@nifrajs/core 5.7.0 → 5.9.0

package/src/evidence.ts

@@ -7,6 +7,7 @@
  */
 
 import type { AssuranceEvidence, AssuranceFinding, AssuranceReport } from "./assurance.ts"
+import { canonicalJson } from "./canonical-json.ts"
 import type {
   AssuredCapabilityRoute,
   CapabilityAssuranceReport,
@@ -15,7 +16,9 @@ import type {
 } from "./capabilities.ts"
 import type { ResponseClassification } from "./classification.ts"
 import { codeUnitOrder } from "./internal/code-unit-order.ts"
+import { sha256Hex } from "./internal/hex.ts"
 import { evidenceProvenance } from "./internal/route-assurance.ts"
+import { mapSchemaParts } from "./internal/schema-parts.ts"
 import {
   type JsonSchema,
   type ReflectedMount,
@@ -134,11 +137,6 @@ export interface ProjectEvidenceCompositionPart {
   readonly pathPrefix?: string
 }
 
-const recordOf = (value: unknown): Readonly<Record<string, unknown>> | undefined =>
-  value !== null && typeof value === "object" && !Array.isArray(value)
-    ? (value as Readonly<Record<string, unknown>>)
-    : undefined
-
 function schemaPart(value: SchemaReflection | undefined): ProjectEvidenceSchemaPart | undefined {
   if (value === undefined) return undefined
   return Object.freeze({
@@ -154,12 +152,6 @@ function schemaPart(value: SchemaReflection | undefined): ProjectEvidenceSchemaP
 function schemaOf(route: ReflectedRoute): ProjectEvidenceSchema | undefined {
   const source = route.schema
   if (source === undefined) return undefined
-  const headers = schemaPart(source.headers)
-  const cookies = schemaPart(source.cookies)
-  const body = schemaPart(source.body)
-  const query = schemaPart(source.query)
-  const params = schemaPart(source.params)
-  const response = schemaPart(source.response)
   const sse = schemaPart(source.sse)
   const errors: Record<string, ProjectEvidenceSchemaPart> = {}
   for (const [status, value] of Object.entries(source.errors ?? {})) {
@@ -170,12 +162,7 @@ function schemaOf(route: ReflectedRoute): ProjectEvidenceSchema | undefined {
     ...(source.validationOrder !== undefined ? { validationOrder: source.validationOrder } : {}),
     ...(source.bodyLimit !== undefined ? { bodyLimit: source.bodyLimit } : {}),
     ...(source.bodyLimitReason !== undefined ? { bodyLimitReason: source.bodyLimitReason } : {}),
-    ...(headers !== undefined ? { headers } : {}),
-    ...(cookies !== undefined ? { cookies } : {}),
-    ...(body !== undefined ? { body } : {}),
-    ...(query !== undefined ? { query } : {}),
-    ...(params !== undefined ? { params } : {}),
-    ...(response !== undefined ? { response } : {}),
+    ...mapSchemaParts(source, schemaPart),
     ...(Object.keys(errors).length > 0 ? { errors: Object.freeze(errors) } : {}),
     ...(sse !== undefined ? { sse } : {}),
     ...(source.validationErrorHook === true ? { validationErrorHook: true as const } : {}),
@@ -221,6 +208,20 @@ const sortByRoute = <T extends { readonly method: string; readonly path: string
     [...values].sort((a, b) => codeUnitOrder(a.path, b.path) || codeUnitOrder(a.method, b.method)),
   )
 
+const sortByFinding = <
+  T extends { readonly method: string; readonly path: string; readonly code: string },
+>(
+  values: readonly T[],
+): readonly T[] =>
+  Object.freeze(
+    [...values].sort(
+      (a, b) =>
+        codeUnitOrder(a.path, b.path) ||
+        codeUnitOrder(a.method, b.method) ||
+        codeUnitOrder(a.code, b.code),
+    ),
+  )
+
 function evidenceRouteOf(
   route: ReflectedRoute,
   locations: readonly ProjectEvidenceSourceLocation[] | undefined,
@@ -260,14 +261,7 @@ function assuranceOf(report: AssuranceReport | undefined): ProjectEvidenceAssura
         }),
       ),
     ),
-    findings: Object.freeze(
-      [...report.findings].sort(
-        (a, b) =>
-          codeUnitOrder(a.path, b.path) ||
-          codeUnitOrder(a.method, b.method) ||
-          codeUnitOrder(a.code, b.code),
-      ),
-    ),
+    findings: sortByFinding(report.findings),
   })
 }
 
@@ -290,14 +284,7 @@ function capabilitiesOf(
         }),
       ),
     ),
-    findings: Object.freeze(
-      [...report.findings].sort(
-        (a, b) =>
-          codeUnitOrder(a.path, b.path) ||
-          codeUnitOrder(a.method, b.method) ||
-          codeUnitOrder(a.code, b.code),
-      ),
-    ),
+    findings: sortByFinding(report.findings),
   })
 }
 
@@ -443,16 +430,7 @@ export function composeProjectEvidence(
       : Object.freeze({
           ok: assuranceReports.every((report) => report.ok),
           routes: sortByRoute(assuranceReports.flatMap((report) => report.routes)),
-          findings: Object.freeze(
-            assuranceReports
-              .flatMap((report) => report.findings)
-              .sort(
-                (a, b) =>
-                  codeUnitOrder(a.path, b.path) ||
-                  codeUnitOrder(a.method, b.method) ||
-                  codeUnitOrder(a.code, b.code),
-              ),
-          ),
+          findings: sortByFinding(assuranceReports.flatMap((report) => report.findings)),
         })
   const capabilities =
     capabilityReports.length === 0
@@ -460,16 +438,7 @@ export function composeProjectEvidence(
       : Object.freeze({
           ok: capabilityReports.every((report) => report.ok),
           routes: sortByRoute(capabilityReports.flatMap((report) => report.routes)),
-          findings: Object.freeze(
-            capabilityReports
-              .flatMap((report) => report.findings)
-              .sort(
-                (a, b) =>
-                  codeUnitOrder(a.path, b.path) ||
-                  codeUnitOrder(a.method, b.method) ||
-                  codeUnitOrder(a.code, b.code),
-              ),
-          ),
+          findings: sortByFinding(capabilityReports.flatMap((report) => report.findings)),
         })
   if (assurance !== undefined) validateComposedReportRoutes(assurance, routeKeys, "assurance")
   if (capabilities !== undefined)
@@ -506,23 +475,12 @@ function schemaFromEvidence(schema: ProjectEvidenceSchema | undefined): Reflecte
       schemaPartToReflection(value) as SchemaReflection,
     ]),
   )
-  const headers = schemaPartToReflection(schema.headers)
-  const cookies = schemaPartToReflection(schema.cookies)
-  const body = schemaPartToReflection(schema.body)
-  const query = schemaPartToReflection(schema.query)
-  const params = schemaPartToReflection(schema.params)
-  const response = schemaPartToReflection(schema.response)
   const sse = schemaPartToReflection(schema.sse)
   return {
     ...(schema.validationOrder !== undefined ? { validationOrder: schema.validationOrder } : {}),
     ...(schema.bodyLimit !== undefined ? { bodyLimit: schema.bodyLimit } : {}),
     ...(schema.bodyLimitReason !== undefined ? { bodyLimitReason: schema.bodyLimitReason } : {}),
-    ...(headers !== undefined ? { headers } : {}),
-    ...(cookies !== undefined ? { cookies } : {}),
-    ...(body !== undefined ? { body } : {}),
-    ...(query !== undefined ? { query } : {}),
-    ...(params !== undefined ? { params } : {}),
-    ...(response !== undefined ? { response } : {}),
+    ...mapSchemaParts(schema, schemaPartToReflection),
     ...(Object.keys(errors).length > 0 ? { errors } : {}),
     ...(sse !== undefined ? { sse } : {}),
     ...(schema.validationErrorHook === true ? { validationErrorHook: true as const } : {}),
@@ -592,35 +550,12 @@ const mountsPart = (
         ),
       }
 
-function canonicalValue(value: unknown): string {
-  if (value === null || typeof value === "string" || typeof value === "boolean") {
-    return JSON.stringify(value)
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value))
-      throw new TypeError("project evidence cannot encode non-finite numbers")
-    return JSON.stringify(value)
-  }
-  if (Array.isArray(value)) return `[${value.map((item) => canonicalValue(item)).join(",")}]`
-  const record = recordOf(value)
-  if (record !== undefined) {
-    return `{${Object.keys(record)
-      .filter((key) => record[key] !== undefined)
-      .sort()
-      .map((key) => `${JSON.stringify(key)}:${canonicalValue(record[key])}`)
-      .join(",")}}`
-  }
-  throw new TypeError(`project evidence cannot encode ${typeof value}`)
-}
-
 /** Stable JSON for logs, MCP, generated artifacts, and snapshot tests. */
 export function serializeProjectEvidence(snapshot: ProjectEvidenceSnapshot): string {
-  return canonicalValue(snapshot)
+  return canonicalJson(snapshot)
 }
 
 /** SHA-256 of the canonical snapshot, useful as a cheap freshness/reference token. */
 export async function digestProjectEvidence(snapshot: ProjectEvidenceSnapshot): Promise<string> {
-  const bytes = new TextEncoder().encode(serializeProjectEvidence(snapshot))
-  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))
-  return [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("")
+  return sha256Hex(serializeProjectEvidence(snapshot))
 }

package/src/idempotency.ts

@@ -10,6 +10,9 @@
  * unit-tested without a server. A durable store (cross-restart) implements the same interface.
  */
 
+import { canonicalJson } from "./canonical-json.ts"
+import { bytesToHex } from "./internal/hex.ts"
+
 /** Whether a route's idempotency is satisfied by an in-process store or a durable (cross-restart) one. */
 export type IdempotencyScope = "request" | "durable"
 
@@ -172,32 +175,64 @@ export async function computeIdempotencyFingerprint(
   const material = new Uint8Array(head.length + body.length)
   material.set(head, 0)
   material.set(body, head.length)
-  const digest = await crypto.subtle.digest("SHA-256", material)
-  const bytes = new Uint8Array(digest)
-  let hex = ""
-  for (let i = 0; i < bytes.length; i++) hex += (bytes[i] as number).toString(16).padStart(2, "0")
-  return hex
+  return bytesToHex(new Uint8Array(await crypto.subtle.digest("SHA-256", material)))
 }
 
-function canonicalJson(value: unknown): string {
-  if (value === null || typeof value === "boolean" || typeof value === "string") {
-    return JSON.stringify(value)
+const isDigit = (code: number): boolean => code >= 48 && code <= 57
+const isDigitOrDot = (code: number): boolean => isDigit(code) || code === 46
+
+/**
+ * Whether `text` may hold a JSON number no double holds exactly: one written with 16+ digits (a dot
+ * counted) or with a negative exponent of 3+ digits. Any other number round-trips exactly, or
+ * overflows to Infinity, which canonical JSON refuses. A match inside a string only costs the slower
+ * parse.
+ */
+function mayHoldLossyNumber(text: string): boolean {
+  // A run of 16 digits or dots covers an index that is 15 mod 16, so only those indexes are probed.
+  for (let i = 15; i < text.length; i += 16) {
+    if (!isDigitOrDot(text.charCodeAt(i))) continue
+    let start = i
+    while (isDigitOrDot(text.charCodeAt(start - 1))) start--
+    let end = i + 1
+    while (isDigitOrDot(text.charCodeAt(end))) end++
+    if (end - start >= 16) return true
   }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new TypeError("non-finite JSON number")
-    return JSON.stringify(value)
+  // A negative exponent follows "e-" or "E-"; "-" is the rarer character to search for.
+  for (let i = text.indexOf("-"); i !== -1; i = text.indexOf("-", i + 1)) {
+    if ((text.charCodeAt(i - 1) | 32) !== 101) continue
+    let digit = i + 1
+    while (text.charCodeAt(digit) === 48) digit++
+    if (
+      isDigit(text.charCodeAt(digit)) &&
+      isDigit(text.charCodeAt(digit + 1)) &&
+      isDigit(text.charCodeAt(digit + 2))
+    ) {
+      return true
+    }
   }
-  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`
-  if (typeof value === "object") {
-    const record = value as Record<string, unknown>
-    const entries = Object.keys(record)
-      .sort()
-      .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
-    return `{${entries.join(",")}}`
+  return false
+}
+
+/** A `JSON.parse` reviver that keeps a lossy number's own text and reads every other value as usual. */
+function keepLossyNumberText(
+  _key: string,
+  value: unknown,
+  context?: { readonly source?: string },
+): unknown {
+  if (typeof value !== "number") return value
+  const source = context?.source
+  // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: the member is optional, so an engine without JSON.rawJSON leaves it undefined.
+  const rawJson = (JSON as JSON & { readonly rawJSON?: (text: string) => unknown }).rawJSON
+  // Unable to keep the text, the caller fingerprints the exact bytes rather than a rounded number.
+  if (source === undefined || rawJson === undefined) {
+    throw new TypeError("no JSON number source text")
   }
-  throw new TypeError("unsupported JSON value")
+  return mayHoldLossyNumber(source) ? rawJson(source) : value
 }
 
+// Not fatal: Deno's fatal decode costs several times a replacing one; U+FFFD is checked for instead.
+const utf8 = new TextDecoder()
+
 /** Canonicalize JSON bodies so whitespace/property-order retries bind to the same semantic request. */
 export function canonicalizeIdempotencyBody(
   body: Uint8Array,
@@ -206,7 +241,14 @@ export function canonicalizeIdempotencyBody(
   const mediaType = contentType?.split(";", 1)[0]?.trim().toLowerCase() ?? ""
   if (mediaType !== "application/json" && !mediaType.endsWith("+json")) return body
   try {
-    return encoder.encode(canonicalJson(JSON.parse(new TextDecoder().decode(body))))
+    const text = utf8.decode(body)
+    // Every invalid byte decodes to U+FFFD, so two different bodies could read the same: such a
+    // body, or one that writes U+FFFD itself, keeps its exact bytes.
+    if (text.includes("\uFFFD")) return body
+    const parsed: unknown = mayHoldLossyNumber(text)
+      ? JSON.parse(text, keepLossyNumberText)
+      : JSON.parse(text)
+    return encoder.encode(canonicalJson(parsed))
   } catch {
     // Invalid JSON is rejected by the validation/body lane. Preserve its raw bytes for a stable
     // fingerprint until that rejection releases the reservation.

package/src/index.ts

@@ -16,7 +16,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 = "5.7.0" as const
+export const VERSION = "5.9.0" as const
 
 export type Version = typeof VERSION
 
@@ -85,7 +85,13 @@ export {
   type ScheduledHandler,
   toFetchHandler,
 } from "./server/edge.ts"
-export { isSameOriginPath, pathnameOf, type UrlParts, urlPartsOf } from "./server/http.ts"
+export {
+  isSameOriginPath,
+  pathnameOf,
+  type UrlParts,
+  urlPartsOf,
+  varyOn,
+} from "./server/http.ts"
 export {
   commonSecretPatterns,
   jsonLogger,
@@ -119,6 +125,11 @@ export type {
   RouteInfoFor,
 } from "./server/registry.ts"
 export { replacedRequestOf } from "./server/request-lineage.ts"
+export {
+  carryRequestLocals,
+  type RequestLocal,
+  requestLocal,
+} from "./server/request-local.ts"
 export { writableResponse } from "./server/respond.ts"
 export { routeTemplateOf } from "./server/route-template.ts"
 export {

package/src/internal/control-character.ts

@@ -0,0 +1,8 @@
+/** Whether `value` holds a C0 control character or DEL. */
+export function hasControlCharacter(value: string): boolean {
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index)
+    if (code <= 31 || code === 127) return true
+  }
+  return false
+}

package/src/internal/durable-shared.ts

@@ -40,7 +40,10 @@ export function addDuration(timestamp: number, duration: number, label: string):
 export function bytesToBase64Url(bytes: Uint8Array): string {
   let binary = ""
   for (const byte of bytes) binary += String.fromCharCode(byte)
-  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "")
+  return btoa(binary)
+    .replaceAll("+", "-")
+    .replaceAll("/", "_")
+    .replace(/={1,2}$/u, "")
 }
 
 export async function sha256(value: string): Promise<string> {

package/src/internal/hex.ts

@@ -0,0 +1,14 @@
+const encoder = new TextEncoder()
+
+/** Lowercase hex, two digits a byte. */
+export function bytesToHex(bytes: Uint8Array): string {
+  let hex = ""
+  // Indexed: a for-of over the bytes runs 1.4x slower on Bun.
+  for (let i = 0; i < bytes.length; i++) hex += (bytes[i] ?? 0).toString(16).padStart(2, "0")
+  return hex
+}
+
+/** SHA-256 of `text`'s UTF-8 bytes, as lowercase hex. */
+export async function sha256Hex(text: string): Promise<string> {
+  return bytesToHex(new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(text))))
+}

package/src/internal/record.ts

@@ -0,0 +1,4 @@
+/** A non-null, non-array object. The prototype is not checked: a `Date` or a `Map` passes. */
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}

package/src/internal/route-compiler.ts

@@ -17,6 +17,7 @@ import { assertByteLimit } from "../server/body.ts"
 import type { RouteSchema } from "../server/context.ts"
 import type { IdempotencyRuntime, ResolvedIdempotency } from "../server/idempotency-lane.ts"
 import type { EffectLedgerRuntime, ResolvedEffectLedger } from "../server/ledger-lane.ts"
+import { decorationsAssignable } from "../server/request-context.ts"
 import type {
   ResponseContractDefinition,
   ResponseContractRuntime,
@@ -136,7 +137,6 @@ export function adoptRouteRuntimes(
     hasIdempotency: entry.idempotent !== undefined,
     hasLedger: ledgered !== undefined,
     hasResponseContract: responseContract !== undefined,
-    hasDecorations: entry.hasDecorations,
     derives: entry.derives.length,
     beforeHandle: entry.beforeHandle.length,
     afterHandle: entry.afterHandle.length,
@@ -297,7 +297,7 @@ export function compileRouteOptions(
     hasIdempotency: idempotent !== undefined,
     hasLedger: ledgered !== undefined,
     hasResponseContract: contracted !== undefined,
-    hasDecorations,
+    decorationsAssignable: !hasDecorations || decorationsAssignable(routeDecorations),
     derives: context.derives.length,
     beforeHandle: context.beforeHandleHooks.length,
     afterHandle: context.afterHandleHooks.length,

package/src/internal/route-execution.ts

@@ -140,15 +140,7 @@ export function compileRouteExecutionPlan(options: {
   readonly hasLedger: boolean
   readonly fusedWeb: FusedWebRunner | undefined
   readonly fusedBody: FusedBodyRunner | undefined
-  readonly fusedLane:
-    | "bare"
-    | "body"
-    | "query"
-    | "derive-before"
-    | "derive-before-after"
-    | "body-derive-before"
-    | "body-derive-before-after"
-    | undefined
+  readonly fusedLane: "bare" | "body" | "query" | "hooks" | "body-hooks" | undefined
 }): RouteExecutionPlan {
   const { lane, contextless, hasAround, hasLedger, fusedWeb, fusedBody, fusedLane } = options
 
@@ -254,6 +246,9 @@ export function compileRouteExecutionPlan(options: {
           maxBodyBytes,
           server.protoPoisoning,
         )
+    // `c.json` writes by the route's contract, if it has one, so the reply and its check share one walk.
+    // Only then: one more own property moves a context that holds a body out of its inline slots.
+    if (entry.responseContract !== undefined) ctx.jsonContract = entry.responseContract
     let ledger: RequestLedger | undefined
     // The runtime is always present when a route resolved a ledger (enforced at registration).
     const ledgerRuntime = server.effectLedgerRuntime
@@ -286,15 +281,7 @@ export interface RouteExecutionPlan {
   /** Which builder produced {@link fusedWeb} - a merge rebinds the closure to the executing server
    * and must rebuild it with the SAME semantics (a query-fused route rebuilt as bare would skip its
    * validation). `undefined` iff `fusedWeb` is. */
-  readonly fusedLane:
-    | "bare"
-    | "body"
-    | "query"
-    | "derive-before"
-    | "derive-before-after"
-    | "body-derive-before"
-    | "body-derive-before-after"
-    | undefined
+  readonly fusedLane: "bare" | "body" | "query" | "hooks" | "body-hooks" | undefined
 }
 
 export interface RouteEntry {
@@ -334,8 +321,8 @@ export interface RouteEntry {
   readonly beforeHandle: ReadonlyArray<RawBeforeHandle>
   readonly afterHandle: ReadonlyArray<RawAfterHandle>
   readonly onError: ReadonlyArray<RawErrorHandler>
-  /** Registration-specialized hook shape for the common derive + before middleware route. */
-  readonly lifecycleHookLane: "derive-before" | "derive-before-after" | undefined
+  /** Registration-specialized hook shape: a route whose only lifecycle steps are derive, before and after hooks. */
+  readonly lifecycleHookLane: "hooks" | undefined
   /** Wraps the matched route lifecycle. Empty for the common no-around path. */
   readonly around: ReadonlyArray<RawAround>
   /** The single immutable execution decision consumed by portable, Node-direct, and Bun-native paths. */

package/src/internal/route-lanes.ts

@@ -17,16 +17,8 @@ export interface RouteLaneSelection {
   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
+  readonly lifecycleHookLane: "hooks" | undefined
+  readonly fusedLane: "bare" | "body" | "query" | "hooks" | "body-hooks" | undefined
 }
 
 export function selectRouteLanes(options: {
@@ -35,7 +27,8 @@ export function selectRouteLanes(options: {
   readonly hasIdempotency: boolean
   readonly hasLedger: boolean
   readonly hasResponseContract: boolean
-  readonly hasDecorations: boolean
+  /** False when a decoration cannot be merged into the context, which keeps the fused hook lanes off. */
+  readonly decorationsAssignable?: boolean
   readonly derives: number
   readonly beforeHandle: number
   readonly afterHandle: number
@@ -48,7 +41,7 @@ export function selectRouteLanes(options: {
     hasIdempotency,
     hasLedger,
     hasResponseContract,
-    hasDecorations,
+    decorationsAssignable = true,
     derives,
     beforeHandle,
     afterHandle,
@@ -153,39 +146,31 @@ export function selectRouteLanes(options: {
           ? "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, headers, or cookies schema
-  // routes back to the generic lane because the fused builder has no validation step for them
-  // 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.
+  // A route whose only lifecycle steps are derive, before and after hooks (any number of each, at least
+  // one) runs them in one fused closure chain, with the route's decorations and error hooks. Anything
+  // that can observe around hooks, a response contract or a validation-error recovery keeps the
+  // generic runner. A params, headers or cookies schema
+  // routes back to the generic lane because the fused builder has no validation step for them, and a
+  // `body` schema is the `body-hooks` lane below because this one does not parse the body.
+  const hookCount = derives + beforeHandle + afterHandle
   const lifecycleHookLane =
     lane === "lifecycle" &&
     !authBeforeValidation &&
     !hasResponseContract &&
-    !hasDecorations &&
+    decorationsAssignable &&
     !hasIdempotency &&
     !hasLedger &&
     schema?.onValidationError === undefined &&
     !defaultOnValidationError &&
     plain &&
     schema?.body === undefined &&
-    derives === 1 &&
-    beforeHandle === 1 &&
-    afterHandle <= 1 &&
-    onError === 0 &&
+    hookCount > 0 &&
     around === 0
-      ? afterHandle === 0
-        ? "derive-before"
-        : "derive-before-after"
+      ? "hooks"
       : 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.
+  // The same hooks around a body schema: the fused closure runs parse, validate, derive, before,
+  // handler and after in one function frame, the win `fusedBody` already gives the no-hooks shape.
   const fusedBodyLifecycle =
     lane === "lifecycle" &&
     !authBeforeValidation &&
@@ -195,13 +180,10 @@ export function selectRouteLanes(options: {
     schema?.onValidationError === undefined &&
     !defaultOnValidationError &&
     !hasResponseContract &&
-    !hasDecorations &&
+    decorationsAssignable &&
     !hasIdempotency &&
     !hasLedger &&
-    derives === 1 &&
-    beforeHandle === 1 &&
-    afterHandle <= 1 &&
-    onError === 0 &&
+    hookCount > 0 &&
     around === 0
 
   return {
@@ -220,13 +202,7 @@ export function selectRouteLanes(options: {
             ? "body"
             : bare
               ? "bare"
-              : lifecycleHookLane !== undefined
-                ? (lifecycleHookLane as "derive-before" | "derive-before-after")
-                : fusedBodyLifecycle
-                  ? afterHandle === 0
-                    ? "body-derive-before"
-                    : "body-derive-before-after"
-                  : undefined
+              : (lifecycleHookLane ?? (fusedBodyLifecycle ? "body-hooks" : undefined))
         : undefined,
   }
 }

package/src/internal/schema-parts.ts

@@ -0,0 +1,19 @@
+const SCHEMA_PARTS = ["headers", "cookies", "body", "query", "params", "response"] as const
+
+type SchemaPartKey = (typeof SCHEMA_PARTS)[number]
+
+/**
+ * Each request and response schema part of `source` that `map` turns into a value, under its own key,
+ * in the order route reflections, evidence and snapshots all write them.
+ */
+export function mapSchemaParts<In, Out>(
+  source: { readonly [K in SchemaPartKey]?: In },
+  map: (part: In | undefined) => Out | undefined,
+): { [K in SchemaPartKey]?: Out } {
+  const parts: { [K in SchemaPartKey]?: Out } = {}
+  for (const key of SCHEMA_PARTS) {
+    const part = map(source[key])
+    if (part !== undefined) parts[key] = part
+  }
+  return parts
+}

package/src/ledger.ts

@@ -15,6 +15,7 @@
  */
 
 import { validCapabilityId } from "./internal/capability-runtime.ts"
+import { bytesToHex, sha256Hex } from "./internal/hex.ts"
 
 /** Lifecycle phase of one effect. `intent` precedes execution; the rest describe its outcome. */
 export type EffectPhase = "intent" | "committed" | "failed" | "compensated"
@@ -341,17 +342,6 @@ function canonicalEntry(entry: EffectEntry): string {
   )
 }
 
-const encoder = new TextEncoder()
-
-async function sha256Hex(value: string): Promise<string> {
-  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(value)))
-  let hex = ""
-  for (let index = 0; index < digest.length; index++) {
-    hex += (digest[index] as number).toString(16).padStart(2, "0")
-  }
-  return hex
-}
-
 export interface MemoryLedgerSinkOptions {
   /** Retain at most this many sealed ledgers (oldest evicted first). Default 1000. */
   readonly maxLedgers?: number
@@ -440,11 +430,7 @@ export async function computeEffectDigest(
   const mac = new Uint8Array(
     await crypto.subtle.sign("HMAC", cryptoKey, payload as unknown as ArrayBuffer),
   )
-  let hex = ""
-  for (let index = 0; index < mac.length; index++) {
-    hex += (mac[index] as number).toString(16).padStart(2, "0")
-  }
-  return hex
+  return bytesToHex(mac)
 }
 
 const EFFECT_LEDGER = Symbol("nifra.effect.ledger")