feat: add number base resolvers

dev/openapi-ts.config.ts

···
             },
           },
           '~resolvers': {
-            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'),
-                      ),
-                    );
-              }
-            },
+            // 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(

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/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 { stringToNode } from './string';
 import { tupleToAst } from './tuple';
···
       });
     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' },
           })

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

···
 import { identifiers } from '../../constants';
 import type { Chain } from '../../shared/chain';
 import type { Ast, IrSchemaToAstOptions } from '../../shared/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',
-  });
+import type { NumberResolverContext } from '../../types';
 
-  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<Chain> = [];
+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));
+}
 
-  let hasLowerBound = false;
-  let hasUpperBound = false;
+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)),
-    );
-    hasLowerBound = true;
-  } else if (schema.minimum !== undefined) {
-    checks.push(
-      $(z)
-        .attr(identifiers.gte)
-        .call(maybeBigInt(schema.minimum, schema.format)),
-    );
-    hasLowerBound = true;
+    return $(z)
+      .attr(identifiers.gt)
+      .call(ctx.utils.maybeBigInt(schema.exclusiveMinimum, schema.format));
   }
-
-  if (schema.exclusiveMaximum !== undefined) {
-    checks.push(
-      $(z)
-        .attr(identifiers.lt)
-        .call(maybeBigInt(schema.exclusiveMaximum, schema.format)),
-    );
-    hasUpperBound = true;
-  } else if (schema.maximum !== undefined) {
-    checks.push(
-      $(z)
-        .attr(identifiers.lte)
-        .call(maybeBigInt(schema.maximum, schema.format)),
-    );
-    hasUpperBound = true;
+  if (schema.minimum !== undefined) {
+    return $(z)
+      .attr(identifiers.gte)
+      .call(ctx.utils.maybeBigInt(schema.minimum, schema.format));
   }
-
-  const integerLimit = getIntegerLimit(schema.format);
-  if (integerLimit) {
-    if (!hasLowerBound) {
-      checks.push(
-        $(z)
-          .attr(identifiers.minimum)
-          .call(
-            maybeBigInt(integerLimit.minValue, schema.format),
-            $.object().prop('error', $.literal(integerLimit.minError)),
-          ),
+  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)),
       );
-      hasLowerBound = true;
-    }
+  }
+  return;
+}
 
-    if (!hasUpperBound) {
-      checks.push(
-        $(z)
-          .attr(identifiers.maximum)
-          .call(
-            maybeBigInt(integerLimit.maxValue, schema.format),
-            $.object().prop('error', $.literal(integerLimit.maxError)),
-          ),
-      );
-      hasUpperBound = true;
-    }
+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/string.ts

···
   const patternNode = ctx.nodes.pattern(ctx);
   if (patternNode) checks.push(patternNode);
 
-  if (checks.length) {
+  if (checks.length > 0) {
     ctx.chain.current = ctx.chain.current
       .attr(identifiers.check)
       .call(...checks);

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

···
 
 import type { IR } from '~/ir/types';
 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';
···
   };
 }
 
+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 interface ObjectResolverContext extends BaseResolverContext {
   /**
    * Nodes used to build different parts of the object schema.
···
     state: Refs<PluginState>;
   };
 }
-
-type ResolverResult = boolean | number;
 
 export interface StringResolverContext extends BaseResolverContext {
   /**
···
    *
    * Returning `undefined` will execute the default resolver logic.
    */
-  number?: {
-    /**
-     * Controls the base segment for number schemas.
-     *
-     * Returning `undefined` will execute the default resolver logic.
-     */
-    base?: (ctx: StringResolverContext) => ResolverResult | undefined;
-    /**
-     * 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,
-      (ctx: StringResolverContext) => ResolverResult | undefined
-    >;
-  };
+  number?: (ctx: NumberResolverContext) => Chain | undefined;
   /**
    * Resolver for object schemas.
    *

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 { stringToNode } from './string';
 import { tupleToAst } from './tuple';
···
     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' },
             })

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

···
 
 import { identifiers } from '../../constants';
 import type { Chain } from '../../shared/chain';
-import type { IrSchemaToAstOptions } from '../../shared/types';
+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: Chain;
+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));
   }
-
-  let hasLowerBound = false;
-  let hasUpperBound = false;
+  const limit = ctx.utils.getIntegerLimit(schema.format);
+  if (limit) {
+    return chain.current
+      .attr(identifiers.max)
+      .call(
+        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));
-    hasLowerBound = true;
-  } 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));
-    hasLowerBound = true;
+      .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));
-    hasUpperBound = true;
-  } else if (schema.maximum !== undefined) {
-    numberExpression = numberExpression
-      .attr(identifiers.lte)
-      .call(maybeBigInt(schema.maximum, schema.format));
-    hasUpperBound = true;
+function numberResolver(ctx: NumberResolverContext): Chain {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) {
+    ctx.chain.current = constNode;
+    return ctx.chain.current;
   }
 
-  const integerLimit = getIntegerLimit(schema.format);
-  if (integerLimit) {
-    if (!hasLowerBound) {
-      numberExpression = numberExpression
-        .attr(identifiers.min)
-        .call(
-          maybeBigInt(integerLimit.minValue, schema.format),
-          $.object().prop('message', $.literal(integerLimit.minError)),
-        );
-      hasLowerBound = true;
-    }
+  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;
 
-    if (!hasUpperBound) {
-      numberExpression = numberExpression
-        .attr(identifiers.max)
-        .call(
-          maybeBigInt(integerLimit.maxValue, schema.format),
-          $.object().prop('message', $.literal(integerLimit.maxError)),
-        );
-      hasUpperBound = true;
-    }
-  }
+  return ctx.chain.current;
+}
 
-  return numberExpression;
+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/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 { stringToNode } from './string';
 import { tupleToAst } from './tuple';
···
       });
     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' },
           })

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));
   }
-
-  let hasLowerBound = false;
-  let hasUpperBound = false;
+  const limit = ctx.utils.getIntegerLimit(schema.format);
+  if (limit) {
+    return chain.current
+      .attr(identifiers.max)
+      .call(
+        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));
-    hasLowerBound = true;
-  } 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));
-    hasLowerBound = true;
+      .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));
-    hasUpperBound = true;
-  } else if (schema.maximum !== undefined) {
-    result.expression = result.expression
-      .attr(identifiers.lte)
-      .call(maybeBigInt(schema.maximum, schema.format));
-    hasUpperBound = true;
+function numberResolver(ctx: NumberResolverContext): Chain {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) {
+    ctx.chain.current = constNode;
+    return ctx.chain.current;
   }
 
-  const integerLimit = getIntegerLimit(schema.format);
-  if (integerLimit) {
-    if (!hasLowerBound) {
-      result.expression = result.expression
-        .attr(identifiers.min)
-        .call(
-          maybeBigInt(integerLimit.minValue, schema.format),
-          $.object().prop('error', $.literal(integerLimit.minError)),
-        );
-      hasLowerBound = true;
-    }
+  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;
 
-    if (!hasUpperBound) {
-      result.expression = result.expression
-        .attr(identifiers.max)
-        .call(
-          maybeBigInt(integerLimit.maxValue, schema.format),
-          $.object().prop('error', $.literal(integerLimit.maxError)),
-        );
-      hasUpperBound = true;
-    }
-  }
+  return ctx.chain.current;
+}
 
-  return result as Omit<Ast, 'typeName'>;
+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

···
   const resolver = plugin.config['~resolvers']?.object;
   const node = resolver?.(ctx) ?? objectResolver(ctx);
   ast.expression = node;
-  // Return with typeName for circular references
-  if (ast.hasLazyExpression) {
-    return {
-      ...ast,
-      typeName: 'ZodType',
-    } as Ast;
-  }
   return ast as Omit<Ast, 'typeName'>;
 };