@mpen/routekit 0.1.0 → 0.1.2

package/dist/router-Cwb7ak0J.d.mts

@@ -0,0 +1,1819 @@
+import { l as RouterBodyInit, n as RoutekitResponse, t as RoutekitBody, u as RouterHeadersInit } from "./core-CzUCxvGk.mjs";
+import { HttpMethod, HttpStatus } from "@mpen/http";
+import { Logger } from "@mpen/logger";
+
+//#region src/router/server-interface.d.ts
+interface SimpleServerInterface {
+  fetch(request: Request): Promise<Response>;
+}
+//#endregion
+//#region src/router/response/framers.d.ts
+type MaybePromise$2<T> = T | Promise<T>;
+type BodyChunk = string | Uint8Array | Buffer;
+/**
+ * Framer used by streaming generators to encode structured chunks.
+ *
+ * @example
+ * ```ts
+ * yield stream(sseFramer())
+ * yield chunk({event: 'ready'})
+ * ```
+ */
+interface StreamFramer<T = unknown> {
+  /**
+   * Content type for the stream.
+   */
+  contentType: string;
+  /**
+   * Headers to add when this stream starts.
+   */
+  headers?: RouterHeadersInit;
+  /**
+   * Return `true` when this framer can encode the provided chunk.
+   *
+   * @param value - Stream chunk to inspect.
+   * @returns Whether `value` can be framed.
+   */
+  canFrame?: (value: unknown) => value is T;
+  /**
+   * Encode one logical stream chunk.
+   *
+   * @param value - Stream chunk to encode.
+   * @returns Encoded stream bytes or text.
+   */
+  frame(value: T): MaybePromise$2<BodyChunk>;
+  /**
+   * Optional final stream bytes emitted when the generator completes.
+   *
+   * @returns Encoded closing bytes or text.
+   */
+  close?(): MaybePromise$2<BodyChunk | undefined>;
+}
+/**
+ * Create an SSE stream framer.
+ *
+ * @example
+ * ```ts
+ * yield stream(sseFramer())
+ * yield chunk({event: 'ready'})
+ * ```
+ *
+ * @returns Stream framer for `text/event-stream`.
+ */
+declare function sseFramer(): StreamFramer<unknown>;
+/**
+ * Create a JSON Lines stream framer.
+ *
+ * @example
+ * ```ts
+ * yield stream(jsonLinesFramer())
+ * yield chunk({event: 'ready'})
+ * ```
+ *
+ * @returns Stream framer for `application/jsonl`.
+ */
+declare function jsonLinesFramer(): StreamFramer<unknown>;
+//#endregion
+//#region src/router/response/directives.d.ts
+declare const routekitDirectiveBrand: unique symbol;
+interface BaseDirective {
+  readonly [routekitDirectiveBrand]: true;
+}
+/**
+ * Generator directive that sets the response status.
+ */
+interface StatusDirective extends BaseDirective {
+  kind: 'status';
+  status: number | HttpStatus;
+}
+/**
+ * Generator directive that merges response headers.
+ */
+interface HeadersDirective extends BaseDirective {
+  kind: 'headers';
+  headers: Headers;
+}
+/**
+ * Generator directive that sets response status and merges response headers.
+ */
+interface HeadDirective extends BaseDirective {
+  kind: 'head';
+  status: number | HttpStatus;
+  headers: Headers;
+}
+/**
+ * Generator directive that starts structured streaming with a framer.
+ */
+interface StreamDirective<T = unknown> extends BaseDirective {
+  kind: 'stream';
+  framer: StreamFramer<T>;
+  headers: Headers;
+}
+/**
+ * Generator directive that emits one stream chunk.
+ */
+interface ChunkDirective<T = unknown> extends BaseDirective {
+  kind: 'chunk';
+  value: T;
+}
+/**
+ * Values that generator-style handlers may yield.
+ */
+type RoutekitYield = StatusDirective | HeadersDirective | HeadDirective | StreamDirective | ChunkDirective | undefined;
+/**
+ * Test whether a value is a generator directive.
+ *
+ * @example
+ * ```ts
+ * if (isRoutekitDirective(value)) console.log(value.kind)
+ * ```
+ *
+ * @param value - Value to inspect.
+ * @returns Whether `value` is a Routekit generator directive.
+ */
+declare function isRoutekitDirective(value: unknown): value is Exclude<RoutekitYield, undefined>;
+/**
+ * Test whether a value is a status directive.
+ *
+ * @param value - Value to inspect.
+ * @returns Whether `value` was created by [`status`]{@link status}.
+ */
+declare function isStatusDirective(value: unknown): value is StatusDirective;
+/**
+ * Test whether a value is a headers directive.
+ *
+ * @param value - Value to inspect.
+ * @returns Whether `value` was created by [`headers`]{@link headers}.
+ */
+declare function isHeadersDirective(value: unknown): value is HeadersDirective;
+/**
+ * Test whether a value is a head directive.
+ *
+ * @param value - Value to inspect.
+ * @returns Whether `value` was created by [`head`]{@link head}.
+ */
+declare function isHeadDirective(value: unknown): value is HeadDirective;
+/**
+ * Test whether a value is a stream directive.
+ *
+ * @param value - Value to inspect.
+ * @returns Whether `value` was created by [`stream`]{@link stream}.
+ */
+declare function isStreamDirective(value: unknown): value is StreamDirective;
+/**
+ * Test whether a value is a chunk directive.
+ *
+ * @param value - Value to inspect.
+ * @returns Whether `value` was created by [`chunk`]{@link chunk}.
+ */
+declare function isChunkDirective(value: unknown): value is ChunkDirective;
+/**
+ * Create a generator directive that sets the response status.
+ *
+ * @example
+ * ```ts
+ * yield status(HttpStatus.ACCEPTED)
+ * ```
+ *
+ * @param statusCode - HTTP status code to use.
+ * @returns Status directive.
+ */
+declare function status(statusCode: number | HttpStatus): StatusDirective;
+/**
+ * Create a generator directive that merges response headers.
+ *
+ * @example
+ * ```ts
+ * yield headers({'cache-control': 'no-store'})
+ * ```
+ *
+ * @param init - Headers to merge into the response.
+ * @returns Headers directive.
+ */
+declare function headers(init: RouterHeadersInit): HeadersDirective;
+/**
+ * Create a generator directive that sets response status and headers.
+ *
+ * @example
+ * ```ts
+ * yield head(HttpStatus.OK, {'cache-control': 'no-store'})
+ * ```
+ *
+ * @param statusCode - HTTP status code to use.
+ * @param init - Headers to merge into the response.
+ * @returns Head directive.
+ */
+declare function head(statusCode: number | HttpStatus, init?: RouterHeadersInit): HeadDirective;
+/**
+ * Create a generator directive that selects a structured stream framer.
+ *
+ * @example
+ * ```ts
+ * yield stream(sseFramer())
+ * ```
+ *
+ * @param framer - Stream framer to use for subsequent chunks.
+ * @param init - Additional stream headers.
+ * @returns Stream directive.
+ */
+declare function stream<const T>(framer: StreamFramer<T>, init?: RouterHeadersInit): StreamDirective<T>;
+/**
+ * Create a generator directive that emits one stream chunk.
+ *
+ * @example
+ * ```ts
+ * yield chunk({event: 'ready'})
+ * ```
+ *
+ * @param value - Chunk value to stream.
+ * @returns Chunk directive.
+ */
+declare function chunk<const T>(value: T): ChunkDirective<T>;
+//#endregion
+//#region src/router/response/serializers.d.ts
+type MaybePromise$1<T> = T | Promise<T>;
+/**
+ * Serializer used by the router when a logical response has no explicit `Content-Type`.
+ *
+ * @example
+ * ```ts
+ * const json = jsonResponseBodySerializer()
+ * ```
+ */
+interface ResponseBodySerializer<T = unknown> {
+  /**
+   * Media types this serializer can produce. Entries may include an Accept-style
+   * `q` parameter for server-side preference during content negotiation.
+   */
+  mediaTypes: readonly string[];
+  /**
+   * Return `true` when this serializer can encode the provided value.
+   *
+   * @param value - Logical response body to inspect.
+   * @returns Whether `value` can be serialized by this serializer.
+   */
+  canSerialize?(value: unknown): value is T;
+  /**
+   * Encode a logical response body into a native Fetch response body.
+   *
+   * @param value - Logical response body to encode.
+   * @returns Native response body data.
+   */
+  serialize(value: T): MaybePromise$1<RouterBodyInit | null>;
+}
+/**
+ * Create the default JSON response body serializer.
+ *
+ * @example
+ * ```ts
+ * const router = new Router().setResponseBodySerializers([jsonResponseBodySerializer()])
+ * ```
+ *
+ * @returns Serializer for `application/json`.
+ */
+declare function jsonResponseBodySerializer(): ResponseBodySerializer<unknown>;
+/**
+ * Create the default response body serializer list.
+ *
+ * @example
+ * ```ts
+ * const serializers = defaultResponseBodySerializers()
+ * ```
+ *
+ * @returns Default response body serializers.
+ */
+declare function defaultResponseBodySerializers(): ResponseBodySerializer[];
+//#endregion
+//#region src/router/response/stream.d.ts
+declare function createStartStream<R = any>(fn: (controller: ReadableStreamDefaultController<R>) => void | Promise<void>): ReadableStream<any>;
+interface StreamWriter<R = any> {
+  write(chunk: R): void;
+}
+declare function createAsyncStream<R = any>(fn: (controller: StreamWriter<R>) => void | Promise<void>): ReadableStream<any>;
+//#endregion
+//#region src/router/request.d.ts
+/**
+ * Request body stream exposed by Routekit request bodies.
+ *
+ * @example
+ * ```ts
+ * const stream = request.body.stream()
+ * ```
+ */
+type RequestBodyStream = ReadableStream<Uint8Array<ArrayBufferLike>> | null;
+/**
+ * FormData type returned by the active Fetch runtime.
+ *
+ * @example
+ * ```ts
+ * const form: RequestBodyFormData = await request.body.formData()
+ * ```
+ */
+type RequestBodyFormData = Awaited<ReturnType<Response['formData']>>;
+/**
+ * Error thrown when Routekit cannot read or parse a request body.
+ *
+ * @example
+ * ```ts
+ * throw new RequestBodyError('Unsupported body', HttpStatus.UNSUPPORTED_MEDIA_TYPE)
+ * ```
+ */
+declare class RequestBodyError extends Error {
+  /**
+   * HTTP status code that should be returned for this request body failure.
+   */
+  readonly status: HttpStatus;
+  /**
+   * Create a request body error.
+   *
+   * @param message - Error message.
+   * @param status - HTTP status code for the failure.
+   */
+  constructor(message: string, status: HttpStatus);
+}
+/**
+ * Error thrown when no registered parser accepts the request `Content-Type`.
+ *
+ * @example
+ * ```ts
+ * throw new UnsupportedRequestBodyMediaTypeError('image/png')
+ * ```
+ */
+declare class UnsupportedRequestBodyMediaTypeError extends RequestBodyError {
+  /**
+   * Incoming `Content-Type` value that was rejected.
+   */
+  readonly contentType: string | null;
+  /**
+   * Create an unsupported media type error.
+   *
+   * @param contentType - Incoming content type, when present.
+   */
+  constructor(contentType: string | null);
+}
+/**
+ * Error thrown when a request body exceeds a configured byte limit.
+ *
+ * @example
+ * ```ts
+ * throw new RequestBodyTooLargeError(1024, 2048)
+ * ```
+ */
+declare class RequestBodyTooLargeError extends RequestBodyError {
+  /**
+   * Maximum allowed body size in bytes.
+   */
+  readonly maxSize: number;
+  /**
+   * Number of bytes received before the limit failed.
+   */
+  readonly received: number;
+  /**
+   * Create a body-too-large error.
+   *
+   * @param maxSize - Maximum allowed body size in bytes.
+   * @param received - Number of bytes received.
+   */
+  constructor(maxSize: number, received: number);
+}
+/**
+ * Error thrown when `Content-Length` does not match the streamed body size.
+ *
+ * @example
+ * ```ts
+ * throw new RequestBodyLengthMismatchError(4, 3)
+ * ```
+ */
+declare class RequestBodyLengthMismatchError extends RequestBodyError {
+  /**
+   * Expected byte count from `Content-Length`.
+   */
+  readonly expected: number;
+  /**
+   * Actual byte count read from the stream.
+   */
+  readonly received: number;
+  /**
+   * Create a content-length mismatch error.
+   *
+   * @param expected - Expected byte count.
+   * @param received - Actual byte count.
+   */
+  constructor(expected: number, received: number);
+}
+/**
+ * Body reader context passed to request body parsers.
+ *
+ * @example
+ * ```ts
+ * const parser = {
+ *     mediaTypes: ['text/plain'],
+ *     parse: (ctx: RequestBodyParseContext) => ctx.text(),
+ * }
+ * ```
+ */
+interface RequestBodyParseContext {
+  /**
+   * Parsed request `Content-Type`, when present and valid.
+   */
+  readonly contentType: ContentType | null;
+  /**
+   * Request headers.
+   */
+  readonly headers: Headers;
+  /**
+   * Return the current body stream.
+   *
+   * @returns Body stream, or `null` when the request has no body.
+   */
+  stream(): RequestBodyStream;
+  /**
+   * Read the body as UTF-8 text.
+   *
+   * @returns Body text.
+   */
+  text(): Promise<string>;
+  /**
+   * Read the body as raw bytes.
+   *
+   * @returns Body bytes.
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /**
+   * Read the body as form data.
+   *
+   * @returns Parsed form data.
+   */
+  formData(): Promise<RequestBodyFormData>;
+}
+/**
+ * Parser used by [`RoutekitRequestBody.parse`]{@link RoutekitRequestBody#parse}.
+ *
+ * @example
+ * ```ts
+ * const jsonParser: RequestBodyParser = {
+ *     mediaTypes: ['application/json'],
+ *     parse: async ctx => JSON.parse(await ctx.text()),
+ * }
+ * ```
+ */
+interface RequestBodyParser<T = unknown> {
+  /**
+   * Media ranges this parser can consume. Entries may include an Accept-style
+   * `q` parameter to prefer more specific parsers over broader media ranges.
+   */
+  readonly mediaTypes: readonly string[];
+  /**
+   * Return `true` when this parser should handle the content type.
+   *
+   * @param contentType - Parsed request content type.
+   * @returns Whether this parser can parse the request body.
+   */
+  canParse?(contentType: ContentType | null): boolean;
+  /**
+   * Parse the request body.
+   *
+   * @param ctx - Lazy body reader context.
+   * @returns Parsed request body.
+   */
+  parse(ctx: RequestBodyParseContext): MaybePromise<T>;
+}
+/**
+ * Lazy request body reader exposed to handlers and middleware.
+ *
+ * @example
+ * ```ts
+ * const body = await request.body.parse()
+ * ```
+ */
+interface RoutekitRequestBody {
+  /**
+   * Parsed request `Content-Type`, when present and valid.
+   */
+  readonly contentType: ContentType | null;
+  /**
+   * Return the current body stream.
+   *
+   * @returns Body stream, or `null` when the request has no body.
+   */
+  stream(): RequestBodyStream;
+  /**
+   * Return a body wrapper that reads from another stream.
+   *
+   * @param stream - Replacement body stream.
+   * @returns Request body wrapper using the replacement stream.
+   */
+  withStream(stream: RequestBodyStream): RoutekitRequestBody;
+  /**
+   * Parse the body with the first matching registered body parser.
+   *
+   * @returns Parsed request body.
+   * @typeParam T - Expected parsed body type.
+   */
+  parse<T = unknown>(): Promise<T>;
+  /**
+   * Read the body as JSON.
+   *
+   * @returns Parsed JSON body.
+   * @typeParam T - Expected JSON body type.
+   */
+  json<T = unknown>(): Promise<T>;
+  /**
+   * Read the body as UTF-8 text.
+   *
+   * @returns Body text.
+   */
+  text(): Promise<string>;
+  /**
+   * Read the body as raw bytes.
+   *
+   * @returns Body bytes.
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /**
+   * Read the body as form data.
+   *
+   * @returns Parsed form data.
+   */
+  formData(): Promise<RequestBodyFormData>;
+}
+/**
+ * Routekit request wrapper exposed to handlers and middleware.
+ *
+ * @example
+ * ```ts
+ * const method = request.method
+ * const body = await request.body.parse()
+ * ```
+ */
+interface RoutekitRequest {
+  /**
+   * Native Fetch request for low-level escape hatches.
+   */
+  readonly raw: Request;
+  /**
+   * Parsed request URL.
+   */
+  readonly url: URL;
+  /**
+   * Request method.
+   */
+  readonly method: string;
+  /**
+   * Request headers.
+   */
+  readonly headers: Headers;
+  /**
+   * Request abort signal.
+   */
+  readonly signal: AbortSignal;
+  /**
+   * Lazy request body reader.
+   */
+  readonly body: RoutekitRequestBody;
+  /**
+   * Return a request wrapper with another body reader.
+   *
+   * @param body - Replacement body reader.
+   * @returns Request wrapper using the replacement body reader.
+   */
+  withBody(body: RoutekitRequestBody): RoutekitRequest;
+}
+/**
+ * Create the default JSON request body parser.
+ *
+ * @example
+ * ```ts
+ * const router = new Router().setRequestBodyParsers([jsonRequestBodyParser()])
+ * ```
+ *
+ * @returns Parser for `application/json` and `application/*+json` request bodies.
+ */
+declare function jsonRequestBodyParser(): RequestBodyParser<unknown>;
+/**
+ * Create the default text request body parser.
+ *
+ * @example
+ * ```ts
+ * const router = new Router().setRequestBodyParsers([textRequestBodyParser()])
+ * ```
+ *
+ * @returns Parser for `text/*` request bodies.
+ */
+declare function textRequestBodyParser(): RequestBodyParser<string>;
+/**
+ * Create the default URL-encoded form request body parser.
+ *
+ * @example
+ * ```ts
+ * const router = new Router().setRequestBodyParsers([urlEncodedRequestBodyParser()])
+ * ```
+ *
+ * @returns Parser for `application/x-www-form-urlencoded` request bodies.
+ */
+declare function urlEncodedRequestBodyParser(): RequestBodyParser<Record<string, string | string[]>>;
+/**
+ * Create the default multipart form request body parser.
+ *
+ * @example
+ * ```ts
+ * const router = new Router().setRequestBodyParsers([formDataRequestBodyParser()])
+ * ```
+ *
+ * @returns Parser for `multipart/form-data` request bodies.
+ */
+declare function formDataRequestBodyParser(): RequestBodyParser<RequestBodyFormData>;
+/**
+ * Create the default Routekit request body parser list.
+ *
+ * @example
+ * ```ts
+ * const parsers = defaultRequestBodyParsers()
+ * ```
+ *
+ * @returns Default parser list.
+ */
+declare function defaultRequestBodyParsers(): RequestBodyParser[];
+/**
+ * Create a Routekit request wrapper for a native Fetch request.
+ *
+ * @example
+ * ```ts
+ * const request = createRoutekitRequest(new Request('https://example.com'), new URL('https://example.com'), defaultRequestBodyParsers())
+ * ```
+ *
+ * @param raw - Native Fetch request.
+ * @param url - Parsed request URL.
+ * @param parsers - Request body parsers.
+ * @returns Routekit request wrapper.
+ */
+declare function createRoutekitRequest(raw: Request, url: URL, parsers: readonly RequestBodyParser[]): RoutekitRequest;
+/**
+ * Create a plain response for a request body error.
+ *
+ * @example
+ * ```ts
+ * const response = responseFromRequestBodyError(error)
+ * ```
+ *
+ * @param error - Request body error to convert.
+ * @returns HTTP response for the body error.
+ */
+declare function responseFromRequestBodyError(error: RequestBodyError): Response;
+//#endregion
+//#region src/router/types.d.ts
+type NonEmptyArray<T> = [T, ...T[]];
+type OneOrMany<T> = T | NonEmptyArray<T>;
+type MaybePromise<T> = T | Promise<T>;
+type RoutePath = string | URLPattern;
+/**
+ * JSON Schema value used for runtime request and response metadata.
+ */
+type JsonSchema = boolean | Record<string, unknown>;
+/**
+ * JSON Schema object used for path and query parameter declarations.
+ */
+type JsonObjectSchema = Record<string, unknown>;
+/**
+ * Schema metadata used to describe route request inputs and response bodies.
+ *
+ * @example
+ * ```ts
+ * const schema: RouteSchema = {
+ *   request: {
+ *     query: {
+ *       type: 'object',
+ *       properties: {
+ *         page: {type: 'integer'},
+ *       },
+ *     },
+ *     path: {
+ *       type: 'object',
+ *       properties: {
+ *         id: {type: 'string'},
+ *       },
+ *       required: ['id'],
+ *     },
+ *     body: {
+ *       type: 'object',
+ *       properties: {
+ *         name: {type: 'string'},
+ *       },
+ *       required: ['name'],
+ *     },
+ *   },
+ *   response: {
+ *     body: {
+ *       200: {
+ *         type: 'object',
+ *         properties: {
+ *           ok: {type: 'boolean'},
+ *         },
+ *         required: ['ok'],
+ *       },
+ *     },
+ *   },
+ * }
+ * ```
+ */
+interface RouteSchema {
+  request?: {
+    query?: JsonObjectSchema;
+    path?: JsonObjectSchema;
+    body?: JsonSchema;
+  };
+  response?: {
+    body?: Partial<Record<number | 'default', JsonSchema>>;
+  };
+}
+/**
+ * Custom request matcher used when a route needs logic beyond pathname, method, or `accept`.
+ *
+ * @example
+ * ```ts
+ * const match: RouteMatch = request => request.headers.get('x-internal') === 'true'
+ * ```
+ *
+ * @param request - Incoming request to test.
+ * @returns `true` when the route should handle the request.
+ */
+type RouteMatch = (request: RoutekitRequest) => boolean;
+/**
+ * Route metadata used by tooling like OpenAPI generation.
+ */
+interface RouteMeta {
+  /**
+   * OpenAPI operation metadata for this route.
+   */
+  openapi?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+type AddedContextOf<Middleware> = Exclude<Middleware, null | undefined | false> extends DeclaredMiddleware<infer AddedCtx, any> ? AddedCtx : Exclude<Middleware, null | undefined | false> extends ContextMiddleware<infer AddedCtx, any> ? AddedCtx : Exclude<Middleware, null | undefined | false> extends RequestMiddleware<infer AddedCtx, any> ? AddedCtx : {};
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends ((value: infer Intersection) => void) ? Intersection : never;
+type AddedContextFromList<List extends readonly unknown[]> = List extends readonly [infer First, ...infer Rest] ? AddedContextOf<First> & AddedContextFromList<Rest> : number extends List['length'] ? UnionToIntersection<AddedContextOf<List[number]>> : {};
+type ContextOf<Middleware> = Exclude<Middleware, null | undefined | false> extends DeclaredMiddleware<any, infer Ctx> ? Ctx : Exclude<Middleware, null | undefined | false> extends ContextMiddleware<any, infer Ctx> ? Ctx : Exclude<Middleware, null | undefined | false> extends RequestMiddleware<any, infer Ctx> ? Ctx : object;
+type ContextFromList<List extends readonly unknown[]> = List extends readonly [infer First, ...infer Rest] ? ContextOf<First> & ContextFromList<Rest> : number extends List['length'] ? UnionToIntersection<ContextOf<List[number]>> : object;
+/**
+ * Context added by a middleware value or middleware list.
+ *
+ * @example
+ * ```ts
+ * type AuthContext = AddedContextFromMiddlewareInput<typeof requireAuth>
+ * ```
+ *
+ * @typeParam Middleware - Middleware value or list whose added context should be inferred.
+ */
+type AddedContextFromMiddlewareInput<Middleware> = Middleware extends readonly unknown[] ? AddedContextFromList<Middleware> : AddedContextOf<Middleware>;
+/**
+ * Base context expected by a middleware value or middleware list.
+ *
+ * @example
+ * ```ts
+ * type ServicesContext = ContextFromMiddlewareInput<typeof requireAuth>
+ * ```
+ *
+ * @typeParam Middleware - Middleware value or list whose base context should be inferred.
+ */
+type ContextFromMiddlewareInput<Middleware> = Middleware extends readonly unknown[] ? ContextFromList<Middleware> : ContextOf<Middleware>;
+/**
+ * Declarative route definition that the router can normalize and register.
+ *
+ * @example
+ * ```ts
+ * const route: Route = {
+ *   name: 'user.detail',
+ *   method: HttpMethod.GET,
+ *   path: '/users/:id',
+ *   handler: async ({request}) => new Response(await request.body.text()),
+ * }
+ * ```
+ */
+interface Route<Ctx extends object = AnyContext, RouteMiddleware extends MiddlewareInput<Ctx> = undefined, HandlerCtx extends object = Ctx & AddedContextFromMiddlewareInput<RouteMiddleware>> {
+  name?: OneOrMany<string>;
+  /**
+   * Path pattern matched by the default route matcher.
+   */
+  path: RoutePath;
+  handler: Handler<any, HandlerCtx>;
+  method?: OneOrMany<HttpMethod>;
+  /**
+   * Middleware applied only to this route after router and mount middleware.
+   *
+   * @example
+   * ```ts
+   * const route: Route = {
+   *   path: '/me',
+   *   middleware: auth(),
+   *   handler: ({userId}) => new Response(userId),
+   * }
+   * ```
+   */
+  middleware?: RouteMiddleware;
+  /**
+   * Optional custom matcher. When omitted, the router matches using `path`, `method`, and `accept`.
+   */
+  match?: RouteMatch;
+  /**
+   * Arbitrary metadata attached to the route.
+   *
+   * @example
+   * ```ts
+   * const route: Route = {
+   *   path: '/pets',
+   *   method: HttpMethod.GET,
+   *   meta: {
+   *     openapi: {
+   *       description: 'Returns all pets from the system that the user has access to',
+   *       responses: {
+   *         200: {description: 'A list of pets'},
+   *       },
+   *     },
+   *   },
+   *   handler: () => new Response('ok'),
+   * }
+   * ```
+   */
+  meta?: RouteMeta;
+  /**
+   * Expected media type(s) for the incoming request body. When provided, the router compares each
+   * entry against the incoming `Content-Type` header.
+   *
+   * @example
+   * ```ts
+   * const route: Route = {
+   *   path: '/upload',
+   *   method: HttpMethod.POST,
+   *   accept: ['multipart/form-data', {type: 'application/json'}],
+   *   handler: async () => new Response('ok'),
+   * }
+   * ```
+   */
+  accept?: OneOrMany<string | MediaType>;
+  /**
+   * Runtime request and response schemas used by tooling such as OpenAPI generation and API client codegen.
+   */
+  schema?: RouteSchema;
+}
+/**
+ * Route definition fields accepted by method-specific router helpers.
+ *
+ * @example
+ * ```ts
+ * const options: RouteOptions = {
+ *   name: 'user.detail',
+ *   handler: async ({request}) => new Response(request.url),
+ * }
+ * router.get('/users/:id', options)
+ * ```
+ */
+type RouteOptions<Ctx extends object = AnyContext, RouteMiddleware extends MiddlewareInput<Ctx> = undefined, HandlerCtx extends object = Ctx & AddedContextFromMiddlewareInput<RouteMiddleware>> = Omit<Route<Ctx, RouteMiddleware, HandlerCtx>, 'method' | 'path'>;
+/**
+ * Normalized route metadata used internally by the router.
+ *
+ * @example
+ * ```ts
+ * const route: NormalizedRoute = {
+ *   name: ['user', 'detail'],
+ *   method: HttpMethod.GET,
+ *   path: new URLPattern({pathname: '/users/:id'}),
+ *   handler: async ({request}) => new Response(await request.body.text()),
+ * }
+ * ```
+ */
+interface NormalizedRoute<Ctx extends object = AnyContext> {
+  name: string[];
+  path: URLPattern;
+  handler: Handler<any, Ctx>;
+  method?: HttpMethod | HttpMethod[];
+  accept?: MediaType[];
+  match?: RouteMatch;
+  meta?: RouteMeta;
+  schema?: RouteSchema;
+}
+/**
+ * Parameterized HTTP `Content-Type` media type.
+ *
+ * @example
+ * ```ts
+ * const contentType: ContentType = {type: 'application/json', charset: 'utf-8'}
+ * ```
+ */
+type ContentType = {
+  type: string;
+  charset?: string;
+  boundary?: string;
+  parameters?: Record<string, string>;
+};
+/**
+ * Backwards-compatible alias for a concrete media type.
+ *
+ * @example
+ * ```ts
+ * const media: MediaType = {type: 'application/json'}
+ * ```
+ */
+type MediaType = ContentType;
+/**
+ * Media range parsed from an HTTP `Accept` header.
+ *
+ * @example
+ * ```ts
+ * const accept: AcceptMediaRange = {type: 'application/json', q: 1}
+ * ```
+ */
+type AcceptMediaRange = ContentType & {
+  q: number;
+};
+/**
+ * Generic context dictionary used when no custom context type is provided.
+ *
+ * @example
+ * ```ts
+ * const ctx: AnyContext = {featureFlag: true}
+ * ```
+ */
+type AnyContext = Record<string, any>;
+/**
+ * Extension hook that intentionally configures a router instance.
+ *
+ * @example
+ * ```ts
+ * const extension: RouterExtension = router => {
+ *   router.onNotFound(() => new Response('missing', {status: 404}))
+ * }
+ *
+ * new Router().install(extension)
+ * ```
+ *
+ * @typeParam Ctx - Context carried by the router being configured.
+ */
+type RouterExtension<Ctx extends object = AnyContext> = (router: Router<Ctx>) => void;
+/**
+ * Request context made available to middleware.
+ * Extended data can be attached by middleware via the generic parameter.
+ *
+ * @example
+ * ```ts
+ * const middleware: ContextMiddleware<{userId: string}> = ctx => {
+ *   ctx.userId = 'user-123'
+ * }
+ * ```
+ */
+type RequestContext<Ctx extends object = AnyContext> = {
+  /**
+   * Routekit request wrapper for the current request.
+   */
+  request: RoutekitRequest;
+  /**
+   * Contextual logger selected for the current request.
+   */
+  logger: Logger;
+} & Ctx;
+/**
+ * Context object provided to route handlers.
+ * Includes request metadata as well as any context extensions added by middleware.
+ *
+ * @example
+ * ```ts
+ * const handler: HandlerContext = {
+ *   request,
+ *   url: new URL('https://example.com/users/123'),
+ *   path: {id: '123'},
+ * }
+ * ```
+ */
+type HandlerContext<Ctx extends object = AnyContext> = RequestContext<Ctx> & {
+  /**
+   * Parsed request URL for convenience.
+   */
+  url: URL;
+  /**
+   * Route path parameters extracted from the matched URL pattern.
+   */
+  path: unknown;
+};
+/**
+ * Values yielded by generator-style handlers.
+ *
+ * @example
+ * ```ts
+ * async function* handler() {
+ *   yield head(HttpStatus.OK, {'cache-control': 'no-store'})
+ *   return {ok: true}
+ * }
+ * ```
+ */
+type HandlerYield = RoutekitYield;
+/**
+ * Native body value that can be passed to the Fetch [`Response`]{@link Response} constructor.
+ *
+ * @example
+ * ```ts
+ * const body: HandlerBody = 'ok'
+ * ```
+ */
+type HandlerBody = RouterBodyInit | null | undefined;
+/**
+ * Final value a handler or generator may return.
+ */
+type HandlerFinalResult<TOkRes = unknown> = Response | RoutekitResponse<TOkRes> | RoutekitBody<TOkRes> | TOkRes | HandlerBody;
+/**
+ * Allowed handler return values.
+ *
+ * @example
+ * ```ts
+ * const handler: Handler = async ({request}) => new Response(await request.body.text())
+ * ```
+ */
+type HandlerResult<TOkRes = unknown> = HandlerFinalResult<TOkRes> | Promise<HandlerFinalResult<TOkRes> | AsyncGenerator<HandlerYield, HandlerFinalResult<TOkRes>>> | AsyncGenerator<HandlerYield, HandlerFinalResult<TOkRes>>;
+/**
+ * Route handler signature that preserves generic type parameters for API generation.
+ *
+ * @example
+ * ```ts
+ * const handler: Handler = ({path}) => {
+ *   return JSON.stringify(path)
+ * }
+ * ```
+ *
+ * The handler is invoked with `this` bound to the active [`Router`]{@link Router}.
+ *
+ * @param ctx - Handler context containing the incoming [`RoutekitRequest`]{@link RoutekitRequest}, parsed [`URL`]{@link URL}, path parameters, and middleware extensions.
+ * @returns A response, a serializable value handled by middleware, or a streaming generator that yields response metadata.
+ */
+type Handler<TOkRes = unknown, Ctx extends object = AnyContext> = (this: Router<any>, ctx: HandlerContext<Ctx>) => HandlerResult<TOkRes>;
+/**
+ * Middleware that extends request context and then continues routing.
+ *
+ * @example
+ * ```ts
+ * const addRequestId = (): ContextMiddleware<{requestId: number}> => ctx => {
+ *   ctx.requestId = 123
+ * }
+ * ```
+ *
+ * @param ctx - Request context for the current request, including any added fields.
+ * @returns Nothing, or a promise resolved after context initialization.
+ */
+type ContextMiddleware<AddedCtx extends object = AnyContext, Ctx extends object = AnyContext> = (ctx: RequestContext<Ctx & AddedCtx>) => void | Promise<void>;
+/**
+ * Middleware that surrounds final response production for every incoming request.
+ *
+ * @example
+ * ```ts
+ * const timing: RequestMiddleware = async (ctx, next) => {
+ *   const started = performance.now()
+ *   const response = await next()
+ *   ctx.logger.info('completed', {duration: performance.now() - started})
+ *   return response
+ * }
+ * ```
+ *
+ * @param ctx - Request context shared with downstream middleware and handlers.
+ * @param next - Continue processing and obtain the final response.
+ * @returns The final response, optionally decorated by the middleware.
+ * @typeParam AddedCtx - Context fields made available to downstream processing.
+ * @typeParam Ctx - Context required before this middleware executes.
+ */
+type RequestMiddleware<AddedCtx extends object = {}, Ctx extends object = AnyContext> = (ctx: HandlerContext<Ctx & AddedCtx>, next: () => Promise<Response>) => Response | Promise<Response>;
+/**
+ * Middleware entry accepted inside typed middleware lists.
+ *
+ * @example
+ * ```ts
+ * const middleware = [auth(), false] satisfies MiddlewareEntry[]
+ * ```
+ *
+ * @typeParam Ctx - Base context available before this middleware runs.
+ */
+type MiddlewareEntry<Ctx extends object = AnyContext> = ContextMiddleware<any, Ctx> | DeclaredMiddleware<any, Ctx> | null | undefined | false;
+/**
+ * Middleware that performs context-only request initialization.
+ *
+ * @example
+ * ```ts
+ * const middleware: Middleware = ctx => {
+ *   ctx.request.headers.get('accept')
+ * }
+ * ```
+ *
+ * @param ctx - Request context for the current request.
+ * @returns Nothing, or a promise resolved after context initialization.
+ */
+type Middleware<Ctx extends object = AnyContext> = ContextMiddleware<{}, Ctx>;
+/**
+ * Middleware list container for registering multiple middleware entries.
+ *
+ * @example
+ * ```ts
+ * const middleware: MiddlewareList = [auth(), logging()]
+ * ```
+ *
+ * @param list - Collection of middleware entries, optionally including falsy values.
+ * @returns A list of middleware compatible with `Router.use`.
+ */
+type MiddlewareList<Ctx extends object = AnyContext> = ReadonlyArray<MiddlewareEntry<Ctx>>;
+/**
+ * Middleware value accepted by router middleware registration APIs.
+ *
+ * @example
+ * ```ts
+ * const input: MiddlewareInput = [auth(), logging()]
+ * ```
+ *
+ * @typeParam Ctx - Base context available before this middleware runs.
+ */
+type MiddlewareInput<Ctx extends object = AnyContext> = OneOrMany<MiddlewareEntry<Ctx>> | MiddlewareList<Ctx> | null | undefined | false;
+/**
+ * Request-boundary middleware entry accepted by [`Router.useRequest`]{@link Router#useRequest}.
+ *
+ * @typeParam Ctx - Base context available before this middleware runs.
+ */
+type RequestMiddlewareEntry<Ctx extends object = AnyContext> = RequestMiddleware<any, Ctx> | null | undefined | false;
+/**
+ * Request-boundary middleware input accepted by [`Router.useRequest`]{@link Router#useRequest}.
+ *
+ * @typeParam Ctx - Base context available before this middleware runs.
+ */
+type RequestMiddlewareInput<Ctx extends object = AnyContext> = OneOrMany<RequestMiddlewareEntry<Ctx>> | ReadonlyArray<RequestMiddlewareEntry<Ctx>> | null | undefined | false;
+/**
+ * Request body parser value accepted by router request body parser APIs.
+ *
+ * @example
+ * ```ts
+ * const input: RequestBodyParserInput = [jsonRequestBodyParser()]
+ * ```
+ */
+type RequestBodyParserInput = RequestBodyParser | ReadonlyArray<RequestBodyParser | null | undefined | false> | null | undefined | false;
+/**
+ * Response body serializer value accepted by router response body serializer APIs.
+ *
+ * @example
+ * ```ts
+ * const input: ResponseBodySerializerInput = [jsonResponseBodySerializer()]
+ * ```
+ */
+type ResponseBodySerializerInput = ResponseBodySerializer | ReadonlyArray<ResponseBodySerializer | null | undefined | false> | null | undefined | false;
+/**
+ * Options for mounting a router or configuring a scoped inline router.
+ *
+ * @example
+ * ```ts
+ * const options: RouterMountOptions = {prefix: '/admin', middleware: auth()}
+ * ```
+ */
+interface RouterMountOptions<Ctx extends object = AnyContext> {
+  /**
+   * Optional pathname prefix for the mounted routes.
+   */
+  prefix?: string;
+  /**
+   * Middleware applied to the mounted router scope.
+   */
+  middleware?: MiddlewareInput<Ctx>;
+}
+//#endregion
+//#region src/router/middleware/define.d.ts
+declare const declaredMiddlewareBrand: unique symbol;
+declare const middlewareActionBrand: unique symbol;
+/**
+ * A response declaration owned by middleware.
+ *
+ * @example
+ * ```ts
+ * const forbidden = {
+ *     schema: { type: 'string' },
+ *     parse: value => String(value),
+ * }
+ * ```
+ *
+ * @typeParam Body - Parsed response body produced by the declaration.
+ */
+interface MiddlewareResponseDeclaration<Body = unknown> {
+  /**
+   * JSON Schema emitted for metadata consumers such as OpenAPI and client generation.
+   */
+  readonly schema: JsonSchema;
+  /**
+   * Validate and optionally parse a locally originated response body.
+   *
+   * @param value - Body supplied through `respond(...)`.
+   * @returns The validated response body.
+   */
+  parse(value: unknown): Body;
+}
+/**
+ * Status-keyed response declarations owned by middleware.
+ */
+type MiddlewareResponseDeclarations = Partial<Record<number | 'default', MiddlewareResponseDeclaration<any>>>;
+type DeclaredBody<Declaration> = Declaration extends MiddlewareResponseDeclaration<infer Body> ? Body : never;
+type DeclaredResponse<Declarations extends MiddlewareResponseDeclarations> = { [Status in keyof Declarations]-?: NonNullable<Declarations[Status]> extends MiddlewareResponseDeclaration<any> ? RoutekitResponse<DeclaredBody<NonNullable<Declarations[Status]>>, Status extends number ? Status : number> : never }[keyof Declarations];
+/** @internal */
+interface MiddlewareAction {
+  readonly [middlewareActionBrand]: true;
+  readonly result: HandlerResult;
+}
+/**
+ * Controls passed to a declared middleware implementation.
+ *
+ * @typeParam Declarations - Locally originated response declarations.
+ */
+interface MiddlewareControls<Declarations extends MiddlewareResponseDeclarations> {
+  /**
+   * Invoke downstream middleware and the route handler.
+   *
+   * @returns The downstream result before it is finalized into a Fetch response.
+   */
+  next(): Promise<HandlerResult>;
+  /**
+   * Forward an unchanged or decorated downstream result.
+   *
+   * @param result - Result obtained from [`MiddlewareControls.next`]{@link MiddlewareControls#next}.
+   * @returns A middleware action accepted by the declaring factory.
+   */
+  forward(result: HandlerResult): MiddlewareAction;
+  /**
+   * Return a response originated by this middleware.
+   *
+   * @param result - Logical response matching a declared body and exact status.
+   * @returns A validated terminal middleware action.
+   */
+  respond(result: DeclaredResponse<Declarations>): MiddlewareAction;
+}
+/**
+ * Callable middleware carrying schema declarations for router metadata.
+ *
+ * @typeParam AddedCtx - Context values made available to downstream handlers.
+ * @typeParam Ctx - Context required before this middleware executes.
+ */
+interface DeclaredMiddleware<AddedCtx extends object = {}, Ctx extends object = AnyContext> {
+  readonly [declaredMiddlewareBrand]: true;
+  readonly schema?: RouteSchema;
+  readonly schemaAppliesTo?: (route: {
+    readonly method?: string | readonly string[];
+  }) => boolean;
+  (ctx: HandlerContext<Ctx & AddedCtx>, next: () => Promise<HandlerResult>): Promise<HandlerResult>;
+}
+/**
+ * Options for [`defineMiddleware`]{@link defineMiddleware}.
+ *
+ * @typeParam AddedCtx - Context values made available to downstream handlers.
+ * @typeParam Ctx - Context required before this middleware executes.
+ * @typeParam Declarations - Status-keyed locally originated responses.
+ */
+interface DefineMiddlewareOptions<AddedCtx extends object, Ctx extends object, Declarations extends MiddlewareResponseDeclarations> {
+  /**
+   * Additional metadata contributed by the middleware, such as request schemas or
+   * downstream response boundary schemas.
+   */
+  schema?: RouteSchema;
+  /**
+   * Limit this middleware's schema contribution to matching flattened routes.
+   *
+   * @param route - Route metadata being flattened by the router.
+   * @returns Whether this middleware's schema applies to that route.
+   */
+  schemaAppliesTo?: (route: {
+    readonly method?: string | readonly string[];
+  }) => boolean;
+  /**
+   * Responses that this middleware may originate through `respond(...)`.
+   */
+  responses?: Declarations;
+  /**
+   * Execute middleware behavior.
+   *
+   * @param ctx - Request and route context available at execution time.
+   * @param controls - Continuation, forwarding, and terminal response operations.
+   * @returns A terminal/forward action, or void to continue automatically.
+   */
+  run(ctx: HandlerContext<Ctx & AddedCtx>, controls: MiddlewareControls<Declarations>): MiddlewareAction | void | Promise<MiddlewareAction | void>;
+}
+/**
+ * Create middleware that declares and validates every response it originates.
+ *
+ * @example
+ * ```ts
+ * const auth = defineMiddleware({
+ *     responses: {
+ *         401: {
+ *             schema: { type: 'string' },
+ *             parse: value => String(value),
+ *         },
+ *     },
+ *     run: async (_ctx, { respond }) => respond(response('Sign in', { status: 401 })),
+ * })
+ * ```
+ *
+ * @param options - Schema declarations and middleware implementation.
+ * @returns Executable middleware carrying its metadata contribution.
+ * @typeParam AddedCtx - Context values made available to downstream handlers.
+ * @typeParam Ctx - Context required before this middleware executes.
+ * @typeParam Declarations - Status-keyed locally originated responses.
+ */
+declare function defineMiddleware<AddedCtx extends object = {}, Ctx extends object = AnyContext, const Declarations extends MiddlewareResponseDeclarations = {}>(options: DefineMiddlewareOptions<AddedCtx, Ctx, Declarations>): DeclaredMiddleware<AddedCtx, Ctx>;
+//#endregion
+//#region src/router/router.d.ts
+/**
+ * Router that matches requests against registered routes and executes middleware.
+ *
+ * @example
+ * ```ts
+ * const router = new Router()
+ * router.add({method: HttpMethod.GET, path: '/', handler: async ({request}) => new Response(request.url)})
+ * ```
+ */
+declare class Router<Ctx extends object = AnyContext> implements SimpleServerInterface {
+  private _entries;
+  private _middleware;
+  private _requestMiddleware;
+  private _responseBodySerializers;
+  private _responseBodySerializersMode;
+  private _requestBodyParsers;
+  private _requestBodyParsersMode;
+  private _logger?;
+  private readonly _defaultLogger;
+  private _onNotFoundHandler?;
+  private _onMethodNotAllowedHandler?;
+  private _onUnsupportedMediaTypeHandler?;
+  private _onInternalErrorHandler?;
+  /**
+   * Create a new router instance.
+   */
+  constructor();
+  /**
+   * Install an extension that configures this router instance.
+   *
+   * @example
+   * ```ts
+   * router.install(problemRootErrors())
+   * ```
+   *
+   * @param extension - Extension function that mutates or configures this router.
+   * @returns The router instance for chaining.
+   */
+  install(extension: RouterExtension<Ctx>): this;
+  /**
+   * Register a handler for requests that do not match any route.
+   *
+   * @example
+   * ```ts
+   * router.onNotFound(() => new Response('missing', {status: 404}))
+   * ```
+   *
+   * @param handler - Handler invoked when no route matches.
+   * @returns The router instance for chaining.
+   */
+  onNotFound(handler: Handler<any, Ctx>): this;
+  /**
+   * Register a handler for requests that match a path but use an unsupported method.
+   *
+   * @example
+   * ```ts
+   * router.onMethodNotAllowed(() => new Response('nope', {status: 405}))
+   * ```
+   *
+   * @param handler - Handler invoked when a route exists but the method does not match.
+   * @returns The router instance for chaining.
+   */
+  onMethodNotAllowed(handler: Handler<any, Ctx>): this;
+  /**
+   * Register a handler for requests with unsupported request body media types.
+   *
+   * @example
+   * ```ts
+   * router.onUnsupportedMediaType(() => new Response('unsupported', {status: 415}))
+   * ```
+   *
+   * @param handler - Handler invoked when the incoming `Content-Type` is not accepted.
+   * @returns The router instance for chaining.
+   */
+  onUnsupportedMediaType(handler: Handler<any, Ctx>): this;
+  /**
+   * Register a handler for unhandled errors thrown by route handlers.
+   *
+   * @example
+   * ```ts
+   * router.onInternalError(() => new Response('oops', {status: 500}))
+   * ```
+   *
+   * @param handler - Handler invoked when a route handler throws.
+   * @returns The router instance for chaining.
+   */
+  onInternalError(handler: Handler<any, Ctx>): this;
+  /**
+   * Add a request body parser to the inherited parser list.
+   *
+   * @example
+   * ```ts
+   * router.addRequestBodyParser(jsonRequestBodyParser())
+   * ```
+   *
+   * @param parser - Request body parser to append.
+   * @returns The router instance for chaining.
+   */
+  addRequestBodyParser(parser: RequestBodyParser): this;
+  /**
+   * Add request body parsers to the inherited parser list.
+   *
+   * @example
+   * ```ts
+   * router.addRequestBodyParsers([jsonRequestBodyParser(), textRequestBodyParser()])
+   * ```
+   *
+   * @param parsers - Request body parsers to append.
+   * @returns The router instance for chaining.
+   */
+  addRequestBodyParsers(parsers: RequestBodyParserInput): this;
+  /**
+   * Replace the inherited request body parser list for this router subtree.
+   *
+   * @example
+   * ```ts
+   * router.setRequestBodyParsers([jsonRequestBodyParser()])
+   * ```
+   *
+   * @param parsers - Exact request body parsers to use for this router subtree.
+   * @returns The router instance for chaining.
+   */
+  setRequestBodyParsers(parsers: RequestBodyParserInput): this;
+  /**
+   * Add a response body serializer to the inherited serializer list.
+   *
+   * @example
+   * ```ts
+   * router.addResponseBodySerializer(jsonResponseBodySerializer())
+   * ```
+   *
+   * @param serializer - Response body serializer to append.
+   * @returns The router instance for chaining.
+   */
+  addResponseBodySerializer(serializer: ResponseBodySerializer): this;
+  /**
+   * Add response body serializers to the inherited serializer list.
+   *
+   * @example
+   * ```ts
+   * router.addResponseBodySerializers([jsonResponseBodySerializer(), yamlSerializer])
+   * ```
+   *
+   * @param serializers - Response body serializers to append.
+   * @returns The router instance for chaining.
+   */
+  addResponseBodySerializers(serializers: ResponseBodySerializerInput): this;
+  /**
+   * Replace the inherited response body serializer list for this router subtree.
+   *
+   * @example
+   * ```ts
+   * router.setResponseBodySerializers([jsonResponseBodySerializer()])
+   * ```
+   *
+   * @param serializers - Exact response body serializers to use for this router subtree.
+   * @returns The router instance for chaining.
+   */
+  setResponseBodySerializers(serializers: ResponseBodySerializerInput): this;
+  /**
+   * Set the logger for this router subtree.
+   *
+   * @example
+   * ```ts
+   * router.setLogger(logger)
+   * ```
+   *
+   * @param logger - Logger exposed through request contexts and used for internal server errors.
+   * @returns The router instance for chaining.
+   */
+  setLogger(logger: Logger): this;
+  /**
+   * Register middleware on the current router.
+   *
+   * @example
+   * ```ts
+   * router.use(ctx => {
+   *   ctx.traceId = crypto.randomUUID()
+   * })
+   * ```
+   *
+   * @param middleware - Middleware or a list of middleware to register.
+   * @returns The router instance for chaining.
+   */
+  use<AddedCtx extends object>(middleware: ContextMiddleware<AddedCtx, Ctx> | null | undefined | false): Router<Ctx & AddedCtx>;
+  use<AddedCtx extends object>(middleware: DeclaredMiddleware<AddedCtx, Ctx>): Router<Ctx & AddedCtx>;
+  /**
+   * Register middleware on the current router.
+   *
+   * @example
+   * ```ts
+   * router.use([auth(), logging()])
+   * ```
+   *
+   * @param middleware - Middleware list to register.
+   * @returns The router instance for chaining.
+   */
+  use<List extends readonly MiddlewareEntry<Ctx>[]>(middleware: List): Router<Ctx & AddedContextFromMiddlewareInput<List>>;
+  /**
+   * Register middleware that surrounds final response production for every request.
+   *
+   * @example
+   * ```ts
+   * router.useRequest(requestIdCtx())
+   * router.useRequest(requestLogger())
+   * ```
+   *
+   * @param middleware - Request-boundary middleware or a middleware list.
+   * @returns The router instance with added request context fields.
+   */
+  useRequest<AddedCtx extends object>(middleware: RequestMiddleware<AddedCtx, Ctx> | null | undefined | false): Router<Ctx & AddedCtx>;
+  useRequest<List extends readonly RequestMiddlewareEntry<Ctx>[]>(middleware: List): Router<Ctx & AddedContextFromMiddlewareInput<List>>;
+  /**
+   * Mount a router at the current path.
+   *
+   * @example
+   * ```ts
+   * router.mount(apiRouter)
+   * ```
+   *
+   * @param router - Router to mount.
+   * @returns The router instance for chaining.
+   */
+  mount(router: Router<any>): this;
+  /**
+   * Mount an inline router at the current path.
+   *
+   * @example
+   * ```ts
+   * router.mount(admin => {
+   *   admin.get('/admin/users', handler)
+   * })
+   * ```
+   *
+   * @param configure - Callback used to register routes on the mounted router.
+   * @returns The router instance for chaining.
+   */
+  mount(configure: (router: Router<Ctx>) => void): this;
+  /**
+   * Mount a router under a pathname prefix.
+   *
+   * @example
+   * ```ts
+   * router.mount('/api', apiRouter)
+   * ```
+   *
+   * @param prefix - Pathname prefix to strip before routing.
+   * @param router - Router to mount.
+   * @returns The router instance for chaining.
+   */
+  mount(prefix: string, router: Router<any>): this;
+  /**
+   * Mount an inline router under a pathname prefix.
+   *
+   * @example
+   * ```ts
+   * router.mount('/api', api => {
+   *   api.get('/items', handler)
+   * })
+   * ```
+   *
+   * @param prefix - Pathname prefix to strip before routing.
+   * @param configure - Callback used to register routes on the mounted router.
+   * @returns The router instance for chaining.
+   */
+  mount(prefix: string, configure: (router: Router<Ctx>) => void): this;
+  /**
+   * Mount an inline router with additional middleware.
+   *
+   * @example
+   * ```ts
+   * router.mount({prefix: '/admin', middleware: auth()}, admin => {
+   *   admin.get('/users', ({userId}) => ok({userId}))
+   * })
+   * ```
+   *
+   * @param options - Mount options for the inline router.
+   * @param configure - Callback used to register routes on the mounted router.
+   * @returns The router instance for chaining.
+   */
+  mount<AddedCtx extends object>(options: RouterMountOptions<Ctx> & {
+    middleware: ContextMiddleware<AddedCtx, Ctx> | DeclaredMiddleware<AddedCtx, Ctx> | null | undefined | false;
+  }, configure: (router: Router<Ctx & AddedCtx>) => void): this;
+  /**
+   * Mount an inline router with a middleware list.
+   *
+   * @example
+   * ```ts
+   * router.mount({middleware: [auth(), logging()] as const}, scoped => {
+   *   scoped.get('/me', handler)
+   * })
+   * ```
+   *
+   * @param options - Mount options for the inline router.
+   * @param configure - Callback used to register routes on the mounted router.
+   * @returns The router instance for chaining.
+   */
+  mount<List extends readonly MiddlewareEntry<Ctx>[]>(options: RouterMountOptions<Ctx> & {
+    middleware: List;
+  }, configure: (router: Router<Ctx & AddedContextFromMiddlewareInput<List>>) => void): this;
+  /**
+   * Mount an inline router with options and no additional typed middleware.
+   *
+   * @example
+   * ```ts
+   * router.mount({prefix: '/reports'}, reports => {
+   *   reports.get('/export', handler)
+   * })
+   * ```
+   *
+   * @param options - Mount options for the inline router.
+   * @param configure - Callback used to register routes on the mounted router.
+   * @returns The router instance for chaining.
+   */
+  mount(options: RouterMountOptions<Ctx>, configure: (router: Router<Ctx>) => void): this;
+  /**
+   * Mount an existing router with options.
+   *
+   * @example
+   * ```ts
+   * router.mount({prefix: '/api', middleware: logging()}, apiRouter)
+   * ```
+   *
+   * @param options - Mount options for the existing router.
+   * @param router - Router to mount.
+   * @returns The router instance for chaining.
+   */
+  mount(options: RouterMountOptions<Ctx>, router: Router<any>): this;
+  /**
+   * Add a route definition to this router.
+   *
+   * @example
+   * ```ts
+   * router.add({method: HttpMethod.POST, path: '/items', handler: ({request}) => new Response(request.url)})
+   * ```
+   *
+   * @param route - Route definition to normalize and register.
+   * @returns The router instance for chaining.
+   */
+  add<RouteMiddleware extends MiddlewareInput<Ctx> = undefined, HandlerCtx extends object = Ctx & AddedContextFromMiddlewareInput<RouteMiddleware>>(route: Route<Ctx, RouteMiddleware, HandlerCtx>): this;
+  private _addMethod;
+  /**
+   * Add a GET route handler to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param handler - Handler invoked when the route matches.
+   * @returns The router instance for chaining.
+   */
+  get(path: NonNullable<Route<Ctx>['path']>, handler: Handler<any, Ctx>): this;
+  /**
+   * Add a GET route definition to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param options - Route options registered with the GET method.
+   * @returns The router instance for chaining.
+   */
+  get<RouteMiddleware extends MiddlewareInput<Ctx> = undefined, HandlerCtx extends object = Ctx & AddedContextFromMiddlewareInput<RouteMiddleware>>(path: NonNullable<Route<Ctx>['path']>, options: RouteOptions<Ctx, RouteMiddleware, HandlerCtx>): this;
+  /**
+   * Add a HEAD route handler to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param handler - Handler invoked when the route matches.
+   * @returns The router instance for chaining.
+   */
+  head(path: NonNullable<Route<Ctx>['path']>, handler: Handler<any, Ctx>): this;
+  /**
+   * Add a HEAD route definition to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param options - Route options registered with the HEAD method.
+   * @returns The router instance for chaining.
+   */
+  head<RouteMiddleware extends MiddlewareInput<Ctx> = undefined, HandlerCtx extends object = Ctx & AddedContextFromMiddlewareInput<RouteMiddleware>>(path: NonNullable<Route<Ctx>['path']>, options: RouteOptions<Ctx, RouteMiddleware, HandlerCtx>): this;
+  /**
+   * Add a POST route handler to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param handler - Handler invoked when the route matches.
+   * @returns The router instance for chaining.
+   */
+  post(path: NonNullable<Route<Ctx>['path']>, handler: Handler<any, Ctx>): this;
+  /**
+   * Add a POST route definition to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param options - Route options registered with the POST method.
+   * @returns The router instance for chaining.
+   */
+  post<RouteMiddleware extends MiddlewareInput<Ctx> = undefined, HandlerCtx extends object = Ctx & AddedContextFromMiddlewareInput<RouteMiddleware>>(path: NonNullable<Route<Ctx>['path']>, options: RouteOptions<Ctx, RouteMiddleware, HandlerCtx>): this;
+  /**
+   * Add a PUT route handler to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param handler - Handler invoked when the route matches.
+   * @returns The router instance for chaining.
+   */
+  put(path: NonNullable<Route<Ctx>['path']>, handler: Handler<any, Ctx>): this;
+  /**
+   * Add a PUT route definition to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param options - Route options registered with the PUT method.
+   * @returns The router instance for chaining.
+   */
+  put<RouteMiddleware extends MiddlewareInput<Ctx> = undefined, HandlerCtx extends object = Ctx & AddedContextFromMiddlewareInput<RouteMiddleware>>(path: NonNullable<Route<Ctx>['path']>, options: RouteOptions<Ctx, RouteMiddleware, HandlerCtx>): this;
+  /**
+   * Add a DELETE route handler to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param handler - Handler invoked when the route matches.
+   * @returns The router instance for chaining.
+   */
+  delete(path: NonNullable<Route<Ctx>['path']>, handler: Handler<any, Ctx>): this;
+  /**
+   * Add a DELETE route definition to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param options - Route options registered with the DELETE method.
+   * @returns The router instance for chaining.
+   */
+  delete<RouteMiddleware extends MiddlewareInput<Ctx> = undefined, HandlerCtx extends object = Ctx & AddedContextFromMiddlewareInput<RouteMiddleware>>(path: NonNullable<Route<Ctx>['path']>, options: RouteOptions<Ctx, RouteMiddleware, HandlerCtx>): this;
+  /**
+   * Add a PATCH route handler to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param handler - Handler invoked when the route matches.
+   * @returns The router instance for chaining.
+   */
+  patch(path: NonNullable<Route<Ctx>['path']>, handler: Handler<any, Ctx>): this;
+  /**
+   * Add a PATCH route definition to this router.
+   *
+   * @param path - URL path pattern to match.
+   * @param options - Route options registered with the PATCH method.
+   * @returns The router instance for chaining.
+   */
+  patch<RouteMiddleware extends MiddlewareInput<Ctx> = undefined, HandlerCtx extends object = Ctx & AddedContextFromMiddlewareInput<RouteMiddleware>>(path: NonNullable<Route<Ctx>['path']>, options: RouteOptions<Ctx, RouteMiddleware, HandlerCtx>): this;
+  /**
+   * Return a flattened list of registered routes.
+   *
+   * @example
+   * ```ts
+   * const routes = router.getRoutes()
+   * ```
+   *
+   * @returns Array of normalized routes.
+   */
+  getRoutes(): NormalizedRoute<any>[];
+  private _getRoutes;
+  private _defaultRuntimeConfig;
+  private _handlerRegistration;
+  private _resolveRuntimeConfig;
+  private _match;
+  private _collectAllowedMethods;
+  private _acceptMatches;
+  private _formatAllowMethods;
+  private _buildHandlerContext;
+  private _runRequestMiddleware;
+  private _executeHandler;
+  private _statusResponse;
+  private _logInternalServerError;
+  private _finalizeResult;
+  private _responseFromRoutekitResponse;
+  private _appendVary;
+  private _selectSerializer;
+  private _isBetterSerializerCandidate;
+  private _tryCustomHandler;
+  private _requestWithBodyParsers;
+  private _handleNotFound;
+  private _handleMethodNotAllowed;
+  private _handleInternalError;
+  private _handleUnsupportedMediaType;
+  private _handleMatch;
+  private _methodMatches;
+  private _withRoutePrefix;
+  private _matchWithMethodCheck;
+  private _run;
+  private _isAsyncGenerator;
+  private _closeGenerator;
+  private _toResponseBody;
+  private _setContentLength;
+  private _getBodyByteLength;
+  private _isBodyChunk;
+  private _toBodyChunk;
+  private _mergeHeaders;
+  private _frameChunk;
+  private _responseFromGenerator;
+  private _handleRequest;
+  /**
+   * Handle an incoming request by matching routes and executing middleware.
+   *
+   * @example
+   * ```ts
+   * const response = await router.fetch(new Request('https://example.com/'))
+   * ```
+   *
+   * @param request - Incoming request to route.
+   * @returns The response produced by the matched handler.
+   */
+  fetch: (request: Request) => Promise<Response>;
+}
+//#endregion
+export { formDataRequestBodyParser as $, RequestMiddlewareEntry as A, RouterMountOptions as B, MiddlewareInput as C, isStreamDirective as Ct, RequestBodyParserInput as D, jsonLinesFramer as Dt, OneOrMany as E, StreamFramer as Et, RouteMeta as F, RequestBodyParser as G, RequestBodyFormData as H, RouteOptions as I, RoutekitRequest as J, RequestBodyStream as K, RoutePath as L, ResponseBodySerializerInput as M, Route as N, RequestContext as O, sseFramer as Ot, RouteMatch as P, defaultRequestBodyParsers as Q, RouteSchema as R, MiddlewareEntry as S, isStatusDirective as St, NormalizedRoute as T, stream as Tt, RequestBodyLengthMismatchError as U, RequestBodyError as V, RequestBodyParseContext as W, UnsupportedRequestBodyMediaTypeError as X, RoutekitRequestBody as Y, createRoutekitRequest as Z, JsonObjectSchema as _, headers as _t, MiddlewareResponseDeclaration as a, createStartStream as at, MediaType as b, isHeadersDirective as bt, AcceptMediaRange as c, jsonResponseBodySerializer as ct, ContentType as d, HeadersDirective as dt, jsonRequestBodyParser as et, ContextFromMiddlewareInput as f, RoutekitYield as ft, HandlerResult as g, head as gt, HandlerContext as h, chunk as ht, MiddlewareControls as i, createAsyncStream as it, RequestMiddlewareInput as j, RequestMiddleware as k, AddedContextFromMiddlewareInput as l, ChunkDirective as lt, Handler as m, StreamDirective as mt, DeclaredMiddleware as n, textRequestBodyParser as nt, MiddlewareResponseDeclarations as o, ResponseBodySerializer as ot, ContextMiddleware as p, StatusDirective as pt, RequestBodyTooLargeError as q, DefineMiddlewareOptions as r, urlEncodedRequestBodyParser as rt, defineMiddleware as s, defaultResponseBodySerializers as st, Router as t, responseFromRequestBodyError as tt, AnyContext as u, HeadDirective as ut, JsonSchema as v, isChunkDirective as vt, MiddlewareList as w, status as wt, Middleware as x, isRoutekitDirective as xt, MaybePromise as y, isHeadDirective as yt, RouterExtension as z };