@nifrajs/core 2.14.1 → 3.2.0

package/src/internal/route-lanes.ts

@@ -0,0 +1,221 @@
+/**
+ * Registration-time route-lane selection.
+ *
+ * A route's lane is a property of its registered shape, not of an individual request. Keeping this
+ * decision in a small internal module gives the server kernel one vocabulary for bare/body/query/
+ * lifecycle execution while preserving the important invariant: this module is never called from the
+ * request path. The returned booleans are consumed by the existing compiled execution plan and fused
+ * builders; no adapter or extra dispatch hop is introduced at runtime.
+ */
+import type { RouteSchema } from "../server/context.ts"
+import type { LifecycleExecutionLane, RouteExecutionLane } from "./route-execution.ts"
+
+export interface RouteLaneSelection {
+  readonly bare: boolean
+  readonly fusedQuery: boolean
+  readonly bodyOnly: boolean
+  readonly fusedBody: boolean
+  readonly lane: RouteExecutionLane
+  readonly lifecycleLane: LifecycleExecutionLane
+  readonly lifecycleHookLane: "derive-before" | "derive-before-after" | undefined
+  readonly fusedLane:
+    | "bare"
+    | "body"
+    | "query"
+    | "derive-before"
+    | "derive-before-after"
+    | "body-derive-before"
+    | "body-derive-before-after"
+    | undefined
+}
+
+export function selectRouteLanes(options: {
+  readonly schema: RouteSchema | undefined
+  readonly hasIdempotency: boolean
+  readonly hasLedger: boolean
+  readonly hasResponseContract: boolean
+  readonly hasDecorations: boolean
+  readonly derives: number
+  readonly beforeHandle: number
+  readonly afterHandle: number
+  readonly onError: number
+  readonly around: number
+  readonly defaultOnValidationError: boolean
+}): RouteLaneSelection {
+  const {
+    schema,
+    hasIdempotency,
+    hasLedger,
+    hasResponseContract,
+    hasDecorations,
+    derives,
+    beforeHandle,
+    afterHandle,
+    onError,
+    around,
+    defaultOnValidationError,
+  } = options
+
+  const bare =
+    schema?.params === undefined &&
+    schema?.headers === undefined &&
+    schema?.body === undefined &&
+    schema?.query === undefined &&
+    !hasIdempotency &&
+    !hasLedger &&
+    !hasResponseContract &&
+    derives === 0 &&
+    beforeHandle === 0 &&
+    afterHandle === 0 &&
+    onError === 0
+
+  // A route whose ONLY lifecycle step is a query schema can fuse too: the parse + validate + handler +
+  // respond collapse into one closure with no lifecycle promise on the sync path. The guards mirror the
+  // query lane below PLUS everything the fused dispatch skips: around hooks, the idempotency/ledger
+  // wrappers, and validation-error recovery (schema or server default) - the fused invalid path is
+  // exactly `validationError(issues)`, so any recovery semantics keep the generic lane.
+  const fusedQuery =
+    !bare &&
+    !hasResponseContract &&
+    schema?.query !== undefined &&
+    schema.body === undefined &&
+    schema.params === undefined &&
+    schema.headers === undefined &&
+    schema.onValidationError === undefined &&
+    !defaultOnValidationError &&
+    !hasIdempotency &&
+    !hasLedger &&
+    derives === 0 &&
+    beforeHandle === 0 &&
+    afterHandle === 0 &&
+    onError === 0 &&
+    around === 0
+
+  const bodyOnly =
+    !hasResponseContract &&
+    schema?.body !== undefined &&
+    schema.query === undefined &&
+    schema.params === undefined &&
+    schema.headers === undefined &&
+    derives === 0 &&
+    beforeHandle === 0 &&
+    afterHandle === 0 &&
+    onError === 0
+
+  const fusedBody =
+    !bare &&
+    bodyOnly &&
+    schema.onValidationError === undefined &&
+    !defaultOnValidationError &&
+    !hasIdempotency &&
+    !hasLedger &&
+    around === 0
+
+  const lane: RouteExecutionLane = bare
+    ? "bare"
+    : bodyOnly
+      ? "body"
+      : !hasResponseContract &&
+          schema?.body === undefined &&
+          schema?.query !== undefined &&
+          schema.params === undefined &&
+          schema.headers === undefined &&
+          derives === 0 &&
+          beforeHandle === 0 &&
+          afterHandle === 0 &&
+          onError === 0
+        ? "query"
+        : "lifecycle"
+
+  // Lifecycle routes with no params schema are the common middleware shape: derive/before plus an
+  // optional query or body schema. Select their complete validation stage at registration so the
+  // request path never re-checks params/body presence. Parameter-schema routes retain the generic
+  // lifecycle runner until their more involved recovery matrix is selected explicitly.
+  const lifecycleLane: LifecycleExecutionLane =
+    lane !== "lifecycle" || schema?.params !== undefined || schema?.headers !== undefined
+      ? undefined
+      : schema?.body !== undefined
+        ? schema.query !== undefined
+          ? "body-query"
+          : "body"
+        : schema?.query !== undefined
+          ? "query"
+          : "hooks"
+
+  // The realistic middleware shape is commonly exactly one synchronous-or-async derive followed by
+  // one before hook. Keep the generic runner for every route that can observe decorations, after hooks,
+  // error hooks, or response contracts; this lane only removes the two per-request hook-loop dispatches
+  // and preserves the same async continuations and error handling. A params or headers schema routes
+  // back to the generic lane because the fused builder has no `params` / `headers` validation step
+  // baked in - adding them would be more code than it saves. A `body` schema is the same story
+  // because the fused derive-before / derive-before-after builders don't parse the body: routes with a
+  // body schema are routed to the `body-derive-before` / `body-derive-before-after` lane below.
+  const lifecycleHookLane =
+    lane === "lifecycle" &&
+    !hasResponseContract &&
+    !hasDecorations &&
+    !hasIdempotency &&
+    !hasLedger &&
+    schema?.onValidationError === undefined &&
+    !defaultOnValidationError &&
+    schema?.params === undefined &&
+    schema?.headers === undefined &&
+    schema?.body === undefined &&
+    derives === 1 &&
+    beforeHandle === 1 &&
+    afterHandle <= 1 &&
+    onError === 0 &&
+    around === 0
+      ? afterHandle === 0
+        ? "derive-before"
+        : "derive-before-after"
+      : undefined
+
+  // Body + lifecycle hooks in a closed shape: a body schema plus the same 1-derive + 1-before +
+  // 0-or-1-after + 0-onError shape, with no other body/query/path conflict. The fused closure runs
+  // parse → validate → derive → before → handler → after → respond in one function frame, the same
+  // win `fusedBody` already gives for the no-hooks body shape.
+  const fusedBodyLifecycle =
+    lane === "lifecycle" &&
+    schema?.body !== undefined &&
+    schema?.query === undefined &&
+    schema?.params === undefined &&
+    schema?.headers === undefined &&
+    schema?.onValidationError === undefined &&
+    !defaultOnValidationError &&
+    !hasResponseContract &&
+    !hasDecorations &&
+    !hasIdempotency &&
+    !hasLedger &&
+    derives === 1 &&
+    beforeHandle === 1 &&
+    afterHandle <= 1 &&
+    onError === 0 &&
+    around === 0
+
+  return {
+    bare,
+    fusedQuery,
+    bodyOnly,
+    fusedBody,
+    lane,
+    lifecycleLane,
+    lifecycleHookLane,
+    fusedLane:
+      around === 0
+        ? fusedQuery
+          ? "query"
+          : fusedBody
+            ? "body"
+            : bare
+              ? "bare"
+              : lifecycleHookLane !== undefined
+                ? (lifecycleHookLane as "derive-before" | "derive-before-after")
+                : fusedBodyLifecycle
+                  ? afterHandle === 0
+                    ? "body-derive-before"
+                    : "body-derive-before-after"
+                  : undefined
+        : undefined,
+  }
+}

package/src/internal/route-program.ts

@@ -0,0 +1,404 @@
+/**
+ * Registration-compiled general route program.
+ *
+ * This is deliberately a data-and-control-flow compiler, not source generation: user functions and
+ * schemas remain opaque references and no request value is ever converted into executable code. The
+ * program is frozen at registration so the request path walks one immutable stage sequence instead
+ * of rediscovering which lifecycle features are present.
+ */
+
+import type { StandardSchemaV1 } from "../schema/standard.ts"
+import type { Registry } from "../server/registry.ts"
+import {
+  CONTEXT_SET,
+  EMPTY_RESPONSE_CONTROLS,
+  isResponseResult,
+  type ResponseResult,
+} from "../server/runtime-core.ts"
+import type { CtxSet, MaybePromise, RawContext, RequestSource, Server } from "../server/server.ts"
+import type {
+  InternalHandler,
+  RawAfterHandle,
+  RawBeforeHandle,
+  RawDerive,
+  RawErrorHandler,
+  RouteEntry,
+} from "./route-execution.ts"
+
+export type ProgramValidationKind = "headers" | "params" | "body" | "query"
+
+export type RouteProgramStage =
+  | { readonly kind: ProgramValidationKind; readonly schema: StandardSchemaV1 }
+  | { readonly kind: "derive"; readonly run: RawDerive }
+  | { readonly kind: "before"; readonly run: RawBeforeHandle }
+  | { readonly kind: "handler"; readonly run: InternalHandler }
+  | { readonly kind: "after"; readonly run: RawAfterHandle }
+
+/** The complete registration-time lifecycle, in semantic execution order. */
+export interface RouteProgram {
+  readonly stages: readonly RouteProgramStage[]
+  readonly validationStages: readonly Extract<RouteProgramStage, { kind: ProgramValidationKind }>[]
+  readonly derives: readonly RawDerive[]
+  readonly beforeHandle: readonly RawBeforeHandle[]
+  readonly afterHandle: readonly RawAfterHandle[]
+  readonly onError: readonly RawErrorHandler[]
+  readonly handler: InternalHandler
+  readonly decorations: Record<PropertyKey, unknown>
+  readonly hasDecorations: boolean
+  readonly bodySchema: StandardSchemaV1 | undefined
+  readonly bodyLimit: RouteEntry["bodyLimit"]
+  readonly responseContract: RouteEntry["responseContract"]
+}
+
+export interface RouteProgramInput {
+  readonly schema: RouteEntry["schema"]
+  readonly handler: InternalHandler
+  readonly derives: readonly RawDerive[]
+  readonly beforeHandle: readonly RawBeforeHandle[]
+  readonly afterHandle: readonly RawAfterHandle[]
+  readonly onError: readonly RawErrorHandler[]
+  readonly decorations: Record<PropertyKey, unknown>
+  readonly hasDecorations: boolean
+  readonly bodySchema: StandardSchemaV1 | undefined
+  readonly bodyLimit: RouteEntry["bodyLimit"]
+  readonly responseContract: RouteEntry["responseContract"]
+}
+
+/** Build the immutable stage sequence once, while the server is still configurable. */
+export function compileRouteProgram(input: RouteProgramInput): RouteProgram {
+  const stages: RouteProgramStage[] = []
+  const validationStages: Extract<RouteProgramStage, { kind: ProgramValidationKind }>[] = []
+  const schema = input.schema
+  if (schema?.headers !== undefined) {
+    const stage = { kind: "headers", schema: schema.headers } as const
+    stages.push(stage)
+    validationStages.push(stage)
+  }
+  if (schema?.params !== undefined) {
+    const stage = { kind: "params", schema: schema.params } as const
+    stages.push(stage)
+    validationStages.push(stage)
+  }
+  if (schema?.body !== undefined) {
+    const stage = { kind: "body", schema: schema.body } as const
+    stages.push(stage)
+    validationStages.push(stage)
+  }
+  if (schema?.query !== undefined) {
+    const stage = { kind: "query", schema: schema.query } as const
+    stages.push(stage)
+    validationStages.push(stage)
+  }
+  for (const derive of input.derives) stages.push({ kind: "derive", run: derive })
+  for (const before of input.beforeHandle) stages.push({ kind: "before", run: before })
+  stages.push({ kind: "handler", run: input.handler })
+  for (const after of input.afterHandle) stages.push({ kind: "after", run: after })
+
+  return Object.freeze({
+    stages: Object.freeze(stages),
+    validationStages: Object.freeze(validationStages),
+    derives: Object.freeze([...input.derives]),
+    beforeHandle: Object.freeze([...input.beforeHandle]),
+    afterHandle: Object.freeze([...input.afterHandle]),
+    onError: Object.freeze([...input.onError]),
+    handler: input.handler,
+    decorations: Object.freeze({ ...input.decorations }),
+    hasDecorations: input.hasDecorations,
+    bodySchema: input.bodySchema,
+    bodyLimit: input.bodyLimit,
+    responseContract: input.responseContract,
+  })
+}
+
+interface RouteProgramRuntime {
+  validateProgramStage(
+    entry: RouteEntry,
+    stage: Extract<RouteProgramStage, { kind: ProgramValidationKind }>,
+    source: RequestSource,
+    ctx: RawContext,
+  ): MaybePromise<Response | ResponseResult | undefined>
+  readProgramBody(
+    entry: RouteEntry,
+    source: RequestSource,
+    ctx: RawContext,
+  ): Promise<Response | ResponseResult | undefined>
+  handleProgramError<T>(
+    entry: RouteEntry,
+    error: unknown,
+    ctx: RawContext,
+    finalize: (result: unknown, set: CtxSet) => T,
+    wrapResponse: (response: Response | ResponseResult) => T,
+  ): MaybePromise<T>
+  finishProgramResult<T>(
+    entry: RouteEntry,
+    ctx: RawContext,
+    result: unknown,
+    finalize: (result: unknown, set: CtxSet) => T,
+    wrapResponse: (response: Response | ResponseResult) => T,
+  ): MaybePromise<T>
+}
+
+function responseSet(ctx: RawContext): CtxSet {
+  return ctx[CONTEXT_SET]() ?? EMPTY_RESPONSE_CONTROLS
+}
+
+function isEarly(value: unknown): value is Response | ResponseResult {
+  return value instanceof Response || isResponseResult(value)
+}
+
+type ProgramResult<T> = MaybePromise<T>
+
+type PendingPhase =
+  | { readonly kind: "validation"; readonly next: number }
+  | { readonly kind: "derive"; readonly next: number }
+  | { readonly kind: "before"; readonly next: number }
+  | { readonly kind: "handler" }
+  | { readonly kind: "after"; readonly next: number }
+
+/** Execute the general program. The first synchronous stage sequence stays synchronous. */
+export function executeRouteProgram<T, R extends Registry, Ctx>(
+  runtime: Server<R, Ctx>,
+  entry: RouteEntry,
+  program: RouteProgram,
+  source: RequestSource,
+  ctx: RawContext,
+  finalize: (result: unknown, set: CtxSet) => T,
+  wrapResponse: (response: Response | ResponseResult) => T,
+): ProgramResult<T> {
+  const host = runtime as unknown as RouteProgramRuntime
+  try {
+    if (program.hasDecorations) Object.assign(ctx, program.decorations)
+    return runSync(host, entry, program, source, ctx, finalize, wrapResponse, 0, undefined)
+  } catch (error) {
+    return host.handleProgramError(entry, error, ctx, finalize, wrapResponse)
+  }
+}
+
+function runSync<T>(
+  host: RouteProgramRuntime,
+  entry: RouteEntry,
+  program: RouteProgram,
+  source: RequestSource,
+  ctx: RawContext,
+  finalize: (result: unknown, set: CtxSet) => T,
+  wrapResponse: (response: Response | ResponseResult) => T,
+  validationIndex: number,
+  initial: unknown,
+): ProgramResult<T> {
+  const validations = program.validationStages
+  for (let i = validationIndex; i < validations.length; i++) {
+    const stage = validations[i]!
+    const outcome =
+      stage.kind === "body"
+        ? host.readProgramBody(entry, source, ctx)
+        : host.validateProgramStage(entry, stage, source, ctx)
+    if (outcome instanceof Promise) {
+      return continueProgram(
+        host,
+        entry,
+        program,
+        source,
+        ctx,
+        finalize,
+        wrapResponse,
+        { kind: "validation", next: i + 1 },
+        outcome,
+        initial,
+      )
+    }
+    if (outcome !== undefined) return wrapResponse(outcome)
+  }
+  return runHooksSync(host, entry, program, source, ctx, finalize, wrapResponse, 0, 0, 0, initial)
+}
+
+function runHooksSync<T>(
+  host: RouteProgramRuntime,
+  entry: RouteEntry,
+  program: RouteProgram,
+  source: RequestSource,
+  ctx: RawContext,
+  finalize: (result: unknown, set: CtxSet) => T,
+  wrapResponse: (response: Response | ResponseResult) => T,
+  deriveIndex: number,
+  beforeIndex: number,
+  afterIndex: number,
+  initial: unknown,
+): ProgramResult<T> {
+  for (let i = deriveIndex; i < program.derives.length; i++) {
+    const outcome = program.derives[i]!(ctx)
+    if (outcome instanceof Promise) {
+      return continueProgram(
+        host,
+        entry,
+        program,
+        source,
+        ctx,
+        finalize,
+        wrapResponse,
+        { kind: "derive", next: i + 1 },
+        outcome,
+        initial,
+      )
+    }
+    if (isEarly(outcome)) return finalize(outcome, responseSet(ctx))
+    Object.assign(ctx, outcome)
+  }
+  for (let i = beforeIndex; i < program.beforeHandle.length; i++) {
+    const outcome = program.beforeHandle[i]!(ctx)
+    if (outcome instanceof Promise) {
+      return continueProgram(
+        host,
+        entry,
+        program,
+        source,
+        ctx,
+        finalize,
+        wrapResponse,
+        { kind: "before", next: i + 1 },
+        outcome,
+        initial,
+      )
+    }
+    if (outcome !== undefined) return finalize(outcome, responseSet(ctx))
+  }
+
+  const output = program.handler(ctx)
+  if (output instanceof Promise) {
+    return continueProgram(
+      host,
+      entry,
+      program,
+      source,
+      ctx,
+      finalize,
+      wrapResponse,
+      { kind: "handler" },
+      output,
+      initial,
+    )
+  }
+  let result = output
+  for (let i = afterIndex; i < program.afterHandle.length; i++) {
+    const outcome = program.afterHandle[i]!(result, ctx)
+    if (outcome instanceof Promise) {
+      return continueProgram(
+        host,
+        entry,
+        program,
+        source,
+        ctx,
+        finalize,
+        wrapResponse,
+        { kind: "after", next: i + 1 },
+        outcome,
+        result,
+      )
+    }
+    result = outcome
+  }
+  return host.finishProgramResult(entry, ctx, result, finalize, wrapResponse)
+}
+
+async function continueProgram<T>(
+  host: RouteProgramRuntime,
+  entry: RouteEntry,
+  program: RouteProgram,
+  source: RequestSource,
+  ctx: RawContext,
+  finalize: (result: unknown, set: CtxSet) => T,
+  wrapResponse: (response: Response | ResponseResult) => T,
+  pendingPhase: PendingPhase,
+  pending: Promise<unknown>,
+  initial: unknown,
+): Promise<T> {
+  try {
+    const settled = await pending
+    let result = initial
+    if (pendingPhase.kind === "validation") {
+      if (settled !== undefined) return wrapResponse(settled as Response | ResponseResult)
+    } else if (pendingPhase.kind === "derive") {
+      if (isEarly(settled)) return finalize(settled, responseSet(ctx))
+      Object.assign(ctx, settled)
+    } else if (pendingPhase.kind === "before") {
+      if (settled !== undefined) return finalize(settled, responseSet(ctx))
+    } else if (pendingPhase.kind === "handler") {
+      result = settled
+    } else {
+      result = settled
+    }
+    return await runAsyncStages(
+      host,
+      entry,
+      program,
+      source,
+      ctx,
+      finalize,
+      wrapResponse,
+      pendingPhase,
+      result,
+    )
+  } catch (error) {
+    return await host.handleProgramError(entry, error, ctx, finalize, wrapResponse)
+  }
+}
+
+async function runAsyncStages<T>(
+  host: RouteProgramRuntime,
+  entry: RouteEntry,
+  program: RouteProgram,
+  source: RequestSource,
+  ctx: RawContext,
+  finalize: (result: unknown, set: CtxSet) => T,
+  wrapResponse: (response: Response | ResponseResult) => T,
+  pendingPhase: PendingPhase,
+  result: unknown,
+): Promise<T> {
+  try {
+    if (pendingPhase.kind === "validation") {
+      const validations = program.validationStages
+      for (let i = pendingPhase.next; i < validations.length; i++) {
+        const stage = validations[i]!
+        const outcome =
+          stage.kind === "body"
+            ? await host.readProgramBody(entry, source, ctx)
+            : host.validateProgramStage(entry, stage, source, ctx)
+        const settled = outcome instanceof Promise ? await outcome : outcome
+        if (settled !== undefined) return wrapResponse(settled)
+      }
+    }
+
+    const deriveStart = pendingPhase.kind === "derive" ? pendingPhase.next : 0
+    if (pendingPhase.kind === "validation" || pendingPhase.kind === "derive") {
+      for (let i = deriveStart; i < program.derives.length; i++) {
+        const outcome = program.derives[i]!(ctx)
+        const settled = outcome instanceof Promise ? await outcome : outcome
+        if (isEarly(settled)) return finalize(settled, responseSet(ctx))
+        Object.assign(ctx, settled)
+      }
+    }
+
+    const beforeStart = pendingPhase.kind === "before" ? pendingPhase.next : 0
+    if (
+      pendingPhase.kind === "validation" ||
+      pendingPhase.kind === "derive" ||
+      pendingPhase.kind === "before"
+    ) {
+      for (let i = beforeStart; i < program.beforeHandle.length; i++) {
+        const outcome = program.beforeHandle[i]!(ctx)
+        const settled = outcome instanceof Promise ? await outcome : outcome
+        if (settled !== undefined) return finalize(settled, responseSet(ctx))
+      }
+      const output = program.handler(ctx)
+      result = output instanceof Promise ? await output : output
+    }
+
+    const afterStart = pendingPhase.kind === "after" ? pendingPhase.next : 0
+    for (let i = afterStart; i < program.afterHandle.length; i++) {
+      const outcome = program.afterHandle[i]!(result, ctx)
+      result = outcome instanceof Promise ? await outcome : outcome
+    }
+    return await host.finishProgramResult(entry, ctx, result, finalize, wrapResponse)
+  } catch (error) {
+    return await host.handleProgramError(entry, error, ctx, finalize, wrapResponse)
+  }
+}

package/src/response-observer.ts

@@ -0,0 +1,64 @@
+import { INSTALL_RESPONSE_OBSERVER } from "./server/install.ts"
+import {
+  createResponseObserverRuntime,
+  type ResponseObserverRuntime,
+} from "./server/response-observer-runtime.ts"
+import type { AnyServer } from "./server/server.ts"
+
+export type {
+  ResponseBodyHook,
+  ResponseHeadersHook,
+  ResponseObserverMethods,
+  ResponseObserverRuntime,
+} from "./server/response-observer-runtime.ts"
+
+/** A server shape with the opt-in response observation methods installed. */
+export type ResponseObserverServer<S extends AnyServer> = S &
+  import("./server/response-observer-runtime.ts").ResponseObserverMethods
+
+/** A plugin that enables response header, body, and raw-response observation methods. */
+export type ResponseObserverPlugin = (<S extends AnyServer>(
+  app: S,
+) => ResponseObserverServer<S>) & { readonly pluginName?: string }
+
+/**
+ * Enable the response observation methods on a server.
+ *
+ * The default server does not carry the header, body, or raw-response observation adapters. Apply
+ * this plugin before using those methods:
+ *
+ * ```ts
+ * import { responseObserver } from "@nifrajs/core/response-observer"
+ * const app = server().use(responseObserver()).onResponseHeaders((headers) => {
+ *   headers.set("cache-control", "no-store")
+ * })
+ * ```
+ */
+export function responseObserver(): ResponseObserverPlugin {
+  const apply = <S extends AnyServer>(app: S): ResponseObserverServer<S> => {
+    const install = (app as unknown as Record<symbol, unknown>)[INSTALL_RESPONSE_OBSERVER]
+    if (typeof install !== "function") {
+      throw new TypeError("[nifra] responseObserver() requires a compatible Server")
+    }
+    const methods = (install as (runtime: ResponseObserverRuntime) => unknown).call(
+      app,
+      createResponseObserverRuntime(),
+    )
+    if (methods === null || typeof methods !== "object") {
+      throw new TypeError("[nifra] responseObserver() failed to install its methods")
+    }
+    Object.assign(app, methods)
+    return app as ResponseObserverServer<S>
+  }
+  return Object.assign(apply, { pluginName: "nifra:response-observer" })
+}
+
+/** Attach the opt-in observer runtime to a middleware bundle that uses response observation. */
+export function withResponseObserver<T extends object>(middleware: T): T {
+  Object.defineProperty(middleware, INSTALL_RESPONSE_OBSERVER, {
+    value: createResponseObserverRuntime(),
+    enumerable: false,
+    configurable: false,
+  })
+  return middleware
+}