@znight/http 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@znight/http",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Znight HTTP plugin: controllers, routing, guards, interceptors, validation with Fastify, Express or Hono",
   "license": "MIT",
   "author": "Ugho STEPHAN",
@@ -79,7 +79,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@znight/core": "0.1.1"
+    "@znight/core": "0.1.2"
   },
   "peerDependencies": {
     "@hono/node-server": "^2.1.5",
@@ -87,7 +87,7 @@
     "fastify": "^5.12.7",
     "hono": "^4.13.14",
     "light-my-request": "^6.8.0",
-    "@znight/compiler": "^0.1.1"
+    "@znight/compiler": "^0.1.2"
   },
   "peerDependenciesMeta": {
     "@hono/node-server": {
@@ -118,7 +118,7 @@
     "valibot": "1.5.0",
     "zod": "4.6.7",
     "light-my-request": "6.8.0",
-    "@znight/compiler": "0.1.1"
+    "@znight/compiler": "0.1.2"
   },
   "znight": {
     "apiVersion": 1,

package/src/adapter.ts

@@ -81,6 +81,12 @@ export interface AdapterReply {
   readonly headers: Readonly<Record<string, HeaderValue>>
   /** `null` for HEAD requests and bodyless statuses (headers such as `content-length` are kept). */
   readonly body: ReplyBody
+  /**
+   * The text `body` holds encoded as UTF-8, for a body serialised from a string (JSON, text).
+   * Adapters writing strings MAY send it instead of `body`, which writes the same bytes: Node.js then
+   * writes the headers and the body at once (bytes take a second write).
+   */
+  readonly text?: string
   /**
    * The `Blob` (file) that `body` streams, for adapters able to send it natively (`sendfile`, exact
    * length: `new Response(blob)` on `Bun.serve()`). An adapter sending it instead of reading `body`

package/src/adapters/fastify.ts

@@ -17,6 +17,7 @@ import type {
   InjectStreamRequest,
   InjectStreamResponse,
 } from '../adapter.ts'
+import type { HeaderValue } from '../exceptions.ts'
 
 import { Readable } from 'node:stream'
 import Fastify, {
@@ -189,14 +190,18 @@ class FastifyHttpAdapter implements FastifyAdapter {
       const native = lowerCaseHeaders(reply.getHeaders())
       const headers = { ...native, ...withNativeCookies(native['set-cookie'], result.headers) }
       reply.hijack()
-      void writeNodeReply(reply.raw, { ...result, headers })
+      writeNodeReply(reply.raw, { ...result, headers })
       return reply
     }
     reply.code(result.status)
     for (const name of Object.keys(result.headers)) reply.header(name, result.headers[name])
     const body = result.body
     if (body === null) return reply.send()
-    if (body instanceof Uint8Array) return reply.send(Buffer.from(body.buffer, body.byteOffset, body.byteLength))
+    if (body instanceof Uint8Array) {
+      // a string is written with the headers at once (bytes take a second write)
+      if (result.text !== undefined && sendsTextAsIs(result.headers['content-type'])) return reply.send(result.text)
+      return reply.send(Buffer.isBuffer(body) ? body : Buffer.from(body.buffer, body.byteOffset, body.byteLength))
+    }
     const stream = body instanceof Blob ? body.stream() : body
     return reply.send(Readable.fromWeb(stream as import('node:stream/web').ReadableStream))
   }
@@ -236,6 +241,20 @@ class FastifyHttpAdapter implements FastifyAdapter {
   }
 }
 
+/** The JSON content type of the plugin (with a charset). */
+const JSON_TYPE = 'application/json; charset=utf-8'
+
+/**
+ * Whether Fastify sends a string with this content type unchanged: it adds a charset to a JSON
+ * type without one, and a content type to a string without one.
+ */
+function sendsTextAsIs(type: HeaderValue | undefined): boolean {
+  if (typeof type !== 'string') return false
+  if (type === JSON_TYPE) return true
+  const semicolon = type.indexOf(';')
+  return !(semicolon === -1 ? type : type.slice(0, semicolon)).toLowerCase().includes('json')
+}
+
 function lowerCaseHeaders(
   headers: Readonly<Record<string, string | number | readonly string[] | undefined>>,
 ): Record<string, string | string[]> {
@@ -257,24 +276,50 @@ function adapterRequest(
     HIDDEN_CONTENT_TYPES.delete(request.raw)
     request.raw.headers['content-type'] = hidden
   }
-  let body: Promise<Uint8Array> | undefined
-  return {
-    method: request.raw.method ?? request.method,
-    url: request.raw.url ?? request.url,
-    headers: normalizeNodeHeaders(request.headers),
-    ip: request.ip,
-    remoteAddress: request.raw.socket?.remoteAddress,
-    encrypted: isEncrypted(request.raw),
-    raw: request,
-    rawResponse: reply,
-    readBody: (limit: number): Promise<Uint8Array> => {
-      body ??= readNodeBody(request.raw, limit)
-      return body
-    },
-    streamBody: (limit: number): ReadableStream<Uint8Array> => nodeBodyStream(request.raw, limit),
-    rawStatus: (): number | undefined => reply?.statusCode,
-    onAbort: (listener: () => void): void => {
-      if (response !== undefined) onResponseAbort(response.raw, listener)
-    },
+  return new FastifyAdapterRequest(request, reply, response)
+}
+
+/** A Fastify request as an {@link AdapterRequest} (a class: no closure per request). */
+class FastifyAdapterRequest 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: FastifyRequest
+  /** `@Res()`: the reply of a route, `undefined` for the fallback handler. */
+  readonly rawResponse: FastifyReply | undefined
+  /** The reply whose disconnection aborts the request. */
+  readonly #response: FastifyReply | undefined
+  #body: Promise<Uint8Array> | undefined
+
+  constructor(request: FastifyRequest, reply: FastifyReply | undefined, response: FastifyReply | undefined) {
+    this.method = request.raw.method ?? request.method
+    this.url = request.raw.url ?? request.url
+    this.headers = normalizeNodeHeaders(request.headers)
+    this.ip = request.ip
+    this.remoteAddress = request.raw.socket?.remoteAddress
+    this.encrypted = isEncrypted(request.raw)
+    this.raw = request
+    this.rawResponse = reply
+    this.#response = response
+  }
+
+  readBody(limit: number): Promise<Uint8Array> {
+    this.#body ??= readNodeBody(this.raw.raw, limit)
+    return this.#body
+  }
+
+  streamBody(limit: number): ReadableStream<Uint8Array> {
+    return nodeBodyStream(this.raw.raw, limit)
+  }
+
+  rawStatus(): number | undefined {
+    return this.rawResponse?.statusCode
+  }
+
+  onAbort(listener: () => void): void {
+    if (this.#response !== undefined) onResponseAbort(this.#response.raw, listener)
   }
 }

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,13 +18,14 @@ import type {
   InjectStreamRequest,
   InjectStreamResponse,
 } from '../adapter.ts'
+import type { HeaderValue } from '../exceptions.ts'
 
 import { type Context, Hono, type Next } from 'hono'
 
 import { toHonoPath } from '../path.ts'
 import { discardStream } from '../stream.ts'
 import { isBun } from '../utils.ts'
-import { ConnectionTracker, closeServer, onResponseAbort } from './node-io.ts'
+import { ConnectionTracker, closeServer, nodeBodyStream, onResponseAbort, readNodeBody } from './node-io.ts'
 import { bufferInjectStream, injectFetchStream, readWebStream, serverAddress, webBodyStream } from './shared.ts'
 
 /** Options of {@link honoAdapter}. */
@@ -130,6 +131,8 @@ 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
   #fallback: FallbackHandler | undefined
   #prepared = false
   #bun: BunServer | undefined
@@ -150,6 +153,7 @@ class HonoHttpAdapter implements HonoAdapter {
   registerRoute(route: AdapterRoute): void {
     const handler = route.handler
     const path = toHonoPath(route.path)
+    this.#routes++
     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) =>
@@ -187,7 +191,16 @@ class HonoHttpAdapter implements HonoAdapter {
     return this.#toResponse(c, await this.#fallback(adapterRequest(c), error))
   }
 
+  /**
+   * 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()
     const outgoing = nodeOutgoing(c)
     if (outgoing !== undefined) {
       const body = reply.body instanceof ReadableStream ? reply.body : null
@@ -195,7 +208,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,7 +220,7 @@ 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)
+    if (this.#bun === undefined || !(reply.body instanceof ReadableStream)) return toResponse(c, reply, middleware)
     // served by Bun.serve(): observe the end of the body (idle timeout, native blob: see #bunFetch)
     const reader = reply.body.getReader()
     let ended = false
@@ -247,7 +260,7 @@ class HonoHttpAdapter implements HonoAdapter {
         onEnd = callback
       },
     })
-    return toResponse(c, { ...reply, body })
+    return toResponse(c, { ...reply, body }, middleware)
   }
 
   /** The fetch handler given to `Bun.serve()`. */
@@ -355,49 +368,107 @@ class HonoHttpAdapter implements HonoAdapter {
 }
 
 function adapterRequest(c: Context): AdapterRequest {
-  const request = c.req.raw
-  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,
+  return new HonoAdapterRequest(c)
+}
+
+/** 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
+  /** 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
+  #body: Promise<Uint8Array> | undefined
+
+  constructor(c: Context) {
+    const request = c.req.raw
+    const incoming = nodeIncoming(c)
+    const http1 = incoming !== undefined && incoming.httpVersionMajor < 2 ? (incoming as IncomingMessage) : undefined
+    const address = remoteAddress(c)
+    this.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 })
-    },
+    this.url = pathAndQuery(typeof incoming?.url === 'string' && incoming.url !== '' ? incoming.url : 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.raw = request
+    this.rawResponse = c
+    this.#incoming = incoming
+    this.#http1 = http1
+  }
+
+  readBody(limit: number): Promise<Uint8Array> {
+    if (this.#body === undefined) {
+      const http1 = this.#http1
+      this.#body =
+        http1 === undefined
+          ? readWebStream(() => this.raw.body, limit, this.headers['content-length'])
+          : readNodeBody(http1, limit)
+    }
+    return this.#body
+  }
+
+  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 = 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 source) headers[name] = value
+  return headers
+}
+
+/**
+ * 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. */
 interface NodeOutgoing {
   readonly writableFinished: boolean
@@ -439,11 +510,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 +542,14 @@ 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 {
+  for (const name in headers) if (typeof headers[name] !== 'string') return false
+  return true
 }
 
 /**

package/src/adapters/node-io.ts

@@ -183,23 +183,52 @@ export function nodeAdapterRequest(
   response: ServerResponse,
   options: NodeRequestOptions = {},
 ): AdapterRequest {
-  let body: Promise<Uint8Array> | undefined
-  return {
-    method: request.method ?? 'GET',
-    url: options.url ?? request.url ?? '/',
-    headers: normalizeNodeHeaders(request.headers),
-    ip: options.ip ?? request.socket?.remoteAddress,
-    remoteAddress: request.socket?.remoteAddress,
-    encrypted: isEncrypted(request),
-    raw: options.raw ?? request,
-    rawResponse: options.rawResponse ?? response,
-    readBody: (limit: number): Promise<Uint8Array> => {
-      body ??= readNodeBody(request, limit)
-      return body
-    },
-    streamBody: (limit: number): ReadableStream<Uint8Array> => nodeBodyStream(request, limit),
-    rawStatus: (): number => response.statusCode,
-    onAbort: (listener: () => void): void => onResponseAbort(response, listener),
+  return new NodeAdapterRequest(request, response, options)
+}
+
+/** A Node.js request/response pair as an {@link AdapterRequest} (a class: no closure per request). */
+class NodeAdapterRequest 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: unknown
+  readonly rawResponse: unknown
+  readonly #request: IncomingMessage
+  readonly #response: ServerResponse
+  #body: Promise<Uint8Array> | undefined
+
+  constructor(request: IncomingMessage, response: ServerResponse, options: NodeRequestOptions) {
+    const remoteAddress = request.socket?.remoteAddress
+    this.method = request.method ?? 'GET'
+    this.url = options.url ?? request.url ?? '/'
+    this.headers = normalizeNodeHeaders(request.headers)
+    this.ip = options.ip ?? remoteAddress
+    this.remoteAddress = remoteAddress
+    this.encrypted = isEncrypted(request)
+    this.raw = options.raw ?? request
+    this.rawResponse = options.rawResponse ?? response
+    this.#request = request
+    this.#response = response
+  }
+
+  readBody(limit: number): Promise<Uint8Array> {
+    this.#body ??= readNodeBody(this.#request, limit)
+    return this.#body
+  }
+
+  streamBody(limit: number): ReadableStream<Uint8Array> {
+    return nodeBodyStream(this.#request, limit)
+  }
+
+  rawStatus(): number {
+    return this.#response.statusCode
+  }
+
+  onAbort(listener: () => void): void {
+    onResponseAbort(this.#response, listener)
   }
 }
 
@@ -224,10 +253,10 @@ export function isEncrypted(request: IncomingMessage): boolean {
 }
 
 /**
- * Writes a reply to a `ServerResponse`. Resolves when the response is complete (streams included);
- * never rejects (a failing stream destroys the response).
+ * Writes a reply to a `ServerResponse`, piping a stream body (a failing stream destroys the
+ * response). Never throws.
  */
-export async function writeNodeReply(response: ServerResponse, reply: AdapterReply): Promise<void> {
+export function writeNodeReply(response: ServerResponse, reply: AdapterReply): void {
   if (reply.raw === true) {
     discardStream(reply.body instanceof ReadableStream ? reply.body : null)
     return
@@ -263,14 +292,18 @@ export async function writeNodeReply(response: ServerResponse, reply: AdapterRep
     response.setTimeout(0)
   }
   if (body instanceof Uint8Array) {
-    response.end(body)
+    // a string is written with the headers at once (bytes take a second write)
+    response.end(reply.text ?? body)
     return
   }
-  const stream = body instanceof Blob ? body.stream() : body
+  const fail = (): void => {
+    if (!response.destroyed) response.destroy()
+  }
   try {
-    await pipeline(Readable.fromWeb(stream as import('node:stream/web').ReadableStream), response)
+    const stream = body instanceof Blob ? body.stream() : body
+    pipeline(Readable.fromWeb(stream as import('node:stream/web').ReadableStream), response).catch(fail)
   } catch {
-    if (!response.destroyed) response.destroy()
+    fail()
   }
 }
 

package/src/context.ts

@@ -11,7 +11,7 @@ import { DEFAULT_COOKIE_SETTINGS, missingSecrets, serializeWith, verifySigned }
 import { parseCookieHeader } from './cookies.ts'
 import { UnsupportedMediaTypeException } from './exceptions.ts'
 import { parseMultipart, readMultipart } from './multipart.ts'
-import { parseQuery, type QueryRecord, splitUrl } from './query.ts'
+import { parseQuery, type QueryRecord, type RequestTarget, splitUrl } from './query.ts'
 import { emptyRecord } from './utils.ts'
 
 declare const requestIdBrand: unique symbol
@@ -226,11 +226,13 @@ export class RequestContext implements HttpContext {
     init: {
       readonly requestId: RequestId
       readonly adapter: string
+      /** `source.url` split (default: split here). */
+      readonly url?: RequestTarget
       readonly route: HttpRouteInfo | undefined
       readonly params: Readonly<Record<string, string>>
       readonly body: BodyPlan
       /** Client address and protocol (`trustProxy`); default: the adapter's `ip` and `encrypted`. */
-      readonly client?: { readonly ip: string | undefined; readonly protocol: 'http' | 'https' }
+      readonly client?: { readonly ip: string | undefined; readonly protocol: 'http' | 'https' } | undefined
       /** Cookie defaults and signing key (plugin option `cookies`); default: secure defaults, no signing. */
       readonly cookies?: CookieSettings
     },
@@ -238,7 +240,7 @@ export class RequestContext implements HttpContext {
     this.#source = source
     this.#plan = init.body
     this.#cookieSettings = init.cookies ?? DEFAULT_COOKIE_SETTINGS
-    const { path, query } = splitUrl(source.url)
+    const { path, query } = init.url ?? splitUrl(source.url)
     this.#rawQuery = query
     this.requestId = init.requestId
     this.method = source.method
@@ -333,7 +335,7 @@ export class RequestContext implements HttpContext {
 
   /** The `Set-Cookie` lines of {@link setCookie} / {@link clearCookie}, with their keys, in order (internal). */
   get cookieLines(): readonly SerializedCookie[] {
-    return this.#jar === undefined ? [] : [...this.#jar].map(([key, entry]) => ({ key, line: entry.line }))
+    return this.#jar === undefined ? NO_LINES : [...this.#jar].map(([key, entry]) => ({ key, line: entry.line }))
   }
 
   #addCookie(cookie: ResponseCookie): void {
@@ -530,4 +532,5 @@ function withoutLifetime(options: ClearCookieOptions): ClearCookieOptions {
 
 const EMPTY_HEADERS: Readonly<Record<string, HeaderValue>> = Object.freeze({})
 const NO_COOKIES: readonly ResponseCookie[] = Object.freeze([])
+const NO_LINES: readonly SerializedCookie[] = Object.freeze([])
 const NO_FILES: Readonly<Record<string, readonly File[]>> = Object.freeze(emptyRecord<readonly File[]>())