@mpen/routekit 0.1.0 → 0.1.2

package/dist/response/content.d.mts

@@ -0,0 +1,79 @@
+import { n as RoutekitResponse, r as RoutekitResponseInit } from "../core-CzUCxvGk.mjs";
+import { HttpStatus } from "@mpen/http";
+
+//#region src/router/response/formats/content/content.d.ts
+/**
+ * Create a represented `text/plain` response.
+ *
+ * @example
+ * ```ts
+ * return text('pong')
+ * ```
+ *
+ * @param value - Text response body.
+ * @param init - Response status and headers.
+ * @returns Routekit logical response with `Content-Type` set.
+ */
+declare function text(value: string): RoutekitResponse<string, HttpStatus.OK>;
+declare function text(value: string, init: Omit<RoutekitResponseInit, 'status'>): RoutekitResponse<string, HttpStatus.OK>;
+declare function text<const Status extends number>(value: string, init: RoutekitResponseInit<Status> & {
+  status: Status;
+}): RoutekitResponse<string, Status>;
+/**
+ * Create a represented `text/html` response.
+ *
+ * @example
+ * ```ts
+ * return html('<h1>Hello</h1>')
+ * ```
+ *
+ * @param value - HTML response body.
+ * @param init - Response status and headers.
+ * @returns Routekit logical response with `Content-Type` set.
+ */
+declare function html(value: string): RoutekitResponse<string, HttpStatus.OK>;
+declare function html(value: string, init: Omit<RoutekitResponseInit, 'status'>): RoutekitResponse<string, HttpStatus.OK>;
+declare function html<const Status extends number>(value: string, init: RoutekitResponseInit<Status> & {
+  status: Status;
+}): RoutekitResponse<string, Status>;
+//#endregion
+//#region src/router/response/formats/content/bodyless.d.ts
+/**
+ * Create an empty response with the provided status.
+ *
+ * @example
+ * ```ts
+ * return empty(HttpStatus.ACCEPTED)
+ * ```
+ *
+ * @param statusCode - HTTP status code to use.
+ * @param init - Response headers.
+ * @returns Routekit logical response with no body.
+ */
+declare function empty<const Status extends number = HttpStatus.NO_CONTENT>(statusCode?: Status, init?: Omit<RoutekitResponseInit, 'status'>): RoutekitResponse<undefined, Status>;
+/**
+ * Create a `204 No Content` response.
+ *
+ * @example
+ * ```ts
+ * return noContent()
+ * ```
+ *
+ * @returns Routekit logical response with no body.
+ */
+declare function noContent(): RoutekitResponse<undefined, HttpStatus.NO_CONTENT>;
+/**
+ * Create a redirect response.
+ *
+ * @example
+ * ```ts
+ * return redirect('/login')
+ * ```
+ *
+ * @param url - Redirect target URL.
+ * @param statusCode - Redirect status code. Defaults to `302`.
+ * @returns Routekit logical response with a `Location` header.
+ */
+declare function redirect<const Status extends number = HttpStatus.FOUND>(url: string, statusCode?: Status): RoutekitResponse<undefined, Status>;
+//#endregion
+export { empty, html, noContent, redirect, text };

package/dist/response/content.mjs

@@ -0,0 +1,2 @@
+import { a as text, i as html, n as noContent, r as redirect, t as empty } from "../content-BuDOmhH_.mjs";
+export { empty, html, noContent, redirect, text };

package/dist/response/json-rpc.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/response/json-rpc.mjs

@@ -0,0 +1 @@
+export {};

package/dist/response/problem/valibot.d.mts

@@ -0,0 +1,230 @@
+import { C as MiddlewareInput, f as ContextFromMiddlewareInput } from "../../router-Cwb7ak0J.mjs";
+import { n as RoutekitResponse } from "../../core-CzUCxvGk.mjs";
+import { d as ProblemResponse, i as ValidationProblemInit, l as ProblemIssue } from "../../responses-B379Ep9Y.mjs";
+import { i as ValibotRouteBuilder, l as ValibotValidationError, o as ValibotRouteHelperDefaults } from "../../valibot-D7liFYyB.mjs";
+import * as v from "valibot";
+
+//#region src/router/response/formats/problem/valibot.d.ts
+type AnySchema = v.BaseSchema<any, any, any>;
+type StringSchema = v.BaseSchema<any, string, any>;
+type ProblemSchemaResult<CodeSchema extends StringSchema, Schema extends AnySchema> = v.BaseSchema<v.InferInput<Schema>, ProblemResponse<v.InferOutput<CodeSchema> & string>, v.InferIssue<Schema>>;
+declare function createSuccessSchema<const DataSchema extends AnySchema>(dataSchema: DataSchema): v.ObjectSchema<{
+  readonly success: v.LiteralSchema<true, undefined>;
+  readonly data: DataSchema;
+}, undefined>;
+declare function createSuccessSchemaWithMeta<const DataSchema extends AnySchema, const MetaSchema extends AnySchema>(dataSchema: DataSchema, metaSchema: MetaSchema): v.ObjectSchema<{
+  readonly success: v.LiteralSchema<true, undefined>;
+  readonly data: DataSchema;
+  readonly meta: v.OptionalSchema<MetaSchema, undefined>;
+}, undefined>;
+type SuccessSchemaResult<DataSchema extends AnySchema, MetaSchema extends AnySchema | undefined> = MetaSchema extends AnySchema ? ReturnType<typeof createSuccessSchemaWithMeta<DataSchema, MetaSchema>> : ReturnType<typeof createSuccessSchema<DataSchema>>;
+/**
+ * Create a Valibot schema for standard response issues.
+ *
+ * @example
+ * ```ts
+ * const schema = problemIssueSchema(v.picklist(['required', 'invalid_type']))
+ * ```
+ *
+ * @param codeSchema - Optional issue code schema. Defaults to `v.string()`.
+ * @returns Valibot object schema for [`ProblemIssue`]{@link ProblemIssue}.
+ * @typeParam CodeSchema - Valibot schema used for issue codes.
+ */
+declare function problemIssueSchema<const CodeSchema extends StringSchema = StringSchema>(codeSchema?: CodeSchema): v.ObjectSchema<{
+  readonly code: CodeSchema;
+  readonly message: v.StringSchema<undefined>;
+  readonly path: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>;
+  readonly expected: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly received: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Create a Valibot schema for standard primary error metadata.
+ *
+ * @example
+ * ```ts
+ * const schema = problemErrorSchema(v.picklist(['not_found', 'validation_failed']))
+ * ```
+ *
+ * @param codeSchema - Optional primary error code schema. Defaults to `v.string()`.
+ * @returns Valibot object schema for problem error metadata.
+ * @typeParam CodeSchema - Valibot schema used for primary error codes.
+ */
+declare function problemErrorSchema<const CodeSchema extends StringSchema = StringSchema>(codeSchema?: CodeSchema): v.ObjectSchema<{
+  readonly code: CodeSchema;
+  readonly message: v.StringSchema<undefined>;
+  readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Create a Valibot schema for successful standard response envelopes.
+ *
+ * @example
+ * ```ts
+ * const schema = okSchema(v.object({ id: v.string() }))
+ * ```
+ *
+ * @param dataSchema - Valibot schema for the response payload.
+ * @param metaSchema - Optional Valibot schema for response metadata.
+ * @returns Valibot object schema for a successful standard response.
+ * @typeParam DataSchema - Valibot schema used for the response payload.
+ * @typeParam MetaSchema - Optional Valibot schema used for response metadata.
+ */
+declare function okSchema<const DataSchema extends AnySchema, const MetaSchema extends AnySchema | undefined = undefined>(dataSchema: DataSchema, metaSchema?: MetaSchema): SuccessSchemaResult<DataSchema, MetaSchema>;
+/**
+ * Create a Valibot schema for standard problem response envelopes.
+ *
+ * @example
+ * ```ts
+ * const schema = problemSchema({
+ *     code: v.picklist(['not_found', 'validation_failed']),
+ * })
+ * ```
+ *
+ * @param options - Optional primary error and issue schemas.
+ * @returns Valibot object schema for a standard problem response.
+ * @typeParam CodeSchema - Valibot schema used for primary error codes.
+ * @typeParam IssueSchema - Valibot schema used for response issues.
+ */
+declare function problemSchema<const CodeSchema extends StringSchema = StringSchema, const IssueSchema extends AnySchema = ReturnType<typeof problemIssueSchema>>(options?: {
+  code?: CodeSchema;
+  issue?: IssueSchema;
+}): ProblemSchemaResult<CodeSchema, v.ObjectSchema<{
+  readonly success: v.LiteralSchema<false, undefined>;
+  readonly error: v.ObjectSchema<{
+    readonly code: CodeSchema;
+    readonly message: v.StringSchema<undefined>;
+    readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly issues: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<IssueSchema, undefined>, v.ReadonlyAction<v.InferOutput<IssueSchema>[]>]>, undefined>;
+}, undefined>>;
+/**
+ * Create a Valibot schema for the full standard response union.
+ *
+ * @example
+ * ```ts
+ * const schema = standardResponseSchema(v.object({ id: v.string() }), {
+ *     code: v.picklist(['not_found']),
+ * })
+ * ```
+ *
+ * @param dataSchema - Valibot schema for the successful response payload.
+ * @param options - Optional metadata, primary error, and issue schemas.
+ * @returns Valibot union schema for successful and problem responses.
+ * @typeParam DataSchema - Valibot schema used for the response payload.
+ * @typeParam MetaSchema - Optional Valibot schema used for response metadata.
+ * @typeParam CodeSchema - Valibot schema used for primary error codes.
+ * @typeParam IssueSchema - Valibot schema used for response issues.
+ */
+declare function standardResponseSchema<const DataSchema extends AnySchema, const MetaSchema extends AnySchema | undefined = undefined, const CodeSchema extends StringSchema = StringSchema, const IssueSchema extends AnySchema = ReturnType<typeof problemIssueSchema>>(dataSchema: DataSchema, options?: {
+  meta?: MetaSchema;
+  code?: CodeSchema;
+  issue?: IssueSchema;
+}): v.UnionSchema<[v.ObjectSchema<{
+  readonly success: v.LiteralSchema<true, undefined>;
+  readonly data: DataSchema;
+}, undefined> | SuccessSchemaResult<DataSchema, MetaSchema & {}>, ProblemSchemaResult<CodeSchema, v.ObjectSchema<{
+  readonly success: v.LiteralSchema<false, undefined>;
+  readonly error: v.ObjectSchema<{
+    readonly code: CodeSchema;
+    readonly message: v.StringSchema<undefined>;
+    readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly issues: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<IssueSchema, undefined>, v.ReadonlyAction<v.InferOutput<IssueSchema>[]>]>, undefined>;
+}, undefined>>], undefined>;
+/**
+ * Convert a Valibot issue into a standard response issue.
+ *
+ * @example
+ * ```ts
+ * const parsed = v.safeParse(v.object({ id: v.string() }), { id: 123 })
+ * if (!parsed.success) {
+ *     const issue = issueFromValibotIssue(parsed.issues[0])
+ * }
+ * ```
+ *
+ * @param issue - Valibot issue to convert.
+ * @returns Standard response issue.
+ */
+declare function issueFromValibotIssue(issue: v.BaseIssue<unknown>): ProblemIssue;
+/**
+ * Convert Valibot issues into standard response issues.
+ *
+ * @example
+ * ```ts
+ * const parsed = v.safeParse(v.object({ id: v.string() }), { id: 123 })
+ * if (!parsed.success) {
+ *     const issues = issuesFromValibotIssues(parsed.issues)
+ * }
+ * ```
+ *
+ * @param issues - Valibot issues to convert.
+ * @returns Standard response issues.
+ */
+declare function issuesFromValibotIssues(issues: readonly v.BaseIssue<unknown>[]): ProblemIssue[];
+/**
+ * Create a validation problem response from Valibot issues.
+ *
+ * @example
+ * ```ts
+ * const route = createValibotRouteBuilder()
+ * route({
+ *     onRequestValidationError: (_component, issues) => validationProblemFromValibotIssues(issues),
+ *     handler: () => ok({ saved: true }),
+ * })
+ * ```
+ *
+ * @param issues - Valibot issues to convert and include in the response.
+ * @param init - Optional problem response overrides and headers.
+ * @returns Routekit logical response with a validation [`ProblemResponse`]{@link ProblemResponse}.
+ * @typeParam Code - Machine-readable primary error code.
+ */
+declare function validationProblemFromValibotIssues<const Code extends string = 'validation_failed'>(issues: readonly v.BaseIssue<unknown>[], init?: ValidationProblemInit<Code>): RoutekitResponse<ProblemResponse<Code>>;
+/**
+ * A Valibot validation error handler that maps request validation errors to problem-compliant responses.
+ *
+ * This handler returns `422 Unprocessable Content` with error code `validation_failed:body` for request body
+ * validation failures, and `400 Bad Request` with `validation_failed:query` or `validation_failed:path` for
+ * query and path parameter validation failures respectively.
+ *
+ * @example
+ * ```ts
+ * const route = createValibotRouteBuilder({
+ *     onRequestValidationError: problemValidationErrorHandler,
+ * })
+ * ```
+ *
+ * @param component - The request component that failed validation.
+ * @param issues - A non-empty tuple of Valibot validation issues.
+ * @returns A Routekit handler result containing the formatted problem response.
+ */
+declare function problemValidationErrorHandler(component: ValibotValidationError, issues: [v.BaseIssue<unknown>, ...v.BaseIssue<unknown>[]]): RoutekitResponse<ProblemResponse<'validation_failed:body' | 'validation_failed:query' | 'validation_failed:path'>>;
+/**
+ * Create a Valibot route builder pre-configured with problem-spec-compliant request validation errors.
+ *
+ * This route builder automatically configures standard error schemas for `400 Bad Request` and
+ * `422 Unprocessable Content` statuses. It also uses [`problemValidationErrorHandler`]{@link problemValidationErrorHandler}
+ * as its default validation error handler to output structured JSON responses when validation fails.
+ *
+ * @example
+ * ```ts
+ * const route = createValibotRouteBuilder()
+ *
+ * router.post('/todos', route({
+ *     schema: {
+ *         request: {
+ *             body: v.object({ title: v.string() })
+ *         }
+ *     },
+ *     handler: ({ body }) => ok({ title: body.title })
+ * }))
+ * ```
+ *
+ * @param defaults - Additional defaults to apply to built routes.
+ * @returns A problem-spec-compliant Valibot route builder.
+ * @typeParam BuilderCtx - Custom context registered by middlewares (e.g. Services, Auth).
+ */
+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 { createValibotRouteBuilder, issueFromValibotIssue, issuesFromValibotIssues, okSchema, problemErrorSchema, problemIssueSchema, problemSchema, problemValidationErrorHandler, standardResponseSchema, validationProblemFromValibotIssues };

package/dist/response/problem/valibot.mjs

@@ -0,0 +1,258 @@
+import { i as validationProblem } from "../../responses-BpVrgeYi.mjs";
+import { n as createValibotRouteBuilder$1 } from "../../valibot-Du97X-TS.mjs";
+import { HttpStatus } from "@mpen/http";
+import * as v from "valibot";
+//#region src/router/response/formats/problem/valibot.ts
+function pathSegmentFromValibotKey(key) {
+	if (typeof key === "string" || typeof key === "number") return key;
+}
+function pathFromValibotIssue(issue) {
+	const path = issue.path?.map((item) => pathSegmentFromValibotKey(item.key)).filter((item) => item !== void 0);
+	return path?.length ? path : void 0;
+}
+function collectValibotIssues(issue, target) {
+	if (issue.issues?.length) {
+		for (const child of issue.issues) collectValibotIssues(child, target);
+		return target;
+	}
+	target.push(issueFromValibotIssue(issue));
+	return target;
+}
+function createSuccessSchema(dataSchema) {
+	return v.object({
+		success: v.literal(true),
+		data: dataSchema
+	});
+}
+function createSuccessSchemaWithMeta(dataSchema, metaSchema) {
+	return v.object({
+		success: v.literal(true),
+		data: dataSchema,
+		meta: v.optional(metaSchema)
+	});
+}
+/**
+* Create a Valibot schema for standard response issues.
+*
+* @example
+* ```ts
+* const schema = problemIssueSchema(v.picklist(['required', 'invalid_type']))
+* ```
+*
+* @param codeSchema - Optional issue code schema. Defaults to `v.string()`.
+* @returns Valibot object schema for [`ProblemIssue`]{@link ProblemIssue}.
+* @typeParam CodeSchema - Valibot schema used for issue codes.
+*/
+function problemIssueSchema(codeSchema = v.string()) {
+	return v.object({
+		code: codeSchema,
+		message: v.string(),
+		path: v.optional(v.pipe(v.array(v.union([v.string(), v.number()])), v.readonly())),
+		expected: v.optional(v.string()),
+		received: v.optional(v.string())
+	});
+}
+/**
+* Create a Valibot schema for standard primary error metadata.
+*
+* @example
+* ```ts
+* const schema = problemErrorSchema(v.picklist(['not_found', 'validation_failed']))
+* ```
+*
+* @param codeSchema - Optional primary error code schema. Defaults to `v.string()`.
+* @returns Valibot object schema for problem error metadata.
+* @typeParam CodeSchema - Valibot schema used for primary error codes.
+*/
+function problemErrorSchema(codeSchema = v.string()) {
+	return v.object({
+		code: codeSchema,
+		message: v.string(),
+		title: v.optional(v.string())
+	});
+}
+/**
+* Create a Valibot schema for successful standard response envelopes.
+*
+* @example
+* ```ts
+* const schema = okSchema(v.object({ id: v.string() }))
+* ```
+*
+* @param dataSchema - Valibot schema for the response payload.
+* @param metaSchema - Optional Valibot schema for response metadata.
+* @returns Valibot object schema for a successful standard response.
+* @typeParam DataSchema - Valibot schema used for the response payload.
+* @typeParam MetaSchema - Optional Valibot schema used for response metadata.
+*/
+function okSchema(dataSchema, metaSchema) {
+	if (metaSchema) return createSuccessSchemaWithMeta(dataSchema, metaSchema);
+	return createSuccessSchema(dataSchema);
+}
+/**
+* Create a Valibot schema for standard problem response envelopes.
+*
+* @example
+* ```ts
+* const schema = problemSchema({
+*     code: v.picklist(['not_found', 'validation_failed']),
+* })
+* ```
+*
+* @param options - Optional primary error and issue schemas.
+* @returns Valibot object schema for a standard problem response.
+* @typeParam CodeSchema - Valibot schema used for primary error codes.
+* @typeParam IssueSchema - Valibot schema used for response issues.
+*/
+function problemSchema(options = {}) {
+	const codeSchema = options.code ?? v.string();
+	const issueSchema = options.issue ?? problemIssueSchema();
+	return v.object({
+		success: v.literal(false),
+		error: problemErrorSchema(codeSchema),
+		issues: v.optional(v.pipe(v.array(issueSchema), v.readonly()))
+	});
+}
+/**
+* Create a Valibot schema for the full standard response union.
+*
+* @example
+* ```ts
+* const schema = standardResponseSchema(v.object({ id: v.string() }), {
+*     code: v.picklist(['not_found']),
+* })
+* ```
+*
+* @param dataSchema - Valibot schema for the successful response payload.
+* @param options - Optional metadata, primary error, and issue schemas.
+* @returns Valibot union schema for successful and problem responses.
+* @typeParam DataSchema - Valibot schema used for the response payload.
+* @typeParam MetaSchema - Optional Valibot schema used for response metadata.
+* @typeParam CodeSchema - Valibot schema used for primary error codes.
+* @typeParam IssueSchema - Valibot schema used for response issues.
+*/
+function standardResponseSchema(dataSchema, options = {}) {
+	const successEnvelopeSchema = options.meta === void 0 ? okSchema(dataSchema) : okSchema(dataSchema, options.meta);
+	return v.union([successEnvelopeSchema, problemSchema({
+		code: options.code,
+		issue: options.issue
+	})]);
+}
+/**
+* Convert a Valibot issue into a standard response issue.
+*
+* @example
+* ```ts
+* const parsed = v.safeParse(v.object({ id: v.string() }), { id: 123 })
+* if (!parsed.success) {
+*     const issue = issueFromValibotIssue(parsed.issues[0])
+* }
+* ```
+*
+* @param issue - Valibot issue to convert.
+* @returns Standard response issue.
+*/
+function issueFromValibotIssue(issue) {
+	const path = pathFromValibotIssue(issue);
+	return {
+		code: issue.type,
+		message: issue.message,
+		...path ? { path } : {},
+		...issue.expected == null ? {} : { expected: issue.expected },
+		received: issue.received
+	};
+}
+/**
+* Convert Valibot issues into standard response issues.
+*
+* @example
+* ```ts
+* const parsed = v.safeParse(v.object({ id: v.string() }), { id: 123 })
+* if (!parsed.success) {
+*     const issues = issuesFromValibotIssues(parsed.issues)
+* }
+* ```
+*
+* @param issues - Valibot issues to convert.
+* @returns Standard response issues.
+*/
+function issuesFromValibotIssues(issues) {
+	return issues.flatMap((issue) => collectValibotIssues(issue, []));
+}
+/**
+* Create a validation problem response from Valibot issues.
+*
+* @example
+* ```ts
+* const route = createValibotRouteBuilder()
+* route({
+*     onRequestValidationError: (_component, issues) => validationProblemFromValibotIssues(issues),
+*     handler: () => ok({ saved: true }),
+* })
+* ```
+*
+* @param issues - Valibot issues to convert and include in the response.
+* @param init - Optional problem response overrides and headers.
+* @returns Routekit logical response with a validation [`ProblemResponse`]{@link ProblemResponse}.
+* @typeParam Code - Machine-readable primary error code.
+*/
+function validationProblemFromValibotIssues(issues, init = {}) {
+	return validationProblem(issuesFromValibotIssues(issues), init);
+}
+/**
+* A Valibot validation error handler that maps request validation errors to problem-compliant responses.
+*
+* This handler returns `422 Unprocessable Content` with error code `validation_failed:body` for request body
+* validation failures, and `400 Bad Request` with `validation_failed:query` or `validation_failed:path` for
+* query and path parameter validation failures respectively.
+*
+* @example
+* ```ts
+* const route = createValibotRouteBuilder({
+*     onRequestValidationError: problemValidationErrorHandler,
+* })
+* ```
+*
+* @param component - The request component that failed validation.
+* @param issues - A non-empty tuple of Valibot validation issues.
+* @returns A Routekit handler result containing the formatted problem response.
+*/
+function problemValidationErrorHandler(component, issues) {
+	let code;
+	let status;
+	switch (component) {
+		case 0:
+			code = "validation_failed:body";
+			status = HttpStatus.UNPROCESSABLE_ENTITY;
+			break;
+		case 2:
+			code = "validation_failed:query";
+			status = HttpStatus.BAD_REQUEST;
+			break;
+		case 1:
+			code = "validation_failed:path";
+			status = HttpStatus.BAD_REQUEST;
+			break;
+		default:
+			code = "validation_failed:body";
+			status = HttpStatus.UNPROCESSABLE_ENTITY;
+			break;
+	}
+	return validationProblemFromValibotIssues(issues, {
+		code,
+		status,
+		message: `Validation failed: ${component === 0 ? "body" : component === 2 ? "query" : "path"}`
+	});
+}
+function createValibotRouteBuilder(defaults = {}) {
+	return createValibotRouteBuilder$1({
+		onRequestValidationError: problemValidationErrorHandler,
+		validationResponses: { response: { body: {
+			400: v.union([problemSchema({ code: v.literal("validation_failed:query") }), problemSchema({ code: v.literal("validation_failed:path") })]),
+			422: problemSchema({ code: v.literal("validation_failed:body") })
+		} } }.response.body,
+		...defaults
+	});
+}
+//#endregion
+export { createValibotRouteBuilder, issueFromValibotIssue, issuesFromValibotIssues, okSchema, problemErrorSchema, problemIssueSchema, problemSchema, problemValidationErrorHandler, standardResponseSchema, validationProblemFromValibotIssues };