@mpen/routekit 0.1.0 → 0.1.1

package/dist/valibot-D7liFYyB.d.mts

@@ -0,0 +1,290 @@
+import { C as MiddlewareInput, I as RouteOptions, N as Route, a as MiddlewareResponseDeclaration, f as ContextFromMiddlewareInput, g as HandlerResult, h as HandlerContext, l as AddedContextFromMiddlewareInput, n as DeclaredMiddleware, r as DefineMiddlewareOptions, t as Router } from "./router-Cwb7ak0J.mjs";
+import { n as RoutekitResponse } from "./core-CzUCxvGk.mjs";
+import * as v from "valibot";
+
+//#region src/router/routes/valibot/valibot.d.ts
+/**
+ * Validation error component identifiers for Valibot-backed routes.
+ */
+declare const enum ValibotValidationError {
+  REQUEST_BODY = 0,
+  URL_PATH = 1,
+  QUERY_PARAMETERS = 2
+}
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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}),
+ * }))
+ * ```
+ */
+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>>;
+};
+/**
+ * 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.
+ */
+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.
+ */
+declare function defineValibotMiddleware<AddedCtx extends object = {}, Ctx extends object = object, const Responses extends AnyValibotResponseBodySchemas = {}>(options: DefineValibotMiddlewareOptions<AddedCtx, Ctx, Responses>): DeclaredMiddleware<AddedCtx, Ctx>;
+/**
+ * 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.
+ */
+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.
+ */
+declare function valibotSchemaMiddleware<Schema extends AnyValibotRouteSchemaInput | undefined, const ValidationResponses extends AnyValibotResponseBodySchemas | undefined = undefined, Ctx extends object = object>(options: ValibotSchemaMiddlewareOptions<Schema, ValidationResponses>): DeclaredMiddleware<ValibotSchemaMiddlewareContext<Schema>, Ctx>;
+/**
+ * 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.
+ */
+declare function createValibotRouteBuilder<BuilderMiddleware extends MiddlewareInput<any>, BuilderCtx extends object = ContextFromMiddlewareInput<BuilderMiddleware>>(defaults: ValibotRouteHelperDefaults<BuilderCtx, BuilderMiddleware> & {
+  middleware: BuilderMiddleware;
+}): ValibotRouteBuilder<BuilderCtx, BuilderMiddleware>;
+declare function createValibotRouteBuilder<BuilderCtx extends object = object, BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined>(defaults?: ValibotRouteHelperDefaults<BuilderCtx, BuilderMiddleware>): ValibotRouteBuilder<BuilderCtx, BuilderMiddleware>;
+//#endregion
+export { ValibotRouteHandler as a, ValibotSchemaMiddlewareOptions as c, ValibotValidationErrorHandler as d, createValibotRouteBuilder as f, ValibotRouteBuilder as i, ValibotValidationError as l, valibotSchemaMiddleware as m, ValibotHandlerContext as n, ValibotRouteHelperDefaults as o, defineValibotMiddleware as p, ValibotHandlerParams as r, ValibotRouteSchemaInput as s, DefineValibotMiddlewareOptions as t, ValibotValidationErrorBody as u };

package/dist/valibot-Du97X-TS.mjs

@@ -0,0 +1,326 @@
+import { M as isJsonContentType, f as defineMiddleware, t as RequestBodyError } from "./request-Dn0zc-xm.mjs";
+import { a as response, i as isRoutekitResponse, r as isRoutekitBody } from "./core-DbmQauwS.mjs";
+import { HttpStatus } from "@mpen/http";
+import * as v from "valibot";
+import { toJsonSchema } from "@valibot/to-json-schema";
+//#region src/router/routes/valibot/valibot.ts
+/**
+* Validation error component identifiers for Valibot-backed routes.
+*/
+let ValibotValidationError = /* @__PURE__ */ function(ValibotValidationError) {
+	ValibotValidationError[ValibotValidationError["REQUEST_BODY"] = 0] = "REQUEST_BODY";
+	ValibotValidationError[ValibotValidationError["URL_PATH"] = 1] = "URL_PATH";
+	ValibotValidationError[ValibotValidationError["QUERY_PARAMETERS"] = 2] = "QUERY_PARAMETERS";
+	return ValibotValidationError;
+}({});
+const validationErrorComponentName = new Map([
+	[0, "request_body"],
+	[1, "url_path"],
+	[2, "query_parameters"]
+]);
+const jsonSchemaApproximationConfig = {
+	target: "draft-07",
+	errorMode: "ignore"
+};
+var ValibotResponseValidationError = class extends Error {
+	status;
+	issues;
+	constructor(status, issues) {
+		super(`Response validation failed for status ${status}: ${v.summarize(issues)}`);
+		this.name = "ValibotResponseValidationError";
+		this.status = status;
+		this.issues = issues;
+	}
+};
+function createValidationResponse(component, issues) {
+	return response({
+		component: validationErrorComponentName.get(component) ?? "request_body",
+		issues,
+		message: v.summarize(issues)
+	}, { status: HttpStatus.BAD_REQUEST });
+}
+function normalizeResponseValidationMode(option) {
+	if (option === true) return "strict";
+	return option;
+}
+function readQueryParams(searchParams) {
+	const query = {};
+	for (const [key, value] of searchParams.entries()) {
+		const existing = query[key];
+		if (existing === void 0) {
+			query[key] = value;
+			continue;
+		}
+		if (Array.isArray(existing)) existing.push(value);
+		else query[key] = [existing, value];
+	}
+	return query;
+}
+function valibotIssuesFromThrowable(error) {
+	return [{
+		kind: "schema",
+		type: "custom",
+		input: void 0,
+		expected: null,
+		received: "unknown",
+		message: error instanceof Error ? error.message : String(error)
+	}];
+}
+function sanitizeJsonSchema(schema) {
+	if (Array.isArray(schema)) return schema.map((entry) => sanitizeJsonSchema(entry));
+	if (!schema || typeof schema !== "object") return schema;
+	const sanitizedEntries = Object.entries(schema).filter(([key]) => key !== "$schema" && key !== "~standard").map(([key, value]) => [key, sanitizeJsonSchema(value)]);
+	return Object.fromEntries(sanitizedEntries);
+}
+function toRequestJsonSchema(schema) {
+	return sanitizeJsonSchema(toJsonSchema(schema, {
+		...jsonSchemaApproximationConfig,
+		typeMode: "input"
+	}));
+}
+function toResponseJsonSchema(schema) {
+	return sanitizeJsonSchema(toJsonSchema(schema, {
+		...jsonSchemaApproximationConfig,
+		typeMode: "output"
+	}));
+}
+function buildRouteSchema(schema) {
+	if (!schema) return void 0;
+	const request = schema.request ? {
+		...schema.request.query ? { query: toRequestJsonSchema(schema.request.query) } : {},
+		...schema.request.path ? { path: toRequestJsonSchema(schema.request.path) } : {},
+		...schema.request.body ? { body: toRequestJsonSchema(schema.request.body) } : {}
+	} : void 0;
+	const responseBody = schema.response?.body ? Object.fromEntries(Object.entries(schema.response.body).map(([status, responseSchema]) => {
+		return [status === "default" ? status : Number(status), toResponseJsonSchema(responseSchema)];
+	})) : void 0;
+	const response = responseBody && Object.keys(responseBody).length > 0 ? { body: responseBody } : void 0;
+	if ((!request || Object.keys(request).length === 0) && !response) return;
+	return {
+		...request && Object.keys(request).length > 0 ? { request } : {},
+		...response ? { response } : {}
+	};
+}
+function buildValibotMiddlewareDeclarations(schemas) {
+	return Object.fromEntries(Object.entries(schemas).flatMap(([status, schema]) => schema ? [[status, {
+		schema: toResponseJsonSchema(schema),
+		parse: (value) => v.parse(schema, value)
+	}]] : []));
+}
+function defineValibotMiddleware(options) {
+	return defineMiddleware({
+		responses: buildValibotMiddlewareDeclarations(options.responses),
+		run: options.run
+	});
+}
+function mergeRouteSchema(defaults, schema) {
+	const defaultSchema = defaults.schema;
+	if (!defaultSchema) return schema;
+	if (!schema) return defaultSchema;
+	const request = !defaultSchema.request && !schema.request ? void 0 : {
+		...defaultSchema.request,
+		...schema.request
+	};
+	const defaultBody = defaultSchema.response?.body ?? {};
+	const routeBody = schema.response?.body ?? {};
+	const responseBody = {};
+	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];
+		const routeStatusSchema = routeBody[s];
+		if (defaultStatusSchema && routeStatusSchema) responseBody[s] = v.union([defaultStatusSchema, routeStatusSchema]);
+		else if (defaultStatusSchema) responseBody[s] = defaultStatusSchema;
+		else if (routeStatusSchema) responseBody[s] = routeStatusSchema;
+	}
+	const response = Object.keys(responseBody).length > 0 ? { body: responseBody } : void 0;
+	return {
+		...request ? { request } : {},
+		...response ? { response } : {}
+	};
+}
+function normalizeMiddlewareInput(middleware) {
+	if (!middleware) return [];
+	if (Array.isArray(middleware)) return middleware.filter(Boolean);
+	return [middleware];
+}
+function mergeMiddleware(defaultMiddleware, routeMiddleware) {
+	const list = [...normalizeMiddlewareInput(defaultMiddleware), ...normalizeMiddlewareInput(routeMiddleware)];
+	return list.length ? list : void 0;
+}
+function mergeValibotOptions(defaults, options) {
+	const { middleware: defaultMiddleware, ...defaultOptions } = defaults;
+	const schema = mergeRouteSchema(defaults, options.schema);
+	const middleware = mergeMiddleware(defaultMiddleware, options.middleware);
+	return {
+		...defaultOptions,
+		...options,
+		...schema === void 0 ? {} : { schema },
+		...middleware === void 0 ? {} : { middleware }
+	};
+}
+function hasRoutePath(options) {
+	return options.path !== void 0;
+}
+function isSkippableResponseValidationValue(value) {
+	return value instanceof ReadableStream || value instanceof Uint8Array || typeof Buffer !== "undefined" && value instanceof Buffer || !!value && typeof value === "object" && Symbol.asyncIterator in value;
+}
+function jsonValuesEqual(left, right) {
+	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;
+	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, status) {
+	return schema?.response?.body?.[status] ?? schema?.response?.body?.default;
+}
+async function readResponseBodyForValidation(response) {
+	if (!response.body) return void 0;
+	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, value) {
+	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 === void 0 ? void 0 : JSON.stringify(value), {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+function parseResponseSchema(schema, status, value, mode) {
+	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(/* @__PURE__ */ new Error("Response body does not match the parsed schema output.")));
+	return mode === "parse" ? result.output : value;
+}
+async function validateHandlerResult(schema, result, mode) {
+	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()
+});
+/**
+* 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.
+*/
+function valibotSchemaMiddleware(options) {
+	const validateResponse = normalizeResponseValidationMode(options.validateResponse) ?? "parse";
+	const parsesRequest = options.schema?.request !== void 0;
+	const declarations = buildValibotMiddlewareDeclarations(options.validationResponses ?? (parsesRequest ? { [HttpStatus.BAD_REQUEST]: defaultValidationErrorSchema } : {}));
+	const onRequestValidationError = options.onRequestValidationError ?? createValidationResponse;
+	return defineMiddleware({
+		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,
+				query: void 0,
+				body: void 0
+			};
+			const handlerContext = ctx;
+			handlerContext.params = handlerParams;
+			if (querySchema) {
+				const parsed = v.safeParse(querySchema, queryParams);
+				if (!parsed.success) return respond(onRequestValidationError(2, parsed.issues));
+				handlerParams.query = parsed.output;
+				handlerContext.query = handlerParams.query;
+			}
+			if (pathSchema) {
+				const parsed = v.safeParse(pathSchema, ctx.path);
+				if (!parsed.success) return respond(onRequestValidationError(1, parsed.issues));
+				handlerParams.path = parsed.output;
+				handlerContext.path = handlerParams.path;
+			}
+			if (bodySchema) {
+				let rawBody;
+				try {
+					rawBody = await ctx.request.body.parse();
+				} catch (err) {
+					if (err instanceof RequestBodyError) throw err;
+					return respond(onRequestValidationError(0, valibotIssuesFromThrowable(err)));
+				}
+				const parsed = v.safeParse(bodySchema, rawBody);
+				if (!parsed.success) return respond(onRequestValidationError(0, parsed.issues));
+				handlerParams.body = parsed.output;
+				handlerContext.body = handlerParams.body;
+			}
+			const result = await next();
+			return forward(validateResponse === false ? result : await validateHandlerResult(options.schema, result, validateResponse));
+		}
+	});
+}
+function createValibotRouteBuilder(defaults = {}) {
+	return ((options) => {
+		const { schema, handler, onRequestValidationError, validateResponse, validationResponses, middleware, ...routeOptions } = mergeValibotOptions(defaults, options);
+		const routeMiddleware = mergeMiddleware(middleware, valibotSchemaMiddleware({
+			...schema ? { schema } : {},
+			...onRequestValidationError ? { onRequestValidationError } : {},
+			...validateResponse === void 0 ? {} : { validateResponse },
+			...validationResponses === void 0 ? {} : { validationResponses }
+		}));
+		const built = {
+			...routeOptions,
+			handler,
+			middleware: routeMiddleware
+		};
+		if (hasRoutePath(built)) return built;
+		return built;
+	});
+}
+//#endregion
+export { valibotSchemaMiddleware as i, createValibotRouteBuilder as n, defineValibotMiddleware as r, ValibotValidationError as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpen/routekit",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Typed server-side routing utilities for Fetch-compatible runtimes.",
   "exports": {
     ".": "./dist/index.mjs",
@@ -21,7 +21,8 @@
     "routekit": "./dist/bin.mjs"
   },
   "files": [
-    "src"
+    "dist",
+    "README.md"
   ],
   "module": "./dist/index.mjs",
   "type": "module",
@@ -91,5 +92,10 @@
   "types": "./dist/index.d.mts",
   "publishConfig": {
     "access": "public"
+  },
+  "publishHash": {
+    "buildDate": "2026-05-30T17:02:21.521-07:00",
+    "hgChangesetId": "60958a12c122+",
+    "sha256": "99d67ed8a13ebfe8f5edc5bb1f4d551d85fdbc287d311fffe8cdc860234ed9c6"
   }
 }