refactor: clean up valibot resolver interface

dev/openapi-ts.config.ts

···
             },
           },
           '~resolvers': {
-            number(ctx) {
-              const { $, plugin, symbols } = ctx;
-              const { v } = symbols;
-              // ctx.nodes.base = () => {
-              //   // implement custom base number resolver
-              // }
-              const big = plugin.symbolOnce('Big', {
-                external: 'big.js',
-                importKind: 'default',
-              });
-              return $(v).attr('instance').call(big);
-            },
+            // number(ctx) {
+            //   const { $, plugin, symbols } = ctx;
+            //   const { v } = symbols;
+            //   // ctx.nodes.base = () => {
+            //   //   // implement custom base number resolver
+            //   // }
+            //   const big = plugin.symbolOnce('Big', {
+            //     external: 'big.js',
+            //     importKind: 'default',
+            //   });
+            //   return $(v).attr('instance').call(big);
+            // },
             // object(ctx) {
             //   const { $ } = ctx;
             //   const additional = ctx.nodes.additionalProperties(ctx);
···
             //     ctx.nodes.format = () => $('v').attr('isoDateTime').call();
             //   }
             // },
-            // validator({ $, plugin, schema, v }) {
+            // validator(ctx) {
+            //   const { $, plugin, symbols } = ctx;
+            //   const { schema, v } = symbols;
             //   const vShadow = plugin.symbol('v');
             //   const test = plugin.symbol('test');
             //   const e = plugin.symbol('err');

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

···
 };
 
 export interface PipesUtils {
+  /**
+   * Push pipes into target array.
+   */
   push: PushPipes;
+  /**
+   * Convert pipes to a single node.
+   */
   toNode: PipesToNode;
 }
 
···
  * Functions for working with pipes.
  */
 export const pipes: PipesUtils = {
-  /**
-   * Push pipes into target array.
-   */
   push: pushPipes,
-  /**
-   * Convert pipes to a single node.
-   */
   toNode: pipesToNode,
 };

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

···
 import type { Refs, Symbol } from '@hey-api/codegen-core';
-import type ts from 'typescript';
 
 import type { IR } from '~/ir/types';
 import type { DefinePlugin, Plugin, SchemaWithType } from '~/plugins';
···
   ShouldCoerceToBigInt,
 } from '~/plugins/shared/utils/coerce';
 import type { GetIntegerLimit } from '~/plugins/shared/utils/formats';
-import type { $, DollarTsDsl, TsDsl } from '~/ts-dsl';
+import type { $, DollarTsDsl } from '~/ts-dsl';
 import type { StringCase, StringName } from '~/types/case';
-import type { MaybeArray } from '~/types/utils';
 
 import type { IApi } from './api';
 import type { Pipe, PipeResult, PipesUtils } from './shared/pipes';
···
     };
   };
 
-type SharedResolverArgs = DollarTsDsl & {
+interface BaseResolverContext extends DollarTsDsl {
   /**
    * Functions for working with pipes.
    */
-  pipes: PipesUtils;
+  pipes: PipesUtils & {
+    /**
+     * 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.
+     */
+    current: Pipes;
+  };
   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.
-   */
-  result: Pipes;
-  /**
    * Provides access to commonly used symbols within the Valibot plugin.
    */
   symbols: {
     v: Symbol;
   };
-};
+}
 
-export type NumberResolverContext = SharedResolverArgs & {
+export interface NumberResolverContext extends BaseResolverContext {
   /**
    * Nodes used to build different parts of the number schema.
    */
···
     maybeBigInt: MaybeBigInt;
     shouldCoerceToBigInt: ShouldCoerceToBigInt;
   };
-};
+}
 
-export type ObjectResolverContext = SharedResolverArgs & {
+export interface ObjectResolverContext extends BaseResolverContext {
   /**
    * Nodes used to build different parts of the object schema.
    */
···
     ast: Partial<Omit<Ast, 'typeName'>>;
     state: Refs<PluginState>;
   };
-};
+}
 
-export type StringResolverContext = SharedResolverArgs & {
+export interface StringResolverContext extends BaseResolverContext {
   /**
    * Nodes used to build different parts of the string schema.
    */
···
     pattern: (ctx: StringResolverContext) => PipeResult | undefined;
   };
   schema: SchemaWithType<'string'>;
-};
+}
 
-export type ValidatorResolverArgs = SharedResolverArgs & {
+export interface ValidatorResolverContext extends BaseResolverContext {
   operation: IR.Operation;
-  schema: Symbol;
-};
+  /**
+   * Provides access to commonly used symbols within the Valibot plugin.
+   */
+  symbols: BaseResolverContext['symbols'] & {
+    schema: Symbol;
+  };
+}
 
 type ValidatorResolver = (
-  args: ValidatorResolverArgs,
-) => MaybeArray<TsDsl<ts.Statement>> | null | undefined;
+  args: ValidatorResolverContext,
+) => PipeResult | null | undefined;
 
 type Resolvers = Plugin.Resolvers<{
   /**
···
    *
    * Example path: `~resolvers.validator.request` or `~resolvers.validator.response`
    *
-   * Returning `undefined` from a resolver will apply the default generation logic.
+   * Returning `undefined` will execute the default resolver logic.
    */
   validator?:
     | ValidatorResolver
···
         /**
          * Controls how the request validator function body is generated.
          *
-         * Returning `undefined` will fall back to the default `.await().return()` logic.
+         * Returning `undefined` will execute the default resolver logic.
          */
         request?: ValidatorResolver;
         /**
          * Controls how the response validator function body is generated.
          *
-         * Returning `undefined` will fall back to the default `.await().return()` logic.
+         * Returning `undefined` will execute the default resolver logic.
          */
         response?: ValidatorResolver;
       };

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

···
 
 import { pipes } from '../shared/pipes';
 import type { ValidatorArgs } from '../shared/types';
-import type { ValidatorResolverArgs } from '../types';
+import type { ValidatorResolverContext } from '../types';
 import { identifiers } from './constants';
 
 const validatorResolver = (
-  ctx: ValidatorResolverArgs,
+  ctx: ValidatorResolverContext,
 ): ReturnType<typeof $.return> => {
-  const { schema, symbols } = ctx;
-  const { v } = symbols;
+  const { schema, v } = ctx.symbols;
   return $(v)
     .attr(identifiers.async.parseAsync)
     .call(schema, 'data')
···
   });
   if (!symbol) return;
 
-  const args: ValidatorResolverArgs = {
+  const ctx: ValidatorResolverContext = {
     $,
     operation,
-    pipes,
+    pipes: {
+      ...pipes,
+      current: [],
+    },
     plugin,
-    result: [],
-    schema: symbol,
     symbols: {
+      schema: symbol,
       v: plugin.external('valibot.v'),
     },
   };
···
     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 args: ValidatorResolverArgs = {
+  const ctx: ValidatorResolverContext = {
     $,
     operation,
-    pipes,
+    pipes: {
+      ...pipes,
+      current: [],
+    },
     plugin,
-    result: [],
-    schema: symbol,
     symbols: {
+      schema: symbol,
       v: plugin.external('valibot.v'),
     },
   };
···
     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/valibot/v1/toAst/number.ts

···
 
 function numberResolver(ctx: NumberResolverContext): Pipes {
   const constNode = ctx.nodes.const(ctx);
-  if (constNode) return ctx.pipes.push(ctx.result, constNode);
+  if (constNode) return ctx.pipes.push(ctx.pipes.current, constNode);
 
   const baseNode = ctx.nodes.base(ctx);
-  if (baseNode) ctx.pipes.push(ctx.result, baseNode);
+  if (baseNode) ctx.pipes.push(ctx.pipes.current, baseNode);
 
   const minNode = ctx.nodes.min(ctx);
-  if (minNode) ctx.pipes.push(ctx.result, minNode);
+  if (minNode) ctx.pipes.push(ctx.pipes.current, minNode);
 
   const maxNode = ctx.nodes.max(ctx);
-  if (maxNode) ctx.pipes.push(ctx.result, maxNode);
+  if (maxNode) ctx.pipes.push(ctx.pipes.current, maxNode);
 
-  return ctx.result;
+  return ctx.pipes.current;
 }
 
 export const numberToNode = ({
···
       max: maxNode,
       min: minNode,
     },
-    pipes,
+    pipes: {
+      ...pipes,
+      current: [],
+    },
     plugin,
-    result: [],
     schema,
     symbols: {
       v: plugin.external('valibot.v'),

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

···
       base: baseNode,
       shape: shapeNode,
     },
-    pipes,
+    pipes: {
+      ...pipes,
+      current: [],
+    },
     plugin,
-    result: [],
     schema,
     symbols: {
       v: plugin.external('valibot.v'),

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

···
 
 function stringResolver(ctx: StringResolverContext): Pipes {
   const constNode = ctx.nodes.const(ctx);
-  if (constNode) return ctx.pipes.push(ctx.result, constNode);
+  if (constNode) return ctx.pipes.push(ctx.pipes.current, constNode);
 
   const baseNode = ctx.nodes.base(ctx);
-  if (baseNode) ctx.pipes.push(ctx.result, baseNode);
+  if (baseNode) ctx.pipes.push(ctx.pipes.current, baseNode);
 
   const formatNode = ctx.nodes.format(ctx);
-  if (formatNode) ctx.pipes.push(ctx.result, formatNode);
+  if (formatNode) ctx.pipes.push(ctx.pipes.current, formatNode);
 
   const lengthNode = ctx.nodes.length(ctx);
   if (lengthNode) {
-    ctx.pipes.push(ctx.result, lengthNode);
+    ctx.pipes.push(ctx.pipes.current, lengthNode);
   } else {
     const minLengthNode = ctx.nodes.minLength(ctx);
-    if (minLengthNode) ctx.pipes.push(ctx.result, minLengthNode);
+    if (minLengthNode) ctx.pipes.push(ctx.pipes.current, minLengthNode);
 
     const maxLengthNode = ctx.nodes.maxLength(ctx);
-    if (maxLengthNode) ctx.pipes.push(ctx.result, maxLengthNode);
+    if (maxLengthNode) ctx.pipes.push(ctx.pipes.current, maxLengthNode);
   }
 
   const patternNode = ctx.nodes.pattern(ctx);
-  if (patternNode) ctx.pipes.push(ctx.result, patternNode);
+  if (patternNode) ctx.pipes.push(ctx.pipes.current, patternNode);
 
-  return ctx.result;
+  return ctx.pipes.current;
 }
 
 export const stringToNode = ({
···
       minLength: minLengthNode,
       pattern: patternNode,
     },
-    pipes,
+    pipes: {
+      ...pipes,
+      current: [],
+    },
     plugin,
-    result: [],
     schema,
     symbols: {
       v: plugin.external('valibot.v'),