@nifrajs/core 2.14.1 → 3.1.0

package/src/server/install.ts

@@ -6,6 +6,7 @@
  *   - the seam stays off the server's public typed surface (symbol-keyed methods are not part of it).
  * Both sides reference the SAME registered symbol, so no module has to import the other.
  */
+import { NODE_BRIDGE_MARKER_KEYS } from "./bridge-markers.ts"
 
 /** @internal Install the idempotency runtime on a server (called by the `idempotency()` plugin). */
 export const INSTALL_IDEMPOTENCY: unique symbol = Symbol.for("@nifrajs/core/install-idempotency")
@@ -31,3 +32,16 @@ export const INSTALL_WS: unique symbol = Symbol.for("@nifrajs/core/install-ws")
 export const INSTALL_RESPONSE_CONTRACT: unique symbol = Symbol.for(
   "@nifrajs/core/install-response-contract",
 )
+
+/** @internal Install the response-observer adapters on a server. */
+export const INSTALL_RESPONSE_OBSERVER: unique symbol = Symbol.for(
+  "@nifrajs/core/install-response-observer",
+)
+
+/** @internal Resolve a native mount for an adapter that can keep the request on its own stream lane. */
+export const RESOLVE_NODE_MOUNT: unique symbol = Symbol.for(
+  NODE_BRIDGE_MARKER_KEYS.resolveNodeMount,
+)
+
+/** @internal Marker on a mounted handler that knows how to serve a native Node request/response. */
+export const NODE_NATIVE_MOUNT: unique symbol = Symbol.for("@nifrajs/core/node-native-mount")

package/src/server/node-outcome-hook.ts

@@ -3,6 +3,7 @@
 import type { Platform } from "./context.ts"
 import { hasLowercaseHeaderKeysMark, hasUpperAscii } from "./header-case.ts"
 import type { NodeServeOutcome } from "./node-outcome.ts"
+import type { ResponseResult } from "./runtime-core.ts"
 import type { CtxSet, MaybePromise } from "./server.ts"
 
 /**
@@ -309,7 +310,7 @@ export interface NodeOutcomeRuntime {
   toOutcome(result: unknown, set: CtxSet): NodeServeOutcome
   /** Materialize a buffered outcome for a Web response hook without losing its direct-write marker. */
   toResponse(outcome: NodeServeOutcome): Response
-  fromResponse(response: Response): NodeServeOutcome
+  fromResponse(response: Response | ResponseResult): NodeServeOutcome
   timeout(): NodeServeOutcome
   /** The `Content-Type` this runtime's json render writes implicitly. The native hook walk
    * materializes it into the hook-visible header record so a body hook's content-type checks see

package/src/server/node-outcome.ts

@@ -11,7 +11,14 @@ import {
   rememberMutableHeaders,
   taggedResponseBody,
 } from "./respond.ts"
-import { type HandlerResult, isResponseResult } from "./runtime-core.ts"
+import {
+  EMPTY_RESPONSE_CONTROLS,
+  type HandlerResult,
+  isResponseResult,
+  type PlainRender,
+  plainRenderHeaders,
+  type ResponseResult,
+} from "./runtime-core.ts"
 import type { CtxSet } from "./server.ts"
 import {
   mergeStaticHeaderRecord,
@@ -58,6 +65,8 @@ export type NodeServeOutcome =
  */
 export function toNodeOutcome(result: HandlerResult, set: CtxSet): NodeServeOutcome {
   if (isResponseResult(result)) {
+    const plain = result.plain
+    if (plain !== undefined) return plainNodeOutcome(plain, set)
     const body = result.toNodeBody?.()
     if (body !== undefined) {
       return {
@@ -85,6 +94,24 @@ export function toNodeOutcome(result: HandlerResult, set: CtxSet): NodeServeOutc
   }
 }
 
+/**
+ * A `status(...)` (or any other {@link PlainRender} carrier) on the node lane: the same `kind: "json"`
+ * outcome a handler's plain return produces, so an early exit is written to the socket by the same
+ * direct writer, with a `content-length`, and never builds a `Response`.
+ */
+export function plainNodeOutcome(plain: PlainRender, set: CtxSet): NodeServeOutcome {
+  return {
+    kind: "json",
+    status: plain.status,
+    headers: plainRenderHeaders(plain, set),
+    cookies: set._cookies,
+    body:
+      plain.body === undefined || isBodylessStatus(plain.status)
+        ? null
+        : JSON.stringify(plain.body),
+  }
+}
+
 /**
  * Materialize a buffered node outcome only when a Web `onResponse` hook needs to see a real
  * `Response`. The marker lets an in-place hook (`response.headers.set(...); return response`) go back
@@ -162,8 +189,22 @@ export function withStaticNodeHeaders(
   return { ...outcome, headers }
 }
 
-export function nodeOutcomeFromResponse(response: Response): NodeServeOutcome {
-  response = normalizeBodylessResponse(response)
+/**
+ * The node lane's `wrapResponse`: what an early exit built OUTSIDE the handler's finalizer renders as
+ * - an `onRequest` hook's `Response`, a mount's, and every framework error render.
+ *
+ * A plain-data carrier ({@link plainError}, `status(...)`) takes the same `kind: "json"` lane a
+ * handler's plain return takes: no `Response` built, and none drained. `EMPTY_RESPONSE_CONTROLS`
+ * rather than the request's `c.set` on purpose - these renders happen where no context exists (before
+ * routing, or after it was abandoned), which is exactly why they are wrapped rather than finalized.
+ */
+export function nodeOutcomeFromResponse(result: Response | ResponseResult): NodeServeOutcome {
+  if (!(result instanceof Response)) {
+    const plain = result.plain
+    if (plain !== undefined) return plainNodeOutcome(plain, EMPTY_RESPONSE_CONTROLS)
+    return nodeOutcomeFromResponse(result.toResponse())
+  }
+  const response = normalizeBodylessResponse(result)
   const body = nodeResponseBody(response)
   return body === undefined
     ? { kind: "response", response }

package/src/server/query.ts

@@ -4,7 +4,8 @@
  * and the byte-capped HTML-form reader. Split out of the server kernel so the file stays one domain.
  */
 import { readBoundedBytes } from "./body.ts"
-import { jsonError, urlPartsOf } from "./http.ts"
+import { plainError, urlPartsOf } from "./http.ts"
+import type { ResponseResult } from "./runtime-core.ts"
 import type { RequestSource } from "./server.ts"
 
 // The query string ("?a=1", or "" when absent) - for lazily building `c.query` only when read.
@@ -123,16 +124,21 @@ const FORM_DECODER = new TextDecoder()
  * Read an HTML-form body (urlencoded) into the plain object a body schema validates - same byte
  * cap as the JSON path (a lying/absent Content-Length can't force an oversized buffer), same
  * repeated-key -> `string[]` promotion as query parsing, same `__proto__` guard.
+ *
+ * A rejection is a `ResponseResult`, not a built `Response`, matching the JSON reader: the cap is a
+ * framework render, and answering one on the plain lane costs what a handler's plain return costs
+ * (see `plainError`). The distinction is observable on the Node adapter - a `Response` there is
+ * untagged, so its body drains through a Web stream and the answer goes out chunked.
  */
 export async function readBoundedForm(
   req: RequestSource,
   maxBytes: number,
-): Promise<Record<string, QueryValue> | Response> {
+): Promise<Record<string, QueryValue> | ResponseResult> {
   const read = await readBoundedBytes(req, maxBytes)
   if (!read.ok) {
     return read.status === 413
-      ? jsonError(413, "payload_too_large")
-      : jsonError(400, "invalid_content_length")
+      ? plainError(413, "payload_too_large")
+      : plainError(400, "invalid_content_length")
   }
   const out: Record<string, QueryValue> = Object.create(null) as Record<string, QueryValue>
   // URLSearchParams owns the format's quirks (`+` as space, percent-decoding, empty keys);

package/src/server/request-context.ts

@@ -16,9 +16,9 @@ import {
 import type { Platform } from "./context.ts"
 import { type CookieOptions, cookieNamePrefix, parseCookies, serializeCookie } from "./cookies.ts"
 import { headerObjectOf } from "./headers.ts"
-import { jsonError } from "./http.ts"
+import { plainError } from "./http.ts"
 import { guardParsedValue, type ProtoPoisoning, parseJsonGuarded } from "./proto-guard.ts"
-import { searchOf } from "./query.ts"
+import { isUrlEncodedForm, readBoundedForm, searchOf } from "./query.ts"
 import { responseJsonContentType } from "./respond.ts"
 import {
   CONTEXT_SEARCH,
@@ -27,12 +27,14 @@ import {
   getNeverAbortSignal,
   getUnboundedRequestBudget,
   headerOf,
+  isResponseResult,
   PRE_DECODED_BODY,
   type PreDecodedBody,
+  type ResponseResult,
   requestOf,
   TEXT_DECODER,
 } from "./runtime-core.ts"
-import type { CtxSet, RawContext, RequestSource } from "./server.ts"
+import type { CtxSet, MaybePromise, RawContext, RequestSource } from "./server.ts"
 
 /** A fixed past instant for cookie deletion (`Expires`). A literal epoch - deterministic, unlike an
  * argless `new Date()`. */
@@ -390,7 +392,7 @@ export class RequestContext implements RawContext {
   }
 }
 
-/** Backs `c.boundedBody`: bounded byte read that throws a flat 413/400 `Response` (caught by
+/** Backs `c.boundedBody`: bounded byte read that throws a flat 413/400 plain render (caught by
  * `runLifecycle` as control flow, like `throw redirect(...)`), so a handler can't ignore the cap.
  * The byte-cap itself lives in `./body.ts` (shared with the schema path and `verifyWebhook`). */
 async function readBoundedBodyOrThrow(
@@ -401,8 +403,8 @@ async function readBoundedBodyOrThrow(
   const r = await readBoundedBytes(req, maxBytes ?? maxBodyBytes)
   if (r.ok) return r.bytes
   throw r.status === 413
-    ? jsonError(413, "payload_too_large")
-    : jsonError(400, "invalid_content_length")
+    ? plainError(413, "payload_too_large")
+    : plainError(400, "invalid_content_length")
 }
 
 /** Backs `c.boundedJson`: `readBoundedJsonSource`, throwing its flat 400/413 on failure. */
@@ -413,7 +415,9 @@ async function readBoundedJsonBodyOrThrow<T>(
   maxBytes?: number,
 ): Promise<T> {
   const parsed = await readBoundedJsonSource(req, maxBytes ?? maxBodyBytes, protoPoisoning)
-  if (parsed instanceof Response) throw parsed
+  // The lane's own failures are the only branded values it can produce: a parsed JSON body is
+  // `JSON.parse` output, which carries string keys only and so can never answer to a symbol brand.
+  if (isResponseResult(parsed)) throw parsed
   return parsed as T
 }
 
@@ -431,7 +435,7 @@ async function readBoundedJsonBodyOrThrow<T>(
  * own promise chain instead, and only the streaming fallback - which is already doing IO in a loop
  * - runs as an async function. Callers that `await` the result are unaffected.
  */
-type JsonResultContinuation<T> = (result: unknown | Response) => T | Promise<T>
+type JsonResultContinuation<T> = (result: unknown | ResponseResult) => T | Promise<T>
 type JsonErrorContinuation<T> = (error: unknown) => T | Promise<T>
 type FramedJsonSource = RequestSource & {
   readonly bytes?: () => Promise<Uint8Array>
@@ -445,7 +449,7 @@ export function readBoundedJsonSource(
   req: RequestSource,
   maxBytes: number,
   protoPoisoning?: ProtoPoisoning,
-): Promise<unknown | Response>
+): Promise<unknown | ResponseResult>
 export function readBoundedJsonSource<T>(
   req: RequestSource,
   maxBytes: number,
@@ -459,7 +463,7 @@ export function readBoundedJsonSource<T>(
   protoPoisoning: ProtoPoisoning = "reject",
   onResult?: JsonResultContinuation<T>,
   onError?: JsonErrorContinuation<T>,
-): Promise<unknown | Response | T> {
+): Promise<unknown | ResponseResult | T> {
   // A pre-parsing hook (the transport-codec lane) may have decoded the body already - its stash
   // is taken verbatim: the stasher enforced its own byte cap and poisoning policy on text this
   // lane never sees. One symbol read; a miss on ordinary requests costs a cache-line, not a parse.
@@ -493,12 +497,12 @@ export function readBoundedJsonSource<T>(
     const length = parseContentLength(declared)
     if (length === undefined)
       return onResult === undefined
-        ? Promise.resolve(jsonError(400, "invalid_content_length"))
-        : Promise.resolve(jsonError(400, "invalid_content_length")).then(onResult)
+        ? Promise.resolve(plainError(400, "invalid_content_length"))
+        : Promise.resolve(plainError(400, "invalid_content_length")).then(onResult)
     if (length > maxBytes)
       return onResult === undefined
-        ? Promise.resolve(jsonError(413, "payload_too_large"))
-        : Promise.resolve(jsonError(413, "payload_too_large")).then(onResult)
+        ? Promise.resolve(plainError(413, "payload_too_large"))
+        : Promise.resolve(plainError(413, "payload_too_large")).then(onResult)
     // Trusted framing (Bun's native route table, Deno.serve): the runtime's HTTP parser already
     // delimited the bytes, so the declared length IS the transport frame and chunked routing is
     // moot - the over-cap 413 above already enforced the byte cap. Take the runtime's fused
@@ -514,8 +518,8 @@ export function readBoundedJsonSource<T>(
             guarded = guardParsedValue(parsed, protoPoisoning)
           } catch {
             return onResult === undefined
-              ? jsonError(400, "invalid_json")
-              : onResult(jsonError(400, "invalid_json"))
+              ? plainError(400, "invalid_json")
+              : onResult(plainError(400, "invalid_json"))
           }
           return onResult === undefined ? guarded : onResult(guarded)
         },
@@ -533,16 +537,16 @@ export function readBoundedJsonSource<T>(
           ({ value, byteLength }) => {
             if (byteLength > length || byteLength > maxBytes) {
               return onResult === undefined
-                ? jsonError(413, "payload_too_large")
-                : onResult(jsonError(413, "payload_too_large"))
+                ? plainError(413, "payload_too_large")
+                : onResult(plainError(413, "payload_too_large"))
             }
             let guarded: unknown
             try {
               guarded = guardParsedValue(value, protoPoisoning)
             } catch {
               return onResult === undefined
-                ? jsonError(400, "invalid_json")
-                : onResult(jsonError(400, "invalid_json"))
+                ? plainError(400, "invalid_json")
+                : onResult(plainError(400, "invalid_json"))
             }
             return onResult === undefined ? guarded : onResult(guarded)
           },
@@ -555,16 +559,16 @@ export function readBoundedJsonSource<T>(
           (bytes) => {
             if (bytes.byteLength > length || bytes.byteLength > maxBytes) {
               return onResult === undefined
-                ? jsonError(413, "payload_too_large")
-                : onResult(jsonError(413, "payload_too_large"))
+                ? plainError(413, "payload_too_large")
+                : onResult(plainError(413, "payload_too_large"))
             }
             try {
               const parsed = parseJsonGuarded(TEXT_DECODER.decode(bytes), protoPoisoning)
               return onResult === undefined ? parsed : onResult(parsed)
             } catch {
               return onResult === undefined
-                ? jsonError(400, "invalid_json")
-                : onResult(jsonError(400, "invalid_json"))
+                ? plainError(400, "invalid_json")
+                : onResult(plainError(400, "invalid_json"))
             }
           },
           () => (onResult === undefined ? INVALID_JSON() : onResult(INVALID_JSON())),
@@ -581,16 +585,16 @@ export function readBoundedJsonSource<T>(
           const bytes = new Uint8Array(buffer)
           if (bytes.byteLength > length || bytes.byteLength > maxBytes) {
             return onResult === undefined
-              ? jsonError(413, "payload_too_large")
-              : onResult(jsonError(413, "payload_too_large"))
+              ? plainError(413, "payload_too_large")
+              : onResult(plainError(413, "payload_too_large"))
           }
           let parsed: unknown
           try {
             parsed = parseJsonGuarded(TEXT_DECODER.decode(bytes), protoPoisoning)
           } catch {
             return onResult === undefined
-              ? jsonError(400, "invalid_json")
-              : onResult(jsonError(400, "invalid_json"))
+              ? plainError(400, "invalid_json")
+              : onResult(plainError(400, "invalid_json"))
           }
           return onResult === undefined ? parsed : onResult(parsed)
         },
@@ -605,21 +609,69 @@ export function readBoundedJsonSource<T>(
 /** The shared rejection handler for a body read that never completed (client abort, socket error,
  * malformed framing): the same flat 400 a syntactically invalid body gets. Hoisted so the framed
  * lane allocates no per-request closure for it. */
-const INVALID_JSON = (): Response => jsonError(400, "invalid_json")
+const INVALID_JSON = (): ResponseResult => plainError(400, "invalid_json")
 
 /** The chunked / length-less fallback: drain under the streaming byte cap, then parse guarded. */
 async function readStreamedJsonSource(
   raw: RequestSource,
   maxBytes: number,
   protoPoisoning: ProtoPoisoning,
-): Promise<unknown | Response> {
+): Promise<unknown | ResponseResult> {
   const body = raw.body
-  if (body === null) return jsonError(400, "invalid_json")
+  if (body === null) return plainError(400, "invalid_json")
   const drained = await drainCapped(body, maxBytes)
-  if (!drained.ok) return jsonError(413, "payload_too_large")
+  if (!drained.ok) return plainError(413, "payload_too_large")
   try {
     return parseJsonGuarded(TEXT_DECODER.decode(drained.bytes), protoPoisoning)
   } catch {
-    return jsonError(400, "invalid_json")
+    return plainError(400, "invalid_json")
+  }
+}
+
+/**
+ * The shared bounded body framing/parser: the single trust-boundary enforcement point every body
+ * lane routes through. Content-type dispatch, the urlencoded-form cap, and the JSON path
+ * (`Content-Length` pre-reject -> streaming cap -> prototype-poisoning guard, all inside
+ * `readBoundedJsonSource`) live here so the fused body runner, the generic body-only lane, and a
+ * compact edge entrypoint all enforce the same boundary from one definition. `protoPoisoning` is a
+ * parameter, not read off a server instance, so this stays free of any dependency on the class.
+ *
+ * `onParsed` receives the decoded, guard-screened value; a framing rejection (`Content-Length` over
+ * the cap, a lying length caught mid-stream, malformed JSON, an unsupported media type) is rendered
+ * through `wrapResponse`; a read that never completed (client abort, socket error) reaches `onError`.
+ */
+export function readBodyFramed<T>(
+  source: RequestSource,
+  maxBodyBytes: number,
+  protoPoisoning: ProtoPoisoning,
+  onParsed: (parsed: unknown) => MaybePromise<T>,
+  wrapResponse: (response: Response | ResponseResult) => T,
+  onError: (err: unknown) => MaybePromise<T>,
+): Promise<T> {
+  const contentType = headerOf(source, "content-type") ?? ""
+  if (contentType !== "application/json" && !contentType.includes("application/json")) {
+    if (isUrlEncodedForm(contentType)) {
+      return readBoundedForm(source, maxBodyBytes).then(
+        (form) => (isResponseResult(form) ? wrapResponse(form) : onParsed(form)),
+        onError,
+      ) as Promise<T>
+    }
+    // multipart/form-data (file uploads) stays 415 on the schema path by design - files don't fit a
+    // value schema; use a schema-less route + @nifrajs/uploads helpers for those.
+    return Promise.resolve(wrapResponse(plainError(415, "unsupported_media_type")))
+  }
+  // All JSON bodies go through readBoundedJsonSource - the single enforcement point for the framed
+  // fast path (post-read byte re-check), the streaming cap, and the prototype-poisoning guard. A
+  // separate inlined native-json() fast path here would fork the trust boundary in two.
+  try {
+    return readBoundedJsonSource(
+      source,
+      maxBodyBytes,
+      protoPoisoning,
+      (parsed) => (isResponseResult(parsed) ? wrapResponse(parsed) : onParsed(parsed)),
+      onError,
+    )
+  } catch (err) {
+    return Promise.resolve(onError(err))
   }
 }

package/src/server/respond.ts

@@ -4,11 +4,14 @@
  * spine types, so the wire-response format lives in one module distinct from the request engine.
  */
 
+import { NODE_BRIDGE_MARKER_KEYS } from "./bridge-markers.ts"
 import {
   CONTEXT_SET,
   EMPTY_RESPONSE_CONTROLS,
   type HandlerResult,
   isResponseResult,
+  type PlainRender,
+  plainRenderHeaders,
 } from "./runtime-core.ts"
 import type { CtxSet, RawContext } from "./server.ts"
 import { mergeStaticHeaderRecord, type StaticResponseHeaders } from "./static-headers.ts"
@@ -24,6 +27,16 @@ function headersInit(set: CtxSet): Record<string, string> | Headers | undefined
   return headers
 }
 
+/** The `c.set` a plain render stands for: its status and headers, carrying over the request's queued
+ * cookies so `set.cookie(...)` then an early exit still ships them. */
+function plainRenderSet(plain: PlainRender, set: CtxSet): CtxSet {
+  return {
+    status: plain.status,
+    _headers: plainRenderHeaders(plain, set),
+    _cookies: set._cookies,
+  } as CtxSet
+}
+
 // Keep the fast JSON respond path byte-identical to `Response.json` without probing it at module
 // scope: workerd forbids `Response.json()` during startup. A shared `Headers` is safe to reuse
 // across responses: the Response constructor copies `init.headers` into its own list.
@@ -178,7 +191,7 @@ function denoResponseWithJsonBody(
 // The framework-buffered-body marker shared with the Node adapter: a Response carrying it exposes
 // its already-serialized bytes without draining. On the Web serving paths it exists ONLY when a
 // registered body/raw hook needs it, so hook-less apps pay nothing.
-const RESPONSE_BODY = Symbol.for("nifra.response.body")
+const RESPONSE_BODY = Symbol.for(NODE_BRIDGE_MARKER_KEYS.responseBody)
 
 /**
  * Headers objects the framework itself constructed - guaranteed mutable, no guard. Response
@@ -396,6 +409,18 @@ export function toResponse(
   statics?: StaticResponseHeaders,
 ): Response {
   if (isResponseResult(result)) {
+    const plain = result.plain
+    if (plain !== undefined) {
+      // Rendered as the value it is, on the branches below, rather than through `toResponse()`: the
+      // status and headers fold into a `set` and the body takes the ordinary JSON lane. One level
+      // only - a plain render's body is a user value, never another response carrier.
+      return toResponse(
+        plain.body as HandlerResult,
+        plainRenderSet(plain, set),
+        tagResponseBody,
+        statics,
+      )
+    }
     return withStatics(
       appendCookiesToResponse(normalizeBodylessResponse(result.toResponse()), set),
       statics,

package/src/server/response-contract-lane.ts

@@ -48,6 +48,7 @@ import {
 } from "../schema/standard.ts"
 import { INSTALL_RESPONSE_CONTRACT } from "./install.ts"
 import type { IdentityPlugin } from "./plugin.ts"
+import { isResponseResult } from "./runtime-core.ts"
 import type { AnyServer } from "./server.ts"
 
 /**
@@ -91,8 +92,11 @@ export function checkResponseContract(
   mode: "warn" | "enforce",
 ): ResponseContractOutcome | Promise<ResponseContractOutcome> {
   // A handler may return a raw Response as deliberate control flow (a redirect, a stream). There is no
-  // JSON payload to hold to the contract, and re-serializing one would corrupt it.
-  if (result instanceof Response || result === undefined) return { kind: "ok", value: result }
+  // JSON payload to hold to the contract, and re-serializing one would corrupt it. A `status(...)` is
+  // the same control flow in plain-data form: the contract describes the route's SUCCESS payload, so
+  // holding an early exit (a 401 body, say) to it would fail every guarded route that declares one.
+  if (result instanceof Response || result === undefined || isResponseResult(result))
+    return { kind: "ok", value: result }
   const settled = schema["~standard"].validate(result)
   return settled instanceof Promise
     ? settled.then((r) => interpret(r, result, mode))

package/src/server/response-observer-runtime.ts

@@ -0,0 +1,135 @@
+import type {
+  NodeRequestContext,
+  NodeResponseHook,
+  ResponseBodyHook,
+  ResponseHeadersHook,
+  ResponseHeadersView,
+} from "./node-outcome-hook.ts"
+import { recordHeadersView } from "./node-outcome-hook.ts"
+import { knownMutableHeaders, rememberMutableHeaders, taggedResponseBody } from "./respond.ts"
+import { applyBodyReplacement, withReplacedBody } from "./response-hooks.ts"
+
+type MaybePromise<T> = T | Promise<T>
+type WebResponseHook = (response: Response, req: Request) => MaybePromise<Response>
+
+export type { ResponseBodyHook, ResponseHeadersHook } from "./node-outcome-hook.ts"
+
+export interface ResponseObserverHost {
+  assertConfigurable(operation: string): void
+  addResponseHook(web: WebResponseHook, node: NodeResponseHook | undefined): void
+  enableResponseBodyTagging(): object
+  responseBodyOwners(): ReadonlySet<object>
+}
+
+export interface ResponseObserverMethods {
+  onResponseHeaders(fn: ResponseHeadersHook): this
+  onResponseBody(fn: ResponseBodyHook): this
+  onResponseRaw(fn: (response: Response, req: Request) => MaybePromise<Response>): this
+}
+
+export interface ResponseObserverRuntime {
+  install(host: ResponseObserverHost): ResponseObserverMethods
+}
+
+const HEADER_MUTABILITY_PROBE = "x-nifra-header-probe"
+const GUARDED_RESPONSE_HEADERS = new WeakSet<Headers>()
+
+function hasMutableResponseHeaders(headers: Headers): boolean {
+  if (knownMutableHeaders(headers)) return true
+  if (GUARDED_RESPONSE_HEADERS.has(headers)) return false
+  let previous: string | null = null
+  try {
+    previous = headers.get(HEADER_MUTABILITY_PROBE)
+    headers.set(HEADER_MUTABILITY_PROBE, "1")
+    if (previous === null) headers.delete(HEADER_MUTABILITY_PROBE)
+    else headers.set(HEADER_MUTABILITY_PROBE, previous)
+    rememberMutableHeaders(headers)
+    return true
+  } catch {
+    try {
+      if (previous === null) headers.delete(HEADER_MUTABILITY_PROBE)
+      else headers.set(HEADER_MUTABILITY_PROBE, previous)
+    } catch {
+      // A guarded response rejected the probe and the clone path is authoritative.
+    }
+    GUARDED_RESPONSE_HEADERS.add(headers)
+    return false
+  }
+}
+
+function webRequestView(req: Request): NodeRequestContext {
+  return { method: req.method, url: req.url, header: (name) => req.headers.get(name) }
+}
+
+function webHeadersView(
+  response: Response,
+  req: Request,
+): {
+  readonly response: Response
+  readonly headers: ResponseHeadersView
+  readonly request: NodeRequestContext
+} {
+  const request = webRequestView(req)
+  if (!hasMutableResponseHeaders(response.headers)) {
+    const clone = new Response(response.body, response)
+    return { response: clone, headers: clone.headers, request }
+  }
+  return { response, headers: response.headers, request }
+}
+
+export function createResponseObserverRuntime(): ResponseObserverRuntime {
+  return {
+    install(host) {
+      return {
+        onResponseHeaders(this: ResponseObserverMethods, fn): ResponseObserverMethods {
+          host.assertConfigurable("onResponseHeaders()")
+          host.addResponseHook(
+            (response, req) => {
+              const view = webHeadersView(response, req)
+              const out = fn(view.headers, view.request, response.status)
+              return out instanceof Promise ? out.then(() => view.response) : view.response
+            },
+            (response, req) => fn(recordHeadersView(response), req, response.status),
+          )
+          return this
+        },
+        onResponseBody(this: ResponseObserverMethods, fn): ResponseObserverMethods {
+          host.assertConfigurable("onResponseBody()")
+          host.enableResponseBodyTagging()
+          host.addResponseHook(
+            (response, req) => {
+              const body = taggedResponseBody(response, host.responseBodyOwners())
+              if (body === undefined) return response
+              const view = webHeadersView(response, req)
+              const out = fn(body, view.headers, view.request, response.status)
+              return out instanceof Promise
+                ? out.then((replaced) => withReplacedBody(response, replaced))
+                : withReplacedBody(response, out)
+            },
+            (response, req) => {
+              if (response.body === null) return undefined
+              const out = fn(response.body, recordHeadersView(response), req, response.status)
+              if (out instanceof Promise)
+                return out.then((replaced) => applyBodyReplacement(response, replaced))
+              applyBodyReplacement(response, out)
+              return undefined
+            },
+          )
+          return this
+        },
+        onResponseRaw(this: ResponseObserverMethods, fn): ResponseObserverMethods {
+          host.assertConfigurable("onResponseRaw()")
+          host.enableResponseBodyTagging()
+          host.addResponseHook(
+            (response, req) =>
+              taggedResponseBody(response, host.responseBodyOwners()) === undefined
+                ? fn(response, req)
+                : response,
+            () => undefined,
+          )
+          return this
+        },
+      }
+    },
+  }
+}