@nifrajs/cli 2.0.0 → 2.1.0

package/docs/types.json

@@ -303,6 +303,90 @@
     "signature": "export declare function applyResponseHeaders(headers: Headers, res: NodeHeaderSink): void;",
     "doc": "/**\n * Copy a Web `Response`'s headers onto a Node response, emitting EACH `Set-Cookie` as its own header. The\n * `Headers` iterator (and `.get`) join multiple set-cookie values with \", \", which corrupts cookies — e.g.\n * better-auth's `session_token` + `session_data` collapse into one unparseable cookie and the session is\n * silently lost. `getSetCookie()` returns them split; Node's `setHeader` emits one header per array element.\n */"
   },
+  {
+    "name": "ApprovalBindingError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class ApprovalBindingError extends Error {\n    constructor();\n}"
+  },
+  {
+    "name": "ApprovalConsumeResult",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ApprovalConsumeResult = {\n    readonly state: \"consumed\";\n} | {\n    readonly state: \"missing\" | \"pending\" | \"denied\" | \"expired\" | \"replay\" | \"binding\" | \"token\";\n};"
+  },
+  {
+    "name": "ApprovalCoordinator",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ApprovalCoordinator extends CapabilityApprovalGate {\n    decide(input: {\n        readonly approvalId: string;\n        readonly tenantId: string;\n        readonly decision: \"approved\" | \"denied\";\n        readonly decidedBy: string;\n    }): Promise<void>;\n    get(approvalId: string): Promise<ApprovalRecord | undefined>;\n}"
+  },
+  {
+    "name": "ApprovalCoordinatorOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ApprovalCoordinatorOptions {\n    readonly store: ApprovalStore;\n    /** At least 32 random bytes, kept separately from the approval store. */\n    readonly secret: Uint8Array;\n    readonly ttlMs?: number;\n    readonly now?: () => number;\n    /** Tests/local development only. Production approval records require a durable store. */\n    readonly allowMemoryStore?: boolean;\n}"
+  },
+  {
+    "name": "ApprovalDeniedError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class ApprovalDeniedError extends Error {\n    constructor();\n}"
+  },
+  {
+    "name": "ApprovalPendingError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class ApprovalPendingError extends Error {\n    constructor();\n}"
+  },
+  {
+    "name": "ApprovalRecord",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ApprovalRecord {\n    readonly approvalId: string;\n    readonly effectId: string;\n    readonly capability: string;\n    readonly target?: string;\n    readonly digest?: string;\n    readonly tenantId: string;\n    readonly principalId: string;\n    readonly tokenHash: string;\n    readonly state: ApprovalState;\n    readonly createdAt: number;\n    readonly expiresAt: number;\n    readonly updatedAt: number;\n    readonly decidedBy?: string;\n    readonly version: number;\n}"
+  },
+  {
+    "name": "ApprovalRequiredError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class ApprovalRequiredError extends Error {\n    readonly approvalId: string;\n    readonly effectId: string;\n    readonly resumeToken: string;\n    readonly expiresAt: number;\n    constructor(approvalId: string, effectId: string, resumeToken: string, expiresAt: number);\n}"
+  },
+  {
+    "name": "ApprovalState",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ApprovalState = \"pending\" | \"approved\" | \"denied\" | \"consumed\" | \"expired\";"
+  },
+  {
+    "name": "ApprovalStore",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ApprovalStore {\n    readonly durability?: \"memory\" | \"durable\";\n    create(record: ApprovalRecord): boolean | Promise<boolean>;\n    get(approvalId: string): ApprovalRecord | undefined | Promise<ApprovalRecord | undefined>;\n    decide(input: {\n        readonly approvalId: string;\n        readonly tenantId: string;\n        readonly decision: \"approved\" | \"denied\";\n        readonly decidedBy: string;\n        readonly now: number;\n    }): boolean | Promise<boolean>;\n    /**\n     * Atomically validate binding/token/state and change `approved` to `consumed`. Two concurrent\n     * callers with one token must yield exactly one `consumed` and one `replay` result.\n     */\n    consume(input: {\n        readonly approvalId: string;\n        readonly tenantId: string;\n        readonly principalId: string;\n        readonly capability: string;\n        readonly target?: string;\n        readonly digest?: string;\n        readonly tokenHash: string;\n        readonly now: number;\n    }): ApprovalConsumeResult | Promise<ApprovalConsumeResult>;\n}"
+  },
+  {
+    "name": "ApprovalTokenExpiredError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class ApprovalTokenExpiredError extends Error {\n    constructor();\n}"
+  },
+  {
+    "name": "ApprovalTokenInvalidError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class ApprovalTokenInvalidError extends Error {\n    constructor();\n}"
+  },
+  {
+    "name": "ApprovalTokenReplayError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class ApprovalTokenReplayError extends Error {\n    constructor();\n}"
+  },
+  {
+    "name": "AroundCapabilityOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface AroundCapabilityOptions {\n    /** Maximum admission time in milliseconds. Default 30_000. */\n    readonly timeoutMs?: number;\n}"
+  },
   {
     "name": "assertAdapterCertification",
     "kind": "function",
@@ -648,6 +732,12 @@
     "package": "@nifrajs/middleware",
     "signature": "export interface BearerOptions<P> {\n    /** Verify a bearer token → a principal (truthy) or `null`/`undefined` (rejected). May be async\n     * (DB/JWT lookup). For a constant-secret comparison, use a constant-time compare — never `===`. */\n    readonly verify: (token: string) => MaybePromise<P | null | undefined>;\n    /** When `true`, requests without a valid token pass through (`principal` is `null`) instead of `401`. */\n    readonly optional?: boolean;\n    /** `realm` for the `WWW-Authenticate: Bearer` header on `401`. Default `\"api\"`. */\n    readonly realm?: string;\n}"
   },
+  {
+    "name": "beginRequestEffectTracking",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function beginRequestEffectTracking(request: Request): EffectEvidenceScope;"
+  },
   {
     "name": "betterAuth",
     "kind": "function",
@@ -981,6 +1071,25 @@
     "package": "@nifrajs/core",
     "signature": "export type CapabilityAccess = \"read\" | \"write\";"
   },
+  {
+    "name": "CapabilityAdmissionAbortedError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class CapabilityAdmissionAbortedError extends Error {\n    readonly capability: string;\n    readonly effectId: string;\n    constructor(capability: string, effectId: string);\n}",
+    "doc": "/** The request was cancelled while capability admission was pending. */"
+  },
+  {
+    "name": "CapabilityApprovalGate",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface CapabilityApprovalGate {\n    authorize(input: {\n        readonly effectId: string;\n        readonly capability: string;\n        readonly target?: string;\n        readonly digest?: string;\n        readonly identity: CapabilityExecutionIdentity;\n        readonly resumeToken?: string;\n        readonly signal: AbortSignal;\n    }): void | PromiseLike<void>;\n}"
+  },
+  {
+    "name": "CapabilityApprovalInput",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface CapabilityApprovalInput extends CapabilityExecutionIdentity {\n    /** Signed token returned by the approval coordinator after the first suspended attempt. */\n    readonly resumeToken?: string;\n}"
+  },
   {
     "name": "CapabilityAssuranceReport",
     "kind": "interface",
@@ -993,6 +1102,13 @@
     "package": "@nifrajs/core",
     "signature": "export interface CapabilityDefinition {\n    readonly id: string;\n    /** Domain state is subject to HTTP method semantics; operational writes (logs/metrics) are not. */\n    readonly zone: CapabilityZone;\n    readonly access: CapabilityAccess;\n    /** Evidence required when this capability may execute. Default `none`. */\n    readonly idempotency?: CapabilityIdempotency;\n}"
   },
+  {
+    "name": "CapabilityDeniedError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class CapabilityDeniedError extends Error {\n    readonly capability: string;\n    readonly effectId: string;\n    constructor(capability: string, effectId: string);\n}",
+    "doc": "/** A capability admission policy returned without calling `next()`. */"
+  },
   {
     "name": "CapabilityEvidence",
     "kind": "interface",
@@ -1012,6 +1128,40 @@
     "package": "@nifrajs/core",
     "signature": "export interface CapabilityEvidenceSet {\n    readonly routes: readonly RouteCapabilityEvidence[];\n}"
   },
+  {
+    "name": "CapabilityExecutionContext",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface CapabilityExecutionContext {\n    readonly effectId: string;\n    readonly signal: AbortSignal;\n}",
+    "doc": "/** Context passed to the owned effect callback. Use the signal for cancellation-aware I/O. */"
+  },
+  {
+    "name": "CapabilityExecutionIdentity",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface CapabilityExecutionIdentity {\n    readonly tenantId: string;\n    readonly principalId: string;\n}",
+    "doc": "/** Server-owned identity binding for durable admission. Values are opaque tokens, never payloads. */"
+  },
+  {
+    "name": "CapabilityExecutionJournal",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface CapabilityExecutionJournal {\n    intent(input: {\n        readonly effectId: string;\n        readonly capability: string;\n        readonly target?: string;\n        readonly digest?: string;\n        readonly identity?: CapabilityExecutionIdentity;\n    }): void | PromiseLike<void>;\n    executing(effectId: string): void | PromiseLike<void>;\n    committed(effectId: string): void | PromiseLike<void>;\n    failed(effectId: string, input: {\n        readonly began: boolean;\n        readonly errorCode: string;\n    }): void | PromiseLike<void>;\n}",
+    "doc": "/** Durable, token-only journal seam. Implementations must fail closed on transition failure. */"
+  },
+  {
+    "name": "CapabilityExecutionOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface CapabilityExecutionOptions extends UseCapabilityOptions {\n    readonly approval?: CapabilityApprovalInput & {\n        readonly gate: CapabilityApprovalGate;\n    };\n    readonly journal?: CapabilityExecutionJournal;\n}",
+    "doc": "/** Durable controls consumed by `executeCapability`; none of these fields enter the effect ledger. */"
+  },
+  {
+    "name": "CapabilityExecutor",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type CapabilityExecutor<T> = (execution: CapabilityExecutionContext) => T | PromiseLike<T>;"
+  },
   {
     "name": "CapabilityFinding",
     "kind": "interface",
@@ -1028,7 +1178,7 @@
     "name": "CapabilityGuard",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface CapabilityGuard {\n    readonly allowed: readonly string[];\n    readonly method: string;\n    readonly path: string;\n    readonly onUse?: (event: CapabilityUseEvent) => void;\n}"
+    "signature": "export interface CapabilityGuard {\n    readonly allowed: readonly string[];\n    readonly method: string;\n    readonly path: string;\n    readonly onUse?: (event: CapabilityUseEvent) => void;\n    readonly trackEffect?: (context: object, committed: boolean) => void;\n    readonly interceptors: readonly RegisteredCapabilityInterceptor[];\n    readonly observers: readonly EffectLifecycleObserver[];\n}"
   },
   {
     "name": "CapabilityIdempotency",
@@ -1048,6 +1198,47 @@
     "package": "@nifrajs/cli",
     "signature": "export interface CapabilityImportViolation {\n    readonly method: string;\n    readonly path: string;\n    readonly module: string;\n    readonly specifier: string;\n    readonly reason: string;\n    readonly chain: readonly string[];\n}"
   },
+  {
+    "name": "CapabilityInterceptor",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type CapabilityInterceptor = (event: CapabilityInterceptorEvent, next: CapabilityInterceptorNext) => void | PromiseLike<void>;"
+  },
+  {
+    "name": "CapabilityInterceptorEvent",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface CapabilityInterceptorEvent extends CapabilityUseEvent {\n    readonly effectId: string;\n    readonly signal: AbortSignal;\n    readonly target?: string;\n    readonly cost?: EffectCost;\n    readonly digest?: string;\n}",
+    "doc": "/** Token-only metadata supplied to an asynchronous capability admission interceptor. */"
+  },
+  {
+    "name": "CapabilityInterceptorNext",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type CapabilityInterceptorNext = () => Promise<void>;",
+    "doc": "/** Continue to the next admission policy. The owned effect runs only after the full chain admits. */"
+  },
+  {
+    "name": "CapabilityInterceptorProtocolError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class CapabilityInterceptorProtocolError extends Error {\n    readonly capability: string;\n    readonly effectId: string;\n    constructor(capability: string, effectId: string);\n}",
+    "doc": "/** An interceptor called its one-shot `next()` continuation more than once. */"
+  },
+  {
+    "name": "CapabilityInterceptorTimeoutError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class CapabilityInterceptorTimeoutError extends Error {\n    readonly capability: string;\n    readonly effectId: string;\n    readonly timeoutMs: number;\n    constructor(capability: string, effectId: string, timeoutMs: number);\n}",
+    "doc": "/** A capability admission policy exceeded its configured bound. */"
+  },
+  {
+    "name": "CapabilityJournalTransitionError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class CapabilityJournalTransitionError extends Error {\n    readonly capability: string;\n    readonly effectId: string;\n    readonly transition: \"committed\";\n    constructor(capability: string, effectId: string, transition: \"committed\");\n}",
+    "doc": "/** The effect may have committed, but its durable terminal transition could not be recorded. */"
+  },
   {
     "name": "CapabilityOutcomeOptions",
     "kind": "interface",
@@ -1456,7 +1647,7 @@
     "name": "ClientOptions",
     "kind": "interface",
     "package": "@nifrajs/client",
-    "signature": "export interface ClientOptions {\n    /** Headers sent on every request (a per-call `headers` option is merged on top). */\n    readonly headers?: Record<string, string>;\n    /** Override the `fetch` implementation (tests, an in-process bridge, a custom agent, etc.). */\n    readonly fetch?: FetchFn;\n    /**\n     * Runs before each request (including each retry). Return a header map to MERGE onto the outgoing\n     * request — the place to inject a fresh auth token. `await`ed, so async token refresh works.\n     */\n    readonly onRequest?: (request: {\n        readonly url: string;\n        readonly method: string;\n        readonly headers: Record<string, string>;\n        readonly body: unknown;\n    }) => MaybePromise<Record<string, string> | undefined>;\n    /** Runs after a response arrives (once per call, on the final response). Observe-only. */\n    readonly onResponse?: (response: {\n        readonly url: string;\n        readonly method: string;\n        readonly response: Response;\n    }) => MaybePromise<void>;\n    /** Abort a call that takes longer than this many ms. Surfaces as `{ ok: false, status: 0 }` with a\n     * `timeout` error, never a throw. Combined with a per-call `signal`. */\n    readonly timeoutMs?: number;\n    /** Enable safe automatic retries. See {@link ClientRetryOptions}. */\n    readonly retry?: ClientRetryOptions;\n}"
+    "signature": "export interface ClientOptions {\n    /** Headers sent on every request (a per-call `headers` option is merged on top). */\n    readonly headers?: Record<string, string>;\n    /** Override the `fetch` implementation (tests, an in-process bridge, a custom agent, etc.). */\n    readonly fetch?: FetchFn;\n    /**\n     * Runs before each request (including each retry). Return a header map to MERGE onto the outgoing\n     * request — the place to inject a fresh auth token. `await`ed, so async token refresh works.\n     */\n    readonly onRequest?: (request: {\n        readonly url: string;\n        readonly method: string;\n        readonly headers: Record<string, string>;\n        readonly body: unknown;\n    }) => MaybePromise<Record<string, string> | undefined>;\n    /** Runs after a response arrives (once per call, on the final response). Observe-only. */\n    readonly onResponse?: (response: {\n        readonly url: string;\n        readonly method: string;\n        readonly response: Response;\n    }) => MaybePromise<void>;\n    /** Abort a call that takes longer than this many ms. Surfaces as `{ ok: false, status: 0 }` with a\n     * `timeout` error, never a throw. Combined with a per-call `signal`. */\n    readonly timeoutMs?: number;\n    /** Enable safe automatic retries. See {@link ClientRetryOptions}. */\n    readonly retry?: ClientRetryOptions;\n    /**\n     * Opt into a versioned transport representation. Plain JSON remains the default. Responses are\n     * decoded through the bounded registry, and WebSocket frames use the same codec.\n     */\n    readonly transport?: {\n        readonly codec: TransportCodec;\n        readonly registry?: TransportCodecRegistry;\n        readonly maxBytes?: number;\n    };\n}"
   },
   {
     "name": "ClientRetryOptions",
@@ -1962,6 +2153,12 @@
     "signature": "export declare function createAdmissionController(options: AdmissionOptions): AdmissionControllerHandle;",
     "doc": "/**\n * Build a capacity-admission controller. Pass the returned handle as the server's `admission` option.\n */"
   },
+  {
+    "name": "createApprovalCoordinator",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createApprovalCoordinator(options: ApprovalCoordinatorOptions): ApprovalCoordinator;"
+  },
   {
     "name": "createBunWsHandlers",
     "kind": "function",
@@ -1987,7 +2184,7 @@
     "name": "createCapabilityGuard",
     "kind": "function",
     "package": "@nifrajs/core",
-    "signature": "export declare function createCapabilityGuard(allowed: readonly string[], method: string, path: string, onUse: ((event: CapabilityUseEvent) => void) | undefined): CapabilityGuard;"
+    "signature": "export declare function createCapabilityGuard(allowed: readonly string[], method: string, path: string, onUse: ((event: CapabilityUseEvent) => void) | undefined, trackEffect: ((context: object, committed: boolean) => void) | undefined, interceptors: readonly RegisteredCapabilityInterceptor[], observers: readonly EffectLifecycleObserver[]): CapabilityGuard;"
   },
   {
     "name": "createClientRouter",
@@ -2009,6 +2206,25 @@
     "signature": "export declare function createDevServer(options: DevServerOptions): Promise<DevServer>;",
     "doc": "/** Start the dev server: build → serve → watch → rebuild + reload on change. */"
   },
+  {
+    "name": "createDurableEffectJournal",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createDurableEffectJournal(options: DurableEffectJournalOptions): CapabilityExecutionJournal;"
+  },
+  {
+    "name": "createDurableExecutionAdapter",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createDurableExecutionAdapter(backend: DurableRecordBackend): DurableExecutionAdapter;"
+  },
+  {
+    "name": "createEffectEvidenceScope",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createEffectEvidenceScope(): EffectEvidenceScope;",
+    "doc": "/** Lightweight aggregate evidence shared by request idempotency and full owned-effect runners. */"
+  },
   {
     "name": "createEffectLedgerRuntime",
     "kind": "function",
@@ -2016,6 +2232,12 @@
     "signature": "export declare function createEffectLedgerRuntime(options: EffectLedgerOptions): EffectLedgerRuntime;",
     "doc": "/**\n * Build an effect-ledger runtime from the app-wide options. `sink` receives the sealed, token-only\n * ledger when a capability-declaring route settles with recorded entries; `maxEntries` bounds a single\n * request's ledger; `chain` opts into the per-entry hash chain.\n */"
   },
+  {
+    "name": "createEffectScope",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createEffectScope(options?: EffectScopeOptions, evidenceScope?: EffectEvidenceScope): EffectScope;"
+  },
   {
     "name": "createEventLoopLagSampler",
     "kind": "function",
@@ -2192,6 +2414,12 @@
     "package": "@nifrajs/core",
     "signature": "export interface CreateRequestLedgerOptions {\n    /** HTTP method of the matched route. */\n    readonly method: string;\n    /** The registered route pattern — callers must never pass the concrete request URL. */\n    readonly path: string;\n    /** The route's declared capability tokens, surfaced verbatim on the sealed ledger. Default `[]`. */\n    readonly declared?: readonly string[];\n    /** Entry bound; exceeding it throws {@link EffectLedgerOverflowError}. Default {@link DEFAULT_MAX_ENTRIES}. */\n    readonly maxEntries?: number;\n    /** Compute the tamper-evident hash chain at seal. Default false. */\n    readonly chain?: boolean;\n    /** Injectable monotonic clock (ms) for deterministic tests. Default `performance.now`. */\n    readonly clock?: () => number;\n}"
   },
+  {
+    "name": "createSagaEngine",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createSagaEngine(options: SagaEngineOptions): SagaEngine;"
+  },
   {
     "name": "createScheduler",
     "kind": "function",
@@ -2212,6 +2440,12 @@
     "signature": "export declare function createStylesheetEmitter(build: PluginBuilder, namespace: string): StylesheetEmitter;",
     "doc": "/**\n * Wire the virtual-CSS-module handlers onto `build` for `namespace`, returning an {@link StylesheetEmitter}.\n * The `namespace` must be a plain identifier (letters/`-`); it's used verbatim as the import suffix and\n * the Bun namespace. Only the `\"dom\"` build should emit CSS — the `\"ssr\"` build ships no stylesheet.\n */"
   },
+  {
+    "name": "createTransportCodecRegistry",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createTransportCodecRegistry(codecs: readonly TransportCodec[], fallback?: TransportCodec): TransportCodecRegistry;"
+  },
   {
     "name": "createUnboundedRequestBudget",
     "kind": "function",
@@ -2416,6 +2650,13 @@
     "signature": "export declare function declaredCapabilities(context: object): readonly string[];",
     "doc": "/**\n * Read the route's token-only declaration for admission plugins. This intentionally exposes neither\n * the request nor runtime evidence; it is the stable public seam for private entitlement policy.\n */"
   },
+  {
+    "name": "decode",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function decode(wire: Wire, limits?: WireDecodeLimits): unknown;",
+    "doc": "/** Reconstruct the original value from a {@link Wire} form produced by {@link encode}. */"
+  },
   {
     "name": "decodeBase64",
     "kind": "function",
@@ -2443,12 +2684,30 @@
     "signature": "export declare function decodeRouteParams(raw: Record<string, string>): Record<string, string> | null;",
     "doc": "/** Decode router captures under one rule. Plain values take the zero-allocation path; malformed\n * escapes return `null`, allowing HTTP to emit 400 while client navigation declines the match. */"
   },
+  {
+    "name": "decodeTransportFrame",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function decodeTransportFrame(frame: string, registry?: TransportCodecRegistry, options?: TransportDecodeOptions): unknown;"
+  },
+  {
+    "name": "decodeTransportResponse",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function decodeTransportResponse(response: Response, registry?: TransportCodecRegistry, options?: TransportDecodeOptions): Promise<unknown>;"
+  },
   {
     "name": "DEFAULT_ASSURANCE_CONFIG",
     "kind": "const",
     "package": "@nifrajs/cli",
     "signature": "export declare const DEFAULT_ASSURANCE_CONFIG = \"nifra.assurance.ts\";"
   },
+  {
+    "name": "DEFAULT_CAPABILITY_INTERCEPTOR_TIMEOUT_MS",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const DEFAULT_CAPABILITY_INTERCEPTOR_TIMEOUT_MS = 30000;"
+  },
   {
     "name": "DEFAULT_DEV_PORT",
     "kind": "const",
@@ -2489,6 +2748,18 @@
     "package": "@nifrajs/cli",
     "signature": "export declare const DEFAULT_SNAPSHOT_FILE = \"api-snapshot.json\";"
   },
+  {
+    "name": "DEFAULT_WIRE_DECODE_LIMITS",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const DEFAULT_WIRE_DECODE_LIMITS: Readonly<Required<WireDecodeLimits>>;"
+  },
+  {
+    "name": "defaultTransportCodecs",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const defaultTransportCodecs: TransportCodecRegistry;"
+  },
   {
     "name": "defer",
     "kind": "function",
@@ -2617,6 +2888,12 @@
     "signature": "export declare const defineRouterPlugin: typeof defineIdentityPlugin;",
     "doc": "/**\n * Alias of {@link defineIdentityPlugin} with a name that says what it's FOR: a plugin that **mounts\n * routes/hooks but adds no context type** (an auth router, an audit logger). Use this - not\n * {@link definePlugin} - for any such plugin, or the typed client silently collapses to `any`. The\n * \"identity\" in {@link defineIdentityPlugin} refers to the type-identity it preserves; `defineRouterPlugin`\n * is the same thing under a clearer name.\n *\n * Mount routes as a **side effect**, then return the app unchanged (registering via `.get`/`.post` would\n * change the type away from the identity `S`; the mounted routes run but aren't in the caller's typed\n * registry - that's the trade that keeps everything else typed):\n *\n * ```ts\n * export const scim = defineRouterPlugin(\"scim\", (app) => {\n *   app.get(\"/scim/v2/Users\", listUsers) // side effect: mounted at runtime\n *   return app                           // return S unchanged → routes added after .use(scim) stay typed\n * })\n * const api = server().get(\"/a\", h).use(scim).get(\"/b\", h) // /a AND /b stay typed\n * ```\n */"
   },
+  {
+    "name": "defineSaga",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function defineSaga<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>): SagaDefinition<I, C>;"
+  },
   {
     "name": "DehydratedState",
     "kind": "interface",
@@ -2871,6 +3148,54 @@
     "package": "@nifrajs/cli",
     "signature": "export interface DuplicateInstallFinding {\n    readonly package: string;\n    readonly copies: readonly DuplicateInstallCopy[];\n}"
   },
+  {
+    "name": "DurableEffectJournalOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface DurableEffectJournalOptions {\n    readonly store: DurableEffectStore;\n    readonly now?: () => number;\n    /** Tests/local development only. Production journals require `store.durability === \"durable\"`. */\n    readonly allowMemoryStore?: boolean;\n}"
+  },
+  {
+    "name": "DurableEffectRecord",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface DurableEffectRecord {\n    readonly effectId: string;\n    readonly capability: string;\n    readonly target?: string;\n    readonly digest?: string;\n    readonly tenantId?: string;\n    readonly principalId?: string;\n    readonly state: DurableEffectState;\n    readonly createdAt: number;\n    readonly updatedAt: number;\n    readonly errorCode?: string;\n    readonly version: number;\n}"
+  },
+  {
+    "name": "DurableEffectState",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type DurableEffectState = \"admission\" | \"executing\" | \"committed\" | \"failed\" | \"unknown\";"
+  },
+  {
+    "name": "DurableEffectStore",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface DurableEffectStore {\n    readonly durability?: \"memory\" | \"durable\";\n    create(record: DurableEffectRecord): boolean | Promise<boolean>;\n    get(effectId: string): DurableEffectRecord | undefined | Promise<DurableEffectRecord | undefined>;\n    /** Atomic compare-and-set; exactly one caller may advance the supplied `version` and `from` state. */\n    transition(input: {\n        readonly effectId: string;\n        readonly version: number;\n        readonly from: DurableEffectState;\n        readonly to: DurableEffectState;\n        readonly updatedAt: number;\n        readonly errorCode?: string;\n    }): boolean | Promise<boolean>;\n    /** Bounded operational scan. Transition-only stores do not need to implement reconciliation. */\n    scan?(input: ReconciliationScanOptions<DurableEffectState>): ReconciliationScanPage<DurableEffectRecord> | Promise<ReconciliationScanPage<DurableEffectRecord>>;\n    /** @deprecated Compatibility fallback; production reconciliation should implement `scan`. */\n    list?(): readonly DurableEffectRecord[] | Promise<readonly DurableEffectRecord[]>;\n}"
+  },
+  {
+    "name": "DurableEffectTransitionError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class DurableEffectTransitionError extends Error {\n    readonly effectId: string;\n    readonly transition: string;\n    constructor(effectId: string, transition: string);\n}"
+  },
+  {
+    "name": "DurableExecutionAdapter",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface DurableExecutionAdapter {\n    readonly effects: DurableEffectStore;\n    readonly approvals: ApprovalStore;\n    readonly sagas: SagaStore;\n    readonly leases: ReconciliationLeaseStore;\n}"
+  },
+  {
+    "name": "DurableExecutionConformanceResult",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface DurableExecutionConformanceResult {\n    readonly effects: true;\n    readonly approvals: true;\n    readonly sagas: true;\n    readonly leases: true;\n}"
+  },
+  {
+    "name": "DurableObjectExecutionAdapter",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class DurableObjectExecutionAdapter implements DurableExecutionAdapter {\n    readonly effects: DurableEffectStore;\n    readonly approvals: ApprovalStore;\n    readonly sagas: SagaStore;\n    readonly leases: ReconciliationLeaseStore;\n    readonly backend: DurableObjectRecordBackend;\n    constructor(storage: DurableObjectStorage);\n}"
+  },
   {
     "name": "DurableObjectNamespaceLike",
     "kind": "interface",
@@ -2878,6 +3203,36 @@
     "signature": "export interface DurableObjectNamespaceLike {\n    idFromName(name: string): unknown;\n    get(id: unknown): {\n        fetch(request: Request): Promise<Response>;\n    };\n}",
     "doc": "/** Structural view of a Cloudflare Durable Object namespace binding — keeps `@cloudflare/workers-types`\n * out of `@nifrajs/core`. The real `DurableObjectNamespace` satisfies it. */"
   },
+  {
+    "name": "DurableObjectRecordBackend",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class DurableObjectRecordBackend implements DurableRecordBackend {\n    private readonly storage;\n    constructor(storage: DurableObjectStorage);\n    private recordKey;\n    private leaseKey;\n    create(kind: DurableRecordKind, id: string, record: {\n        readonly version: number;\n        readonly state?: string;\n        readonly updatedAt?: number;\n    }): Promise<boolean>;\n    get<T extends {\n        readonly version: number;\n    }>(kind: DurableRecordKind, id: string): Promise<T | undefined>;\n    compareAndSet(kind: DurableRecordKind, id: string, expectedVersion: number, record: {\n        readonly version: number;\n        readonly state?: string;\n        readonly updatedAt?: number;\n    }): Promise<boolean>;\n    scan<T extends {\n        readonly state: string;\n        readonly updatedAt: number;\n    }>(kind: DurableRecordKind, input: ReconciliationScanOptions<string>): Promise<ReconciliationScanPage<T>>;\n    acquireLease(input: Parameters<DurableRecordBackend[\"acquireLease\"]>[0]): Promise<ReconciliationLease | undefined>;\n    renewLease(input: Parameters<DurableRecordBackend[\"renewLease\"]>[0]): Promise<boolean>;\n    checkpointLease(input: Parameters<DurableRecordBackend[\"checkpointLease\"]>[0]): Promise<boolean>;\n    releaseLease(input: Parameters<DurableRecordBackend[\"releaseLease\"]>[0]): Promise<boolean>;\n}"
+  },
+  {
+    "name": "DurableObjectStorage",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface DurableObjectStorage extends DurableObjectStorageTransaction {\n    transaction<T>(closure: (transaction: DurableObjectStorageTransaction) => Promise<T>): Promise<T>;\n}"
+  },
+  {
+    "name": "DurableObjectStorageTransaction",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface DurableObjectStorageTransaction {\n    get<T = unknown>(key: string): Promise<T | undefined>;\n    put<T = unknown>(key: string, value: T): Promise<void>;\n    list<T = unknown>(options?: {\n        readonly prefix?: string;\n        readonly startAfter?: string;\n        readonly limit?: number;\n    }): Promise<Map<string, T>>;\n}"
+  },
+  {
+    "name": "DurableRecordBackend",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface DurableRecordBackend {\n    create(kind: DurableRecordKind, id: string, record: {\n        readonly version: number;\n        readonly state?: string;\n        readonly updatedAt?: number;\n    }): Promise<boolean>;\n    get<T extends {\n        readonly version: number;\n    }>(kind: DurableRecordKind, id: string): Promise<T | undefined>;\n    compareAndSet(kind: DurableRecordKind, id: string, expectedVersion: number, record: {\n        readonly version: number;\n        readonly state?: string;\n        readonly updatedAt?: number;\n    }): Promise<boolean>;\n    scan<T extends {\n        readonly state: string;\n        readonly updatedAt: number;\n    }>(kind: DurableRecordKind, input: ReconciliationScanOptions<string>): Promise<ReconciliationScanPage<T>>;\n    acquireLease(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly now: number;\n        readonly leaseMs: number;\n    }): Promise<ReconciliationLease | undefined>;\n    renewLease(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly token: string;\n        readonly now: number;\n        readonly leaseMs: number;\n    }): Promise<boolean>;\n    checkpointLease(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly token: string;\n        readonly cursor?: string;\n    }): Promise<boolean>;\n    releaseLease(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly token: string;\n    }): Promise<boolean>;\n}"
+  },
+  {
+    "name": "DurableRecordKind",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type DurableRecordKind = \"effect\" | \"approval\" | \"saga\";"
+  },
   {
     "name": "effect",
     "kind": "function",
@@ -2903,16 +3258,22 @@
     "name": "EffectEntry",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface EffectEntry {\n    /** Monotonic position within the request (0-based). The replay/simulation order. */\n    readonly seq: number;\n    /** Milliseconds from the ledger's (injectable) clock at append time. */\n    readonly at: number;\n    readonly capability: string;\n    readonly phase: EffectPhase;\n    readonly target?: string;\n    readonly cost?: EffectCost;\n    readonly digest?: string;\n    readonly error?: {\n        readonly code: string;\n    };\n}",
+    "signature": "export interface EffectEntry {\n    /** Monotonic position within the request (0-based). The replay/simulation order. */\n    readonly seq: number;\n    /** Milliseconds from the ledger's (injectable) clock at append time. */\n    readonly at: number;\n    readonly effectId?: string;\n    readonly capability: string;\n    readonly phase: EffectPhase;\n    readonly target?: string;\n    readonly cost?: EffectCost;\n    readonly digest?: string;\n    readonly error?: {\n        readonly code: string;\n    };\n}",
     "doc": "/** One recorded effect. Frozen; token-only by construction (no payload field exists). */"
   },
   {
     "name": "EffectEntryInput",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface EffectEntryInput {\n    /** Capability token (`db.write`, `payments.charge`). Must be a valid capability id. */\n    readonly capability: string;\n    /** Default `\"intent\"`. Record `committed`/`failed`/`compensated` only after the outcome is known. */\n    readonly phase?: EffectPhase;\n    /** Adapter/resource token (`repo:orders`, `provider:payments`). A token — never a value or a row. */\n    readonly target?: string;\n    /** Dimensionless counters; see {@link EffectCost}. At most {@link MAX_COST_AXES} axes. */\n    readonly cost?: EffectCost;\n    /** Optional keyed-HMAC digest of the effect payload (see {@link computeEffectDigest}); hex, 64 chars. */\n    readonly digest?: string;\n    /** Outcome error as a bounded token code — never a message, never a stack. */\n    readonly error?: {\n        readonly code: string;\n    };\n}",
+    "signature": "export interface EffectEntryInput extends EffectMetadata {\n    /** Opaque execution correlation token shared by one intent and its terminal outcome. */\n    readonly effectId?: string;\n    /** Capability token (`db.write`, `payments.charge`). Must be a valid capability id. */\n    readonly capability: string;\n    /** Default `\"intent\"`. Record `committed`/`failed`/`compensated` only after the outcome is known. */\n    readonly phase?: EffectPhase;\n    /** Outcome error as a bounded token code — never a message, never a stack. */\n    readonly error?: {\n        readonly code: string;\n    };\n}",
     "doc": "/** Caller-supplied fields for one entry. Everything else (`seq`, `at`) is assigned by the ledger. */"
   },
+  {
+    "name": "EffectEvidenceScope",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface EffectEvidenceScope {\n    evidence(): EffectScopeEvidence;\n    /** Legacy/manual effects cannot prove a terminal outcome and therefore become ambiguous. */\n    markBegan(): void;\n    /** Pair a prior manual `markBegan()` with a proven commit. */\n    markCommitted(): void;\n    /** Preserve uncertainty when a caller loses the terminal outcome. */\n    markAmbiguous(): void;\n    /** Settle one begun effect as a proven terminal failure without claiming it committed. */\n    markFailed(): void;\n    /**\n     * Declare that the enclosing request may release its idempotency reservation if it returns a\n     * server error before any owned effect begins.\n     */\n    markSafeToRetry(): void;\n    /** True only while the retry declaration remains backed by evidence that no effect began. */\n    safeToRetry(): boolean;\n}"
+  },
   {
     "name": "effectLedger",
     "kind": "function",
@@ -2955,6 +3316,40 @@
     "signature": "export declare class EffectLedgerSealedError extends Error {\n    constructor();\n}",
     "doc": "/** Thrown by `append` after `seal()` — e.g. an effect attempted while streaming a response body. */"
   },
+  {
+    "name": "EffectLifecycleEvent",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface EffectLifecycleEvent extends EffectMetadata {\n    readonly effectId: string;\n    readonly capability: string;\n    readonly stage: EffectLifecycleStage;\n    readonly phase: EffectLifecyclePhase;\n    readonly at: number;\n    readonly durationMs?: number;\n    readonly attempt?: number;\n    readonly errorCode?: string;\n    readonly trace?: EffectTraceParent;\n}",
+    "doc": "/**\n * Token-only lifecycle evidence. There is deliberately no payload, argument, result, error message,\n * request, or context field, so observation adapters cannot accidentally export business data.\n */"
+  },
+  {
+    "name": "EffectLifecycleObserver",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type EffectLifecycleObserver = (event: EffectLifecycleEvent) => void;",
+    "doc": "/** Observation is fail-open: a broken sink must never change effect behavior. */"
+  },
+  {
+    "name": "EffectLifecyclePhase",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type EffectLifecyclePhase = \"started\" | \"succeeded\" | \"failed\" | \"ambiguous\";"
+  },
+  {
+    "name": "EffectLifecycleStage",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type EffectLifecycleStage = \"admission\" | \"execution\" | \"compensation\" | \"reconciliation\";",
+    "doc": "/** A bounded, payload-free stage in an effect's lifecycle. */"
+  },
+  {
+    "name": "EffectMetadata",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface EffectMetadata {\n    /** Adapter/resource token (`repo:orders`, `provider:payments`). A token — never a value or a row. */\n    readonly target?: string;\n    /** Dimensionless counters; see {@link EffectCost}. At most {@link MAX_COST_AXES} axes. */\n    readonly cost?: EffectCost;\n    /** Optional keyed-HMAC digest of the effect payload (see {@link computeEffectDigest}); hex, 64 chars. */\n    readonly digest?: string;\n}",
+    "doc": "/** Token-only caller metadata shared by an effect intent and outcome. */"
+  },
   {
     "name": "EffectPhase",
     "kind": "type",
@@ -2962,6 +3357,81 @@
     "signature": "export type EffectPhase = \"intent\" | \"committed\" | \"failed\" | \"compensated\";",
     "doc": "/** Lifecycle phase of one effect. `intent` precedes execution; the rest describe its outcome. */"
   },
+  {
+    "name": "EffectReconciliationFinding",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface EffectReconciliationFinding {\n    readonly effectId: string;\n    readonly capability: string;\n    readonly state: \"incomplete\" | \"ambiguous\";\n    readonly updatedAt: number;\n}"
+  },
+  {
+    "name": "EffectScope",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface EffectScope extends EffectEvidenceScope {\n    run<T>(options: OwnedEffectRunOptions<T>, execute: (context: OwnedEffectContext) => T | PromiseLike<T>): Promise<T>;\n}"
+  },
+  {
+    "name": "EffectScopeEvidence",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface EffectScopeEvidence {\n    readonly began: boolean;\n    readonly committed: boolean;\n    readonly ambiguous: boolean;\n}"
+  },
+  {
+    "name": "effectScopeForContext",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function effectScopeForContext(context: object): EffectEvidenceScope | undefined;"
+  },
+  {
+    "name": "EffectScopeOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface EffectScopeOptions {\n    readonly observers?: readonly EffectLifecycleObserver[];\n    readonly signal?: AbortSignal;\n    readonly effectId?: () => string;\n}"
+  },
+  {
+    "name": "EffectTraceParent",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface EffectTraceParent {\n    readonly traceId: string;\n    readonly spanId: string;\n    readonly sampled: boolean;\n}",
+    "doc": "/** Trace-parent tokens copied structurally from an installed tracing plugin. */"
+  },
+  {
+    "name": "effectTraceParentOf",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function effectTraceParentOf(context: object): EffectTraceParent | undefined;"
+  },
+  {
+    "name": "effectTracing",
+    "kind": "function",
+    "package": "@nifrajs/otel",
+    "signature": "export declare function effectTracing(options?: EffectTracingOptions): EffectTracingPlugin;",
+    "doc": "/**\n * Installs child effect spans on subsequent routes. The observer consumes only the constrained\n * `EffectLifecycleEvent` contract; request/business payloads and error text cannot enter an export.\n */"
+  },
+  {
+    "name": "EffectTracingOptions",
+    "kind": "interface",
+    "package": "@nifrajs/otel",
+    "signature": "export interface EffectTracingOptions {\n    readonly exporter?: ObservationAdapter;\n    readonly adapters?: readonly ObservationAdapter[];\n    /** Maximum unmatched started events retained at once. Default 10,000. */\n    readonly maxActive?: number;\n    /** Opportunistically expire unmatched events older than this many milliseconds. Default 5 min. */\n    readonly maxActiveAgeMs?: number;\n    /** Injectable wall clock for deterministic retention tests. */\n    readonly now?: () => number;\n}"
+  },
+  {
+    "name": "EffectTracingPlugin",
+    "kind": "interface",
+    "package": "@nifrajs/otel",
+    "signature": "export interface EffectTracingPlugin extends IdentityPlugin {\n    /** Pass the same observer to `createSagaEngine({ observer })` and reconciliation helpers. */\n    readonly observer: EffectLifecycleObserver;\n}"
+  },
+  {
+    "name": "emitEffectLifecycle",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function emitEffectLifecycle(observers: readonly EffectLifecycleObserver[], input: EmitEffectLifecycleInput): void;",
+    "doc": "/** @internal Validate, freeze, and fan out one token-only event. */"
+  },
+  {
+    "name": "EmitEffectLifecycleInput",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface EmitEffectLifecycleInput extends EffectMetadata {\n    readonly effectId: string;\n    readonly capability: string;\n    readonly stage: EffectLifecycleStage;\n    readonly phase: EffectLifecyclePhase;\n    readonly at?: number;\n    readonly durationMs?: number;\n    readonly attempt?: number;\n    readonly errorCode?: string;\n    readonly trace?: EffectTraceParent;\n}"
+  },
   {
     "name": "EMPTY_PARAMS",
     "kind": "const",
@@ -2994,6 +3464,13 @@
     "package": "@nifrajs/web",
     "signature": "export interface EnableDraftOptions {\n    /** Cookie lifetime in **seconds** (default `3600` = 1h). Keep it short — draft is an editor session. */\n    readonly maxAgeSeconds?: number;\n    /** Cookie `Path` (default `\"/\"`). */\n    readonly path?: string;\n    /** Override the `Secure` attribute (defaults to `true` — secure-by-default). Pass `false` only for\n     * local `http://` dev, where a `Secure` cookie isn't stored. */\n    readonly secure?: boolean;\n}"
   },
+  {
+    "name": "encode",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function encode(value: unknown): Wire;",
+    "doc": "/** Encode any supported value into a JSON-safe {@link Wire} form. */"
+  },
   {
     "name": "encodeCursor",
     "kind": "function",
@@ -3001,6 +3478,18 @@
     "signature": "export declare function encodeCursor(value: unknown): string;",
     "doc": "/** Encode any JSON-serializable value (e.g. the last row's sort key) into an opaque cursor string. */"
   },
+  {
+    "name": "encodeTransportFrame",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function encodeTransportFrame(value: unknown, codec?: TransportCodec): string;"
+  },
+  {
+    "name": "encodeTransportResponse",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function encodeTransportResponse(value: unknown, codec?: TransportCodec, init?: ResponseInit): Response;"
+  },
   {
     "name": "EndObservation",
     "kind": "interface",
@@ -3183,6 +3672,13 @@
     "signature": "export interface Example {\n    readonly name: string;\n    /** The doc page's title, e.g. \"Nifra — Auth & sessions\". */\n    readonly topic: string;\n    /** The doc page slug, e.g. \"auth\" — a short, matchable tag. */\n    readonly slug: string;\n    readonly code: string;\n}",
     "doc": "/**\n * `nifra_example` — verified, copy-pasteable code examples for agents. The corpus is `examples.json`\n * (written into this package by `bun run gen:llms`): the same doc snippets `check:docs` typechecks\n * against the live `@nifrajs/*` API. So every example this returns is GUARANTEED to compile against the\n * installed version — the antidote to an agent hallucinating a framework API from stale training.\n *\n * Keyword-scored over each example's name/topic/slug (curated identifiers, heavily weighted) and its\n * code body. No query → a grouped index of what's available (the cheap discovery call).\n */"
   },
+  {
+    "name": "executeCapability",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function executeCapability<T>(context: object, capability: string, options: CapabilityExecutionOptions, executor: CapabilityExecutor<T>): Promise<T>;",
+    "doc": "/**\n * Execute one owned effect behind a fail-closed capability boundary. The boundary assigns a stable\n * effect id, records intent before execution, and records exactly one terminal outcome automatically.\n * The callback result and errors never enter the token-only ledger.\n */"
+  },
   {
     "name": "ExecutionContext",
     "kind": "interface",
@@ -4075,7 +4571,7 @@
     "name": "IdempotencyRuntime",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface IdempotencyRuntime {\n    /** Resolve a route's declared idempotency into a pinned store + defaults, or `undefined` when off. */\n    resolve(schema: RouteSchema | undefined, authenticated: boolean, maxBodyBytes: number): ResolvedIdempotency | undefined;\n    /** The dedupe lane: read the key, fingerprint the request, consult the store, run/replay/reject. */\n    run<T>(config: ResolvedIdempotency, req: Request, platform: Platform | undefined, entry: unknown, params: Record<string, string>, search: string | undefined, wrapResponse: (response: Response) => T, host: IdempotencyHost): Promise<T>;\n}",
+    "signature": "export interface IdempotencyRuntime {\n    readonly trackEffect: (context: object, committed: boolean) => void;\n    /** Resolve a route's declared idempotency into a pinned store + defaults, or `undefined` when off. */\n    resolve(schema: RouteSchema | undefined, authenticated: boolean, maxBodyBytes: number): ResolvedIdempotency | undefined;\n    /** The dedupe lane: read the key, fingerprint the request, consult the store, run/replay/reject. */\n    run<T>(config: ResolvedIdempotency, req: Request, platform: Platform | undefined, entry: unknown, params: Record<string, string>, search: string | undefined, wrapResponse: (response: Response) => T, host: IdempotencyHost): Promise<T>;\n}",
     "doc": "/** The injected idempotency implementation the kernel calls through when the plugin is installed. */"
   },
   {
@@ -5147,6 +5643,50 @@
     "signature": "export declare const MAP_DEFERRED_SOURCE = \"const mapDeferred = (d) => {\\n  if (!d || typeof d !== \\\"object\\\") return d\\n  if (typeof d.__nifra_deferred === \\\"number\\\") return { __nifra_deferred: true, id: d.__nifra_deferred, promise: window.__nifraDeferred(d.__nifra_deferred) }\\n  if (Array.isArray(d)) return d.map(mapDeferred)\\n  const out = {}\\n  for (const k in d) out[k] = mapDeferred(d[k])\\n  return out\\n}\";",
     "doc": "/**\n * Source emitted into the generated client entry: maps serialized `{__nifra_deferred: id}` placeholders\n * (at any depth — nested objects/arrays) to the registry's promises, so the component receives real\n * promises to `<Await>`. A no-op for data without placeholders (so non-deferred pages are unchanged).\n */"
   },
+  {
+    "name": "markBeaconEffectBegan",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function markBeaconEffectBegan(context: object): void;",
+    "doc": "/** A legacy beacon cannot prove what happens after the call, so it is immediately ambiguous. */"
+  },
+  {
+    "name": "markEffect",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function markEffect(context: object, committed: boolean): void;"
+  },
+  {
+    "name": "markEffectAmbiguous",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function markEffectAmbiguous(context: object): void;"
+  },
+  {
+    "name": "markEffectCommitted",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function markEffectCommitted(context: object): void;"
+  },
+  {
+    "name": "markEffectExecuting",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function markEffectExecuting(context: object): void;"
+  },
+  {
+    "name": "markIdempotencySafeToRetry",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function markIdempotencySafeToRetry(context: object): void;",
+    "doc": "/**\n * Opt a concrete 5xx response into releasing its idempotency reservation, but only while the\n * request-local effect scope still proves that no owned effect began.\n */"
+  },
+  {
+    "name": "markRequestSafeToRetry",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function markRequestSafeToRetry(context: object): void;"
+  },
   {
     "name": "matches",
     "kind": "function",
@@ -5410,6 +5950,12 @@
     "signature": "export interface McpWidget {\n    readonly uri: string;\n    readonly resource: McpResource;\n    readonly meta: Record<string, unknown>;\n}",
     "doc": "/** A widget: the resource to register on the server, its `ui://` URI, and the `_meta` link for its tool. */"
   },
+  {
+    "name": "MemoryApprovalStore",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class MemoryApprovalStore implements ApprovalStore {\n    readonly durability: \"memory\";\n    private readonly records;\n    create(record: ApprovalRecord): boolean;\n    get(approvalId: string): ApprovalRecord | undefined;\n    decide(input: Parameters<ApprovalStore[\"decide\"]>[0]): boolean;\n    consume(input: Parameters<ApprovalStore[\"consume\"]>[0]): ApprovalConsumeResult;\n    list(): readonly ApprovalRecord[];\n}"
+  },
   {
     "name": "MemoryCache",
     "kind": "class",
@@ -5441,6 +5987,19 @@
     "package": "@nifrajs/core",
     "signature": "export interface MemoryCausalityStoreOptions {\n    /** Global record bound. Default 10,000. */\n    readonly maxRecords?: number;\n    /** In-memory evidence disappears on restart and is rejected in production unless explicitly allowed. */\n    readonly allowInProduction?: boolean;\n}"
   },
+  {
+    "name": "MemoryDurableEffectStore",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class MemoryDurableEffectStore implements DurableEffectStore {\n    readonly durability: \"memory\";\n    private readonly records;\n    private readonly byState;\n    create(record: DurableEffectRecord): boolean;\n    get(effectId: string): DurableEffectRecord | undefined;\n    transition(input: Parameters<DurableEffectStore[\"transition\"]>[0]): boolean;\n    list(): readonly DurableEffectRecord[];\n    scan(input: ReconciliationScanOptions<DurableEffectState>): ReconciliationScanPage<DurableEffectRecord>;\n}"
+  },
+  {
+    "name": "MemoryDurableRecordBackend",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class MemoryDurableRecordBackend implements DurableRecordBackend {\n    private readonly records;\n    private readonly leases;\n    private key;\n    create(kind: DurableRecordKind, id: string, record: {\n        readonly version: number;\n        readonly state?: string;\n        readonly updatedAt?: number;\n    }): Promise<boolean>;\n    get<T extends {\n        readonly version: number;\n    }>(kind: DurableRecordKind, id: string): Promise<T | undefined>;\n    compareAndSet(kind: DurableRecordKind, id: string, expectedVersion: number, record: {\n        readonly version: number;\n        readonly state?: string;\n        readonly updatedAt?: number;\n    }): Promise<boolean>;\n    scan<T extends {\n        readonly state: string;\n        readonly updatedAt: number;\n    }>(kind: DurableRecordKind, input: ReconciliationScanOptions<string>): Promise<ReconciliationScanPage<T>>;\n    acquireLease(input: Parameters<DurableRecordBackend[\"acquireLease\"]>[0]): Promise<ReconciliationLease | undefined>;\n    renewLease(input: Parameters<DurableRecordBackend[\"renewLease\"]>[0]): Promise<boolean>;\n    checkpointLease(input: Parameters<DurableRecordBackend[\"checkpointLease\"]>[0]): Promise<boolean>;\n    releaseLease(input: Parameters<DurableRecordBackend[\"releaseLease\"]>[0]): Promise<boolean>;\n}",
+    "doc": "/** Deterministic reference backend for tests and adapter conformance; not for production. */"
+  },
   {
     "name": "MemoryIdempotencyStore",
     "kind": "class",
@@ -5486,6 +6045,12 @@
     "package": "@nifrajs/core",
     "signature": "export interface MemoryLedgerSinkOptions {\n    /** Retain at most this many sealed ledgers (oldest evicted first). Default 1000. */\n    readonly maxLedgers?: number;\n}"
   },
+  {
+    "name": "MemoryReconciliationLeaseStore",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class MemoryReconciliationLeaseStore implements ReconciliationLeaseStore {\n    readonly durability: \"memory\";\n    private readonly records;\n    acquire(input: Parameters<ReconciliationLeaseStore[\"acquire\"]>[0]): ReconciliationLease | undefined;\n    renew(input: Parameters<ReconciliationLeaseStore[\"renew\"]>[0]): boolean;\n    checkpoint(input: Parameters<ReconciliationLeaseStore[\"checkpoint\"]>[0]): boolean;\n    release(input: Parameters<ReconciliationLeaseStore[\"release\"]>[0]): boolean;\n}"
+  },
   {
     "name": "MemoryResponseCache",
     "kind": "class",
@@ -5498,6 +6063,12 @@
     "package": "@nifrajs/middleware",
     "signature": "export interface MemoryResponseCacheOptions {\n    /** Maximum entries retained. Default `1000`. Oldest entries are evicted first. */\n    readonly maxEntries?: number;\n    /** Allow in-process cache in production. Off by default because it is per-instance. */\n    readonly allowInProduction?: boolean;\n}"
   },
+  {
+    "name": "MemorySagaStore",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class MemorySagaStore implements SagaStore {\n    readonly durability: \"memory\";\n    private readonly records;\n    private readonly byState;\n    create(record: SagaRecord): boolean;\n    get(sagaId: string): SagaRecord | undefined;\n    compareAndSet(input: Parameters<SagaStore[\"compareAndSet\"]>[0]): boolean;\n    list(): readonly SagaRecord[];\n    scan(input: ReconciliationScanOptions<SagaState>): ReconciliationScanPage<SagaRecord>;\n}"
+  },
   {
     "name": "MemorySessionStore",
     "kind": "class",
@@ -5830,7 +6401,7 @@
     "name": "ndjsonStream",
     "kind": "function",
     "package": "@nifrajs/web",
-    "signature": "export declare function ndjsonStream(forClient: unknown, deferred: ReadonlyArray<{\n    readonly id: number;\n    readonly promise: Promise<unknown>;\n}>): ReadableStream<Uint8Array>;",
+    "signature": "export declare function ndjsonStream(forClient: unknown, deferred: ReadonlyArray<{\n    readonly id: number;\n    readonly promise: Promise<unknown>;\n}>, codec?: TransportCodec): ReadableStream<Uint8Array>;",
     "doc": "/**\n * Stream a loader result as NDJSON for a client (soft) navigation: line 1 is the critical data with\n * `{__nifra_deferred: id}` placeholders (`forClient`), then one line per deferred as its promise\n * settles — `{\"i\": id, \"v\": value}` on resolve, `{\"i\": id, \"e\": \"deferred_error\"}` on reject (a\n * rejection is data, not a stream error; the opaque code never leaks the raw reason). Closes when all\n * settle. The client (`defaultFetchData`) returns the\n * data after line 1 and settles `<Await>`'s markers as the resolution lines arrive. `JSON.stringify`\n * escapes newlines in values, so each line is NDJSON-safe; no HTML escaping (this is a fetch body,\n * parsed with `JSON.parse`, never injected into markup).\n */"
   },
   {
@@ -6030,6 +6601,13 @@
     "package": "@nifrajs/node",
     "signature": "export interface NodeServer {\n    /** The bound port (resolved when `port: 0` is requested). */\n    readonly port: number;\n    /**\n     * Stop accepting connections, let in-flight requests drain (up to `drainMs`), then\n     * force-close stragglers + idle keep-alives. Mirrors nifra's Bun `stop()`.\n     */\n    stop(options?: {\n        drainMs?: number;\n    }): Promise<void>;\n}"
   },
+  {
+    "name": "normalizeEffectMetadata",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function normalizeEffectMetadata(input: EffectMetadata): EffectMetadata;",
+    "doc": "/** Validate, copy, and freeze token-only effect metadata before it reaches a ledger or policy hook. */"
+  },
   {
     "name": "normalizeRolldownPlugins",
     "kind": "function",
@@ -6235,6 +6813,24 @@
     "signature": "export type OutputOf<H extends (...args: never[]) => unknown> = Exclude<Awaited<ReturnType<H>>, Response>;",
     "doc": "/** The client-visible output of a handler: its awaited return, minus raw `Response`. */"
   },
+  {
+    "name": "OwnedEffectContext",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface OwnedEffectContext extends EffectMetadata {\n    readonly effectId: string;\n    readonly capability: string;\n    readonly stage: Exclude<EffectLifecycleStage, \"admission\" | \"reconciliation\">;\n    readonly signal: AbortSignal;\n    readonly attempt?: number;\n}"
+  },
+  {
+    "name": "OwnedEffectRunOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface OwnedEffectRunOptions<T> extends EffectMetadata {\n    readonly effectId?: string;\n    readonly capability: string;\n    readonly stage?: Exclude<EffectLifecycleStage, \"admission\" | \"reconciliation\">;\n    readonly signal?: AbortSignal;\n    readonly attempt?: number;\n    readonly trace?: EffectTraceParent;\n    /** Per-run observers, combined with the scope's observers. */\n    readonly observers?: readonly EffectLifecycleObserver[];\n    /** Optional admission boundary executed before the effect is marked as begun. */\n    readonly admit?: (context: OwnedEffectContext) => void | PromiseLike<void>;\n    readonly transitions?: OwnedEffectTransitions<T>;\n    readonly errorCode?: string | ((error: unknown, began: boolean) => string);\n    /** Classify a caught execution failure when the caller can prove it is terminal. */\n    readonly failurePhase?: (error: unknown, began: boolean) => \"failed\" | \"ambiguous\";\n}"
+  },
+  {
+    "name": "OwnedEffectTransitions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface OwnedEffectTransitions<T> {\n    intent?(context: OwnedEffectContext): void | PromiseLike<void>;\n    executing?(context: OwnedEffectContext): void | PromiseLike<void>;\n    committed?(context: OwnedEffectContext, result: T): void | PromiseLike<void>;\n    failed?(context: OwnedEffectContext, input: {\n        readonly began: boolean;\n        readonly errorCode: string;\n        readonly error: unknown;\n    }): void | PromiseLike<void>;\n}"
+  },
   {
     "name": "packageOf",
     "kind": "function",
@@ -6283,6 +6879,13 @@
     "package": "@nifrajs/core",
     "signature": "export type Params<Path extends string> = Prettify<RawParams<Path>>;"
   },
+  {
+    "name": "parse",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function parse(text: string, limits?: WireDecodeLimits): unknown;",
+    "doc": "/** `JSON.parse` + `decode` in one call - the rich-type equivalent of `JSON.parse`. */"
+  },
   {
     "name": "parseArgs",
     "kind": "function",
@@ -6402,7 +7005,7 @@
     "name": "parseNdjsonData",
     "kind": "function",
     "package": "@nifrajs/web",
-    "signature": "export declare function parseNdjsonData(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): Promise<unknown>;",
+    "signature": "export declare function parseNdjsonData(stream: ReadableStream<Uint8Array>, signal?: AbortSignal, codec?: TransportCodec): Promise<unknown>;",
     "doc": "/**\n * Client side of {@link ndjsonStream} (used by the router's `defaultFetchData` on a soft nav): read\n * the NDJSON body into a data object whose deferred markers settle as resolution lines arrive.\n * Returns after **line 1** so the router can apply the critical data + render immediately; the\n * markers' promises settle/reject in the background. If the stream ends (or `signal` aborts) with\n * markers unsettled, they reject — so `<Await>` never hangs.\n */"
   },
   {
@@ -6480,6 +7083,12 @@
     "signature": "export declare function pipeWebBodyToNode(body: ReadableStream<Uint8Array> | null, res: NodeResLike): Promise<void>;",
     "doc": "/**\n * Stream a Web `Response` body to a Node response chunk-by-chunk. Buffering the whole body (e.g.\n * `arrayBuffer()`) waits for the stream to END — which an open-ended SSE (`text/event-stream`) body never\n * does, so it hung `nifra dev` (the Bun production server streamed it fine). This flushes each chunk as it\n * arrives and cancels the reader if the client disconnects; a finite body just streams its chunk(s) + ends.\n */"
   },
+  {
+    "name": "plainJsonCodec",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const plainJsonCodec: TransportCodec;"
+  },
   {
     "name": "Platform",
     "kind": "interface",
@@ -6562,6 +7171,30 @@
     "signature": "export type PostcssProcessor = (plugins?: readonly unknown[]) => {\n    process(css: string, options: {\n        readonly from?: string;\n        readonly to?: string;\n    }): PromiseLike<{\n        readonly css: string;\n    }>;\n};",
     "doc": "/** The subset of the `postcss` API this plugin uses (structural, so no hard dependency on its types). */"
   },
+  {
+    "name": "PostgresClient",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface PostgresClient {\n    query(sql: string, values?: readonly unknown[]): Promise<PostgresQueryResult>;\n}"
+  },
+  {
+    "name": "PostgresDurableExecutionAdapter",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class PostgresDurableExecutionAdapter implements DurableExecutionAdapter {\n    readonly effects: DurableEffectStore;\n    readonly approvals: ApprovalStore;\n    readonly sagas: SagaStore;\n    readonly leases: ReconciliationLeaseStore;\n    readonly backend: PostgresDurableRecordBackend;\n    constructor(client: PostgresClient, options?: {\n        readonly tablePrefix?: string;\n    });\n    migrate(): Promise<void>;\n}"
+  },
+  {
+    "name": "PostgresDurableRecordBackend",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class PostgresDurableRecordBackend implements DurableRecordBackend {\n    private readonly client;\n    readonly recordsTable: string;\n    readonly leasesTable: string;\n    constructor(client: PostgresClient, options?: {\n        readonly tablePrefix?: string;\n    });\n    migrate(): Promise<void>;\n    create(kind: DurableRecordKind, id: string, record: {\n        readonly version: number;\n        readonly state?: string;\n        readonly updatedAt?: number;\n    }): Promise<boolean>;\n    get<T extends {\n        readonly version: number;\n    }>(kind: DurableRecordKind, id: string): Promise<T | undefined>;\n    compareAndSet(kind: DurableRecordKind, id: string, expectedVersion: number, record: {\n        readonly version: number;\n        readonly state?: string;\n        readonly updatedAt?: number;\n    }): Promise<boolean>;\n    scan<T extends {\n        readonly state: string;\n        readonly updatedAt: number;\n    }>(kind: DurableRecordKind, input: ReconciliationScanOptions<string>): Promise<ReconciliationScanPage<T>>;\n    acquireLease(input: Parameters<DurableRecordBackend[\"acquireLease\"]>[0]): Promise<ReconciliationLease | undefined>;\n    renewLease(input: Parameters<DurableRecordBackend[\"renewLease\"]>[0]): Promise<boolean>;\n    checkpointLease(input: Parameters<DurableRecordBackend[\"checkpointLease\"]>[0]): Promise<boolean>;\n    releaseLease(input: Parameters<DurableRecordBackend[\"releaseLease\"]>[0]): Promise<boolean>;\n}"
+  },
+  {
+    "name": "PostgresQueryResult",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface PostgresQueryResult {\n    readonly rows: readonly Record<string, unknown>[];\n    readonly rowCount?: number;\n}"
+  },
   {
     "name": "poweredBy",
     "kind": "function",
@@ -7085,6 +7718,78 @@
     "signature": "export declare const recipe: UpgradeRecipe;",
     "doc": "/**\n * Upgrade recipe for nifra 1.8.0.\n *\n * 1.8.0 is a fixed-group bump: every `@nifrajs/*` package moves in lockstep. The pin sweep sets them\n * all to 1.8.0 (preserving each spec's `^`/`~`/exact style). 1.8.0 introduced no breaking import moves\n * in the public packages — the new surfaces (route assurance, adversarial testing, `@nifrajs/events`)\n * are additive — so `importMoves` is empty. The notes flag the additive follow-ups a bump can't do for\n * you (wiring the new assurance config), keeping the runner honest about what it did and didn't touch.\n */"
   },
+  {
+    "name": "reconcileEffects",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function reconcileEffects(store: DurableEffectStore, options: {\n    readonly staleBefore: number;\n    readonly observer?: EffectLifecycleObserver;\n}): Promise<readonly EffectReconciliationFinding[]>;"
+  },
+  {
+    "name": "reconcileEffectsPage",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function reconcileEffectsPage(store: DurableEffectStore, options: {\n    readonly staleBefore: number;\n    readonly observer?: EffectLifecycleObserver;\n    readonly cursor?: string;\n    readonly limit?: number;\n}): Promise<ReconciliationPage<EffectReconciliationFinding>>;"
+  },
+  {
+    "name": "reconcileSagas",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function reconcileSagas(store: SagaStore, options: {\n    readonly staleBefore: number;\n}): Promise<readonly SagaReconciliationFinding[]>;"
+  },
+  {
+    "name": "reconcileSagasPage",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function reconcileSagasPage(store: SagaStore, options: {\n    readonly staleBefore: number;\n    readonly cursor?: string;\n    readonly limit?: number;\n}): Promise<ReconciliationPage<SagaReconciliationFinding>>;"
+  },
+  {
+    "name": "ReconciliationLease",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ReconciliationLease {\n    readonly name: string;\n    readonly owner: string;\n    readonly token: string;\n    readonly expiresAt: number;\n    readonly cursor?: string;\n}"
+  },
+  {
+    "name": "ReconciliationLeaseStore",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ReconciliationLeaseStore {\n    readonly durability?: \"memory\" | \"durable\";\n    acquire(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly now: number;\n        readonly leaseMs: number;\n    }): ReconciliationLease | undefined | Promise<ReconciliationLease | undefined>;\n    renew(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly token: string;\n        readonly now: number;\n        readonly leaseMs: number;\n    }): boolean | Promise<boolean>;\n    checkpoint(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly token: string;\n        readonly cursor?: string;\n    }): boolean | Promise<boolean>;\n    release(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly token: string;\n    }): boolean | Promise<boolean>;\n}"
+  },
+  {
+    "name": "ReconciliationPage",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ReconciliationPage<Finding> {\n    readonly findings: readonly Finding[];\n    readonly cursor?: string;\n}"
+  },
+  {
+    "name": "ReconciliationScanOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ReconciliationScanOptions<State extends string> {\n    readonly states: readonly State[];\n    readonly updatedBefore?: number;\n    readonly cursor?: string;\n    readonly limit: number;\n}"
+  },
+  {
+    "name": "ReconciliationScanPage",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ReconciliationScanPage<Record> {\n    readonly records: readonly Record[];\n    readonly cursor?: string;\n}"
+  },
+  {
+    "name": "ReconciliationWorkerEvent",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ReconciliationWorkerEvent = {\n    readonly type: \"acquired\" | \"released\" | \"lease-lost\";\n    readonly name: string;\n} | {\n    readonly type: \"page\" | \"checkpoint\";\n    readonly name: string;\n    readonly scanned: number;\n    readonly handled: number;\n} | {\n    readonly type: \"failed\";\n    readonly name: string;\n    readonly errorCode: \"scan\" | \"handle\";\n};"
+  },
+  {
+    "name": "ReconciliationWorkerOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ReconciliationWorkerOptions<Finding> {\n    readonly name: string;\n    readonly owner: string;\n    readonly leases: ReconciliationLeaseStore;\n    readonly leaseMs?: number;\n    readonly batchSize?: number;\n    readonly maxPages?: number;\n    readonly concurrency?: number;\n    readonly signal?: AbortSignal;\n    readonly now?: () => number;\n    readonly scan: (input: {\n        readonly cursor?: string;\n        readonly limit: number;\n        readonly signal: AbortSignal;\n    }) => {\n        readonly findings: readonly Finding[];\n        readonly cursor?: string;\n    } | Promise<{\n        readonly findings: readonly Finding[];\n        readonly cursor?: string;\n    }>;\n    readonly filter?: (finding: Finding) => boolean;\n    readonly handle: (finding: Finding, signal: AbortSignal) => void | PromiseLike<void>;\n    readonly observe?: (event: ReconciliationWorkerEvent) => void;\n}"
+  },
+  {
+    "name": "ReconciliationWorkerResult",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ReconciliationWorkerResult {\n    readonly acquired: boolean;\n    readonly pages: number;\n    readonly scanned: number;\n    readonly handled: number;\n}"
+  },
   {
     "name": "recordCapabilityOutcome",
     "kind": "function",
@@ -7174,6 +7879,12 @@
     "signature": "export declare function reflectSchema(value: unknown): SchemaReflection;",
     "doc": "/**\n * Reflect a Standard Schema, Nifra/TypeBox schema carrier, or raw JSON Schema. Never throws.\n * Validation-only schemas have `standard` but no `jsonSchema`; raw JSON Schema has the reverse.\n */"
   },
+  {
+    "name": "RegisteredCapabilityInterceptor",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface RegisteredCapabilityInterceptor {\n    readonly interceptor: CapabilityInterceptor;\n    readonly timeoutMs: number;\n}"
+  },
   {
     "name": "registerFormat",
     "kind": "function",
@@ -7378,6 +8089,24 @@
     "package": "@nifrajs/core",
     "signature": "export declare class RequestContext implements RawContext {\n    params: Record<string, string>;\n    body: unknown;\n    private searchValue;\n    private signalValue;\n    private budgetValue;\n    private platformValue;\n    private setValue;\n    private queryValue;\n    private queryReady;\n    private cookiesValue;\n    private readonly source;\n    private readonly maxBodyBytes;\n    constructor(source: RequestSource, params: Record<string, string>, maxBodyBytes: number);\n    constructor(source: RequestSource, params: Record<string, string>, search: string | undefined, signal: AbortSignal, budget: RequestBudget, platform: Platform | undefined, maxBodyBytes: number);\n    static native(source: RequestSource, params: Record<string, string>, maxBodyBytes: number): RequestContext;\n    [CONTEXT_SET](): CtxSet | undefined;\n    get [CONTEXT_SEARCH](): string;\n    get set(): CtxSet;\n    get signal(): AbortSignal;\n    get budget(): RequestBudget;\n    get env(): unknown;\n    get clientIp(): string | undefined;\n    get waitUntil(): (promise: Promise<unknown>) => void;\n    get req(): Request;\n    get request(): Request;\n    json(body: unknown, init?: ResponseInit | number): Response;\n    text(body: string, init?: ResponseInit | number): Response;\n    get query(): unknown;\n    set query(v: unknown);\n    get cookies(): Readonly<Record<string, string>>;\n    boundedBody(maxBytes?: number): Promise<Uint8Array>;\n    boundedJson<T = unknown>(maxBytes?: number): Promise<T>;\n}"
   },
+  {
+    "name": "requestEffectEvidence",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function requestEffectEvidence(request: Request): RequestEffectEvidence;"
+  },
+  {
+    "name": "RequestEffectEvidence",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type RequestEffectEvidence = EffectScopeEvidence;"
+  },
+  {
+    "name": "requestEffectScope",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function requestEffectScope(request: Request): EffectEvidenceScope | undefined;"
+  },
   {
     "name": "requestId",
     "kind": "function",
@@ -7391,6 +8120,12 @@
     "package": "@nifrajs/middleware",
     "signature": "export interface RequestIdOptions {\n    /** Header read for an inbound id (trace propagation) + echoed on the response. Default `\"x-request-id\"`. */\n    readonly header?: string;\n    /** Generate an id when the inbound header is absent. Default `crypto.randomUUID()`. */\n    readonly generate?: () => string;\n}"
   },
+  {
+    "name": "requestIsSafeToRetry",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function requestIsSafeToRetry(request: Request): boolean;"
+  },
   {
     "name": "RequestLedger",
     "kind": "interface",
@@ -7715,6 +8450,18 @@
     "signature": "export declare function rewriteVersionSpec(spec: string, toVersion: string): string | null;",
     "doc": "/**\n * Rewrite a dependency version spec to `toVersion`, preserving the range operator (`^`, `~`, …).\n * Returns null when the spec is not a plain semver spec (→ skip it) or already equals the target.\n */"
   },
+  {
+    "name": "richWireCodec",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function richWireCodec(options?: RichWireCodecOptions): TransportCodec;"
+  },
+  {
+    "name": "RichWireCodecOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface RichWireCodecOptions {\n    readonly limits?: WireDecodeLimits;\n}"
+  },
   {
     "name": "robots",
     "kind": "function",
@@ -8067,6 +8814,19 @@
     "signature": "export declare function runDoctor(cwd: string, opts?: {\n    readonly json?: boolean;\n    readonly autoFix?: boolean;\n}): Promise<boolean>;",
     "doc": "/** Run doctor; print a report (`--json` for machine output) and return whether it passed. */"
   },
+  {
+    "name": "runDurableExecutionAdapterConformance",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function runDurableExecutionAdapterConformance(adapter: DurableExecutionAdapter): Promise<DurableExecutionConformanceResult>;",
+    "doc": "/** Runtime-independent conformance suite reusable by adapter authors and CI. */"
+  },
+  {
+    "name": "runEffectReconciliationWorker",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function runEffectReconciliationWorker(store: DurableEffectStore, options: SpecializedWorkerOptions<EffectReconciliationFinding>): Promise<ReconciliationWorkerResult>;"
+  },
   {
     "name": "runFailureScenario",
     "kind": "function",
@@ -8147,6 +8907,12 @@
     "package": "@nifrajs/mcp-db",
     "signature": "export interface RunQueryOptions {\n    /**\n     * REQUIRED. Authorize each `run_query` call at the transport boundary (inspect the inbound\n     * Request's auth). Return false to reject with a JSON-RPC error. There is no unauthenticated\n     * mode — schema tools are the anonymous surface. Note: `run_query` is therefore HTTP-only;\n     * direct `handle()` dispatch rejects it (no Request to authorize — fails closed).\n     */\n    readonly authorize: (context: McpDbAuthorizeContext) => boolean | Promise<boolean>;\n    /** Max rows returned per query (default 100). */\n    readonly maxRows?: number;\n    /** Max serialized result size in bytes (default 100 KB). */\n    readonly maxResultBytes?: number;\n}"
   },
+  {
+    "name": "runReconciliationWorker",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function runReconciliationWorker<Finding>(options: ReconciliationWorkerOptions<Finding>): Promise<ReconciliationWorkerResult>;"
+  },
   {
     "name": "runRequest",
     "kind": "function",
@@ -8161,6 +8927,12 @@
     "signature": "export interface RunResult {\n    readonly label?: string;\n    readonly method: string;\n    readonly path: string;\n    /** `true` when the app returned a 2xx response. `false` for non-2xx, or when `app.fetch` threw. */\n    readonly ok: boolean;\n    /** HTTP status — present when the app returned a response (absent when it threw). */\n    readonly status?: number;\n    readonly statusText?: string;\n    readonly headers?: Readonly<Record<string, string>>;\n    /** Parsed JSON when the response is JSON; otherwise the (possibly truncated) text. */\n    readonly body?: unknown;\n    /** The response body as text, truncated to `maxBodyChars`. */\n    readonly bodyText?: string;\n    /** `true` when `bodyText` was cut to the cap. */\n    readonly truncated?: boolean;\n    /** Wall-clock time for this request, milliseconds. */\n    readonly durationMs: number;\n    /** Set when `app.fetch` threw (the app crashed) rather than returning a response. */\n    readonly error?: {\n        readonly name: string;\n        readonly message: string;\n        readonly stack?: string;\n    };\n}",
     "doc": "/** The captured outcome of one request. */"
   },
+  {
+    "name": "runSagaReconciliationWorker",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function runSagaReconciliationWorker(store: SagaStore, options: SpecializedWorkerOptions<SagaReconciliationFinding>): Promise<ReconciliationWorkerResult>;"
+  },
   {
     "name": "runSnapshot",
     "kind": "function",
@@ -8200,6 +8972,13 @@
     "package": "@nifrajs/middleware",
     "signature": "export declare const SAFE_METHODS: Set<string>;"
   },
+  {
+    "name": "safeEqual",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function safeEqual(a: string | undefined, b: string | undefined): boolean;",
+    "doc": "/**\n * Constant-time string comparison for credential-shaped values - lease tokens, token hashes, and\n * binding digests.\n *\n * `a !== b` returns as soon as it finds a differing character, so how long it takes reveals how much\n * of a guess was correct. That is only exploitable when an attacker can submit guesses and measure,\n * which is not the case on every path here - but these values are credentials, the comparison is on\n * the verification path, and doing it correctly costs nothing. Doing it inconsistently is what makes\n * the one place that matters easy to miss.\n *\n * Length is compared first, so a length difference is still observable. Every value compared through\n * this helper is fixed-width by construction (a UUID, a SHA-256 hex/base64url digest), so length\n * carries no secret. Content comparison always visits every character.\n *\n * Synchronous on purpose: the callers are store transitions and lease checks that are themselves\n * synchronous. A hash-then-compare variant (which would also hide length) is available as\n * `timingSafeEqualString` in `@nifrajs/middleware`, but it is async and would force those paths async.\n */"
+  },
   {
     "name": "safeJoin",
     "kind": "function",
@@ -8207,6 +8986,109 @@
     "signature": "export declare function safeJoin(cwd: string, rel: string): string;",
     "doc": "/** Confine a project-relative path under `cwd` and return the absolute path. Rejects a spec that escapes\n * the root (defense-in-depth — these specs are constants, but the cwd-confinement invariant is enforced\n * at the seam, not assumed). Exported so the invariant is directly testable. */"
   },
+  {
+    "name": "SagaAmbiguityResolution",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type SagaAmbiguityResolution = {\n    readonly kind: \"execution\";\n    readonly step: string;\n    readonly effectId: string;\n    readonly outcome: \"committed\";\n    /** Provider-confirmed result required by later saga steps. */\n    readonly result: unknown;\n} | {\n    readonly kind: \"execution\";\n    readonly step: string;\n    readonly effectId: string;\n    readonly outcome: \"not-committed\";\n    readonly errorCode?: string;\n} | {\n    readonly kind: \"compensation\";\n    readonly step: string;\n    readonly effectId: string;\n    readonly outcome: \"compensated\" | \"not-compensated\";\n};"
+  },
+  {
+    "name": "SagaAmbiguousStepError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class SagaAmbiguousStepError extends Error {\n    readonly sagaId: string;\n    readonly step: string;\n    readonly effectId: string;\n    constructor(sagaId: string, step: string, effectId: string);\n}"
+  },
+  {
+    "name": "SagaCompensationContext",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SagaCompensationContext {\n    readonly effectId: string;\n    readonly sagaId: string;\n    readonly attempt: number;\n    readonly signal: AbortSignal;\n}"
+  },
+  {
+    "name": "SagaConcurrencyError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class SagaConcurrencyError extends Error {\n    readonly sagaId: string;\n    constructor(sagaId: string);\n}"
+  },
+  {
+    "name": "SagaDefinition",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SagaDefinition<I, C extends Record<string, unknown>> {\n    readonly name: string;\n    readonly capability?: string;\n    readonly run: (context: SagaRunContext<C>, input: I) => void | PromiseLike<void>;\n    readonly compensators: {\n        readonly [K in keyof C]: (args: C[K], context: SagaCompensationContext) => void | PromiseLike<void>;\n    };\n    readonly retry?: {\n        readonly maxAttempts?: number;\n        readonly backoffMs?: (attempt: number) => number;\n    };\n}"
+  },
+  {
+    "name": "SagaEngine",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SagaEngine {\n    execute<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>, sagaId: string, input: I, options?: {\n        readonly signal?: AbortSignal;\n    }): Promise<SagaRecord>;\n    resume<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>, sagaId: string, options?: {\n        readonly signal?: AbortSignal;\n    }): Promise<SagaRecord>;\n    compensate<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>, sagaId: string, options?: {\n        readonly signal?: AbortSignal;\n    }): Promise<SagaRecord>;\n    /**\n     * Apply a provider/operator-confirmed outcome to an ambiguous durable transition. The supplied\n     * effect id must match the stored execution/compensation id, preventing a stale review from\n     * resolving a later operation. The caller remains responsible for authenticating and authorizing\n     * the operator. Call `resume` or `compensate` after the resolution.\n     */\n    resolveAmbiguity<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>, sagaId: string, resolution: SagaAmbiguityResolution): Promise<SagaRecord>;\n}"
+  },
+  {
+    "name": "SagaEngineOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SagaEngineOptions {\n    readonly store: SagaStore;\n    readonly now?: () => number;\n    readonly observer?: EffectLifecycleObserver;\n    /** Tests/local development only. Production sagas require a durable store. */\n    readonly allowMemoryStore?: boolean;\n}"
+  },
+  {
+    "name": "SagaReconciliationFinding",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SagaReconciliationFinding {\n    readonly sagaId: string;\n    readonly state: SagaState;\n    readonly step?: string;\n    readonly effectId?: string;\n    readonly reason: \"stale-running\" | \"ambiguous-execution\" | \"ambiguous-compensation\" | \"manual-review\";\n}"
+  },
+  {
+    "name": "SagaRecord",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SagaRecord {\n    readonly sagaId: string;\n    readonly definition: string;\n    readonly state: SagaState;\n    readonly input: unknown;\n    readonly steps: readonly SagaStepRecord[];\n    readonly createdAt: number;\n    readonly updatedAt: number;\n    readonly version: number;\n}"
+  },
+  {
+    "name": "SagaResolutionError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class SagaResolutionError extends Error {\n    readonly sagaId: string;\n    readonly step: string;\n    constructor(sagaId: string, step: string, message: string);\n}"
+  },
+  {
+    "name": "SagaRunContext",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SagaRunContext<C extends Record<string, unknown>> {\n    step<K extends keyof C & string, T>(name: K, compensationArgs: C[K], execute: (context: SagaStepExecutionContext) => T | PromiseLike<T>): Promise<T>;\n}"
+  },
+  {
+    "name": "SagaState",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type SagaState = \"running\" | \"compensating\" | \"completed\" | \"compensated\" | \"manual-review\";"
+  },
+  {
+    "name": "SagaStepExecutionContext",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SagaStepExecutionContext {\n    readonly effectId: string;\n    readonly signal: AbortSignal;\n}"
+  },
+  {
+    "name": "SagaStepNotCommittedError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class SagaStepNotCommittedError extends Error {\n    readonly code: string;\n    constructor(code?: string);\n}",
+    "doc": "/** Throw this only when a provider conclusively proves that no effect committed. */"
+  },
+  {
+    "name": "SagaStepRecord",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SagaStepRecord {\n    readonly name: string;\n    readonly effectId: string;\n    readonly compensationEffectId: string;\n    readonly state: SagaStepState;\n    readonly compensationArgs: unknown;\n    readonly result?: unknown;\n    readonly attempts: number;\n    readonly nextAttemptAt?: number;\n    readonly errorCode?: string;\n}"
+  },
+  {
+    "name": "SagaStepState",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type SagaStepState = \"executing\" | \"committed\" | \"failed\" | \"ambiguous\" | \"compensating\" | \"compensation-failed\" | \"compensated\";"
+  },
+  {
+    "name": "SagaStore",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SagaStore {\n    readonly durability?: \"memory\" | \"durable\";\n    create(record: SagaRecord): boolean | Promise<boolean>;\n    get(sagaId: string): SagaRecord | undefined | Promise<SagaRecord | undefined>;\n    /** Atomic version compare-and-set; this is the saga engine's crash/concurrency boundary. */\n    compareAndSet(input: {\n        readonly sagaId: string;\n        readonly version: number;\n        readonly record: SagaRecord;\n    }): boolean | Promise<boolean>;\n    /** Bounded operational scan. Transition-only stores do not need to implement reconciliation. */\n    scan?(input: ReconciliationScanOptions<SagaState>): ReconciliationScanPage<SagaRecord> | Promise<ReconciliationScanPage<SagaRecord>>;\n    /** @deprecated Compatibility fallback; production reconciliation should implement `scan`. */\n    list?(): readonly SagaRecord[] | Promise<readonly SagaRecord[]>;\n}"
+  },
   {
     "name": "sanitizeOutputNames",
     "kind": "function",
@@ -8571,7 +9453,7 @@
     "name": "Server",
     "kind": "class",
     "package": "@nifrajs/core",
-    "signature": "export declare class Server<R extends Registry = EmptyRegistry, Ctx = EmptyContext> {\n    private readonly catalog;\n    /** WebSocket routes, matched separately at upgrade time (a GET + `Upgrade: websocket`). */\n    private readonly wsRouter;\n    private wsRouteCount;\n    /** In-process pub/sub backing `ws.subscribe(topic)` + `app.publish(topic, data)` (single-instance).\n     * Created by the first `app.ws()` via the `@nifrajs/core/ws` runtime — `undefined` until then, so a\n     * no-WebSocket app never constructs (or bundles) it. */\n    private topics;\n    private readonly maxBodyBytes;\n    private readonly wsMaxPayloadBytes;\n    private readonly requestTimeoutMs;\n    /** Opt-in caller-IP trust declaration; `undefined` = socket peer only, no forwarded header believed. */\n    private readonly clientIpTrust;\n    private readonly acceptInboundDeadlines;\n    private readonly maxInboundDeadlineMs;\n    private readonly deadlineAdmissionOptions;\n    private readonly gracefulSignals;\n    /** Capacity-admission gate; `undefined` = off (the request path pays nothing). */\n    private readonly capacityGate;\n    private readonly onCapabilityUse;\n    /** The installed effect-ledger runtime (owns the sink + per-route resolution + settle), or\n     * `undefined` when the effect-ledger plugin is not installed. */\n    private effectLedgerRuntime;\n    /** The installed idempotency runtime (owns the app-wide default store + the dedupe lane), or\n     * `undefined` when the idempotency plugin is not installed. */\n    private idempotencyRuntime;\n    /** Installed opt-in runtime for `.tool()`/`.resource()`/`.prompt()`; `undefined` until `.use(mcp())`. */\n    private mcpRuntime;\n    /** Installed Node-direct renderer for direct `resolveNode()` callers; `undefined` until `.use(nodeDirect())`. */\n    private nodeOutcomeRuntime;\n    /** Installed streaming runtime for `.sse()` routes; `undefined` until `.use(streaming())`. */\n    private sseRuntime;\n    /** Installed WebSocket runtime for `.ws()` routes; `undefined` until `.use(websocket())`. */\n    private wsRuntime;\n    private readonly logger;\n    /** App-wide validation-error fallback; a route's own `schema.onValidationError` takes precedence. */\n    private readonly defaultOnValidationError?;\n    private bunServer;\n    private sealed;\n    private readonly derives;\n    private readonly decorations;\n    private readonly beforeHandleHooks;\n    private readonly afterHandleHooks;\n    private readonly onErrorHooks;\n    private readonly aroundHooks;\n    private readonly onRequestHooks;\n    private readonly onResponseHooks;\n    private readonly onResponseFinalizedHooks;\n    private readonly responseRequests;\n    /** Names of plugins/middleware already applied via `use` — for idempotent dedupe. */\n    private readonly appliedPlugins;\n    /** Order-scoped evidence captured by routes registered after an assured plugin. */\n    private readonly activeAssurance;\n    /** App-wide evidence from global hooks; applies retroactively to every route. */\n    private readonly globalAssurance;\n    /** App-declared MCP resources / prompts (via {@link resource} / {@link prompt}), read by `nifra mcp`. */\n    private readonly mcpResourceList;\n    private readonly mcpPromptList;\n    constructor(options?: ServerOptions);\n    private assertConfigurable;\n    /** Add a per-request, computed context extension for subsequent routes. */\n    derive<D extends object>(fn: (context: Context & Ctx) => MaybePromise<D>): Server<R, Ctx & D>;\n    /** Add a static context value for subsequent routes. */\n    decorate<const K extends string, V>(key: K, value: V): Server<R, Ctx & Record<K, V>>;\n    /**\n     * Run before routing on the raw request. Return a `Response` to short-circuit, or a replacement\n     * `Request` to continue routing with a rewritten method/URL/headers. Global.\n     */\n    onRequest(fn: (req: Request, platform?: Platform<EnvOf<Ctx>>) => MaybePromise<OnRequestResult>): this;\n    /** Run after validation, before the handler; a non-`undefined` return short-circuits. Order-scoped. */\n    beforeHandle(fn: (context: Context & Ctx) => MaybePromise<unknown>): this;\n    /**\n     * Wrap the matched route lifecycle for subsequent routes. This is intentionally generic over the\n     * route output, so wrappers like async context storage do not force Node's direct JSON path through\n     * a Web `Response`. The first registered wrapper is outermost.\n     */\n    around(fn: <T>(context: Context & Ctx, next: () => MaybePromise<T>) => MaybePromise<T>): this;\n    /** Transform the handler's result before it is serialized. Order-scoped. */\n    afterHandle(fn: (result: unknown, context: Context & Ctx) => MaybePromise<unknown>): this;\n    /** Handle a thrown error; a non-`undefined` return becomes the response (else the default 500). Order-scoped. */\n    onError(fn: (error: unknown, context: Context & Ctx) => MaybePromise<unknown>): this;\n    /** Transform every outgoing response — success, error, 404, 405, short-circuit. Global. */\n    onResponse(fn: (response: Response, req: Request) => MaybePromise<Response>): this;\n    /** Observe the terminal response after all transformations. Observers are ordered and fail-open. */\n    onResponseFinalized(fn: (outcome: ResponseFinalization, req: Request) => MaybePromise<void>): this;\n    /**\n     * Apply a type-**identity** plugin ({@link IdentityPlugin}, from {@link defineIdentityPlugin}) — it\n     * registers routes/hooks but doesn't change the types, so this returns `this` with the route registry\n     * and context fully intact. This overload exists specifically so a *named* identity plugin (e.g.\n     * `@nifrajs/better-auth`) threads the registry: its `& { pluginName }` intersection would otherwise\n     * defeat the generic inference of the transforming overload below and collapse the result to `any`.\n     */\n    use(plugin: IdentityPlugin): this;\n    /**\n     * Apply a **plugin function** — `(app) => app`, typically built with {@link definePlugin}. It's\n     * called with `this` and its result is returned, so an inline plugin's `derive`/`decorate` thread\n     * the added context to handlers defined after `use` (the overload is generic over the concrete\n     * `this`). A named plugin already applied is skipped (idempotent dedupe).\n     */\n    use<Out extends AnyServer>(plugin: (app: this) => Out): Out;\n    /**\n     * Apply a {@link Middleware} bundle — wire each hook it provides to its lifecycle point. Returns\n     * `this` (no context-type merging); call it before the routes its `beforeHandle`/`afterHandle`\n     * should cover (those are order-scoped; `onRequest`/`onResponse` are global). A named bundle already\n     * applied is skipped (idempotent).\n     */\n    use(mw: Middleware): this;\n    get<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    get<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    /**\n     * Register a **typed SSE route** — a GET endpoint streaming `text/event-stream` whose event\n     * payloads are contracted by `schema.sse`. The handler receives the validated context plus a\n     * {@link TypedSSEStream}: `stream.send(event)` is compile-time-checked against the schema and\n     * JSON-serialized into the SSE `data:` field. The typed client sees the marker and grows a\n     * `.subscribe(onEvent)` for the route with the same payload type — end-to-end typed streaming.\n     *\n     *   import { streaming } from \"@nifrajs/core/sse\"   // .use(streaming()) enables .sse()\n     *   const app = server().use(streaming()).sse(\"/feed\", { sse: t.object({ id: t.integer(), title: t.string() }) },\n     *     async (c, stream) => {\n     *       stream.send({ id: 1, title: \"hello\" })          // typed\n     *       await waitForDisconnect(stream.signal)\n     *     },\n     *     { keepAlive: 15_000 })\n     *\n     *   // client: const off = api.feed.subscribe((post) => console.log(post.title))\n     *\n     * `init` passes through to the underlying {@link sse} helper (`keepAlive`, extra headers). The\n     * connection closes when the handler resolves, `stream.close()` runs, or the client disconnects\n     * (`stream.signal`). Query/body schemas validate exactly as on any other route.\n     */\n    sse<Path extends string, S extends RouteSchema & {\n        sse: StandardSchemaV1;\n    }>(path: Path, schema: S, run: (context: Context<Path, S> & Ctx, stream: TypedSSEStream<InferOutput<S[\"sse\"]>>) => void | Promise<void>, init?: SSEInit): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, S, Response>>, Ctx>;\n    post<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"POST\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    post<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"POST\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    put<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"PUT\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    put<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"PUT\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    patch<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"PATCH\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    patch<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"PATCH\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    delete<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"DELETE\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    delete<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"DELETE\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    /**\n     * Declare an **MCP tool** an agent can call (via `nifra mcp`, or a mounted MCP endpoint): a typed\n     * `POST /_nifra/tool/<name>` route whose `input`/`output` schemas contract the call and surface in\n     * `tools/list`. Requires `.use(mcp())` - without it, `.tool()` is a registration error, so an\n     * ordinary HTTP app never bundles the MCP wiring. Siblings: {@link resource}, {@link prompt}.\n     *\n     *   import { mcp } from \"@nifrajs/core/mcp\"\n     *   const app = server().use(mcp()).tool(\n     *     \"search\",\n     *     { description: \"Search posts\", input: t.object({ q: t.string() }) },\n     *     ({ q }) => findPosts(q),\n     *   )\n     */\n    tool<Name extends string, S extends {\n        description: string;\n        input: StandardSchemaV1;\n        output?: StandardSchemaV1;\n        annotations?: ToolAnnotations;\n    }, H extends (input: InferOutput<S[\"input\"]>, ctx: Context & Ctx) => MaybePromise<S[\"output\"] extends StandardSchemaV1 ? InferOutput<S[\"output\"]> : unknown>>(name: Name, config: S, handler: H): Server<AddRoute<R, \"POST\", `/_nifra/tool/${Name}`, RouteInfoFor<`/_nifra/tool/${Name}`, S[\"output\"] extends StandardSchemaV1 ? {\n        body: S[\"input\"];\n        response: S[\"output\"];\n    } : {\n        body: S[\"input\"];\n    }, OutputOf<H>>>, Ctx>;\n    /**\n     * Declare an MCP **resource** — read-only data an agent can fetch through `nifra mcp` (app config, a\n     * generated document, …). `read` runs in the app process, so capture whatever app state it needs in the\n     * closure. `uri` is the MCP resource identifier (e.g. `\"myapp://config\"`). The sibling of {@link tool}\n     * for the resource half of MCP.\n     */\n    resource(uri: string, config: {\n        readonly name: string;\n        readonly description?: string;\n        readonly mimeType?: string;\n    }, read: McpResourceDescriptor[\"read\"]): Server<R, Ctx>;\n    /**\n     * Declare an MCP **prompt** — a reusable prompt template an agent can fetch through `nifra mcp`.\n     * `handler` receives the caller's arguments and returns the rendered messages.\n     */\n    prompt(name: string, config: {\n        readonly description: string;\n        readonly arguments?: readonly PromptArgument[];\n    }, handler: McpPromptDescriptor[\"handler\"]): Server<R, Ctx>;\n    /** The MCP resources declared via {@link resource} — enumerated by `nifra mcp`. */\n    mcpResources(): readonly McpResourceDescriptor[];\n    /** The MCP prompts declared via {@link prompt} — enumerated by `nifra mcp`. */\n    mcpPrompts(): readonly McpPromptDescriptor[];\n    /**\n     * Register a **WebSocket** route. The connection upgrades on a `GET` to `path` carrying\n     * `Upgrade: websocket`; the optional `handler.upgrade(c)` runs in the request context first and may\n     * reject (return a `Response`) or seed per-connection `ws.data`. WebSockets are served by the\n     * adapter (`listen()`, `@nifrajs/node`, `@nifrajs/deno`, `toFetchHandler`) — not by bare `app.fetch`, which\n     * has no socket (a WS path through `app.fetch` is a normal HTTP response).\n     *\n     * The route also enters the type-level registry (under the pseudo-method `\"WS\"`), so the typed\n     * client grows a `.ws()` handle for it: `messageSchema` types what the client may `send`,\n     * `sendSchema` types the frames it receives. Passing explicit type arguments (`ws<MyData>(…)`)\n     * defeats path-literal inference and skips the registry entry - the route still serves, it is just\n     * invisible to `client<App>`; prefer typing `data` via `upgrade()`'s return.\n     *\n     *   app.ws(\"/chat\", { open: (ws) => ws.send(\"hi\"), message: (ws, data) => ws.send(data) })\n     */\n    ws<Data = unknown, Schema extends StandardSchemaV1 | undefined = undefined, Send extends StandardSchemaV1 | undefined = undefined, Path extends string = string>(path: Path, handler: WebSocketHandler<Data, EnvOf<Ctx>, Schema, Send>): string extends Path ? Server<R, Ctx> : Server<AddRoute<R, \"WS\", Path, WsRouteInfoFor<Path, Schema, Send>>, Ctx>;\n    /**\n     * Broadcast `data` to every WebSocket connection subscribed to `topic` (via `ws.subscribe(topic)`).\n     * In-process and **single-instance** (see {@link TopicRegistry}) — a multi-instance deploy must bridge\n     * an external fan-out (Redis, a Durable Object) to this. A no-op when nobody is subscribed.\n     */\n    publish(topic: string, data: string | ArrayBufferView | ArrayBuffer): void;\n    private route;\n    /**\n     * Low-level route registration shared by the inline builder and `implement()`.\n     * Captures the server's current `derive`/`decorate` chain into the route — this\n     * is the \"compiled\", order-scoped per-route chain.\n     */\n    register(method: Method, path: string, schema: RouteSchema | undefined, handler: (context: never) => unknown): void;\n    /** Register a contract/group route batch atomically. Every route captures the same current chain it\n     * would capture through {@link register}; no route becomes visible unless the full batch validates. */\n    registerBatch(routes: readonly {\n        readonly method: Method;\n        readonly path: string;\n        readonly schema: RouteSchema | undefined;\n        readonly handler: (context: never) => unknown;\n    }[]): void;\n    private prepareRoute;\n    /** Collapse route-invariant lifecycle decisions into one runner at registration. The request path\n     * performs no eligibility ladder: it supplies request state to this already-selected plan. */\n    private compileExecutionPlan;\n    /** The idempotency lane's bridge back into the normal matched lanes, resolved to a concrete Response\n     * (the lane buffers the body, then replays it through the route's real validation + handler). */\n    private idempotencyRunLanes;\n    /** @internal Symbol-keyed install seam for the `idempotency()` plugin. Off the public typed surface. */\n    [INSTALL_IDEMPOTENCY](runtime: IdempotencyRuntime): void;\n    /** @internal Symbol-keyed install seam for the `mcp()` plugin. Off the public typed surface. */\n    [INSTALL_MCP](runtime: McpRuntime): void;\n    /** @internal Symbol-keyed install seam for the `nodeDirect()` plugin. Off the public typed surface. */\n    [INSTALL_NODE_DIRECT](runtime: NodeOutcomeRuntime): void;\n    /** @internal Symbol-keyed install seam for the `streaming()` plugin. Off the public typed surface. */\n    [INSTALL_SSE](runtime: SseRuntime): void;\n    /** @internal Symbol-keyed install seam for the `websocket()` plugin. Off the public typed surface. */\n    [INSTALL_WS](runtime: WsRuntime): void;\n    /**\n     * Merge another server's routes into this one — the composition escape hatch for large apps.\n     *\n     * WHY: the fluent chain accumulates one type-alias level per route, and TypeScript resolves\n     * that stack in one recursion — a single chain hits TS2589 at ~95 routes. Groups keep every\n     * chain short: build each domain (`listings`, `agents`, …) as its own `server()` (its registry\n     * resolves independently), then `app.merge(listings).merge(agents)` — each merge adds ONE level\n     * regardless of group size. 300+ routes stay fully typed (see many-routes.test-d.ts). The\n     * other escape hatch is contract-first `implement()`, whose registry is a single object type.\n     *\n     * Semantics: merged routes keep the chains captured where they were DEFINED — the group's\n     * `derive`/`decorate`/`beforeHandle`/`afterHandle`/`onError`/`around` apply to its routes\n     * exactly as they did standalone, so a group wires its own plugins. The group's request-level\n     * hooks (`onRequest`/`onResponse`/`onResponseFinalized`) are appended to this server's. This\n     * server's route-scoped chains do NOT retroactively wrap merged routes (order-scoped, like\n     * routes registered before a `derive`). Fail closed: a path+method collision throws\n     * `RouteConfigError` at merge time, and a group with WebSocket routes is refused (register\n     * those on the parent).\n     */\n    merge<R2 extends Registry, Ctx2>(other: Server<R2, Ctx2>): Server<R & R2, Ctx>;\n    /** A fused renderer closes over runtime services to keep its seven-argument JSC fast path. Merging\n     * rebinds that closure once to the executing server; generic plans already receive the runtime. */\n    private bindFusedRuntime;\n    /**\n     * Enumerate the registered routes (method, path, input schemas), in registration\n     * order. Powers `toOpenAPI` and other introspection; the router trie itself no\n     * longer holds the original patterns.\n     */\n    routes(): ReadonlyArray<RouteDescriptor>;\n    /**\n     * Resolve a `Request` to a `Response` — the whole lifecycle, testable without a port. The\n     * optional `platform` carries edge inputs (`env`, `waitUntil`); edge adapters pass it, and\n     * Bun/Node/Deno omit it (then `c.env` is `undefined` and `c.waitUntil` runs fire-and-forget).\n     */\n    fetch(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<Response>;\n    private fetchSource;\n    private fetchSourceInner;\n    /** Web response path when Bun already matched the route. The lifecycle and response hooks remain\n     * exactly the same as {@link fetchSource}; only portable URL scanning + trie lookup are skipped. */\n    private fetchMatched;\n    private fetchMatchedInner;\n    /**\n     * Run `produce` under the capacity gate: admit → run → release exactly once when the response is\n     * produced (or the run throws). Only reached when {@link capacityGate} is set, so the off path pays\n     * nothing. The slot is held for the duration of handler execution, not the streaming of the body —\n     * capacity here bounds concurrent *work*, matching how in-flight is counted.\n     */\n    private admitGated;\n    private runAdmitted;\n    /**\n     * Like {@link fetch}, but renders a plain-data result **without** building a Web `Response` — the\n     * `@nifrajs/node` adapter serializes the returned primitives straight to the socket, skipping the undici\n     * `Response` build + body drain (the bulk of the Node bridge cost, measured ≈4µs/req). A handler that\n     * returns a `Response`, an error/short-circuit, or any registered `onResponse` hook falls back to the\n     * full Web path (`{ kind: \"response\" }`), so behavior is identical — only the common JSON-data case is\n     * faster. Same lifecycle as {@link fetch} (body cap, validation, hooks all run); only the final\n     * render differs.\n     */\n    resolveNode(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<NodeServeOutcome>;\n    resolveNodeSource(source: RequestSource, platform?: Platform<EnvOf<Ctx>>, suppliedRuntime?: NodeOutcomeRuntime): MaybePromise<NodeServeOutcome>;\n    /**\n     * Resolve a WebSocket upgrade — the seam every serving adapter uses. Returns `pass` (not a WS\n     * upgrade for a registered route → handle as normal HTTP), `reject` (a WS route matched but\n     * `upgrade()` rejected, or the path was malformed → return `response`), or `upgrade` (perform the\n     * runtime upgrade, then dispatch the native socket's events to `handler`, seeding `ws.data` with\n     * `data`). Runs the route's `upgrade(c)` guard in a real request context. Synchronous unless\n     * `upgrade()` is async; a throw rejects with a flat 500 (no detail leaked).\n     */\n    resolveWebSocketUpgrade(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<WebSocketUpgradeOutcome>;\n    /** Bun `fetch` when WS routes exist: try a WS upgrade first, else run the normal HTTP lifecycle.\n     * `undefined` ⇒ Bun owns the upgraded socket; a `Response` ⇒ a normal reply or a rejected upgrade.\n     * (The socket dispatch itself lives in `ws-bun.ts`, loaded via `@nifrajs/core/ws`.) */\n    private bunFetchWithWebSocket;\n    /**\n     * The shared lifecycle, generic over how the final value is rendered: `finalize` turns a handler's\n     * result + `set` into the output `T` (`toResponse` → a Web `Response`; `toNodeOutcome` → node-direct\n     * primitives), `wrapResponse` lifts an early/error `Response` into that same `T`, and `onTimeout`\n     * produces the 503. The Web `fetch` and `resolveNode` are thin callers over this one routing +\n     * context + lifecycle implementation — no duplication across the trust boundary.\n     */\n    /** Apply the `clientIp` trust declaration to the adapter's raw socket peer, returning a platform\n     * whose `clientIp` is the derived caller. Only called when a trust declaration is configured. */\n    private deriveClientIp;\n    private dispatch;\n    /**\n     * onRequest short-circuit path. Synchronous as long as every hook returns synchronously (the\n     * common case — e.g. CORS returning `undefined` for a non-preflight request): an `async` version\n     * here put EVERY request of any app with one onRequest hook onto the promise machinery, profiled\n     * at ~13% of a realistic request. The first hook that returns a Promise hands the REMAINING\n     * hooks to the async continuation; behavior is identical.\n     */\n    private runWithOnRequest;\n    /** Async tail of {@link runWithOnRequest}: applies the first awaited hook's outcome, then runs\n     * the remaining hooks (awaiting freely — we're already async here). */\n    private continueOnRequest;\n    private takeResponseRequest;\n    /**\n     * Route → build context → run. Synchronous through to the handler for a **bare** route\n     * (selected by its compiled plan), so a sync handler produces its result with zero promise allocations;\n     * routes with validation/hooks keep the full async {@link runLifecycle}, unchanged.\n     */\n    private routeAndRun;\n    /** Run a route that has already been matched by the runtime or Nifra's portable router. */\n    private runMatched;\n    /** Supply request-specific deadline state to the route's precompiled execution plan. */\n    private runMatchedLanes;\n    /** @internal Symbol-keyed install seam for the `effectLedger()` plugin. Off the public typed surface. */\n    [INSTALL_EFFECT_LEDGER](runtime: EffectLedgerRuntime): void;\n    /** The narrowest bare route: a syntactic `() => ...` handler cannot observe the context argument, so\n     * successful requests can skip allocating `RequestContext`. Errors still allocate one for logging. */\n    private runContextlessBare;\n    private contextlessBareError;\n    /**\n     * The synchronous fast path selected by a route's execution plan: apply static decorations, call the\n     * handler, render the result — **no `await`** unless the handler itself returns a promise. It mirrors\n     * the bare slice of {@link runLifecycle} (which a bare route would otherwise no-op through) and shares\n     * {@link logRequestError}; a bare route has no `onError` hooks, so error handling is fully synchronous\n     * (a thrown `Response` is control flow; anything else is a logged flat 500). This is where nifra skips\n     * the per-request async-frame tax — the same win codegen routers get, but without `eval`.\n     */\n    private runBare;\n    /** Bare-route error rendering — identical to {@link runLifecycle}'s catch minus the (absent) onError\n     * loop: a thrown `Response` is returned as deliberate control flow; anything else is logged + 500. */\n    /**\n     * Build a route's fused Web renderer. Composition happens once at\n     * registration; the returned closure is what every request to the route runs. Behavior is\n     * byte-identical to the generic `runBare`/`runContextlessBare` + `toResponse` pair — same\n     * decoration order, same error routing (thrown `Response` = control flow; anything else logs and\n     * 500s), same respond semantics (the lifecycle parity suite pins it).\n     */\n    private buildFusedWeb;\n    private bareError;\n    private runWithAround;\n    private runAround;\n    private runBodyOnly;\n    /** Validate + run the handler for the bodyOnly path — shared by the inline fast path and the\n     * streaming fallback. A method (not per-request closures) so the hot path allocates nothing\n     * beyond the one `.then` continuation. */\n    private finishBodyOnly;\n    private executeHandler;\n    private handleValidationErrorRecovery;\n    private applyBodyValidation;\n    private runQueryOnly;\n    /** Validate-result → set `ctx.query` → run handler. A method (not a per-request closure), the\n     * query analogue of {@link applyBodyValidation}. */\n    private applyQueryValidation;\n    /**\n     * Thread the response through each global `onResponse` hook. Stays SYNCHRONOUS until a hook\n     * actually returns a Promise — an `async` version forced a promise + microtask on EVERY response\n     * of any app with an onResponse hook (cors/securityHeaders/etag/timing all use onResponse), the\n     * same ~13%/req tax the onRequest walk was de-async'd to avoid. The first async hook hands the\n     * rest to {@link continueOnResponse}.\n     */\n    private applyOnResponse;\n    private applyOnResponseAndFinalize;\n    private completeResponseFinalization;\n    private failResponseFinalization;\n    /** Notify terminal observers in order while isolating both sync and async failures. */\n    private notifyResponseFinalized;\n    /** Async tail of {@link applyOnResponse}: runs the remaining hooks once one has gone async. */\n    private continueOnResponse;\n    /**\n     * Bound the response time. On timeout we abort `ctx.signal` (so cancellation-aware\n     * handlers can bail) and return 503; the in-flight work keeps running but its\n     * result is discarded — JS can't forcibly cancel a promise.\n     */\n    private withTimeout;\n    /**\n     * The post-match lifecycle: validate → derive → beforeHandle → handler → afterHandle, with onError.\n     * Generic over the render: a success value goes through `finalize(result, set)` (a Web `Response`, or\n     * node-direct primitives); an early/error `Response` (validation, thrown, 500) through `wrapResponse`.\n     */\n    private runLifecycle;\n    private handleLifecycleError;\n    /** Log an unhandled request error to the (redacting) logger — shared by {@link runLifecycle} and the\n     * bare fast path ({@link bareError}) so both record the same fields. Never throws; never leaks. */\n    private logRequestError;\n    private readAndValidateBody;\n    /** Apply validation and its recovery hook on the generic lifecycle lane. Recovery is completed\n     * before derives/beforeHandle run, matching the body-only and query-only execution lanes. */\n    private applyLifecycleValidation;\n    /**\n     * Read the body as text, capped at `maxBodyBytes`. Rejects (`null`) on a\n     * `Content-Length` over the cap *before* buffering, and aborts mid-stream once the\n     * running byte count exceeds it — so a lying or absent length can't force us to\n     * buffer an oversized payload.\n     *\n     * Fast path: when a non-chunked request carries a `Content-Length` within the cap,\n     * a native `req.json()` is already bounded — under HTTP/1.1 + HTTP/2 framing the\n     * runtime delivers at most `Content-Length` bytes — so we skip the manual stream\n     * loop and a separate text decode. It trusts the wire\n     * *framing*, not the header value: nifra only ever receives framed Requests from the\n     * runtime's HTTP server, never a hand-built one with a mismatched length. Chunked or\n     * length-less bodies fall through to the streaming byte-cap guard below.\n     */\n    private readBoundedJson;\n    /** Adapt one route's compiled execution plan to Bun's already-matched request shape. Route\n     * semantics remain in the plan; this closure only supplies native params and deadline fallback. */\n    private compileBunNativeHandler;\n    /** Compile portable route registrations into Bun's native route table. Apps with request-rewrite\n     * hooks or WebSockets retain the single portable dispatcher because those features must run before\n     * route selection/upgrade. Named wildcards also stay on the fallback until Bun exposes their raw\n     * capture semantics; static and `:param` routes take the native lane. */\n    private buildBunNativeRoutes;\n    /**\n     * Start a `Bun.serve` instance bound to `port` (use `0` for an ephemeral port).\n     *\n     * `reusePort` sets `SO_REUSEPORT` so **multiple processes can bind the same port** and the kernel\n     * load-balances connections across them — the standard way to use every core (Bun is\n     * single-threaded per process). Spawn one process per core, each calling\n     * `app.listen(PORT, { reusePort: true })`; see `examples/cluster.ts`. Every process must opt in,\n     * and all of them must be the same app. Linux balances ~evenly; macOS accepts the flag but may\n     * favor one socket (fine for dev, measure on Linux for production numbers).\n     *\n     * `hostname` is the bind address, defaulting to Bun's `0.0.0.0` (every interface). Pass\n     * `\"127.0.0.1\"` to bind loopback only - an admin surface, a sidecar, or anything that must not be\n     * reachable off the box. Omitting it when you meant to restrict is a real exposure, so it is a\n     * first-class option rather than something a caller has to drop down to `Bun.serve` for.\n     */\n    listen(port: number, options?: {\n        readonly reusePort?: boolean;\n        readonly hostname?: string;\n    }): RunningServer;\n    /**\n     * Gracefully stop: wait for in-flight requests to finish (up to `drainMs`), then\n     * issue a single terminal stop — graceful if everything drained, forced if\n     * stragglers remain. Safe to call when not listening.\n     *\n     * The Bun semantics: poll `pendingRequests` (awaiting\n     * `stop()`'s promise drops in-flight requests), and decide graceful-vs-forced in\n     * ONE call (Bun can't escalate an already-graceful `stop()` to a forced close).\n     * New connections may be accepted during the drain window; in a real deploy the\n     * load balancer has already stopped routing here, and `drainMs` bounds it.\n     */\n    stop({ drainMs }?: {\n        drainMs?: number;\n    }): Promise<void>;\n    private installSignalHandlers;\n}",
+    "signature": "export declare class Server<R extends Registry = EmptyRegistry, Ctx = EmptyContext> {\n    private readonly catalog;\n    /** WebSocket routes, matched separately at upgrade time (a GET + `Upgrade: websocket`). */\n    private readonly wsRouter;\n    private wsRouteCount;\n    /** In-process pub/sub backing `ws.subscribe(topic)` + `app.publish(topic, data)` (single-instance).\n     * Created by the first `app.ws()` via the `@nifrajs/core/ws` runtime — `undefined` until then, so a\n     * no-WebSocket app never constructs (or bundles) it. */\n    private topics;\n    private readonly maxBodyBytes;\n    private readonly wsMaxPayloadBytes;\n    private readonly requestTimeoutMs;\n    /** Opt-in caller-IP trust declaration; `undefined` = socket peer only, no forwarded header believed. */\n    private readonly clientIpTrust;\n    private readonly acceptInboundDeadlines;\n    private readonly maxInboundDeadlineMs;\n    private readonly deadlineAdmissionOptions;\n    private readonly gracefulSignals;\n    /** Capacity-admission gate; `undefined` = off (the request path pays nothing). */\n    private readonly capacityGate;\n    private readonly onCapabilityUse;\n    private readonly capabilityInterceptors;\n    private readonly capabilityObservers;\n    /** The installed effect-ledger runtime (owns the sink + per-route resolution + settle), or\n     * `undefined` when the effect-ledger plugin is not installed. */\n    private effectLedgerRuntime;\n    /** The installed idempotency runtime (owns the app-wide default store + the dedupe lane), or\n     * `undefined` when the idempotency plugin is not installed. */\n    private idempotencyRuntime;\n    /** Installed opt-in runtime for `.tool()`/`.resource()`/`.prompt()`; `undefined` until `.use(mcp())`. */\n    private mcpRuntime;\n    /** Installed Node-direct renderer for direct `resolveNode()` callers; `undefined` until `.use(nodeDirect())`. */\n    private nodeOutcomeRuntime;\n    /** Installed streaming runtime for `.sse()` routes; `undefined` until `.use(streaming())`. */\n    private sseRuntime;\n    /** Installed WebSocket runtime for `.ws()` routes; `undefined` until `.use(websocket())`. */\n    private wsRuntime;\n    private readonly logger;\n    /** App-wide validation-error fallback; a route's own `schema.onValidationError` takes precedence. */\n    private readonly defaultOnValidationError?;\n    private bunServer;\n    private sealed;\n    private readonly derives;\n    private readonly decorations;\n    private readonly beforeHandleHooks;\n    private readonly afterHandleHooks;\n    private readonly onErrorHooks;\n    private readonly aroundHooks;\n    private readonly onRequestHooks;\n    private readonly onResponseHooks;\n    private readonly onResponseFinalizedHooks;\n    private readonly responseRequests;\n    /** Names of plugins/middleware already applied via `use` — for idempotent dedupe. */\n    private readonly appliedPlugins;\n    /** Order-scoped evidence captured by routes registered after an assured plugin. */\n    private readonly activeAssurance;\n    /** App-wide evidence from global hooks; applies retroactively to every route. */\n    private readonly globalAssurance;\n    /** App-declared MCP resources / prompts (via {@link resource} / {@link prompt}), read by `nifra mcp`. */\n    private readonly mcpResourceList;\n    private readonly mcpPromptList;\n    constructor(options?: ServerOptions);\n    private assertConfigurable;\n    /** Add a per-request, computed context extension for subsequent routes. */\n    derive<D extends object>(fn: (context: Context & Ctx) => MaybePromise<D>): Server<R, Ctx & D>;\n    /** Add a static context value for subsequent routes. */\n    decorate<const K extends string, V>(key: K, value: V): Server<R, Ctx & Record<K, V>>;\n    /**\n     * Run before routing on the raw request. Return a `Response` to short-circuit, or a replacement\n     * `Request` to continue routing with a rewritten method/URL/headers. Global.\n     */\n    onRequest(fn: (req: Request, platform?: Platform<EnvOf<Ctx>>) => MaybePromise<OnRequestResult>): this;\n    /** Run after validation, before the handler; a non-`undefined` return short-circuits. Order-scoped. */\n    beforeHandle(fn: (context: Context & Ctx) => MaybePromise<unknown>): this;\n    /**\n     * Wrap the matched route lifecycle for subsequent routes. This is intentionally generic over the\n     * route output, so wrappers like async context storage do not force Node's direct JSON path through\n     * a Web `Response`. The first registered wrapper is outermost.\n     */\n    around(fn: <T>(context: Context & Ctx, next: () => MaybePromise<T>) => MaybePromise<T>): this;\n    /**\n     * Asynchronously admit each subsequent `executeCapability()` call before its owned effect runs.\n     * Interceptors receive token-only metadata plus an abort signal and must call `next()` exactly once\n     * to admit. Returning without `next()`, timing out, aborting, or throwing fails the effect closed.\n     */\n    aroundCapability(interceptor: CapabilityInterceptor, options?: AroundCapabilityOptions): this;\n    /** Observe token-only admission/execution lifecycle events for subsequent capability routes. */\n    observeCapability(observer: EffectLifecycleObserver): this;\n    /** Transform the handler's result before it is serialized. Order-scoped. */\n    afterHandle(fn: (result: unknown, context: Context & Ctx) => MaybePromise<unknown>): this;\n    /** Handle a thrown error; a non-`undefined` return becomes the response (else the default 500). Order-scoped. */\n    onError(fn: (error: unknown, context: Context & Ctx) => MaybePromise<unknown>): this;\n    /** Transform every outgoing response — success, error, 404, 405, short-circuit. Global. */\n    onResponse(fn: (response: Response, req: Request) => MaybePromise<Response>): this;\n    /** Observe the terminal response after all transformations. Observers are ordered and fail-open. */\n    onResponseFinalized(fn: (outcome: ResponseFinalization, req: Request) => MaybePromise<void>): this;\n    /**\n     * Apply a type-**identity** plugin ({@link IdentityPlugin}, from {@link defineIdentityPlugin}) — it\n     * registers routes/hooks but doesn't change the types, so this returns `this` with the route registry\n     * and context fully intact. This overload exists specifically so a *named* identity plugin (e.g.\n     * `@nifrajs/better-auth`) threads the registry: its `& { pluginName }` intersection would otherwise\n     * defeat the generic inference of the transforming overload below and collapse the result to `any`.\n     */\n    use(plugin: IdentityPlugin): this;\n    /**\n     * Apply a **plugin function** — `(app) => app`, typically built with {@link definePlugin}. It's\n     * called with `this` and its result is returned, so an inline plugin's `derive`/`decorate` thread\n     * the added context to handlers defined after `use` (the overload is generic over the concrete\n     * `this`). A named plugin already applied is skipped (idempotent dedupe).\n     */\n    use<Out extends AnyServer>(plugin: (app: this) => Out): Out;\n    /**\n     * Apply a {@link Middleware} bundle — wire each hook it provides to its lifecycle point. Returns\n     * `this` (no context-type merging); call it before the routes its `beforeHandle`/`afterHandle`\n     * should cover (those are order-scoped; `onRequest`/`onResponse` are global). A named bundle already\n     * applied is skipped (idempotent).\n     */\n    use(mw: Middleware): this;\n    get<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    get<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    /**\n     * Register a **typed SSE route** — a GET endpoint streaming `text/event-stream` whose event\n     * payloads are contracted by `schema.sse`. The handler receives the validated context plus a\n     * {@link TypedSSEStream}: `stream.send(event)` is compile-time-checked against the schema and\n     * JSON-serialized into the SSE `data:` field. The typed client sees the marker and grows a\n     * `.subscribe(onEvent)` for the route with the same payload type — end-to-end typed streaming.\n     *\n     *   import { streaming } from \"@nifrajs/core/sse\"   // .use(streaming()) enables .sse()\n     *   const app = server().use(streaming()).sse(\"/feed\", { sse: t.object({ id: t.integer(), title: t.string() }) },\n     *     async (c, stream) => {\n     *       stream.send({ id: 1, title: \"hello\" })          // typed\n     *       await waitForDisconnect(stream.signal)\n     *     },\n     *     { keepAlive: 15_000 })\n     *\n     *   // client: const off = api.feed.subscribe((post) => console.log(post.title))\n     *\n     * `init` passes through to the underlying {@link sse} helper (`keepAlive`, extra headers). The\n     * connection closes when the handler resolves, `stream.close()` runs, or the client disconnects\n     * (`stream.signal`). Query/body schemas validate exactly as on any other route.\n     */\n    sse<Path extends string, S extends RouteSchema & {\n        sse: StandardSchemaV1;\n    }>(path: Path, schema: S, run: (context: Context<Path, S> & Ctx, stream: TypedSSEStream<InferOutput<S[\"sse\"]>>) => void | Promise<void>, init?: SSEInit): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, S, Response>>, Ctx>;\n    post<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"POST\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    post<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"POST\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    put<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"PUT\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    put<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"PUT\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    patch<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"PATCH\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    patch<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"PATCH\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    delete<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"DELETE\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    delete<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"DELETE\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    /**\n     * Declare an **MCP tool** an agent can call (via `nifra mcp`, or a mounted MCP endpoint): a typed\n     * `POST /_nifra/tool/<name>` route whose `input`/`output` schemas contract the call and surface in\n     * `tools/list`. Requires `.use(mcp())` - without it, `.tool()` is a registration error, so an\n     * ordinary HTTP app never bundles the MCP wiring. Siblings: {@link resource}, {@link prompt}.\n     *\n     *   import { mcp } from \"@nifrajs/core/mcp\"\n     *   const app = server().use(mcp()).tool(\n     *     \"search\",\n     *     { description: \"Search posts\", input: t.object({ q: t.string() }) },\n     *     ({ q }) => findPosts(q),\n     *   )\n     */\n    tool<Name extends string, S extends {\n        description: string;\n        input: StandardSchemaV1;\n        output?: StandardSchemaV1;\n        annotations?: ToolAnnotations;\n    }, H extends (input: InferOutput<S[\"input\"]>, ctx: Context & Ctx) => MaybePromise<S[\"output\"] extends StandardSchemaV1 ? InferOutput<S[\"output\"]> : unknown>>(name: Name, config: S, handler: H): Server<AddRoute<R, \"POST\", `/_nifra/tool/${Name}`, RouteInfoFor<`/_nifra/tool/${Name}`, S[\"output\"] extends StandardSchemaV1 ? {\n        body: S[\"input\"];\n        response: S[\"output\"];\n    } : {\n        body: S[\"input\"];\n    }, OutputOf<H>>>, Ctx>;\n    /**\n     * Declare an MCP **resource** — read-only data an agent can fetch through `nifra mcp` (app config, a\n     * generated document, …). `read` runs in the app process, so capture whatever app state it needs in the\n     * closure. `uri` is the MCP resource identifier (e.g. `\"myapp://config\"`). The sibling of {@link tool}\n     * for the resource half of MCP.\n     */\n    resource(uri: string, config: {\n        readonly name: string;\n        readonly description?: string;\n        readonly mimeType?: string;\n    }, read: McpResourceDescriptor[\"read\"]): Server<R, Ctx>;\n    /**\n     * Declare an MCP **prompt** — a reusable prompt template an agent can fetch through `nifra mcp`.\n     * `handler` receives the caller's arguments and returns the rendered messages.\n     */\n    prompt(name: string, config: {\n        readonly description: string;\n        readonly arguments?: readonly PromptArgument[];\n    }, handler: McpPromptDescriptor[\"handler\"]): Server<R, Ctx>;\n    /** The MCP resources declared via {@link resource} — enumerated by `nifra mcp`. */\n    mcpResources(): readonly McpResourceDescriptor[];\n    /** The MCP prompts declared via {@link prompt} — enumerated by `nifra mcp`. */\n    mcpPrompts(): readonly McpPromptDescriptor[];\n    /**\n     * Register a **WebSocket** route. The connection upgrades on a `GET` to `path` carrying\n     * `Upgrade: websocket`; the optional `handler.upgrade(c)` runs in the request context first and may\n     * reject (return a `Response`) or seed per-connection `ws.data`. WebSockets are served by the\n     * adapter (`listen()`, `@nifrajs/node`, `@nifrajs/deno`, `toFetchHandler`) — not by bare `app.fetch`, which\n     * has no socket (a WS path through `app.fetch` is a normal HTTP response).\n     *\n     * The route also enters the type-level registry (under the pseudo-method `\"WS\"`), so the typed\n     * client grows a `.ws()` handle for it: `messageSchema` types what the client may `send`,\n     * `sendSchema` types the frames it receives. Passing explicit type arguments (`ws<MyData>(…)`)\n     * defeats path-literal inference and skips the registry entry - the route still serves, it is just\n     * invisible to `client<App>`; prefer typing `data` via `upgrade()`'s return.\n     *\n     *   app.ws(\"/chat\", { open: (ws) => ws.send(\"hi\"), message: (ws, data) => ws.send(data) })\n     */\n    ws<Data = unknown, Schema extends StandardSchemaV1 | undefined = undefined, Send extends StandardSchemaV1 | undefined = undefined, Path extends string = string>(path: Path, handler: WebSocketHandler<Data, EnvOf<Ctx>, Schema, Send>): string extends Path ? Server<R, Ctx> : Server<AddRoute<R, \"WS\", Path, WsRouteInfoFor<Path, Schema, Send>>, Ctx>;\n    /**\n     * Broadcast `data` to every WebSocket connection subscribed to `topic` (via `ws.subscribe(topic)`).\n     * In-process and **single-instance** (see {@link TopicRegistry}) — a multi-instance deploy must bridge\n     * an external fan-out (Redis, a Durable Object) to this. A no-op when nobody is subscribed.\n     */\n    publish(topic: string, data: string | ArrayBufferView | ArrayBuffer): void;\n    private route;\n    /**\n     * Low-level route registration shared by the inline builder and `implement()`.\n     * Captures the server's current `derive`/`decorate` chain into the route — this\n     * is the \"compiled\", order-scoped per-route chain.\n     */\n    register(method: Method, path: string, schema: RouteSchema | undefined, handler: (context: never) => unknown): void;\n    /** Register a contract/group route batch atomically. Every route captures the same current chain it\n     * would capture through {@link register}; no route becomes visible unless the full batch validates. */\n    registerBatch(routes: readonly {\n        readonly method: Method;\n        readonly path: string;\n        readonly schema: RouteSchema | undefined;\n        readonly handler: (context: never) => unknown;\n    }[]): void;\n    private prepareRoute;\n    /** Collapse route-invariant lifecycle decisions into one runner at registration. The request path\n     * performs no eligibility ladder: it supplies request state to this already-selected plan. */\n    private compileExecutionPlan;\n    /** The idempotency lane's bridge back into the normal matched lanes, resolved to a concrete Response\n     * (the lane buffers the body, then replays it through the route's real validation + handler). */\n    private idempotencyRunLanes;\n    /** @internal Symbol-keyed install seam for the `idempotency()` plugin. Off the public typed surface. */\n    [INSTALL_IDEMPOTENCY](runtime: IdempotencyRuntime): void;\n    /** @internal Symbol-keyed install seam for the `mcp()` plugin. Off the public typed surface. */\n    [INSTALL_MCP](runtime: McpRuntime): void;\n    /** @internal Symbol-keyed install seam for the `nodeDirect()` plugin. Off the public typed surface. */\n    [INSTALL_NODE_DIRECT](runtime: NodeOutcomeRuntime): void;\n    /** @internal Symbol-keyed install seam for the `streaming()` plugin. Off the public typed surface. */\n    [INSTALL_SSE](runtime: SseRuntime): void;\n    /** @internal Symbol-keyed install seam for the `websocket()` plugin. Off the public typed surface. */\n    [INSTALL_WS](runtime: WsRuntime): void;\n    /**\n     * Merge another server's routes into this one — the composition escape hatch for large apps.\n     *\n     * WHY: the fluent chain accumulates one type-alias level per route, and TypeScript resolves\n     * that stack in one recursion — a single chain hits TS2589 at ~95 routes. Groups keep every\n     * chain short: build each domain (`listings`, `agents`, …) as its own `server()` (its registry\n     * resolves independently), then `app.merge(listings).merge(agents)` — each merge adds ONE level\n     * regardless of group size. 300+ routes stay fully typed (see many-routes.test-d.ts). The\n     * other escape hatch is contract-first `implement()`, whose registry is a single object type.\n     *\n     * Semantics: merged routes keep the chains captured where they were DEFINED — the group's\n     * `derive`/`decorate`/`beforeHandle`/`afterHandle`/`onError`/`around` apply to its routes\n     * exactly as they did standalone, so a group wires its own plugins. The group's request-level\n     * hooks (`onRequest`/`onResponse`/`onResponseFinalized`) are appended to this server's. This\n     * server's route-scoped chains do NOT retroactively wrap merged routes (order-scoped, like\n     * routes registered before a `derive`). Fail closed: a path+method collision throws\n     * `RouteConfigError` at merge time, and a group with WebSocket routes is refused (register\n     * those on the parent).\n     */\n    merge<R2 extends Registry, Ctx2>(other: Server<R2, Ctx2>): Server<R & R2, Ctx>;\n    /** A fused renderer closes over runtime services to keep its seven-argument JSC fast path. Merging\n     * rebinds that closure once to the executing server; generic plans already receive the runtime. */\n    private bindFusedRuntime;\n    /**\n     * Enumerate the registered routes (method, path, input schemas), in registration\n     * order. Powers `toOpenAPI` and other introspection; the router trie itself no\n     * longer holds the original patterns.\n     */\n    routes(): ReadonlyArray<RouteDescriptor>;\n    /**\n     * Resolve a `Request` to a `Response` — the whole lifecycle, testable without a port. The\n     * optional `platform` carries edge inputs (`env`, `waitUntil`); edge adapters pass it, and\n     * Bun/Node/Deno omit it (then `c.env` is `undefined` and `c.waitUntil` runs fire-and-forget).\n     */\n    fetch(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<Response>;\n    private fetchSource;\n    private fetchSourceInner;\n    /** Web response path when Bun already matched the route. The lifecycle and response hooks remain\n     * exactly the same as {@link fetchSource}; only portable URL scanning + trie lookup are skipped. */\n    private fetchMatched;\n    private fetchMatchedInner;\n    /**\n     * Run `produce` under the capacity gate: admit → run → release exactly once when the response is\n     * produced (or the run throws). Only reached when {@link capacityGate} is set, so the off path pays\n     * nothing. The slot is held for the duration of handler execution, not the streaming of the body —\n     * capacity here bounds concurrent *work*, matching how in-flight is counted.\n     */\n    private admitGated;\n    private runAdmitted;\n    /**\n     * Like {@link fetch}, but renders a plain-data result **without** building a Web `Response` — the\n     * `@nifrajs/node` adapter serializes the returned primitives straight to the socket, skipping the undici\n     * `Response` build + body drain (the bulk of the Node bridge cost, measured ≈4µs/req). A handler that\n     * returns a `Response`, an error/short-circuit, or any registered `onResponse` hook falls back to the\n     * full Web path (`{ kind: \"response\" }`), so behavior is identical — only the common JSON-data case is\n     * faster. Same lifecycle as {@link fetch} (body cap, validation, hooks all run); only the final\n     * render differs.\n     */\n    resolveNode(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<NodeServeOutcome>;\n    resolveNodeSource(source: RequestSource, platform?: Platform<EnvOf<Ctx>>, suppliedRuntime?: NodeOutcomeRuntime): MaybePromise<NodeServeOutcome>;\n    /**\n     * Resolve a WebSocket upgrade — the seam every serving adapter uses. Returns `pass` (not a WS\n     * upgrade for a registered route → handle as normal HTTP), `reject` (a WS route matched but\n     * `upgrade()` rejected, or the path was malformed → return `response`), or `upgrade` (perform the\n     * runtime upgrade, then dispatch the native socket's events to `handler`, seeding `ws.data` with\n     * `data`). Runs the route's `upgrade(c)` guard in a real request context. Synchronous unless\n     * `upgrade()` is async; a throw rejects with a flat 500 (no detail leaked).\n     */\n    resolveWebSocketUpgrade(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<WebSocketUpgradeOutcome>;\n    /** Bun `fetch` when WS routes exist: try a WS upgrade first, else run the normal HTTP lifecycle.\n     * `undefined` ⇒ Bun owns the upgraded socket; a `Response` ⇒ a normal reply or a rejected upgrade.\n     * (The socket dispatch itself lives in `ws-bun.ts`, loaded via `@nifrajs/core/ws`.) */\n    private bunFetchWithWebSocket;\n    /**\n     * The shared lifecycle, generic over how the final value is rendered: `finalize` turns a handler's\n     * result + `set` into the output `T` (`toResponse` → a Web `Response`; `toNodeOutcome` → node-direct\n     * primitives), `wrapResponse` lifts an early/error `Response` into that same `T`, and `onTimeout`\n     * produces the 503. The Web `fetch` and `resolveNode` are thin callers over this one routing +\n     * context + lifecycle implementation — no duplication across the trust boundary.\n     */\n    /** Apply the `clientIp` trust declaration to the adapter's raw socket peer, returning a platform\n     * whose `clientIp` is the derived caller. Only called when a trust declaration is configured. */\n    private deriveClientIp;\n    private dispatch;\n    /**\n     * onRequest short-circuit path. Synchronous as long as every hook returns synchronously (the\n     * common case — e.g. CORS returning `undefined` for a non-preflight request): an `async` version\n     * here put EVERY request of any app with one onRequest hook onto the promise machinery, profiled\n     * at ~13% of a realistic request. The first hook that returns a Promise hands the REMAINING\n     * hooks to the async continuation; behavior is identical.\n     */\n    private runWithOnRequest;\n    /** Async tail of {@link runWithOnRequest}: applies the first awaited hook's outcome, then runs\n     * the remaining hooks (awaiting freely — we're already async here). */\n    private continueOnRequest;\n    private takeResponseRequest;\n    /**\n     * Route → build context → run. Synchronous through to the handler for a **bare** route\n     * (selected by its compiled plan), so a sync handler produces its result with zero promise allocations;\n     * routes with validation/hooks keep the full async {@link runLifecycle}, unchanged.\n     */\n    private routeAndRun;\n    /** Run a route that has already been matched by the runtime or Nifra's portable router. */\n    private runMatched;\n    /** Supply request-specific deadline state to the route's precompiled execution plan. */\n    private runMatchedLanes;\n    /** @internal Symbol-keyed install seam for the `effectLedger()` plugin. Off the public typed surface. */\n    [INSTALL_EFFECT_LEDGER](runtime: EffectLedgerRuntime): void;\n    /** The narrowest bare route: a syntactic `() => ...` handler cannot observe the context argument, so\n     * successful requests can skip allocating `RequestContext`. Errors still allocate one for logging. */\n    private runContextlessBare;\n    private contextlessBareError;\n    /**\n     * The synchronous fast path selected by a route's execution plan: apply static decorations, call the\n     * handler, render the result — **no `await`** unless the handler itself returns a promise. It mirrors\n     * the bare slice of {@link runLifecycle} (which a bare route would otherwise no-op through) and shares\n     * {@link logRequestError}; a bare route has no `onError` hooks, so error handling is fully synchronous\n     * (a thrown `Response` is control flow; anything else is a logged flat 500). This is where nifra skips\n     * the per-request async-frame tax — the same win codegen routers get, but without `eval`.\n     */\n    private runBare;\n    /** Bare-route error rendering — identical to {@link runLifecycle}'s catch minus the (absent) onError\n     * loop: a thrown `Response` is returned as deliberate control flow; anything else is logged + 500. */\n    /**\n     * Build a route's fused Web renderer. Composition happens once at\n     * registration; the returned closure is what every request to the route runs. Behavior is\n     * byte-identical to the generic `runBare`/`runContextlessBare` + `toResponse` pair — same\n     * decoration order, same error routing (thrown `Response` = control flow; anything else logs and\n     * 500s), same respond semantics (the lifecycle parity suite pins it).\n     */\n    private buildFusedWeb;\n    private bareError;\n    private runWithAround;\n    private runAround;\n    private runBodyOnly;\n    /** Validate + run the handler for the bodyOnly path — shared by the inline fast path and the\n     * streaming fallback. A method (not per-request closures) so the hot path allocates nothing\n     * beyond the one `.then` continuation. */\n    private finishBodyOnly;\n    private executeHandler;\n    private handleValidationErrorRecovery;\n    private applyBodyValidation;\n    private runQueryOnly;\n    /** Validate-result → set `ctx.query` → run handler. A method (not a per-request closure), the\n     * query analogue of {@link applyBodyValidation}. */\n    private applyQueryValidation;\n    /**\n     * Thread the response through each global `onResponse` hook. Stays SYNCHRONOUS until a hook\n     * actually returns a Promise — an `async` version forced a promise + microtask on EVERY response\n     * of any app with an onResponse hook (cors/securityHeaders/etag/timing all use onResponse), the\n     * same ~13%/req tax the onRequest walk was de-async'd to avoid. The first async hook hands the\n     * rest to {@link continueOnResponse}.\n     */\n    private applyOnResponse;\n    private applyOnResponseAndFinalize;\n    private completeResponseFinalization;\n    private failResponseFinalization;\n    /** Notify terminal observers in order while isolating both sync and async failures. */\n    private notifyResponseFinalized;\n    /** Async tail of {@link applyOnResponse}: runs the remaining hooks once one has gone async. */\n    private continueOnResponse;\n    /**\n     * Bound the response time. On timeout we abort `ctx.signal` (so cancellation-aware\n     * handlers can bail) and return 503; the in-flight work keeps running but its\n     * result is discarded — JS can't forcibly cancel a promise.\n     */\n    private withTimeout;\n    /**\n     * The post-match lifecycle: validate → derive → beforeHandle → handler → afterHandle, with onError.\n     * Generic over the render: a success value goes through `finalize(result, set)` (a Web `Response`, or\n     * node-direct primitives); an early/error `Response` (validation, thrown, 500) through `wrapResponse`.\n     */\n    private runLifecycle;\n    private handleLifecycleError;\n    /** Log an unhandled request error to the (redacting) logger — shared by {@link runLifecycle} and the\n     * bare fast path ({@link bareError}) so both record the same fields. Never throws; never leaks. */\n    private logRequestError;\n    private readAndValidateBody;\n    /** Apply validation and its recovery hook on the generic lifecycle lane. Recovery is completed\n     * before derives/beforeHandle run, matching the body-only and query-only execution lanes. */\n    private applyLifecycleValidation;\n    /**\n     * Read the body as text, capped at `maxBodyBytes`. Rejects (`null`) on a\n     * `Content-Length` over the cap *before* buffering, and aborts mid-stream once the\n     * running byte count exceeds it — so a lying or absent length can't force us to\n     * buffer an oversized payload.\n     *\n     * Fast path: when a non-chunked request carries a `Content-Length` within the cap,\n     * a native `req.json()` is already bounded — under HTTP/1.1 + HTTP/2 framing the\n     * runtime delivers at most `Content-Length` bytes — so we skip the manual stream\n     * loop and a separate text decode. It trusts the wire\n     * *framing*, not the header value: nifra only ever receives framed Requests from the\n     * runtime's HTTP server, never a hand-built one with a mismatched length. Chunked or\n     * length-less bodies fall through to the streaming byte-cap guard below.\n     */\n    private readBoundedJson;\n    /** Adapt one route's compiled execution plan to Bun's already-matched request shape. Route\n     * semantics remain in the plan; this closure only supplies native params and deadline fallback. */\n    private compileBunNativeHandler;\n    /** Compile portable route registrations into Bun's native route table. Apps with request-rewrite\n     * hooks or WebSockets retain the single portable dispatcher because those features must run before\n     * route selection/upgrade. Named wildcards also stay on the fallback until Bun exposes their raw\n     * capture semantics; static and `:param` routes take the native lane. */\n    private buildBunNativeRoutes;\n    /**\n     * Start a `Bun.serve` instance bound to `port` (use `0` for an ephemeral port).\n     *\n     * `reusePort` sets `SO_REUSEPORT` so **multiple processes can bind the same port** and the kernel\n     * load-balances connections across them — the standard way to use every core (Bun is\n     * single-threaded per process). Spawn one process per core, each calling\n     * `app.listen(PORT, { reusePort: true })`; see `examples/cluster.ts`. Every process must opt in,\n     * and all of them must be the same app. Linux balances ~evenly; macOS accepts the flag but may\n     * favor one socket (fine for dev, measure on Linux for production numbers).\n     *\n     * `hostname` is the bind address, defaulting to Bun's `0.0.0.0` (every interface). Pass\n     * `\"127.0.0.1\"` to bind loopback only - an admin surface, a sidecar, or anything that must not be\n     * reachable off the box. Omitting it when you meant to restrict is a real exposure, so it is a\n     * first-class option rather than something a caller has to drop down to `Bun.serve` for.\n     */\n    listen(port: number, options?: {\n        readonly reusePort?: boolean;\n        readonly hostname?: string;\n    }): RunningServer;\n    /**\n     * Gracefully stop: wait for in-flight requests to finish (up to `drainMs`), then\n     * issue a single terminal stop — graceful if everything drained, forced if\n     * stragglers remain. Safe to call when not listening.\n     *\n     * The Bun semantics: poll `pendingRequests` (awaiting\n     * `stop()`'s promise drops in-flight requests), and decide graceful-vs-forced in\n     * ONE call (Bun can't escalate an already-graceful `stop()` to a forced close).\n     * New connections may be accepted during the drain window; in a real deploy the\n     * load balancer has already stopped routing here, and `drainMs` bounds it.\n     */\n    stop({ drainMs }?: {\n        drainMs?: number;\n    }): Promise<void>;\n    private installSignalHandlers;\n}",
     "doc": "/**\n * The inline server. Routes are chainable and fully type-inferred. `derive`/\n * `decorate` extend the handler context (`Ctx`) for routes defined *after* them,\n * with full types; `Ctx` is server-only and never touches the client registry.\n *\n *   app.decorate(\"db\", db).derive((c) => ({ user: auth(c) }))\n *      .get(\"/me\", (c) => c.user)            // c.user + c.db are typed\n */"
   },
   {
@@ -8963,6 +9845,12 @@
     "signature": "export declare function splitSections(markdown: string): DocSection[];",
     "doc": "/** Split the generated doc into its `##` sections (the `# title` intro becomes \"Overview\"). */"
   },
+  {
+    "name": "SQLiteClient",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SQLiteClient {\n    exec(sql: string): unknown;\n    query(sql: string): SQLiteStatement;\n}"
+  },
   {
     "name": "SqliteDatabaseLike",
     "kind": "interface",
@@ -8970,6 +9858,30 @@
     "signature": "export interface SqliteDatabaseLike {\n    /** Prepare a statement; `all` runs it and returns row objects. */\n    prepare(sql: string): {\n        all(...params: unknown[]): unknown[];\n    };\n    /** Execute a statement for its side effect (used only for `PRAGMA query_only`). */\n    run(sql: string): unknown;\n}",
     "doc": "/** The structural slice of `bun:sqlite`'s `Database` this package needs. */"
   },
+  {
+    "name": "SQLiteDurableExecutionAdapter",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class SQLiteDurableExecutionAdapter implements DurableExecutionAdapter {\n    readonly effects: DurableEffectStore;\n    readonly approvals: ApprovalStore;\n    readonly sagas: SagaStore;\n    readonly leases: ReconciliationLeaseStore;\n    readonly backend: SQLiteDurableRecordBackend;\n    constructor(client: SQLiteClient, options?: {\n        readonly tablePrefix?: string;\n    });\n    migrate(): void;\n}"
+  },
+  {
+    "name": "SQLiteDurableRecordBackend",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class SQLiteDurableRecordBackend implements DurableRecordBackend {\n    private readonly client;\n    readonly recordsTable: string;\n    readonly leasesTable: string;\n    constructor(client: SQLiteClient, options?: {\n        readonly tablePrefix?: string;\n    });\n    migrate(): void;\n    create(kind: DurableRecordKind, id: string, record: {\n        readonly version: number;\n        readonly state?: string;\n        readonly updatedAt?: number;\n    }): Promise<boolean>;\n    get<T extends {\n        readonly version: number;\n    }>(kind: DurableRecordKind, id: string): Promise<T | undefined>;\n    compareAndSet(kind: DurableRecordKind, id: string, expectedVersion: number, record: {\n        readonly version: number;\n        readonly state?: string;\n        readonly updatedAt?: number;\n    }): Promise<boolean>;\n    scan<T extends {\n        readonly state: string;\n        readonly updatedAt: number;\n    }>(kind: DurableRecordKind, input: ReconciliationScanOptions<string>): Promise<ReconciliationScanPage<T>>;\n    acquireLease(input: Parameters<DurableRecordBackend[\"acquireLease\"]>[0]): Promise<ReconciliationLease | undefined>;\n    renewLease(input: Parameters<DurableRecordBackend[\"renewLease\"]>[0]): Promise<boolean>;\n    checkpointLease(input: Parameters<DurableRecordBackend[\"checkpointLease\"]>[0]): Promise<boolean>;\n    releaseLease(input: Parameters<DurableRecordBackend[\"releaseLease\"]>[0]): Promise<boolean>;\n}"
+  },
+  {
+    "name": "SQLiteRunResult",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SQLiteRunResult {\n    readonly changes: number;\n}"
+  },
+  {
+    "name": "SQLiteStatement",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SQLiteStatement {\n    run(...values: readonly unknown[]): SQLiteRunResult;\n    get(...values: readonly unknown[]): Record<string, unknown> | null | undefined;\n    all(...values: readonly unknown[]): readonly (Record<string, unknown> | undefined)[];\n}"
+  },
   {
     "name": "sse",
     "kind": "function",
@@ -9281,6 +10193,13 @@
     "signature": "export declare function string(opts?: Base<string> & Optional): StandardSchemaV1<string | undefined>;",
     "doc": "/** A required (or defaulted/optional) non-empty string. */"
   },
+  {
+    "name": "stringify",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function stringify(value: unknown): string;",
+    "doc": "/** `encode` + `JSON.stringify` in one call - the rich-type equivalent of `JSON.stringify`. */"
+  },
   {
     "name": "stripComments",
     "kind": "function",
@@ -9689,6 +10608,55 @@
     "signature": "export interface TransitiveServerImportFinding extends ServerImportFinding {\n    /** `[routeFile, ...as-written specifiers…, sink]` — the shortest path the walk found. Length 2 means\n     * the route imports the sink directly (same as the regex scan's direct edge). */\n    readonly chain: readonly string[];\n    /** True when a precise transitive resolve wasn't possible for the first hop (a bare pkg / path alias),\n     * so the chain is the honest direct edge rather than a fabricated deeper path. */\n    readonly fallback: boolean;\n}",
     "doc": "/** One transitive server-only finding: the route module, the route's offending top-level import (the\n * first hop / `specifier`), the line + snippet of that import, and the FULL chain to the sink. */"
   },
+  {
+    "name": "TransportCodec",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface TransportCodec {\n    readonly id: string;\n    readonly version: number;\n    readonly mediaType: string;\n    encode(value: unknown): string;\n    decode(text: string): unknown;\n}"
+  },
+  {
+    "name": "TransportCodecError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class TransportCodecError extends TypeError {\n    constructor(message: string);\n}"
+  },
+  {
+    "name": "TransportCodecRegistry",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface TransportCodecRegistry {\n    readonly fallback: TransportCodec;\n    forContentType(contentType: string | null): TransportCodec;\n    negotiate(accept: string | null): TransportCodec;\n    byIdentity(id: string, version: number): TransportCodec;\n}"
+  },
+  {
+    "name": "transportCodecs",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function transportCodecs(registry: TransportCodecRegistry, options?: TransportCodecsOptions): IdentityPlugin;"
+  },
+  {
+    "name": "TransportCodecsOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface TransportCodecsOptions {\n    /** Maximum encoded request bytes. Keep aligned with `server({ maxBodyBytes })`. */\n    readonly maxBytes?: number;\n}"
+  },
+  {
+    "name": "TransportDecodeOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface TransportDecodeOptions {\n    readonly maxBytes?: number;\n}",
+    "doc": "/**\n * Versioned, bounded codecs shared by HTTP bodies, loader streams, and WebSocket frames. Plain JSON\n * remains the zero-configuration fast path; rich wire is explicit and preserves non-JSON values.\n */"
+  },
+  {
+    "name": "TransportDecodeResult",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type TransportDecodeResult = {\n    readonly matched: false;\n} | {\n    readonly matched: true;\n    readonly value: unknown;\n} | {\n    readonly matched: true;\n    readonly response: Response;\n};"
+  },
+  {
+    "name": "TransportRuntime",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface TransportRuntime {\n    responseCodec(accept: string | null): TransportCodec;\n    decodeRequest(source: TransportBodySource, contentType: string, maxBytes: number): Promise<TransportDecodeResult>;\n}"
+  },
   {
     "name": "Treaty",
     "kind": "type",
@@ -10315,7 +11283,7 @@
     "name": "VERSION",
     "kind": "const",
     "package": "@nifrajs/core",
-    "signature": "export declare const VERSION: \"2.0.0\";",
+    "signature": "export declare const VERSION: \"2.1.0\";",
     "doc": "/**\n * Current package version. A hardcoded literal on purpose — core runs on the edge (no fs), so it can't\n * read its own package.json at runtime. `scripts/version.ts` rewrites it on every release bump and\n * `check:publish` asserts it equals `@nifrajs/core`'s package version.\n */"
   },
   {
@@ -10429,7 +11397,7 @@
     "name": "WebSocketHandler",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface WebSocketHandler<Data = unknown, Env = unknown, Schema extends StandardSchemaV1 | undefined = undefined, Send extends StandardSchemaV1 | undefined = undefined> {\n    /**\n     * Cross-site WebSocket hijacking (CSWSH) guard — checked BEFORE `upgrade()`. A browser does not\n     * apply CORS to WebSocket handshakes and DOES send the page's cookies, so without an Origin check\n     * any site can open an authenticated socket to your app. Set this to lock the route to known\n     * origins: a string allow-list (exact `Origin` header match) or a predicate. A request whose\n     * `Origin` doesn't match (or is absent, for the allow-list form) is rejected with `403` before any\n     * per-connection work.\n     *\n     * **When omitted, the default is same-origin:** a cross-origin BROWSER handshake (an `Origin` header\n     * whose host differs from the request's) is rejected with `403`. Non-browser clients (no `Origin`) and\n     * same-origin browsers pass. Set this to allow specific cross-origin clients, or `() => true` for a\n     * genuinely public socket. Non-browser clients can spoof `Origin`, so this is a browser-CSWSH defense,\n     * not authentication — pair it with auth in `upgrade()`.\n     */\n    allowedOrigins?: ReadonlyArray<string> | ((origin: string | null) => boolean);\n    /**\n     * Runs in the HTTP request context **before** the upgrade (and after {@link allowedOrigins}) — the\n     * place to authenticate or rate-limit. Return the initial per-connection `data` (→ `ws.data`), or a\n     * `Response` to **reject** the upgrade (the client never connects). Omit to accept with\n     * `data: undefined`. A thrown error rejects with a flat 500.\n     */\n    upgrade?(c: WebSocketContext<Env>): MaybePromise<Data | Response>;\n    /**\n     * Contract-first messages: a Standard Schema (`t`, zod, valibot, …) validating each **inbound** frame.\n     * Text frames are parsed as JSON first. When set, `message` receives the validated, typed value; a\n     * non-JSON or schema-invalid frame is routed to `onInvalidMessage` (or dropped if that's omitted).\n     */\n    messageSchema?: Schema;\n    /**\n     * The **outbound** frame contract (server → client), a Standard Schema. Purely type-level: it types\n     * the frames the typed client's `.ws()` handle receives, and documents what this route pushes. The\n     * server does NOT runtime-validate its own sends - the inbound `messageSchema` guards the trust\n     * boundary; outbound honesty is the handler author's code, checked by tests.\n     */\n    sendSchema?: Send;\n    open?(ws: NifraWebSocket<Data>): MaybePromise<void>;\n    message?(ws: NifraWebSocket<Data>, data: WsMessageInput<Schema>): MaybePromise<void>;\n    /** Inbound frame that failed JSON parse or `messageSchema` validation (only fires when a schema is\n     * set). `raw` is the original frame; `issues` are the Standard Schema issues (one synthetic issue for\n     * a JSON parse failure). Omit to silently drop invalid frames. */\n    onInvalidMessage?(ws: NifraWebSocket<Data>, issues: ReadonlyArray<StandardIssue>, raw: WebSocketData): MaybePromise<void>;\n    close?(ws: NifraWebSocket<Data>, code: number, reason: string): MaybePromise<void>;\n    error?(ws: NifraWebSocket<Data>, error: unknown): MaybePromise<void>;\n}",
+    "signature": "export interface WebSocketHandler<Data = unknown, Env = unknown, Schema extends StandardSchemaV1 | undefined = undefined, Send extends StandardSchemaV1 | undefined = undefined> {\n    /**\n     * Cross-site WebSocket hijacking (CSWSH) guard — checked BEFORE `upgrade()`. A browser does not\n     * apply CORS to WebSocket handshakes and DOES send the page's cookies, so without an Origin check\n     * any site can open an authenticated socket to your app. Set this to lock the route to known\n     * origins: a string allow-list (exact `Origin` header match) or a predicate. A request whose\n     * `Origin` doesn't match (or is absent, for the allow-list form) is rejected with `403` before any\n     * per-connection work.\n     *\n     * **When omitted, the default is same-origin:** a cross-origin BROWSER handshake (an `Origin` header\n     * whose host differs from the request's) is rejected with `403`. Non-browser clients (no `Origin`) and\n     * same-origin browsers pass. Set this to allow specific cross-origin clients, or `() => true` for a\n     * genuinely public socket. Non-browser clients can spoof `Origin`, so this is a browser-CSWSH defense,\n     * not authentication — pair it with auth in `upgrade()`.\n     */\n    allowedOrigins?: ReadonlyArray<string> | ((origin: string | null) => boolean);\n    /**\n     * Runs in the HTTP request context **before** the upgrade (and after {@link allowedOrigins}) — the\n     * place to authenticate or rate-limit. Return the initial per-connection `data` (→ `ws.data`), or a\n     * `Response` to **reject** the upgrade (the client never connects). Omit to accept with\n     * `data: undefined`. A thrown error rejects with a flat 500.\n     */\n    upgrade?(c: WebSocketContext<Env>): MaybePromise<Data | Response>;\n    /**\n     * Contract-first messages: a Standard Schema (`t`, zod, valibot, …) validating each **inbound** frame.\n     * Text frames are parsed as JSON first. When set, `message` receives the validated, typed value; a\n     * non-JSON or schema-invalid frame is routed to `onInvalidMessage` (or dropped if that's omitted).\n     */\n    messageSchema?: Schema;\n    /**\n     * The **outbound** frame contract (server → client), a Standard Schema. Purely type-level: it types\n     * the frames the typed client's `.ws()` handle receives, and documents what this route pushes. The\n     * server does NOT runtime-validate its own sends - the inbound `messageSchema` guards the trust\n     * boundary; outbound honesty is the handler author's code, checked by tests.\n     */\n    sendSchema?: Send;\n    /** Decode versioned transport frames before inbound schema validation. Omit for legacy JSON. */\n    transport?: {\n        readonly registry: TransportCodecRegistry;\n        readonly maxBytes?: number;\n    };\n    open?(ws: NifraWebSocket<Data>): MaybePromise<void>;\n    message?(ws: NifraWebSocket<Data>, data: WsMessageInput<Schema>): MaybePromise<void>;\n    /** Inbound frame that failed JSON parse or `messageSchema` validation (only fires when a schema is\n     * set). `raw` is the original frame; `issues` are the Standard Schema issues (one synthetic issue for\n     * a JSON parse failure). Omit to silently drop invalid frames. */\n    onInvalidMessage?(ws: NifraWebSocket<Data>, issues: ReadonlyArray<StandardIssue>, raw: WebSocketData): MaybePromise<void>;\n    close?(ws: NifraWebSocket<Data>, code: number, reason: string): MaybePromise<void>;\n    error?(ws: NifraWebSocket<Data>, error: unknown): MaybePromise<void>;\n}",
     "doc": "/** A WebSocket route's lifecycle. All callbacks optional; only `message` is needed for an echo. */"
   },
   {
@@ -10452,6 +11420,34 @@
     "signature": "export declare function widgetDocument(opts: DefineMcpWidgetOptions): string;",
     "doc": "/** Assemble the full self-contained widget document (bridge inlined in `<head>` so body scripts can use\n * `mcpApp` immediately). */"
   },
+  {
+    "name": "Wire",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface Wire {\n    /** The root value: an inline primitive/scalar, or a `{ [TAG]: \"ref\", i }` into {@link Wire.n}. */\n    readonly r: unknown;\n    /** Interned container and rich-type nodes, addressed by index from `ref`s. */\n    readonly n: readonly unknown[];\n}",
+    "doc": "/** The JSON-safe encoded form produced by {@link encode} and consumed by {@link decode}. */"
+  },
+  {
+    "name": "WireDecodeError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class WireDecodeError extends TypeError {\n    constructor(message: string);\n}",
+    "doc": "/** Thrown by {@link decode} for a wire value carrying an unknown tag, a bad index, or malformed shape. */"
+  },
+  {
+    "name": "WireDecodeLimits",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface WireDecodeLimits {\n    /** Maximum number of interned nodes. Default 10,000. */\n    readonly maxNodes?: number;\n    /** Maximum nesting depth across containers and references. Default 256. */\n    readonly maxDepth?: number;\n    /** Maximum total object/array/map/set entries visited. Default 100,000. */\n    readonly maxCollectionEntries?: number;\n    /** Maximum UTF-8 string plus decoded binary bytes materialized. Default 16 MiB. */\n    readonly maxDecodedBytes?: number;\n}",
+    "doc": "/** Resource limits applied while reconstructing transport-controlled wire data. */"
+  },
+  {
+    "name": "WireEncodeError",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class WireEncodeError extends TypeError {\n    constructor(message: string);\n}",
+    "doc": "/** Thrown by {@link encode} for a value it will not encode (a function or a symbol). */"
+  },
   {
     "name": "withDeadlineHeader",
     "kind": "function",