@mpen/routekit 0.1.0 → 0.1.2

package/src/router/router.test.ts

@@ -1,1571 +0,0 @@
-#!/usr/bin/env -S bun test
-import { describe, expect, it, mock } from 'bun:test'
-import { HttpMethod, HttpStatus } from '@mpen/http'
-import { LogLevel, type LogActivity, type LogContext, type Logger } from '@mpen/logger'
-import { Router } from './router'
-import type { ContextMiddleware, Handler } from './types'
-import { expectType, type TypeEqual } from '@mpen/ts-types'
-import { requestIdCtx } from './middleware/request-id-ctx'
-import { defineMiddleware, type DeclaredMiddleware } from './middleware/define'
-import type { RouterHeadersInit } from './fetch-types'
-import {
-    chunk,
-    head,
-    headers as responseHeaders,
-    response as logicalResponse,
-    status as responseStatus,
-    type ResponseBodySerializer,
-} from './response'
-import { noContent, text } from './response/formats/content'
-import type { RequestBodyParser } from './request'
-
-function makeRequest(
-    path: string,
-    method: HttpMethod = HttpMethod.GET,
-    headers?: RouterHeadersInit,
-): Request {
-    const init: RequestInit = { method }
-    if (headers) init.headers = headers
-    return new Request(`https://example.com${path}`, init)
-}
-
-type LogMethod = 'log' | 'info' | 'warn' | 'error' | 'table'
-
-type LogCall = {
-    method: LogMethod
-    data: any[]
-    context: LogContext
-}
-
-type TestLogger = Logger & {
-    calls: LogCall[]
-}
-
-function createTestLogger(): TestLogger {
-    const calls: LogCall[] = []
-    const create = (context: LogContext): TestLogger => {
-        const write =
-            (method: LogMethod) =>
-            (...data: any[]) => {
-                calls.push({ method, data, context })
-            }
-
-        return {
-            calls,
-            withContext(addedContext) {
-                return create({ ...context, ...addedContext })
-            },
-            startActivity(name: string, addedContext?: LogContext): LogActivity {
-                const logger = create({ ...context, ...addedContext })
-                return {
-                    logger,
-                    end(options) {
-                        const completed = logger.withContext({
-                            ...options?.context,
-                            duration_ms: 0,
-                        }) as TestLogger
-                        const data = [`${name} completed`, ...(options?.data ?? [])]
-                        switch (options?.level ?? LogLevel.INFO) {
-                            case LogLevel.DEBUG:
-                                completed.log(...data)
-                                break
-                            case LogLevel.INFO:
-                                completed.info(...data)
-                                break
-                            case LogLevel.WARN:
-                                completed.warn(...data)
-                                break
-                            case LogLevel.ERROR:
-                                completed.error(...data)
-                        }
-                    },
-                }
-            },
-            log: write('log'),
-            info: write('info'),
-            warn: write('warn'),
-            error: write('error'),
-            table: write('table'),
-        }
-    }
-
-    return create({})
-}
-
-describe('Router', () => {
-    it.skip('works with Bun.serve', async () => {
-        // failing when ran by Codex for some reason
-        const router = new Router().add({
-            method: HttpMethod.GET,
-            path: '/hello',
-            handler: () => new Response('world'),
-        })
-
-        const server = Bun.serve({
-            port: 0,
-            fetch: router.fetch.bind(router),
-        })
-
-        try {
-            const response = await fetch(`http://localhost:${server.port}/hello`)
-            expect(response.status).toBe(HttpStatus.OK)
-            expect(await response.text()).toBe('world')
-        } finally {
-            server.stop(true).catch(console.error)
-        }
-    })
-
-    it('returns 404 for missing routes', async () => {
-        const router = new Router()
-        const response = await router.fetch(makeRequest('/missing'))
-
-        expect(response.status).toBe(HttpStatus.NOT_FOUND)
-        expect(await response.text()).toBe('Not Found')
-    })
-
-    it('provides the parsed URL to handlers', async () => {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.GET,
-            path: '/search',
-            handler: ({ url }) => new Response(`${url.pathname}?q=${url.searchParams.get('q')}`),
-        })
-
-        const response = await router.fetch(makeRequest('/search?q=bun'))
-
-        expect(await response.text()).toBe('/search?q=bun')
-    })
-
-    it('provides path to handlers', async () => {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.GET,
-            path: '/users/:id',
-            handler: ({ path }) => new Response((path as { id: string }).id),
-        })
-
-        const response = await router.fetch(makeRequest('/users/42'))
-
-        expect(await response.text()).toBe('42')
-    })
-
-    it('handles HEAD requests for streaming handlers', async () => {
-        const beforeHeader = mock()
-        const afterHeader = mock()
-        const handler: Handler = async function* () {
-            yield responseStatus(HttpStatus.CREATED)
-            beforeHeader()
-            yield responseHeaders({
-                'content-type': 'text/plain; charset=utf-8',
-                'x-stream': 'true',
-            })
-            afterHeader()
-            return 'hello'
-        }
-        const router = new Router()
-        router.add({ method: HttpMethod.GET, path: '/', handler })
-
-        const getResponse = await router.fetch(makeRequest('/'))
-        expect(getResponse.status).toBe(HttpStatus.CREATED)
-        expect(getResponse.headers.get('x-stream')).toBe('true')
-        expect(await getResponse.text()).toBe('hello')
-
-        const headResponse = await router.fetch(makeRequest('/', HttpMethod.HEAD))
-        expect(headResponse.status).toBe(HttpStatus.CREATED)
-        expect(headResponse.headers.get('x-stream')).toBe('true')
-        expect(await headResponse.text()).toBe('')
-
-        expect(beforeHeader).toHaveBeenCalledTimes(2)
-        expect(afterHeader).toHaveBeenCalledTimes(1)
-    })
-
-    it('defaults to 200 when headers are yielded before status', async () => {
-        const { resolve: resume, promise: deferred } = Promise.withResolvers()
-        const handler: Handler = async function* () {
-            yield responseHeaders({ 'x-stream': 'true' })
-            yield responseStatus(499) // ignored
-            await deferred
-            return new TextEncoder().encode('hello')
-        }
-        const router = new Router()
-        router.add({ method: HttpMethod.GET, path: '/', handler })
-
-        const responsePromise = router.fetch(makeRequest('/', HttpMethod.HEAD))
-        const response = await Promise.race([
-            responsePromise,
-            new Promise<Response>((_, reject) =>
-                setTimeout(() => reject(new Error('response did not resolve')), 50),
-            ),
-        ])
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(response.headers.get('x-stream')).toBe('true')
-        expect(await response.text()).toBe('')
-        resume()
-    })
-
-    it('accepts typed metadata directives from streaming handlers', async () => {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.GET,
-            path: '/status',
-            handler: async function* () {
-                yield responseStatus(HttpStatus.ACCEPTED)
-                return { ok: true }
-            },
-        })
-        router.add({
-            method: HttpMethod.GET,
-            path: '/headers',
-            handler: async function* () {
-                yield responseHeaders({ 'x-meta': 'yes' })
-                return { ok: true }
-            },
-        })
-        router.add({
-            method: HttpMethod.GET,
-            path: '/both',
-            handler: async function* () {
-                yield head(HttpStatus.CREATED, { 'x-both': 'true' })
-                return { ok: true }
-            },
-        })
-
-        const statusResponse = await router.fetch(makeRequest('/status'))
-        expect(statusResponse.status).toBe(HttpStatus.ACCEPTED)
-        expect(await statusResponse.json()).toEqual({ ok: true })
-
-        const headersResponse = await router.fetch(makeRequest('/headers'))
-        expect(headersResponse.status).toBe(HttpStatus.OK)
-        expect(headersResponse.headers.get('x-meta')).toBe('yes')
-        expect(await headersResponse.json()).toEqual({ ok: true })
-
-        const bothResponse = await router.fetch(makeRequest('/both'))
-        expect(bothResponse.status).toBe(HttpStatus.CREATED)
-        expect(bothResponse.headers.get('x-both')).toBe('true')
-        expect(await bothResponse.json()).toEqual({ ok: true })
-    })
-
-    it('streams yielded body chunks and appends the returned body', async () => {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.GET,
-            path: '/stream',
-            handler: async function* () {
-                yield chunk('hello ')
-                yield chunk(new TextEncoder().encode('world'))
-                yield chunk(Buffer.from('!'))
-                yield chunk(' done')
-            },
-        })
-
-        const response = await router.fetch(makeRequest('/stream'))
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.text()).toBe('hello world! done')
-    })
-
-    it('streams response bodies written after returning a Response', async () => {
-        const { resolve: allowWrite, promise: writeAllowed } = Promise.withResolvers<void>()
-        const router = new Router()
-        router.add({
-            method: HttpMethod.GET,
-            path: '/late',
-            handler: () => {
-                const stream = new ReadableStream<Uint8Array>({
-                    async start(controller) {
-                        await writeAllowed
-                        controller.enqueue(new TextEncoder().encode('late body'))
-                        controller.close()
-                    },
-                })
-                return new Response(stream)
-            },
-        })
-
-        const responsePromise = router.fetch(makeRequest('/late'))
-        const response = await Promise.race([
-            responsePromise,
-            new Promise<Response>((_, reject) =>
-                setTimeout(() => reject(new Error('response did not resolve')), 50),
-            ),
-        ])
-
-        expect(response.status).toBe(HttpStatus.OK)
-        allowWrite()
-        expect(await response.text()).toBe('late body')
-    })
-
-    it('exposes request aborts so handlers can stop early', async () => {
-        const { resolve: handlerStarted, promise: handlerStartedPromise } =
-            Promise.withResolvers<void>()
-        const { resolve: allowCheck, promise: allowCheckPromise } = Promise.withResolvers<void>()
-        const controller = new AbortController()
-        let sawAbort = false
-        let finished = false
-        const router = new Router()
-        router.add({
-            method: HttpMethod.GET,
-            path: '/slow',
-            handler: async ({ request }) => {
-                handlerStarted()
-                await allowCheckPromise
-                if (request.signal.aborted) {
-                    sawAbort = true
-                    return new Response('aborted', { status: HttpStatus.CLIENT_CLOSED_REQUEST })
-                }
-                finished = true
-                return new Response('ok')
-            },
-        })
-
-        const responsePromise = router.fetch(
-            new Request('https://example.com/slow', { signal: controller.signal }),
-        )
-        await handlerStartedPromise
-        controller.abort()
-        allowCheck()
-
-        const response = await responsePromise
-        expect(response.status).toBe(HttpStatus.CLIENT_CLOSED_REQUEST)
-        expect(sawAbort).toBe(true)
-        expect(finished).toBe(false)
-    })
-
-    it('returns string or bytes as response bodies', async () => {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.GET,
-            path: '/text',
-            handler: () => 'ok',
-        })
-        router.add({
-            method: HttpMethod.GET,
-            path: '/bytes',
-            handler: () => new Uint8Array([111, 107]),
-        })
-
-        const textResponse = await router.fetch(makeRequest('/text'))
-        expect(textResponse.status).toBe(HttpStatus.OK)
-        expect(await textResponse.text()).toBe('ok')
-
-        const bytesResponse = await router.fetch(makeRequest('/bytes'))
-        expect(bytesResponse.status).toBe(HttpStatus.OK)
-        expect(await bytesResponse.text()).toBe('ok')
-    })
-
-    it('prefers explicit HEAD handlers and falls back to GET handlers', async () => {
-        const router = new Router()
-        let getCalls = 0
-        let headCalls = 0
-        router.add({
-            method: HttpMethod.GET,
-            path: '/resource',
-            handler: () => {
-                getCalls += 1
-                return new Response('get')
-            },
-        })
-        router.add({
-            method: HttpMethod.HEAD,
-            path: '/resource',
-            handler: () => {
-                headCalls += 1
-                return new Response('head')
-            },
-        })
-        router.add({
-            method: HttpMethod.GET,
-            path: '/fallback',
-            handler: () => {
-                getCalls += 1
-                return new Response('get')
-            },
-        })
-
-        const headResponse = await router.fetch(makeRequest('/resource', HttpMethod.HEAD))
-        expect(headResponse.status).toBe(HttpStatus.OK)
-        expect(headCalls).toBe(1)
-        expect(getCalls).toBe(0)
-
-        const fallbackResponse = await router.fetch(makeRequest('/fallback', HttpMethod.HEAD))
-        expect(fallbackResponse.status).toBe(HttpStatus.OK)
-        expect(getCalls).toBe(1)
-    })
-
-    it('returns 405 when the route exists but the method is not allowed', async () => {
-        const router = new Router()
-        let postCalls = 0
-        router.add({
-            method: HttpMethod.POST,
-            path: '/mutate',
-            handler: () => {
-                postCalls += 1
-                return new Response('ok')
-            },
-        })
-
-        const headResponse = await router.fetch(makeRequest('/mutate', HttpMethod.HEAD))
-        expect(headResponse.status).toBe(HttpStatus.METHOD_NOT_ALLOWED)
-        expect(postCalls).toBe(0)
-
-        const getResponse = await router.fetch(makeRequest('/mutate', HttpMethod.GET))
-        expect(getResponse.status).toBe(HttpStatus.METHOD_NOT_ALLOWED)
-        expect(postCalls).toBe(0)
-
-        const postResponse = await router.fetch(makeRequest('/mutate', HttpMethod.POST))
-        expect(postResponse.status).toBe(HttpStatus.OK)
-        expect(postCalls).toBe(1)
-    })
-
-    it('supports method arrays including HEAD', async () => {
-        const router = new Router()
-        let calls = 0
-        router.add({
-            method: [HttpMethod.POST, HttpMethod.HEAD],
-            path: '/combo',
-            handler: () => {
-                calls += 1
-                return new Response('ok')
-            },
-        })
-
-        const headResponse = await router.fetch(makeRequest('/combo', HttpMethod.HEAD))
-        expect(headResponse.status).toBe(HttpStatus.OK)
-        expect(calls).toBe(1)
-
-        const postResponse = await router.fetch(makeRequest('/combo', HttpMethod.POST))
-        expect(postResponse.status).toBe(HttpStatus.OK)
-        expect(calls).toBe(2)
-
-        const getResponse = await router.fetch(makeRequest('/combo', HttpMethod.GET))
-        expect(getResponse.status).toBe(HttpStatus.METHOD_NOT_ALLOWED)
-        expect(calls).toBe(2)
-    })
-
-    it('automatically handles OPTIONS and reports allowed methods', async () => {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.GET,
-            path: '/cors',
-            handler: function () {
-                return new Response('get')
-            },
-        })
-        router.add({
-            method: HttpMethod.POST,
-            path: '/cors',
-            handler: function () {
-                return new Response('post')
-            },
-        })
-
-        const response = await router.fetch(makeRequest('/cors', HttpMethod.OPTIONS))
-        expect(response.status).toBe(HttpStatus.NO_CONTENT)
-        expect(response.headers.get('access-control-allow-methods')).toBe(
-            'GET, HEAD, POST, OPTIONS',
-        )
-        expect(response.headers.has('access-control-allow-origin')).toBe(false)
-    })
-
-    it('returns 415 when Content-Type does not satisfy the route accept', async () => {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.POST,
-            path: '/json',
-            accept: ['application/json; charset=UTF-8', { type: 'text/plain' }],
-            handler: () => new Response('ok'),
-        })
-
-        const missingHeader = await router.fetch(makeRequest('/json', HttpMethod.POST))
-        expect(missingHeader.status).toBe(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
-
-        const wrongType = await router.fetch(
-            makeRequest('/json', HttpMethod.POST, { 'content-type': 'text/html' }),
-        )
-        expect(wrongType.status).toBe(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
-
-        const wrongCharset = await router.fetch(
-            makeRequest('/json', HttpMethod.POST, {
-                'content-type': 'application/json; charset=latin1',
-            }),
-        )
-        expect(wrongCharset.status).toBe(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
-
-        const noCharset = await router.fetch(
-            makeRequest('/json', HttpMethod.POST, { 'content-type': 'application/json' }),
-        )
-        expect(noCharset.status).toBe(HttpStatus.OK)
-        expect(await noCharset.text()).toBe('ok')
-
-        const normalizedCharset = await router.fetch(
-            makeRequest('/json', HttpMethod.POST, {
-                'content-type': 'application/json; charset=utf8',
-            }),
-        )
-        expect(normalizedCharset.status).toBe(HttpStatus.OK)
-        expect(await normalizedCharset.text()).toBe('ok')
-    })
-
-    it('routes to the matching accept route before returning 415', async () => {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.POST,
-            path: '/payload',
-            accept: ['application/json'],
-            handler: () => new Response('json'),
-        })
-        router.add({
-            method: HttpMethod.POST,
-            path: '/payload',
-            accept: ['text/plain'],
-            handler: () => new Response('text'),
-        })
-
-        const jsonResponse = await router.fetch(
-            makeRequest('/payload', HttpMethod.POST, { 'content-type': 'application/json' }),
-        )
-        expect(jsonResponse.status).toBe(HttpStatus.OK)
-        expect(await jsonResponse.text()).toBe('json')
-
-        const textResponse = await router.fetch(
-            makeRequest('/payload', HttpMethod.POST, { 'content-type': 'text/plain' }),
-        )
-        expect(textResponse.status).toBe(HttpStatus.OK)
-        expect(await textResponse.text()).toBe('text')
-
-        const unsupportedResponse = await router.fetch(
-            makeRequest('/payload', HttpMethod.POST, { 'content-type': 'text/html' }),
-        )
-        expect(unsupportedResponse.status).toBe(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
-    })
-
-    it('allows Content-Type when route does not specify accept', async function () {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.POST,
-            path: '/plain',
-            handler: () => new Response('ok'),
-        })
-
-        const response = await router.fetch(
-            makeRequest('/plain', HttpMethod.POST, { 'content-type': 'text/plain' }),
-        )
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.text()).toBe('ok')
-    })
-
-    it('parses request bodies with configured request body parsers', async function () {
-        const router = new Router()
-            .setRequestBodyParsers([
-                {
-                    mediaTypes: ['application/x-lines'],
-                    parse: async (ctx) => (await ctx.text()).split('\n'),
-                },
-            ])
-            .add({
-                method: HttpMethod.POST,
-                path: '/lines',
-                handler: async ({ request }) => await request.body.parse(),
-            })
-
-        const response = await router.fetch(
-            new Request('https://example.com/lines', {
-                method: HttpMethod.POST,
-                headers: { 'content-type': 'application/x-lines' },
-                body: 'a\nb',
-            }),
-        )
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.json()).toEqual(['a', 'b'])
-    })
-
-    it('parses URL-encoded request bodies by default', async function () {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.POST,
-            path: '/form',
-            handler: async ({ request }) => await request.body.parse(),
-        })
-
-        const response = await router.fetch(
-            new Request('https://example.com/form', {
-                method: HttpMethod.POST,
-                headers: { 'content-type': 'application/x-www-form-urlencoded' },
-                body: 'tag=a&tag=b&name=Ada',
-            }),
-        )
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.json()).toEqual({ tag: ['a', 'b'], name: 'Ada' })
-    })
-
-    it('returns 415 when no request body parser matches', async function () {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.POST,
-            path: '/upload',
-            handler: async ({ request }) => await request.body.parse(),
-        })
-
-        const response = await router.fetch(
-            new Request('https://example.com/upload', {
-                method: HttpMethod.POST,
-                headers: { 'content-type': 'image/png' },
-                body: 'not really png',
-            }),
-        )
-
-        expect(response.status).toBe(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
-    })
-})
-
-describe('Router.get', () => {
-    it('registers GET routes', async () => {
-        const router = new Router()
-        router.get('/get', () => new Response('ok'))
-
-        const [route] = router.getRoutes()
-        expect(route?.method).toBe(HttpMethod.GET)
-
-        const response = await router.fetch(makeRequest('/get', HttpMethod.GET))
-        expect(response.status).toBe(HttpStatus.OK)
-    })
-})
-
-describe('Router.head', () => {
-    it('registers HEAD routes', async () => {
-        const router = new Router()
-        router.head('/head', () => new Response('ok'))
-
-        const [route] = router.getRoutes()
-        expect(route?.method).toBe(HttpMethod.HEAD)
-
-        const response = await router.fetch(makeRequest('/head', HttpMethod.HEAD))
-        expect(response.status).toBe(HttpStatus.OK)
-    })
-})
-
-describe('Router.post', () => {
-    it('registers POST routes', async () => {
-        const router = new Router()
-        router.post('/post', () => new Response('ok'))
-
-        const [route] = router.getRoutes()
-        expect(route?.method).toBe(HttpMethod.POST)
-
-        const response = await router.fetch(makeRequest('/post', HttpMethod.POST))
-        expect(response.status).toBe(HttpStatus.OK)
-    })
-})
-
-describe('Router.put', () => {
-    it('registers PUT routes', async () => {
-        const router = new Router()
-        router.put('/put', () => new Response('ok'))
-
-        const [route] = router.getRoutes()
-        expect(route?.method).toBe(HttpMethod.PUT)
-
-        const response = await router.fetch(makeRequest('/put', HttpMethod.PUT))
-        expect(response.status).toBe(HttpStatus.OK)
-    })
-})
-
-describe('Router.delete', () => {
-    it('registers DELETE routes', async () => {
-        const router = new Router()
-        router.delete('/delete', () => new Response('ok'))
-
-        const [route] = router.getRoutes()
-        expect(route?.method).toBe(HttpMethod.DELETE)
-
-        const response = await router.fetch(makeRequest('/delete', HttpMethod.DELETE))
-        expect(response.status).toBe(HttpStatus.OK)
-    })
-})
-
-describe('Router.patch', () => {
-    it('registers PATCH routes', async () => {
-        const router = new Router()
-        router.patch('/patch', () => new Response('ok'))
-
-        const [route] = router.getRoutes()
-        expect(route?.method).toBe(HttpMethod.PATCH)
-
-        const response = await router.fetch(makeRequest('/patch', HttpMethod.PATCH))
-        expect(response.status).toBe(HttpStatus.OK)
-    })
-})
-
-describe('Router.install', () => {
-    it('invokes extensions and returns the same router for chaining', async () => {
-        let installedRouter: Router | undefined
-        const router = new Router()
-
-        const returned = router.install((target) => {
-            installedRouter = target
-            target.get('/installed', () => text('ok'))
-        })
-
-        const response = await router.fetch(makeRequest('/installed'))
-
-        expect(returned).toBe(router)
-        expect(installedRouter).toBe(router)
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.text()).toBe('ok')
-    })
-})
-
-describe('Router.onNotFound', () => {
-    it('uses the configured onNotFound handler', async () => {
-        const router = new Router().onNotFound(
-            () => new Response('missing', { status: HttpStatus.NOT_FOUND }),
-        )
-
-        const response = await router.fetch(makeRequest('/missing'))
-
-        expect(response.status).toBe(HttpStatus.NOT_FOUND)
-        expect(await response.text()).toBe('missing')
-    })
-
-    it('falls back to 500 when the onNotFound handler throws', async () => {
-        const router = new Router().setLogger(createTestLogger()).onNotFound(() => {
-            throw new Error('boom')
-        })
-
-        const response = await router.fetch(makeRequest('/missing'))
-
-        expect(response.status).toBe(HttpStatus.INTERNAL_SERVER_ERROR)
-        expect(await response.text()).toBe('Internal Server Error')
-    })
-})
-
-describe('Router.onMethodNotAllowed', () => {
-    it('uses the configured onMethodNotAllowed handler', async () => {
-        const router = new Router()
-            .onMethodNotAllowed(
-                () => new Response('nope', { status: HttpStatus.METHOD_NOT_ALLOWED }),
-            )
-            .add({
-                method: HttpMethod.POST,
-                path: '/mutate',
-                handler: () => new Response('ok'),
-            })
-
-        const response = await router.fetch(makeRequest('/mutate', HttpMethod.GET))
-
-        expect(response.status).toBe(HttpStatus.METHOD_NOT_ALLOWED)
-        expect(await response.text()).toBe('nope')
-    })
-})
-
-describe('Router.onUnsupportedMediaType', () => {
-    it('uses the configured onUnsupportedMediaType handler', async () => {
-        const router = new Router()
-            .onUnsupportedMediaType(
-                () => new Response('unsupported', { status: HttpStatus.UNSUPPORTED_MEDIA_TYPE }),
-            )
-            .add({
-                method: HttpMethod.POST,
-                path: '/json',
-                accept: ['application/json'],
-                handler: () => new Response('ok'),
-            })
-
-        const response = await router.fetch(makeRequest('/json', HttpMethod.POST))
-
-        expect(response.status).toBe(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
-        expect(await response.text()).toBe('unsupported')
-    })
-})
-
-describe('Router.onInternalError', () => {
-    it('logs matched route errors with the default ConsoleLogger', async () => {
-        const originalError = console.error
-        const calls: any[][] = []
-        const error = new Error('boom')
-        console.error = ((...data: any[]) => {
-            calls.push(data)
-        }) as typeof console.error
-        try {
-            const router = new Router().add({
-                method: HttpMethod.GET,
-                path: '/boom',
-                handler: () => {
-                    throw error
-                },
-            })
-
-            const response = await router.fetch(makeRequest('/boom'))
-
-            expect(response.status).toBe(HttpStatus.INTERNAL_SERVER_ERROR)
-            expect(await response.text()).toBe('Internal Server Error')
-            expect(calls).toHaveLength(1)
-            expect(calls[0]?.[0]).toBe('Routekit internal server error')
-            expect(calls[0]?.[1]).toBe(error)
-            expect(calls[0]?.[2]).toEqual({
-                'http.request.method': HttpMethod.GET,
-                'http.route': '/boom',
-                'url.path': '/boom',
-            })
-        } finally {
-            console.error = originalError
-        }
-    })
-
-    it('uses the configured onInternalError handler', async () => {
-        const logger = createTestLogger()
-        const error = new Error('boom')
-        const router = new Router()
-            .setLogger(logger)
-            .onInternalError(
-                () => new Response('broken', { status: HttpStatus.SERVICE_UNAVAILABLE }),
-            )
-            .add({
-                method: HttpMethod.GET,
-                path: '/boom',
-                handler: () => {
-                    throw error
-                },
-            })
-
-        const response = await router.fetch(makeRequest('/boom'))
-
-        expect(response.status).toBe(HttpStatus.SERVICE_UNAVAILABLE)
-        expect(await response.text()).toBe('broken')
-        expect(logger.calls).toHaveLength(1)
-        expect(logger.calls[0]?.method).toBe('error')
-        expect(logger.calls[0]?.data[0]).toBe('Routekit internal server error')
-        expect(logger.calls[0]?.data[1]).toBe(error)
-        expect(logger.calls[0]?.context).toEqual({
-            'http.request.method': HttpMethod.GET,
-            'http.route': '/boom',
-            'url.path': '/boom',
-        })
-    })
-
-    it('falls back to 500 when the onInternalError handler throws', async () => {
-        const logger = createTestLogger()
-        const routeError = new Error('boom')
-        const handlerError = new Error('handler boom')
-        const router = new Router()
-            .setLogger(logger)
-            .onInternalError(() => {
-                throw handlerError
-            })
-            .add({
-                method: HttpMethod.GET,
-                path: '/boom',
-                handler: () => {
-                    throw routeError
-                },
-            })
-
-        const response = await router.fetch(makeRequest('/boom'))
-
-        expect(response.status).toBe(HttpStatus.INTERNAL_SERVER_ERROR)
-        expect(await response.text()).toBe('Internal Server Error')
-        expect(logger.calls).toHaveLength(2)
-        expect(logger.calls[0]?.data[1]).toBe(routeError)
-        expect(logger.calls[1]?.data[1]).toBe(handlerError)
-    })
-})
-
-describe('Router.fetch', () => {
-    it('binds handler this to the matching router instance', async () => {
-        const router = new Router()
-        let boundRouter: Router | null = null
-        router.add({
-            method: HttpMethod.GET,
-            path: '/ping',
-            handler: function () {
-                boundRouter = this
-                return new Response('ok')
-            },
-        })
-
-        const response = await router.fetch(new Request('https://example.com/ping'))
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(boundRouter === router).toBe(true)
-    })
-
-    it('handles unbound fetch usage', async () => {
-        const router = new Router()
-        router.add({
-            method: HttpMethod.GET,
-            path: '/ping',
-            handler: () => new Response('ok'),
-        })
-
-        const fetch = router.fetch
-        const response = await fetch(new Request('https://example.com/ping'))
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.text()).toBe('ok')
-    })
-
-    it('binds handlers to mounted routers', async () => {
-        const parent = new Router()
-        const child = new Router()
-        let boundRouter: Router | null = null
-        child.add({
-            method: HttpMethod.GET,
-            path: '/nested',
-            handler: function () {
-                boundRouter = this
-                return new Response('ok')
-            },
-        })
-        parent.mount('/api', child)
-
-        const response = await parent.fetch(new Request('https://example.com/api/nested'))
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(boundRouter === child).toBe(true)
-    })
-
-    it('mounted routers use middleware from parent', async () => {
-        const rootRouter = new Router()
-        const childRouter = new Router()
-
-        rootRouter.mount('/api', childRouter) // mounted before adding route
-
-        childRouter.add({
-            method: HttpMethod.GET,
-            path: '/nested',
-            handler: () => noContent(),
-        })
-
-        const mockMiddleware = mock()
-        rootRouter.use(mockMiddleware) // registered after routes
-
-        const response = await rootRouter.fetch(new Request('https://example.com/api/nested'))
-
-        expect(response.status).toBe(HttpStatus.NO_CONTENT)
-        expect(mockMiddleware).toHaveBeenCalled()
-    })
-
-    it('mount middleware not applied to root routes', async () => {
-        const rootRouter = new Router()
-
-        const mockMiddleware = mock()
-        rootRouter.mount({ middleware: [mockMiddleware] }, (r) =>
-            r.get('/grouped', () => text('grouped')),
-        )
-        rootRouter.get('/root', () => text('root'))
-
-        const rootResponse = await rootRouter.fetch(new Request('https://example.com/root'))
-
-        expect(await rootResponse.text()).toBe('root')
-        expect(mockMiddleware).not.toHaveBeenCalled()
-
-        const groupedResponse = await rootRouter.fetch(new Request('https://example.com/grouped'))
-
-        expect(await groupedResponse.text()).toBe('grouped')
-        expect(mockMiddleware).toHaveBeenCalled()
-    })
-
-    it('mounted routers inherit the parent logger for internal errors', async () => {
-        const parentLogger = createTestLogger()
-        const error = new Error('boom')
-        const parent = new Router().setLogger(parentLogger)
-        const child = new Router()
-        child.add({
-            method: HttpMethod.GET,
-            path: '/nested',
-            handler: () => {
-                throw error
-            },
-        })
-        parent.mount('/api', child)
-
-        const response = await parent.fetch(new Request('https://example.com/api/nested'))
-
-        expect(response.status).toBe(HttpStatus.INTERNAL_SERVER_ERROR)
-        expect(parentLogger.calls).toHaveLength(1)
-        expect(parentLogger.calls[0]?.data[1]).toBe(error)
-    })
-
-    it('mounted routers can override the inherited logger for internal errors', async () => {
-        const parentLogger = createTestLogger()
-        const childLogger = createTestLogger()
-        const error = new Error('boom')
-        const parent = new Router().setLogger(parentLogger)
-        const child = new Router().setLogger(childLogger)
-        child.add({
-            method: HttpMethod.GET,
-            path: '/nested',
-            handler: () => {
-                throw error
-            },
-        })
-        parent.mount('/api', child)
-
-        const response = await parent.fetch(new Request('https://example.com/api/nested'))
-
-        expect(response.status).toBe(HttpStatus.INTERNAL_SERVER_ERROR)
-        expect(parentLogger.calls).toHaveLength(0)
-        expect(childLogger.calls).toHaveLength(1)
-        expect(childLogger.calls[0]?.data[1]).toBe(error)
-        expect(childLogger.calls[0]?.context).toEqual({
-            'http.request.method': HttpMethod.GET,
-            'http.route': '/api/nested',
-            'url.path': '/api/nested',
-        })
-    })
-})
-
-describe('Router.addRequestBodyParser', () => {
-    it('adds request body parsers inherited by mounted routers', async () => {
-        const linesParser: RequestBodyParser<string[]> = {
-            mediaTypes: ['application/x-lines'],
-            parse: async (ctx) => (await ctx.text()).split('\n'),
-        }
-        const child = new Router().post('/lines', async ({ request }) => await request.body.parse())
-        const router = new Router().addRequestBodyParser(linesParser).mount('/api', child)
-
-        const response = await router.fetch(
-            new Request('https://example.com/api/lines', {
-                method: HttpMethod.POST,
-                headers: { 'content-type': 'application/x-lines' },
-                body: 'a\nb',
-            }),
-        )
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.json()).toEqual(['a', 'b'])
-    })
-
-    it('uses parser media type q before registration order', async () => {
-        const customParser: RequestBodyParser<string> = {
-            mediaTypes: ['application/vnd.routekit+json'],
-            parse: async (ctx) => `custom:${await ctx.text()}`,
-        }
-        const router = new Router()
-            .addRequestBodyParser(customParser)
-            .post('/body', async ({ request }) => await request.body.parse())
-
-        const response = await router.fetch(
-            new Request('https://example.com/body', {
-                method: HttpMethod.POST,
-                headers: { 'content-type': 'application/vnd.routekit+json' },
-                body: 'not json',
-            }),
-        )
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.text()).toBe('custom:not json')
-    })
-})
-
-describe('Router.setRequestBodyParsers', () => {
-    it('replaces inherited request body parsers for a mounted subtree', async () => {
-        const rootParser: RequestBodyParser<string> = {
-            mediaTypes: ['application/x-root'],
-            parse: async (ctx) => `root:${await ctx.text()}`,
-        }
-        const childParser: RequestBodyParser<string> = {
-            mediaTypes: ['application/x-child'],
-            parse: async (ctx) => `child:${await ctx.text()}`,
-        }
-        const child = new Router()
-            .setRequestBodyParsers([childParser])
-            .post('/body', async ({ request }) => await request.body.parse())
-        const router = new Router().addRequestBodyParser(rootParser).mount('/api', child)
-
-        const rootTypeResponse = await router.fetch(
-            new Request('https://example.com/api/body', {
-                method: HttpMethod.POST,
-                headers: { 'content-type': 'application/x-root' },
-                body: 'value',
-            }),
-        )
-        const childTypeResponse = await router.fetch(
-            new Request('https://example.com/api/body', {
-                method: HttpMethod.POST,
-                headers: { 'content-type': 'application/x-child' },
-                body: 'value',
-            }),
-        )
-
-        expect(rootTypeResponse.status).toBe(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
-        expect(childTypeResponse.status).toBe(HttpStatus.OK)
-        expect(await childTypeResponse.text()).toBe('child:value')
-    })
-})
-
-describe('Router.addResponseBodySerializer', () => {
-    it('adds response body serializers inherited by mounted routers', async () => {
-        const serializer: ResponseBodySerializer<{ message: string }> = {
-            mediaTypes: ['application/x-message'],
-            canSerialize: (value): value is { message: string } =>
-                typeof value === 'object' && value !== null && 'message' in value,
-            serialize: (value) => `message:${value.message}`,
-        }
-        const child = new Router().get('/message', () => ({ message: 'hello' }))
-        const router = new Router().addResponseBodySerializer(serializer).mount('/api', child)
-
-        const response = await router.fetch(
-            new Request('https://example.com/api/message', {
-                headers: { accept: 'application/x-message' },
-            }),
-        )
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(response.headers.get('content-type')).toBe('application/x-message')
-        expect(await response.text()).toBe('message:hello')
-    })
-
-    it('uses serializer media type q before Accept order when client q ties', async () => {
-        const serializer: ResponseBodySerializer<{ message: string }> = {
-            mediaTypes: ['application/x-low;q=0.5', 'application/x-high'],
-            canSerialize: (value): value is { message: string } =>
-                typeof value === 'object' && value !== null && 'message' in value,
-            serialize: (value) => `message:${value.message}`,
-        }
-        const router = new Router().addResponseBodySerializer(serializer).get('/message', () => ({
-            message: 'hello',
-        }))
-
-        const response = await router.fetch(
-            new Request('https://example.com/message', {
-                headers: { accept: 'application/x-low, application/x-high' },
-            }),
-        )
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(response.headers.get('content-type')).toBe('application/x-high')
-        expect(await response.text()).toBe('message:hello')
-    })
-})
-
-describe('Router.setResponseBodySerializers', () => {
-    it('replaces inherited response body serializers for a mounted subtree', async () => {
-        const serializer: ResponseBodySerializer<{ message: string }> = {
-            mediaTypes: ['application/x-message'],
-            canSerialize: (value): value is { message: string } =>
-                typeof value === 'object' && value !== null && 'message' in value,
-            serialize: (value) => `message:${value.message}`,
-        }
-        const child = new Router()
-            .setResponseBodySerializers([serializer])
-            .get('/message', () => ({ message: 'hello' }))
-        const router = new Router().mount('/api', child)
-
-        const jsonResponse = await router.fetch(
-            new Request('https://example.com/api/message', {
-                headers: { accept: 'application/json' },
-            }),
-        )
-        const customResponse = await router.fetch(
-            new Request('https://example.com/api/message', {
-                headers: { accept: 'application/x-message' },
-            }),
-        )
-
-        expect(jsonResponse.status).toBe(HttpStatus.NOT_ACCEPTABLE)
-        expect(customResponse.status).toBe(HttpStatus.OK)
-        expect(await customResponse.text()).toBe('message:hello')
-    })
-})
-
-describe('Router.use', () => {
-    it('infers middleware-added context for handlers', () => {
-        const router = new Router().useRequest(requestIdCtx())
-
-        router.add({
-            method: HttpMethod.GET,
-            path: '/',
-            handler: (ctx) => {
-                expectType<string>(ctx.requestId)
-                expectType<Logger>(ctx.logger)
-                return new Response('ok')
-            },
-        })
-    })
-
-    it('merges context across middleware lists', () => {
-        const addUser: ContextMiddleware<{ userId: string }> = (ctx) => {
-            ctx.userId = 'user-1'
-        }
-        const addFlag: ContextMiddleware<{ isAdmin: boolean }> = (ctx) => {
-            ctx.isAdmin = true
-        }
-
-        const router = new Router().use([addUser, addFlag])
-
-        router.add({
-            method: HttpMethod.GET,
-            path: '/',
-            handler: (ctx) => {
-                expectType<string>(ctx.userId)
-                expectType<boolean>(ctx.isAdmin)
-                return new Response('ok')
-            },
-        })
-    })
-
-    it('passes middleware context through to handlers', async () => {
-        const addRequestIdLocal: ContextMiddleware<{ requestId: number }> = (ctx) => {
-            ctx.requestId = 42
-        }
-        const router = new Router().use(addRequestIdLocal)
-        router.add({
-            method: HttpMethod.GET,
-            path: '/',
-            handler: (ctx) => new Response(String(ctx.requestId)),
-        })
-
-        const response = await router.fetch(makeRequest('/'))
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.text()).toBe('42')
-    })
-})
-
-describe('Route middleware', () => {
-    it('runs for a single route and exposes added context to the handler', async () => {
-        const addRouteContext: ContextMiddleware<{ routeValue: string }> = (ctx) => {
-            ctx.routeValue = 'route'
-        }
-        const router = new Router()
-
-        router.get('/items', {
-            middleware: [addRouteContext],
-            handler: (ctx) => {
-                expectType<TypeEqual<typeof ctx.routeValue, string>>(true)
-                return new Response(ctx.routeValue)
-            },
-        })
-
-        const response = await router.fetch(makeRequest('/items'))
-        const [route] = router.getRoutes()
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.text()).toBe('route')
-        expect(route && 'middleware' in route).toBe(false)
-    })
-
-    it('allows route middleware to short-circuit the handler', async () => {
-        const handler = mock(() => new Response('handler'))
-        const stop = defineMiddleware({
-            responses: {
-                [HttpStatus.IM_A_TEAPOT]: {
-                    schema: { type: 'string' },
-                    parse: (value: unknown) => String(value),
-                },
-            },
-            run: (_ctx, { respond }) =>
-                respond(text('blocked', { status: HttpStatus.IM_A_TEAPOT })),
-        })
-        const router = new Router()
-
-        router.get('/blocked', {
-            middleware: stop,
-            handler,
-        })
-
-        const response = await router.fetch(makeRequest('/blocked'))
-
-        expect(response.status).toBe(HttpStatus.IM_A_TEAPOT)
-        expect(await response.text()).toBe('blocked')
-        expect(handler).not.toHaveBeenCalled()
-    })
-
-    it('does not allow raw context middleware to return a terminal response', () => {
-        // @ts-expect-error Raw context middleware can only initialize context.
-        const invalid: ContextMiddleware = () => new Response('blocked')
-
-        expect(invalid).toBeDefined()
-    })
-
-    it('runs after parent and mount middleware', async () => {
-        const events: string[] = []
-        const log = (label: string) =>
-            defineMiddleware({
-                async run(_ctx, { next, forward }) {
-                    events.push(`${label}:before`)
-                    const result = await next()
-                    events.push(`${label}:after`)
-                    return forward(result)
-                },
-            })
-
-        const router = new Router().use(log('root'))
-        router.mount({ middleware: log('mount') }, (mounted) => {
-            mounted.get('/items', {
-                middleware: log('route'),
-                handler: () => {
-                    events.push('handler')
-                    return new Response('ok')
-                },
-            })
-        })
-
-        const response = await router.fetch(makeRequest('/items'))
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(events).toEqual([
-            'root:before',
-            'mount:before',
-            'route:before',
-            'handler',
-            'route:after',
-            'mount:after',
-            'root:after',
-        ])
-    })
-
-    it('validates and exposes a terminal middleware response declaration', async () => {
-        const requireAuth = defineMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: {
-                    schema: { const: 'sign in' },
-                    parse(value: unknown): 'sign in' {
-                        if (value !== 'sign in') throw new TypeError('Expected auth response.')
-                        return value
-                    },
-                },
-            },
-            run: (_ctx, { respond }) =>
-                respond(logicalResponse('sign in', { status: HttpStatus.UNAUTHORIZED })),
-        })
-        const router = new Router()
-        router.get('/private', { middleware: requireAuth, handler: () => new Response('hidden') })
-
-        const response = await router.fetch(makeRequest('/private'))
-
-        expect(response.status).toBe(HttpStatus.UNAUTHORIZED)
-        expect(await response.json()).toBe('sign in')
-        expect(router.getRoutes()[0]?.schema?.response?.body).toEqual({
-            [HttpStatus.UNAUTHORIZED]: { const: 'sign in' },
-        })
-    })
-
-    it('enforces declared terminal response body and status types', () => {
-        const middleware = defineMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: {
-                    schema: { type: 'string' },
-                    parse(value: unknown): string {
-                        return String(value)
-                    },
-                },
-            },
-            run: (_ctx, { respond }) => {
-                respond(logicalResponse('sign in', { status: HttpStatus.UNAUTHORIZED }))
-                // @ts-expect-error The body must match the response declared for status 401.
-                respond(logicalResponse({ error: true }, { status: HttpStatus.UNAUTHORIZED }))
-                // @ts-expect-error Status 403 has no terminal declaration.
-                respond(logicalResponse('denied', { status: HttpStatus.FORBIDDEN }))
-                // @ts-expect-error Native responses do not provide a statically declared body/status.
-                respond(new Response('sign in', { status: HttpStatus.UNAUTHORIZED }))
-            },
-        })
-        const created = logicalResponse({ id: 'one' }, { status: HttpStatus.CREATED })
-
-        expectType<TypeEqual<typeof created.status, HttpStatus.CREATED>>(true)
-        expect(middleware).toBeDefined()
-    })
-
-    it('infers declarations after middleware context types are fixed', () => {
-        const middleware: DeclaredMiddleware<{ auth: string }, { services: string }> =
-            defineMiddleware({
-                responses: {
-                    [HttpStatus.UNAUTHORIZED]: {
-                        schema: { type: 'string' },
-                        parse(value: unknown): string {
-                            return String(value)
-                        },
-                    },
-                },
-                run: (ctx, { respond }) => {
-                    expectType<TypeEqual<typeof ctx.auth, string>>(true)
-                    expectType<TypeEqual<typeof ctx.services, string>>(true)
-                    respond(logicalResponse('sign in', { status: HttpStatus.UNAUTHORIZED }))
-                    // @ts-expect-error Contextual typing still permits inferred response bodies.
-                    respond(logicalResponse({ error: true }, { status: HttpStatus.UNAUTHORIZED }))
-                },
-            })
-
-        expect(middleware).toBeDefined()
-    })
-
-    it('inherits declared metadata through retroactive use and mounted routers', () => {
-        const rootResponse = defineMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: {
-                    schema: { const: 'root' },
-                    parse: (value: unknown) => value,
-                },
-            },
-            run: () => undefined,
-        })
-        const mountResponse = defineMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: {
-                    schema: { const: 'mount' },
-                    parse: (value: unknown) => value,
-                },
-            },
-            run: () => undefined,
-        })
-        const child = new Router().get('/item', () => new Response('ok'))
-        const router = new Router().mount('/api', child)
-        router.use(rootResponse)
-        router.mount({ prefix: '/scoped', middleware: mountResponse }, (scoped) => {
-            scoped.get('/item', () => new Response('ok'))
-        })
-
-        const [mountedRoute, scopedRoute] = router.getRoutes()
-        expect(mountedRoute?.schema?.response?.body).toEqual({
-            [HttpStatus.UNAUTHORIZED]: { const: 'root' },
-        })
-        expect(scopedRoute?.schema?.response?.body).toEqual({
-            [HttpStatus.UNAUTHORIZED]: {
-                anyOf: [{ const: 'root' }, { const: 'mount' }],
-            },
-        })
-    })
-
-    it('rejects duplicate declared request components in metadata and dispatch', async () => {
-        const first = defineMiddleware({
-            schema: { request: { path: { type: 'object' } } },
-            run: () => undefined,
-        })
-        const second = defineMiddleware({
-            schema: { request: { path: { type: 'object' } } },
-            run: () => undefined,
-        })
-        const router = new Router()
-        router.get('/duplicate', { middleware: [first, second], handler: () => new Response('ok') })
-
-        expect(() => router.getRoutes()).toThrow('request.path')
-        const response = await router.fetch(makeRequest('/duplicate'))
-        expect(response.status).toBe(HttpStatus.INTERNAL_SERVER_ERROR)
-    })
-})
-
-describe('Router.mount', () => {
-    it('exposes scoped middleware context to inline mounted handlers', () => {
-        const addUser: ContextMiddleware<{ userId: string }> = (ctx) => {
-            ctx.userId = 'user-2'
-        }
-
-        const router = new Router().useRequest(requestIdCtx())
-        router.mount({ middleware: [addUser] }, (mounted) => {
-            mounted.add({
-                method: HttpMethod.GET,
-                path: '/',
-                handler: (ctx) => {
-                    expectType<TypeEqual<typeof ctx.requestId, string>>(true)
-                    expectType<TypeEqual<typeof ctx.userId, string>>(true)
-                    return new Response('ok')
-                },
-            })
-        })
-    })
-
-    it('applies parent and scoped middleware in order', async () => {
-        const events: string[] = []
-        const log = (label: string) =>
-            defineMiddleware({
-                async run(_ctx, { next, forward }) {
-                    events.push(`${label}:before`)
-                    const result = await next()
-                    events.push(`${label}:after`)
-                    return forward(result)
-                },
-            })
-        const router = new Router().use(log('root'))
-
-        router.mount({ middleware: [log('scope')] }, (scope) => {
-            scope.add({
-                method: HttpMethod.GET,
-                path: '/items',
-                handler: () => {
-                    events.push('handler')
-                    return new Response('ok')
-                },
-            })
-        })
-
-        const response = await router.fetch(makeRequest('/items'))
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(events).toEqual([
-            'root:before',
-            'scope:before',
-            'handler',
-            'scope:after',
-            'root:after',
-        ])
-    })
-
-    it('uses the inherited logger for inline mounted route internal errors', async () => {
-        const logger = createTestLogger()
-        const error = new Error('boom')
-        const router = new Router().setLogger(logger)
-
-        router.mount((mounted) => {
-            mounted.add({
-                method: HttpMethod.GET,
-                path: '/items',
-                handler: () => {
-                    throw error
-                },
-            })
-        })
-
-        const response = await router.fetch(makeRequest('/items'))
-
-        expect(response.status).toBe(HttpStatus.INTERNAL_SERVER_ERROR)
-        expect(logger.calls).toHaveLength(1)
-        expect(logger.calls[0]?.data[1]).toBe(error)
-    })
-
-    it('uses mounted prefix onNotFound handlers for misses under the prefix', async () => {
-        const child = new Router().onNotFound(() => new Response('child missing'))
-        const router = new Router()
-            .onNotFound(() => new Response('root missing'))
-            .mount('/api', child)
-
-        const response = await router.fetch(makeRequest('/api/missing'))
-
-        expect(response.status).toBe(HttpStatus.OK)
-        expect(await response.text()).toBe('child missing')
-    })
-
-    it('uses mounted prefix onMethodNotAllowed handlers for method misses under the prefix', async () => {
-        const child = new Router()
-            .onMethodNotAllowed(() => new Response('child method', { status: HttpStatus.ACCEPTED }))
-            .post('/items', () => new Response('created'))
-        const router = new Router()
-            .onMethodNotAllowed(() => new Response('root method'))
-            .mount('/api', child)
-
-        const response = await router.fetch(makeRequest('/api/items', HttpMethod.GET))
-
-        expect(response.status).toBe(HttpStatus.ACCEPTED)
-        expect(await response.text()).toBe('child method')
-    })
-
-    it('uses mounted route onUnsupportedMediaType handlers', async () => {
-        const child = new Router()
-            .onUnsupportedMediaType(
-                () => new Response('child unsupported', { status: HttpStatus.ACCEPTED }),
-            )
-            .post('/json', {
-                accept: ['application/json'],
-                handler: () => new Response('ok'),
-            })
-        const router = new Router()
-            .onUnsupportedMediaType(() => new Response('root unsupported'))
-            .mount('/api', child)
-
-        const response = await router.fetch(makeRequest('/api/json', HttpMethod.POST))
-
-        expect(response.status).toBe(HttpStatus.ACCEPTED)
-        expect(await response.text()).toBe('child unsupported')
-    })
-})