refactor: clean up zod resolvers

dev/openapi-ts.config.ts

···
             //   return $(v).attr('instance').call(big);
             // },
             // object(ctx) {
-            //   const { $ } = ctx;
+            //   const { $, symbols } = ctx;
+            //   const { v } = symbols;
             //   const additional = ctx.nodes.additionalProperties(ctx);
-            //   const shape = ctx.nodes.shape(ctx);
             //   if (additional === undefined) {
-            //     return $('v').attr('looseObject').call(shape);
+            //     const shape = ctx.nodes.shape(ctx);
+            //     ctx.nodes.base = () => $(v).attr('looseObject').call(shape);
             //   }
-            //   return;
             // },
             // string(ctx) {
-            //   const { $, schema } = ctx;
+            //   const { $, schema, symbols } = ctx;
+            //   const { v } = symbols;
             //   if (schema.format === 'date' || schema.format === 'date-time') {
-            //     ctx.nodes.format = () => $('v').attr('isoDateTime').call();
+            //     ctx.nodes.format = () => $(v).attr('isoDateTime').call();
             //   }
             // },
             // validator(ctx) {
···
         {
           // 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;
-              // },
+            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: {
-              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'))
-                // ),
-              },
+            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 [

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

···
    */
   pipes: PipesUtils & {
     /**
-     * The current builder state being processed by this resolver.
+     * The current pipe.
      *
-     * In Valibot, this represents the current list of call expressions ("pipes")
+     * 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 how the
-     * resulting schema is constructed.
+     * 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 Valibot plugin.
+   * Provides access to commonly used symbols within the plugin.
    */
   symbols: {
     v: Symbol;
···
 export interface ValidatorResolverContext extends BaseResolverContext {
   operation: IR.Operation;
   /**
-   * Provides access to commonly used symbols within the Valibot plugin.
+   * Provides access to commonly used symbols within the plugin.
    */
   symbols: BaseResolverContext['symbols'] & {
     schema: Symbol;
···
 }
 
 type ValidatorResolver = (
-  args: ValidatorResolverContext,
+  ctx: ValidatorResolverContext,
 ) => PipeResult | null | undefined;
 
 type Resolvers = Plugin.Resolvers<{
···
    *
    * Returning `undefined` will execute the default resolver logic.
    */
-  number?: (args: NumberResolverContext) => PipeResult | undefined;
+  number?: (ctx: NumberResolverContext) => PipeResult | undefined;
   /**
    * Resolver for object schemas.
    *

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

···
 }
 
 function constNode(ctx: StringResolverContext): PipeResult | undefined {
-  const { schema } = ctx;
-  const { v } = ctx.symbols;
+  const { schema, symbols } = ctx;
+  const { v } = symbols;
   if (typeof schema.const !== 'string') return;
   return $(v).attr(identifiers.schemas.literal).call($.literal(schema.const));
 }

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 validatorResolver = ({
-  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 z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
-    z,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.request;
   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 z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
-    z,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.response;
   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/index.ts

···
 import { nullToAst } from './null';
 import { numberToAst } 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';
···
             ...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';
 
 export const numberToAst = ({
···
     }
   }
 
-  const checks: Array<ReturnType<typeof $.call>> = [];
+  const checks: Array<Chain> = [];
 
   let hasLowerBound = false;
   let hasUpperBound = false;

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 defaultBaseResolver({
-  additional,
-  shape,
-  z,
-}: ObjectBaseResolverArgs): ReturnType<typeof $.call> {
+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)
···
   return $(z).attr(identifiers.object).call(shape);
 }
 
-export const objectToAst = ({
-  plugin,
-  schema,
-  state,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'object'>;
-}): Omit<Ast, 'typeName'> => {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-
-  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,
-    z,
+    symbols: {
+      z,
+    },
+    utils: {
+      ast,
+      state,
+    },
   };
-  const resolver = plugin.config['~resolvers']?.object?.base;
-  const chain = resolver?.(args) ?? defaultBaseResolver(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;
   }
-};
+
+  return;
+}
+
+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));
+}
 
-export const stringToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'string'>;
-}): Omit<Ast, 'typeName'> => {
-  const result: Partial<Omit<Ast, 'typeName'>> = {};
-  let chain: ReturnType<typeof $.call>;
+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));
+}
 
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
+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));
+}
 
-  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, z };
-    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) {
-    chain = chain.attr(identifiers.check).call(...checks);
+    ctx.chain.current = ctx.chain.current
+      .attr(identifiers.check)
+      .call(...checks);
   }
 
-  result.expression = chain;
-  return result as Omit<Ast, 'typeName'>;
+  return ctx.chain.current;
+}
+
+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 { $, 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'];
-  z: Symbol;
-};
+  /**
+   * Provides access to commonly used symbols within the plugin.
+   */
+  symbols: {
+    z: Symbol;
+  };
+}
 
-export type FormatResolverArgs = Required<SharedResolverArgs> & {
-  schema: IR.SchemaObject;
-};
-
-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>;
+  };
+}
 
 type ResolverResult = boolean | number;
 
-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.
    *
-   * Allows customization of how number types are rendered, including
-   * per-format handling.
+   * Returning `undefined` will execute the default resolver logic.
    */
   number?: {
     /**
···
      *
      * Returning `undefined` will execute the default resolver logic.
      */
-    base?: (args: FormatResolverArgs) => ResolverResult | undefined;
+    base?: (ctx: StringResolverContext) => ResolverResult | undefined;
     /**
      * Resolvers for number formats (e.g., `float`, `double`, `int32`).
      *
···
      */
     formats?: Record<
       string,
-      (args: FormatResolverArgs) => ResolverResult | undefined
+      (ctx: StringResolverContext) => ResolverResult | 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.
    *
-   * Allows customization of how string types are rendered, including
-   * per-format handling.
+   * 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 validatorResolver = ({
-  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 z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
-    z,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.request;
   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 z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
-    z,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.response;
   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 { nullToAst } from './null';
 import { numberToAst } 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';
···
               ...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 { Chain } from '../../shared/chain';
 import type { IrSchemaToAstOptions } from '../../shared/types';
 
 export const numberToAst = ({
···
     return expression;
   }
 
-  let numberExpression: ReturnType<typeof $.call>;
+  let numberExpression: Chain;
 
   if (shouldCoerceToBigInt(schema.format)) {
     numberExpression = $(z)

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 defaultBaseResolver({
-  additional,
-  shape,
-  z,
-}: ObjectBaseResolverArgs): ReturnType<typeof $.call> {
+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;
-} => {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-
-  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,
-    z,
+    symbols: {
+      z,
+    },
+    utils: {
+      ast,
+      state,
+    },
   };
-  const resolver = plugin.config['~resolvers']?.object?.base;
-  const chain = resolver?.(args) ?? defaultBaseResolver(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, z };
-    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 validatorResolver = ({
-  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 z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
-    z,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.request;
   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 z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-  const args: ValidatorResolverArgs = {
+  const z = plugin.external('zod.z');
+  const ctx: ValidatorResolverContext = {
     $,
-    chain: undefined,
+    chain: {
+      current: $(z),
+    },
     operation,
     plugin,
-    schema: symbol,
-    z,
+    symbols: {
+      schema: symbol,
+      z,
+    },
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
     typeof validator === 'function' ? validator : validator?.response;
   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 { nullToAst } from './null';
 import { numberToAst } 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';
···
             ...args,
             schema: { ...schema, type: 'number' },
           })
-        : stringToAst({
+        : stringToNode({
             ...args,
             schema: schema as SchemaWithType<'string'>,
           });

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 defaultBaseResolver({
-  additional,
-  shape,
-  z,
-}: ObjectBaseResolverArgs): ReturnType<typeof $.call> {
+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)
···
   return $(z).attr(identifiers.object).call(shape);
 }
 
-export const objectToAst = ({
-  plugin,
-  schema,
-  state,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'object'>;
-}): Omit<Ast, 'typeName'> => {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-
-  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,
-    z,
+    symbols: {
+      z,
+    },
+    utils: {
+      ast,
+      state,
+    },
   };
-  const resolver = plugin.config['~resolvers']?.object?.base;
-  const chain = resolver?.(args) ?? defaultBaseResolver(args);
-  result.expression = chain;
-
+  const resolver = plugin.config['~resolvers']?.object;
+  const node = resolver?.(ctx) ?? objectResolver(ctx);
+  ast.expression = node;
   // Return with typeName for circular references
-  if (result.hasLazyExpression) {
+  if (ast.hasLazyExpression) {
     return {
-      ...result,
+      ...ast,
       typeName: 'ZodType',
     } as Ast;
   }
-
-  return result as Omit<Ast, 'typeName'>;
+  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));
+}
+
+function formatNode(ctx: StringResolverContext): Chain | undefined {
+  const { plugin, schema, symbols } = ctx;
+  const { z } = symbols;
 
-const defaultFormatResolver = ({
-  chain,
-  plugin,
-  schema,
-  z,
-}: FormatResolverArgs): ReturnType<typeof $.call> => {
   switch (schema.format) {
     case 'date':
       return $(z).attr(identifiers.iso).attr(identifiers.date).call();
···
       return $(z).attr(identifiers.url).call();
     case 'uuid':
       return $(z).attr(identifiers.uuid).call();
-    default:
-      return chain;
   }
-};
+
+  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));
+}
 
-export const stringToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'string'>;
-}): Omit<Ast, 'typeName'> => {
-  const result: Partial<Omit<Ast, 'typeName'>> = {};
-  let chain: ReturnType<typeof $.call>;
+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));
+}
 
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
+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 (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 { 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;
   }
 
-  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, z };
-    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;
 
-  result.expression = chain;
-  return result as Omit<Ast, 'typeName'>;
+  return ctx.chain.current;
+}
+
+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,
+  };
 };