refactor: clean up valibot resolvers

dev/openapi-ts.config.ts

···
             },
           },
           '~resolvers': {
-            number: {
-              // base({ $, pipes, v }) {
-              //   return pipes.push($(v).attr('test').call());
-              // },
-              formats: {
-                // date: ({ $, pipes }) => pipes.push($('v').attr('isoDateTime').call()),
-                // 'date-time': ({ $, pipes }) => pipes.push($('v').attr('isoDateTime').call()),
-              },
-            },
-            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 } = ctx;
+              const { v } = ctx.symbols;
+              const big = plugin.symbolOnce('Big', {
+                external: 'big.js',
+                importKind: 'default',
+                meta: {
+                  category: 'external',
+                  resource: 'big.js',
+                },
+              });
+              return $(v).attr('instance').call(big);
             },
+            // object(ctx) {
+            //   const { $ } = ctx;
+            //   const additional = ctx.nodes.additionalProperties(ctx);
+            //   const shape = ctx.nodes.shape(ctx);
+            //   if (additional === undefined) {
+            //     return $('v').attr('looseObject').call(shape);
+            //   }
+            //   return;
+            // },
+            // string(ctx) {
+            //   const { $, schema } = ctx;
+            //   if (schema.format === 'date' || schema.format === 'date-time') {
+            //     ctx.nodes.format = () => $('v').attr('isoDateTime').call();
+            //   }
+            //   return;
+            // },
             // validator({ $, plugin, schema, v }) {
             //   const vShadow = plugin.symbol('v');
             //   const test = plugin.symbol('test');

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 existing = symbol?.meta ? this.querySymbol(symbol.meta) : undefined;
+    if (existing) return existing;
+    return this.symbol(name, symbol);
   }
 
   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: PushPipes;
+  toNode: PipesToNode;
+}
+
+/**
+ * Functions for working with pipes.
+ */
+export const pipes: PipesUtils = {
+  /**
+   * Push pipes into target array.
+   */
+  push: pushPipes,
+  /**
+   * Convert pipes to a single node.
+   */
+  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 { 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 { Pipe, PipeResult, PipesUtils } from './shared/pipes';
+import type { Ast, PluginState } from './shared/types';
 
 export type UserConfig = Plugin.Name<'valibot'> &
   Plugin.Hooks &
···
 
 type SharedResolverArgs = DollarTsDsl & {
   /**
+   * Functions for working with pipes.
+   */
+  pipes: PipesUtils;
+  plugin: ValibotPlugin['Instance'];
+  /**
    * 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.
+   * resulting schema is constructed.
    */
-  pipes: Array<ReturnType<typeof $.call>>;
-  plugin: ValibotPlugin['Instance'];
-  v: Symbol;
+  result: Pipes;
+  /**
+   * Provides access to commonly used symbols within the Valibot plugin.
+   */
+  symbols: {
+    v: Symbol;
+  };
 };
 
-export type FormatResolverArgs = SharedResolverArgs & {
-  schema: IR.SchemaObject;
+export type NumberResolverContext = SharedResolverArgs & {
+  /**
+   * 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 type ObjectResolverContext = SharedResolverArgs & {
+  /**
+   * 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>;
+  };
 };
 
-type ResolverResult = boolean | number;
+export type StringResolverContext = SharedResolverArgs & {
+  /**
+   * 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 type ValidatorResolverArgs = SharedResolverArgs & {
   operation: IR.Operation;
···
 
 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?: {
-    /**
-     * Controls the base segment for number schemas.
-     *
-     * Returning `undefined` will execute the default resolver logic.
-     */
-    base?: (args: FormatResolverArgs) => 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,
-      (args: FormatResolverArgs) => ResolverResult | undefined
-    >;
-  };
+  number?: (args: 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) => ResolverResult | undefined;
-  };
+  object?: (ctx: ObjectResolverContext) => PipeResult | 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 behavior for that format.
-     */
-    formats?: Record<
-      string,
-      (args: FormatResolverArgs) => ResolverResult | undefined
-    >;
-  };
+  string?: (ctx: StringResolverContext) => PipeResult | undefined;
   /**
    * Resolvers for request and response validators.
    *

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 { identifiers } from './constants';
 
-const defaultValidatorResolver = ({
-  schema,
-  v,
-}: ValidatorResolverArgs): ReturnType<typeof $.return> =>
-  $(v).attr(identifiers.async.parseAsync).call(schema, 'data').await().return();
+const validatorResolver = (
+  ctx: ValidatorResolverArgs,
+): ReturnType<typeof $.return> => {
+  const { schema } = ctx;
+  const { 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 = {
     $,
     operation,
-    pipes: [],
+    pipes,
     plugin,
+    result: [],
     schema: symbol,
-    v,
+    symbols: {
+      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);
     if (statements === null) return;
···
   });
   if (!symbol) return;
 
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
   const args: ValidatorResolverArgs = {
     $,
     operation,
-    pipes: [],
+    pipes,
     plugin,
+    result: [],
     schema: symbol,
-    v,
+    symbols: {
+      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);
     if (statements === null) return;

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 { FormatResolverArgs } from '../../types';
+import type { NumberResolverContext } from '../../types';
 import { identifiers } from '../constants';
 
-const defaultBaseResolver = ({
-  pipes,
-  schema,
-  v,
-}: FormatResolverArgs): boolean | number => {
-  if (shouldCoerceToBigInt(schema.format)) {
-    pipes.push(
+function baseNode(ctx: NumberResolverContext): PipeResult {
+  const { schema } = ctx;
+  const { v } = ctx.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;
+}
 
-  return true;
-};
+function constNode(ctx: NumberResolverContext): PipeResult | undefined {
+  const { schema } = ctx;
+  const { v } = ctx.symbols;
+  if (schema.const === undefined) return;
+  return $(v)
+    .attr(identifiers.schemas.literal)
+    .call(ctx.utils.maybeBigInt(schema.const, schema.format));
+}
 
-export const numberToAst = ({
-  plugin,
-  schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'integer' | 'number'>;
-}) => {
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
+function maxNode(ctx: NumberResolverContext): PipeResult | undefined {
+  const { schema } = ctx;
+  const { v } = ctx.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;
+}
 
-  if (schema.const !== undefined) {
+function minNode(ctx: NumberResolverContext): PipeResult | undefined {
+  const { schema } = ctx;
+  const { v } = ctx.symbols;
+  if (schema.exclusiveMinimum !== undefined) {
+    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.schemas.literal)
-      .call(maybeBigInt(schema.const, schema.format));
+      .attr(identifiers.actions.minValue)
+      .call(
+        ctx.utils.maybeBigInt(limit.minValue, schema.format),
+        $.literal(limit.minError),
+      );
   }
+  return;
+}
 
-  const pipes: Array<ReturnType<typeof $.call>> = [];
+function numberResolver(ctx: NumberResolverContext): Pipes {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) return ctx.pipes.push(ctx.result, constNode);
 
-  const args: FormatResolverArgs = { $, pipes, plugin, schema, v };
-  const resolver = plugin.config['~resolvers']?.number?.base;
-  if (!resolver?.(args)) defaultBaseResolver(args);
+  const baseNode = ctx.nodes.base(ctx);
+  if (baseNode) ctx.pipes.push(ctx.result, baseNode);
 
-  let hasLowerBound = false;
-  let hasUpperBound = false;
-
-  if (schema.exclusiveMinimum !== undefined) {
-    pipes.push(
-      $(v)
-        .attr(identifiers.actions.gtValue)
-        .call(maybeBigInt(schema.exclusiveMinimum, schema.format)),
-    );
-    hasLowerBound = true;
-  } else if (schema.minimum !== undefined) {
-    pipes.push(
-      $(v)
-        .attr(identifiers.actions.minValue)
-        .call(maybeBigInt(schema.minimum, schema.format)),
-    );
-    hasLowerBound = true;
-  }
+  const minNode = ctx.nodes.min(ctx);
+  if (minNode) ctx.pipes.push(ctx.result, minNode);
 
-  if (schema.exclusiveMaximum !== undefined) {
-    pipes.push(
-      $(v)
-        .attr(identifiers.actions.ltValue)
-        .call(maybeBigInt(schema.exclusiveMaximum, schema.format)),
-    );
-    hasUpperBound = true;
-  } else if (schema.maximum !== undefined) {
-    pipes.push(
-      $(v)
-        .attr(identifiers.actions.maxValue)
-        .call(maybeBigInt(schema.maximum, schema.format)),
-    );
-    hasUpperBound = true;
-  }
-
-  const integerLimit = getIntegerLimit(schema.format);
-  if (integerLimit) {
-    if (!hasLowerBound) {
-      pipes.push(
-        $(v)
-          .attr(identifiers.actions.minValue)
-          .call(
-            maybeBigInt(integerLimit.minValue, schema.format),
-            $.literal(integerLimit.minError),
-          ),
-      );
-      hasLowerBound = true;
-    }
+  const maxNode = ctx.nodes.max(ctx);
+  if (maxNode) ctx.pipes.push(ctx.result, maxNode);
 
-    if (!hasUpperBound) {
-      pipes.push(
-        $(v)
-          .attr(identifiers.actions.maxValue)
-          .call(
-            maybeBigInt(integerLimit.maxValue, schema.format),
-            $.literal(integerLimit.maxError),
-          ),
-      );
-      hasUpperBound = true;
-    }
-  }
+  return ctx.result;
+}
 
-  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,
+    plugin,
+    result: [],
+    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 defaultBaseResolver({
-  additional,
-  pipes,
-  shape,
-  v,
-}: ObjectBaseResolverArgs): number {
-  // Handle `additionalProperties: { type: 'never' }` → v.strictObject()
+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);
+}
+
+function baseNode(ctx: ObjectResolverContext): PipeResult {
+  const { v } = ctx.symbols;
+
+  const additional = ctx.nodes.additionalProperties(ctx);
+  const shape = ctx.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 v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
-
-  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,
+    nodes: {
+      additionalProperties: additionalPropertiesNode,
+      base: baseNode,
+      shape: shapeNode,
+    },
     pipes,
     plugin,
+    result: [],
     schema,
-    shape,
-    v,
+    symbols: {
+      v: plugin.external('valibot.v'),
+    },
+    utils: {
+      ast: {},
+      state,
+    },
   };
-  const resolver = plugin.config['~resolvers']?.object?.base;
-  if (!resolver?.(args)) defaultBaseResolver(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,
-  schema,
-  v,
-}: FormatResolverArgs): boolean | number => {
+function baseNode(ctx: StringResolverContext): PipeResult {
+  const { v } = ctx.symbols;
+  return $(v).attr(identifiers.schemas.string).call();
+}
+
+function constNode(ctx: StringResolverContext): PipeResult | undefined {
+  const { schema } = ctx;
+  const { v } = ctx.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 } = ctx;
+  const { v } = ctx.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 } = ctx;
+  const { v } = ctx.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 } = ctx;
+  const { v } = ctx.symbols;
+  if (schema.maxLength === undefined) return;
+  return $(v)
+    .attr(identifiers.actions.maxLength)
+    .call($.literal(schema.maxLength));
+}
 
-  const pipes = [$(v).attr(identifiers.schemas.string).call()];
+function minLengthNode(ctx: StringResolverContext): PipeResult | undefined {
+  const { schema } = ctx;
+  const { v } = ctx.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, v };
-    const resolver =
-      plugin.config['~resolvers']?.string?.formats?.[schema.format];
-    if (!resolver?.(args)) defaultFormatResolver(args);
-  }
+function patternNode(ctx: StringResolverContext): PipeResult | undefined {
+  const { schema } = ctx;
+  const { v } = ctx.symbols;
+  if (!schema.pattern) return;
+  return $(v).attr(identifiers.actions.regex).call($.regexp(schema.pattern));
+}
+
+function stringResolver(ctx: StringResolverContext): Pipes {
+  const constNode = ctx.nodes.const(ctx);
+  if (constNode) return ctx.pipes.push(ctx.result, constNode);
+
+  const baseNode = ctx.nodes.base(ctx);
+  if (baseNode) ctx.pipes.push(ctx.result, baseNode);
 
-  if (schema.minLength === schema.maxLength && schema.minLength !== undefined) {
-    pipes.push(
-      $(v).attr(identifiers.actions.length).call($.literal(schema.minLength)),
-    );
+  const formatNode = ctx.nodes.format(ctx);
+  if (formatNode) ctx.pipes.push(ctx.result, formatNode);
+
+  const lengthNode = ctx.nodes.length(ctx);
+  if (lengthNode) {
+    ctx.pipes.push(ctx.result, 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.result, 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.result, 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.result, patternNode);
+
+  return ctx.result;
+}
 
-  return pipesToAst(pipes, plugin);
+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,
+    plugin,
+    result: [],
+    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 type { ValidatorArgs } from '../shared/types';
 import type { ValidatorResolverArgs } from '../types';
 
-const defaultValidatorResolver = ({
+const validatorResolver = ({
   schema,
 }: ValidatorResolverArgs): ReturnType<typeof $.return> =>
   $(schema).attr(identifiers.parseAsync).call('data').await().return();
···
   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);
     if (statements === null) return;
···
   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);
     if (statements === null) return;

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

···
 import type { ValidatorArgs } from '../shared/types';
 import type { ValidatorResolverArgs } from '../types';
 
-const defaultValidatorResolver = ({
+const validatorResolver = ({
   schema,
 }: ValidatorResolverArgs): ReturnType<typeof $.return> =>
   $(schema).attr(identifiers.parseAsync).call('data').await().return();
···
   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);
     if (statements === null) return;
···
   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);
     if (statements === null) return;

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

···
 import type { ValidatorArgs } from '../shared/types';
 import type { ValidatorResolverArgs } from '../types';
 
-const defaultValidatorResolver = ({
+const validatorResolver = ({
   schema,
 }: ValidatorResolverArgs): ReturnType<typeof $.return> =>
   $(schema).attr(identifiers.parseAsync).call('data').await().return();
···
   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);
     if (statements === null) return;
···
   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);
     if (statements === null) return;