@mpen/routekit 0.1.0 → 0.1.1

package/src/router/routes/valibot/valibot.ts

@@ -1,1393 +0,0 @@
-import { HttpStatus } from '@mpen/http'
-import { toJsonSchema, type ConversionConfig } from '@valibot/to-json-schema'
-import type { Router } from '../../router'
-import {
-    defineMiddleware,
-    type DeclaredMiddleware,
-    type DefineMiddlewareOptions,
-    type MiddlewareResponseDeclaration,
-} from '../../middleware/define'
-import type {
-    AddedContextFromMiddlewareInput,
-    ContextFromMiddlewareInput,
-    ContextMiddleware,
-    Handler,
-    HandlerContext,
-    HandlerResult,
-    JsonObjectSchema,
-    JsonSchema,
-    MiddlewareInput,
-    Route,
-    RouteOptions,
-    RouteSchema,
-} from '../../types'
-import { isJsonContentType } from '../../lib/media-type'
-import { RequestBodyError } from '../../request'
-import { isRoutekitBody, isRoutekitResponse, response, type RoutekitResponse } from '../../response'
-import * as v from 'valibot'
-
-/**
- * Validation error component identifiers for Valibot-backed routes.
- */
-export const enum ValibotValidationError {
-    REQUEST_BODY,
-    URL_PATH,
-    QUERY_PARAMETERS,
-}
-
-type AnyValibotSchema = v.GenericSchema
-type ValibotSchema = AnyValibotSchema | undefined
-type ValibotObjectSchema = v.ObjectSchema<
-    v.ObjectEntries,
-    v.ErrorMessage<v.ObjectIssue> | undefined
->
-type ValibotPathSchema = ValibotObjectSchema | undefined
-type AnyValibotResponseBodySchemas = Partial<Record<number | 'default', AnyValibotSchema>>
-type ValibotResponseBodySchemas = AnyValibotResponseBodySchemas | undefined
-type ResponseValidationMode = false | 'strict' | 'parse'
-type ResponseValidationOption = boolean | ResponseValidationMode
-
-type ValibotRouteContext<Ctx extends object, BuilderMiddleware, RouteMiddleware> = Ctx &
-    AddedContextFromMiddlewareInput<BuilderMiddleware> &
-    AddedContextFromMiddlewareInput<RouteMiddleware>
-
-type ValibotBuilderMiddlewareInput<
-    Ctx extends object,
-    BuilderMiddleware extends MiddlewareInput<Ctx>,
-    RouteMiddleware extends MiddlewareInput<Ctx>,
-> = [BuilderMiddleware] extends [undefined]
-    ? RouteMiddleware
-    : [RouteMiddleware] extends [undefined]
-      ? BuilderMiddleware
-      : MiddlewareInput<Ctx>
-
-/**
- * Default validation error payload returned by Valibot-backed routes.
- */
-export type ValibotValidationErrorBody = {
-    component: 'request_body' | 'url_path' | 'query_parameters'
-    issues: v.BaseIssue<unknown>[]
-    message: string
-}
-
-/**
- * Valibot schema input that mirrors the core route `schema` shape.
- */
-export type ValibotRouteSchemaInput<
-    BodySchema extends ValibotSchema = undefined,
-    PathSchema extends ValibotPathSchema = undefined,
-    QuerySchema extends ValibotSchema = undefined,
-    ResponseBodySchemas extends ValibotResponseBodySchemas = undefined,
-> = {
-    request?: {
-        query?: QuerySchema
-        path?: PathSchema
-        body?: BodySchema
-    }
-    response?: {
-        body?: ResponseBodySchemas
-    }
-}
-
-type AnyValibotRouteSchemaInput = ValibotRouteSchemaInput<
-    AnyValibotSchema,
-    ValibotObjectSchema,
-    AnyValibotSchema,
-    AnyValibotResponseBodySchemas
->
-
-type InferSchema<Schema extends ValibotSchema> = Schema extends v.GenericSchema
-    ? v.InferOutput<Schema>
-    : unknown
-
-type InferResponseBodySchemaUnion<ResponseBodySchemas extends AnyValibotResponseBodySchemas> = [
-    keyof ResponseBodySchemas,
-] extends [never]
-    ? unknown
-    : {
-          [Status in keyof ResponseBodySchemas]: NonNullable<
-              ResponseBodySchemas[Status]
-          > extends AnyValibotSchema
-              ? v.InferOutput<NonNullable<ResponseBodySchemas[Status]>>
-              : never
-      }[keyof ResponseBodySchemas]
-
-type InferResponseBody<ResponseBodySchemas extends ValibotResponseBodySchemas> =
-    ResponseBodySchemas extends AnyValibotResponseBodySchemas
-        ? 200 extends keyof ResponseBodySchemas
-            ? InferResponseBodySchemaUnion<ResponseBodySchemas>
-            : 'default' extends keyof ResponseBodySchemas
-              ? InferResponseBodySchemaUnion<ResponseBodySchemas>
-              : unknown
-        : unknown
-
-type NormalizeSchema<Schema> = Schema extends AnyValibotRouteSchemaInput
-    ? Schema
-    : ValibotRouteSchemaInput<undefined, undefined, undefined, undefined>
-
-type ExtractBodySchema<Schema extends AnyValibotRouteSchemaInput | undefined> =
-    NormalizeSchema<Schema> extends ValibotRouteSchemaInput<
-        infer BodySchema,
-        infer _PathSchema,
-        infer _QuerySchema,
-        infer _ResponseBodySchemas
-    >
-        ? BodySchema
-        : undefined
-
-type ExtractPathSchema<Schema extends AnyValibotRouteSchemaInput | undefined> =
-    NormalizeSchema<Schema> extends ValibotRouteSchemaInput<
-        infer _BodySchema,
-        infer PathSchema,
-        infer _QuerySchema,
-        infer _ResponseBodySchemas
-    >
-        ? PathSchema
-        : undefined
-
-type ExtractQuerySchema<Schema extends AnyValibotRouteSchemaInput | undefined> =
-    NormalizeSchema<Schema> extends ValibotRouteSchemaInput<
-        infer _BodySchema,
-        infer _PathSchema,
-        infer QuerySchema,
-        infer _ResponseBodySchemas
-    >
-        ? QuerySchema
-        : undefined
-
-type ExtractResponseBodySchemas<Schema extends AnyValibotRouteSchemaInput | undefined> =
-    NormalizeSchema<Schema> extends ValibotRouteSchemaInput<
-        infer _BodySchema,
-        infer _PathSchema,
-        infer _QuerySchema,
-        infer ResponseBodySchemas
-    >
-        ? ResponseBodySchemas
-        : undefined
-
-type ValibotMiddlewareDeclarations<Schemas extends AnyValibotResponseBodySchemas> = {
-    [Status in keyof Schemas]: NonNullable<Schemas[Status]> extends AnyValibotSchema
-        ? MiddlewareResponseDeclaration<v.InferOutput<NonNullable<Schemas[Status]>>>
-        : never
-}
-
-type ValibotDeclaredResponse<Schemas extends AnyValibotResponseBodySchemas> = {
-    [Status in keyof Schemas]-?: NonNullable<Schemas[Status]> extends AnyValibotSchema
-        ? RoutekitResponse<
-              v.InferOutput<NonNullable<Schemas[Status]>>,
-              Status extends number ? Status : number
-          >
-        : never
-}[keyof Schemas]
-
-type ValibotSchemaMiddlewareContext<Schema extends AnyValibotRouteSchemaInput | undefined> =
-    ValibotHandlerParams<
-        ExtractBodySchema<Schema>,
-        ExtractPathSchema<Schema>,
-        ExtractQuerySchema<Schema>
-    > & {
-        params: ValibotHandlerParams<
-            ExtractBodySchema<Schema>,
-            ExtractPathSchema<Schema>,
-            ExtractQuerySchema<Schema>
-        >
-    }
-
-/**
- * Validated request inputs exposed to a Valibot-backed handler.
- */
-export type ValibotHandlerParams<
-    BodySchema extends ValibotSchema,
-    PathSchema extends ValibotPathSchema,
-    QuerySchema extends ValibotSchema,
-> = {
-    path: InferSchema<PathSchema>
-    query: InferSchema<QuerySchema>
-    body: InferSchema<BodySchema>
-}
-
-/**
- * Context object exposed to a Valibot-backed handler.
- */
-export type ValibotHandlerContext<
-    BodySchema extends ValibotSchema,
-    PathSchema extends ValibotPathSchema,
-    QuerySchema extends ValibotSchema,
-    Ctx extends object,
-> = Omit<HandlerContext<Ctx>, 'path'> &
-    ValibotHandlerParams<BodySchema, PathSchema, QuerySchema> & {
-        params: ValibotHandlerParams<BodySchema, PathSchema, QuerySchema>
-    }
-
-/**
- * Validation error handler used when request parsing fails.
- *
- * @param component - Request component that failed validation.
- * @param issues - The Valibot validation issues.
- * @returns A handler result that should be returned to the client.
- */
-export type ValibotValidationErrorHandler<
-    Responses extends AnyValibotResponseBodySchemas = AnyValibotResponseBodySchemas,
-> = (
-    component: ValibotValidationError,
-    issues: [v.BaseIssue<unknown>, ...v.BaseIssue<unknown>[]],
-) => ValibotDeclaredResponse<Responses>
-
-/**
- * Shared defaults that can be applied to Valibot handler helpers.
- */
-type ValibotHandlerDefaults = {
-    /**
-     * Route schema fragments that should be merged into every built route.
-     * Route-level schemas override matching request fields and response status codes.
-     */
-    schema?: AnyValibotRouteSchemaInput
-    /**
-     * Whether and how to apply `schema.response.body` to handler responses.
-     * `false` disables response validation, `true` and `'strict'` validate without changing the
-     * response body, and `'parse'` returns the parsed response body. Defaults to `'parse'`.
-     */
-    validateResponse?: ResponseValidationOption
-} & (
-    | {
-          onRequestValidationError?: undefined
-          validationResponses?: undefined
-      }
-    | {
-          /**
-           * Override the default request validation error response.
-           */
-          onRequestValidationError: ValibotValidationErrorHandler
-          /**
-           * Response schemas returned by `onRequestValidationError`.
-           */
-          validationResponses: AnyValibotResponseBodySchemas
-      }
-)
-
-/**
- * Shared defaults that can be applied to Valibot route helpers.
- */
-export type ValibotRouteHelperDefaults<
-    BuilderCtx extends object = object,
-    BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined,
-> = ValibotHandlerDefaults & {
-    /**
-     * Middleware applied to every route built by the helper.
-     */
-    middleware?: BuilderMiddleware
-}
-
-/**
- * Handler signature used by Valibot schema boundaries and route builders.
- */
-export type ValibotRouteHandler<
-    BodySchema extends ValibotSchema,
-    PathSchema extends ValibotPathSchema,
-    QuerySchema extends ValibotSchema,
-    ResponseBodySchemas extends ValibotResponseBodySchemas,
-    Ctx extends object = object,
-> = (
-    this: Router<any>,
-    ctx: ValibotHandlerContext<BodySchema, PathSchema, QuerySchema, Ctx>,
-) => HandlerResult<InferResponseBody<ResponseBodySchemas>>
-
-/**
- * Shared options used by Valibot route builders.
- */
-export type ValibotHandlerOptions<
-    Schema extends AnyValibotRouteSchemaInput | undefined,
-    Ctx extends object = object,
-> = ValibotHandlerDefaults & {
-    schema?: Schema
-    handler: ValibotRouteHandler<
-        ExtractBodySchema<Schema>,
-        ExtractPathSchema<Schema>,
-        ExtractQuerySchema<Schema>,
-        ExtractResponseBodySchemas<Schema>,
-        Ctx
-    >
-}
-
-/**
- * Full route options used by Valibot route builders.
- */
-export type ValibotRouteOptions<
-    Schema extends AnyValibotRouteSchemaInput | undefined,
-    Ctx extends object = object,
-    BuilderMiddleware extends MiddlewareInput<Ctx> = undefined,
-    RouteMiddleware extends MiddlewareInput<Ctx> = undefined,
-> = Omit<
-    Route<Ctx, RouteMiddleware, ValibotRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>>,
-    'handler' | 'schema' | 'middleware'
-> &
-    ValibotHandlerOptions<Schema, ValibotRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>> & {
-        middleware?: RouteMiddleware
-    }
-
-/**
- * Method-specific route options used by Valibot route builders.
- */
-export type WithValibotOptions<
-    Schema extends AnyValibotRouteSchemaInput | undefined,
-    Ctx extends object = object,
-    BuilderMiddleware extends MiddlewareInput<Ctx> = undefined,
-    RouteMiddleware extends MiddlewareInput<Ctx> = undefined,
-> = Omit<
-    RouteOptions<
-        Ctx,
-        RouteMiddleware,
-        ValibotRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>
-    >,
-    'handler' | 'schema' | 'middleware'
-> &
-    ValibotHandlerOptions<Schema, ValibotRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>> & {
-        middleware?: RouteMiddleware
-    }
-
-/**
- * Valibot route builder created by [`createValibotRouteBuilder`]{@link createValibotRouteBuilder}.
- *
- * @example
- * ```ts
- * const route = createValibotRouteBuilder()
- *
- * router.get('/users/:id', route({
- *   schema: {
- *     request: {
- *       path: v.object({id: v.string()}),
- *     },
- *   },
- *   handler: ({path}) => ({id: path.id}),
- * }))
- *
- * router.add(route({
- *   method: HttpMethod.GET,
- *   path: '/health',
- *   handler: () => ({ok: true}),
- * }))
- * ```
- */
-export type ValibotRouteBuilder<
-    BuilderCtx extends object = object,
-    BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined,
-> = {
-    /**
-     * Build a full route definition that includes its own path.
-     *
-     * @param options - Full route options including `path`.
-     * @returns A full route definition compatible with [`Router.add`]{@link Router#add}.
-     */
-    <
-        Schema extends AnyValibotRouteSchemaInput | undefined,
-        RouteMiddleware extends MiddlewareInput<BuilderCtx> = undefined,
-    >(
-        options: ValibotRouteOptions<Schema, BuilderCtx, BuilderMiddleware, RouteMiddleware>,
-    ): Route<
-        BuilderCtx,
-        ValibotBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>,
-        ValibotRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>
-    >
-    /**
-     * Build method-specific route options that leave the path to the registering router.
-     *
-     * @param options - Method route options without a route path.
-     * @returns Route options compatible with helpers like [`Router.get`]{@link Router#get}.
-     */
-    <
-        Schema extends AnyValibotRouteSchemaInput | undefined,
-        RouteMiddleware extends MiddlewareInput<BuilderCtx> = undefined,
-    >(
-        options: WithValibotOptions<Schema, BuilderCtx, BuilderMiddleware, RouteMiddleware>,
-    ): RouteOptions<
-        BuilderCtx,
-        ValibotBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>,
-        ValibotRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>
-    >
-}
-
-type ResolvedValibotHandlerOptions<
-    Schema extends AnyValibotRouteSchemaInput | undefined,
-    Ctx extends object,
-> = {
-    schema: Schema | undefined
-    handler: ValibotRouteHandler<
-        ExtractBodySchema<Schema>,
-        ExtractPathSchema<Schema>,
-        ExtractQuerySchema<Schema>,
-        ExtractResponseBodySchemas<Schema>,
-        Ctx
-    >
-    validateResponse: ResponseValidationMode
-    onRequestValidationError: ValibotValidationErrorHandler
-}
-
-type ResponseBodyForValidation = {
-    value: unknown
-    writableJson: boolean
-}
-
-const validationErrorComponentName = new Map<
-    ValibotValidationError,
-    ValibotValidationErrorBody['component']
->([
-    [ValibotValidationError.REQUEST_BODY, 'request_body'],
-    [ValibotValidationError.URL_PATH, 'url_path'],
-    [ValibotValidationError.QUERY_PARAMETERS, 'query_parameters'],
-])
-
-const jsonSchemaApproximationConfig = {
-    target: 'draft-07',
-    errorMode: 'ignore',
-} satisfies Pick<ConversionConfig, 'target' | 'errorMode'>
-
-class ValibotResponseValidationError extends Error {
-    readonly status: number
-    readonly issues: [v.BaseIssue<unknown>, ...v.BaseIssue<unknown>[]]
-
-    constructor(status: number, issues: [v.BaseIssue<unknown>, ...v.BaseIssue<unknown>[]]) {
-        super(`Response validation failed for status ${status}: ${v.summarize(issues)}`)
-        this.name = 'ValibotResponseValidationError'
-        this.status = status
-        this.issues = issues
-    }
-}
-
-function createValidationResponse(
-    component: ValibotValidationError,
-    issues: [v.BaseIssue<unknown>, ...v.BaseIssue<unknown>[]],
-): RoutekitResponse<ValibotValidationErrorBody, HttpStatus.BAD_REQUEST> {
-    const payload: ValibotValidationErrorBody = {
-        component: validationErrorComponentName.get(component) ?? 'request_body',
-        issues,
-        message: v.summarize(issues),
-    }
-    return response(payload, { status: HttpStatus.BAD_REQUEST })
-}
-
-function normalizeResponseValidationMode(
-    option: ResponseValidationOption | undefined,
-): ResponseValidationMode | undefined {
-    if (option === true) return 'strict'
-    return option
-}
-
-function resolveDefaults<Schema extends AnyValibotRouteSchemaInput | undefined, Ctx extends object>(
-    options: ValibotHandlerOptions<Schema, Ctx>,
-    defaults?: ValibotHandlerDefaults,
-): ResolvedValibotHandlerOptions<Schema, Ctx> {
-    return {
-        schema: options.schema,
-        handler: options.handler,
-        validateResponse:
-            normalizeResponseValidationMode(options.validateResponse) ??
-            normalizeResponseValidationMode(defaults?.validateResponse) ??
-            'parse',
-        onRequestValidationError:
-            options.onRequestValidationError ??
-            defaults?.onRequestValidationError ??
-            createValidationResponse,
-    }
-}
-
-function readQueryParams(searchParams: URLSearchParams): Record<string, string | string[]> {
-    const query: Record<string, string | string[]> = {}
-    for (const [key, value] of searchParams.entries()) {
-        const existing = query[key]
-        if (existing === undefined) {
-            query[key] = value
-            continue
-        }
-        if (Array.isArray(existing)) {
-            existing.push(value)
-        } else {
-            query[key] = [existing, value]
-        }
-    }
-    return query
-}
-
-function valibotIssuesFromThrowable(
-    error: unknown,
-): [v.BaseIssue<unknown>, ...v.BaseIssue<unknown>[]] {
-    return [
-        {
-            kind: 'schema',
-            type: 'custom',
-            input: undefined,
-            expected: null,
-            received: 'unknown',
-            message: error instanceof Error ? error.message : String(error),
-        },
-    ]
-}
-
-function sanitizeJsonSchema(schema: JsonSchema): JsonSchema {
-    if (Array.isArray(schema)) {
-        return schema.map((entry) =>
-            sanitizeJsonSchema(entry as JsonSchema),
-        ) as unknown as JsonSchema
-    }
-    if (!schema || typeof schema !== 'object') {
-        return schema
-    }
-
-    const sanitizedEntries = Object.entries(schema)
-        .filter(([key]) => key !== '$schema' && key !== '~standard')
-        .map(([key, value]) => [key, sanitizeJsonSchema(value as JsonSchema)])
-    return Object.fromEntries(sanitizedEntries)
-}
-
-function toRequestJsonSchema(schema: v.GenericSchema): JsonSchema {
-    return sanitizeJsonSchema(
-        toJsonSchema(schema, { ...jsonSchemaApproximationConfig, typeMode: 'input' }) as JsonSchema,
-    )
-}
-
-function toResponseJsonSchema(schema: v.GenericSchema): JsonSchema {
-    return sanitizeJsonSchema(
-        toJsonSchema(schema, {
-            ...jsonSchemaApproximationConfig,
-            typeMode: 'output',
-        }) as JsonSchema,
-    )
-}
-
-function buildRouteSchema(schema?: AnyValibotRouteSchemaInput): RouteSchema | undefined {
-    if (!schema) return undefined
-
-    const request = schema.request
-        ? {
-              ...(schema.request.query
-                  ? { query: toRequestJsonSchema(schema.request.query) as JsonObjectSchema }
-                  : {}),
-              ...(schema.request.path
-                  ? { path: toRequestJsonSchema(schema.request.path) as JsonObjectSchema }
-                  : {}),
-              ...(schema.request.body ? { body: toRequestJsonSchema(schema.request.body) } : {}),
-          }
-        : undefined
-
-    const responseBody = schema.response?.body
-        ? Object.fromEntries(
-              Object.entries(schema.response.body).map(([status, responseSchema]) => {
-                  const normalizedStatus = status === 'default' ? status : Number(status)
-                  return [normalizedStatus, toResponseJsonSchema(responseSchema as v.GenericSchema)]
-              }),
-          )
-        : undefined
-
-    const response =
-        responseBody && Object.keys(responseBody).length > 0 ? { body: responseBody } : undefined
-
-    if ((!request || Object.keys(request).length === 0) && !response) {
-        return undefined
-    }
-
-    return {
-        ...(request && Object.keys(request).length > 0 ? { request } : {}),
-        ...(response ? { response } : {}),
-    }
-}
-
-function buildValibotMiddlewareDeclarations<Schemas extends AnyValibotResponseBodySchemas>(
-    schemas: Schemas,
-): ValibotMiddlewareDeclarations<Schemas> {
-    return Object.fromEntries(
-        Object.entries(schemas).flatMap(([status, schema]) =>
-            schema
-                ? [
-                      [
-                          status,
-                          {
-                              schema: toResponseJsonSchema(schema as AnyValibotSchema),
-                              parse: (value: unknown) => v.parse(schema as AnyValibotSchema, value),
-                          },
-                      ],
-                  ]
-                : [],
-        ),
-    ) as ValibotMiddlewareDeclarations<Schemas>
-}
-
-/**
- * Options for [`defineValibotMiddleware`]{@link defineValibotMiddleware}.
- *
- * @typeParam AddedCtx - Context made available to downstream handlers.
- * @typeParam Ctx - Context required by the middleware.
- * @typeParam Responses - Status-keyed Valibot schemas for locally originated responses.
- */
-export type DefineValibotMiddlewareOptions<
-    AddedCtx extends object,
-    Ctx extends object,
-    Responses extends AnyValibotResponseBodySchemas,
-> = {
-    /**
-     * Responses that this middleware may originate.
-     */
-    responses: Responses
-    /**
-     * Execute middleware behavior using typed `respond(...)` and `forward(...)` controls.
-     */
-    run: DefineMiddlewareOptions<AddedCtx, Ctx, ValibotMiddlewareDeclarations<Responses>>['run']
-}
-
-/**
- * Create response-declaring middleware backed by Valibot response schemas.
- *
- * @example
- * ```ts
- * const requireAuth = defineValibotMiddleware({
- *     responses: { 401: v.object({ message: v.string() }) },
- *     run: (_ctx, { respond }) => respond(response({ message: 'Sign in' }, { status: 401 })),
- * })
- * ```
- *
- * @param options - Locally originated response schemas and middleware implementation.
- * @returns Declared middleware with inferred, runtime-validated terminal responses.
- * @typeParam AddedCtx - Context made available to downstream handlers.
- * @typeParam Ctx - Context required by the middleware.
- * @typeParam Responses - Status-keyed Valibot schemas for locally originated responses.
- */
-export function defineValibotMiddleware<
-    AddedCtx extends object = {},
-    Ctx extends object = object,
-    const Responses extends AnyValibotResponseBodySchemas = {},
->(
-    options: DefineValibotMiddlewareOptions<AddedCtx, Ctx, Responses>,
-): DeclaredMiddleware<AddedCtx, Ctx>
-export function defineValibotMiddleware<
-    AddedCtx extends object = {},
-    Ctx extends object = object,
-    const Responses extends AnyValibotResponseBodySchemas = {},
->(
-    options: DefineValibotMiddlewareOptions<AddedCtx, Ctx, Responses>,
-): DeclaredMiddleware<AddedCtx, Ctx> {
-    return defineMiddleware<AddedCtx, Ctx, ValibotMiddlewareDeclarations<Responses>>({
-        responses: buildValibotMiddlewareDeclarations(options.responses),
-        run: options.run,
-    })
-}
-
-function mergeRouteSchema(
-    defaults: ValibotHandlerDefaults,
-    schema: AnyValibotRouteSchemaInput | undefined,
-): AnyValibotRouteSchemaInput | undefined {
-    const defaultSchema = defaults.schema
-    if (!defaultSchema) return schema
-    if (!schema) return defaultSchema
-
-    const request =
-        !defaultSchema.request && !schema.request
-            ? undefined
-            : {
-                  ...defaultSchema.request,
-                  ...schema.request,
-              }
-
-    const defaultBody = defaultSchema.response?.body ?? {}
-    const routeBody = schema.response?.body ?? {}
-    const responseBody: AnyValibotResponseBodySchemas = {}
-
-    const statuses = new Set([...Object.keys(defaultBody), ...Object.keys(routeBody)])
-    for (const status of statuses) {
-        const s = status === 'default' ? status : Number(status)
-        const defaultStatusSchema = defaultBody[s as keyof typeof defaultBody]
-        const routeStatusSchema = routeBody[s as keyof typeof routeBody]
-        if (defaultStatusSchema && routeStatusSchema) {
-            responseBody[s as keyof typeof responseBody] = v.union([
-                defaultStatusSchema,
-                routeStatusSchema,
-            ])
-        } else if (defaultStatusSchema) {
-            responseBody[s as keyof typeof responseBody] = defaultStatusSchema
-        } else if (routeStatusSchema) {
-            responseBody[s as keyof typeof responseBody] = routeStatusSchema
-        }
-    }
-
-    const response = Object.keys(responseBody).length > 0 ? { body: responseBody } : undefined
-
-    return {
-        ...(request ? { request } : {}),
-        ...(response ? { response } : {}),
-    }
-}
-
-function normalizeMiddlewareInput<Ctx extends object>(
-    middleware: MiddlewareInput<Ctx>,
-): ContextMiddleware<any, Ctx>[] {
-    if (!middleware) return []
-    if (Array.isArray(middleware)) {
-        return middleware.filter(Boolean) as ContextMiddleware<any, Ctx>[]
-    }
-    return [middleware as ContextMiddleware<any, Ctx>]
-}
-
-function mergeMiddleware<Ctx extends object>(
-    defaultMiddleware: MiddlewareInput<Ctx>,
-    routeMiddleware: MiddlewareInput<Ctx>,
-): MiddlewareInput<Ctx> {
-    const list = [
-        ...normalizeMiddlewareInput(defaultMiddleware),
-        ...normalizeMiddlewareInput(routeMiddleware),
-    ]
-    return list.length ? list : undefined
-}
-
-function mergeValibotOptions<
-    Ctx extends object,
-    BuilderMiddleware extends MiddlewareInput<Ctx>,
-    RouteMiddleware extends MiddlewareInput<Ctx>,
-    Options extends {
-        schema?: AnyValibotRouteSchemaInput | undefined
-        middleware?: RouteMiddleware
-    },
->(
-    defaults: ValibotRouteHelperDefaults<Ctx, BuilderMiddleware>,
-    options: Options,
-): Omit<Options, 'middleware'> & { middleware?: MiddlewareInput<Ctx> } {
-    const { middleware: defaultMiddleware, ...defaultOptions } = defaults
-    const schema = mergeRouteSchema(defaults, options.schema)
-    const middleware = mergeMiddleware(defaultMiddleware, options.middleware)
-    return {
-        ...defaultOptions,
-        ...options,
-        ...(schema === undefined ? {} : { schema }),
-        ...(middleware === undefined ? {} : { middleware }),
-    } as Omit<Options, 'middleware'> & { middleware?: MiddlewareInput<Ctx> }
-}
-
-function hasRoutePath(options: unknown): options is { path: unknown } {
-    return (options as { path?: unknown }).path !== undefined
-}
-
-function isSkippableResponseValidationValue(value: unknown): boolean {
-    return (
-        value instanceof ReadableStream ||
-        value instanceof Uint8Array ||
-        (typeof Buffer !== 'undefined' && value instanceof Buffer) ||
-        (!!value && typeof value === 'object' && Symbol.asyncIterator in value)
-    )
-}
-
-function jsonValuesEqual(left: unknown, right: unknown): boolean {
-    if (Object.is(left, right)) return true
-    if (typeof left !== typeof right) return false
-    if (!left || !right || typeof left !== 'object') return false
-    if (Array.isArray(left) || Array.isArray(right)) {
-        return (
-            Array.isArray(left) &&
-            Array.isArray(right) &&
-            left.length === right.length &&
-            left.every((value, index) => jsonValuesEqual(value, right[index]))
-        )
-    }
-
-    const leftEntries = Object.entries(left)
-    const rightRecord = right as Record<string, unknown>
-    const rightKeys = new Set(Object.keys(rightRecord))
-    return (
-        leftEntries.length === rightKeys.size &&
-        leftEntries.every(
-            ([key, value]) => rightKeys.has(key) && jsonValuesEqual(value, rightRecord[key]),
-        )
-    )
-}
-
-function getResponseSchemaForStatus(
-    schema: AnyValibotRouteSchemaInput | undefined,
-    status: number,
-): v.GenericSchema | undefined {
-    return schema?.response?.body?.[status] ?? schema?.response?.body?.default
-}
-
-async function readResponseBodyForValidation(
-    response: Response,
-): Promise<ResponseBodyForValidation | undefined> {
-    if (!response.body) return undefined
-    const contentType = response.headers.get('content-type') ?? ''
-    const clone = response.clone()
-    if (isJsonContentType(contentType)) {
-        return {
-            value: await clone.json(),
-            writableJson: true,
-        }
-    }
-    return {
-        value: await clone.text(),
-        writableJson: false,
-    }
-}
-
-function responseWithJsonBody(response: Response, value: unknown): Response {
-    const headers = new Headers(response.headers)
-    headers.delete('content-length')
-    if (!headers.has('content-type')) {
-        headers.set('content-type', 'application/json')
-    }
-    return new Response(value === undefined ? undefined : JSON.stringify(value), {
-        status: response.status,
-        statusText: response.statusText,
-        headers,
-    })
-}
-
-function parseResponseSchema(
-    schema: AnyValibotRouteSchemaInput | undefined,
-    status: number,
-    value: unknown,
-    mode: ResponseValidationMode,
-): unknown {
-    const responseSchema = getResponseSchemaForStatus(schema, status)
-    if (!responseSchema) return value
-    const result = v.safeParse(responseSchema, value)
-    if (!result.success) {
-        throw new ValibotResponseValidationError(status, result.issues)
-    }
-    if (mode === 'strict' && !jsonValuesEqual(value, result.output)) {
-        throw new ValibotResponseValidationError(
-            status,
-            valibotIssuesFromThrowable(
-                new Error('Response body does not match the parsed schema output.'),
-            ),
-        )
-    }
-    return mode === 'parse' ? result.output : value
-}
-
-async function validateHandlerResult(
-    schema: AnyValibotRouteSchemaInput | undefined,
-    result: unknown,
-    mode: ResponseValidationMode,
-): Promise<unknown> {
-    if (result instanceof Response) {
-        const body = await readResponseBodyForValidation(result)
-        if (!body) return result
-        const parsed = parseResponseSchema(schema, result.status, body.value, mode)
-        return mode === 'parse' && body.writableJson ? responseWithJsonBody(result, parsed) : result
-    }
-    if (isRoutekitResponse(result)) {
-        const parsed = parseResponseSchema(schema, result.status, result.body, mode)
-        return mode === 'parse'
-            ? response(parsed, { status: result.status, headers: result.headers })
-            : result
-    }
-    if (isRoutekitBody(result)) {
-        const parsed = parseResponseSchema(schema, HttpStatus.OK, result.value, mode)
-        return mode === 'parse' ? parsed : result
-    }
-    if (isSkippableResponseValidationValue(result)) {
-        return result
-    }
-    return parseResponseSchema(schema, HttpStatus.OK, result, mode)
-}
-
-const defaultValidationErrorSchema = v.object({
-    component: v.picklist(['request_body', 'url_path', 'query_parameters']),
-    issues: v.array(v.unknown()),
-    message: v.string(),
-})
-
-/**
- * Options for [`valibotSchemaMiddleware`]{@link valibotSchemaMiddleware}.
- *
- * @typeParam Schema - Valibot request and downstream response schema declaration.
- */
-type ValibotSchemaMiddlewareBaseOptions<Schema extends AnyValibotRouteSchemaInput | undefined> = {
-    schema?: Schema
-    validateResponse?: ResponseValidationOption
-}
-
-/**
- * Options for a Valibot request/response schema boundary.
- *
- * A custom request-validation callback must declare the response schemas it can originate.
- *
- * @typeParam Schema - Valibot request and downstream response schema declaration.
- * @typeParam ValidationResponses - Schemas owned by a custom validation-error callback.
- */
-export type ValibotSchemaMiddlewareOptions<
-    Schema extends AnyValibotRouteSchemaInput | undefined,
-    ValidationResponses extends AnyValibotResponseBodySchemas | undefined = undefined,
-> = ValibotSchemaMiddlewareBaseOptions<Schema> &
-    ([ValidationResponses] extends [undefined]
-        ? {
-              onRequestValidationError?: undefined
-              validationResponses?: undefined
-          }
-        : {
-              onRequestValidationError: ValibotValidationErrorHandler<
-                  Extract<ValidationResponses, AnyValibotResponseBodySchemas>
-              >
-              validationResponses: ValidationResponses
-          })
-
-/**
- * Create Valibot middleware that parses request inputs and validates downstream responses.
- *
- * @example
- * ```ts
- * const parseUserId = valibotSchemaMiddleware({
- *     schema: { request: { path: v.object({ id: v.string() }) } },
- * })
- * ```
- *
- * @param options - Request, response, and validation-error schema behavior.
- * @returns Declared middleware exposing parsed request values to downstream handlers.
- * @typeParam Schema - Valibot request and downstream response schema declaration.
- * @typeParam Ctx - Context required before this middleware executes.
- */
-export function valibotSchemaMiddleware<
-    Schema extends AnyValibotRouteSchemaInput | undefined,
-    const ValidationResponses extends AnyValibotResponseBodySchemas | undefined = undefined,
-    Ctx extends object = object,
->(
-    options: ValibotSchemaMiddlewareOptions<Schema, ValidationResponses>,
-): DeclaredMiddleware<ValibotSchemaMiddlewareContext<Schema>, Ctx> {
-    const validateResponse = normalizeResponseValidationMode(options.validateResponse) ?? 'parse'
-    const parsesRequest = options.schema?.request !== undefined
-    const validationResponses =
-        options.validationResponses ??
-        (parsesRequest
-            ? ({
-                  [HttpStatus.BAD_REQUEST]: defaultValidationErrorSchema,
-              } satisfies AnyValibotResponseBodySchemas)
-            : {})
-    const declarations = buildValibotMiddlewareDeclarations(validationResponses)
-    const onRequestValidationError = options.onRequestValidationError ?? createValidationResponse
-
-    return defineMiddleware<ValibotSchemaMiddlewareContext<Schema>, Ctx, typeof declarations>({
-        schema: buildRouteSchema(options.schema),
-        responses: declarations,
-        async run(ctx, { next, forward, respond }) {
-            const bodySchema = options.schema?.request?.body
-            const pathSchema = options.schema?.request?.path
-            const querySchema = options.schema?.request?.query
-            const queryParams = readQueryParams(ctx.url.searchParams)
-            const handlerParams = {
-                path: ctx.path as InferSchema<ExtractPathSchema<Schema>>,
-                query: undefined as InferSchema<ExtractQuerySchema<Schema>>,
-                body: undefined as InferSchema<ExtractBodySchema<Schema>>,
-            }
-            const handlerContext = ctx as HandlerContext<Ctx> &
-                ValibotSchemaMiddlewareContext<Schema>
-            handlerContext.params = handlerParams
-
-            if (querySchema) {
-                const parsed = v.safeParse(querySchema, queryParams)
-                if (!parsed.success) {
-                    return respond(
-                        onRequestValidationError(
-                            ValibotValidationError.QUERY_PARAMETERS,
-                            parsed.issues,
-                        ) as never,
-                    )
-                }
-                handlerParams.query = parsed.output as InferSchema<ExtractQuerySchema<Schema>>
-                handlerContext.query = handlerParams.query
-            }
-
-            if (pathSchema) {
-                const parsed = v.safeParse(pathSchema, ctx.path)
-                if (!parsed.success) {
-                    return respond(
-                        onRequestValidationError(
-                            ValibotValidationError.URL_PATH,
-                            parsed.issues,
-                        ) as never,
-                    )
-                }
-                handlerParams.path = parsed.output as InferSchema<ExtractPathSchema<Schema>>
-                handlerContext.path = handlerParams.path
-            }
-
-            if (bodySchema) {
-                let rawBody: unknown
-                try {
-                    rawBody = await ctx.request.body.parse()
-                } catch (err) {
-                    if (err instanceof RequestBodyError) throw err
-                    return respond(
-                        onRequestValidationError(
-                            ValibotValidationError.REQUEST_BODY,
-                            valibotIssuesFromThrowable(err),
-                        ) as never,
-                    )
-                }
-                const parsed = v.safeParse(bodySchema, rawBody)
-                if (!parsed.success) {
-                    return respond(
-                        onRequestValidationError(
-                            ValibotValidationError.REQUEST_BODY,
-                            parsed.issues,
-                        ) as never,
-                    )
-                }
-                handlerParams.body = parsed.output as InferSchema<ExtractBodySchema<Schema>>
-                handlerContext.body = handlerParams.body
-            }
-
-            const result = await next()
-            return forward(
-                validateResponse === false
-                    ? result
-                    : ((await validateHandlerResult(
-                          options.schema,
-                          result,
-                          validateResponse,
-                      )) as HandlerResult),
-            )
-        },
-    })
-}
-
-/**
- * Build a route handler that parses request inputs with Valibot and optionally validates responses.
- *
- * @example
- * ```ts
- * const handler = valibotHandler({
- *   schema: {
- *     request: {
- *       path: v.object({id: v.string()}),
- *     },
- *     response: {
- *       body: {
- *         200: v.object({id: v.string()}),
- *       },
- *     },
- *   },
- *   handler: ({path}) => ({id: path.id}),
- * })
- * ```
- *
- * @param options - Handler definition extended with request and response Valibot schemas.
- * @returns A handler that validates request inputs before invoking the provided handler.
- */
-export function valibotHandler<
-    Schema extends AnyValibotRouteSchemaInput | undefined,
-    Ctx extends object = object,
->(
-    options: ValibotHandlerOptions<Schema, Ctx>,
-): Handler<InferResponseBody<ExtractResponseBodySchemas<Schema>>, Ctx> {
-    const resolved = resolveDefaults(options)
-
-    return async function (this: Router<any>, ctx: HandlerContext<Ctx>) {
-        const run = async (): Promise<
-            HandlerResult<InferResponseBody<ExtractResponseBodySchemas<Schema>>>
-        > => {
-            const validateAndReturn = async (
-                result: HandlerResult<InferResponseBody<ExtractResponseBodySchemas<Schema>>>,
-            ): Promise<HandlerResult<InferResponseBody<ExtractResponseBodySchemas<Schema>>>> => {
-                if (resolved.validateResponse !== false) {
-                    return (await validateHandlerResult(
-                        resolved.schema,
-                        result,
-                        resolved.validateResponse,
-                    )) as HandlerResult<InferResponseBody<ExtractResponseBodySchemas<Schema>>>
-                }
-                return result
-            }
-            const bodySchema = resolved.schema?.request?.body
-            const pathSchema = resolved.schema?.request?.path
-            const querySchema = resolved.schema?.request?.query
-            const queryParams = readQueryParams(ctx.url.searchParams)
-
-            const handlerParams = {
-                path: ctx.path as InferSchema<ExtractPathSchema<Schema>>,
-                query: undefined as InferSchema<ExtractQuerySchema<Schema>>,
-                body: undefined as InferSchema<ExtractBodySchema<Schema>>,
-            }
-            const handlerContext = {
-                ...ctx,
-                ...handlerParams,
-                params: handlerParams,
-            } as ValibotHandlerContext<
-                ExtractBodySchema<Schema>,
-                ExtractPathSchema<Schema>,
-                ExtractQuerySchema<Schema>,
-                Ctx
-            >
-
-            if (querySchema) {
-                const queryResult = v.safeParse(querySchema, queryParams)
-                if (!queryResult.success) {
-                    return await validateAndReturn(
-                        resolved.onRequestValidationError(
-                            ValibotValidationError.QUERY_PARAMETERS,
-                            queryResult.issues,
-                        ) as HandlerResult<InferResponseBody<ExtractResponseBodySchemas<Schema>>>,
-                    )
-                }
-                handlerContext.params.query = queryResult.output as InferSchema<
-                    ExtractQuerySchema<Schema>
-                >
-                handlerContext.query = handlerContext.params.query
-            }
-
-            if (pathSchema) {
-                const pathResult = v.safeParse(pathSchema, ctx.path)
-                if (!pathResult.success) {
-                    return await validateAndReturn(
-                        resolved.onRequestValidationError(
-                            ValibotValidationError.URL_PATH,
-                            pathResult.issues,
-                        ) as HandlerResult<InferResponseBody<ExtractResponseBodySchemas<Schema>>>,
-                    )
-                }
-                handlerContext.params.path = pathResult.output as InferSchema<
-                    ExtractPathSchema<Schema>
-                >
-                handlerContext.path = handlerContext.params.path
-            }
-
-            if (bodySchema) {
-                let rawBody: unknown
-                try {
-                    rawBody = await ctx.request.body.parse()
-                } catch (err) {
-                    if (err instanceof RequestBodyError) throw err
-                    return await validateAndReturn(
-                        resolved.onRequestValidationError(
-                            ValibotValidationError.REQUEST_BODY,
-                            valibotIssuesFromThrowable(err),
-                        ) as HandlerResult<InferResponseBody<ExtractResponseBodySchemas<Schema>>>,
-                    )
-                }
-                const bodyResult = v.safeParse(bodySchema, rawBody)
-                if (!bodyResult.success) {
-                    return await validateAndReturn(
-                        resolved.onRequestValidationError(
-                            ValibotValidationError.REQUEST_BODY,
-                            bodyResult.issues,
-                        ) as HandlerResult<InferResponseBody<ExtractResponseBodySchemas<Schema>>>,
-                    )
-                }
-                handlerContext.params.body = bodyResult.output as InferSchema<
-                    ExtractBodySchema<Schema>
-                >
-                handlerContext.body = handlerContext.params.body
-            }
-
-            const result = await resolved.handler.call(this, handlerContext)
-            return await validateAndReturn(result)
-        }
-
-        return await run()
-    }
-}
-
-/**
- * Build a validated handler plus the matching JSON Schema route metadata.
- *
- * @param options - Valibot-backed handler definition with optional request and response schemas.
- * @returns The validated handler and generated route `schema`.
- */
-export function valibotPartial<
-    Schema extends AnyValibotRouteSchemaInput | undefined,
-    Ctx extends object = object,
->(
-    options: ValibotHandlerOptions<Schema, Ctx>,
-): {
-    handler: Handler<InferResponseBody<ExtractResponseBodySchemas<Schema>>, Ctx>
-    schema?: RouteSchema
-} {
-    const schema = buildRouteSchema(options.schema)
-    return {
-        handler: valibotHandler(options),
-        ...(schema ? { schema } : {}),
-    }
-}
-
-/**
- * Build method-specific route options that validate inputs with Valibot and expose JSON Schema metadata.
- *
- * @example
- * ```ts
- * router.post('/users/:id', withValibot({
- *   name: 'user.update',
- *   schema: {
- *     request: {
- *       path: v.object({id: v.string()}),
- *       body: v.object({name: v.string()}),
- *     },
- *   },
- *   handler: ({path, body}) => ({id: path.id, name: body.name}),
- * }))
- * ```
- *
- * @param options - Method route options extended with Valibot request and response schemas.
- * @returns Route options compatible with method-specific router helpers.
- */
-export function withValibot<
-    Schema extends AnyValibotRouteSchemaInput | undefined,
-    Ctx extends object = object,
-    RouteMiddleware extends MiddlewareInput<Ctx> = undefined,
->(
-    options: WithValibotOptions<Schema, Ctx, undefined, RouteMiddleware>,
-): RouteOptions<Ctx, RouteMiddleware, ValibotRouteContext<Ctx, undefined, RouteMiddleware>> {
-    const {
-        schema,
-        handler,
-        onRequestValidationError,
-        validateResponse,
-        validationResponses,
-        ...routeOptions
-    } = options
-    const partial = valibotPartial<Schema, ValibotRouteContext<Ctx, undefined, RouteMiddleware>>({
-        ...(schema ? { schema } : {}),
-        handler,
-        ...(onRequestValidationError ? { onRequestValidationError } : {}),
-        ...(validationResponses ? { validationResponses } : {}),
-        ...(validateResponse === undefined ? {} : { validateResponse }),
-    } as ValibotHandlerOptions<Schema, ValibotRouteContext<Ctx, undefined, RouteMiddleware>>)
-    return {
-        ...routeOptions,
-        handler: partial.handler,
-        ...(partial.schema ? { schema: partial.schema } : {}),
-    }
-}
-
-/**
- * Create a Valibot route builder with shared defaults.
- *
- * @example
- * ```ts
- * const route = createValibotRouteBuilder({
- *   validateResponse: false,
- *   schema: {
- *     response: {
- *       body: {
- *         400: v.object({message: v.string()}),
- *       },
- *     },
- *   },
- * })
- *
- * router.post('/users/:id', route({
- *   name: 'user.update',
- *   schema: {
- *     request: {
- *       path: v.object({id: v.string()}),
- *     },
- *   },
- *   handler: ({path}) => ({id: path.id}),
- * }))
- * ```
- *
- * @param defaults - Default schema fragments, response validation, and request validation error handling.
- * @returns A route builder compatible with method-specific router helpers and full route definitions.
- */
-export function createValibotRouteBuilder<
-    BuilderMiddleware extends MiddlewareInput<any>,
-    BuilderCtx extends object = ContextFromMiddlewareInput<BuilderMiddleware>,
->(
-    defaults: ValibotRouteHelperDefaults<BuilderCtx, BuilderMiddleware> & {
-        middleware: BuilderMiddleware
-    },
-): ValibotRouteBuilder<BuilderCtx, BuilderMiddleware>
-export function createValibotRouteBuilder<
-    BuilderCtx extends object = object,
-    BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined,
->(
-    defaults?: ValibotRouteHelperDefaults<BuilderCtx, BuilderMiddleware>,
-): ValibotRouteBuilder<BuilderCtx, BuilderMiddleware>
-export function createValibotRouteBuilder<
-    BuilderCtx extends object = object,
-    BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined,
->(
-    defaults: ValibotRouteHelperDefaults<BuilderCtx, BuilderMiddleware> = {},
-): ValibotRouteBuilder<BuilderCtx, BuilderMiddleware> {
-    return (<
-        Schema extends AnyValibotRouteSchemaInput | undefined,
-        RouteMiddleware extends MiddlewareInput<BuilderCtx> = undefined,
-    >(
-        options:
-            | ValibotRouteOptions<Schema, BuilderCtx, BuilderMiddleware, RouteMiddleware>
-            | WithValibotOptions<Schema, BuilderCtx, BuilderMiddleware, RouteMiddleware>,
-    ):
-        | Route<
-              BuilderCtx,
-              ValibotBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>,
-              ValibotRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>
-          >
-        | RouteOptions<
-              BuilderCtx,
-              ValibotBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>,
-              ValibotRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>
-          > => {
-        const merged = mergeValibotOptions(defaults, options)
-        const {
-            schema,
-            handler,
-            onRequestValidationError,
-            validateResponse,
-            validationResponses,
-            middleware,
-            ...routeOptions
-        } = merged
-        const boundary = valibotSchemaMiddleware({
-            ...(schema ? { schema } : {}),
-            ...(onRequestValidationError ? { onRequestValidationError } : {}),
-            ...(validateResponse === undefined ? {} : { validateResponse }),
-            ...(validationResponses === undefined ? {} : { validationResponses }),
-        } as any)
-        const routeMiddleware = mergeMiddleware(
-            middleware as MiddlewareInput<BuilderCtx>,
-            boundary as unknown as MiddlewareInput<BuilderCtx>,
-        )
-        const built = {
-            ...routeOptions,
-            handler,
-            middleware: routeMiddleware,
-        }
-        if (hasRoutePath(built)) {
-            return built as unknown as Route<
-                BuilderCtx,
-                ValibotBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>,
-                ValibotRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>
-            >
-        }
-        return built as unknown as RouteOptions<
-            BuilderCtx,
-            ValibotBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>,
-            ValibotRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>
-        >
-    }) as ValibotRouteBuilder<BuilderCtx, BuilderMiddleware>
-}
-
-/**
- * Build a full route definition that validates inputs with Valibot and exposes JSON Schema metadata.
- *
- * @param options - Route definition extended with Valibot request and response schemas.
- * @returns A route compatible with the core router.
- */
-export function valibotRoute<
-    Schema extends AnyValibotRouteSchemaInput | undefined,
-    Ctx extends object = object,
-    RouteMiddleware extends MiddlewareInput<Ctx> = undefined,
->(
-    options: ValibotRouteOptions<Schema, Ctx, undefined, RouteMiddleware>,
-): Route<Ctx, RouteMiddleware, ValibotRouteContext<Ctx, undefined, RouteMiddleware>> {
-    const {
-        schema,
-        handler,
-        onRequestValidationError,
-        validateResponse,
-        validationResponses,
-        ...route
-    } = options
-    const partial = valibotPartial<Schema, ValibotRouteContext<Ctx, undefined, RouteMiddleware>>({
-        ...(schema ? { schema } : {}),
-        handler,
-        ...(onRequestValidationError ? { onRequestValidationError } : {}),
-        ...(validationResponses ? { validationResponses } : {}),
-        ...(validateResponse === undefined ? {} : { validateResponse }),
-    } as ValibotHandlerOptions<Schema, ValibotRouteContext<Ctx, undefined, RouteMiddleware>>)
-    return {
-        ...route,
-        handler: partial.handler,
-        ...(partial.schema ? { schema: partial.schema } : {}),
-    }
-}