@znight/http 0.1.1 → 0.1.3

package/src/adapters/hono.ts

@@ -3,7 +3,7 @@
  * dependency `hono`). On Bun the server is `Bun.serve()`; on Node.js it is `@hono/node-server`
  * (optional peer dependency, loaded on `listen()`). `inject()` uses `app.request()`.
  */
-import type { Server, ServerResponse } from 'node:http'
+import type { IncomingMessage, Server, ServerResponse } from 'node:http'
 import type {
   AdapterCloseOptions,
   AdapterHandler,
@@ -18,14 +18,24 @@ import type {
   InjectStreamRequest,
   InjectStreamResponse,
 } from '../adapter.ts'
+import type { HeaderValue } from '../exceptions.ts'
 
 import { type Context, Hono, type Next } from 'hono'
 
+import { BadRequestException } from '../exceptions.ts'
 import { toHonoPath } from '../path.ts'
 import { discardStream } from '../stream.ts'
 import { isBun } from '../utils.ts'
-import { ConnectionTracker, closeServer, onResponseAbort } from './node-io.ts'
-import { bufferInjectStream, injectFetchStream, readWebStream, serverAddress, webBodyStream } from './shared.ts'
+import { ConnectionTracker, closeServer, nodeBodyStream, onResponseAbort, readNodeBody } from './node-io.ts'
+import {
+  bufferInjectStream,
+  exceedsDeclaredLength,
+  injectFetchStream,
+  payloadTooLarge,
+  readWebStream,
+  serverAddress,
+  webBodyStream,
+} from './shared.ts'
 
 /** Options of {@link honoAdapter}. */
 export interface HonoAdapterOptions {
@@ -102,12 +112,47 @@ interface BunRuntime {
 /** Default `idleTimeout` of `Bun.serve()`, in seconds. */
 const BUN_IDLE_TIMEOUT = 10
 
-/** A response body built while serving with `Bun.serve()` (see `#bunFetch`). */
-interface BunBody {
+/**
+ * A streamed response body built for a request of `Bun.serve()` (see `#bunStream`); with middleware,
+ * pending until `#bunFetch` takes it or it ends.
+ */
+class BunBody {
   /** The `Blob` (file) the body reads. */
   readonly blob: Blob | undefined
-  /** Sets the function called when the body ends (read to its end, failed or cancelled). */
-  onEnd(callback: () => void): void
+  #settle: (() => void) | undefined
+  #onEnd: (() => void) | undefined
+  #ended = false
+
+  /** `settle` is called once, when the body is taken by `#bunFetch` or ends, whichever comes first. */
+  constructor(blob: Blob | undefined, settle: (() => void) | undefined) {
+    this.blob = blob
+    this.#settle = settle
+  }
+
+  /** Whether the body ended (read to its end, failed or cancelled). */
+  get ended(): boolean {
+    return this.#ended
+  }
+
+  /** The body is no longer pending (taken by `#bunFetch`). */
+  settle(): void {
+    const settle = this.#settle
+    this.#settle = undefined
+    settle?.()
+  }
+
+  /** Sets the function called when the body ends. */
+  onEnd(callback: () => void): void {
+    this.#onEnd = callback
+  }
+
+  /** The body ended (read to its end, failed or cancelled). */
+  end(): void {
+    if (this.#ended) return
+    this.#ended = true
+    this.settle()
+    this.#onEnd?.()
+  }
 }
 
 /** Response bodies built while serving with `Bun.serve()`, by body (Hono may copy a `Response`, not its body). */
@@ -126,13 +171,31 @@ const INJECT_ENV = Object.freeze({ incoming: Object.freeze({ socket: Object.free
 
 type HonoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS'
 
+/** The handlers of the GET and HEAD routes of one path. */
+interface ReadHandlers {
+  get: AdapterHandler | undefined
+  head: AdapterHandler | undefined
+}
+
 class HonoHttpAdapter implements HonoAdapter {
   readonly name = 'hono' as const
   readonly app: Hono
   readonly #serveOptions: HonoServeOptions
+  /** Number of routes of `app` registered by the adapter (see {@link #middleware}). */
+  #routes = 0
+  /** The GET and HEAD handlers of each path shape, served by one route of `app` (see {@link registerRoute}). */
+  readonly #reads = new Map<string, ReadHandlers>()
   #fallback: FallbackHandler | undefined
   #prepared = false
   #bun: BunServer | undefined
+  /**
+   * Streamed bodies of `Bun.serve()` replies (with middleware) neither taken by `#bunFetch` nor ended
+   * (see {@link BunBody}): while there is none, `#bunFetch` returns responses untouched (reading
+   * `response.body` would turn a text body into a stream that Bun then sends as one).
+   */
+  #pendingBodies = 0
+  /** Idle timeout of the `Bun.serve()` server, in seconds (`0`: none). */
+  #idleTimeout = BUN_IDLE_TIMEOUT
   #node: Server | undefined
   #tracker: ConnectionTracker | undefined
   #closing: Promise<void> | undefined
@@ -150,13 +213,29 @@ class HonoHttpAdapter implements HonoAdapter {
   registerRoute(route: AdapterRoute): void {
     const handler = route.handler
     const path = toHonoPath(route.path)
-    if (route.method === 'HEAD') {
-      // Hono routes HEAD requests to GET handlers: serve them from a GET handler that only answers HEAD
-      this.app.get(path, (c: Context, next: Next) =>
-        c.req.raw.method === 'HEAD' ? this.#serve(c, handler) : next().then(() => c.res),
-      )
+    if (route.method === 'GET' || route.method === 'HEAD') {
+      // Hono routes HEAD requests to GET handlers: one GET handler per path serves both methods (the
+      // plugin registers HEAD routes first), so that a request matches a single handler and Hono
+      // skips its middleware composition. Paths are keyed by their shape (`/users/:` for
+      // `/users/:id` and `/users/:userId`): a GET route joins the HEAD route matching the same
+      // requests, at its rank (Znight reads the parameters itself, never Hono's names)
+      const existing = this.#reads.get(route.path.shape)
+      if (existing !== undefined) {
+        if (route.method === 'GET') existing.get = handler
+        else existing.head = handler
+        return
+      }
+      const reads: ReadHandlers =
+        route.method === 'GET' ? { get: handler, head: undefined } : { get: undefined, head: handler }
+      this.#reads.set(route.path.shape, reads)
+      this.#routes++
+      this.app.get(path, (c: Context, next: Next) => {
+        const read = c.req.raw.method === 'HEAD' ? reads.head : reads.get
+        return read === undefined ? next().then(() => c.res) : this.#serve(c, read)
+      })
       return
     }
+    this.#routes++
     this.app.on(route.method as HonoMethod, path, (c: Context) => this.#serve(c, handler))
   }
 
@@ -172,11 +251,12 @@ class HonoHttpAdapter implements HonoAdapter {
   }
 
   async #serve(c: Context, handler: AdapterHandler): Promise<Response> {
-    const request = adapterRequest(c)
+    const request = this.#request(c)
     // Hono routes the WHATWG-normalised URL (`/a/../b` → `/b`, `%2e%2e` resolved): when the raw
-    // target differs (Node.js), let the plugin route the raw path, like on the other adapters
+    // target differs (Node.js; on Bun only the normalised URL is known), let the plugin route the raw
+    // path, like on the other adapters
     const reply =
-      this.#fallback !== undefined && pathOf(request.url) !== pathOf(pathAndQuery(c.req.raw.url))
+      this.#fallback !== undefined && request.rawTarget && pathOf(request.url) !== pathOf(pathAndQuery(c.req.raw.url))
         ? await this.#fallback(request)
         : await handler(request)
     return this.#toResponse(c, reply)
@@ -184,10 +264,33 @@ class HonoHttpAdapter implements HonoAdapter {
 
   async #serveFallback(c: Context, error: unknown): Promise<Response> {
     if (this.#fallback === undefined) throw error ?? new Error('No fallback handler')
-    return this.#toResponse(c, await this.#fallback(adapterRequest(c), error))
+    return this.#toResponse(c, await this.#fallback(this.#request(c), error))
+  }
+
+  #request(c: Context): HonoAdapterRequest {
+    return new HonoAdapterRequest(c, this.#servedByBun(c) ? this.#bun : undefined)
+  }
+
+  /** Whether the request of `c` was received by the `Bun.serve()` server of the adapter. */
+  #servedByBun(c: Context): boolean {
+    return this.#bun !== undefined && c.env === this.#bun
+  }
+
+  /**
+   * Whether `app` has routes the adapter did not register (middleware, other routes): only they can
+   * set headers on the context or read the response.
+   */
+  #middleware(): boolean {
+    return this.app.routes.length !== this.#routes
   }
 
   #toResponse(c: Context, reply: AdapterReply): Response {
+    const middleware = this.#middleware()
+    if (this.#servedByBun(c)) {
+      return reply.body instanceof ReadableStream
+        ? this.#bunStream(c, reply, middleware)
+        : toResponse(c, reply, middleware)
+    }
     const outgoing = nodeOutgoing(c)
     if (outgoing !== undefined) {
       const body = reply.body instanceof ReadableStream ? reply.body : null
@@ -195,7 +298,7 @@ class HonoHttpAdapter implements HonoAdapter {
         // @hono/node-server: the client left before the reply was ready (an async pre-flight). The
         // server would neither read nor cancel the body: release it (event source, request scope)
         discardStream(body)
-        return toResponse(c, { ...reply, body: null })
+        return toResponse(c, { ...reply, body: null }, middleware)
       }
       if (body !== null) {
         // the client may leave before @hono/node-server reads the body (its own listener then comes
@@ -207,16 +310,23 @@ class HonoHttpAdapter implements HonoAdapter {
       // a quiet event stream must outlive a socket timeout
       if (reply.eventStream === true && typeof outgoing.setTimeout === 'function') outgoing.setTimeout(0)
     }
-    if (this.#bun === undefined || !(reply.body instanceof ReadableStream)) return toResponse(c, reply)
-    // served by Bun.serve(): observe the end of the body (idle timeout, native blob: see #bunFetch)
-    const reader = reply.body.getReader()
-    let ended = false
-    let onEnd = (): void => undefined
-    const end = (): void => {
-      if (ended) return
-      ended = true
-      onEnd()
-    }
+    return toResponse(c, reply, middleware)
+  }
+
+  /**
+   * The response of a streamed reply to a request of `Bun.serve()`: the end of its body is observed
+   * (idle timeout, native blob: see {@link #bunSend}).
+   */
+  #bunStream(c: Context, reply: AdapterReply, middleware: boolean): Response {
+    const reader = (reply.body as ReadableStream<Uint8Array>).getReader()
+    const served = new BunBody(
+      reply.blob,
+      middleware
+        ? () => {
+            this.#pendingBodies--
+          }
+        : undefined,
+    )
     const body = new ReadableStream<Uint8Array>(
       {
         async pull(controller) {
@@ -224,39 +334,53 @@ class HonoHttpAdapter implements HonoAdapter {
           try {
             result = await reader.read()
           } catch (error) {
-            end()
+            served.end()
             throw error
           }
           if (result.done) {
-            end() // before closing: Bun ignores timeout() once the response is complete
+            served.end() // before closing: Bun ignores timeout() once the response is complete
             controller.close()
             return
           }
           controller.enqueue(result.value)
         },
         cancel(reason) {
-          end()
+          served.end()
           return reader.cancel(reason)
         },
       },
       { highWaterMark: 0 },
     )
-    BUN_BODIES.set(body, {
-      blob: reply.blob,
-      onEnd: callback => {
-        onEnd = callback
-      },
-    })
-    return toResponse(c, { ...reply, body })
+    const response = toResponse(c, { ...reply, body }, middleware)
+    if (!middleware) {
+      // nothing else handles the request (see the fetch handler given to Bun.serve()): Bun sends this
+      // response, unless it does not carry the body (an invalid header: the body was discarded)
+      return served.ended ? response : this.#bunSend(response, body, served, c.req.raw)
+    }
+    // middleware may copy the response (not its body) or replace it: #bunFetch finds the body
+    this.#pendingBodies++
+    BUN_BODIES.set(body, served)
+    return response
   }
 
-  /** The fetch handler given to `Bun.serve()`. */
-  async #bunFetch(request: Request, server: BunServer, idleTimeout: number): Promise<Response> {
+  /** The fetch handler given to `Bun.serve()` when `app` has middleware (see {@link #bunStream}). */
+  async #bunFetch(request: Request, server: BunServer): Promise<Response> {
     const response = await this.app.fetch(request, server)
+    // only a streamed reply needs more: leave the other responses untouched (see #pendingBodies)
+    if (this.#pendingBodies === 0) return response
     const body = response.body
     const served = body === null ? undefined : BUN_BODIES.get(body)
     if (body === null || served === undefined) return response
     BUN_BODIES.delete(body)
+    served.settle()
+    return this.#bunSend(response, body, served, request)
+  }
+
+  /**
+   * The response Bun sends for a streamed reply, once final: a file `Blob` is sent natively, a
+   * stream with the idle timeout of the connection lifted.
+   */
+  #bunSend(response: Response, body: ReadableStream<Uint8Array>, served: BunBody, request: Request): Response {
     if (served.blob !== undefined && !body.locked) {
       // a Blob is sent by Bun itself (sendfile, exact Content-Length; a stream would be chunked). Bun
       // opens its file as soon as it takes the response: release the stream (and with it the request
@@ -269,9 +393,12 @@ class HonoHttpAdapter implements HonoAdapter {
       setImmediate(() => discardStream(body))
       return native
     }
-    if (idleTimeout > 0 && typeof server.timeout === 'function') {
+    const server = this.#bun
+    const idleTimeout = this.#idleTimeout
+    if (idleTimeout > 0 && !served.ended && typeof server?.timeout === 'function') {
       // the idle timeout of Bun.serve() also cuts a response whose stream pauses (SSE, slow producers):
-      // lift it while the stream is sent, then restore it for the keep-alive connection
+      // lift it while the stream is sent, then restore it for the keep-alive connection (a body that
+      // already ended would never restore it)
       server.timeout(request, 0)
       served.onEnd(() => {
         try {
@@ -290,14 +417,16 @@ class HonoHttpAdapter implements HonoAdapter {
     const bun = (globalThis as { Bun?: BunRuntime }).Bun
     if (isBun() && bun !== undefined) {
       const options = this.#serveOptions
-      const idleTimeout = typeof options.idleTimeout === 'number' ? options.idleTimeout : BUN_IDLE_TIMEOUT
+      this.#idleTimeout = typeof options.idleTimeout === 'number' ? options.idleTimeout : BUN_IDLE_TIMEOUT
       const server = bun.serve({
         // Znight enforces the body limits (route @BodyLimit, plugin bodyLimit): not Bun's 128 MiB default
         maxRequestBodySize: Number.MAX_SAFE_INTEGER,
         ...options,
         port,
         hostname: host,
-        fetch: (request, server) => this.#bunFetch(request, server, idleTimeout),
+        // without middleware, the response of a Znight route is the one Bun sends (no wrapper needed)
+        fetch: (request, server) =>
+          this.#middleware() ? this.#bunFetch(request, server) : this.app.fetch(request, server),
       })
       this.#bun = server
       return serverAddress(server.hostname, server.port)
@@ -354,48 +483,153 @@ class HonoHttpAdapter implements HonoAdapter {
   }
 }
 
-function adapterRequest(c: Context): AdapterRequest {
-  const request = c.req.raw
+/** A Hono request as an {@link AdapterRequest} (a class: no closure per request). */
+class HonoAdapterRequest implements AdapterRequest {
+  readonly method: string
+  readonly url: string
+  readonly headers: Readonly<Record<string, string | undefined>>
+  readonly ip: string | undefined
+  readonly remoteAddress: string | undefined
+  readonly encrypted: boolean
+  readonly raw: Request
+  readonly rawResponse: Context
+  /** `url` is the raw request target (Node.js), not the WHATWG-normalised URL of `raw`. */
+  readonly rawTarget: boolean
+  /** The Node.js request of `@hono/node-server`, absent on Bun and for `inject()`. */
+  readonly #incoming: NodeIncoming | undefined
+  /**
+   * The same request over HTTP/1.1, read directly (Node.js streams): no Fetch `Request` and body
+   * stream are built for it.
+   */
+  readonly #http1: IncomingMessage | undefined
+  /** Received by the `Bun.serve()` server of the adapter: its body is framed by the HTTP parser. */
+  readonly #bun: boolean
+  #body: Promise<Uint8Array> | undefined
+
+  constructor(c: Context, bun: BunServer | undefined) {
+    const request = c.req.raw
+    this.method = request.method
+    this.raw = request
+    this.rawResponse = c
+    this.#bun = bun !== undefined
+    if (bun !== undefined) {
+      // Bun.serve(): only the normalised URL is known; the address is asked now (Bun no longer knows
+      // it once the response is sent)
+      const url = request.url
+      const address = bun.requestIP?.(request)?.address ?? undefined
+      this.url = pathAndQuery(url)
+      this.rawTarget = false
+      this.headers = fetchHeaders(request.headers)
+      this.ip = address
+      this.remoteAddress = address
+      this.encrypted = url.startsWith('https:')
+      this.#incoming = undefined
+      this.#http1 = undefined
+      return
+    }
+    const incoming = nodeIncoming(c)
+    const http1 = incoming !== undefined && incoming.httpVersionMajor < 2 ? (incoming as IncomingMessage) : undefined
+    const address = remoteAddress(c)
+    const target = incoming?.url
+    // the raw target on Node.js; for a Web request only the normalised URL is known
+    this.rawTarget = typeof target === 'string' && target !== ''
+    this.url = pathAndQuery(this.rawTarget ? (target as string) : request.url)
+    this.headers = (http1 === undefined ? undefined : distinctHeaders(http1)) ?? fetchHeaders(request.headers)
+    this.ip = address
+    this.remoteAddress = address
+    this.encrypted = incoming === undefined ? request.url.startsWith('https:') : incoming.socket?.encrypted === true
+    this.#incoming = incoming
+    this.#http1 = http1
+  }
+
+  readBody(limit: number): Promise<Uint8Array> {
+    if (this.#body === undefined) {
+      const http1 = this.#http1
+      if (http1 !== undefined) this.#body = readNodeBody(http1, limit)
+      else if (this.#bun && this.#framed()) this.#body = readFramedBody(this.raw, limit, this.headers['content-length'])
+      else this.#body = readWebStream(() => this.raw.body, limit, this.headers['content-length'])
+    }
+    return this.#body
+  }
+
+  /**
+   * Whether the whole body can be read at once from `Bun.serve()`: its length is declared (the
+   * HTTP parser then reads no more) and nothing read it yet.
+   */
+  #framed(): boolean {
+    const headers = this.headers
+    return headers['content-length'] !== undefined && headers['transfer-encoding'] === undefined && !this.raw.bodyUsed
+  }
+
+  streamBody(limit: number): ReadableStream<Uint8Array> {
+    const http1 = this.#http1
+    if (http1 !== undefined) return nodeBodyStream(http1, limit)
+    return webBodyStream(() => this.raw.body, limit, this.headers['content-length'])
+  }
+
+  // asked only without content-length / transfer-encoding: a request read from an HTTP/1.1
+  // connection then has no body (`@hono/node-server` still gives every POST a body stream), an
+  // HTTP/2 one unless its HEADERS frame ended the stream; a Web `Request` (Bun, inject) says it
+  hasBody(): boolean {
+    const incoming = this.#incoming
+    return incoming === undefined
+      ? this.raw.body !== null
+      : incoming.httpVersionMajor >= 2 && incoming.stream?.endAfterHeaders === false
+  }
+
+  onAbort(listener: () => void): void {
+    const outgoing = this.#bun ? undefined : nodeOutgoing(this.rawResponse)
+    if (outgoing !== undefined) {
+      onResponseAbort(outgoing as unknown as ServerResponse, listener)
+      return
+    }
+    // Bun.serve() and inject(): the request signal aborts when the client leaves
+    const signal = this.raw.signal
+    if (signal.aborted) queueMicrotask(listener)
+    else signal.addEventListener('abort', listener, { once: true })
+  }
+}
+
+/** The headers of a Fetch request: lower-case names, repeated headers joined (`Headers` semantics). */
+function fetchHeaders(source: Headers): Record<string, string> {
   const headers: Record<string, string> = {}
-  for (const [name, value] of request.headers) headers[name] = value
-  const incoming = nodeIncoming(c)
-  const address = remoteAddress(c)
-  let body: Promise<Uint8Array> | undefined
-  return {
-    method: request.method,
-    // the raw target on Node.js; on Bun only the normalised URL is known
-    url: pathAndQuery(typeof incoming?.url === 'string' && incoming.url !== '' ? incoming.url : request.url),
-    headers,
-    ip: address,
-    remoteAddress: address,
-    encrypted: incoming === undefined ? request.url.startsWith('https:') : incoming.socket?.encrypted === true,
-    raw: request,
-    rawResponse: c,
-    readBody: (limit: number): Promise<Uint8Array> => {
-      body ??= readWebStream(() => request.body, limit, headers['content-length'])
-      return body
-    },
-    streamBody: (limit: number): ReadableStream<Uint8Array> =>
-      webBodyStream(() => request.body, limit, headers['content-length']),
-    // asked only without content-length / transfer-encoding: a request read from an HTTP/1.1
-    // connection then has no body (`@hono/node-server` still gives every POST a body stream), an
-    // HTTP/2 one unless its HEADERS frame ended the stream; a Web `Request` (Bun, inject) says it
-    hasBody: (): boolean =>
-      incoming === undefined
-        ? request.body !== null
-        : incoming.httpVersionMajor >= 2 && incoming.stream?.endAfterHeaders === false,
-    onAbort: (listener: () => void): void => {
-      const outgoing = nodeOutgoing(c)
-      if (outgoing !== undefined) {
-        onResponseAbort(outgoing as unknown as ServerResponse, listener)
-        return
-      }
-      // Bun.serve() and inject(): the request signal aborts when the client leaves
-      const signal = request.signal
-      if (signal.aborted) queueMicrotask(listener)
-      else signal.addEventListener('abort', listener, { once: true })
-    },
+  // forEach: no iterator nor entry array per header
+  source.forEach((value, name) => {
+    headers[name] = value
+  })
+  return headers
+}
+
+/**
+ * Reads at once (`request.bytes()`, no stream) the body of a request received by `Bun.serve()`
+ * whose `content-length` is declared: Bun reads exactly that many bytes, so checking the declared
+ * length enforces `limit`. Failures are those of {@link readWebStream}: 413 above `limit`, 400 when
+ * the client aborts.
+ */
+async function readFramedBody(request: Request, limit: number, contentLength: string | undefined): Promise<Uint8Array> {
+  if (exceedsDeclaredLength(contentLength, limit)) throw payloadTooLarge(limit)
+  let bytes: Uint8Array
+  try {
+    bytes = await request.bytes()
+  } catch (error) {
+    throw new BadRequestException('Failed to read the request body', undefined, { cause: error })
+  }
+  if (bytes.byteLength > limit) throw payloadTooLarge(limit)
+  return bytes
+}
+
+/**
+ * The headers of a Node.js request when none is repeated: then they hold the values of its Fetch
+ * `Headers` (Node.js keeps the first of some repeated headers where `Headers` join them all).
+ */
+function distinctHeaders(request: IncomingMessage): Record<string, string | undefined> | undefined {
+  const headers = request.headers
+  let count = 0
+  for (const name in headers) {
+    if (typeof headers[name] !== 'string') return undefined
+    count++
   }
+  return count * 2 === request.rawHeaders.length ? (headers as Record<string, string | undefined>) : undefined
 }
 
 /** The part of a Node.js `ServerResponse` used here. */
@@ -439,11 +673,22 @@ function remoteAddress(c: Context): string | undefined {
   return env.incoming?.socket?.remoteAddress
 }
 
-function toResponse(c: Context, reply: AdapterReply): Response {
+/**
+ * The `Response` of a reply. Without `middleware` (see `#middleware`), nothing set headers on the
+ * context and nothing reads the response: headers given as a record of strings are sent as is by
+ * `@hono/node-server` (no `Headers` object), and a text body as a string.
+ */
+function toResponse(c: Context, reply: AdapterReply, middleware: boolean): Response {
   if (reply.raw === true) {
     discardStream(reply.body instanceof ReadableStream ? reply.body : null)
     return c.res
   }
+  if (!middleware && isStringRecord(reply.headers)) {
+    return new Response(reply.text ?? reply.body, {
+      status: reply.status,
+      headers: reply.headers as Readonly<Record<string, string>>,
+    })
+  }
   const headers = new Headers()
   try {
     for (const name of Object.keys(reply.headers)) {
@@ -460,8 +705,18 @@ function toResponse(c: Context, reply: AdapterReply): Response {
       headers: { 'content-type': 'application/json; charset=utf-8' },
     })
   }
-  keepContextCookies(c, headers)
-  return new Response(reply.body, { status: reply.status, headers })
+  if (middleware) keepContextCookies(c, headers)
+  return new Response(reply.text ?? reply.body, { status: reply.status, headers })
+}
+
+/** Whether every header has a single value (a record of strings is a valid `HeadersInit`). */
+function isStringRecord(headers: Readonly<Record<string, HeaderValue>>): boolean {
+  // Object.keys: faster than for...in on the null-prototype records of the pipeline (V8)
+  const names = Object.keys(headers)
+  for (let index = 0; index < names.length; index++) {
+    if (typeof headers[names[index] as string] !== 'string') return false
+  }
+  return true
 }
 
 /**