Merge pull request #3147 from hey-api/feat/plugin-resolvers-number-2

feat: add number base resolvers

.changeset/curly-geckos-play.md

···
+---
+'@hey-api/codegen-core': patch
+---
+
+**types**: document default values for `importKind` and `kind`

.changeset/fruity-camels-type.md

···
+---
+'@hey-api/openapi-ts': minor
+---
+
+**plugin(valibot)**: **BREAKING:** standardize `~resolvers` API
+
+The [Resolvers API](https://heyapi.dev/openapi-ts/plugins/concepts/resolvers) has been simplified and expanded to provide a more consistent behavior across plugins. You can view a few common examples on the [Resolvers](https://heyapi.dev/openapi-ts/plugins/concepts/resolvers) page.

.changeset/upset-weeks-dream.md

···
+---
+'@hey-api/openapi-ts': minor
+---
+
+**plugin(zod)**: **BREAKING:** standardize `~resolvers` API
+
+The [Resolvers API](https://heyapi.dev/openapi-ts/plugins/concepts/resolvers) has been simplified and expanded to provide a more consistent behavior across plugins. You can view a few common examples on the [Resolvers](https://heyapi.dev/openapi-ts/plugins/concepts/resolvers) page.

dev/openapi-ts.config.ts

···
             },
           },
           '~resolvers': {
-            object: {
-              // base({ $, additional, pipes, shape }) {
-              //   if (additional === undefined) {
-              //     return pipes.push($('v').attr('looseObject').call(shape));
-              //   }
-              //   return;
-              // },
-            },
-            string: {
-              formats: {
-                // date: ({ $, pipes }) => pipes.push($('v').attr('isoDateTime').call()),
-                // 'date-time': ({ $, pipes }) => pipes.push($('v').attr('isoDateTime').call()),
-              },
+            // number(ctx) {
+            //   const { $, plugin, symbols } = ctx;
+            //   const { v } = symbols;
+            //   // ctx.nodes.base = () => {
+            //   //   // implement custom base number resolver
+            //   // }
+            //   const big = plugin.symbolOnce('Big', {
+            //     external: 'big.js',
+            //     importKind: 'default',
+            //   });
+            //   return $(v).attr('instance').call(big);
+            // },
+            object(ctx) {
+              const { $, symbols } = ctx;
+              const { v } = symbols;
+              const additional = ctx.nodes.additionalProperties(ctx);
+              if (additional === undefined) {
+                const shape = ctx.nodes.shape(ctx);
+                ctx.nodes.base = () => $(v).attr('looseObject').call(shape);
+              }
             },
-            // validator({ $, plugin, schema, v }) {
+            // string(ctx) {
+            //   const { $, schema, symbols } = ctx;
+            //   const { v } = symbols;
+            //   if (schema.format === 'date' || schema.format === 'date-time') {
+            //     ctx.nodes.format = () => $(v).attr('isoDateTime').call();
+            //   }
+            // },
+            // validator(ctx) {
+            //   const { $, plugin, symbols } = ctx;
+            //   const { schema, v } = symbols;
             //   const vShadow = plugin.symbol('v');
             //   const test = plugin.symbol('test');
             //   const e = plugin.symbol('err');
···
         {
           // case: 'snake_case',
           // comments: false,
-          compatibilityVersion: 3,
+          compatibilityVersion: 'mini',
           dates: {
             // local: true,
             // offset: true,
···
             },
           },
           '~resolvers': {
-            object: {
-              // base({ $, additional, shape }) {
-              //   if (!additional) {
-              //     // return $('z').attr('object').call(shape).attr('passthrough').call()
-              //     return $('z').attr('object').call(shape).attr('strict').call();
-              //   }
-              //   return;
-              // },
-            },
-            string: {
-              formats: {
-                // date: ({ $ }) => $('z').attr('date').call(),
-                // 'date-time': ({ $ }) => $('z').attr('date').call(),
-                // int64: ({ $ }) => $('z').attr('string').call().attr('refine').call(
-                //   $.func().param('val').do(
-                //     $.try(
-                //       $('z').attr('int64').call().attr('parse').call($('BigInt').call('val')),
-                //       $.return($.literal(true))
-                //     ).catch(
-                //       $.return($.literal(false))
-                //     ),
-                //   ),
-                //   $.object().prop('message', $.literal('Must be a valid int64 string'))
-                // ),
-              },
-            },
+            // number(ctx) {
+            //   const { $, plugin, symbols } = ctx;
+            //   const { z } = symbols;
+            //   // ctx.nodes.base = () => {
+            //   //   // implement custom base number resolver
+            //   // }
+            //   const big = plugin.symbolOnce('Big', {
+            //     external: 'big.js',
+            //     importKind: 'default',
+            //   });
+            //   return $(z).attr('instanceof').call(big);
+            // },
+            // object(ctx) {
+            //   const { $, symbols } = ctx;
+            //   const { z } = symbols;
+            //   const additional = ctx.nodes.additionalProperties(ctx);
+            //   if (additional === undefined) {
+            //     const shape = ctx.nodes.shape(ctx);
+            //     // return $('z').attr('object').call(shape).attr('passthrough').call()
+            //     ctx.nodes.base = () =>
+            //       $(z).attr('object').call(shape).attr('strict').call();
+            //   }
+            // },
+            // string(ctx) {
+            //   const { $, schema, symbols } = ctx;
+            //   const { z } = symbols;
+            //   if (schema.format === 'date' || schema.format === 'date-time') {
+            //     ctx.nodes.format = () => $(z).attr('date').call();
+            //   }
+            //   if (schema.format === 'int64') {
+            //     ctx.nodes.format = () =>
+            //       $(z)
+            //         .attr('string')
+            //         .call()
+            //         .attr('refine')
+            //         .call(
+            //           $.func()
+            //             .param('val')
+            //             .do(
+            //               $.try(
+            //                 $(z)
+            //                   .attr('int64')
+            //                   .call()
+            //                   .attr('parse')
+            //                   .call($('BigInt').call('val')),
+            //                 $.return($.literal(true)),
+            //               ).catch($.return($.literal(false))),
+            //             ),
+            //           $.object().prop(
+            //             'message',
+            //             $.literal('Must be a valid int64 string'),
+            //           ),
+            //         );
+            //   }
+            // },
             // validator({ $, schema }) {
             //   return [
             //     $.const('parsed').assign(

docs/.vitepress/config/en.ts

···
             collapsed: true,
             items: [
               {
+                link: '/openapi-ts/plugins/concepts/resolvers',
+                text: 'Resolvers',
+              },
+            ],
+            text: 'Concepts',
+          },
+          {
+            collapsed: true,
+            items: [
+              {
                 link: '/openapi-ts/plugins/custom',
                 text: 'Plugin',
               },

docs/openapi-ts/clients.md

···
 ---
 title: Clients
-description: REST clients for Hey API. Compatible with all our features.
+description: HTTP clients for Hey API. Compatible with all our features.
 ---
 
 <script setup lang="ts">
 import { embedProject } from '../embed'
 </script>
 
-# REST Clients
+# HTTP Clients
 
 We all send HTTP requests in a slightly different way. Hey API doesn't force you to use any specific technology. What we do, however, is support your choice with great clients. All seamlessly integrated with our other features.
 

docs/openapi-ts/migrating.md

···
 
 While we try to avoid breaking changes, sometimes it's unavoidable in order to offer you the latest features. This page lists changes that require updates to your code. If you run into a problem with migration, please [open an issue](https://github.com/hey-api/openapi-ts/issues).
 
+## v0.90.0
+
+### Resolvers API
+
+The [Resolvers API](/openapi-ts/plugins/concepts/resolvers) has been simplified and expanded to provide a more consistent behavior across plugins. You can view a few common examples on the [Resolvers](/openapi-ts/plugins/concepts/resolvers) page.
+
 ## v0.89.0
 
 ### Prefer named exports

docs/openapi-ts/plugins/concepts/resolvers.md

···
+---
+title: Resolvers
+description: Understand the concepts behind plugins.
+---
+
+# Resolvers
+
+Sometimes the default plugin behavior isn't what you need or expect. Resolvers let you patch plugins in a safe and performant way, without forking or reimplementing core logic.
+
+Currently available for [Valibot](/openapi-ts/plugins/valibot) and [Zod](/openapi-ts/plugins/zod).
+
+## Examples
+
+This page demonstrates resolvers through a few common scenarios.
+
+1. [Handle arbitrary schema formats](#example-1)
+2. [Validate high precision numbers](#example-2)
+3. [Replace default base](#example-3)
+
+## Terminology
+
+Before we look at examples, let's go through the resolvers API to help you understand how they work. Plugins that support resolvers expose them through the `~resolvers` option. Each resolver is a function that receives context and returns an implemented node (or patches existing ones).
+
+The resolver context will usually contain:
+
+- `$` - The node builder interface. Use it to build your custom logic.
+- `nodes` - Parts of the plugin logic. You can use these to avoid reimplementing the functionality, or replace them with custom implementation.
+- `plugin` - The plugin instance. You'll most likely use it to register new symbols.
+- `symbols` - Frequently used symbols. These are effectively shorthands for commonly used `plugin.referenceSymbol()` calls.
+
+Other fields may include the current schema or relevant utilities.
+
+## Example 1
+
+### Handle arbitrary schema formats
+
+By default, the Valibot plugin may produce the following schemas for `date` and `date-time` strings.
+
+```js
+export const vDates = v.object({
+  created: v.pipe(v.string(), v.isoDate()),
+  modified: v.pipe(v.string(), v.isoTimestamp()),
+});
+```
+
+We can override this behavior by patching the `nodes.format` function only for strings with `date` or `date-time` formats.
+
+```js
+{
+  name: 'valibot',
+  '~resolvers': {
+    string(ctx) {
+      const { $, schema, symbols } = ctx;
+      const { v } = symbols;
+      if (schema.format === 'date' || schema.format === 'date-time') {
+        ctx.nodes.format = () => $(v).attr('isoDateTime').call();
+      }
+    }
+  }
+}
+```
+
+This applies custom logic with surgical precision, without affecting the rest of the default behavior.
+
+::: code-group
+
+```js [after]
+export const vDates = v.object({
+  created: v.pipe(v.string(), v.isoDateTime()),
+  modified: v.pipe(v.string(), v.isoDateTime()),
+});
+```
+
+```js [before]
+export const vDates = v.object({
+  created: v.pipe(v.string(), v.isoDate()),
+  modified: v.pipe(v.string(), v.isoTimestamp()),
+});
+```
+
+:::
+
+## Example 2
+
+### Validate high precision numbers
+
+Let's say you're dealing with very large or unsafe numbers.
+
+```js
+export const vAmount = v.number();
+```
+
+In this case, you'll want to use a third-party library to validate your values. We can use big.js to validate all numbers by replacing the whole resolver.
+
+```js
+{
+  name: 'valibot',
+  '~resolvers': {
+    number(ctx) {
+      const { $, plugin, symbols } = ctx;
+      const { v } = symbols;
+      const big = plugin.symbolOnce('Big', {
+        external: 'big.js',
+        importKind: 'default',
+      });
+      return $(v).attr('instance').call(big);
+    }
+  }
+}
+```
+
+We're calling `plugin.symbolOnce()` to ensure we always use the same symbol reference.
+
+::: code-group
+
+```js [after]
+import Big from 'big.js';
+
+export const vAmount = v.instance(Big);
+```
+
+```js [before]
+export const vAmount = v.number();
+```
+
+:::
+
+## Example 3
+
+### Replace default base
+
+You might want to replace the default base schema, e.g. `v.object()`.
+
+```js
+export const vUser = v.object({
+  age: v.number(),
+});
+```
+
+Let's say we want to interpret any schema without explicitly defined additional properties as a loose object.
+
+```js
+{
+  name: 'valibot',
+  '~resolvers': {
+    object(ctx) {
+      const { $, symbols } = ctx;
+      const { v } = symbols;
+      const additional = ctx.nodes.additionalProperties(ctx);
+      if (additional === undefined) {
+        const shape = ctx.nodes.shape(ctx);
+        ctx.nodes.base = () => $(v).attr('looseObject').call(shape);
+      }
+    }
+  }
+}
+```
+
+Above we demonstrate patching a node based on the result of another node.
+
+::: code-group
+
+```js [after]
+export const vUser = v.looseObject({
+  age: v.number(),
+});
+```
+
+```js [before]
+export const vUser = v.object({
+  age: v.number(),
+});
+```
+
+:::
+
+## Feedback
+
+We welcome feedback on the Resolvers API. [Open a GitHub issue](https://github.com/hey-api/openapi-ts/issues) to request support for additional plugins.
+
+<!--@include: ../../../partials/sponsors.md-->

docs/openapi-ts/plugins/valibot.md

···
 
 :::
 
+## Resolvers
+
+You can further customize this plugin's behavior using [resolvers](/openapi-ts/plugins/concepts/resolvers).
+
 ## API
 
 You can view the complete list of options in the [UserConfig](https://github.com/hey-api/openapi-ts/blob/main/packages/openapi-ts/src/plugins/valibot/types.d.ts) interface.

docs/openapi-ts/plugins/zod.md

···
 
 You can customize the naming and casing pattern for schema-specific `types` using the `.name` and `.case` options.
 
+## Resolvers
+
+You can further customize this plugin's behavior using [resolvers](/openapi-ts/plugins/concepts/resolvers).
+
 ## API
 
 You can view the complete list of options in the [UserConfig](https://github.com/hey-api/openapi-ts/blob/main/packages/openapi-ts/src/plugins/zod/types.d.ts) interface.

docs/openapi-ts/plugins/zod/mini.md

···
 
 You can customize the naming and casing pattern for schema-specific `types` using the `.name` and `.case` options.
 
+## Resolvers
+
+You can further customize this plugin's behavior using [resolvers](/openapi-ts/plugins/concepts/resolvers).
+
 ## API
 
 You can view the complete list of options in the [UserConfig](https://github.com/hey-api/openapi-ts/blob/main/packages/openapi-ts/src/plugins/zod/types.d.ts) interface.

docs/openapi-ts/plugins/zod/v3.md

···
 
 You can customize the naming and casing pattern for schema-specific `types` using the `.name` and `.case` options.
 
+## Resolvers
+
+You can further customize this plugin's behavior using [resolvers](/openapi-ts/plugins/concepts/resolvers).
+
 ## API
 
 You can view the complete list of options in the [UserConfig](https://github.com/hey-api/openapi-ts/blob/main/packages/openapi-ts/src/plugins/zod/types.d.ts) interface.

packages/codegen-core/src/symbols/types.d.ts

···
   getFilePath?: Symbol['getFilePath'];
   /**
    * Kind of import if this symbol represents an import.
+   *
+   * @default 'named'
    */
   importKind?: BindingKind;
   /**
    * Kind of symbol.
+   *
+   * @default 'var'
    */
   kind?: SymbolKind;
   /**

packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/valibot/default/valibot.gen.ts

···
 });
 
 export const vPageable = v.object({
-    page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(0)), 0),
-    size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(1))),
+    page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647')), 0),
+    size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'))),
     sort: v.optional(v.array(v.string()))
 });
 
···
         }), v.strictObject({
             bar: vNonAsciiStringæøåÆøÅöôêÊ字符串
         })]), v.object({
-        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]),
-        qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0))
+        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]),
+        qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'))
     })]);
 
 export const vModelWithOneOfAndProperties = v.intersect([v.union([vSimpleParameter, vNonAsciiStringæøåÆøÅöôêÊ字符串]), v.object({
-        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]),
-        qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0))
+        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]),
+        qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'))
     })]);
 
 /**

packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/valibot/default/valibot.gen.ts

···
 });
 
 export const vPageable = v.object({
-    page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(0)), 0),
-    size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(1))),
+    page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647')), 0),
+    size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'))),
     sort: v.optional(v.array(v.string()))
 });
 
···
         }), v.strictObject({
             bar: vNonAsciiStringæøåÆøÅöôêÊ字符串
         })]), v.object({
-        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]),
-        qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0))
+        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]),
+        qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'))
     })]);
 
 export const vModelWithOneOfAndProperties = v.intersect([v.union([vSimpleParameter, vNonAsciiStringæøåÆøÅöôêÊ字符串]), v.object({
-        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]),
-        qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0))
+        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]),
+        qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'))
     })]);
 
 /**

packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/validators-bigint-min-max/valibot.gen.ts

···
         v.number(),
         v.string(),
         v.bigint()
-    ]), v.transform(x => BigInt(x)), v.minValue(BigInt('-9223372036854775808'), 'Invalid value: Expected int64 to be >= -9223372036854775808'), v.maxValue(BigInt('9223372036854775807'), 'Invalid value: Expected int64 to be <= 9223372036854775807'), v.minValue(BigInt(0)), v.maxValue(BigInt(100))))
+    ]), v.transform(x => BigInt(x)), v.minValue(BigInt(0)), v.maxValue(BigInt(100))))
 });

packages/openapi-ts-tests/zod/v3/__snapshots__/3.0.x/mini/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0),
-    size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))),
+    page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0),
+    size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.0.x/v3/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0),
-    size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(),
+    page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0),
+    size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
     sort: z.array(z.string()).optional()
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.0.x/v4/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0),
-    size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)),
+    page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0),
+    size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/mini/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0),
-    size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))),
+    page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0),
+    size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/mini/validators-bigint-min-max/zod.gen.ts

···
 import * as z from 'zod/v4-mini';
 
 export const zFoo = z.object({
-    foo: z.optional(z.coerce.bigint().check(z.minimum(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }), z.maximum(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }), z.gte(BigInt(0)), z.lte(BigInt(100))))
+    foo: z.optional(z.coerce.bigint().check(z.gte(BigInt(0)), z.lte(BigInt(100))))
 });

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v3/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0),
-    size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(),
+    page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0),
+    size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
     sort: z.array(z.string()).optional()
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v3/validators-bigint-min-max/zod.gen.ts

···
 import { z } from 'zod';
 
 export const zFoo = z.object({
-    foo: z.coerce.bigint().min(BigInt('-9223372036854775808'), { message: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { message: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100)).optional()
+    foo: z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100)).optional()
 });

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v4/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0),
-    size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)),
+    page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0),
+    size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v4/validators-bigint-min-max/zod.gen.ts

···
 import { z } from 'zod/v4';
 
 export const zFoo = z.object({
-    foo: z.optional(z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100)))
+    foo: z.optional(z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100)))
 });

packages/openapi-ts-tests/zod/v4/__snapshots__/3.0.x/mini/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0),
-    size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))),
+    page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0),
+    size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.0.x/v3/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0),
-    size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(),
+    page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0),
+    size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
     sort: z.array(z.string()).optional()
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.0.x/v4/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0),
-    size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)),
+    page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0),
+    size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/mini/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0),
-    size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))),
+    page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0),
+    size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/mini/validators-bigint-min-max/zod.gen.ts

···
 import * as z from 'zod/mini';
 
 export const zFoo = z.object({
-    foo: z.optional(z.coerce.bigint().check(z.minimum(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }), z.maximum(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }), z.gte(BigInt(0)), z.lte(BigInt(100))))
+    foo: z.optional(z.coerce.bigint().check(z.gte(BigInt(0)), z.lte(BigInt(100))))
 });

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v3/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0),
-    size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(),
+    page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0),
+    size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
     sort: z.array(z.string()).optional()
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v3/validators-bigint-min-max/zod.gen.ts

···
 import { z } from 'zod/v3';
 
 export const zFoo = z.object({
-    foo: z.coerce.bigint().min(BigInt('-9223372036854775808'), { message: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { message: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100)).optional()
+    foo: z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100)).optional()
 });

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v4/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0),
-    size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)),
+    page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0),
+    size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v4/validators-bigint-min-max/zod.gen.ts

···
 import { z } from 'zod';
 
 export const zFoo = z.object({
-    foo: z.optional(z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100)))
+    foo: z.optional(z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100)))
 });

packages/openapi-ts/src/plugins/arktype/v2/toAst/object.ts

···
       result.hasLazyExpression = true;
     }
 
-    // Return with typeName for circular references
-    if (result.hasLazyExpression) {
-      return {
-        ...result,
-        typeName: 'TODO',
-      } as Ast;
-    }
-
     return result as Omit<Ast, 'typeName'>;
   }
 

packages/openapi-ts/src/plugins/shared/utils/coerce.ts

···
 import { $ } from '~/ts-dsl';
 
-export const shouldCoerceToBigInt = (format: string | undefined): boolean =>
+export type MaybeBigInt = (
+  value: unknown,
+  format: string | undefined,
+) => ReturnType<typeof $.fromValue>;
+export type ShouldCoerceToBigInt = (format: string | undefined) => boolean;
+
+export const shouldCoerceToBigInt: ShouldCoerceToBigInt = (format) =>
   format === 'int64' || format === 'uint64';
 
-export const maybeBigInt = (
-  value: unknown,
-  format: string | undefined,
-): ReturnType<typeof $.fromValue> => {
+export const maybeBigInt: MaybeBigInt = (value, format) => {
   if (!shouldCoerceToBigInt(format)) {
     return $.fromValue(value);
   }

packages/openapi-ts/src/plugins/shared/utils/formats.ts

···
   minValue: Range;
 }
 
+export type GetIntegerLimit = (
+  format: string | undefined,
+) => IntegerLimit | undefined;
+
 const rangeErrors = (format: string, range: [Range, Range]) => ({
   maxError: `Invalid value: Expected ${format} to be <= ${range[1]}`,
   minError: `Invalid value: Expected ${format} to be >= ${range[0]}`,
···
   uint8: [0, 255],
 };
 
-export function getIntegerLimit(
-  format: string | undefined,
-): IntegerLimit | undefined {
+export const getIntegerLimit: GetIntegerLimit = (format) => {
   if (!format) return;
   const range = integerRange[format];
   if (!range) return;
   const errors = rangeErrors(format, range);
   return { maxValue: range[1], minValue: range[0], ...errors };
-}
+};

packages/openapi-ts/src/plugins/shared/utils/instance.ts

···
     this.package = props.context.package;
   }
 
+  external(
+    resource: Required<SymbolMeta>['resource'],
+    meta?: Omit<SymbolMeta, 'category' | 'resource'>,
+  ): Symbol {
+    return this.gen.symbols.reference({
+      ...meta,
+      category: 'external',
+      resource,
+    });
+  }
+
   /**
    * Iterates over various input elements as specified by the event types, in
    * a specific order: servers, schemas, parameters, request bodies, then
···
       hook({ plugin: this, symbol: symbolOut });
     }
     return symbolOut;
+  }
+
+  /**
+   * Registers a symbol only if it does not already exist based on the provided
+   * metadata. This prevents duplicate symbols from being created in the project.
+   */
+  symbolOnce(name: SymbolIn['name'], symbol?: Omit<SymbolIn, 'name'>): Symbol {
+    const meta = {
+      ...symbol?.meta,
+    };
+    if (symbol?.external) {
+      meta.category = 'external';
+      meta.resource = symbol.external;
+    }
+    const existing = this.querySymbol(meta);
+    if (existing) return existing;
+    return this.symbol(name, { ...symbol, meta });
   }
 
   private buildEventHooks(): EventHooks {

packages/openapi-ts/src/plugins/valibot/shared/export.ts

···
 import { $ } from '~/ts-dsl';
 
 import { identifiers } from '../v1/constants';
-import { pipesToAst } from './pipesToAst';
+import { pipesToNode } from './pipes';
 import type { Ast, IrSchemaToAstOptions } from './types';
 
 export const exportAst = ({
···
     .$if(state.hasLazyExpression['~ref'], (c) =>
       c.type($.type(v).attr(ast.typeName || identifiers.types.GenericSchema)),
     )
-    .assign(pipesToAst(ast.pipes, plugin));
+    .assign(pipesToNode(ast.pipes, plugin));
   plugin.node(statement);
 };

packages/openapi-ts/src/plugins/valibot/shared/pipes.ts

···
+import { $ } from '~/ts-dsl';
+
+import type { ValibotPlugin } from '../types';
+import { identifiers } from '../v1/constants';
+
+export type Pipe = ReturnType<typeof $.call | typeof $.expr>;
+export type Pipes = Array<Pipe>;
+export type PipeResult = Pipes | Pipe;
+
+type PushPipes = (target: Pipes, pipes: PipeResult) => Pipes;
+type PipesToNode = (
+  pipes: PipeResult,
+  plugin: ValibotPlugin['Instance'],
+) => Pipe;
+
+export const pipesToNode: PipesToNode = (pipes, plugin) => {
+  if (!(pipes instanceof Array)) return pipes;
+  if (pipes.length === 1) return pipes[0]!;
+
+  const v = plugin.external('valibot.v');
+  return $(v)
+    .attr(identifiers.methods.pipe)
+    .call(...pipes);
+};
+
+export const pushPipes: PushPipes = (target, pipes) => {
+  if (pipes instanceof Array) {
+    target.push(...pipes);
+  } else {
+    target.push(pipes);
+  }
+  return target;
+};
+
+export interface PipesUtils {
+  /**
+   * Push pipes into target array.
+   */
+  push: PushPipes;
+  /**
+   * Convert pipes to a single node.
+   */
+  toNode: PipesToNode;
+}
+
+/**
+ * Functions for working with pipes.
+ */
+export const pipes: PipesUtils = {
+  push: pushPipes,
+  toNode: pipesToNode,
+};

packages/openapi-ts/src/plugins/valibot/shared/pipesToAst.ts

···
-import { $ } from '~/ts-dsl';
-
-import type { ValibotPlugin } from '../types';
-import { identifiers } from '../v1/constants';
-
-export const pipesToAst = (
-  pipes: ReadonlyArray<ReturnType<typeof $.call | typeof $.expr>>,
-  plugin: ValibotPlugin['Instance'],
-): ReturnType<typeof $.call | typeof $.expr> => {
-  if (pipes.length === 1) {
-    return pipes[0]!;
-  }
-
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
-  return $(v)
-    .attr(identifiers.methods.pipe)
-    .call(...pipes);
-};

packages/openapi-ts/src/plugins/valibot/shared/types.d.ts

···
 import type ts from 'typescript';
 
 import type { IR } from '~/ir/types';
-import type { $ } from '~/ts-dsl';
 
 import type { ValibotPlugin } from '../types';
+import type { Pipes } from './pipes';
 
 export type Ast = {
   hasLazyExpression?: boolean;
-  pipes: Array<ReturnType<typeof $.call | typeof $.expr>>;
+  pipes: Pipes;
   typeName?: string | ts.Identifier;
 };
 

packages/openapi-ts/src/plugins/valibot/types.d.ts

···
-import type { Symbol } from '@hey-api/codegen-core';
-import type ts from 'typescript';
+import type { Refs, Symbol } from '@hey-api/codegen-core';
 
 import type { IR } from '~/ir/types';
-import type { DefinePlugin, Plugin } from '~/plugins';
-import type { $, DollarTsDsl, TsDsl } from '~/ts-dsl';
+import type { DefinePlugin, Plugin, SchemaWithType } from '~/plugins';
+import type {
+  MaybeBigInt,
+  ShouldCoerceToBigInt,
+} from '~/plugins/shared/utils/coerce';
+import type { GetIntegerLimit } from '~/plugins/shared/utils/formats';
+import type { $, DollarTsDsl } from '~/ts-dsl';
 import type { StringCase, StringName } from '~/types/case';
-import type { MaybeArray } from '~/types/utils';
 
 import type { IApi } from './api';
+import type { Pipe, PipeResult, PipesUtils } from './shared/pipes';
+import type { Ast, PluginState } from './shared/types';
 
 export type UserConfig = Plugin.Name<'valibot'> &
   Plugin.Hooks &
···
     };
   };
 
-type SharedResolverArgs = DollarTsDsl & {
+interface BaseResolverContext extends DollarTsDsl {
   /**
-   * The current builder state being processed by this resolver.
-   *
-   * In Valibot, this represents the current list of call expressions ("pipes")
-   * being assembled to form a schema definition.
-   *
-   * Each pipe can be extended, modified, or replaced to customize how the
-   * resulting schema is constructed. Returning `undefined` from a resolver will
-   * use the default generation behavior.
+   * Functions for working with pipes.
    */
-  pipes: Array<ReturnType<typeof $.call>>;
+  pipes: PipesUtils & {
+    /**
+     * The current pipe.
+     *
+     * In Valibot, this represents a list of call expressions ("pipes")
+     * being assembled to form a schema definition.
+     *
+     * Each pipe can be extended, modified, or replaced to customize
+     * the resulting schema.
+     */
+    current: Pipes;
+  };
+  /**
+   * The plugin instance.
+   */
   plugin: ValibotPlugin['Instance'];
-};
+  /**
+   * Provides access to commonly used symbols within the plugin.
+   */
+  symbols: {
+    v: Symbol;
+  };
+}
 
-export type FormatResolverArgs = SharedResolverArgs & {
-  schema: IR.SchemaObject;
-};
+export interface NumberResolverContext extends BaseResolverContext {
+  /**
+   * Nodes used to build different parts of the number schema.
+   */
+  nodes: {
+    base: (ctx: NumberResolverContext) => PipeResult;
+    const: (ctx: NumberResolverContext) => PipeResult | undefined;
+    max: (ctx: NumberResolverContext) => PipeResult | undefined;
+    min: (ctx: NumberResolverContext) => PipeResult | undefined;
+  };
+  schema: SchemaWithType<'integer' | 'number'>;
+  /**
+   * Utility functions for number schema processing.
+   */
+  utils: {
+    getIntegerLimit: GetIntegerLimit;
+    maybeBigInt: MaybeBigInt;
+    shouldCoerceToBigInt: ShouldCoerceToBigInt;
+  };
+}
 
-export type ObjectBaseResolverArgs = SharedResolverArgs & {
-  /** Null = never */
-  additional?: ReturnType<typeof $.call | typeof $.expr> | null;
-  schema: IR.SchemaObject;
-  shape: ReturnType<typeof $.object>;
-};
+export interface ObjectResolverContext extends BaseResolverContext {
+  /**
+   * Nodes used to build different parts of the object schema.
+   */
+  nodes: {
+    /**
+     * If `additionalProperties` is `false` or `{ type: 'never' }`, returns `null`
+     * to indicate no additional properties are allowed.
+     */
+    additionalProperties: (
+      ctx: ObjectResolverContext,
+    ) => Pipe | null | undefined;
+    base: (ctx: ObjectResolverContext) => PipeResult;
+    shape: (ctx: ObjectResolverContext) => ReturnType<typeof $.object>;
+  };
+  schema: SchemaWithType<'object'>;
+  /**
+   * Utility functions for object schema processing.
+   */
+  utils: {
+    ast: Partial<Omit<Ast, 'typeName'>>;
+    state: Refs<PluginState>;
+  };
+}
 
-export type ValidatorResolverArgs = SharedResolverArgs & {
+export interface StringResolverContext extends BaseResolverContext {
+  /**
+   * Nodes used to build different parts of the string schema.
+   */
+  nodes: {
+    base: (ctx: StringResolverContext) => PipeResult;
+    const: (ctx: StringResolverContext) => PipeResult | undefined;
+    format: (ctx: StringResolverContext) => PipeResult | undefined;
+    length: (ctx: StringResolverContext) => PipeResult | undefined;
+    maxLength: (ctx: StringResolverContext) => PipeResult | undefined;
+    minLength: (ctx: StringResolverContext) => PipeResult | undefined;
+    pattern: (ctx: StringResolverContext) => PipeResult | undefined;
+  };
+  schema: SchemaWithType<'string'>;
+}
+
+export interface ValidatorResolverContext extends BaseResolverContext {
   operation: IR.Operation;
-  schema: Symbol;
-  v: Symbol;
-};
+  /**
+   * Provides access to commonly used symbols within the plugin.
+   */
+  symbols: BaseResolverContext['symbols'] & {
+    schema: Symbol;
+  };
+}
 
 type ValidatorResolver = (
-  args: ValidatorResolverArgs,
-) => MaybeArray<TsDsl<ts.Statement>> | null | undefined;
+  ctx: ValidatorResolverContext,
+) => PipeResult | null | undefined;
 
 type Resolvers = Plugin.Resolvers<{
   /**
-   * Resolvers for number schemas.
+   * Resolver for number schemas.
    *
-   * Allows customization of how number types are rendered, including
-   * per-format handling.
+   * Allows customization of how number types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
    */
-  number?: {
-    /**
-     * Resolvers for number formats (e.g., `float`, `double`, `int32`).
-     *
-     * Each key represents a specific format name with a custom
-     * resolver function that controls how that format is rendered.
-     *
-     * Example path: `~resolvers.number.formats.float`
-     *
-     * Returning `undefined` from a resolver will apply the default
-     * generation behavior for that format.
-     */
-    formats?: Record<
-      string,
-      (args: FormatResolverArgs) => boolean | number | undefined
-    >;
-  };
+  number?: (ctx: NumberResolverContext) => PipeResult | undefined;
   /**
-   * Resolvers for object schemas.
+   * Resolver for object schemas.
    *
    * Allows customization of how object types are rendered.
    *
-   * Example path: `~resolvers.object.base`
-   *
-   * Returning `undefined` from a resolver will apply the default
-   * generation behavior for the object schema.
+   * Returning `undefined` will execute the default resolver logic.
    */
-  object?: {
-    /**
-     * Controls how object schemas are constructed.
-     *
-     * Called with the fully assembled shape (properties) and any additional
-     * property schema, allowing the resolver to choose the correct Valibot
-     * base constructor and modify the schema chain if needed.
-     *
-     * Returning `undefined` will execute the default resolver logic.
-     */
-    base?: (
-      args: ObjectBaseResolverArgs,
-    ) => ReturnType<typeof $.call> | undefined;
-  };
+  object?: (ctx: ObjectResolverContext) => PipeResult | undefined;
   /**
-   * Resolvers for string schemas.
+   * Resolver for string schemas.
    *
-   * Allows customization of how string types are rendered, including
-   * per-format handling.
+   * Allows customization of how string types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
    */
-  string?: {
-    /**
-     * Resolvers for string formats (e.g., `uuid`, `email`, `date-time`).
-     *
-     * Each key represents a specific format name with a custom
-     * resolver function that controls how that format is rendered.
-     *
-     * Example path: `~resolvers.string.formats.uuid`
-     *
-     * Returning `undefined` from a resolver will apply the default
-     * generation behavior for that format.
-     */
-    formats?: Record<
-      string,
-      (args: FormatResolverArgs) => boolean | number | undefined
-    >;
-  };
+  string?: (ctx: StringResolverContext) => PipeResult | undefined;
   /**
    * Resolvers for request and response validators.
    *
···
    *
    * Example path: `~resolvers.validator.request` or `~resolvers.validator.response`
    *
-   * Returning `undefined` from a resolver will apply the default generation logic.
+   * Returning `undefined` will execute the default resolver logic.
    */
   validator?:
     | ValidatorResolver
···
         /**
          * Controls how the request validator function body is generated.
          *
-         * Returning `undefined` will fall back to the default `.await().return()` logic.
+         * Returning `undefined` will execute the default resolver logic.
          */
         request?: ValidatorResolver;
         /**
          * Controls how the response validator function body is generated.
          *
-         * Returning `undefined` will fall back to the default `.await().return()` logic.
+         * Returning `undefined` will execute the default resolver logic.
          */
         response?: ValidatorResolver;
       };

packages/openapi-ts/src/plugins/valibot/v1/api.ts

···
 import { $ } from '~/ts-dsl';
 
+import { pipes } from '../shared/pipes';
 import type { ValidatorArgs } from '../shared/types';
-import type { ValidatorResolverArgs } from '../types';
+import type { ValidatorResolverContext } from '../types';
 import { identifiers } from './constants';
 
-const defaultValidatorResolver = ({
-  schema,
-  v,
-}: ValidatorResolverArgs): ReturnType<typeof $.return> =>
-  $(v).attr(identifiers.async.parseAsync).call(schema, 'data').await().return();
+const validatorResolver = (
+  ctx: ValidatorResolverContext,
+): ReturnType<typeof $.return> => {
+  const { schema, v } = ctx.symbols;
+  return $(v)
+    .attr(identifiers.async.parseAsync)
+    .call(schema, 'data')
+    .await()
+    .return();
+};
 
 export const createRequestValidatorV1 = ({
   operation,
···
   });
   if (!symbol) return;
 
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
-  const args: ValidatorResolverArgs = {
+  const ctx: ValidatorResolverContext = {
     $,
     operation,
-    pipes: [],
+    pipes: {
+      ...pipes,
+      current: [],
+    },
     plugin,
-    schema: symbol,
-    v,
+    symbols: {
+      schema: symbol,
+      v: plugin.external('valibot.v'),
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.request;
-  const candidates = [resolver, defaultValidatorResolver];
+  const candidates = [resolver, validatorResolver];
   for (const candidate of candidates) {
-    const statements = candidate?.(args);
+    const statements = candidate?.(ctx);
     if (statements === null) return;
     if (statements !== undefined) {
       return $.func()
···
   });
   if (!symbol) return;
 
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
-  const args: ValidatorResolverArgs = {
+  const ctx: ValidatorResolverContext = {
     $,
     operation,
-    pipes: [],
+    pipes: {
+      ...pipes,
+      current: [],
+    },
     plugin,
-    schema: symbol,
-    v,
+    symbols: {
+      schema: symbol,
+      v: plugin.external('valibot.v'),
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.response;
-  const candidates = [resolver, defaultValidatorResolver];
+  const candidates = [resolver, validatorResolver];
   for (const candidate of candidates) {
-    const statements = candidate?.(args);
+    const statements = candidate?.(ctx);
     if (statements === null) return;
     if (statements !== undefined) {
       return $.func()

packages/openapi-ts/src/plugins/valibot/v1/plugin.ts

···
 
 import { exportAst } from '../shared/export';
 import { irOperationToAst } from '../shared/operation';
-import { pipesToAst } from '../shared/pipesToAst';
+import { pipesToNode } from '../shared/pipes';
 import type { Ast, IrSchemaToAstOptions, PluginState } from '../shared/types';
 import { irWebhookToAst } from '../shared/webhook';
 import type { ValibotPlugin } from '../types';
···
             path: ref([...fromRef(state.path), 'items', index]),
           },
         });
-        return pipesToAst(itemAst.pipes, plugin);
+        return pipesToNode(itemAst.pipes, plugin);
       });
 
       if (schema.logicalOperator === 'and') {
···
         $(v)
           .attr(identifiers.schemas.optional)
           .call(
-            pipesToAst(ast.pipes, plugin),
+            pipesToNode(ast.pipes, plugin),
             schema.type === 'integer' || schema.type === 'number'
               ? maybeBigInt(schema.default, schema.format)
               : $.fromValue(schema.default),
···
       ast.pipes = [
         $(v)
           .attr(identifiers.schemas.optional)
-          .call(pipesToAst(ast.pipes, plugin)),
+          .call(pipesToNode(ast.pipes, plugin)),
       ];
     }
   }

packages/openapi-ts/src/plugins/valibot/v1/toAst/array.ts

···
 import type { SchemaWithType } from '~/plugins';
 import { $ } from '~/ts-dsl';
 
-import { pipesToAst } from '../../shared/pipesToAst';
+import { pipesToNode } from '../../shared/pipes';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
 import { identifiers } from '../constants';
 import { irSchemaToAst } from '../plugin';
···
       if (itemAst.hasLazyExpression) {
         result.hasLazyExpression = true;
       }
-      return pipesToAst(itemAst.pipes, plugin);
+      return pipesToNode(itemAst.pipes, plugin);
     });
 
     if (itemExpressions.length === 1) {

packages/openapi-ts/src/plugins/valibot/v1/toAst/boolean.ts

···
 import type { SchemaWithType } from '~/plugins';
 import { $ } from '~/ts-dsl';
 
-import { pipesToAst } from '../../shared/pipesToAst';
+import { pipesToNode } from '../../shared/pipes';
 import type { IrSchemaToAstOptions } from '../../shared/types';
 import { identifiers } from '../constants';
 
···
     pipes.push(
       $(v).attr(identifiers.schemas.literal).call($.literal(schema.const)),
     );
-    return pipesToAst(pipes, plugin);
+    return pipesToNode(pipes, plugin);
   }
 
   pipes.push($(v).attr(identifiers.schemas.boolean).call());
-  return pipesToAst(pipes, plugin);
+  return pipesToNode(pipes, plugin);
 };

packages/openapi-ts/src/plugins/valibot/v1/toAst/index.ts

···
 import { shouldCoerceToBigInt } from '~/plugins/shared/utils/coerce';
 import type { $ } from '~/ts-dsl';
 
-import { pipesToAst } from '../../shared/pipesToAst';
+import { pipesToNode } from '../../shared/pipes';
 import type { IrSchemaToAstOptions } from '../../shared/types';
 import { arrayToAst } from './array';
 import { booleanToAst } from './boolean';
 import { enumToAst } from './enum';
 import { neverToAst } from './never';
 import { nullToAst } from './null';
-import { numberToAst } from './number';
+import { numberToNode } from './number';
 import { objectToAst } from './object';
-import { stringToAst } from './string';
+import { stringToNode } from './string';
 import { tupleToAst } from './tuple';
 import { undefinedToAst } from './undefined';
 import { unknownToAst } from './unknown';
···
   switch (schema.type) {
     case 'array':
       return {
-        expression: pipesToAst(
+        expression: pipesToNode(
           arrayToAst({
             ...args,
             schema: schema as SchemaWithType<'array'>,
···
     case 'integer':
     case 'number':
       return {
-        expression: numberToAst({
+        expression: numberToNode({
           ...args,
           schema: schema as SchemaWithType<'integer' | 'number'>,
         }),
···
       };
     case 'object':
       return {
-        expression: pipesToAst(
+        expression: pipesToNode(
           objectToAst({
             ...args,
             schema: schema as SchemaWithType<'object'>,
···
     case 'string':
       return {
         expression: shouldCoerceToBigInt(schema.format)
-          ? numberToAst({
+          ? numberToNode({
               ...args,
               schema: { ...schema, type: 'number' },
             })
-          : stringToAst({
+          : stringToNode({
               ...args,
               schema: schema as SchemaWithType<'string'>,
             }),
       };
     case 'tuple':
       return {
-        expression: pipesToAst(
+        expression: pipesToNode(
           tupleToAst({
             ...args,
             schema: schema as SchemaWithType<'tuple'>,

packages/openapi-ts/src/plugins/valibot/v1/toAst/number.ts

···
 import { getIntegerLimit } from '~/plugins/shared/utils/formats';
 import { $ } from '~/ts-dsl';
 
-import { pipesToAst } from '../../shared/pipesToAst';
+import type { Pipe, PipeResult, Pipes } from '../../shared/pipes';
+import { pipes } from '../../shared/pipes';
 import type { IrSchemaToAstOptions } from '../../shared/types';
+import type { NumberResolverContext } from '../../types';
 import { identifiers } from '../constants';
 
-export const numberToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'integer' | 'number'>;
-}) => {
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
-
-  if (schema.const !== undefined) {
-    return $(v)
-      .attr(identifiers.schemas.literal)
-      .call(maybeBigInt(schema.const, schema.format));
-  }
-
-  const pipes: Array<ReturnType<typeof $.call>> = [];
-
-  if (shouldCoerceToBigInt(schema.format)) {
-    pipes.push(
+function baseNode(ctx: NumberResolverContext): PipeResult {
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
+  if (ctx.utils.shouldCoerceToBigInt(schema.format)) {
+    return [
       $(v)
         .attr(identifiers.schemas.union)
         .call(
···
       $(v)
         .attr(identifiers.actions.transform)
         .call($.func().param('x').do($('BigInt').call('x').return())),
-    );
-  } else {
-    pipes.push($(v).attr(identifiers.schemas.number).call());
-    if (schema.type === 'integer') {
-      pipes.push($(v).attr(identifiers.actions.integer).call());
-    }
+    ];
+  }
+  const pipes: Pipes = [];
+  pipes.push($(v).attr(identifiers.schemas.number).call());
+  if (schema.type === 'integer') {
+    pipes.push($(v).attr(identifiers.actions.integer).call());
   }
+  return pipes;
+}
 
-  const integerLimit = getIntegerLimit(schema.format);
-  if (integerLimit) {
-    pipes.push(
-      $(v)
-        .attr(identifiers.actions.minValue)
-        .call(
-          maybeBigInt(integerLimit.minValue, schema.format),
-          $.literal(integerLimit.minError),
-        ),
-      $(v)
-        .attr(identifiers.actions.maxValue)
-        .call(
-          maybeBigInt(integerLimit.maxValue, schema.format),
-          $.literal(integerLimit.maxError),
-        ),
-    );
+function constNode(ctx: NumberResolverContext): PipeResult | undefined {
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
+  if (schema.const === undefined) return;
+  return $(v)
+    .attr(identifiers.schemas.literal)
+    .call(ctx.utils.maybeBigInt(schema.const, schema.format));
+}
+
+function maxNode(ctx: NumberResolverContext): PipeResult | undefined {
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
+  if (schema.exclusiveMaximum !== undefined) {
+    return $(v)
+      .attr(identifiers.actions.ltValue)
+      .call(ctx.utils.maybeBigInt(schema.exclusiveMaximum, schema.format));
   }
+  if (schema.maximum !== undefined) {
+    return $(v)
+      .attr(identifiers.actions.maxValue)
+      .call(ctx.utils.maybeBigInt(schema.maximum, schema.format));
+  }
+  const limit = ctx.utils.getIntegerLimit(schema.format);
+  if (limit) {
+    return $(v)
+      .attr(identifiers.actions.maxValue)
+      .call(
+        ctx.utils.maybeBigInt(limit.maxValue, schema.format),
+        $.literal(limit.maxError),
+      );
+  }
+  return;
+}
 
+function minNode(ctx: NumberResolverContext): PipeResult | undefined {
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
   if (schema.exclusiveMinimum !== undefined) {
-    pipes.push(
-      $(v)
-        .attr(identifiers.actions.gtValue)
-        .call(maybeBigInt(schema.exclusiveMinimum, schema.format)),
-    );
-  } else if (schema.minimum !== undefined) {
-    pipes.push(
-      $(v)
-        .attr(identifiers.actions.minValue)
-        .call(maybeBigInt(schema.minimum, schema.format)),
-    );
+    return $(v)
+      .attr(identifiers.actions.gtValue)
+      .call(ctx.utils.maybeBigInt(schema.exclusiveMinimum, schema.format));
+  }
+  if (schema.minimum !== undefined) {
+    return $(v)
+      .attr(identifiers.actions.minValue)
+      .call(ctx.utils.maybeBigInt(schema.minimum, schema.format));
+  }
+  const limit = ctx.utils.getIntegerLimit(schema.format);
+  if (limit) {
+    return $(v)
+      .attr(identifiers.actions.minValue)
+      .call(
+        ctx.utils.maybeBigInt(limit.minValue, schema.format),
+        $.literal(limit.minError),
+      );
   }
+  return;
+}
+
+function numberResolver(ctx: NumberResolverContext): Pipes {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) return ctx.pipes.push(ctx.pipes.current, constNode);
 
-  if (schema.exclusiveMaximum !== undefined) {
-    pipes.push(
-      $(v)
-        .attr(identifiers.actions.ltValue)
-        .call(maybeBigInt(schema.exclusiveMaximum, schema.format)),
-    );
-  } else if (schema.maximum !== undefined) {
-    pipes.push(
-      $(v)
-        .attr(identifiers.actions.maxValue)
-        .call(maybeBigInt(schema.maximum, schema.format)),
-    );
-  }
+  const baseNode = ctx.nodes.base(ctx);
+  if (baseNode) ctx.pipes.push(ctx.pipes.current, baseNode);
+
+  const minNode = ctx.nodes.min(ctx);
+  if (minNode) ctx.pipes.push(ctx.pipes.current, minNode);
+
+  const maxNode = ctx.nodes.max(ctx);
+  if (maxNode) ctx.pipes.push(ctx.pipes.current, maxNode);
+
+  return ctx.pipes.current;
+}
 
-  return pipesToAst(pipes, plugin);
+export const numberToNode = ({
+  plugin,
+  schema,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'integer' | 'number'>;
+}): Pipe => {
+  const ctx: NumberResolverContext = {
+    $,
+    nodes: {
+      base: baseNode,
+      const: constNode,
+      max: maxNode,
+      min: minNode,
+    },
+    pipes: {
+      ...pipes,
+      current: [],
+    },
+    plugin,
+    schema,
+    symbols: {
+      v: plugin.external('valibot.v'),
+    },
+    utils: {
+      getIntegerLimit,
+      maybeBigInt,
+      shouldCoerceToBigInt,
+    },
+  };
+  const resolver = plugin.config['~resolvers']?.number;
+  const node = resolver?.(ctx) ?? numberResolver(ctx);
+  return ctx.pipes.toNode(node, plugin);
 };

packages/openapi-ts/src/plugins/valibot/v1/toAst/object.ts

···
 import type { SchemaWithType } from '~/plugins';
 import { $ } from '~/ts-dsl';
 
-import { pipesToAst } from '../../shared/pipesToAst';
+import type { Pipe, PipeResult } from '../../shared/pipes';
+import { pipes } from '../../shared/pipes';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
-import type { ObjectBaseResolverArgs } from '../../types';
+import type { ObjectResolverContext } from '../../types';
 import { identifiers } from '../constants';
 import { irSchemaToAst } from '../plugin';
 
-function defaultObjectBaseResolver({
-  additional,
-  pipes,
-  plugin,
-  shape,
-}: ObjectBaseResolverArgs): number {
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
+function additionalPropertiesNode(
+  ctx: ObjectResolverContext,
+): Pipe | null | undefined {
+  const { plugin, schema } = ctx;
+
+  if (!schema.additionalProperties || !schema.additionalProperties.type) return;
+  if (schema.additionalProperties.type === 'never') return null;
+
+  const additionalAst = irSchemaToAst({
+    plugin,
+    schema: schema.additionalProperties,
+    state: {
+      ...ctx.utils.state,
+      path: ref([...fromRef(ctx.utils.state.path), 'additionalProperties']),
+    },
   });
+  if (additionalAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true;
+  return pipes.toNode(additionalAst.pipes, plugin);
+}
 
-  // Handle `additionalProperties: { type: 'never' }` → v.strictObject()
+function baseNode(ctx: ObjectResolverContext): PipeResult {
+  const { nodes, symbols } = ctx;
+  const { v } = symbols;
+
+  const additional = nodes.additionalProperties(ctx);
+  const shape = nodes.shape(ctx);
+
   if (additional === null) {
-    return pipes.push($(v).attr(identifiers.schemas.strictObject).call(shape));
+    return $(v).attr(identifiers.schemas.strictObject).call(shape);
   }
 
-  // Handle additionalProperties as schema → v.record() or v.objectWithRest()
   if (additional) {
     if (shape.isEmpty) {
-      return pipes.push(
-        $(v)
-          .attr(identifiers.schemas.record)
-          .call($(v).attr(identifiers.schemas.string).call(), additional),
-      );
+      return $(v)
+        .attr(identifiers.schemas.record)
+        .call($(v).attr(identifiers.schemas.string).call(), additional);
     }
 
-    // If there are named properties, use v.objectWithRest() to validate both
-    return pipes.push(
-      $(v).attr(identifiers.schemas.objectWithRest).call(shape, additional),
-    );
+    return $(v)
+      .attr(identifiers.schemas.objectWithRest)
+      .call(shape, additional);
   }
 
-  // Default case → v.object()
-  return pipes.push($(v).attr(identifiers.schemas.object).call(shape));
+  return $(v).attr(identifiers.schemas.object).call(shape);
 }
 
-export const objectToAst = ({
-  plugin,
-  schema,
-  state,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'object'>;
-}): Omit<Ast, 'typeName'> => {
-  const result: Partial<Omit<Ast, 'typeName'>> = {};
-  const pipes: Array<ReturnType<typeof $.call>> = [];
-
+function objectResolver(ctx: ObjectResolverContext): PipeResult {
   // TODO: parser - handle constants
+  return ctx.nodes.base(ctx);
+}
 
+function shapeNode(ctx: ObjectResolverContext): ReturnType<typeof $.object> {
+  const { plugin, schema } = ctx;
   const shape = $.object().pretty();
-  const required = schema.required ?? [];
 
   for (const name in schema.properties) {
     const property = schema.properties[name]!;
-    const isRequired = required.includes(name);
 
     const propertyAst = irSchemaToAst({
-      optional: !isRequired,
+      optional: !schema.required?.includes(name),
       plugin,
       schema: property,
       state: {
-        ...state,
-        path: ref([...fromRef(state.path), 'properties', name]),
+        ...ctx.utils.state,
+        path: ref([...fromRef(ctx.utils.state.path), 'properties', name]),
       },
     });
-    if (propertyAst.hasLazyExpression) result.hasLazyExpression = true;
-
-    shape.prop(name, pipesToAst(propertyAst.pipes, plugin));
+    if (propertyAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true;
+    shape.prop(name, pipes.toNode(propertyAst.pipes, plugin));
   }
 
-  let additional: ReturnType<typeof $.call | typeof $.expr> | null | undefined;
-  if (schema.additionalProperties && schema.additionalProperties.type) {
-    if (schema.additionalProperties.type === 'never') {
-      additional = null;
-    } else {
-      const additionalAst = irSchemaToAst({
-        plugin,
-        schema: schema.additionalProperties,
-        state: {
-          ...state,
-          path: ref([...fromRef(state.path), 'additionalProperties']),
-        },
-      });
-      if (additionalAst.hasLazyExpression) result.hasLazyExpression = true;
-      additional = pipesToAst(additionalAst.pipes, plugin);
-    }
-  }
+  return shape;
+}
 
-  const args: ObjectBaseResolverArgs = {
+export const objectToAst = ({
+  plugin,
+  schema,
+  state,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'object'>;
+}): Omit<Ast, 'typeName'> => {
+  const ctx: ObjectResolverContext = {
     $,
-    additional,
-    pipes,
+    nodes: {
+      additionalProperties: additionalPropertiesNode,
+      base: baseNode,
+      shape: shapeNode,
+    },
+    pipes: {
+      ...pipes,
+      current: [],
+    },
     plugin,
     schema,
-    shape,
+    symbols: {
+      v: plugin.external('valibot.v'),
+    },
+    utils: {
+      ast: {},
+      state,
+    },
   };
-  const resolver = plugin.config['~resolvers']?.object?.base;
-  if (!resolver?.(args)) defaultObjectBaseResolver(args);
-
-  result.pipes = [pipesToAst(pipes, plugin)];
-  return result as Omit<Ast, 'typeName'>;
+  const resolver = plugin.config['~resolvers']?.object;
+  const node = resolver?.(ctx) ?? objectResolver(ctx);
+  ctx.utils.ast.pipes = [ctx.pipes.toNode(node, plugin)];
+  return ctx.utils.ast as Omit<Ast, 'typeName'>;
 };

packages/openapi-ts/src/plugins/valibot/v1/toAst/string.ts

···
 import type { SchemaWithType } from '~/plugins';
 import { $ } from '~/ts-dsl';
 
-import { pipesToAst } from '../../shared/pipesToAst';
+import type { Pipe, PipeResult, Pipes } from '../../shared/pipes';
+import { pipes } from '../../shared/pipes';
 import type { IrSchemaToAstOptions } from '../../shared/types';
-import type { FormatResolverArgs } from '../../types';
+import type { StringResolverContext } from '../../types';
 import { identifiers } from '../constants';
 
-const defaultFormatResolver = ({
-  pipes,
-  plugin,
-  schema,
-}: FormatResolverArgs): boolean | number => {
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
+function baseNode(ctx: StringResolverContext): PipeResult {
+  const { v } = ctx.symbols;
+  return $(v).attr(identifiers.schemas.string).call();
+}
 
+function constNode(ctx: StringResolverContext): PipeResult | undefined {
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
+  if (typeof schema.const !== 'string') return;
+  return $(v).attr(identifiers.schemas.literal).call($.literal(schema.const));
+}
+
+function formatNode(ctx: StringResolverContext): PipeResult | undefined {
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
   switch (schema.format) {
     case 'date':
-      return pipes.push($(v).attr(identifiers.actions.isoDate).call());
+      return $(v).attr(identifiers.actions.isoDate).call();
     case 'date-time':
-      return pipes.push($(v).attr(identifiers.actions.isoTimestamp).call());
+      return $(v).attr(identifiers.actions.isoTimestamp).call();
     case 'email':
-      return pipes.push($(v).attr(identifiers.actions.email).call());
+      return $(v).attr(identifiers.actions.email).call();
     case 'ipv4':
     case 'ipv6':
-      return pipes.push($(v).attr(identifiers.actions.ip).call());
+      return $(v).attr(identifiers.actions.ip).call();
     case 'time':
-      return pipes.push($(v).attr(identifiers.actions.isoTimeSecond).call());
+      return $(v).attr(identifiers.actions.isoTimeSecond).call();
     case 'uri':
-      return pipes.push($(v).attr(identifiers.actions.url).call());
+      return $(v).attr(identifiers.actions.url).call();
     case 'uuid':
-      return pipes.push($(v).attr(identifiers.actions.uuid).call());
+      return $(v).attr(identifiers.actions.uuid).call();
   }
 
-  return true;
-};
+  return;
+}
 
-export const stringToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'string'>;
-}): ReturnType<typeof $.call | typeof $.expr> => {
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
+function lengthNode(ctx: StringResolverContext): PipeResult | undefined {
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
+  if (schema.minLength === undefined || schema.minLength !== schema.maxLength)
+    return;
+  return $(v)
+    .attr(identifiers.actions.length)
+    .call($.literal(schema.minLength));
+}
 
-  if (typeof schema.const === 'string') {
-    return $(v).attr(identifiers.schemas.literal).call($.literal(schema.const));
-  }
+function maxLengthNode(ctx: StringResolverContext): PipeResult | undefined {
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
+  if (schema.maxLength === undefined) return;
+  return $(v)
+    .attr(identifiers.actions.maxLength)
+    .call($.literal(schema.maxLength));
+}
 
-  const pipes: Array<ReturnType<typeof $.call>> = [];
-  pipes.push($(v).attr(identifiers.schemas.string).call());
+function minLengthNode(ctx: StringResolverContext): PipeResult | undefined {
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
+  if (schema.minLength === undefined) return;
+  return $(v)
+    .attr(identifiers.actions.minLength)
+    .call($.literal(schema.minLength));
+}
 
-  if (schema.format) {
-    const args: FormatResolverArgs = { $, pipes, plugin, schema };
-    const resolver =
-      plugin.config['~resolvers']?.string?.formats?.[schema.format];
-    if (!resolver?.(args)) defaultFormatResolver(args);
-  }
+function patternNode(ctx: StringResolverContext): PipeResult | undefined {
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
+  if (!schema.pattern) return;
+  return $(v).attr(identifiers.actions.regex).call($.regexp(schema.pattern));
+}
 
-  if (schema.minLength === schema.maxLength && schema.minLength !== undefined) {
-    pipes.push(
-      $(v).attr(identifiers.actions.length).call($.literal(schema.minLength)),
-    );
+function stringResolver(ctx: StringResolverContext): Pipes {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) return ctx.pipes.push(ctx.pipes.current, constNode);
+
+  const baseNode = ctx.nodes.base(ctx);
+  if (baseNode) ctx.pipes.push(ctx.pipes.current, baseNode);
+
+  const formatNode = ctx.nodes.format(ctx);
+  if (formatNode) ctx.pipes.push(ctx.pipes.current, formatNode);
+
+  const lengthNode = ctx.nodes.length(ctx);
+  if (lengthNode) {
+    ctx.pipes.push(ctx.pipes.current, lengthNode);
   } else {
-    if (schema.minLength !== undefined) {
-      pipes.push(
-        $(v)
-          .attr(identifiers.actions.minLength)
-          .call($.literal(schema.minLength)),
-      );
-    }
+    const minLengthNode = ctx.nodes.minLength(ctx);
+    if (minLengthNode) ctx.pipes.push(ctx.pipes.current, minLengthNode);
 
-    if (schema.maxLength !== undefined) {
-      pipes.push(
-        $(v)
-          .attr(identifiers.actions.maxLength)
-          .call($.literal(schema.maxLength)),
-      );
-    }
+    const maxLengthNode = ctx.nodes.maxLength(ctx);
+    if (maxLengthNode) ctx.pipes.push(ctx.pipes.current, maxLengthNode);
   }
 
-  if (schema.pattern) {
-    pipes.push(
-      $(v).attr(identifiers.actions.regex).call($.regexp(schema.pattern)),
-    );
-  }
+  const patternNode = ctx.nodes.pattern(ctx);
+  if (patternNode) ctx.pipes.push(ctx.pipes.current, patternNode);
 
-  return pipesToAst(pipes, plugin);
+  return ctx.pipes.current;
+}
+
+export const stringToNode = ({
+  plugin,
+  schema,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'string'>;
+}): Pipe => {
+  const ctx: StringResolverContext = {
+    $,
+    nodes: {
+      base: baseNode,
+      const: constNode,
+      format: formatNode,
+      length: lengthNode,
+      maxLength: maxLengthNode,
+      minLength: minLengthNode,
+      pattern: patternNode,
+    },
+    pipes: {
+      ...pipes,
+      current: [],
+    },
+    plugin,
+    schema,
+    symbols: {
+      v: plugin.external('valibot.v'),
+    },
+  };
+  const resolver = plugin.config['~resolvers']?.string;
+  const node = resolver?.(ctx) ?? stringResolver(ctx);
+  return ctx.pipes.toNode(node, plugin);
 };

packages/openapi-ts/src/plugins/valibot/v1/toAst/tuple.ts

···
 import type { SchemaWithType } from '~/plugins';
 import { $ } from '~/ts-dsl';
 
-import { pipesToAst } from '../../shared/pipesToAst';
+import { pipesToNode } from '../../shared/pipes';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
 import { identifiers } from '../constants';
 import { irSchemaToAst } from '../plugin';
···
       if (schemaPipes.hasLazyExpression) {
         result.hasLazyExpression = true;
       }
-      return pipesToAst(schemaPipes.pipes, plugin);
+      return pipesToNode(schemaPipes.pipes, plugin);
     });
     result.pipes = [
       $(v)

packages/openapi-ts/src/plugins/zod/mini/api.ts

···
 
 import { identifiers } from '../constants';
 import type { ValidatorArgs } from '../shared/types';
-import type { ValidatorResolverArgs } from '../types';
+import type { ValidatorResolverContext } from '../types';
 
-const defaultValidatorResolver = ({
-  schema,
-}: ValidatorResolverArgs): ReturnType<typeof $.return> =>
-  $(schema).attr(identifiers.parseAsync).call('data').await().return();
+const validatorResolver = (
+  ctx: ValidatorResolverContext,
+): ReturnType<typeof $.return> => {
+  const { schema } = ctx.symbols;
+  return $(schema).attr(identifiers.parseAsync).call('data').await().return();
+};
 
 export const createRequestValidatorMini = ({
   operation,
···
   });
   if (!symbol) return;
 
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.request;
-  const candidates = [resolver, defaultValidatorResolver];
+  const candidates = [resolver, validatorResolver];
   for (const candidate of candidates) {
-    const statements = candidate?.(args);
+    const statements = candidate?.(ctx);
     if (statements === null) return;
     if (statements !== undefined) {
       return $.func()
···
   });
   if (!symbol) return;
 
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.response;
-  const candidates = [resolver, defaultValidatorResolver];
+  const candidates = [resolver, validatorResolver];
   for (const candidate of candidates) {
-    const statements = candidate?.(args);
+    const statements = candidate?.(ctx);
     if (statements === null) return;
     if (statements !== undefined) {
       return $.func()

packages/openapi-ts/src/plugins/zod/mini/toAst/array.ts

···
     }
   }
 
-  if (checks.length) {
+  if (checks.length > 0) {
     result.expression = result.expression
       .attr(identifiers.check)
       .call(...checks);

packages/openapi-ts/src/plugins/zod/mini/toAst/index.ts

···
 import { enumToAst } from './enum';
 import { neverToAst } from './never';
 import { nullToAst } from './null';
-import { numberToAst } from './number';
+import { numberToNode } from './number';
 import { objectToAst } from './object';
-import { stringToAst } from './string';
+import { stringToNode } from './string';
 import { tupleToAst } from './tuple';
 import { undefinedToAst } from './undefined';
 import { unknownToAst } from './unknown';
···
       });
     case 'integer':
     case 'number':
-      return numberToAst({
+      return numberToNode({
         ...args,
         schema: schema as SchemaWithType<'integer' | 'number'>,
       });
···
       });
     case 'string':
       return shouldCoerceToBigInt(schema.format)
-        ? numberToAst({
+        ? numberToNode({
             ...args,
             schema: { ...schema, type: 'number' },
           })
-        : stringToAst({
+        : stringToNode({
             ...args,
             schema: schema as SchemaWithType<'string'>,
           });

packages/openapi-ts/src/plugins/zod/mini/toAst/number.ts

···
 import { $ } from '~/ts-dsl';
 
 import { identifiers } from '../../constants';
+import type { Chain } from '../../shared/chain';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
+import type { NumberResolverContext } from '../../types';
 
-export const numberToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'integer' | 'number'>;
-}): Omit<Ast, 'typeName'> => {
-  const result: Partial<Omit<Ast, 'typeName'>> = {};
-
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-
-  if (schema.const !== undefined) {
-    result.expression = $(z)
-      .attr(identifiers.literal)
-      .call(maybeBigInt(schema.const, schema.format));
-    return result as Omit<Ast, 'typeName'>;
+function baseNode(ctx: NumberResolverContext): Chain {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (ctx.utils.shouldCoerceToBigInt(schema.format)) {
+    return $(z).attr(identifiers.coerce).attr(identifiers.bigint).call();
   }
-
-  if (shouldCoerceToBigInt(schema.format)) {
-    result.expression = $(z)
-      .attr(identifiers.coerce)
-      .attr(identifiers.bigint)
-      .call();
-  } else {
-    result.expression = $(z).attr(identifiers.number).call();
-    if (schema.type === 'integer') {
-      result.expression = $(z).attr(identifiers.int).call();
-    }
+  let chain = $(z).attr(identifiers.number).call();
+  if (schema.type === 'integer') {
+    chain = $(z).attr(identifiers.int).call();
   }
+  return chain;
+}
 
-  const checks: Array<ReturnType<typeof $.call>> = [];
+function constNode(ctx: NumberResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (schema.const === undefined) return;
+  return $(z)
+    .attr(identifiers.literal)
+    .call(ctx.utils.maybeBigInt(schema.const, schema.format));
+}
 
-  const integerLimit = getIntegerLimit(schema.format);
-  if (integerLimit) {
-    checks.push(
-      $(z)
-        .attr(identifiers.minimum)
-        .call(
-          maybeBigInt(integerLimit.minValue, schema.format),
-          $.object().prop('error', $.literal(integerLimit.minError)),
-        ),
-      $(z)
-        .attr(identifiers.maximum)
-        .call(
-          maybeBigInt(integerLimit.maxValue, schema.format),
-          $.object().prop('error', $.literal(integerLimit.maxError)),
-        ),
-    );
+function maxNode(ctx: NumberResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (schema.exclusiveMaximum !== undefined) {
+    return $(z)
+      .attr(identifiers.lt)
+      .call(ctx.utils.maybeBigInt(schema.exclusiveMaximum, schema.format));
+  }
+  if (schema.maximum !== undefined) {
+    return $(z)
+      .attr(identifiers.lte)
+      .call(ctx.utils.maybeBigInt(schema.maximum, schema.format));
+  }
+  const limit = ctx.utils.getIntegerLimit(schema.format);
+  if (limit) {
+    return $(z)
+      .attr(identifiers.maximum)
+      .call(
+        ctx.utils.maybeBigInt(limit.maxValue, schema.format),
+        $.object().prop('error', $.literal(limit.maxError)),
+      );
   }
+  return;
+}
 
+function minNode(ctx: NumberResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
   if (schema.exclusiveMinimum !== undefined) {
-    checks.push(
-      $(z)
-        .attr(identifiers.gt)
-        .call(maybeBigInt(schema.exclusiveMinimum, schema.format)),
-    );
-  } else if (schema.minimum !== undefined) {
-    checks.push(
-      $(z)
-        .attr(identifiers.gte)
-        .call(maybeBigInt(schema.minimum, schema.format)),
-    );
+    return $(z)
+      .attr(identifiers.gt)
+      .call(ctx.utils.maybeBigInt(schema.exclusiveMinimum, schema.format));
+  }
+  if (schema.minimum !== undefined) {
+    return $(z)
+      .attr(identifiers.gte)
+      .call(ctx.utils.maybeBigInt(schema.minimum, schema.format));
+  }
+  const limit = ctx.utils.getIntegerLimit(schema.format);
+  if (limit) {
+    return $(z)
+      .attr(identifiers.minimum)
+      .call(
+        ctx.utils.maybeBigInt(limit.minValue, schema.format),
+        $.object().prop('error', $.literal(limit.minError)),
+      );
   }
+  return;
+}
 
-  if (schema.exclusiveMaximum !== undefined) {
-    checks.push(
-      $(z)
-        .attr(identifiers.lt)
-        .call(maybeBigInt(schema.exclusiveMaximum, schema.format)),
-    );
-  } else if (schema.maximum !== undefined) {
-    checks.push(
-      $(z)
-        .attr(identifiers.lte)
-        .call(maybeBigInt(schema.maximum, schema.format)),
-    );
+function numberResolver(ctx: NumberResolverContext): Chain {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) {
+    ctx.chain.current = constNode;
+    return ctx.chain.current;
   }
 
-  if (checks.length) {
-    result.expression = result.expression
+  const baseNode = ctx.nodes.base(ctx);
+  if (baseNode) ctx.chain.current = baseNode;
+
+  const checks: Array<Chain> = [];
+
+  const minNode = ctx.nodes.min(ctx);
+  if (minNode) checks.push(minNode);
+
+  const maxNode = ctx.nodes.max(ctx);
+  if (maxNode) checks.push(maxNode);
+
+  if (checks.length > 0) {
+    ctx.chain.current = ctx.chain.current
       .attr(identifiers.check)
       .call(...checks);
   }
 
-  return result as Omit<Ast, 'typeName'>;
+  return ctx.chain.current;
+}
+
+export const numberToNode = ({
+  plugin,
+  schema,
+  state,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'integer' | 'number'>;
+}): Omit<Ast, 'typeName'> => {
+  const ast: Partial<Omit<Ast, 'typeName'>> = {};
+  const z = plugin.external('zod.z');
+  const ctx: NumberResolverContext = {
+    $,
+    chain: {
+      current: $(z),
+    },
+    nodes: {
+      base: baseNode,
+      const: constNode,
+      max: maxNode,
+      min: minNode,
+    },
+    plugin,
+    schema,
+    symbols: {
+      z,
+    },
+    utils: {
+      ast,
+      getIntegerLimit,
+      maybeBigInt,
+      shouldCoerceToBigInt,
+      state,
+    },
+  };
+  const resolver = plugin.config['~resolvers']?.number;
+  const node = resolver?.(ctx) ?? numberResolver(ctx);
+  ast.expression = node;
+  return ast as Omit<Ast, 'typeName'>;
 };

packages/openapi-ts/src/plugins/zod/mini/toAst/object.ts

···
 import { $ } from '~/ts-dsl';
 
 import { identifiers } from '../../constants';
+import type { Chain } from '../../shared/chain';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
-import type { ObjectBaseResolverArgs } from '../../types';
+import type { ObjectResolverContext } from '../../types';
 import { irSchemaToAst } from '../plugin';
 
-function defaultObjectBaseResolver({
-  additional,
-  plugin,
-  shape,
-}: ObjectBaseResolverArgs): ReturnType<typeof $.call> {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
+function additionalPropertiesNode(
+  ctx: ObjectResolverContext,
+): Chain | null | undefined {
+  const { plugin, schema } = ctx;
+
+  if (
+    !schema.additionalProperties ||
+    (schema.properties && Object.keys(schema.properties).length > 0)
+  )
+    return;
+
+  const additionalAst = irSchemaToAst({
+    plugin,
+    schema: schema.additionalProperties,
+    state: {
+      ...ctx.utils.state,
+      path: ref([...fromRef(ctx.utils.state.path), 'additionalProperties']),
+    },
   });
+  if (additionalAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true;
+  return additionalAst.expression;
+}
+
+function baseNode(ctx: ObjectResolverContext): Chain {
+  const { nodes, symbols } = ctx;
+  const { z } = symbols;
+
+  const additional = nodes.additionalProperties(ctx);
+  const shape = nodes.shape(ctx);
 
   if (additional) {
     return $(z)
···
   return $(z).attr(identifiers.object).call(shape);
 }
 
-export const objectToAst = ({
-  plugin,
-  schema,
-  state,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'object'>;
-}): Omit<Ast, 'typeName'> => {
-  const result: Partial<Omit<Ast, 'typeName'>> = {};
-
+function objectResolver(ctx: ObjectResolverContext): Chain {
   // TODO: parser - handle constants
+  return ctx.nodes.base(ctx);
+}
 
+function shapeNode(ctx: ObjectResolverContext): ReturnType<typeof $.object> {
+  const { plugin, schema } = ctx;
   const shape = $.object().pretty();
-  const required = schema.required ?? [];
 
   for (const name in schema.properties) {
     const property = schema.properties[name]!;
-    const isRequired = required.includes(name);
 
     const propertyAst = irSchemaToAst({
-      optional: !isRequired,
+      optional: !schema.required?.includes(name),
       plugin,
       schema: property,
       state: {
-        ...state,
-        path: ref([...fromRef(state.path), 'properties', name]),
+        ...ctx.utils.state,
+        path: ref([...fromRef(ctx.utils.state.path), 'properties', name]),
       },
     });
     if (propertyAst.hasLazyExpression) {
-      result.hasLazyExpression = true;
-    }
-
-    if (propertyAst.hasLazyExpression) {
+      ctx.utils.ast.hasLazyExpression = true;
       shape.getter(name, propertyAst.expression.return());
     } else {
       shape.prop(name, propertyAst.expression);
     }
   }
 
-  let additional: ReturnType<typeof $.call | typeof $.expr> | null | undefined;
-  if (
-    schema.additionalProperties &&
-    (!schema.properties || !Object.keys(schema.properties).length)
-  ) {
-    const additionalAst = irSchemaToAst({
-      plugin,
-      schema: schema.additionalProperties,
-      state: {
-        ...state,
-        path: ref([...fromRef(state.path), 'additionalProperties']),
-      },
-    });
-    if (additionalAst.hasLazyExpression) result.hasLazyExpression = true;
-    additional = additionalAst.expression;
-  }
+  return shape;
+}
 
-  const args: ObjectBaseResolverArgs = {
+export const objectToAst = ({
+  plugin,
+  schema,
+  state,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'object'>;
+}): Omit<Ast, 'typeName'> => {
+  const ast: Partial<Omit<Ast, 'typeName'>> = {};
+  const z = plugin.external('zod.z');
+  const ctx: ObjectResolverContext = {
     $,
-    additional,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
+    nodes: {
+      additionalProperties: additionalPropertiesNode,
+      base: baseNode,
+      shape: shapeNode,
+    },
     plugin,
     schema,
-    shape,
+    symbols: {
+      z,
+    },
+    utils: {
+      ast,
+      state,
+    },
   };
-  const resolver = plugin.config['~resolvers']?.object?.base;
-  const chain = resolver?.(args) ?? defaultObjectBaseResolver(args);
-  result.expression = chain;
-
-  return result as Omit<Ast, 'typeName'>;
+  const resolver = plugin.config['~resolvers']?.object;
+  const node = resolver?.(ctx) ?? objectResolver(ctx);
+  ast.expression = node;
+  return ast as Omit<Ast, 'typeName'>;
 };

packages/openapi-ts/src/plugins/zod/mini/toAst/string.ts

···
 import { $ } from '~/ts-dsl';
 
 import { identifiers } from '../../constants';
+import type { Chain } from '../../shared/chain';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
-import type { FormatResolverArgs } from '../../types';
+import type { StringResolverContext } from '../../types';
+
+function baseNode(ctx: StringResolverContext): Chain {
+  const { z } = ctx.symbols;
+  return $(z).attr(identifiers.string).call();
+}
+
+function constNode(ctx: StringResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (typeof schema.const !== 'string') return;
+  return $(z).attr(identifiers.literal).call($.literal(schema.const));
+}
 
-const defaultFormatResolver = ({
-  chain,
-  plugin,
-  schema,
-}: FormatResolverArgs): ReturnType<typeof $.call> => {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
+function formatNode(ctx: StringResolverContext): Chain | undefined {
+  const { plugin, schema, symbols } = ctx;
+  const { z } = symbols;
 
   switch (schema.format) {
     case 'date':
···
       return $(z).attr(identifiers.url).call();
     case 'uuid':
       return $(z).attr(identifiers.uuid).call();
-    default:
-      return chain;
   }
-};
 
-export const stringToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'string'>;
-}): Omit<Ast, 'typeName'> => {
-  const result: Partial<Omit<Ast, 'typeName'>> = {};
-  let chain: ReturnType<typeof $.call>;
+  return;
+}
 
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
+function lengthNode(ctx: StringResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (schema.minLength === undefined || schema.minLength !== schema.maxLength)
+    return;
+  return $(z).attr(identifiers.length).call($.literal(schema.minLength));
+}
+
+function maxLengthNode(ctx: StringResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (schema.maxLength === undefined) return;
+  return $(z).attr(identifiers.maxLength).call($.literal(schema.maxLength));
+}
+
+function minLengthNode(ctx: StringResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (schema.minLength === undefined) return;
+  return $(z).attr(identifiers.minLength).call($.literal(schema.minLength));
+}
 
-  if (typeof schema.const === 'string') {
-    chain = $(z).attr(identifiers.literal).call($.literal(schema.const));
-    result.expression = chain;
-    return result as Omit<Ast, 'typeName'>;
+function patternNode(ctx: StringResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (!schema.pattern) return;
+  return $(z).attr(identifiers.regex).call($.regexp(schema.pattern));
+}
+
+function stringResolver(ctx: StringResolverContext): Chain {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) {
+    ctx.chain.current = constNode;
+    return ctx.chain.current;
   }
 
-  chain = $(z).attr(identifiers.string).call();
+  const baseNode = ctx.nodes.base(ctx);
+  if (baseNode) ctx.chain.current = baseNode;
 
-  if (schema.format) {
-    const args: FormatResolverArgs = { $, chain, plugin, schema };
-    const resolver =
-      plugin.config['~resolvers']?.string?.formats?.[schema.format];
-    chain = resolver?.(args) ?? defaultFormatResolver(args);
-  }
+  const formatNode = ctx.nodes.format(ctx);
+  if (formatNode) ctx.chain.current = formatNode;
 
-  const checks: Array<ReturnType<typeof $.call>> = [];
+  const checks: Array<Chain> = [];
 
-  if (schema.minLength === schema.maxLength && schema.minLength !== undefined) {
-    checks.push(
-      $(z).attr(identifiers.length).call($.literal(schema.minLength)),
-    );
+  const lengthNode = ctx.nodes.length(ctx);
+  if (lengthNode) {
+    checks.push(lengthNode);
   } else {
-    if (schema.minLength !== undefined) {
-      checks.push(
-        $(z).attr(identifiers.minLength).call($.literal(schema.minLength)),
-      );
-    }
+    const minLengthNode = ctx.nodes.minLength(ctx);
+    if (minLengthNode) checks.push(minLengthNode);
 
-    if (schema.maxLength !== undefined) {
-      checks.push(
-        $(z).attr(identifiers.maxLength).call($.literal(schema.maxLength)),
-      );
-    }
+    const maxLengthNode = ctx.nodes.maxLength(ctx);
+    if (maxLengthNode) checks.push(maxLengthNode);
   }
 
-  if (schema.pattern) {
-    checks.push($(z).attr(identifiers.regex).call($.regexp(schema.pattern)));
+  const patternNode = ctx.nodes.pattern(ctx);
+  if (patternNode) checks.push(patternNode);
+
+  if (checks.length > 0) {
+    ctx.chain.current = ctx.chain.current
+      .attr(identifiers.check)
+      .call(...checks);
   }
 
-  if (checks.length) {
-    chain = chain.attr(identifiers.check).call(...checks);
-  }
+  return ctx.chain.current;
+}
 
-  result.expression = chain;
-  return result as Omit<Ast, 'typeName'>;
+export const stringToNode = ({
+  plugin,
+  schema,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'string'>;
+}): Omit<Ast, 'typeName'> => {
+  const z = plugin.external('zod.z');
+  const ctx: StringResolverContext = {
+    $,
+    chain: {
+      current: $(z),
+    },
+    nodes: {
+      base: baseNode,
+      const: constNode,
+      format: formatNode,
+      length: lengthNode,
+      maxLength: maxLengthNode,
+      minLength: minLengthNode,
+      pattern: patternNode,
+    },
+    plugin,
+    schema,
+    symbols: {
+      z,
+    },
+  };
+  const resolver = plugin.config['~resolvers']?.string;
+  const node = resolver?.(ctx) ?? stringResolver(ctx);
+  return {
+    expression: node,
+  };
 };

packages/openapi-ts/src/plugins/zod/shared/chain.ts

···
+import type { $ } from '~/ts-dsl';
+
+export type Chain = ReturnType<typeof $.call | typeof $.expr>;

packages/openapi-ts/src/plugins/zod/types.d.ts

···
-import type { Symbol } from '@hey-api/codegen-core';
+import type { Refs, Symbol } from '@hey-api/codegen-core';
 import type ts from 'typescript';
 
 import type { IR } from '~/ir/types';
-import type { DefinePlugin, Plugin } from '~/plugins';
+import type { DefinePlugin, Plugin, SchemaWithType } from '~/plugins';
+import type {
+  MaybeBigInt,
+  ShouldCoerceToBigInt,
+} from '~/plugins/shared/utils/coerce';
+import type { GetIntegerLimit } from '~/plugins/shared/utils/formats';
 import type { $, DollarTsDsl, TsDsl } from '~/ts-dsl';
 import type { StringCase, StringName } from '~/types/case';
 import type { MaybeArray } from '~/types/utils';
 
 import type { IApi } from './api';
+import type { Chain } from './shared/chain';
+import type { Ast, PluginState } from './shared/types';
 
 export type UserConfig = Plugin.Name<'zod'> &
   Plugin.Hooks &
···
     };
   };
 
-type SharedResolverArgs = DollarTsDsl & {
+interface BaseResolverContext extends DollarTsDsl {
+  /**
+   * Functions for working with chains.
+   */
+  chain: {
+    /**
+     * The current chain.
+     *
+     * In Zod, this represents a chain of call expressions ("chains")
+     * being assembled to form a schema definition.
+     *
+     * Each chain can be extended, modified, or replaced to customize
+     * the resulting schema.
+     */
+    current: Chain;
+  };
   /**
-   * The current fluent builder chain under construction for this resolver.
-   *
-   * Represents the in-progress call sequence (e.g., a Zod or DSL chain)
-   * that defines the current schema or expression being generated.
-   *
-   * This chain can be extended, transformed, or replaced entirely to customize
-   * the resulting output of the resolver.
+   * The plugin instance.
    */
-  chain?: ReturnType<typeof $.call>;
   plugin: ZodPlugin['Instance'];
-};
+  /**
+   * Provides access to commonly used symbols within the plugin.
+   */
+  symbols: {
+    z: Symbol;
+  };
+}
 
-export type FormatResolverArgs = Required<SharedResolverArgs> & {
-  schema: IR.SchemaObject;
-};
+export interface NumberResolverContext extends BaseResolverContext {
+  /**
+   * Nodes used to build different parts of the number schema.
+   */
+  nodes: {
+    base: (ctx: NumberResolverContext) => Chain;
+    const: (ctx: NumberResolverContext) => Chain | undefined;
+    max: (ctx: NumberResolverContext) => Chain | undefined;
+    min: (ctx: NumberResolverContext) => Chain | undefined;
+  };
+  schema: SchemaWithType<'integer' | 'number'>;
+  /**
+   * Utility functions for number schema processing.
+   */
+  utils: {
+    ast: Partial<Omit<Ast, 'typeName'>>;
+    getIntegerLimit: GetIntegerLimit;
+    maybeBigInt: MaybeBigInt;
+    shouldCoerceToBigInt: ShouldCoerceToBigInt;
+    state: Refs<PluginState>;
+  };
+}
 
-export type ObjectBaseResolverArgs = SharedResolverArgs & {
-  /** Null = never */
-  additional?: ReturnType<typeof $.call | typeof $.expr> | null;
-  schema: IR.SchemaObject;
-  shape: ReturnType<typeof $.object>;
-};
+export interface ObjectResolverContext extends BaseResolverContext {
+  /**
+   * Nodes used to build different parts of the object schema.
+   */
+  nodes: {
+    /**
+     * If `additionalProperties` is `false` or `{ type: 'never' }`, returns `null`
+     * to indicate no additional properties are allowed.
+     */
+    additionalProperties: (
+      ctx: ObjectResolverContext,
+    ) => Chain | null | undefined;
+    base: (ctx: ObjectResolverContext) => Chain;
+    shape: (ctx: ObjectResolverContext) => ReturnType<typeof $.object>;
+  };
+  schema: SchemaWithType<'object'>;
+  /**
+   * Utility functions for object schema processing.
+   */
+  utils: {
+    ast: Partial<Omit<Ast, 'typeName'>>;
+    state: Refs<PluginState>;
+  };
+}
 
-export type ValidatorResolverArgs = SharedResolverArgs & {
+export interface StringResolverContext extends BaseResolverContext {
+  /**
+   * Nodes used to build different parts of the string schema.
+   */
+  nodes: {
+    base: (ctx: StringResolverContext) => Chain;
+    const: (ctx: StringResolverContext) => Chain | undefined;
+    format: (ctx: StringResolverContext) => Chain | undefined;
+    length: (ctx: StringResolverContext) => Chain | undefined;
+    maxLength: (ctx: StringResolverContext) => Chain | undefined;
+    minLength: (ctx: StringResolverContext) => Chain | undefined;
+    pattern: (ctx: StringResolverContext) => Chain | undefined;
+  };
+  schema: SchemaWithType<'string'>;
+}
+
+export interface ValidatorResolverContext extends BaseResolverContext {
   operation: IR.Operation;
-  schema: Symbol;
-};
+  /**
+   * Provides access to commonly used symbols within the plugin.
+   */
+  symbols: BaseResolverContext['symbols'] & {
+    schema: Symbol;
+  };
+}
 
 type ValidatorResolver = (
-  args: ValidatorResolverArgs,
+  ctx: ValidatorResolverContext,
 ) => MaybeArray<TsDsl<ts.Statement>> | null | undefined;
 
 type Resolvers = Plugin.Resolvers<{
   /**
-   * Resolvers for number schemas.
+   * Resolver for number schemas.
    *
-   * Allows customization of how number types are rendered, including
-   * per-format handling.
+   * Allows customization of how number types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
    */
-  number?: {
-    /**
-     * Resolvers for number formats (e.g., `float`, `double`, `int32`).
-     *
-     * Each key represents a specific format name with a custom
-     * resolver function that controls how that format is rendered.
-     *
-     * Example path: `~resolvers.number.formats.float`
-     *
-     * Returning `undefined` from a resolver will apply the default
-     * generation behavior for that format.
-     */
-    formats?: Record<
-      string,
-      (args: FormatResolverArgs) => boolean | number | undefined
-    >;
-  };
+  number?: (ctx: NumberResolverContext) => Chain | undefined;
   /**
-   * Resolvers for object schemas.
+   * Resolver for object schemas.
    *
    * Allows customization of how object types are rendered.
    *
-   * Example path: `~resolvers.object.base`
-   *
-   * Returning `undefined` from a resolver will apply the default
-   * generation behavior for the object schema.
+   * Returning `undefined` will execute the default resolver logic.
    */
-  object?: {
-    /**
-     * Controls how object schemas are constructed.
-     *
-     * Called with the fully assembled shape (properties) and any additional
-     * property schema, allowing the resolver to choose the correct Zod
-     * base constructor and modify the schema chain if needed.
-     *
-     * Returning `undefined` will execute the default resolver logic.
-     */
-    base?: (
-      args: ObjectBaseResolverArgs,
-    ) => ReturnType<typeof $.call> | undefined;
-  };
+  object?: (ctx: ObjectResolverContext) => Chain | undefined;
   /**
-   * Resolvers for string schemas.
+   * Resolver for string schemas.
    *
-   * Allows customization of how string types are rendered, including
-   * per-format handling.
+   * Allows customization of how string types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
    */
-  string?: {
-    /**
-     * Resolvers for string formats (e.g., `uuid`, `email`, `date-time`).
-     *
-     * Each key represents a specific format name with a custom
-     * resolver function that controls how that format is rendered.
-     *
-     * Example path: `~resolvers.string.formats.uuid`
-     *
-     * Returning `undefined` from a resolver will apply the default
-     * generation logic for that format.
-     */
-    formats?: Record<
-      string,
-      (args: FormatResolverArgs) => ReturnType<typeof $.call> | undefined
-    >;
-  };
+  string?: (ctx: StringResolverContext) => Chain | undefined;
   /**
    * Resolvers for request and response validators.
    *
···
    *
    * Example path: `~resolvers.validator.request` or `~resolvers.validator.response`
    *
-   * Returning `undefined` from a resolver will apply the default generation logic.
+   * Returning `undefined` will execute the default resolver logic.
    */
   validator?:
     | ValidatorResolver
···
         /**
          * Controls how the request validator function body is generated.
          *
-         * Returning `undefined` will fall back to the default `.await().return()` logic.
+         * Returning `undefined` will execute the default resolver logic.
          */
         request?: ValidatorResolver;
         /**
          * Controls how the response validator function body is generated.
          *
-         * Returning `undefined` will fall back to the default `.await().return()` logic.
+         * Returning `undefined` will execute the default resolver logic.
          */
         response?: ValidatorResolver;
       };

packages/openapi-ts/src/plugins/zod/v3/api.ts

···
 
 import { identifiers } from '../constants';
 import type { ValidatorArgs } from '../shared/types';
-import type { ValidatorResolverArgs } from '../types';
+import type { ValidatorResolverContext } from '../types';
 
-const defaultValidatorResolver = ({
-  schema,
-}: ValidatorResolverArgs): ReturnType<typeof $.return> =>
-  $(schema).attr(identifiers.parseAsync).call('data').await().return();
+const validatorResolver = (
+  ctx: ValidatorResolverContext,
+): ReturnType<typeof $.return> => {
+  const { schema } = ctx.symbols;
+  return $(schema).attr(identifiers.parseAsync).call('data').await().return();
+};
 
 export const createRequestValidatorV3 = ({
   operation,
···
   });
   if (!symbol) return;
 
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.request;
-  const candidates = [resolver, defaultValidatorResolver];
+  const candidates = [resolver, validatorResolver];
   for (const candidate of candidates) {
-    const statements = candidate?.(args);
+    const statements = candidate?.(ctx);
     if (statements === null) return;
     if (statements !== undefined) {
       return $.func()
···
   });
   if (!symbol) return;
 
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.response;
-  const candidates = [resolver, defaultValidatorResolver];
+  const candidates = [resolver, validatorResolver];
   for (const candidate of candidates) {
-    const statements = candidate?.(args);
+    const statements = candidate?.(ctx);
     if (statements === null) return;
     if (statements !== undefined) {
       return $.func()

packages/openapi-ts/src/plugins/zod/v3/toAst/index.ts

···
 import { enumToAst } from './enum';
 import { neverToAst } from './never';
 import { nullToAst } from './null';
-import { numberToAst } from './number';
+import { numberToNode } from './number';
 import { objectToAst } from './object';
-import { stringToAst } from './string';
+import { stringToNode } from './string';
 import { tupleToAst } from './tuple';
 import { undefinedToAst } from './undefined';
 import { unknownToAst } from './unknown';
···
     case 'integer':
     case 'number':
       return {
-        expression: numberToAst({
+        expression: numberToNode({
           ...args,
           schema: schema as SchemaWithType<'integer' | 'number'>,
         }),
···
     case 'string':
       return {
         expression: shouldCoerceToBigInt(schema.format)
-          ? numberToAst({
+          ? numberToNode({
               ...args,
               schema: { ...schema, type: 'number' },
             })
-          : stringToAst({
+          : stringToNode({
               ...args,
               schema: schema as SchemaWithType<'string'>,
             }),

packages/openapi-ts/src/plugins/zod/v3/toAst/number.ts

···
 import { $ } from '~/ts-dsl';
 
 import { identifiers } from '../../constants';
-import type { IrSchemaToAstOptions } from '../../shared/types';
+import type { Chain } from '../../shared/chain';
+import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
+import type { NumberResolverContext } from '../../types';
 
-export const numberToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'integer' | 'number'>;
-}) => {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-
-  if (schema.const !== undefined) {
-    const expression = $(z)
-      .attr(identifiers.literal)
-      .call(maybeBigInt(schema.const, schema.format));
-    return expression;
+function baseNode(ctx: NumberResolverContext): Chain {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (ctx.utils.shouldCoerceToBigInt(schema.format)) {
+    return $(z).attr(identifiers.coerce).attr(identifiers.bigint).call();
   }
+  let chain = $(z).attr(identifiers.number).call();
+  if (schema.type === 'integer') {
+    chain = chain.attr(identifiers.int).call();
+  }
+  return chain;
+}
 
-  let numberExpression: ReturnType<typeof $.call>;
+function constNode(ctx: NumberResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (schema.const === undefined) return;
+  return $(z)
+    .attr(identifiers.literal)
+    .call(ctx.utils.maybeBigInt(schema.const, schema.format));
+}
 
-  if (shouldCoerceToBigInt(schema.format)) {
-    numberExpression = $(z)
-      .attr(identifiers.coerce)
-      .attr(identifiers.bigint)
-      .call();
-  } else {
-    numberExpression = $(z).attr(identifiers.number).call();
-    if (schema.type === 'integer') {
-      numberExpression = numberExpression.attr(identifiers.int).call();
-    }
+function maxNode(ctx: NumberResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
+  if (schema.exclusiveMaximum !== undefined) {
+    return chain.current
+      .attr(identifiers.lt)
+      .call(ctx.utils.maybeBigInt(schema.exclusiveMaximum, schema.format));
+  }
+  if (schema.maximum !== undefined) {
+    return chain.current
+      .attr(identifiers.lte)
+      .call(ctx.utils.maybeBigInt(schema.maximum, schema.format));
   }
-
-  const integerLimit = getIntegerLimit(schema.format);
-  if (integerLimit) {
-    numberExpression = numberExpression
-      .attr(identifiers.min)
-      .call(
-        maybeBigInt(integerLimit.minValue, schema.format),
-        $.object().prop('message', $.literal(integerLimit.minError)),
-      )
+  const limit = ctx.utils.getIntegerLimit(schema.format);
+  if (limit) {
+    return chain.current
       .attr(identifiers.max)
       .call(
-        maybeBigInt(integerLimit.maxValue, schema.format),
-        $.object().prop('message', $.literal(integerLimit.maxError)),
+        ctx.utils.maybeBigInt(limit.maxValue, schema.format),
+        $.object().prop('message', $.literal(limit.maxError)),
       );
   }
+  return;
+}
 
+function minNode(ctx: NumberResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
   if (schema.exclusiveMinimum !== undefined) {
-    numberExpression = numberExpression
+    return chain.current
       .attr(identifiers.gt)
-      .call(maybeBigInt(schema.exclusiveMinimum, schema.format));
-  } else if (schema.minimum !== undefined) {
-    numberExpression = numberExpression
+      .call(ctx.utils.maybeBigInt(schema.exclusiveMinimum, schema.format));
+  }
+  if (schema.minimum !== undefined) {
+    return chain.current
       .attr(identifiers.gte)
-      .call(maybeBigInt(schema.minimum, schema.format));
+      .call(ctx.utils.maybeBigInt(schema.minimum, schema.format));
+  }
+  const limit = ctx.utils.getIntegerLimit(schema.format);
+  if (limit) {
+    return chain.current
+      .attr(identifiers.min)
+      .call(
+        ctx.utils.maybeBigInt(limit.minValue, schema.format),
+        $.object().prop('message', $.literal(limit.minError)),
+      );
   }
+  return;
+}
 
-  if (schema.exclusiveMaximum !== undefined) {
-    numberExpression = numberExpression
-      .attr(identifiers.lt)
-      .call(maybeBigInt(schema.exclusiveMaximum, schema.format));
-  } else if (schema.maximum !== undefined) {
-    numberExpression = numberExpression
-      .attr(identifiers.lte)
-      .call(maybeBigInt(schema.maximum, schema.format));
+function numberResolver(ctx: NumberResolverContext): Chain {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) {
+    ctx.chain.current = constNode;
+    return ctx.chain.current;
   }
 
-  return numberExpression;
+  const baseNode = ctx.nodes.base(ctx);
+  if (baseNode) ctx.chain.current = baseNode;
+
+  const minNode = ctx.nodes.min(ctx);
+  if (minNode) ctx.chain.current = minNode;
+
+  const maxNode = ctx.nodes.max(ctx);
+  if (maxNode) ctx.chain.current = maxNode;
+
+  return ctx.chain.current;
+}
+
+export const numberToNode = ({
+  plugin,
+  schema,
+  state,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'integer' | 'number'>;
+}): Chain => {
+  const ast: Partial<Omit<Ast, 'typeName'>> = {};
+  const z = plugin.external('zod.z');
+  const ctx: NumberResolverContext = {
+    $,
+    chain: {
+      current: $(z),
+    },
+    nodes: {
+      base: baseNode,
+      const: constNode,
+      max: maxNode,
+      min: minNode,
+    },
+    plugin,
+    schema,
+    symbols: {
+      z,
+    },
+    utils: {
+      ast,
+      getIntegerLimit,
+      maybeBigInt,
+      shouldCoerceToBigInt,
+      state,
+    },
+  };
+  const resolver = plugin.config['~resolvers']?.number;
+  const node = resolver?.(ctx) ?? numberResolver(ctx);
+  return node;
 };

packages/openapi-ts/src/plugins/zod/v3/toAst/object.ts

···
 import { $ } from '~/ts-dsl';
 
 import { identifiers } from '../../constants';
+import type { Chain } from '../../shared/chain';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
-import type { ObjectBaseResolverArgs } from '../../types';
+import type { ObjectResolverContext } from '../../types';
 import { irSchemaToAst } from '../plugin';
 
-function defaultObjectBaseResolver({
-  additional,
-  plugin,
-  shape,
-}: ObjectBaseResolverArgs): ReturnType<typeof $.call> {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
+function additionalPropertiesNode(
+  ctx: ObjectResolverContext,
+): Chain | null | undefined {
+  const { plugin, schema } = ctx;
+
+  if (
+    !schema.additionalProperties ||
+    (schema.properties && Object.keys(schema.properties).length > 0)
+  )
+    return;
+
+  const additionalAst = irSchemaToAst({
+    plugin,
+    schema: schema.additionalProperties,
+    state: {
+      ...ctx.utils.state,
+      path: ref([...fromRef(ctx.utils.state.path), 'additionalProperties']),
+    },
   });
+  if (additionalAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true;
+  return additionalAst.expression;
+}
+
+function baseNode(ctx: ObjectResolverContext): Chain {
+  const { nodes, symbols } = ctx;
+  const { z } = symbols;
+
+  const additional = nodes.additionalProperties(ctx);
+  const shape = nodes.shape(ctx);
 
   if (additional) {
     return $(z).attr(identifiers.record).call(additional);
···
   return $(z).attr(identifiers.object).call(shape);
 }
 
-export const objectToAst = ({
-  plugin,
-  schema,
-  state,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'object'>;
-}): Omit<Ast, 'typeName'> & {
-  anyType?: string;
-} => {
-  let hasLazyExpression = false;
-
+function objectResolver(ctx: ObjectResolverContext): Chain {
   // TODO: parser - handle constants
+  return ctx.nodes.base(ctx);
+}
 
+function shapeNode(ctx: ObjectResolverContext): ReturnType<typeof $.object> {
+  const { plugin, schema } = ctx;
   const shape = $.object().pretty();
-  const required = schema.required ?? [];
 
   for (const name in schema.properties) {
     const property = schema.properties[name]!;
-    const isRequired = required.includes(name);
 
-    const propertyExpression = irSchemaToAst({
-      optional: !isRequired,
+    const propertyAst = irSchemaToAst({
+      optional: !schema.required?.includes(name),
       plugin,
       schema: property,
       state: {
-        ...state,
-        path: ref([...fromRef(state.path), 'properties', name]),
+        ...ctx.utils.state,
+        path: ref([...fromRef(ctx.utils.state.path), 'properties', name]),
       },
     });
-
-    if (propertyExpression.hasLazyExpression) hasLazyExpression = true;
-
-    shape.prop(name, propertyExpression.expression);
+    if (propertyAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true;
+    shape.prop(name, propertyAst.expression);
   }
 
-  let additional: ReturnType<typeof $.call | typeof $.expr> | null | undefined;
-  const result: Partial<Omit<Ast, 'typeName'>> = {};
-  if (
-    schema.additionalProperties &&
-    (!schema.properties || !Object.keys(schema.properties).length)
-  ) {
-    const additionalAst = irSchemaToAst({
-      plugin,
-      schema: schema.additionalProperties,
-      state: {
-        ...state,
-        path: ref([...fromRef(state.path), 'additionalProperties']),
-      },
-    });
-    hasLazyExpression = additionalAst.hasLazyExpression || hasLazyExpression;
-    additional = additionalAst.expression;
-  }
+  return shape;
+}
 
-  const args: ObjectBaseResolverArgs = {
+export const objectToAst = ({
+  plugin,
+  schema,
+  state,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'object'>;
+}): Omit<Ast, 'typeName'> & {
+  anyType?: string;
+} => {
+  const ast: Partial<Omit<Ast, 'typeName'>> = {};
+  const z = plugin.external('zod.z');
+  const ctx: ObjectResolverContext = {
     $,
-    additional,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
+    nodes: {
+      additionalProperties: additionalPropertiesNode,
+      base: baseNode,
+      shape: shapeNode,
+    },
     plugin,
     schema,
-    shape,
+    symbols: {
+      z,
+    },
+    utils: {
+      ast,
+      state,
+    },
   };
-  const resolver = plugin.config['~resolvers']?.object?.base;
-  const chain = resolver?.(args) ?? defaultObjectBaseResolver(args);
-  result.expression = chain;
-
+  const resolver = plugin.config['~resolvers']?.object;
+  const node = resolver?.(ctx) ?? objectResolver(ctx);
+  ast.expression = node;
   return {
+    ...ast,
     anyType: 'AnyZodObject',
-    expression: result.expression!,
-    hasLazyExpression,
+  } as Omit<Ast, 'typeName'> & {
+    anyType: string;
   };
 };

packages/openapi-ts/src/plugins/zod/v3/toAst/string.ts

···
 import { $ } from '~/ts-dsl';
 
 import { identifiers } from '../../constants';
+import type { Chain } from '../../shared/chain';
 import type { IrSchemaToAstOptions } from '../../shared/types';
-import type { FormatResolverArgs } from '../../types';
+import type { StringResolverContext } from '../../types';
 
-const defaultFormatResolver = ({
-  chain,
-  plugin,
-  schema,
-}: FormatResolverArgs): ReturnType<typeof $.call> => {
+function baseNode(ctx: StringResolverContext): Chain {
+  const { z } = ctx.symbols;
+  return $(z).attr(identifiers.string).call();
+}
+
+function constNode(ctx: StringResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (typeof schema.const !== 'string') return;
+  return $(z).attr(identifiers.literal).call($.literal(schema.const));
+}
+
+function formatNode(ctx: StringResolverContext): Chain | undefined {
+  const { chain, plugin, schema } = ctx;
+
   switch (schema.format) {
     case 'date':
-      return chain.attr(identifiers.date).call();
+      return chain.current.attr(identifiers.date).call();
     case 'date-time': {
       const obj = $.object()
         .$if(plugin.config.dates.offset, (o) =>
···
         .$if(plugin.config.dates.local, (o) =>
           o.prop('local', $.literal(true)),
         );
-      return chain
+      return chain.current
         .attr(identifiers.datetime)
         .call(obj.hasProps() ? obj : undefined);
     }
     case 'email':
-      return chain.attr(identifiers.email).call();
+      return chain.current.attr(identifiers.email).call();
     case 'ipv4':
     case 'ipv6':
-      return chain.attr(identifiers.ip).call();
+      return chain.current.attr(identifiers.ip).call();
     case 'time':
-      return chain.attr(identifiers.time).call();
+      return chain.current.attr(identifiers.time).call();
     case 'uri':
-      return chain.attr(identifiers.url).call();
+      return chain.current.attr(identifiers.url).call();
     case 'uuid':
-      return chain.attr(identifiers.uuid).call();
-    default:
-      return chain;
+      return chain.current.attr(identifiers.uuid).call();
   }
-};
 
-export const stringToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'string'>;
-}): ReturnType<typeof $.call> => {
-  let chain: ReturnType<typeof $.call>;
+  return;
+}
 
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
+function lengthNode(ctx: StringResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
+  if (schema.minLength === undefined || schema.minLength !== schema.maxLength)
+    return;
+  return chain.current
+    .attr(identifiers.length)
+    .call($.literal(schema.minLength));
+}
 
-  if (typeof schema.const === 'string') {
-    chain = $(z).attr(identifiers.literal).call($.literal(schema.const));
-    return chain;
-  }
+function maxLengthNode(ctx: StringResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
+  if (schema.maxLength === undefined) return;
+  return chain.current.attr(identifiers.max).call($.literal(schema.maxLength));
+}
 
-  chain = $(z).attr(identifiers.string).call();
+function minLengthNode(ctx: StringResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
+  if (schema.minLength === undefined) return;
+  return chain.current.attr(identifiers.min).call($.literal(schema.minLength));
+}
 
-  if (schema.format) {
-    const args: FormatResolverArgs = { $, chain, plugin, schema };
-    const resolver =
-      plugin.config['~resolvers']?.string?.formats?.[schema.format];
-    chain = resolver?.(args) ?? defaultFormatResolver(args);
+function patternNode(ctx: StringResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
+  if (!schema.pattern) return;
+  return chain.current.attr(identifiers.regex).call($.regexp(schema.pattern));
+}
+
+function stringResolver(ctx: StringResolverContext): Chain {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) {
+    ctx.chain.current = constNode;
+    return ctx.chain.current;
   }
 
-  if (schema.minLength === schema.maxLength && schema.minLength !== undefined) {
-    chain = chain.attr(identifiers.length).call($.literal(schema.minLength));
+  const baseNode = ctx.nodes.base(ctx);
+  if (baseNode) ctx.chain.current = baseNode;
+
+  const formatNode = ctx.nodes.format(ctx);
+  if (formatNode) ctx.chain.current = formatNode;
+
+  const lengthNode = ctx.nodes.length(ctx);
+  if (lengthNode) {
+    ctx.chain.current = lengthNode;
   } else {
-    if (schema.minLength !== undefined) {
-      chain = chain.attr(identifiers.min).call($.literal(schema.minLength));
-    }
+    const minLengthNode = ctx.nodes.minLength(ctx);
+    if (minLengthNode) ctx.chain.current = minLengthNode;
 
-    if (schema.maxLength !== undefined) {
-      chain = chain.attr(identifiers.max).call($.literal(schema.maxLength));
-    }
+    const maxLengthNode = ctx.nodes.maxLength(ctx);
+    if (maxLengthNode) ctx.chain.current = maxLengthNode;
   }
 
-  if (schema.pattern) {
-    chain = chain.attr(identifiers.regex).call($.regexp(schema.pattern));
-  }
+  const patternNode = ctx.nodes.pattern(ctx);
+  if (patternNode) ctx.chain.current = patternNode;
 
-  return chain;
+  return ctx.chain.current;
+}
+
+export const stringToNode = ({
+  plugin,
+  schema,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'string'>;
+}): Chain => {
+  const z = plugin.external('zod.z');
+  const ctx: StringResolverContext = {
+    $,
+    chain: {
+      current: $(z),
+    },
+    nodes: {
+      base: baseNode,
+      const: constNode,
+      format: formatNode,
+      length: lengthNode,
+      maxLength: maxLengthNode,
+      minLength: minLengthNode,
+      pattern: patternNode,
+    },
+    plugin,
+    schema,
+    symbols: {
+      z,
+    },
+  };
+  const resolver = plugin.config['~resolvers']?.string;
+  const node = resolver?.(ctx) ?? stringResolver(ctx);
+  return node;
 };

packages/openapi-ts/src/plugins/zod/v4/api.ts

···
 
 import { identifiers } from '../constants';
 import type { ValidatorArgs } from '../shared/types';
-import type { ValidatorResolverArgs } from '../types';
+import type { ValidatorResolverContext } from '../types';
 
-const defaultValidatorResolver = ({
-  schema,
-}: ValidatorResolverArgs): ReturnType<typeof $.return> =>
-  $(schema).attr(identifiers.parseAsync).call('data').await().return();
+const validatorResolver = (
+  ctx: ValidatorResolverContext,
+): ReturnType<typeof $.return> => {
+  const { schema } = ctx.symbols;
+  return $(schema).attr(identifiers.parseAsync).call('data').await().return();
+};
 
 export const createRequestValidatorV4 = ({
   operation,
···
   });
   if (!symbol) return;
 
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.request;
-  const candidates = [resolver, defaultValidatorResolver];
+  const candidates = [resolver, validatorResolver];
   for (const candidate of candidates) {
-    const statements = candidate?.(args);
+    const statements = candidate?.(ctx);
     if (statements === null) return;
     if (statements !== undefined) {
       return $.func()
···
   });
   if (!symbol) return;
 
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.response;
-  const candidates = [resolver, defaultValidatorResolver];
+  const candidates = [resolver, validatorResolver];
   for (const candidate of candidates) {
-    const statements = candidate?.(args);
+    const statements = candidate?.(ctx);
     if (statements === null) return;
     if (statements !== undefined) {
       return $.func()

packages/openapi-ts/src/plugins/zod/v4/toAst/index.ts

···
 import { enumToAst } from './enum';
 import { neverToAst } from './never';
 import { nullToAst } from './null';
-import { numberToAst } from './number';
+import { numberToNode } from './number';
 import { objectToAst } from './object';
-import { stringToAst } from './string';
+import { stringToNode } from './string';
 import { tupleToAst } from './tuple';
 import { undefinedToAst } from './undefined';
 import { unknownToAst } from './unknown';
···
       });
     case 'integer':
     case 'number':
-      return numberToAst({
+      return numberToNode({
         ...args,
         schema: schema as SchemaWithType<'integer' | 'number'>,
       });
···
       });
     case 'string':
       return shouldCoerceToBigInt(schema.format)
-        ? numberToAst({
+        ? numberToNode({
             ...args,
             schema: { ...schema, type: 'number' },
           })
-        : stringToAst({
+        : stringToNode({
             ...args,
             schema: schema as SchemaWithType<'string'>,
           });

packages/openapi-ts/src/plugins/zod/v4/toAst/number.ts

···
 import { $ } from '~/ts-dsl';
 
 import { identifiers } from '../../constants';
+import type { Chain } from '../../shared/chain';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
+import type { NumberResolverContext } from '../../types';
 
-export const numberToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'integer' | 'number'>;
-}): Omit<Ast, 'typeName'> => {
-  const result: Partial<Omit<Ast, 'typeName'>> = {};
+function baseNode(ctx: NumberResolverContext): Chain {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (ctx.utils.shouldCoerceToBigInt(schema.format)) {
+    return $(z).attr(identifiers.coerce).attr(identifiers.bigint).call();
+  }
+  let chain = $(z).attr(identifiers.number).call();
+  if (schema.type === 'integer') {
+    chain = $(z).attr(identifiers.int).call();
+  }
+  return chain;
+}
 
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
+function constNode(ctx: NumberResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (schema.const === undefined) return;
+  return $(z)
+    .attr(identifiers.literal)
+    .call(ctx.utils.maybeBigInt(schema.const, schema.format));
+}
 
-  if (schema.const !== undefined) {
-    result.expression = $(z)
-      .attr(identifiers.literal)
-      .call(maybeBigInt(schema.const, schema.format));
-    return result as Omit<Ast, 'typeName'>;
+function maxNode(ctx: NumberResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
+  if (schema.exclusiveMaximum !== undefined) {
+    return chain.current
+      .attr(identifiers.lt)
+      .call(ctx.utils.maybeBigInt(schema.exclusiveMaximum, schema.format));
   }
-
-  if (shouldCoerceToBigInt(schema.format)) {
-    result.expression = $(z)
-      .attr(identifiers.coerce)
-      .attr(identifiers.bigint)
-      .call();
-  } else {
-    result.expression = $(z).attr(identifiers.number).call();
-    if (schema.type === 'integer') {
-      result.expression = $(z).attr(identifiers.int).call();
-    }
+  if (schema.maximum !== undefined) {
+    return chain.current
+      .attr(identifiers.lte)
+      .call(ctx.utils.maybeBigInt(schema.maximum, schema.format));
   }
-
-  const integerLimit = getIntegerLimit(schema.format);
-  if (integerLimit) {
-    result.expression = result.expression
-      .attr(identifiers.min)
-      .call(
-        maybeBigInt(integerLimit.minValue, schema.format),
-        $.object().prop('error', $.literal(integerLimit.minError)),
-      )
+  const limit = ctx.utils.getIntegerLimit(schema.format);
+  if (limit) {
+    return chain.current
       .attr(identifiers.max)
       .call(
-        maybeBigInt(integerLimit.maxValue, schema.format),
-        $.object().prop('error', $.literal(integerLimit.maxError)),
+        ctx.utils.maybeBigInt(limit.maxValue, schema.format),
+        $.object().prop('error', $.literal(limit.maxError)),
       );
   }
+  return;
+}
 
+function minNode(ctx: NumberResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
   if (schema.exclusiveMinimum !== undefined) {
-    result.expression = result.expression
+    return chain.current
       .attr(identifiers.gt)
-      .call(maybeBigInt(schema.exclusiveMinimum, schema.format));
-  } else if (schema.minimum !== undefined) {
-    result.expression = result.expression
+      .call(ctx.utils.maybeBigInt(schema.exclusiveMinimum, schema.format));
+  }
+  if (schema.minimum !== undefined) {
+    return chain.current
       .attr(identifiers.gte)
-      .call(maybeBigInt(schema.minimum, schema.format));
+      .call(ctx.utils.maybeBigInt(schema.minimum, schema.format));
+  }
+  const limit = ctx.utils.getIntegerLimit(schema.format);
+  if (limit) {
+    return chain.current
+      .attr(identifiers.min)
+      .call(
+        ctx.utils.maybeBigInt(limit.minValue, schema.format),
+        $.object().prop('error', $.literal(limit.minError)),
+      );
   }
+  return;
+}
 
-  if (schema.exclusiveMaximum !== undefined) {
-    result.expression = result.expression
-      .attr(identifiers.lt)
-      .call(maybeBigInt(schema.exclusiveMaximum, schema.format));
-  } else if (schema.maximum !== undefined) {
-    result.expression = result.expression
-      .attr(identifiers.lte)
-      .call(maybeBigInt(schema.maximum, schema.format));
+function numberResolver(ctx: NumberResolverContext): Chain {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) {
+    ctx.chain.current = constNode;
+    return ctx.chain.current;
   }
 
-  return result as Omit<Ast, 'typeName'>;
+  const baseNode = ctx.nodes.base(ctx);
+  if (baseNode) ctx.chain.current = baseNode;
+
+  const minNode = ctx.nodes.min(ctx);
+  if (minNode) ctx.chain.current = minNode;
+
+  const maxNode = ctx.nodes.max(ctx);
+  if (maxNode) ctx.chain.current = maxNode;
+
+  return ctx.chain.current;
+}
+
+export const numberToNode = ({
+  plugin,
+  schema,
+  state,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'integer' | 'number'>;
+}): Omit<Ast, 'typeName'> => {
+  const ast: Partial<Omit<Ast, 'typeName'>> = {};
+  const z = plugin.external('zod.z');
+  const ctx: NumberResolverContext = {
+    $,
+    chain: {
+      current: $(z),
+    },
+    nodes: {
+      base: baseNode,
+      const: constNode,
+      max: maxNode,
+      min: minNode,
+    },
+    plugin,
+    schema,
+    symbols: {
+      z,
+    },
+    utils: {
+      ast,
+      getIntegerLimit,
+      maybeBigInt,
+      shouldCoerceToBigInt,
+      state,
+    },
+  };
+  const resolver = plugin.config['~resolvers']?.number;
+  const node = resolver?.(ctx) ?? numberResolver(ctx);
+  ast.expression = node;
+  return ast as Omit<Ast, 'typeName'>;
 };

packages/openapi-ts/src/plugins/zod/v4/toAst/object.ts

···
 import { $ } from '~/ts-dsl';
 
 import { identifiers } from '../../constants';
+import type { Chain } from '../../shared/chain';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
-import type { ObjectBaseResolverArgs } from '../../types';
+import type { ObjectResolverContext } from '../../types';
 import { irSchemaToAst } from '../plugin';
 
-function defaultObjectBaseResolver({
-  additional,
-  plugin,
-  shape,
-}: ObjectBaseResolverArgs): ReturnType<typeof $.call> {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
+function additionalPropertiesNode(
+  ctx: ObjectResolverContext,
+): Chain | null | undefined {
+  const { plugin, schema } = ctx;
+
+  if (
+    !schema.additionalProperties ||
+    (schema.properties && Object.keys(schema.properties).length > 0)
+  )
+    return;
+
+  const additionalAst = irSchemaToAst({
+    plugin,
+    schema: schema.additionalProperties,
+    state: {
+      ...ctx.utils.state,
+      path: ref([...fromRef(ctx.utils.state.path), 'additionalProperties']),
+    },
   });
+  if (additionalAst.hasLazyExpression) ctx.utils.ast.hasLazyExpression = true;
+  return additionalAst.expression;
+}
+
+function baseNode(ctx: ObjectResolverContext): Chain {
+  const { nodes, symbols } = ctx;
+  const { z } = symbols;
+
+  const additional = nodes.additionalProperties(ctx);
+  const shape = nodes.shape(ctx);
 
   if (additional) {
     return $(z)
···
   return $(z).attr(identifiers.object).call(shape);
 }
 
-export const objectToAst = ({
-  plugin,
-  schema,
-  state,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'object'>;
-}): Omit<Ast, 'typeName'> => {
-  const result: Partial<Omit<Ast, 'typeName'>> = {};
-
+function objectResolver(ctx: ObjectResolverContext): Chain {
   // TODO: parser - handle constants
+  return ctx.nodes.base(ctx);
+}
 
+function shapeNode(ctx: ObjectResolverContext): ReturnType<typeof $.object> {
+  const { plugin, schema } = ctx;
   const shape = $.object().pretty();
-  const required = schema.required ?? [];
 
   for (const name in schema.properties) {
     const property = schema.properties[name]!;
-    const isRequired = required.includes(name);
 
     const propertyAst = irSchemaToAst({
-      optional: !isRequired,
+      optional: !schema.required?.includes(name),
       plugin,
       schema: property,
       state: {
-        ...state,
-        path: ref([...fromRef(state.path), 'properties', name]),
+        ...ctx.utils.state,
+        path: ref([...fromRef(ctx.utils.state.path), 'properties', name]),
       },
     });
     if (propertyAst.hasLazyExpression) {
-      result.hasLazyExpression = true;
-    }
-
-    if (propertyAst.hasLazyExpression) {
+      ctx.utils.ast.hasLazyExpression = true;
       shape.getter(name, propertyAst.expression.return());
     } else {
       shape.prop(name, propertyAst.expression);
     }
   }
 
-  let additional: ReturnType<typeof $.call | typeof $.expr> | null | undefined;
-  if (
-    schema.additionalProperties &&
-    (!schema.properties || !Object.keys(schema.properties).length)
-  ) {
-    const additionalAst = irSchemaToAst({
-      plugin,
-      schema: schema.additionalProperties,
-      state: {
-        ...state,
-        path: ref([...fromRef(state.path), 'additionalProperties']),
-      },
-    });
-    if (additionalAst.hasLazyExpression) result.hasLazyExpression = true;
-    additional = additionalAst.expression;
-  }
+  return shape;
+}
 
-  const args: ObjectBaseResolverArgs = {
+export const objectToAst = ({
+  plugin,
+  schema,
+  state,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'object'>;
+}): Omit<Ast, 'typeName'> => {
+  const ast: Partial<Omit<Ast, 'typeName'>> = {};
+  const z = plugin.external('zod.z');
+  const ctx: ObjectResolverContext = {
     $,
-    additional,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
+    nodes: {
+      additionalProperties: additionalPropertiesNode,
+      base: baseNode,
+      shape: shapeNode,
+    },
     plugin,
     schema,
-    shape,
+    symbols: {
+      z,
+    },
+    utils: {
+      ast,
+      state,
+    },
   };
-  const resolver = plugin.config['~resolvers']?.object?.base;
-  const chain = resolver?.(args) ?? defaultObjectBaseResolver(args);
-  result.expression = chain;
-
-  // Return with typeName for circular references
-  if (result.hasLazyExpression) {
-    return {
-      ...result,
-      typeName: 'ZodType',
-    } as Ast;
-  }
-
-  return result as Omit<Ast, 'typeName'>;
+  const resolver = plugin.config['~resolvers']?.object;
+  const node = resolver?.(ctx) ?? objectResolver(ctx);
+  ast.expression = node;
+  return ast as Omit<Ast, 'typeName'>;
 };

packages/openapi-ts/src/plugins/zod/v4/toAst/string.ts

···
 import { $ } from '~/ts-dsl';
 
 import { identifiers } from '../../constants';
+import type { Chain } from '../../shared/chain';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/types';
-import type { FormatResolverArgs } from '../../types';
+import type { StringResolverContext } from '../../types';
+
+function baseNode(ctx: StringResolverContext): Chain {
+  const { z } = ctx.symbols;
+  return $(z).attr(identifiers.string).call();
+}
+
+function constNode(ctx: StringResolverContext): Chain | undefined {
+  const { schema, symbols } = ctx;
+  const { z } = symbols;
+  if (typeof schema.const !== 'string') return;
+  return $(z).attr(identifiers.literal).call($.literal(schema.const));
+}
 
-const defaultFormatResolver = ({
-  chain,
-  plugin,
-  schema,
-}: FormatResolverArgs): ReturnType<typeof $.call> => {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
+function formatNode(ctx: StringResolverContext): Chain | undefined {
+  const { plugin, schema, symbols } = ctx;
+  const { z } = symbols;
 
   switch (schema.format) {
     case 'date':
···
       return $(z).attr(identifiers.url).call();
     case 'uuid':
       return $(z).attr(identifiers.uuid).call();
-    default:
-      return chain;
   }
-};
 
-export const stringToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'string'>;
-}): Omit<Ast, 'typeName'> => {
-  const result: Partial<Omit<Ast, 'typeName'>> = {};
-  let chain: ReturnType<typeof $.call>;
+  return;
+}
+
+function lengthNode(ctx: StringResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
+  if (schema.minLength === undefined || schema.minLength !== schema.maxLength)
+    return;
+  return chain.current
+    .attr(identifiers.length)
+    .call($.literal(schema.minLength));
+}
+
+function maxLengthNode(ctx: StringResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
+  if (schema.maxLength === undefined) return;
+  return chain.current.attr(identifiers.max).call($.literal(schema.maxLength));
+}
+
+function minLengthNode(ctx: StringResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
+  if (schema.minLength === undefined) return;
+  return chain.current.attr(identifiers.min).call($.literal(schema.minLength));
+}
 
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
+function patternNode(ctx: StringResolverContext): Chain | undefined {
+  const { chain, schema } = ctx;
+  if (!schema.pattern) return;
+  return chain.current.attr(identifiers.regex).call($.regexp(schema.pattern));
+}
 
-  if (typeof schema.const === 'string') {
-    chain = $(z).attr(identifiers.literal).call($.literal(schema.const));
-    result.expression = chain;
-    return result as Omit<Ast, 'typeName'>;
+function stringResolver(ctx: StringResolverContext): Chain {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) {
+    ctx.chain.current = constNode;
+    return ctx.chain.current;
   }
 
-  chain = $(z).attr(identifiers.string).call();
+  const baseNode = ctx.nodes.base(ctx);
+  if (baseNode) ctx.chain.current = baseNode;
 
-  if (schema.format) {
-    const args: FormatResolverArgs = { $, chain, plugin, schema };
-    const resolver =
-      plugin.config['~resolvers']?.string?.formats?.[schema.format];
-    chain = resolver?.(args) ?? defaultFormatResolver(args);
-  }
+  const formatNode = ctx.nodes.format(ctx);
+  if (formatNode) ctx.chain.current = formatNode;
 
-  if (schema.minLength === schema.maxLength && schema.minLength !== undefined) {
-    chain = chain.attr(identifiers.length).call($.literal(schema.minLength));
+  const lengthNode = ctx.nodes.length(ctx);
+  if (lengthNode) {
+    ctx.chain.current = lengthNode;
   } else {
-    if (schema.minLength !== undefined) {
-      chain = chain.attr(identifiers.min).call($.literal(schema.minLength));
-    }
+    const minLengthNode = ctx.nodes.minLength(ctx);
+    if (minLengthNode) ctx.chain.current = minLengthNode;
 
-    if (schema.maxLength !== undefined) {
-      chain = chain.attr(identifiers.max).call($.literal(schema.maxLength));
-    }
+    const maxLengthNode = ctx.nodes.maxLength(ctx);
+    if (maxLengthNode) ctx.chain.current = maxLengthNode;
   }
 
-  if (schema.pattern) {
-    chain = chain.attr(identifiers.regex).call($.regexp(schema.pattern));
-  }
+  const patternNode = ctx.nodes.pattern(ctx);
+  if (patternNode) ctx.chain.current = patternNode;
+
+  return ctx.chain.current;
+}
 
-  result.expression = chain;
-  return result as Omit<Ast, 'typeName'>;
+export const stringToNode = ({
+  plugin,
+  schema,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'string'>;
+}): Omit<Ast, 'typeName'> => {
+  const z = plugin.external('zod.z');
+  const ctx: StringResolverContext = {
+    $,
+    chain: {
+      current: $(z),
+    },
+    nodes: {
+      base: baseNode,
+      const: constNode,
+      format: formatNode,
+      length: lengthNode,
+      maxLength: maxLengthNode,
+      minLength: minLengthNode,
+      pattern: patternNode,
+    },
+    plugin,
+    schema,
+    symbols: {
+      z,
+    },
+  };
+  const resolver = plugin.config['~resolvers']?.string;
+  const node = resolver?.(ctx) ?? stringResolver(ctx);
+  return {
+    expression: node,
+  };
 };