castrum 0.9.0 → 0.9.2

package/src/ingress/routes/read.ts

@@ -2,8 +2,7 @@
 
 import type { BakedContext, OptimizedIngressHandler } from '../types'
 import type { BakedIngressResult } from '../decode/baked-result'
-import { resolveIp, type BakedHandlerOptions } from './common'
-import { secondsFromMs } from '../shared'
+import { buildSuccessInit, runBaked, type BakedHandlerOptions } from './common'
 
 /**
  * Pre-baked GET read handler: returns the ingress body JSON on success.
@@ -25,21 +24,12 @@ export function readHandler(
       return ingress.internalErrorResponse(ctx, result)
     }
 
-    const init: ResponseInit = {
-      status: 200,
-      headers: ingress.responseHeaders(
-        result.headerVariant,
-        ctx.requestIdHeader,
-        ctx.origin,
-        result.rateRemaining,
-        result.rateResetMs > 0 ? secondsFromMs(result.rateResetMs) : undefined,
-      ),
-    }
+    const init = buildSuccessInit(ingress, result, ctx)
 
     return copyBody
       ? new Response(result.bodyJson(true), init)
       : ingress.zeroCopyResponse(result, ctx, init)
   }
 
-  return (req, srv) => ingress.run<Response>(req, resolveIp(req, srv, opts), null, respond)
+  return runBaked(ingress, opts, respond)
 }

package/src/ingress/routes/responder.ts

@@ -0,0 +1,159 @@
+// src/ingress/routes/responder.ts — JS responder bridge over the native
+// pipeline ("native decides, JS formats the 2xx").
+//
+// The responder bridge is the castrum foundation for delegating a WHOLE
+// request to the per-route native `IngressInner` while keeping the 2xx body in
+// JS: the native pipeline runs parse/validate/CORS/rate-limit/limits and either
+// produces a terminal (rejection) response — in the configured envelope style —
+// or hands a decoded snapshot to a `NativeResponder` that builds the 2xx.
+//
+// The sync/async boundary is deliberate: `OptimizedIngressHandler.run()` is
+// SYNC-only (`assertSyncCallback` rejects thenables), so the factory captures
+// the decoded snapshot (requestId/query/cookies/body/verdicts) INSIDE the sync
+// callback and calls the async `responder` OUTSIDE it, after the pooled output
+// buffer has been released. `result.body` is the caller-provided request body
+// (never the pooled output buffer), so the snapshot's `body` is safe to hold.
+
+import { decoder } from '../../shared/bytes'
+import { generateRequestId } from '../../shared/request-id'
+import { readBodyWithLimit } from '../body'
+import type { BakedIngressResult } from '../decode/baked-result'
+import { errorCodeName, errorMessage } from '../errors'
+import type { RouteHandler } from '../server'
+import { DEFAULT_BODY_TIMEOUT_MS, DEFAULT_MAX_BODY_BYTES } from '../shared'
+import { safeTerminalStatus } from '../status'
+import type {
+  BakedContext,
+  NativeRequestContext,
+  NativeResponder,
+  OptimizedIngressHandler,
+  TerminalStyle,
+} from '../types'
+import { type BakedHandlerOptions, resolveIp } from './common'
+
+/** Options for {@link nativeResponderRoute}. */
+export interface ResponderRouteOptions extends BakedHandlerOptions {
+  /** Terminal envelope style. Default: `'castrum'` (the pre-baked wire). */
+  terminalStyle?: TerminalStyle
+  /**
+   * Read the request body and pass it to the native pipeline for validation
+   * (`requireJsonBody`/schema). Default `false` — the framework owns the body
+   * (the responder reads it via `ctx.body`); native only needs the bytes when
+   * a body stage is enabled in the route's `IngressHandlerOptions`.
+   */
+  readBody?: boolean
+}
+
+/** ignex framework security posture for terminal responses. */
+const IGNGEX_SECURITY_HEADERS: [string, string][] = [
+  ['x-frame-options', 'DENY'],
+  ['x-content-type-options', 'nosniff'],
+  ['referrer-policy', 'no-referrer'],
+]
+
+/** Build the ignex-framework terminal envelope (`{error,status,code}` + security headers). */
+function buildIgngexTerminal(result: BakedIngressResult, _ctx: BakedContext): Response {
+  const preflightAllowed = result.isPreflight && result.corsAllowed
+  if (preflightAllowed) {
+    return new Response(null, { status: 204, headers: IGNGEX_SECURITY_HEADERS })
+  }
+  const status = safeTerminalStatus(result)
+  const body = JSON.stringify({
+    error: errorMessage(status, result.errorCode),
+    status,
+    code: errorCodeName(result.errorCode),
+  })
+  const headers = new Headers(IGNGEX_SECURITY_HEADERS)
+  headers.set('content-type', 'application/json; charset=utf-8')
+  return new Response(body, { status, headers })
+}
+
+/** Parse a `queryJson()`/`cookiesJson()` section into an object (empty on failure). */
+function parseSection(json: string): Record<string, unknown> {
+  try {
+    const v: unknown = JSON.parse(json)
+    return v !== null && typeof v === 'object' && !Array.isArray(v)
+      ? (v as Record<string, unknown>)
+      : {}
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Build a responder route: native pipeline decides + rejects (terminal
+ * response in the chosen style); on success the JS `responder` builds the 2xx.
+ * Returns an async `RouteHandler` (`(req, srv?, params?) => Promise<Response>`).
+ */
+export function nativeResponderRoute(
+  ingress: OptimizedIngressHandler,
+  responder: NativeResponder,
+  opts: ResponderRouteOptions = {},
+): RouteHandler {
+  const terminalStyle: TerminalStyle = opts.terminalStyle ?? 'castrum'
+  const readBody = opts.readBody ?? false
+  const maxBodyBytes = opts.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES
+  const bodyTimeoutMs = opts.bodyTimeoutMs ?? DEFAULT_BODY_TIMEOUT_MS
+
+  return async (req, srv, _params) => {
+    const ip = resolveIp(req, srv, opts)
+    // The request-id the framework surfaces (same source as the pre-baked path's
+    // `ctx.requestIdHeader`): the baked result does not carry it, so generate it
+    // here — the native pipeline uses the same rid for its internal frame.
+    const requestId = decoder.decode(generateRequestId())
+    // Read the body ONLY when native validation needs it (the framework owns
+    // the body otherwise). A `BODY_TOO_LARGE`/`REQUEST_TIMEOUT` throw becomes
+    // a terminal 413/408 from the native path.
+    let body: Uint8Array | null = null
+    if (readBody) {
+      try {
+        body = await readBodyWithLimit(req, maxBodyBytes, true, bodyTimeoutMs)
+      } catch (err) {
+        const code = (err as Error & { code?: string }).code
+        const status = code === 'REQUEST_TIMEOUT' ? 408 : code === 'BODY_TOO_LARGE' ? 413 : 400
+        const payload = JSON.stringify({ error: 'Bad Request', status, code: 'BAD_REQUEST' })
+        const headers = new Headers(IGNGEX_SECURITY_HEADERS)
+        headers.set('content-type', 'application/json; charset=utf-8')
+        return new Response(payload, { status, headers })
+      }
+    }
+
+    let terminal: Response | null = null
+    let snapshot: NativeRequestContext | null = null
+
+    // Sync callback (never returns a thenable). Captures the decoded snapshot
+    // or the terminal response, then the async responder runs outside `run()`.
+    ingress.run<null>(req, ip, body, (result, ctx) => {
+      if (result.terminal || !result.ok) {
+        terminal =
+          terminalStyle === 'ignex'
+            ? buildIgngexTerminal(result, ctx)
+            : ingress.terminalResponse(req, result, ctx)
+        return null
+      }
+      const query = parseSection(result.queryJson())
+      const cookies = parseSection(result.cookiesJson())
+      snapshot = {
+        requestId,
+        status: result.status,
+        rateLimited: result.rateLimited,
+        retryAfterMs: result.retryAfterMs,
+        query: query as Record<string, string | string[]>,
+        cookies: cookies as Record<string, string>,
+        body: body ?? new Uint8Array(0),
+        ip,
+        req,
+      }
+      return null
+    })
+
+    if (terminal !== null) {
+      return terminal
+    }
+    if (snapshot === null) {
+      // Native internal error (setInternalError) — the result was never OK.
+      return ingress.internalErrorResponse({ requestIdHeader: null, origin: null })
+    }
+    return responder(snapshot)
+  }
+}

package/src/ingress/server-node.ts

@@ -15,21 +15,20 @@
 
 import {
   createServer,
-  type IncomingMessage,
   type Server as HttpServer,
+  type IncomingMessage,
   type ServerResponse,
 } from 'node:http'
-import { Readable, type Duplex } from 'node:stream'
-
+import { type Duplex, Readable } from 'node:stream'
+import { buildPathMatcher } from './path-matcher'
+import { fallbackHandler } from './routes'
 import {
-  buildPathMatcher,
-  buildRouteHandlers,
   type BakedServer,
+  buildRouteHandlers,
   type CreateIngressServerOptions,
-  type ServerHandle,
   type RouteHandler,
+  type ServerHandle,
 } from './server'
-import { fallbackHandler } from './routes'
 
 export type { RouteHandler } from './server'
 
@@ -41,6 +40,7 @@ export type { RouteHandler } from './server'
  * body-read loop after headers arrive.
  */
 const DEFAULT_SOCKET_TIMEOUT_MS = 30_000
+
 import type { BakedHandlerOptions } from './routes/common'
 
 /** A Node.js ingress server: {@link BakedServer} plus an async ready signal. */

package/src/ingress/server.ts

@@ -1,17 +1,21 @@
 // src/ingress/server.ts — Bun.serve builder over pre-baked route handlers.
 
+import { isBun } from '../shared/runtime'
 import {
-  readHandler,
-  headHandler,
-  jsonWriteHandler,
+  deleteHandler,
   echoHandler,
   fallbackHandler,
-  deleteHandler,
+  headHandler,
+  jsonWriteHandler,
   optionsHandler,
+  readHandler,
 } from './routes'
 import type { BakedHandlerOptions } from './routes/common'
-import type { OptimizedIngressHandler } from './types'
-import { isBun } from '../shared/runtime'
+import { nativeRouteHandler } from './routes/native'
+import { nativeResponderRoute } from './routes/responder'
+import { createNativeRoute } from './native-route'
+import type { NativeRoutePlan } from './native-route'
+import type { NativeResponder, OptimizedIngressHandler, TerminalStyle } from './types'
 
 /** Server-level default for the socket request-body cap (16 MiB). */
 export const DEFAULT_MAX_REQUEST_BODY_SIZE = 16 * 1024 * 1024
@@ -45,6 +49,40 @@ export interface BakedRoute {
   cookies?: OptimizedIngressHandler
   /** Wires a DELETE read-style handler. */
   delete?: OptimizedIngressHandler
+  /**
+   * A JS responder route: the native pipeline owns parse/validate/CORS/
+   * rate-limit + terminal rejections; the responder builds the 2xx body
+   * (async OK). Wired for `methods` (default GET). Built by
+   * `nativeResponderRoute` (src/ingress/routes/responder.ts).
+   */
+  responder?: {
+    /** The route's compiled native `IngressInner`. */
+    ingress: OptimizedIngressHandler
+    /** The JS 2xx builder. */
+    handler: NativeResponder
+    /** HTTP methods to wire (default `['GET']`). */
+    methods?: ReadonlyArray<string>
+    /** Terminal envelope style (`'castrum'` default / `'ignex'`). */
+    terminalStyle?: TerminalStyle
+    /** Read the body for native validation (default false — framework owns it). */
+    readBody?: boolean
+  }
+  /**
+   * A LEAN native-stack responder route: the route-wire v3 per-route stack
+   * (`createNativeRoute`) runs ONLY the plan's stages in ONE native call —
+   * no CORS/rate-limit/security/IP/metadata envelope. Wired for `methods`
+   * (default GET) by `nativeRouteHandler` (src/ingress/routes/native.ts).
+   */
+  native?: {
+    /** The route-wire v3 plan (parse/validate stages + limits). */
+    plan: NativeRoutePlan
+    /** The JS 2xx builder. */
+    handler: NativeResponder
+    /** HTTP methods to wire (default `['GET']`). */
+    methods?: ReadonlyArray<string>
+    /** Read the body for `requireJsonBody`/`validateBody` (default false). */
+    readBody?: boolean
+  }
   /** Overrides `maxBodyBytes` for this route's write/echo handlers. */
   maxBodyBytes?: number
   /**
@@ -124,6 +162,7 @@ export interface BakedServer {
   port: number
 }
 
+/** Options for `gracefulShutdown` (drain grace period + signals). */
 export interface GracefulShutdownOptions {
   /** Grace period (ms) to drain in-flight requests before force-closing. */
   timeoutMs?: number
@@ -182,13 +221,6 @@ export function gracefulShutdown(
   }
 }
 
-/**
- * Build the route → { method → handler } map from a server spec.
- *
- * Shared by `createIngressServer` (Bun.serve) and `createIngressServerNode`
- * (node:http) so both runtimes wire the exact same route handlers.
- */
-
 /** Options `buildRouteHandlers` actually consumes (a subset of the server
  *  options — it does not need `port` or the Node-only server fields). */
 export type BuildRouteHandlersOptions = Pick<
@@ -196,6 +228,12 @@ export type BuildRouteHandlersOptions = Pick<
   'routes' | 'fallback' | 'getIp' | 'copyBody'
 >
 
+/**
+ * Build the route → { method → handler } map from a server spec.
+ *
+ * Shared by `createIngressServer` (Bun.serve) and `createIngressServerNode`
+ * (node:http) so both runtimes wire the exact same route handlers.
+ */
 export function buildRouteHandlers(options: BuildRouteHandlersOptions): {
   routes: Record<string, Record<string, unknown>>
   baseOpts: BakedHandlerOptions
@@ -249,6 +287,33 @@ export function buildRouteHandlers(options: BuildRouteHandlersOptions): {
       methods.DELETE = deleteHandler(spec.delete, routeOpts)
     }
 
+    if (spec.responder) {
+      // JS responder route: native decides + rejects; JS builds the 2xx.
+      const responderRoute = nativeResponderRoute(spec.responder.ingress, spec.responder.handler, {
+        ...routeOpts,
+        terminalStyle: spec.responder.terminalStyle,
+        readBody: spec.responder.readBody,
+      })
+      const responderMethods = spec.responder.methods ?? ['GET']
+      for (const m of responderMethods) {
+        methods[m] = responderRoute
+      }
+    }
+
+    if (spec.native) {
+      // LEAN native-stack responder route: route-wire v3 stack, no envelope.
+      // The compiled route is injected into the pure route factory (DI across
+      // the purity boundary — the compile touches the dlopen layer here).
+      const nativeRoute = nativeRouteHandler(createNativeRoute(spec.native.plan), spec.native.handler, {
+        ...routeOpts,
+        readBody: spec.native.readBody,
+      })
+      const nativeMethods = spec.native.methods ?? ['GET']
+      for (const m of nativeMethods) {
+        methods[m] = nativeRoute
+      }
+    }
+
     // CORS preflight (OPTIONS) is served for EVERY route with a NATIVE handler
     // (not just write routes with a fallback), so read-only routes also answer
     // preflights with 204/403 from the native pipeline. Raw probe handlers
@@ -269,106 +334,12 @@ export function buildRouteHandlers(options: BuildRouteHandlersOptions): {
   return { routes: serverRoutes, baseOpts }
 }
 
-/** A matched dynamic route: the handler map + the extracted path params. */
-export interface PathMatch {
-  methods: Record<string, unknown>
-  params: Record<string, string>
-}
-
-interface CompiledDynamicPattern {
-  re: RegExp
-  paramNames: string[]
-  rest: boolean
-  methods: Record<string, unknown>
-  /** Number of literal (static) segments — used to prefer the most specific pattern. */
-  staticSegments: number
-}
-
-/**
- * Build a path matcher over a route map, supporting `:param` and `*` (rest)
- * segments. Exact (static) paths always win over dynamic patterns; dynamic
- * patterns are ordered most-specific-first (most static segments, then fewest
- * params). Used by `createIngressServerNode` (Bun's native router already
- * matches dynamic patterns itself). The ingress pipeline does not echo path
- * params in its response, so matching only selects the handler.
- */
-export function buildPathMatcher(
-  routes: Record<string, Record<string, unknown>>,
-): (pathname: string) => PathMatch | undefined {
-  const exact = new Map<string, Record<string, unknown>>()
-  const dynamic: CompiledDynamicPattern[] = []
-
-  for (const [path, methods] of Object.entries(routes)) {
-    const hasParam = path.indexOf(':') !== -1
-    const hasRest = path.indexOf('*') !== -1
-    if (!hasParam && !hasRest) {
-      exact.set(path, methods)
-      continue
-    }
+// ── Path matching (shared with server-node.ts + router.ts) ─────────
+// `buildPathMatcher` / `PathMatch` / `safeDecode` live in path-matcher.ts;
+// re-exported here for back-compat (they were historically exported from this
+// module).
 
-    const paramNames: string[] = []
-    let rest = false
-    let staticSegments = 0
-    const parts = path.split('/').filter((s) => s.length > 0)
-    const source = parts
-      .map((seg) => {
-        if (seg === '*') {
-          rest = true
-          return '(.*)'
-        }
-        if (seg.startsWith(':')) {
-          paramNames.push(seg.slice(1))
-          return '([^/]+)'
-        }
-        staticSegments++
-        return seg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-      })
-      .join('/')
-
-    dynamic.push({
-      re: new RegExp(`^/${source}${rest ? '' : '/?$'}`),
-      paramNames,
-      rest,
-      methods,
-      staticSegments,
-    })
-  }
-
-  dynamic.sort(
-    (a, b) => b.staticSegments - a.staticSegments || a.paramNames.length - b.paramNames.length,
-  )
-
-  return (pathname: string) => {
-    const exactHit = exact.get(pathname)
-    if (exactHit !== undefined) {
-      return { methods: exactHit, params: {} }
-    }
-    for (const d of dynamic) {
-      const m = d.re.exec(pathname)
-      if (m !== null) {
-        const params: Record<string, string> = {}
-        for (let i = 0; i < d.paramNames.length; i++) {
-          const raw = m[i + 1]
-          if (raw !== undefined) params[d.paramNames[i] ?? ''] = safeDecode(raw)
-        }
-        if (d.rest) {
-          const restRaw = m[d.paramNames.length + 1]
-          if (restRaw !== undefined) params['*'] = safeDecode(restRaw)
-        }
-        return { methods: d.methods, params }
-      }
-    }
-    return undefined
-  }
-}
-
-function safeDecode(value: string): string {
-  try {
-    return decodeURIComponent(value)
-  } catch {
-    return value
-  }
-}
+export { buildPathMatcher, type PathMatch, safeDecode } from './path-matcher'
 
 /** Typed options forwarded to `Bun.serve`. */
 interface BunServerOptions {

package/src/ingress/sync.ts

@@ -0,0 +1,151 @@
+// src/ingress/sync.ts — Sync + async convenience factories (path 1 wrappers)
+//
+// `createIngressSync` and `createIngress` wrap `createIngressFast` (path 1)
+// with the synchronous-callback guard / automatic body reading + error
+// contexts. Kept OUT of index.ts so the public barrel stays a pure re-export
+// hub. Runtime/server selection lives in src/runtime/server.ts — NOT here.
+
+import { decoder } from '../shared/bytes'
+import { generateRequestId } from '../shared/request-id'
+import { readRequestBodyOnce } from './body'
+import { ERR_CODE_BODY_TOO_LARGE, ERR_CODE_REQUEST_TIMEOUT } from './constants'
+import { internalContext, snapshotResult, syntheticContext } from './context'
+import { createIngressFast } from './fast'
+import { buildResponseContext } from './headers/fast-templates'
+import { buildTerminalResponse } from './response/terminal'
+import { assertSyncCallback, DEFAULT_BODY_TIMEOUT_MS, DEFAULT_MAX_BODY_BYTES } from './shared'
+import type { IngressContext, IngressHandler, IngressOptions, SyncIngressHandler } from './types'
+
+/**
+ * Synchronous convenience wrapper over `createIngressFast` (path 1).
+ *
+ * The callback runs on the fast-path result and MUST be synchronous. Use
+ * {@link createIngress} when you want automatic body reading + error contexts.
+ *
+ * @param options fast-path ingress options
+ * @returns a sync handler (callback must be synchronous)
+ */
+export function createIngressSync(options: IngressOptions = {}): SyncIngressHandler {
+  const fast = createIngressFast(options)
+
+  return {
+    run(req, ip, body, requestId, fn) {
+      return fast.run(req, ip, body, requestId, (result) => {
+        const out = fn(result)
+        assertSyncCallback(out, 'createIngressSync().run()')
+        return out
+      })
+    },
+  }
+}
+
+/**
+ * Return a copy of `options` without the security-header keys.
+ *
+ * `createIngress` applies security headers itself (via `buildResponseContext`),
+ * so they must not be forwarded to the underlying fast handler, which rejects
+ * them (see `createIngressFast`).
+ */
+function stripSecurityOptions(options: IngressOptions): IngressOptions {
+  const copy = { ...options }
+  delete copy.security
+  delete copy.enableSecurityHeaders
+  return copy
+}
+
+/**
+ * Async ingress factory: reads the request body (size guard + deadline) and
+ * returns a snapshot `IngressContext` with a terminal `Response`.
+ *
+ * Recommended default for serverless/edge-style `fetch` handlers. For maximum
+ * throughput use `createIngressFast` / `createIngressSync` directly.
+ *
+ * @param options fast-path ingress options (security applied here, not forwarded)
+ * @returns an async handler returning a snapshot context
+ */
+export function createIngress(options: IngressOptions = {}): IngressHandler {
+  const sync = createIngressSync(stripSecurityOptions(options))
+
+  const guard = options.enableBodySizeGuard !== false
+  const max = options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES
+  const bodyTimeoutMs = options.bodyTimeoutMs ?? DEFAULT_BODY_TIMEOUT_MS
+
+  const wantsBody =
+    options.readBody === true ||
+    options.requireJsonBody === true ||
+    options.schema != null ||
+    (options.readBody !== false && guard)
+
+  const responseCtx = buildResponseContext(options)
+
+  return async function ingressAsync(req: Request, ip?: string): Promise<IngressContext> {
+    const requestId = options.enableRequestIds === false ? '' : decoder.decode(generateRequestId())
+    options.onRequest?.(req, requestId, ip)
+
+    // Every terminal outcome (success, 413, 408, 500) flows through here so a
+    // hook consumer sees exactly one onResponse per request.
+    const emitResponse = (context: IngressContext): IngressContext => {
+      options.onResponse?.(req, context, context.status, requestId)
+      return context
+    }
+
+    try {
+      if (guard) {
+        const rawLen = req.headers.get('content-length')
+        const contentLength = Number(rawLen ?? '0')
+
+        if (Number.isFinite(contentLength) && contentLength > max) {
+          return emitResponse(
+            syntheticContext(req, requestId, options, responseCtx, 413, ERR_CODE_BODY_TOO_LARGE),
+          )
+        }
+      }
+
+      let body: Uint8Array | null = null
+
+      if (wantsBody && req.body !== null) {
+        try {
+          body = await readRequestBodyOnce(req, max, guard, bodyTimeoutMs)
+        } catch (err) {
+          const code = (err as { code?: string } | null)?.code
+
+          if (code === 'BODY_TOO_LARGE') {
+            return emitResponse(
+              syntheticContext(req, requestId, options, responseCtx, 413, ERR_CODE_BODY_TOO_LARGE),
+            )
+          }
+
+          if (code === 'REQUEST_TIMEOUT') {
+            // Match the pre-baked route factories: a body-read deadline is a
+            // 408, not a 500 (was silently swallowed as 500 before).
+            return emitResponse(
+              syntheticContext(req, requestId, options, responseCtx, 408, ERR_CODE_REQUEST_TIMEOUT),
+            )
+          }
+
+          // Unknown body-read failure: surface to onError, then fall through
+          // to the internal-error context below.
+          options.onError?.(err instanceof Error ? err : new Error(String(err)))
+          throw err
+        }
+      }
+
+      return emitResponse(
+        sync.run(req, ip, body, requestId, (r) => {
+          const snapshot = snapshotResult(r)
+          const response = buildTerminalResponse(responseCtx, snapshot, req, requestId)
+
+          return {
+            ...snapshot,
+            response,
+          }
+        }),
+      )
+    } catch (err) {
+      // Native/other failures: never silent — report to onError and emit a
+      // structured 500 context so the request still completes observably.
+      options.onError?.(err instanceof Error ? err : new Error(String(err)))
+      return emitResponse(internalContext(req, requestId, options, responseCtx))
+    }
+  }
+}