@nifrajs/core 2.13.0 → 2.14.1

package/src/binary.ts

@@ -34,6 +34,23 @@ export const NIFRA_BINARY_HEADER = "x-nifra-binary"
 /** A `Response` a route declared as binary. `Jsonify` maps this to `Blob`. */
 export type BinaryResponse = Response & { readonly [NIFRA_BYTES]: true }
 
+/**
+ * Marker on a raw response's TYPE carrying the payload it serializes to. Like {@link NIFRA_BYTES} it is
+ * a unique symbol declared *required*, so an ordinary `Response` cannot satisfy it by accident - an
+ * optional brand would be met by every `Response`, and every raw-response route would wrongly claim a
+ * typed body.
+ */
+declare const NIFRA_RAW: unique symbol
+
+/**
+ * A raw `Response` whose JSON body a route declared as `T`. Returning a bare `Response` drops a route
+ * out of the typed contract - the client reads its `data` as `never`, since a `Response`'s own
+ * properties say nothing about the payload. {@link raw} brands the `Response` with the shape it
+ * actually serializes, so `Jsonify` answers `Jsonify<T>` and the route stays inside the typed client.
+ * The brand is a phantom: nothing is added at runtime.
+ */
+export type RawResponse<T> = Response & { readonly [NIFRA_RAW]: T }
+
 /** What can be sent as bytes without being re-encoded on the way out. */
 export type BinaryBody = ArrayBuffer | ArrayBufferView | Blob | ReadableStream<Uint8Array>
 
@@ -126,3 +143,21 @@ export function bytes(body: BinaryBody, options: BytesOptions = {}): BinaryRespo
     headers,
   }) as BinaryResponse
 }
+
+/**
+ * Brand a hand-built `Response` with the payload type `T` its body serializes to, so a route that must
+ * return a `Response` directly still types `res.data` as `Jsonify<T>` on the client instead of `never`.
+ * Use it for the endpoints that build their own `Response` - a token minted by a third-party SDK, a
+ * redirect that also carries a JSON body, a hand-tuned cache header - but should still be part of the
+ * contract. Purely a type assertion: the `Response` is returned unchanged, nothing is added at runtime.
+ *
+ *     app.get("/livekit-token", async (c) =>
+ *       raw<{ token: string }>(Response.json({ token: await mint(c) })))
+ *     // client: res.data is typed { token: string }
+ *
+ * The payload `T` is the type the body serializes to - it is not validated, so it is a promise the route
+ * must keep. For bytes prefer {@link bytes}, which also sets the media-type headers.
+ */
+export function raw<T>(response: Response): RawResponse<T> {
+  return response as RawResponse<T>
+}

package/src/durable-adapters.ts

@@ -13,6 +13,9 @@ import type {
   SagaRecord,
   SagaStore,
 } from "./durable-execution.ts"
+import { durableApprovalProtocol } from "./internal/durable-approval-protocol.ts"
+import { durableEffectProtocol } from "./internal/durable-effect-protocol.ts"
+import { durableSagaProtocol } from "./internal/durable-saga-protocol.ts"
 import { safeEqual } from "./internal/safe-equal.ts"
 import type { ReconciliationLease, ReconciliationLeaseStore } from "./reconciliation-worker.ts"
 import { parse as parseWire, stringify as stringifyWire } from "./wire.ts"
@@ -93,20 +96,8 @@ export function createDurableExecutionAdapter(
     get: (effectId) => backend.get<DurableEffectRecord>("effect", effectId),
     async transition(input) {
       const current = await backend.get<DurableEffectRecord>("effect", input.effectId)
-      if (
-        current === undefined ||
-        current.version !== input.version ||
-        current.state !== input.from
-      ) {
-        return false
-      }
-      const next: DurableEffectRecord = {
-        ...current,
-        state: input.to,
-        updatedAt: input.updatedAt,
-        version: current.version + 1,
-        ...(input.errorCode === undefined ? {} : { errorCode: input.errorCode }),
-      }
+      const next = durableEffectProtocol.transition(current, input)
+      if (next === undefined) return false
       return await backend.compareAndSet("effect", input.effectId, input.version, next)
     },
     scan: (input) =>
@@ -119,46 +110,26 @@ export function createDurableExecutionAdapter(
     get: (approvalId) => backend.get<ApprovalRecord>("approval", approvalId),
     async decide(input) {
       const current = await backend.get<ApprovalRecord>("approval", input.approvalId)
-      if (
-        current === undefined ||
-        current.tenantId !== input.tenantId ||
-        current.state !== "pending" ||
-        current.expiresAt <= input.now
-      ) {
-        return false
-      }
-      const decided: ApprovalRecord = {
-        ...current,
-        state: input.decision,
-        decidedBy: input.decidedBy,
-        updatedAt: input.now,
-        version: current.version + 1,
-      }
-      return await backend.compareAndSet("approval", input.approvalId, current.version, decided)
+      const next = durableApprovalProtocol.decide(current, input)
+      if (current === undefined || next === undefined) return false
+      return await backend.compareAndSet("approval", input.approvalId, current.version, next)
     },
     async consume(input): Promise<ApprovalConsumeResult> {
       const current = await backend.get<ApprovalRecord>("approval", input.approvalId)
-      if (current === undefined) return { state: "missing" }
-      if (current.tenantId !== input.tenantId || current.principalId !== input.principalId)
-        return { state: "binding" }
+      const transition = durableApprovalProtocol.consume(current, input)
       if (
-        current.capability !== input.capability ||
-        current.target !== input.target ||
-        !safeEqual(current.digest, input.digest)
+        current === undefined ||
+        transition.result.state !== "consumed" ||
+        transition.next === undefined
       )
-        return { state: "binding" }
-      if (!safeEqual(current.tokenHash, input.tokenHash)) return { state: "token" }
-      if (current.state === "consumed") return { state: "replay" }
-      if (current.state === "denied") return { state: "denied" }
-      if (current.state === "pending") return { state: "pending" }
-      if (current.state === "expired" || current.expiresAt <= input.now) return { state: "expired" }
-      const consumed = await backend.compareAndSet("approval", input.approvalId, current.version, {
-        ...current,
-        state: "consumed",
-        updatedAt: input.now,
-        version: current.version + 1,
-      })
-      return consumed ? { state: "consumed" } : { state: "replay" }
+        return transition.result
+      const consumed = await backend.compareAndSet(
+        "approval",
+        input.approvalId,
+        current.version,
+        transition.next,
+      )
+      return consumed ? transition.result : { state: "replay" }
     },
   }
 
@@ -166,8 +137,12 @@ export function createDurableExecutionAdapter(
     durability: "durable",
     create: (record) => backend.create("saga", record.sagaId, clone(record)),
     get: (sagaId) => backend.get<SagaRecord>("saga", sagaId),
-    compareAndSet: (input) =>
-      backend.compareAndSet("saga", input.sagaId, input.version, clone(input.record)),
+    compareAndSet: (input) => {
+      const next = durableSagaProtocol.transition(undefined, input)
+      return next === undefined
+        ? false
+        : backend.compareAndSet("saga", input.sagaId, input.version, clone(next))
+    },
     scan: (input) => backend.scan<SagaRecord>("saga", input as ReconciliationScanOptions<string>),
   }
 

package/src/durable-execution.ts

@@ -13,7 +13,9 @@ import type {
   CapabilityExecutionJournal,
 } from "./internal/capability-runtime.ts"
 import { validCapabilityId } from "./internal/capability-runtime.ts"
-import { safeEqual } from "./internal/safe-equal.ts"
+import { durableApprovalProtocol } from "./internal/durable-approval-protocol.ts"
+import { durableEffectProtocol } from "./internal/durable-effect-protocol.ts"
+import { durableSagaProtocol } from "./internal/durable-saga-protocol.ts"
 
 export type { CapabilityApprovalGate, CapabilityExecutionIdentity, CapabilityExecutionJournal }
 
@@ -208,8 +210,7 @@ export function createDurableEffectJournal(
     errorCode?: string,
   ): Promise<void> => {
     const record = await current(effectId)
-    if (record.state !== from) throw new DurableEffectTransitionError(effectId, `${from}->${to}`)
-    const accepted = await options.store.transition({
+    const next = durableEffectProtocol.transition(record, {
       effectId,
       version: record.version,
       from,
@@ -217,6 +218,15 @@ export function createDurableEffectJournal(
       updatedAt: now(),
       ...(errorCode === undefined ? {} : { errorCode }),
     })
+    if (next === undefined) throw new DurableEffectTransitionError(effectId, `${from}->${to}`)
+    const accepted = await options.store.transition({
+      effectId,
+      version: record.version,
+      from,
+      to,
+      updatedAt: next.updatedAt,
+      ...(errorCode === undefined ? {} : { errorCode }),
+    })
     if (!accepted) throw new DurableEffectTransitionError(effectId, `${from}->${to}`)
   }
 
@@ -261,7 +271,7 @@ export function createDurableEffectJournal(
         throw new TypeError("durable effect errorCode is invalid")
       const record = await current(effectId)
       const to = input.began ? "unknown" : "failed"
-      const accepted = await options.store.transition({
+      const next = durableEffectProtocol.transition(record, {
         effectId,
         version: record.version,
         from: record.state,
@@ -269,6 +279,16 @@ export function createDurableEffectJournal(
         updatedAt: now(),
         errorCode: input.errorCode,
       })
+      if (next === undefined)
+        throw new DurableEffectTransitionError(effectId, `${record.state}->${to}`)
+      const accepted = await options.store.transition({
+        effectId,
+        version: record.version,
+        from: record.state,
+        to,
+        updatedAt: next.updatedAt,
+        errorCode: input.errorCode,
+      })
       if (!accepted) throw new DurableEffectTransitionError(effectId, `${record.state}->${to}`)
     },
   }
@@ -296,18 +316,10 @@ export class MemoryDurableEffectStore implements DurableEffectStore {
 
   transition(input: Parameters<DurableEffectStore["transition"]>[0]): boolean {
     const current = this.records.get(input.effectId)
-    if (current === undefined || current.version !== input.version || current.state !== input.from)
-      return false
-    this.records.set(
-      input.effectId,
-      Object.freeze({
-        ...current,
-        state: input.to,
-        updatedAt: input.updatedAt,
-        version: current.version + 1,
-        ...(input.errorCode === undefined ? {} : { errorCode: input.errorCode }),
-      }),
-    )
+    const next = durableEffectProtocol.transition(current, input)
+    if (next === undefined) return false
+    if (current === undefined) return false
+    this.records.set(input.effectId, Object.freeze(next))
     bucketMove(this.byState, current.state, input.to, input.effectId)
     return true
   }
@@ -801,64 +813,17 @@ export class MemoryApprovalStore implements ApprovalStore {
   }
   decide(input: Parameters<ApprovalStore["decide"]>[0]): boolean {
     const record = this.records.get(input.approvalId)
-    if (
-      record === undefined ||
-      record.tenantId !== input.tenantId ||
-      record.state !== "pending" ||
-      record.expiresAt <= input.now
-    )
-      return false
-    this.records.set(
-      input.approvalId,
-      Object.freeze({
-        ...record,
-        state: input.decision,
-        decidedBy: input.decidedBy,
-        updatedAt: input.now,
-        version: record.version + 1,
-      }),
-    )
+    const next = durableApprovalProtocol.decide(record, input)
+    if (next === undefined) return false
+    this.records.set(input.approvalId, Object.freeze(next))
     return true
   }
   consume(input: Parameters<ApprovalStore["consume"]>[0]): ApprovalConsumeResult {
     const record = this.records.get(input.approvalId)
-    if (record === undefined) return { state: "missing" }
-    if (
-      record.tenantId !== input.tenantId ||
-      record.principalId !== input.principalId ||
-      record.capability !== input.capability ||
-      record.target !== input.target ||
-      !safeEqual(record.digest, input.digest)
-    )
-      return { state: "binding" }
-    if (!safeEqual(record.tokenHash, input.tokenHash)) return { state: "token" }
-    if (record.state === "consumed") return { state: "replay" }
-    if (record.expiresAt <= input.now || record.state === "expired") {
-      if (record.state !== "expired")
-        this.records.set(
-          input.approvalId,
-          Object.freeze({
-            ...record,
-            state: "expired",
-            updatedAt: input.now,
-            version: record.version + 1,
-          }),
-        )
-      return { state: "expired" }
-    }
-    if (record.state === "pending") return { state: "pending" }
-    if (record.state === "denied") return { state: "denied" }
-    if (record.state !== "approved") return { state: "token" }
-    this.records.set(
-      input.approvalId,
-      Object.freeze({
-        ...record,
-        state: "consumed",
-        updatedAt: input.now,
-        version: record.version + 1,
-      }),
-    )
-    return { state: "consumed" }
+    const transition = durableApprovalProtocol.consume(record, input)
+    if (transition.next !== undefined)
+      this.records.set(input.approvalId, Object.freeze(transition.next))
+    return transition.result
   }
   list(): readonly ApprovalRecord[] {
     return Object.freeze(
@@ -1174,7 +1139,12 @@ export function createSagaEngine(options: SagaEngineOptions): SagaEngine {
     current: SagaRecord,
     update: Omit<SagaRecord, "version">,
   ): Promise<SagaRecord> => {
-    const next = Object.freeze({ ...update, version: current.version + 1 })
+    const next = durableSagaProtocol.transition(current, {
+      sagaId: current.sagaId,
+      version: current.version,
+      record: Object.freeze({ ...update, version: current.version + 1 }),
+    })
+    if (next === undefined) throw new SagaConcurrencyError(current.sagaId)
     if (
       !(await options.store.compareAndSet({
         sagaId: current.sagaId,
@@ -1190,16 +1160,7 @@ export function createSagaEngine(options: SagaEngineOptions): SagaEngine {
     index: number,
     step: SagaStepRecord,
     state = record.state,
-  ): Omit<SagaRecord, "version"> => ({
-    ...record,
-    state,
-    steps: Object.freeze(
-      record.steps.map((candidate, candidateIndex) =>
-        candidateIndex === index ? Object.freeze(step) : candidate,
-      ),
-    ),
-    updatedAt: now(),
-  })
+  ): Omit<SagaRecord, "version"> => durableSagaProtocol.withStep(record, index, step, state, now())
   const effectScope = createEffectScope({
     ...(observer === undefined ? {} : { observers: [observer] }),
   })
@@ -1569,13 +1530,10 @@ export class MemorySagaStore implements SagaStore {
   }
   compareAndSet(input: Parameters<SagaStore["compareAndSet"]>[0]): boolean {
     const current = this.records.get(input.sagaId)
-    if (
-      current === undefined ||
-      current.version !== input.version ||
-      input.record.version !== input.version + 1
-    )
-      return false
-    this.records.set(input.sagaId, Object.freeze(cloneValue(input.record)))
+    const next = durableSagaProtocol.transition(current, input)
+    if (next === undefined) return false
+    if (current === undefined) return false
+    this.records.set(input.sagaId, Object.freeze(next))
     bucketMove(this.byState, current.state, input.record.state, input.sagaId)
     return true
   }

package/src/index.ts

@@ -10,7 +10,7 @@
  * read its own package.json at runtime. `scripts/version.ts` rewrites it on every release bump and
  * `check:publish` asserts it equals `@nifrajs/core`'s package version.
  */
-export const VERSION = "2.13.0" as const
+export const VERSION = "2.14.1" as const
 
 export type Version = typeof VERSION
 

package/src/internal/durable-approval-protocol.ts

@@ -0,0 +1,92 @@
+import type { ApprovalConsumeResult, ApprovalRecord, ApprovalStore } from "../durable-execution.ts"
+import { safeEqual } from "./safe-equal.ts"
+
+export type DurableApprovalDecisionInput = Parameters<ApprovalStore["decide"]>[0]
+export type DurableApprovalConsumeInput = Parameters<ApprovalStore["consume"]>[0]
+
+export interface DurableApprovalConsumeTransition {
+  readonly result: ApprovalConsumeResult
+  readonly next?: ApprovalRecord
+}
+
+export interface DurableApprovalProtocol {
+  decide(
+    current: ApprovalRecord | undefined,
+    input: DurableApprovalDecisionInput,
+  ): ApprovalRecord | undefined
+  consume(
+    current: ApprovalRecord | undefined,
+    input: DurableApprovalConsumeInput,
+  ): DurableApprovalConsumeTransition
+}
+
+function decideApproval(
+  current: ApprovalRecord | undefined,
+  input: DurableApprovalDecisionInput,
+): ApprovalRecord | undefined {
+  if (
+    current === undefined ||
+    current.tenantId !== input.tenantId ||
+    current.state !== "pending" ||
+    current.expiresAt <= input.now
+  ) {
+    return undefined
+  }
+  return Object.freeze({
+    ...current,
+    state: input.decision,
+    decidedBy: input.decidedBy,
+    updatedAt: input.now,
+    version: current.version + 1,
+  })
+}
+
+function consumeApproval(
+  current: ApprovalRecord | undefined,
+  input: DurableApprovalConsumeInput,
+): DurableApprovalConsumeTransition {
+  if (current === undefined) return { result: { state: "missing" } }
+  if (
+    current.tenantId !== input.tenantId ||
+    current.principalId !== input.principalId ||
+    current.capability !== input.capability ||
+    current.target !== input.target ||
+    !safeEqual(current.digest, input.digest)
+  ) {
+    return { result: { state: "binding" } }
+  }
+  if (!safeEqual(current.tokenHash, input.tokenHash)) return { result: { state: "token" } }
+  if (current.state === "consumed") return { result: { state: "replay" } }
+  if (current.state === "denied") return { result: { state: "denied" } }
+  if (current.state === "pending") return { result: { state: "pending" } }
+  if (current.state === "expired" || current.expiresAt <= input.now) {
+    return {
+      result: { state: "expired" },
+      ...(current.state === "expired"
+        ? {}
+        : {
+            next: Object.freeze({
+              ...current,
+              state: "expired" as const,
+              updatedAt: input.now,
+              version: current.version + 1,
+            }),
+          }),
+    }
+  }
+  if (current.state !== "approved") return { result: { state: "token" } }
+  return {
+    result: { state: "consumed" },
+    next: Object.freeze({
+      ...current,
+      state: "consumed" as const,
+      updatedAt: input.now,
+      version: current.version + 1,
+    }),
+  }
+}
+
+export const durableApprovalProtocol: DurableApprovalProtocol = Object.freeze({
+  decide: decideApproval,
+  consume: consumeApproval,
+})

package/src/internal/durable-effect-protocol.ts

@@ -0,0 +1,37 @@
+import type { DurableEffectRecord, DurableEffectState } from "../durable-execution.ts"
+
+export interface DurableEffectTransitionInput {
+  readonly effectId: string
+  readonly version: number
+  readonly from: DurableEffectState
+  readonly to: DurableEffectState
+  readonly updatedAt: number
+  readonly errorCode?: string
+}
+
+export interface DurableEffectProtocol {
+  transition(
+    current: DurableEffectRecord | undefined,
+    input: DurableEffectTransitionInput,
+  ): DurableEffectRecord | undefined
+}
+
+function transitionEffect(
+  current: DurableEffectRecord | undefined,
+  input: DurableEffectTransitionInput,
+): DurableEffectRecord | undefined {
+  if (current === undefined || current.version !== input.version || current.state !== input.from) {
+    return undefined
+  }
+  return Object.freeze({
+    ...current,
+    state: input.to,
+    updatedAt: input.updatedAt,
+    version: current.version + 1,
+    ...(input.errorCode === undefined ? {} : { errorCode: input.errorCode }),
+  })
+}
+
+export const durableEffectProtocol: DurableEffectProtocol = Object.freeze({
+  transition: transitionEffect,
+})

package/src/internal/durable-saga-protocol.ts

@@ -0,0 +1,55 @@
+import type { SagaRecord, SagaState, SagaStepRecord, SagaStore } from "../durable-execution.ts"
+
+export type DurableSagaTransitionInput = Parameters<SagaStore["compareAndSet"]>[0]
+
+export interface DurableSagaProtocol {
+  transition(
+    current: SagaRecord | undefined,
+    input: DurableSagaTransitionInput,
+  ): SagaRecord | undefined
+  withStep(
+    record: SagaRecord,
+    index: number,
+    step: SagaStepRecord,
+    state: SagaState,
+    updatedAt: number,
+  ): Omit<SagaRecord, "version">
+}
+
+function transitionSaga(
+  current: SagaRecord | undefined,
+  input: DurableSagaTransitionInput,
+): SagaRecord | undefined {
+  if (
+    input.record.version !== input.version + 1 ||
+    (current !== undefined &&
+      (current.sagaId !== input.sagaId || current.version !== input.version))
+  ) {
+    return undefined
+  }
+  return Object.freeze({ ...input.record })
+}
+
+function withSagaStep(
+  record: SagaRecord,
+  index: number,
+  step: SagaStepRecord,
+  state: SagaState,
+  updatedAt: number,
+): Omit<SagaRecord, "version"> {
+  return {
+    ...record,
+    state,
+    steps: Object.freeze(
+      record.steps.map((candidate, candidateIndex) =>
+        candidateIndex === index ? Object.freeze(step) : candidate,
+      ),
+    ),
+    updatedAt,
+  }
+}
+
+export const durableSagaProtocol: DurableSagaProtocol = Object.freeze({
+  transition: transitionSaga,
+  withStep: withSagaStep,
+})

package/src/internal/route-catalog.ts

@@ -80,6 +80,12 @@ export class RouteCatalog {
     return this.records
   }
 
+  /** Number of registered routes. Read at hook push time and at seal to detect an order-scoped hook
+   * that captured no route (see `Server.sealConfiguration`). */
+  get size(): number {
+    return this.records.length
+  }
+
   routeDescriptors(): ReadonlyArray<RouteDescriptor> {
     return this.descriptors
   }

package/src/server/plugin.ts

@@ -86,7 +86,7 @@ export interface PluginTypeCollapsed {
  * every route type flowing through it is about to be widened away.
  */
 // biome-ignore lint/suspicious/noExplicitAny: matches any Server shape to inspect its Registry alone
-type ServerTypeUnpinned<S> = [S] extends [Server<infer R, any>]
+export type ServerTypeUnpinned<S> = [S] extends [Server<infer R, any>]
   ? 0 extends 1 & R
     ? true
     : false

package/src/server/registry.ts

@@ -1,3 +1,4 @@
+import type { BinaryResponse, RawResponse } from "../binary.ts"
 import type { InferInput, InferOutput, StandardSchemaV1 } from "../schema/standard.ts"
 import type { Params, RouteSchema } from "./context.ts"
 
@@ -79,12 +80,26 @@ export type RouteInfoFor<Path extends string, S extends RouteSchema, Output> = {
   readonly sse: RegistrySse<S>
 }
 
-/** The client-visible output of a handler: its awaited return, minus raw `Response`. */
-export type OutputOf<H extends (...args: never[]) => unknown> = Exclude<
-  Awaited<ReturnType<H>>,
-  Response
+/**
+ * The client-visible output of a handler: its awaited return, with an UNbranded raw `Response` removed
+ * (a route returning a bare `Response` has no describable body). A response branded by `bytes()`
+ * ({@link BinaryResponse}) or `raw()` ({@link RawResponse}) is KEPT, so the brand reaches the client's
+ * `Jsonify` and types `data` as `Blob` / `Jsonify<T>` rather than collapsing to `never`.
+ */
+export type OutputOf<H extends (...args: never[]) => unknown> = KeepBrandedResponse<
+  Awaited<ReturnType<H>>
 >
 
+/** Preserve a `bytes()`/`raw()`-branded response; drop only a bare `Response`. Distributes over a
+ * union return, so `Foo | BinaryResponse` keeps both arms. */
+type KeepBrandedResponse<O> = O extends BinaryResponse
+  ? O
+  : O extends RawResponse<unknown>
+    ? O
+    : O extends Response
+      ? never
+      : O
+
 /**
  * The registry entry for a WebSocket route (stored under the pseudo-method key `"WS"`, so WS routes
  * ride the same path → method map as HTTP routes - no extra Server generic). `in` is the client →

package/src/server/request-context.ts

@@ -499,31 +499,34 @@ export function readBoundedJsonSource<T>(
       return onResult === undefined
         ? Promise.resolve(jsonError(413, "payload_too_large"))
         : Promise.resolve(jsonError(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
+    // decode+parse straight away, before the transfer-encoding probe that only exists to route
+    // *untrusted* Node/adapter sources to the streaming lane. Skipping that probe drops one
+    // `Headers.get()` from every Bun/Deno JSON POST; Node/adapter sources are never marked and fall
+    // through below. The parsed-value poisoning walk still applies.
+    if (hasTrustedBodyFraming(req)) {
+      return raw.json().then(
+        (parsed) => {
+          let guarded: unknown
+          try {
+            guarded = guardParsedValue(parsed, protoPoisoning)
+          } catch {
+            return onResult === undefined
+              ? jsonError(400, "invalid_json")
+              : onResult(jsonError(400, "invalid_json"))
+          }
+          return onResult === undefined ? guarded : onResult(guarded)
+        },
+        () => (onResult === undefined ? INVALID_JSON() : onResult(INVALID_JSON())),
+      )
+    }
     const chunked =
       (sourceHeader === undefined
         ? req.headers.get("transfer-encoding")
         : sourceHeader.call(req, "transfer-encoding")) !== null
     if (!chunked) {
-      // Bun's compiled native route table receives a Request whose bytes were already delimited by
-      // Bun's HTTP parser. Keep the exact-byte path for every portable/adapted source, but preserve
-      // Bun's fused decode+parse on this trusted ingress; the declared length is the transport frame
-      // there, not an attacker-controlled hint. The parsed-value poisoning walk still applies.
-      if (hasTrustedBodyFraming(req)) {
-        return raw.json().then(
-          (parsed) => {
-            let guarded: unknown
-            try {
-              guarded = guardParsedValue(parsed, protoPoisoning)
-            } catch {
-              return onResult === undefined
-                ? jsonError(400, "invalid_json")
-                : onResult(jsonError(400, "invalid_json"))
-            }
-            return onResult === undefined ? guarded : onResult(guarded)
-          },
-          () => (onResult === undefined ? INVALID_JSON() : onResult(INVALID_JSON())),
-        )
-      }
       const jsonWithByteLength = raw.jsonWithByteLength
       if (jsonWithByteLength !== undefined) {
         return jsonWithByteLength.call(raw).then(