@mpen/routekit 0.1.0 → 0.1.1

package/src/router/router.ts

@@ -1,1965 +0,0 @@
-import { CommonHeaders, HttpMethod, HttpStatus, StatusText } from '@mpen/http'
-import { ConsoleLogger, type Logger } from '@mpen/logger'
-import type { SimpleServerInterface } from './server-interface'
-import { joinPrefixPathname, stripPrefixPathname } from './lib/pathname'
-import { normalizeRoute } from './lib/route-normalize'
-import { mergeRouteSchemas } from './lib/schema-merge'
-import { isDeclaredMiddleware, type DeclaredMiddleware } from './middleware/define'
-import {
-    mediaRangeAccepts,
-    mediaRangeQuality,
-    mediaRangeToContentType,
-    mediaTypeMatches,
-    parseAcceptHeader,
-    parseContentType,
-} from './lib/media-type'
-import {
-    createRoutekitRequest,
-    defaultRequestBodyParsers,
-    RequestBodyError,
-    responseFromRequestBodyError,
-    type RequestBodyParser,
-    type RoutekitRequest,
-} from './request'
-import type {
-    AddedContextFromMiddlewareInput,
-    AnyContext,
-    ContextMiddleware,
-    Handler,
-    HandlerBody,
-    HandlerFinalResult,
-    HandlerResult,
-    HandlerContext,
-    HandlerYield,
-    MiddlewareEntry,
-    MiddlewareInput,
-    NormalizedRoute,
-    RequestContext,
-    RequestBodyParserInput,
-    RequestMiddleware,
-    RequestMiddlewareEntry,
-    RequestMiddlewareInput,
-    Route,
-    RouteOptions,
-    RouterExtension,
-    RouterMountOptions,
-    ResponseBodySerializerInput,
-} from './types'
-import {
-    defaultResponseBodySerializers,
-    isChunkDirective,
-    isHeadersDirective,
-    isHeadDirective,
-    isResponseBodyInit,
-    isRoutekitBody,
-    isRoutekitResponse,
-    isStatusDirective,
-    isStreamDirective,
-    response as routekitResponse,
-    type ResponseBodySerializer,
-    type RoutekitResponse,
-    type StreamFramer,
-} from './response'
-import { text } from './response/formats/content'
-import type { RouterBodyInit } from './fetch-types'
-
-type ExecutableMiddleware = ContextMiddleware<any, any> | DeclaredMiddleware<any, any>
-type ExecutableRequestMiddleware = RequestMiddleware<any, any>
-
-type RouteEntry =
-    | { kind: 'route'; route: NormalizedRoute<any>; middleware: ExecutableMiddleware[] }
-    | { kind: 'router'; prefix?: string; router: Router<any> }
-
-type MatchResult = {
-    kind: 'match'
-    route: NormalizedRoute<any>
-    routePath: string
-    match: URLPatternResult | null
-    middleware: ExecutableMiddleware[]
-    router: Router<any>
-    config: RuntimeConfig
-}
-
-type HandlerRegistration = {
-    handler: Handler<any, any>
-    router: Router<any>
-}
-
-type RuntimeConfig = {
-    requestBodyParsers: RequestBodyParser[]
-    responseBodySerializers: ResponseBodySerializer[]
-    logger: Logger
-    requestMiddleware: ExecutableRequestMiddleware[]
-    onNotFoundHandler?: HandlerRegistration
-    onMethodNotAllowedHandler?: HandlerRegistration
-    onUnsupportedMediaTypeHandler?: HandlerRegistration
-    onInternalErrorHandler?: HandlerRegistration
-}
-
-type ResponseBodySerializerCandidate = {
-    serializer: ResponseBodySerializer
-    mediaType: string
-    acceptQuality: number
-    mediaTypeQuality: number
-    acceptIndex: number
-    serializerIndex: number
-    mediaTypeIndex: number
-}
-
-type MatchAttempt = {
-    match: MatchResult | null
-    unsupportedMediaType: MatchResult | null
-    methodNotAllowedConfig: RuntimeConfig | null
-    notFoundConfig: RuntimeConfig
-}
-
-type MethodRouteInput<Ctx extends object> = Handler<any, Ctx> | RouteOptions<any, any, any>
-
-function normalizeMiddlewareList<Ctx extends object>(
-    middleware: MiddlewareInput<Ctx>,
-): ExecutableMiddleware[] {
-    if (!middleware) return []
-    if (Array.isArray(middleware)) {
-        return middleware.filter(Boolean) as ExecutableMiddleware[]
-    }
-    return [middleware as ExecutableMiddleware]
-}
-
-function normalizeRequestMiddlewareList<Ctx extends object>(
-    middleware: RequestMiddlewareInput<Ctx>,
-): ExecutableRequestMiddleware[] {
-    if (!middleware) return []
-    if (Array.isArray(middleware)) {
-        return middleware.filter(Boolean) as ExecutableRequestMiddleware[]
-    }
-    return [middleware as ExecutableRequestMiddleware]
-}
-
-function normalizeRequestBodyParsers(input: RequestBodyParserInput): RequestBodyParser[] {
-    if (!input) return []
-    if (Array.isArray(input)) return input.filter(Boolean) as RequestBodyParser[]
-    return [input as RequestBodyParser]
-}
-
-function normalizeResponseBodySerializers(
-    input: ResponseBodySerializerInput,
-): ResponseBodySerializer[] {
-    if (!input) return []
-    if (Array.isArray(input)) return input.filter(Boolean) as ResponseBodySerializer[]
-    return [input as ResponseBodySerializer]
-}
-
-function isHandler<Ctx extends object>(input: MethodRouteInput<Ctx>): input is Handler<any, Ctx> {
-    return typeof input === 'function'
-}
-
-/**
- * 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)})
- * ```
- */
-export class Router<Ctx extends object = AnyContext> implements SimpleServerInterface {
-    private _entries: RouteEntry[] = []
-    private _middleware: ExecutableMiddleware[] = []
-    private _requestMiddleware: ExecutableRequestMiddleware[] = []
-    private _responseBodySerializers: ResponseBodySerializer[] = []
-    private _responseBodySerializersMode: 'inherit' | 'replace' = 'inherit'
-    private _requestBodyParsers: RequestBodyParser[] = []
-    private _requestBodyParsersMode: 'inherit' | 'replace' = 'inherit'
-    private _logger?: Logger
-    private readonly _defaultLogger = new ConsoleLogger()
-    private _onNotFoundHandler?: Handler<any, Ctx>
-    private _onMethodNotAllowedHandler?: Handler<any, Ctx>
-    private _onUnsupportedMediaTypeHandler?: Handler<any, Ctx>
-    private _onInternalErrorHandler?: Handler<any, Ctx>
-
-    /**
-     * 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 {
-        extension(this)
-        return 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 {
-        this._onNotFoundHandler = handler
-        return 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 {
-        this._onMethodNotAllowedHandler = handler
-        return 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 {
-        this._onUnsupportedMediaTypeHandler = handler
-        return 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 {
-        this._onInternalErrorHandler = handler
-        return 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 {
-        return this.addRequestBodyParsers([parser])
-    }
-
-    /**
-     * 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 {
-        this._requestBodyParsers.push(...normalizeRequestBodyParsers(parsers))
-        return 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 {
-        this._requestBodyParsers = normalizeRequestBodyParsers(parsers)
-        this._requestBodyParsersMode = 'replace'
-        return 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 {
-        return this.addResponseBodySerializers([serializer])
-    }
-
-    /**
-     * 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 {
-        this._responseBodySerializers.push(...normalizeResponseBodySerializers(serializers))
-        return 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 {
-        this._responseBodySerializers = normalizeResponseBodySerializers(serializers)
-        this._responseBodySerializersMode = 'replace'
-        return 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 {
-        this._logger = logger
-        return 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>>
-    use(middleware: MiddlewareInput<Ctx>): Router<any> {
-        const list = normalizeMiddlewareList(middleware)
-        this._middleware.push(...list)
-        return this
-    }
-
-    /**
-     * 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>>
-    useRequest(middleware: RequestMiddlewareInput<Ctx>): Router<any> {
-        this._requestMiddleware.push(...normalizeRequestMiddlewareList(middleware))
-        return this
-    }
-
-    /**
-     * 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
-    mount(
-        prefixOrOptionsOrRouter:
-            | string
-            | RouterMountOptions<Ctx>
-            | Router<any>
-            | ((router: Router<any>) => void),
-        routerOrConfigure?: Router<any> | ((router: Router<any>) => void),
-    ): this {
-        const mountOptions: RouterMountOptions<Ctx> =
-            typeof prefixOrOptionsOrRouter === 'string'
-                ? { prefix: prefixOrOptionsOrRouter }
-                : prefixOrOptionsOrRouter instanceof Router ||
-                    typeof prefixOrOptionsOrRouter === 'function'
-                  ? {}
-                  : prefixOrOptionsOrRouter
-        const target =
-            prefixOrOptionsOrRouter instanceof Router ||
-            typeof prefixOrOptionsOrRouter === 'function'
-                ? prefixOrOptionsOrRouter
-                : routerOrConfigure
-
-        if (target instanceof Router && !mountOptions.middleware) {
-            this._entries.push({ kind: 'router', prefix: mountOptions.prefix, router: target })
-            return this
-        }
-
-        const scope = new Router<any>()
-        if (mountOptions.middleware) {
-            scope.use(normalizeMiddlewareList(mountOptions.middleware as MiddlewareInput<any>))
-        }
-        if (target instanceof Router) {
-            scope.mount(target)
-        } else {
-            target?.(scope)
-        }
-        this._entries.push({ kind: 'router', prefix: mountOptions.prefix, router: scope })
-        return 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 {
-        this._entries.push({
-            kind: 'route',
-            route: normalizeRoute(route),
-            middleware: normalizeMiddlewareList(route.middleware as MiddlewareInput<any>),
-        })
-        return this
-    }
-
-    private _addMethod<
-        RouteMiddleware extends MiddlewareInput<Ctx> = undefined,
-        HandlerCtx extends object = Ctx & AddedContextFromMiddlewareInput<RouteMiddleware>,
-    >(
-        method: HttpMethod,
-        path: NonNullable<Route<Ctx>['path']>,
-        input: Handler<any, Ctx> | RouteOptions<Ctx, RouteMiddleware, HandlerCtx>,
-    ): this {
-        return this.add({
-            ...(isHandler(input) ? { handler: input } : input),
-            path,
-            method,
-        } as Route<Ctx, RouteMiddleware, HandlerCtx>)
-    }
-
-    /**
-     * 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
-    get(path: NonNullable<Route<Ctx>['path']>, input: MethodRouteInput<Ctx>): this {
-        return this._addMethod(HttpMethod.GET, path, input)
-    }
-
-    /**
-     * 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
-    head(path: NonNullable<Route<Ctx>['path']>, input: MethodRouteInput<Ctx>): this {
-        return this._addMethod(HttpMethod.HEAD, path, input)
-    }
-
-    /**
-     * 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
-    post(path: NonNullable<Route<Ctx>['path']>, input: MethodRouteInput<Ctx>): this {
-        return this._addMethod(HttpMethod.POST, path, input)
-    }
-
-    /**
-     * 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
-    put(path: NonNullable<Route<Ctx>['path']>, input: MethodRouteInput<Ctx>): this {
-        return this._addMethod(HttpMethod.PUT, path, input)
-    }
-
-    /**
-     * 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
-    delete(path: NonNullable<Route<Ctx>['path']>, input: MethodRouteInput<Ctx>): this {
-        return this._addMethod(HttpMethod.DELETE, path, input)
-    }
-
-    /**
-     * 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
-    patch(path: NonNullable<Route<Ctx>['path']>, input: MethodRouteInput<Ctx>): this {
-        return this._addMethod(HttpMethod.PATCH, path, input)
-    }
-
-    /**
-     * Return a flattened list of registered routes.
-     *
-     * @example
-     * ```ts
-     * const routes = router.getRoutes()
-     * ```
-     *
-     * @returns Array of normalized routes.
-     */
-    getRoutes(): NormalizedRoute<any>[] {
-        return this._getRoutes([])
-    }
-
-    private _getRoutes(parentMiddleware: ExecutableMiddleware[]): NormalizedRoute<any>[] {
-        const routes: NormalizedRoute<any>[] = []
-        const middleware = [...parentMiddleware, ...this._middleware]
-        for (const entry of this._entries) {
-            if (entry.kind === 'route') {
-                const routeMiddleware = [...middleware, ...entry.middleware]
-                const schema = mergeRouteSchemas(
-                    ...routeMiddleware.flatMap((value) =>
-                        isDeclaredMiddleware(value) &&
-                        (!value.schemaAppliesTo || value.schemaAppliesTo(entry.route))
-                            ? [value.schema]
-                            : [],
-                    ),
-                    entry.route.schema,
-                )
-                routes.push({
-                    ...entry.route,
-                    ...(schema === undefined ? {} : { schema }),
-                })
-                continue
-            }
-
-            for (const subRoute of entry.router._getRoutes(middleware)) {
-                if (!entry.prefix) {
-                    routes.push(subRoute)
-                    continue
-                }
-
-                const path = new URLPattern({
-                    pathname: joinPrefixPathname(entry.prefix, subRoute.path.pathname),
-                })
-                routes.push({
-                    ...subRoute,
-                    path,
-                })
-            }
-        }
-        return routes
-    }
-
-    private _defaultRuntimeConfig(): RuntimeConfig {
-        return {
-            requestBodyParsers: defaultRequestBodyParsers(),
-            responseBodySerializers: defaultResponseBodySerializers(),
-            logger: this._defaultLogger,
-            requestMiddleware: [],
-        }
-    }
-
-    private _handlerRegistration(
-        handler: Handler<any, any> | undefined,
-    ): HandlerRegistration | undefined {
-        return handler ? { handler, router: this } : undefined
-    }
-
-    private _resolveRuntimeConfig(parent: RuntimeConfig): RuntimeConfig {
-        const requestBodyParsers =
-            this._requestBodyParsersMode === 'replace'
-                ? [...this._requestBodyParsers]
-                : [...parent.requestBodyParsers, ...this._requestBodyParsers]
-        const responseBodySerializers =
-            this._responseBodySerializersMode === 'replace'
-                ? [...this._responseBodySerializers]
-                : [...parent.responseBodySerializers, ...this._responseBodySerializers]
-
-        return {
-            requestBodyParsers,
-            responseBodySerializers,
-            logger: this._logger ?? parent.logger,
-            requestMiddleware: [...parent.requestMiddleware, ...this._requestMiddleware],
-            onNotFoundHandler:
-                this._handlerRegistration(this._onNotFoundHandler) ?? parent.onNotFoundHandler,
-            onMethodNotAllowedHandler:
-                this._handlerRegistration(this._onMethodNotAllowedHandler) ??
-                parent.onMethodNotAllowedHandler,
-            onUnsupportedMediaTypeHandler:
-                this._handlerRegistration(this._onUnsupportedMediaTypeHandler) ??
-                parent.onUnsupportedMediaTypeHandler,
-            onInternalErrorHandler:
-                this._handlerRegistration(this._onInternalErrorHandler) ??
-                parent.onInternalErrorHandler,
-        }
-    }
-
-    private _match(
-        request: RoutekitRequest,
-        method: HttpMethod,
-        url: URL,
-        parentConfig: RuntimeConfig,
-    ):
-        | MatchResult
-        | { kind: 'method_not_allowed'; config: RuntimeConfig }
-        | { kind: 'unsupported_media_type'; found: MatchResult }
-        | { kind: 'not_found'; config: RuntimeConfig } {
-        const isHead = method === HttpMethod.HEAD
-        if (isHead) {
-            const headOnly = this._matchWithMethodCheck(
-                request,
-                url,
-                (routeMethod) => this._methodMatches(routeMethod, HttpMethod.HEAD),
-                parentConfig,
-                [],
-            )
-            if (headOnly.match) return headOnly.match
-            const getOnly = this._matchWithMethodCheck(
-                request,
-                url,
-                (routeMethod) => this._methodMatches(routeMethod, HttpMethod.GET),
-                parentConfig,
-                [],
-            )
-            if (getOnly.match) return getOnly.match
-            if (headOnly.unsupportedMediaType)
-                return { kind: 'unsupported_media_type', found: headOnly.unsupportedMediaType }
-            if (getOnly.unsupportedMediaType)
-                return { kind: 'unsupported_media_type', found: getOnly.unsupportedMediaType }
-            const methodNotAllowedConfig =
-                headOnly.methodNotAllowedConfig ?? getOnly.methodNotAllowedConfig
-            if (methodNotAllowedConfig) {
-                return { kind: 'method_not_allowed', config: methodNotAllowedConfig }
-            }
-            return { kind: 'not_found', config: headOnly.notFoundConfig }
-        }
-        const match = this._matchWithMethodCheck(
-            request,
-            url,
-            (routeMethod) => this._methodMatches(routeMethod, method),
-            parentConfig,
-            [],
-        )
-        if (match.match) return match.match
-        if (match.unsupportedMediaType)
-            return { kind: 'unsupported_media_type', found: match.unsupportedMediaType }
-        if (match.methodNotAllowedConfig) {
-            return { kind: 'method_not_allowed', config: match.methodNotAllowedConfig }
-        }
-        return { kind: 'not_found', config: match.notFoundConfig }
-    }
-
-    private _collectAllowedMethods(url: URL): Set<HttpMethod> {
-        const methods = new Set<HttpMethod>()
-        function addMethods(routeMethod?: HttpMethod | HttpMethod[]) {
-            if (!routeMethod) return
-            const normalized = Array.isArray(routeMethod) ? routeMethod : [routeMethod]
-            for (const method of normalized) {
-                methods.add(method)
-            }
-        }
-        function visit(entries: RouteEntry[], currentUrl: URL) {
-            for (const entry of entries) {
-                if (entry.kind === 'route') {
-                    if (entry.route.match) continue
-                    if (!entry.route.path.exec(currentUrl)) continue
-                    addMethods(entry.route.method)
-                    continue
-                }
-
-                if (entry.prefix) {
-                    const subPathname = stripPrefixPathname(entry.prefix, currentUrl.pathname)
-                    if (subPathname == null) continue
-                    const subUrl = new URL(currentUrl.toString())
-                    subUrl.pathname = subPathname
-                    visit(entry.router._entries, subUrl)
-                } else {
-                    visit(entry.router._entries, currentUrl)
-                }
-            }
-        }
-        visit(this._entries, url)
-        return methods
-    }
-
-    private _acceptMatches(route: NormalizedRoute<any>, request: RoutekitRequest): boolean {
-        if (!route.accept || route.accept.length === 0) return true
-        const contentTypeHeader = request.headers.get(CommonHeaders.CONTENT_TYPE)
-        if (!contentTypeHeader) return false
-        const contentType = parseContentType(contentTypeHeader)
-        if (!contentType) return false
-        return route.accept.some((accept) => mediaTypeMatches(accept, contentType))
-    }
-
-    private _formatAllowMethods(methods: Set<HttpMethod>): string {
-        const order = [
-            HttpMethod.GET,
-            HttpMethod.HEAD,
-            HttpMethod.POST,
-            HttpMethod.PUT,
-            HttpMethod.PATCH,
-            HttpMethod.DELETE,
-            HttpMethod.OPTIONS,
-        ]
-        const ordered: HttpMethod[] = []
-        for (const method of order) {
-            if (methods.has(method)) ordered.push(method)
-        }
-        const remaining = [...methods].filter((method) => !order.includes(method)).sort()
-        return [...ordered, ...remaining].join(', ')
-    }
-
-    private _buildHandlerContext(
-        request: RoutekitRequest,
-        url: URL,
-        path: Record<string, string>,
-        config: RuntimeConfig,
-        routePath?: string,
-    ): HandlerContext<Ctx> {
-        return {
-            request,
-            url,
-            path,
-            logger: config.logger.withContext({
-                'http.request.method': request.method,
-                'url.path': url.pathname,
-                ...(routePath == null ? {} : { 'http.route': routePath }),
-            }),
-        } as HandlerContext<Ctx>
-    }
-
-    private _runRequestMiddleware(
-        middleware: ExecutableRequestMiddleware[],
-        ctx: HandlerContext<any>,
-        respond: () => Promise<Response>,
-    ): Promise<Response> {
-        let index = -1
-        const dispatch = async (nextIndex: number): Promise<Response> => {
-            if (nextIndex <= index) throw new Error('next() called multiple times')
-            index = nextIndex
-
-            const current = middleware[nextIndex]
-            if (current == null) {
-                return nextIndex >= middleware.length
-                    ? await respond()
-                    : await dispatch(nextIndex + 1)
-            }
-            return await current(ctx, () => dispatch(nextIndex + 1))
-        }
-
-        return dispatch(0)
-    }
-
-    private async _executeHandler(
-        handler: Handler<any, any>,
-        middleware: ExecutableMiddleware[],
-        ctx: HandlerContext<any>,
-        router: Router<any>,
-        request: RoutekitRequest,
-        config: RuntimeConfig,
-    ): Promise<Response> {
-        const result = await this._run(handler, middleware, ctx, router)
-        if (result instanceof Response) {
-            return result
-        }
-        if (this._isAsyncGenerator(result)) {
-            const response = await this._responseFromGenerator(result, request, config)
-            if (response) return response
-            return new Response(null, { status: HttpStatus.CLIENT_CLOSED_REQUEST })
-        }
-        return await this._finalizeResult(result, request, config)
-    }
-
-    private _statusResponse(status: HttpStatus, request?: RoutekitRequest): Response {
-        const result = text(StatusText[status] ?? `HTTP Status ${status}`, { status })
-        return new Response(
-            request?.method.toUpperCase() === HttpMethod.HEAD ? null : (result.body as string),
-            {
-                status,
-                headers: result.headers,
-            },
-        )
-    }
-
-    private _logInternalServerError(error: unknown, logger: Logger): void {
-        try {
-            logger.error('Routekit internal server error', error)
-        } catch {
-            // Logging must not change the response produced for an internal server error.
-        }
-    }
-
-    private async _finalizeResult(
-        result: HandlerFinalResult,
-        request: RoutekitRequest,
-        config: RuntimeConfig,
-    ): Promise<Response> {
-        if (result instanceof Response) {
-            return result
-        }
-        if (this._isAsyncGenerator(result)) {
-            const response = await this._responseFromGenerator(result, request, config)
-            if (response) return response
-            return new Response(null, { status: HttpStatus.CLIENT_CLOSED_REQUEST })
-        }
-        if (isRoutekitResponse(result)) {
-            return await this._responseFromRoutekitResponse(result, request, config)
-        }
-        if (isRoutekitBody(result)) {
-            return await this._responseFromRoutekitResponse(
-                routekitResponse(result.value),
-                request,
-                config,
-            )
-        }
-        if (isResponseBodyInit(result)) {
-            const body = this._toResponseBody(result)
-            const headers = new Headers()
-            this._setContentLength(headers, body)
-            return new Response(body, {
-                status: HttpStatus.OK,
-                headers,
-            })
-        }
-        return await this._responseFromRoutekitResponse(routekitResponse(result), request, config)
-    }
-
-    private async _responseFromRoutekitResponse(
-        result: RoutekitResponse,
-        request: RoutekitRequest,
-        config: RuntimeConfig,
-    ): Promise<Response> {
-        const isHead = request.method.toUpperCase() === HttpMethod.HEAD
-        const headers = new Headers(result.headers)
-        const status = result.status
-
-        if (headers.has(CommonHeaders.CONTENT_TYPE)) {
-            if (!isResponseBodyInit(result.body)) {
-                throw new TypeError(
-                    'Routekit response has Content-Type set, so body must be a native Response body.',
-                )
-            }
-            const body = this._toResponseBody(result.body)
-            this._setContentLength(headers, body)
-            return new Response(isHead ? null : body, {
-                status,
-                headers,
-            })
-        }
-
-        if (result.body === undefined) {
-            return new Response(null, { status, headers })
-        }
-
-        const serializer = this._selectSerializer(result.body, request, config)
-        if (!serializer) {
-            return this._statusResponse(HttpStatus.NOT_ACCEPTABLE, request)
-        }
-        headers.set(CommonHeaders.CONTENT_TYPE, serializer.mediaType)
-        this._appendVary(headers, CommonHeaders.ACCEPT)
-        const body = await serializer.serializer.serialize(result.body)
-        this._setContentLength(headers, body)
-
-        return new Response(isHead ? null : body, {
-            status,
-            headers,
-        })
-    }
-
-    private _appendVary(headers: Headers, value: string): void {
-        const current = headers.get(CommonHeaders.VARY)
-        if (!current) {
-            headers.set(CommonHeaders.VARY, value)
-            return
-        }
-        const entries = current.split(',').map((entry) => entry.trim().toLowerCase())
-        if (entries.includes(value.toLowerCase())) return
-        headers.set(CommonHeaders.VARY, `${current}, ${value}`)
-    }
-
-    private _selectSerializer(
-        body: unknown,
-        request: RoutekitRequest,
-        config: RuntimeConfig,
-    ): { serializer: ResponseBodySerializer; mediaType: string } | null {
-        const accepted = parseAcceptHeader(request.headers.get(CommonHeaders.ACCEPT) ?? '*/*')
-        const ranges = accepted.length ? accepted : parseAcceptHeader('*/*')
-        let best: ResponseBodySerializerCandidate | null = null
-        for (const [acceptIndex, accept] of ranges.entries()) {
-            if (accept.q === 0) continue
-            for (const [serializerIndex, serializer] of config.responseBodySerializers.entries()) {
-                if (serializer.canSerialize && !serializer.canSerialize(body)) continue
-                for (const [mediaTypeIndex, mediaTypeRange] of serializer.mediaTypes.entries()) {
-                    const mediaTypeQuality = mediaRangeQuality(mediaTypeRange)
-                    if (mediaTypeQuality === 0) continue
-                    if (mediaRangeAccepts(accept, mediaTypeRange)) {
-                        const mediaType = mediaRangeToContentType(mediaTypeRange)
-                        if (!mediaType) continue
-                        const candidate = {
-                            serializer,
-                            mediaType,
-                            acceptQuality: accept.q,
-                            mediaTypeQuality,
-                            acceptIndex,
-                            serializerIndex,
-                            mediaTypeIndex,
-                        }
-                        if (this._isBetterSerializerCandidate(candidate, best)) {
-                            best = candidate
-                        }
-                    }
-                }
-            }
-        }
-        return best ? { serializer: best.serializer, mediaType: best.mediaType } : null
-    }
-
-    private _isBetterSerializerCandidate(
-        candidate: ResponseBodySerializerCandidate,
-        best: ResponseBodySerializerCandidate | null,
-    ): boolean {
-        if (!best) return true
-        if (candidate.acceptQuality !== best.acceptQuality) {
-            return candidate.acceptQuality > best.acceptQuality
-        }
-        if (candidate.mediaTypeQuality !== best.mediaTypeQuality) {
-            return candidate.mediaTypeQuality > best.mediaTypeQuality
-        }
-        if (candidate.acceptIndex !== best.acceptIndex) {
-            return candidate.acceptIndex < best.acceptIndex
-        }
-        if (candidate.serializerIndex !== best.serializerIndex) {
-            return candidate.serializerIndex < best.serializerIndex
-        }
-        return candidate.mediaTypeIndex < best.mediaTypeIndex
-    }
-
-    private async _tryCustomHandler(
-        registration: HandlerRegistration | undefined,
-        ctx: HandlerContext<any>,
-        config: RuntimeConfig,
-        request: RoutekitRequest,
-    ): Promise<Response | null> {
-        if (!registration) return null
-        try {
-            return await this._executeHandler(
-                registration.handler,
-                [],
-                ctx,
-                registration.router,
-                request,
-                config,
-            )
-        } catch (error) {
-            if (error instanceof RequestBodyError) return responseFromRequestBodyError(error)
-            this._logInternalServerError(error, ctx.logger)
-            return this._statusResponse(HttpStatus.INTERNAL_SERVER_ERROR, request)
-        }
-    }
-
-    private _requestWithBodyParsers(
-        request: RoutekitRequest,
-        config: RuntimeConfig,
-    ): RoutekitRequest {
-        return createRoutekitRequest(request.raw, request.url, config.requestBodyParsers)
-    }
-
-    private async _handleNotFound(
-        request: RoutekitRequest,
-        url: URL,
-        config: RuntimeConfig,
-    ): Promise<Response> {
-        request = this._requestWithBodyParsers(request, config)
-        const ctx = this._buildHandlerContext(request, url, {}, config)
-        return await this._runRequestMiddleware(config.requestMiddleware, ctx, async () => {
-            const custom = await this._tryCustomHandler(
-                config.onNotFoundHandler,
-                ctx,
-                config,
-                request,
-            )
-            if (custom) return custom
-            return this._statusResponse(HttpStatus.NOT_FOUND, request)
-        })
-    }
-
-    private async _handleMethodNotAllowed(
-        request: RoutekitRequest,
-        url: URL,
-        config: RuntimeConfig,
-    ): Promise<Response> {
-        request = this._requestWithBodyParsers(request, config)
-        const ctx = this._buildHandlerContext(request, url, {}, config)
-        return await this._runRequestMiddleware(config.requestMiddleware, ctx, async () => {
-            const custom = await this._tryCustomHandler(
-                config.onMethodNotAllowedHandler,
-                ctx,
-                config,
-                request,
-            )
-            if (custom) return custom
-            return this._statusResponse(HttpStatus.METHOD_NOT_ALLOWED, request)
-        })
-    }
-
-    private async _handleInternalError(
-        config: RuntimeConfig,
-        ctx: HandlerContext<any>,
-        request: RoutekitRequest,
-        error: unknown,
-    ): Promise<Response> {
-        if (error instanceof RequestBodyError) return responseFromRequestBodyError(error)
-        this._logInternalServerError(error, ctx.logger)
-        const custom = await this._tryCustomHandler(
-            config.onInternalErrorHandler,
-            ctx,
-            config,
-            request,
-        )
-        if (custom) return custom
-        return this._statusResponse(HttpStatus.INTERNAL_SERVER_ERROR, request)
-    }
-
-    private async _handleUnsupportedMediaType(
-        found: MatchResult,
-        request: RoutekitRequest,
-        url: URL,
-    ): Promise<Response> {
-        request = this._requestWithBodyParsers(request, found.config)
-        const rawPathParams = found.match?.pathname.groups ?? {}
-        const path = Object.fromEntries(
-            Object.entries(rawPathParams).filter(([, value]) => value !== undefined),
-        ) as Record<string, string>
-        const handlerCtx = this._buildHandlerContext(
-            request,
-            url,
-            path,
-            found.config,
-            found.routePath,
-        )
-        return await this._runRequestMiddleware(
-            found.config.requestMiddleware,
-            handlerCtx,
-            async () => {
-                const custom = await this._tryCustomHandler(
-                    found.config.onUnsupportedMediaTypeHandler,
-                    handlerCtx,
-                    found.config,
-                    request,
-                )
-                if (custom) return custom
-                return this._statusResponse(HttpStatus.UNSUPPORTED_MEDIA_TYPE, request)
-            },
-        )
-    }
-
-    private async _handleMatch(
-        found: MatchResult,
-        request: RoutekitRequest,
-        url: URL,
-    ): Promise<Response> {
-        request = this._requestWithBodyParsers(request, found.config)
-        const rawPathParams = found.match?.pathname.groups ?? {}
-        const path = Object.fromEntries(
-            Object.entries(rawPathParams).filter(([, value]) => value !== undefined),
-        ) as Record<string, string>
-        const handlerCtx = this._buildHandlerContext(
-            request,
-            url,
-            path,
-            found.config,
-            found.routePath,
-        )
-
-        return await this._runRequestMiddleware(
-            found.config.requestMiddleware,
-            handlerCtx,
-            async () => {
-                try {
-                    mergeRouteSchemas(
-                        ...found.middleware.flatMap((value) =>
-                            isDeclaredMiddleware(value) &&
-                            (!value.schemaAppliesTo || value.schemaAppliesTo(found.route))
-                                ? [value.schema]
-                                : [],
-                        ),
-                        found.route.schema,
-                    )
-                    return await this._executeHandler(
-                        found.route.handler,
-                        found.middleware,
-                        handlerCtx,
-                        found.router,
-                        request,
-                        found.config,
-                    )
-                } catch (error) {
-                    return await this._handleInternalError(found.config, handlerCtx, request, error)
-                }
-            },
-        )
-    }
-
-    private _methodMatches(
-        routeMethod: HttpMethod | HttpMethod[] | undefined,
-        method: HttpMethod,
-    ): boolean {
-        if (!routeMethod) return true
-        const normalized = Array.isArray(routeMethod) ? routeMethod : [routeMethod]
-        return normalized.some((routeValue) => routeValue === method)
-    }
-
-    private _withRoutePrefix(match: MatchResult, prefix?: string): MatchResult {
-        return prefix == null
-            ? match
-            : {
-                  ...match,
-                  routePath: joinPrefixPathname(prefix, match.routePath),
-              }
-    }
-
-    private _matchWithMethodCheck(
-        request: RoutekitRequest,
-        url: URL,
-        methodCheck: (routeMethod?: HttpMethod | HttpMethod[]) => boolean,
-        parentConfig: RuntimeConfig,
-        parentMiddleware: ExecutableMiddleware[],
-    ): MatchAttempt {
-        const config = this._resolveRuntimeConfig(parentConfig)
-        const middleware = [...parentMiddleware, ...this._middleware]
-        let methodNotAllowedConfig: RuntimeConfig | null = null
-        let unsupportedMediaType: MatchResult | null = null
-        let notFoundConfig = config
-        for (const entry of this._entries) {
-            if (entry.kind === 'route') {
-                const route = entry.route
-                const routeMiddleware = [...middleware, ...entry.middleware]
-                const pathMatch = route.path.exec(url)
-                if (route.match) {
-                    if (!route.match(request)) continue
-                    return {
-                        match: {
-                            kind: 'match',
-                            route,
-                            routePath: route.path.pathname,
-                            match: pathMatch,
-                            middleware: routeMiddleware,
-                            router: this,
-                            config,
-                        },
-                        unsupportedMediaType,
-                        methodNotAllowedConfig,
-                        notFoundConfig,
-                    }
-                }
-                if (!pathMatch) continue
-                if (!methodCheck(route.method)) {
-                    methodNotAllowedConfig ??= config
-                    continue
-                }
-                if (!this._acceptMatches(route, request)) {
-                    unsupportedMediaType ??= {
-                        kind: 'match',
-                        route,
-                        routePath: route.path.pathname,
-                        match: pathMatch,
-                        middleware: routeMiddleware,
-                        router: this,
-                        config,
-                    }
-                    continue
-                }
-                return {
-                    match: {
-                        kind: 'match',
-                        route,
-                        routePath: route.path.pathname,
-                        match: pathMatch,
-                        middleware: routeMiddleware,
-                        router: this,
-                        config,
-                    },
-                    unsupportedMediaType,
-                    methodNotAllowedConfig,
-                    notFoundConfig,
-                }
-            }
-
-            if (entry.prefix) {
-                const subPathname = stripPrefixPathname(entry.prefix, url.pathname)
-                if (subPathname == null) continue
-                const subUrl = new URL(url.toString())
-                subUrl.pathname = subPathname
-                const subMatch = entry.router._matchWithMethodCheck(
-                    request,
-                    subUrl,
-                    methodCheck,
-                    config,
-                    middleware,
-                )
-                if (subMatch.match) {
-                    return {
-                        match: this._withRoutePrefix(subMatch.match, entry.prefix),
-                        unsupportedMediaType,
-                        methodNotAllowedConfig,
-                        notFoundConfig,
-                    }
-                }
-                if (subMatch.unsupportedMediaType && !unsupportedMediaType) {
-                    unsupportedMediaType = this._withRoutePrefix(
-                        subMatch.unsupportedMediaType,
-                        entry.prefix,
-                    )
-                }
-                methodNotAllowedConfig ??= subMatch.methodNotAllowedConfig
-                notFoundConfig = subMatch.notFoundConfig
-            } else {
-                const subMatch = entry.router._matchWithMethodCheck(
-                    request,
-                    url,
-                    methodCheck,
-                    config,
-                    middleware,
-                )
-                if (subMatch.match) {
-                    return {
-                        match: subMatch.match,
-                        unsupportedMediaType,
-                        methodNotAllowedConfig,
-                        notFoundConfig,
-                    }
-                }
-                if (subMatch.unsupportedMediaType && !unsupportedMediaType) {
-                    unsupportedMediaType = subMatch.unsupportedMediaType
-                }
-                methodNotAllowedConfig ??= subMatch.methodNotAllowedConfig
-                notFoundConfig = subMatch.notFoundConfig
-            }
-        }
-        return { match: null, unsupportedMediaType, methodNotAllowedConfig, notFoundConfig }
-    }
-
-    private _run(
-        handler: Handler<any, any>,
-        middleware: ExecutableMiddleware[],
-        ctx: HandlerContext<Ctx>,
-        router: Router<any>,
-    ): Promise<HandlerResult> {
-        let idx = -1
-        const dispatch = async (i: number): Promise<HandlerResult> => {
-            if (i <= idx) throw new Error('next() called multiple times')
-            idx = i
-
-            if (i === middleware.length) {
-                return await Promise.resolve().then(() => handler.call(router, ctx as any))
-            }
-
-            const mw = middleware[i]
-            if (!mw) {
-                return await dispatch(i + 1)
-            }
-            if (isDeclaredMiddleware(mw)) {
-                return await mw(ctx as HandlerContext<any>, () => dispatch(i + 1))
-            }
-            await mw(ctx as RequestContext<any>)
-            return await dispatch(i + 1)
-        }
-
-        return dispatch(0)
-    }
-
-    private _isAsyncGenerator(
-        value: unknown,
-    ): value is AsyncGenerator<HandlerYield, HandlerFinalResult> {
-        return !!value && typeof (value as AsyncGenerator)[Symbol.asyncIterator] === 'function'
-    }
-
-    private async _closeGenerator(
-        generator: AsyncGenerator<HandlerYield, HandlerFinalResult>,
-    ): Promise<void> {
-        try {
-            await generator.return?.(undefined as unknown as HandlerFinalResult)
-        } catch {
-            // Ignore generator errors during teardown.
-        }
-    }
-
-    private _toResponseBody(body: HandlerBody | null): RouterBodyInit | null {
-        if (body == null) return null
-        return body
-    }
-
-    private _setContentLength(headers: Headers, body: RouterBodyInit | null): void {
-        if (headers.has(CommonHeaders.CONTENT_LENGTH) || body == null) {
-            return
-        }
-
-        const size = this._getBodyByteLength(body)
-        if (size != null) {
-            headers.set(CommonHeaders.CONTENT_LENGTH, String(size))
-        }
-    }
-
-    private _getBodyByteLength(body: RouterBodyInit): number | undefined {
-        if (typeof body === 'string') {
-            return new TextEncoder().encode(body).byteLength
-        }
-
-        if (body instanceof Blob) {
-            return body.size
-        }
-
-        if (body instanceof URLSearchParams) {
-            return new TextEncoder().encode(body.toString()).byteLength
-        }
-
-        if (body instanceof ArrayBuffer) {
-            return body.byteLength
-        }
-
-        if (ArrayBuffer.isView(body)) {
-            return body.byteLength
-        }
-
-        return undefined
-    }
-
-    private _isBodyChunk(value: unknown): value is Uint8Array | Buffer | string {
-        return typeof value === 'string' || value instanceof Uint8Array
-    }
-
-    private _toBodyChunk(value: Uint8Array | Buffer | string): Uint8Array {
-        if (typeof value === 'string') {
-            return new TextEncoder().encode(value)
-        }
-        return value
-    }
-
-    private _mergeHeaders(target: Headers, source: Headers): void {
-        source.forEach((value, key) => target.set(key, value))
-    }
-
-    private async _frameChunk(
-        value: unknown,
-        framer: StreamFramer | undefined,
-    ): Promise<Uint8Array> {
-        if (!framer) {
-            if (!this._isBodyChunk(value)) {
-                throw new TypeError(
-                    'Generator yielded a structured chunk without stream(). Use stream(sseFramer()) or yield raw string/bytes chunks.',
-                )
-            }
-            return this._toBodyChunk(value)
-        }
-        if (framer.canFrame && !framer.canFrame(value)) {
-            throw new TypeError('Stream framer cannot encode the yielded chunk.')
-        }
-        return this._toBodyChunk(await framer.frame(value as never))
-    }
-
-    private async _responseFromGenerator(
-        generator: AsyncGenerator<HandlerYield, HandlerFinalResult>,
-        request: RoutekitRequest,
-        config: RuntimeConfig,
-    ): Promise<Response | null> {
-        const isHead = request.method.toUpperCase() === HttpMethod.HEAD
-        let status: number | HttpStatus | undefined
-        let statusSet = false
-        const headers = new Headers()
-        let framer: StreamFramer | undefined
-        let bodyStream: ReadableStream<Uint8Array> | undefined
-        let bodyController: ReadableStreamDefaultController<Uint8Array> | undefined
-        let responseResolved = false
-        let resolveResponse: ((value: Response | null) => void) | undefined
-        let rejectResponse: ((reason?: unknown) => void) | undefined
-        const responsePromise = new Promise<Response | null>((resolve, reject) => {
-            resolveResponse = resolve
-            rejectResponse = reject
-        })
-        let abortListener: (() => void) | undefined
-        const abortSignal = request.signal
-        const abortPromise = abortSignal
-            ? new Promise<'aborted'>((resolve) => {
-                  if (abortSignal.aborted) {
-                      resolve('aborted')
-                      return
-                  }
-                  abortListener = () => resolve('aborted')
-                  abortSignal.addEventListener('abort', abortListener, { once: true })
-              })
-            : null
-
-        if (abortSignal?.aborted) {
-            await this._closeGenerator(generator)
-            return null
-        }
-
-        const resolveResponseOnce = (response: Response | null) => {
-            if (responseResolved) return
-            responseResolved = true
-            resolveResponse?.(response)
-        }
-
-        const rejectResponseOnce = (error: unknown) => {
-            if (responseResolved) {
-                bodyController?.error?.(error)
-                return
-            }
-            responseResolved = true
-            rejectResponse?.(error)
-        }
-
-        const buildResponseInit = (): ResponseInit => ({
-            status: status ?? HttpStatus.OK,
-            headers,
-        })
-
-        const ensureStreamResponse = () => {
-            if (responseResolved) return
-            if (!bodyStream) {
-                bodyStream = new ReadableStream<Uint8Array>({
-                    start(controller) {
-                        bodyController = controller
-                    },
-                })
-            }
-            resolveResponseOnce(new Response(bodyStream, buildResponseInit()))
-        }
-
-        const setStatus = (value: number | HttpStatus) => {
-            if (bodyStream) {
-                throw new TypeError('Generator cannot set status after streaming has started.')
-            }
-            if (statusSet) {
-                throw new TypeError('Generator response status was already set.')
-            }
-            status = value
-            statusSet = true
-        }
-
-        const mergeHeaders = (value: Headers) => {
-            if (bodyStream) {
-                throw new TypeError('Generator cannot set headers after streaming has started.')
-            }
-            this._mergeHeaders(headers, value)
-        }
-
-        const finalizeReturnedValue = async (value: HandlerFinalResult) => {
-            if (isRoutekitResponse(value)) {
-                if (statusSet) {
-                    throw new TypeError(
-                        'Generator returned a Routekit response after status was already set.',
-                    )
-                }
-                const mergedHeaders = new Headers(headers)
-                this._mergeHeaders(mergedHeaders, value.headers)
-                return await this._responseFromRoutekitResponse(
-                    routekitResponse(value.body, {
-                        status: value.status,
-                        headers: mergedHeaders,
-                    }),
-                    request,
-                    config,
-                )
-            }
-            if (value instanceof Response) {
-                if (statusSet || [...headers.keys()].length > 0) {
-                    throw new TypeError(
-                        'Generator returned a native Response after response metadata was already set.',
-                    )
-                }
-                return value
-            }
-            const returnedBody = isRoutekitBody(value) ? value.value : value
-            return await this._responseFromRoutekitResponse(
-                routekitResponse(returnedBody, {
-                    status: status ?? HttpStatus.OK,
-                    headers,
-                }),
-                request,
-                config,
-            )
-        }
-
-        try {
-            const pump = async () => {
-                try {
-                    while (true) {
-                        const next = abortPromise
-                            ? await Promise.race([generator.next(), abortPromise])
-                            : await generator.next()
-                        if (next === 'aborted') {
-                            await this._closeGenerator(generator)
-                            bodyController?.error?.(new Error('Request aborted'))
-                            resolveResponseOnce(null)
-                            return
-                        }
-
-                        if (next.done) {
-                            if (bodyStream) {
-                                if (next.value !== undefined) {
-                                    throw new TypeError(
-                                        'Generator cannot return a final body after yielding chunks.',
-                                    )
-                                }
-                                if (framer?.close && !isHead) {
-                                    const finalChunk = await framer.close()
-                                    if (finalChunk !== undefined) {
-                                        bodyController?.enqueue(this._toBodyChunk(finalChunk))
-                                    }
-                                }
-                                bodyController?.close()
-                                if (!responseResolved) {
-                                    resolveResponseOnce(
-                                        new Response(bodyStream, buildResponseInit()),
-                                    )
-                                }
-                                return
-                            }
-
-                            resolveResponseOnce(await finalizeReturnedValue(next.value))
-                            return
-                        }
-
-                        const yielded = next.value
-                        if (yielded === undefined) {
-                            continue
-                        }
-
-                        if (isStatusDirective(yielded)) {
-                            setStatus(yielded.status)
-                            continue
-                        }
-
-                        if (isHeadersDirective(yielded)) {
-                            mergeHeaders(yielded.headers)
-                            if (isHead) {
-                                await this._closeGenerator(generator)
-                                resolveResponseOnce(new Response(null, buildResponseInit()))
-                                return
-                            }
-                            continue
-                        }
-
-                        if (isHeadDirective(yielded)) {
-                            setStatus(yielded.status)
-                            mergeHeaders(yielded.headers)
-                            if (isHead) {
-                                await this._closeGenerator(generator)
-                                resolveResponseOnce(new Response(null, buildResponseInit()))
-                                return
-                            }
-                            continue
-                        }
-
-                        if (isStreamDirective(yielded)) {
-                            if (bodyStream) {
-                                throw new TypeError(
-                                    'Generator cannot select a stream framer after streaming has started.',
-                                )
-                            }
-                            framer = yielded.framer
-                            mergeHeaders(yielded.headers)
-                            headers.set(CommonHeaders.CONTENT_TYPE, framer.contentType)
-                            if (isHead) {
-                                await this._closeGenerator(generator)
-                                resolveResponseOnce(new Response(null, buildResponseInit()))
-                                return
-                            }
-                            continue
-                        }
-
-                        if (isChunkDirective(yielded)) {
-                            if (isHead) {
-                                await this._closeGenerator(generator)
-                                resolveResponseOnce(new Response(null, buildResponseInit()))
-                                return
-                            }
-                            ensureStreamResponse()
-                            bodyController?.enqueue(await this._frameChunk(yielded.value, framer))
-                            continue
-                        }
-
-                        throw new TypeError(
-                            'Generator yielded an unsupported value. Use status(), headers(), head(), stream(), or chunk().',
-                        )
-                    }
-                } catch (err) {
-                    rejectResponseOnce(err)
-                }
-            }
-
-            void pump()
-            return await responsePromise
-        } finally {
-            if (abortSignal && abortListener) {
-                abortSignal.removeEventListener('abort', abortListener)
-            }
-        }
-    }
-
-    private async _handleRequest(request: Request): Promise<Response> {
-        const url = new URL(request.url)
-        const method = request.method.toUpperCase() as HttpMethod
-        const rootConfig = this._resolveRuntimeConfig(this._defaultRuntimeConfig())
-        const routekitRequest = createRoutekitRequest(request, url, rootConfig.requestBodyParsers)
-
-        if (method === HttpMethod.OPTIONS) {
-            const explicit = this._match(routekitRequest, method, url, this._defaultRuntimeConfig())
-            if (explicit.kind === 'match') {
-                return await this._handleMatch(explicit, routekitRequest, url)
-            }
-            if (explicit.kind === 'unsupported_media_type') {
-                return await this._handleUnsupportedMediaType(explicit.found, routekitRequest, url)
-            }
-            const allowedMethods = this._collectAllowedMethods(url)
-            if (allowedMethods.size === 0) {
-                return await this._handleNotFound(routekitRequest, url, explicit.config)
-            }
-            if (allowedMethods.has(HttpMethod.GET)) {
-                allowedMethods.add(HttpMethod.HEAD)
-            }
-            allowedMethods.add(HttpMethod.OPTIONS)
-            const optionsRequest = this._requestWithBodyParsers(routekitRequest, explicit.config)
-            const ctx = this._buildHandlerContext(optionsRequest, url, {}, explicit.config)
-            return await this._runRequestMiddleware(
-                explicit.config.requestMiddleware,
-                ctx,
-                async () =>
-                    new Response(null, {
-                        status: HttpStatus.NO_CONTENT,
-                        headers: {
-                            'access-control-allow-methods':
-                                this._formatAllowMethods(allowedMethods),
-                        },
-                    }),
-            )
-        }
-
-        const found = this._match(routekitRequest, method, url, this._defaultRuntimeConfig())
-        if (found.kind === 'not_found') {
-            return await this._handleNotFound(routekitRequest, url, found.config)
-        }
-        if (found.kind === 'method_not_allowed') {
-            return await this._handleMethodNotAllowed(routekitRequest, url, found.config)
-        }
-        if (found.kind === 'unsupported_media_type') {
-            return await this._handleUnsupportedMediaType(found.found, routekitRequest, url)
-        }
-        return await this._handleMatch(found, routekitRequest, url)
-    }
-
-    /**
-     * 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> => {
-        // Use = syntax to force `this` binding so that Bun can execute the router directly
-        return this._handleRequest(request)
-    }
-}