@nifrajs/cli 2.11.0 → 2.12.1

package/docs/types.json

@@ -11,7 +11,7 @@
     "kind": "const",
     "package": "@nifrajs/web",
     "signature": "export declare const ACTION_GLOBAL = \"__NIFRA_ACTION__\";",
-    "doc": "/** Global the server serializes an action's data return into (absent on GETs); the client\n * reads it so hydration after a native form POST matches the server-rendered markup. */"
+    "doc": "/** Global the server serializes an action's data return into (absent on GETs); the client reads it\n * so hydration after a native form POST matches the server-rendered markup. */"
   },
   {
     "name": "ActionArgs",
@@ -142,6 +142,38 @@
     "package": "@nifrajs/testing",
     "signature": "export interface AdversarialContractResult {\n    readonly id: string;\n    readonly route: string;\n    readonly runtime: string;\n    readonly kind: ContractCaseKind;\n    readonly target: ContractTarget;\n    readonly mutation?: string;\n    readonly ok: boolean;\n    readonly status?: number;\n    readonly message: string;\n    /** Number of successful greedy reductions applied to a failing hostile input. */\n    readonly shrinkSteps?: number;\n    readonly replay: ContractReplay;\n}"
   },
+  {
+    "name": "AgentApprovalPort",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentApprovalPort {\n    request(input: {\n        readonly turnId: string;\n        readonly effectId: string;\n        readonly tool: string;\n        readonly capability: string;\n        readonly signal: AbortSignal;\n        /** Wall-clock budget reserved for this approval hop and the following tool execution. */\n        readonly deadline?: RequestBudget;\n    }): AgentApprovalResult | PromiseLike<AgentApprovalResult>;\n}"
+  },
+  {
+    "name": "AgentApprovalResult",
+    "kind": "type",
+    "package": "@nifrajs/agent",
+    "signature": "export type AgentApprovalResult = {\n    readonly status: \"approved\";\n    readonly approval: ToolApproval;\n} | {\n    readonly status: \"denied\";\n    readonly reason?: string;\n} | {\n    readonly status: \"pending\";\n    readonly effectId: string;\n};"
+  },
+  {
+    "name": "AgentDefinition",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentDefinition<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1> {\n    readonly name: string;\n    readonly instruction: string;\n    readonly input: InputSchema;\n    readonly output: OutputSchema;\n    readonly tools: readonly AgentToolContract[];\n    /** Dimensionless counters charged once per model decision. */\n    readonly modelCost?: EffectCost;\n}"
+  },
+  {
+    "name": "AgentEvidenceStream",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentEvidenceStream extends AgentTelemetryPort, AsyncIterableIterator<AgentStepEvidence> {\n    complete(): void;\n    /**\n     * How many evidence items the queue discarded because the consumer fell behind. Non-zero means the\n     * `seq` sequence has gaps; the turn result still carries the complete, authoritative evidence array.\n     */\n    readonly dropped: number;\n}",
+    "doc": "/**\n * The existing step evidence as an async iterable. No second event vocabulary is introduced.\n *\n * Pass the stream as `ports.telemetry`, consume it with `for await`, and call `complete()` when the\n * runner finishes. The stream keeps queued evidence until it has been consumed, then terminates.\n */"
+  },
+  {
+    "name": "AgentEvidenceStreamOptions",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentEvidenceStreamOptions {\n    /** Maximum number of produced evidence items waiting for a consumer. Default 1024. */\n    readonly maxQueueSize?: number;\n}",
+    "doc": "/** Options for the lifecycle evidence stream. */"
+  },
   {
     "name": "AgentFileSpec",
     "kind": "interface",
@@ -149,6 +181,48 @@
     "signature": "export interface AgentFileSpec {\n    /** Path relative to the project root (POSIX-style; the caller joins onto the cwd). */\n    readonly path: string;\n    /** A human label for the \"wrote/skipped\" report. */\n    readonly label: string;\n}",
     "doc": "/** Identifies a generated agent-discovery file: where it goes (relative to the project root) and how to\n * produce its content. `merge` is for files that augment an existing one (AGENTS.md) rather than own it. */"
   },
+  {
+    "name": "AgentModelPort",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentModelPort {\n    /** Provider output is unknown until the response parser accepts it. */\n    complete(request: AgentModelRequest): unknown | PromiseLike<unknown>;\n}"
+  },
+  {
+    "name": "AgentModelRequest",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentModelRequest {\n    readonly agent: string;\n    readonly instruction: string;\n    readonly input: unknown;\n    readonly state: AgentTurnState;\n    readonly tools: readonly AgentToolDescriptor[];\n    readonly toolResult?: AgentToolResult;\n    readonly previousOutput?: unknown;\n    readonly signal: AbortSignal;\n    /** Wall-clock budget shared with the parent request. Use withDeadlineHeader for outbound requests. */\n    readonly deadline?: RequestBudget;\n}"
+  },
+  {
+    "name": "AgentModelResponse",
+    "kind": "type",
+    "package": "@nifrajs/agent",
+    "signature": "export type AgentModelResponse = {\n    readonly kind: \"output\";\n    readonly value: unknown;\n} | {\n    readonly kind: \"tool\";\n    readonly name: string;\n    readonly input: unknown;\n};"
+  },
+  {
+    "name": "AgentPendingContinuation",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentPendingContinuation {\n    readonly kind: AgentPendingKind;\n    readonly tool?: string;\n    readonly input?: unknown;\n    readonly effectId: string;\n}"
+  },
+  {
+    "name": "AgentPendingKind",
+    "kind": "type",
+    "package": "@nifrajs/agent",
+    "signature": "export type AgentPendingKind = \"approval\" | \"budget\" | \"model\" | \"cancelled\";"
+  },
+  {
+    "name": "AgentPorts",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentPorts {\n    readonly model: AgentModelPort;\n    readonly capabilities: readonly string[];\n    readonly budget?: ToolBudget;\n    /** Wall-clock budget shared with the parent request. Distinct from `budget`, which is cost. */\n    readonly deadline?: RequestBudget;\n    readonly idempotency?: ToolIdempotencyStore;\n    readonly state?: AgentStateStore;\n    readonly approval?: AgentApprovalPort;\n    readonly telemetry?: AgentTelemetryPort;\n    readonly clock?: () => number;\n    /** Adapter used to satisfy execution policies declared by tool contracts. */\n    readonly executionPolicy?: ExecutionPolicyAdapter;\n    /** Injectable token generator for deterministic replay and tests. */\n    readonly idFactory?: () => string;\n    readonly signal?: AbortSignal;\n    /** Replay mode skips every tool executor and marks the call dry-run. */\n    readonly dryRun?: boolean;\n}"
+  },
+  {
+    "name": "AgentRunResult",
+    "kind": "type",
+    "package": "@nifrajs/agent",
+    "signature": "export type AgentRunResult<Output> = AgentTurnResult<Output> | (AgentTurnBaseResult & {\n    readonly status: \"suspended\";\n    readonly pending: AgentPendingContinuation;\n    readonly reason: \"max_turns\";\n});"
+  },
   {
     "name": "AGENTS_MD_PATH",
     "kind": "const",
@@ -162,6 +236,24 @@
     "signature": "export declare function agentsMcpSection(): string;",
     "doc": "/**\n * The \"## MCP server\" section appended to a scaffolded (or retrofitted) `AGENTS.md`, so non-Claude\n * agents (Cursor, and anything that reads `AGENTS.md`) also learn the MCP exists and what to prefer.\n * Mirrors the CLAUDE.md preamble's guidance without the Claude-specific `@import`.\n */"
   },
+  {
+    "name": "AgentStateStore",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentStateStore {\n    load(turnId: string): AgentTurnState | undefined | PromiseLike<AgentTurnState | undefined>;\n    save(state: AgentTurnState): void | PromiseLike<void>;\n}"
+  },
+  {
+    "name": "AgentStatus",
+    "kind": "type",
+    "package": "@nifrajs/agent",
+    "signature": "export type AgentStatus = \"continue\" | \"completed\" | \"suspended\";"
+  },
+  {
+    "name": "AgentStepEvidence",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentStepEvidence {\n    readonly seq: number;\n    readonly at: number;\n    readonly kind: \"model\" | \"tool\" | \"approval\" | \"budget\" | \"state\";\n    readonly outcome: \"started\" | \"passed\" | \"failed\" | \"denied\" | \"suspended\" | \"committed\";\n    readonly name?: string;\n    readonly effectId?: string;\n    readonly code?: string;\n    readonly ledgerHead?: string;\n}"
+  },
   {
     "name": "agentTelemetry",
     "kind": "function",
@@ -175,6 +267,68 @@
     "package": "@nifrajs/agent-telemetry",
     "signature": "export interface AgentTelemetryOptions {\n    /** Exporter that receives completed tool-call spans. */\n    readonly exporter: ObservationAdapter;\n    /** Path prefix for nifra tool routes (default `\"/_nifra/tool/\"`). */\n    readonly toolPathPrefix?: string | undefined;\n    /** Path for the MCP endpoint (default `\"/mcp\"`). */\n    readonly mcpPath?: string | undefined;\n}"
   },
+  {
+    "name": "AgentTelemetryPort",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentTelemetryPort {\n    step(evidence: AgentStepEvidence): void | PromiseLike<void>;\n}"
+  },
+  {
+    "name": "AgentToolContract",
+    "kind": "type",
+    "package": "@nifrajs/agent",
+    "signature": "export type AgentToolContract = ToolContract<any, any>;",
+    "doc": "/** Heterogeneous tool collection used by an agent definition. Runtime schemas remain authoritative. */"
+  },
+  {
+    "name": "AgentToolDescriptor",
+    "kind": "type",
+    "package": "@nifrajs/agent",
+    "signature": "export type AgentToolDescriptor = ToolCatalogEntry;",
+    "doc": "/** The model-facing descriptor is the complete descriptive catalog entry. */"
+  },
+  {
+    "name": "AgentToolResult",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentToolResult {\n    readonly name: string;\n    readonly ok: boolean;\n    readonly output?: unknown;\n    readonly error?: ToolError | {\n        readonly code: \"unknown_tool\" | \"invalid_model_response\";\n        readonly stage: \"execution\";\n    };\n}"
+  },
+  {
+    "name": "AgentTranscript",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentTranscript {\n    readonly version: 1;\n    readonly turnId: string;\n    readonly responses: readonly AgentModelResponse[];\n    readonly evidence: readonly AgentStepEvidence[];\n}"
+  },
+  {
+    "name": "AgentTurnBaseResult",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentTurnBaseResult {\n    readonly state: AgentTurnState;\n    readonly evidence: readonly AgentStepEvidence[];\n    readonly transcript: AgentTranscript;\n}"
+  },
+  {
+    "name": "AgentTurnError",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentTurnError {\n    readonly code: \"input_invalid\" | \"output_invalid\" | \"model_failed\";\n    readonly issues?: readonly StandardIssue[];\n}"
+  },
+  {
+    "name": "AgentTurnInput",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentTurnInput {\n    readonly value: unknown;\n    readonly toolResult?: AgentToolResult;\n    readonly previousOutput?: unknown;\n    readonly resume?: {\n        readonly continuation: AgentPendingContinuation;\n        readonly approval?: ToolApproval;\n    };\n}"
+  },
+  {
+    "name": "AgentTurnResult",
+    "kind": "type",
+    "package": "@nifrajs/agent",
+    "signature": "export type AgentTurnResult<Output> = (AgentTurnBaseResult & {\n    readonly status: \"completed\";\n    readonly output: Output;\n    readonly error?: never;\n}) | (AgentTurnBaseResult & {\n    readonly status: \"completed\";\n    readonly error: AgentTurnError;\n    readonly output?: never;\n}) | (AgentTurnBaseResult & {\n    readonly status: \"continue\";\n    readonly toolResult: AgentToolResult;\n}) | (AgentTurnBaseResult & {\n    readonly status: \"suspended\";\n    readonly pending: AgentPendingContinuation;\n    readonly reason: \"approval\" | \"budget\" | \"model\" | \"cancelled\";\n});"
+  },
+  {
+    "name": "AgentTurnState",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface AgentTurnState {\n    readonly version: 1;\n    readonly turnId: string;\n    readonly step: number;\n    readonly status: \"ready\" | \"suspended\" | \"completed\";\n    readonly evidence: readonly AgentStepEvidence[];\n    readonly pending?: {\n        readonly kind: AgentPendingKind;\n        readonly tool?: string;\n        readonly effectId: string;\n    };\n}"
+  },
   {
     "name": "aggregateSizeReport",
     "kind": "function",
@@ -230,7 +384,7 @@
     "name": "appendTrailingSlash",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function appendTrailingSlash(options?: TrailingSlashOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
+    "signature": "export declare function appendTrailingSlash(options?: TrailingSlashOptions): import(\"@nifrajs/core\").IdentityPlugin;",
     "doc": "/**\n * Append a trailing slash to non-root paths. By default it skips file-looking paths such as\n * `/app.css`, which keeps static assets and extensionful API routes stable.\n */"
   },
   {
@@ -247,6 +401,12 @@
     "signature": "export interface AppLike {\n    fetch(request: Request): Response | Promise<Response>;\n}",
     "doc": "/** The minimal shape a nifra `server()` app satisfies - its own `fetch`. */"
   },
+  {
+    "name": "applyDiagnosticRecipe",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function applyDiagnosticRecipe(root: string, diagnostic: Diagnostic): Promise<readonly string[]>;"
+  },
   {
     "name": "applyHead",
     "kind": "function",
@@ -393,6 +553,12 @@
     "signature": "export declare function assertStorageAdapterConformance(options: StorageAdapterConformanceOptions): Promise<void>;",
     "doc": "/**\n * Execute the observable {@link StorageAdapter} contract without depending on a test runner.\n *\n * The adapter must be isolated because this writes deterministic conformance keys. The promise resolves\n * only after proving byte + metadata round-trips, overwrite, missing/delete semantics, prefix/limit listing,\n * and uniform unsafe-key rejection across every key-taking method. When the adapter also implements an\n * optional capability ({@link PagedStorageAdapter}, {@link PresignableStorageAdapter},\n * {@link MovableStorageAdapter}), that capability's contract is proven too - implementing a capability\n * partially or unsafely fails conformance rather than silently escaping it.\n */"
   },
+  {
+    "name": "assertTrajectoryInvariants",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function assertTrajectoryInvariants(result: AgentRunResult<unknown>, options?: TrajectoryInvariantOptions): void;"
+  },
   {
     "name": "assertTransportTextBounded",
     "kind": "function",
@@ -400,11 +566,18 @@
     "signature": "export declare function assertTransportTextBounded(text: string, options: TransportDecodeOptions): void;",
     "doc": "/**\n * Enforce the transport byte cap on already-read text - the same limit (and the same error) the\n * streaming reader applies during a bounded read. Exported for callers that read a body through a\n * native, non-streaming path (the typed client's in-process branch) and still owe the cap contract.\n */"
   },
+  {
+    "name": "AssuranceAttachment",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type AssuranceAttachment = Omit<AssuranceDeclaration, \"scope\" | \"provenance\"> & {\n    readonly scope?: AssuranceScope;\n};",
+    "doc": "/**\n * Evidence published from OUTSIDE the plugin chain - a deployment shell, a mount site, the call that\n * hands the app to `serve`. `scope` defaults to `global` (retroactive, app-wide) because the shell\n * runs after every route is registered, and `provenance` is always stamped `declared`: nifra did not\n * install this enforcement and cannot see it, so a `requireProvenance: \"runtime\"` rule still rejects it.\n */"
+  },
   {
     "name": "AssuranceConfig",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface AssuranceConfig {\n    readonly source: unknown;\n    readonly policy: AssurancePolicy;\n    readonly capabilities?: CapabilityPolicy;\n    /** Off-request-path manifest artifact/signing integration. Private keys remain behind `signer`. */\n    readonly manifest?: {\n        /** Default `nifra.manifest.json`. */\n        readonly path?: string;\n        /** Resolve an operator key reference to a signer (KMS/HSM/local WebCrypto). */\n        readonly signer?: (keyRef: string) => NifraManifestSigner | Promise<NifraManifestSigner>;\n    };\n    /** Dynamic invariant execution is opt-in and must use a disposable/sandboxed target. */\n    readonly invariants?: {\n        readonly executor: InvariantExecutor;\n    };\n}"
+    "signature": "export interface AssuranceConfig {\n    readonly source: unknown;\n    readonly policy: AssurancePolicy;\n    readonly capabilities?: CapabilityPolicy;\n    /** Off-request-path manifest artifact/signing integration. Private keys remain behind `signer`. */\n    readonly manifest?: {\n        /** Default `nifra.manifest.json`. */\n        readonly path?: string;\n        /** Resolve an operator key reference to a signer (KMS/HSM/local WebCrypto). */\n        readonly signer?: (keyRef: string) => NifraManifestSigner | Promise<NifraManifestSigner>;\n    };\n    /** Dynamic invariant execution is opt-in and must use a disposable/sandboxed target. */\n    readonly invariants?: {\n        readonly executor: InvariantExecutor;\n    };\n    /** Optional application-supplied rule packs appended after built-in verification rules. */\n    readonly rulePacks?: readonly AssuranceRulePack[];\n    /** Optional sink for an assurance bundle. The CLI validates the callable shape at runtime. */\n    readonly assureSink?: unknown;\n    /** Optional deterministic effect workloads for the tests gate. */\n    readonly idempotency?: readonly IdempotencyWorkload[];\n    /** Optional output-size budget for the assurance bundle's size gate. */\n    readonly size?: AssuranceSizeBudget;\n}"
   },
   {
     "name": "AssuranceDeclaration",
@@ -424,7 +597,7 @@
     "name": "AssuranceEvidence",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface AssuranceEvidence {\n    readonly id: string;\n    readonly source: string;\n}",
+    "signature": "export interface AssuranceEvidence {\n    readonly id: string;\n    readonly source: string;\n    /** Runtime-installed enforcement versus an author assertion on a route. Optional for legacy\n     * reflected descriptors; evaluators infer legacy values from source when absent. */\n    readonly provenance?: \"runtime\" | \"declared\";\n}",
     "doc": "/** Reflection-safe proof that a named enforcement module covered a route. */"
   },
   {
@@ -455,13 +628,20 @@
     "name": "AssuranceRouteSelector",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface AssuranceRouteSelector {\n    /** Omit for every method. */\n    readonly methods?: readonly Method[];\n    /** Absolute route globs. `*` matches one segment; final `**` matches zero or more. */\n    readonly paths?: readonly string[];\n    /** Restrict the rule to MCP tool routes (`true`) or non-tool routes (`false`). */\n    readonly tools?: boolean;\n    /**\n     * Match routes declaring ANY of these capability tokens.\n     *\n     * Lets a policy be written about what a route DOES rather than where it lives: \"anything that writes\n     * to the database must be authenticated\" survives a route being moved or renamed, which a path glob\n     * does not. Reflection already carries the declared tokens, so this reads what the route said about\n     * itself.\n     *\n     * Naming exact tokens is precise but closed: a rule listing `db.write` does not cover `storage.write`,\n     * and a capability added next year escapes it in silence. Prefer `access`/`zone` for a rule that is\n     * meant to hold for a CLASS of effect.\n     */\n    readonly capabilities?: readonly string[];\n    /**\n     * Match routes declaring any capability whose definition has this access.\n     *\n     * This is the selector to reach for when the rule is \"anything that writes must prove who asked\":\n     * it is keyed on what the capability IS rather than what it is called, so a token introduced later\n     * is covered the day it is declared instead of the day someone remembers to widen the rule.\n     *\n     * Requires capability definitions. A policy using it without them is refused rather than quietly\n     * matching nothing - a selector that matches nothing lets the route fall through to a laxer rule.\n     */\n    readonly access?: CapabilityAccess;\n    /**\n     * Match routes declaring any capability in this zone. Combined with `access`, both must hold for the\n     * SAME capability, so `{ access: \"write\", zone: \"domain\" }` is \"writes business state\" and does not\n     * match a route that only writes an audit log.\n     */\n    readonly zone?: CapabilityZone;\n}"
+    "signature": "export interface AssuranceRouteSelector {\n    /** Omit for every method. */\n    readonly methods?: readonly Method[];\n    /** Absolute route globs. `*` matches one segment; final `**` matches zero or more. */\n    readonly paths?: readonly string[];\n    /** Restrict the rule to MCP tool routes (`true`) or non-tool routes (`false`). */\n    readonly tools?: boolean;\n    /**\n     * Match routes declaring ANY of these capability tokens.\n     *\n     * Lets a policy be written about what a route DOES rather than where it lives: \"anything that writes\n     * to the database must be authenticated\" survives a route being moved or renamed, which a path glob\n     * does not. Reflection already carries the declared tokens, so this reads what the route said about\n     * itself.\n     *\n     * Naming exact tokens is precise but closed: a rule listing `db.write` does not cover `storage.write`,\n     * and a capability added next year escapes it in silence. Prefer `access`/`zone` for a rule that is\n     * meant to hold for a CLASS of effect.\n     */\n    readonly capabilities?: readonly string[];\n    /**\n     * Match routes declaring any capability whose definition has this access.\n     *\n     * This is the selector to reach for when the rule is \"anything that writes must prove who asked\":\n     * it is keyed on what the capability IS rather than what it is called, so a token introduced later\n     * is covered the day it is declared instead of the day someone remembers to widen the rule.\n     *\n     * Requires capability definitions. A policy using it without them is refused rather than quietly\n     * matching nothing - a selector that matches nothing lets the route fall through to a laxer rule.\n     */\n    readonly access?: CapabilityAccess;\n    /**\n     * Match routes declaring any capability in this zone. Combined with `access`, both must hold for the\n     * SAME capability, so `{ access: \"write\", zone: \"domain\" }` is \"writes business state\" and does not\n     * match a route that only writes an audit log.\n     */\n    readonly zone?: CapabilityZone;\n    /** Match routes whose response classification is at least this sensitivity. */\n    readonly classificationAtLeast?: DataClassification;\n}"
   },
   {
     "name": "AssuranceRule",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface AssuranceRule {\n    /** Stable human-readable classification included in diagnostics. */\n    readonly name: string;\n    readonly match: AssuranceRouteSelector;\n    /** Evidence ids the route must carry. */\n    readonly require?: readonly string[];\n    /** Evidence ids the route must not carry (useful for public webhooks and health routes). */\n    readonly forbid?: readonly string[];\n}"
+    "signature": "export interface AssuranceRule {\n    /** Stable human-readable classification included in diagnostics. */\n    readonly name: string;\n    readonly match: AssuranceRouteSelector;\n    /** Evidence ids the route must carry. */\n    readonly require?: readonly string[];\n    /** Evidence ids the route must not carry (useful for public webhooks and health routes). */\n    readonly forbid?: readonly string[];\n    /**\n     * Provenance required for every id in require. any (default) preserves compatibility with\n     * existing policies; runtime rejects schema.assurance author assertions and accepts only\n     * evidence installed by middleware/plugins or framework runtime policy. declared is useful for\n     * explicitly reviewing in-handler assertions and should not be used as an enforcement gate.\n     */\n    readonly requireProvenance?: \"any\" | \"runtime\" | \"declared\";\n    /**\n     * When true, an authenticated route selected by this rule must also carry runtime CSRF evidence.\n     * Enable this on rules covering cookie/session-authenticated browser routes; bearer-only APIs\n     * should use a separate rule because they do not have browser ambient-authority exposure.\n     */\n    readonly requireCsrfWithAuthenticated?: boolean;\n}"
+  },
+  {
+    "name": "AssuranceRulePack",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface AssuranceRulePack {\n    readonly name: string;\n    readonly rules: readonly unknown[];\n}",
+    "doc": "/** Application-supplied verification rules. The CLI validates the executable rule shape at runtime. */"
   },
   {
     "name": "AssuranceScope",
@@ -470,6 +650,25 @@
     "signature": "export type AssuranceScope = \"global\" | \"subsequent\" | \"plugin\";",
     "doc": "/** Where enforcement evidence follows Nifra's route-registration semantics. */"
   },
+  {
+    "name": "AssuranceSizeBudget",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface AssuranceSizeBudget {\n    readonly outDir?: string;\n    readonly maxBytes?: number;\n    readonly maxGzipBytes?: number;\n}"
+  },
+  {
+    "name": "assure",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function assure(app: unknown, evidence: AssuranceAttachment | readonly AssuranceAttachment[]): void;",
+    "doc": "/**\n * Publish enforcement evidence from OUTSIDE the plugin chain - the deployment shell that wraps the\n * app, the mount site, or the call that hands it to `serve`. When the thing doing the enforcing is\n * not a nifra plugin (a gateway, a service mesh, an outer framework), the alternative is switching\n * the affected rules off; this records what covers the routes instead, so the policy keeps running.\n *\n *   const app = buildApp()                 // no assurance-bearing plugin in its .use() chain\n *   assure(app, { id: NIFRA_ASSURANCE.AUTHENTICATED, source: \"edge-gateway\" })\n *   serve(app)\n *\n * `scope` defaults to `global`: the shell runs after every route is registered, so the evidence is\n * retroactive and app-wide. Narrow it with `methods`/`paths` (absolute globs), or pass\n * `scope: \"subsequent\"` to cover only routes registered after the call.\n *\n * Provenance is always `declared` - nifra did not install this enforcement and cannot observe it, so\n * a rule with `requireProvenance: \"runtime\"` still rejects the route, by design.\n */"
+  },
+  {
+    "name": "AssureBundle",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface AssureBundle {\n    readonly version: 1;\n    readonly createdAt: string;\n    readonly commit: string;\n    readonly gates: readonly GateResult[];\n    readonly verdict: \"green\" | \"red\";\n}"
+  },
   {
     "name": "AssuredCapabilityRoute",
     "kind": "interface",
@@ -482,6 +681,12 @@
     "package": "@nifrajs/core",
     "signature": "export interface AssuredRoute {\n    readonly method: string;\n    readonly path: string;\n    readonly rule?: string;\n    readonly evidence: readonly AssuranceEvidence[];\n    readonly missing: readonly string[];\n    readonly forbidden: readonly string[];\n}"
   },
+  {
+    "name": "AssureSink",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface AssureSink {\n    record(bundle: AssureBundle): Promise<void>;\n}"
+  },
   {
     "name": "attachCapabilityJournal",
     "kind": "function",
@@ -500,7 +705,7 @@
     "name": "attachWebSocket",
     "kind": "function",
     "package": "@nifrajs/core",
-    "signature": "export declare function attachWebSocket(socket: StandardWebSocket, handler: WebSocketHandler, data: unknown, options: {\n    openNow: boolean;\n    pubsub: TopicRegistry;\n}): NifraWebSocket;",
+    "signature": "export declare function attachWebSocket(socket: StandardWebSocket, handler: WebSocketHandler, data: unknown, options: {\n    openNow: boolean;\n    pubsub: TopicRegistry;\n    maxPayloadBytes?: number;\n}): NifraWebSocket;",
     "doc": "/**\n * Wire a standard server-side `WebSocket` to a nifra {@link WebSocketHandler}, returning the portable\n * {@link NifraWebSocket}. Shared by the Deno and Workers bridges. `openNow` fires `open` immediately\n * (Workers, where the socket is already open after `accept()`); otherwise `open` waits for the socket's\n * `open` event (Deno). Lifecycle callbacks are error-isolated - a throw (or async rejection) routes to\n * `error()` and never tears the process down; binary frames are normalized to `Uint8Array`.\n */"
   },
   {
@@ -540,7 +745,7 @@
     "name": "AuthPlugin",
     "kind": "type",
     "package": "@nifrajs/middleware",
-    "signature": "export type AuthPlugin<P> = NifraPlugin & {\n    /** The verified principal for this request, or `null` (no/invalid token in `optional` mode). */\n    principal(request: Request): P | null;\n    /** The verified principal, or **throws a `401` `Response`** when absent. */\n    requirePrincipal(request: Request): P;\n};",
+    "signature": "export type AuthPlugin<P> = IdentityPlugin & {\n    /** The verified principal for this request, or `null` (no/invalid token in `optional` mode). */\n    principal(request: Request): P | null;\n    /** The verified principal, or **throws a `401` `Response`** when absent. */\n    requirePrincipal(request: Request): P;\n};",
     "doc": "/**\n * A token-auth plugin (`bearer` / `apiKey`). Apply it with `app.use(auth)` - it rejects unauthorized\n * requests to **routes defined after it** with `401` (unless `optional`). Read the verified principal\n * inside a handler/loader via {@link AuthPlugin.principal} (nullable) or\n * {@link AuthPlugin.requirePrincipal} (throws `401` when absent). The principal is verified once per\n * request and cached, so reading it is free.\n *\n * `beforeHandle` is **order-scoped**: place `app.use(auth)` before the routes it should guard. Hold the\n * returned instance to read the principal (mirrors `@nifrajs/auth`'s `sessions.get(c)` and\n * `@nifrajs/better-auth`'s `getSession(auth, req)`):\n *\n * ```ts\n * const auth = bearer({ verify: (t) => lookupUser(t) }) // P = User (inferred)\n * const app = server().use(auth).get(\"/me\", (c) => auth.requirePrincipal(c.req))\n * ```\n */"
   },
   {
@@ -648,7 +853,7 @@
     "name": "BasicAuthPlugin",
     "kind": "type",
     "package": "@nifrajs/middleware",
-    "signature": "export type BasicAuthPlugin<P> = NifraPlugin & {\n    principal(request: Request): P | null;\n    requirePrincipal(request: Request): P;\n};"
+    "signature": "export type BasicAuthPlugin<P> = IdentityPlugin & {\n    principal(request: Request): P | null;\n    requirePrincipal(request: Request): P;\n};"
   },
   {
     "name": "BasicAuthStaticOptions",
@@ -693,7 +898,7 @@
     "name": "betterAuth",
     "kind": "function",
     "package": "@nifrajs/better-auth",
-    "signature": "export declare function betterAuth(auth: BetterAuthLike, options?: BetterAuthOptions): import(\"@nifrajs/core/server\").IdentityPlugin;",
+    "signature": "export declare function betterAuth(auth: BetterAuthLike, options?: BetterAuthOptions): import(\"@nifrajs/core\").IdentityPlugin;",
     "doc": "/**\n * Mount a better-auth instance into a nifra app: registers its handler at `${basePath}/*`\n * (default `/api/auth/*`) for `GET` + `POST`, so every better-auth endpoint - sign-in/up/out, OAuth\n * callbacks, session, 2FA, magic links, … - is served by your nifra server.\n *\n * ```ts\n * import { betterAuth, requireSession } from \"@nifrajs/better-auth\"\n * import { auth } from \"./auth\"           // your configured better-auth instance\n *\n * const app = server().use(betterAuth(auth))            // wires /api/auth/*\n *   .get(\"/me\", async (c) => (await requireSession(auth, c.req)).user)\n * ```\n *\n * Idempotent (named `\"better-auth\"` - applying twice mounts once). Read the session with\n * {@link getSession} / {@link requireSession}, which infer your better-auth types.\n */"
   },
   {
@@ -992,6 +1197,12 @@
     "signature": "export declare function buildFailureDetail(err: unknown): string;",
     "doc": "/**\n * Format a client-build rejection for the guard's report. Bun.build rejects with an AggregateError\n * whose message is just \"Bundle failed\" - the actionable part (which file, which import) lives in\n * `.errors`. Surface it, or the guard reports a failure while hiding the reason.\n */"
   },
+  {
+    "name": "BuildFreshness",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface BuildFreshness {\n    readonly ok: boolean;\n    readonly buildDir?: string;\n    readonly newestSourceMs?: number;\n    readonly newestBuildMs?: number;\n    readonly reason?: string;\n}"
+  },
   {
     "name": "buildManifest",
     "kind": "function",
@@ -1016,7 +1227,7 @@
     "name": "BuildNifraManifestInput",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface BuildNifraManifestInput {\n    readonly source: unknown;\n    readonly assurance?: AssuranceReport;\n    readonly capabilities?: CapabilityAssuranceReport;\n}"
+    "signature": "export interface BuildNifraManifestInput {\n    /** Runtime route source, retained for compatibility with callers that have not built a snapshot. */\n    readonly source?: unknown;\n    /** Canonical offline evidence; when supplied, no second route reflection is performed. */\n    readonly evidence?: ProjectEvidenceSnapshot;\n    readonly assurance?: AssuranceReport;\n    readonly capabilities?: CapabilityAssuranceReport;\n}"
   },
   {
     "name": "buildOpenApiDocument",
@@ -1025,6 +1236,12 @@
     "signature": "export declare function buildOpenApiDocument(routes: readonly RouteLike[], options?: OpenApiOptions): Record<string, unknown>;",
     "doc": "/**\n * Build an OpenAPI 3.1 document from a route list. Delegates to `@nifrajs/schema`'s `toOpenAPI`, so a\n * route validated with `t` (TypeBox) emits full field-level request/query/response schemas plus\n * `$ref`-reused `components.schemas`; a BYO Standard Schema (zod/valibot/arktype) exposes no portable\n * JSON-Schema form, so its body/response is omitted (supply it via `options.operations`). Path params,\n * wildcards, tags, security, and servers always emit. Exported so you can also generate the doc at\n * build time (write it to disk in CI) without booting the server.\n */"
   },
+  {
+    "name": "buildProjectWorkGraph",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function buildProjectWorkGraph(input: WorkGraphBuildInput, options?: {\n    readonly changedFiles?: readonly string[];\n    readonly minLevel?: number;\n}): Promise<ProjectWorkGraphResult>;"
+  },
   {
     "name": "buildRouteManifest",
     "kind": "function",
@@ -1076,7 +1293,7 @@
     "name": "BuildTargetOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface BuildTargetOptions {\n    /** The `routes/` directory to discover (absolute path). */\n    readonly routesDir: string;\n    /** Output directory for the assembled deploy dir (absolute path). Cleared and recreated. */\n    readonly outDir: string;\n    /** A scratch directory for intermediate codegen (the generated server entry + manifest) and the\n     * server bundle, cleaned up after. Absolute path. */\n    readonly workDir: string;\n    /** The adapter's client runtime module (exports `mountRouter`), e.g. `\"@nifrajs/web-react/client\"`. */\n    readonly clientModule: string;\n    /** Import specifier (resolvable from `workDir`) of the module exporting `adapter`. */\n    readonly adapterImport: string;\n    /** Import specifier (resolvable from `workDir`) of the module exporting `backend`, or `undefined`. */\n    readonly backendImport?: string;\n    /** Factory that builds the app for `static` prerendering, GIVEN the client build's manifest - so the\n     * emitted hydration `<script src>` uses the REAL content-hashed entry (`client.entry`) plus the same\n     * styles/route-preload the server targets use. A pre-built instance can't work here: the hash isn't known\n     * until `buildClient` runs inside `buildTarget`, so a hardcoded entry 404s → pages render but never\n     * hydrate. Required for `target: \"static\"` (SSG drives `app.fetch`); ignored otherwise. */\n    readonly prerenderApp?: (client: BuildManifest) => PrerenderAppLike | Promise<PrerenderAppLike>;\n    /** Client-build plugins (e.g. the MDX/Vue/Solid Bun plugins). */\n    readonly clientPlugins?: readonly BunPlugin[];\n    /** Server-build plugins (e.g. the SSR variants). */\n    readonly serverPlugins?: readonly BunPlugin[];\n    /** Extra Bun.build resolve conditions for the CLIENT build. */\n    readonly conditions?: readonly string[];\n    /** Compile-time `define` replacements layered onto both builds. */\n    readonly define?: Readonly<Record<string, string>>;\n    /** Project-root static directory copied to deploy root. `false` disables it. */\n    readonly publicDir?: string | false;\n    /** Prefix of environment variables allowed into the client bundle (default `\"PUBLIC_\"`). */\n    readonly publicEnvPrefix?: string;\n    /** Document `<title>` for the generated server entry. */\n    readonly title?: string;\n}"
+    "signature": "export interface BuildTargetOptions {\n    /** The `routes/` directory to discover (absolute path). */\n    readonly routesDir: string;\n    /** Output directory for the assembled deploy dir (absolute path). Cleared and recreated. */\n    readonly outDir: string;\n    /** A scratch directory for intermediate codegen (the generated server entry + manifest) and the\n     * server bundle, cleaned up after. Absolute path. */\n    readonly workDir: string;\n    /** The adapter's client runtime module (exports `mountRouter`), e.g. `\"@nifrajs/web-react/client\"`. */\n    readonly clientModule: string;\n    /** Import specifier (resolvable from `workDir`) of the module exporting `adapter`. */\n    readonly adapterImport: string;\n    /** Import specifier (resolvable from `workDir`) of the module exporting `backend`, or `undefined`. */\n    readonly backendImport?: string;\n    /** Import specifier (resolvable from `workDir`) of the module exporting `use` (app-level middleware\n     * applied before page routes are declared), or `undefined`. Must resolve to the same edge-safe\n     * module as `adapterImport`. */\n    readonly useImport?: string;\n    /** Factory that builds the app for `static` prerendering, GIVEN the client build's manifest - so the\n     * emitted hydration `<script src>` uses the REAL content-hashed entry (`client.entry`) plus the same\n     * styles/route-preload the server targets use. A pre-built instance can't work here: the hash isn't known\n     * until `buildClient` runs inside `buildTarget`, so a hardcoded entry 404s → pages render but never\n     * hydrate. Required for `target: \"static\"` (SSG drives `app.fetch`); ignored otherwise. */\n    readonly prerenderApp?: (client: BuildManifest) => PrerenderAppLike | Promise<PrerenderAppLike>;\n    /** Client-build plugins (e.g. the MDX/Vue/Solid Bun plugins). */\n    readonly clientPlugins?: readonly BunPlugin[];\n    /** Server-build plugins (e.g. the SSR variants). */\n    readonly serverPlugins?: readonly BunPlugin[];\n    /** Extra Bun.build resolve conditions for the CLIENT build. */\n    readonly conditions?: readonly string[];\n    /** Compile-time `define` replacements layered onto both builds. */\n    readonly define?: Readonly<Record<string, string>>;\n    /** Project-root static directory copied to deploy root. `false` disables it. */\n    readonly publicDir?: string | false;\n    /** Prefix of environment variables allowed into the client bundle (default `\"PUBLIC_\"`). */\n    readonly publicEnvPrefix?: string;\n    /** Document `<title>` for the generated server entry. */\n    readonly title?: string;\n}"
   },
   {
     "name": "BuildTargetResult",
@@ -1099,6 +1316,12 @@
     "signature": "export declare function buildTargetWith(target: BuildTarget, options: BuildTargetOptions, bundler: Bundler): Promise<BuildTargetResult>;",
     "doc": "/**\n * The bundler-agnostic deploy orchestrator: everything `buildTarget` does EXCEPT the two bundling steps,\n * which come from `bundler`. `buildTarget` passes {@link bunBundler}; `buildTargetVite`\n * (`@nifrajs/web/build-vite`) passes the Vite strategy. One orchestrator, so the deploy-dir shape,\n * server-entry codegen, prerender and size report are identical across pipelines.\n */"
   },
+  {
+    "name": "buildWorkGraph",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function buildWorkGraph(input: WorkGraphBuildInput): Promise<WorkGraph>;"
+  },
   {
     "name": "bunBundler",
     "kind": "const",
@@ -1182,7 +1405,7 @@
     "name": "cacheControl",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function cacheControl(value: string | ((request: Request) => string | undefined), options?: CacheControlOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
+    "signature": "export declare function cacheControl(value: string | ((request: Request) => string | undefined), options?: CacheControlOptions): import(\"@nifrajs/core\").IdentityPlugin;",
     "doc": "/**\n * Set a `Cache-Control` header on matching responses. `value` is either a fixed directive string or a\n * function of the request (return `undefined` to leave a response untouched - e.g. cache by path).\n * Defaults to `GET`/`HEAD` + 2xx, and never clobbers a `Cache-Control` the handler set itself.\n *\n * ```ts\n * app.use(cacheControl(\"public, max-age=3600, stale-while-revalidate=60\"))\n * // or per-path:\n * app.use(cacheControl((req) =>\n *   new URL(req.url).pathname.startsWith(\"/assets/\") ? \"public, max-age=31536000, immutable\" : undefined,\n * ))\n * ```\n */"
   },
   {
@@ -1214,7 +1437,7 @@
     "name": "CacheOptions",
     "kind": "interface",
     "package": "@nifrajs/middleware",
-    "signature": "export interface CacheOptions {\n    readonly store: ResponseCacheStore;\n    /** Time to live in milliseconds. */\n    readonly ttlMs: number;\n    /** Methods cached. Default `[\"GET\", \"HEAD\"]`. */\n    readonly methods?: readonly string[];\n    /** Status predicate. Default: `200` only. */\n    readonly status?: (status: number) => boolean;\n    /** Header names included in the cache key and emitted in `Vary`. */\n    readonly vary?: readonly string[];\n    /** Custom cache key. Receives the normalized `vary` headers through the request itself. */\n    readonly key?: (request: Request) => string;\n    /** Maximum response bytes to store. Default `1_000_000`. Larger responses pass through. */\n    readonly maxBytes?: number;\n    /** Respect request `Cache-Control: no-cache/no-store`. Default `true`. */\n    readonly respectRequestCacheControl?: boolean;\n    /** Respect response `Cache-Control: private/no-store`. Default `true`. */\n    readonly respectResponseCacheControl?: boolean;\n    /** Cache responses with `Set-Cookie`. Default `false`. */\n    readonly cacheSetCookie?: boolean;\n    /** Cache responses to requests bearing `Authorization` or `Cookie` even when the response is not\n     * explicitly `Cache-Control: public` (or `s-maxage`). Default `false`: a shared cache must not store a\n     * personalized response (RFC 9111 §3.5), or it would be replayed to other users. Leave this off unless\n     * the cached route is genuinely the same for every caller. */\n    readonly cacheAuthenticated?: boolean;\n    /** Response header for cache status. Default `\"x-nifra-cache\"`; set `false` to disable. */\n    readonly cacheStatusHeader?: string | false;\n}"
+    "signature": "export interface CacheOptions {\n    readonly store: ResponseCacheStore;\n    /** Time to live in milliseconds. */\n    readonly ttlMs: number;\n    /** Methods cached. Default `[\"GET\", \"HEAD\"]`. */\n    readonly methods?: readonly string[];\n    /** Status predicate. Default: `200` only. */\n    readonly status?: (status: number) => boolean;\n    /** Header names included in the cache key and emitted in `Vary`. */\n    readonly vary?: readonly string[];\n    /** Custom cache key. Receives the normalized `vary` headers through the request itself. */\n    readonly key?: (request: Request) => string;\n    /** Maximum response bytes to store. Default `1_000_000`. Larger responses pass through. */\n    readonly maxBytes?: number;\n    /** Respect request `Cache-Control: no-cache/no-store`. Default `true`. */\n    readonly respectRequestCacheControl?: boolean;\n    /** Respect response `Cache-Control: private/no-store`. Default `true`. */\n    readonly respectResponseCacheControl?: boolean;\n    /** Cache responses with `Set-Cookie`. Default `false`. */\n    readonly cacheSetCookie?: boolean;\n    /** Cache responses to requests bearing `Authorization` or `Cookie` even when the response is not\n     * explicitly `Cache-Control: public` (or `s-maxage`). Default `false`: a shared cache must not store a\n     * personalized response (RFC 9111 §3.5), or it would be replayed to other users. Leave this off unless\n     * the cached route is genuinely the same for every caller. */\n    readonly cacheAuthenticated?: boolean;\n    /** Credential headers that make a request private. Defaults to Authorization, Cookie, and x-api-key. */\n    readonly authenticatedHeaders?: readonly string[];\n    /** Response header for cache status. Default `\"x-nifra-cache\"`; set `false` to disable. */\n    readonly cacheStatusHeader?: string | false;\n}"
   },
   {
     "name": "CacheStore",
@@ -1392,7 +1615,7 @@
     "name": "CapabilityFindingCode",
     "kind": "type",
     "package": "@nifrajs/core",
-    "signature": "export type CapabilityFindingCode = \"unknown-capability\" | \"provenance-uncovered\" | \"undeclared-capability-evidence\" | \"safe-method-domain-write\" | \"unconfined-write-reach\" | \"missing-request-idempotency\" | \"missing-durable-idempotency\" | \"forbidden-effect-import\" | \"provenance-truncated\";"
+    "signature": "export type CapabilityFindingCode = \"unknown-capability\" | \"provenance-uncovered\" | \"undeclared-capability-evidence\" | \"safe-method-domain-write\" | \"unconfined-write-reach\" | \"missing-request-idempotency\" | \"missing-durable-idempotency\" | \"forbidden-effect-import\" | \"provenance-truncated\" | \"unmatched-provenance-seam\";"
   },
   {
     "name": "CapabilityIdempotency",
@@ -1404,7 +1627,7 @@
     "name": "CapabilityImportRule",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface CapabilityImportRule {\n    /** Exact module specifier, or a trailing `/*` prefix rule. */\n    readonly specifier: string;\n    readonly capabilities: readonly string[];\n}"
+    "signature": "export interface CapabilityImportRule {\n    /** Exact module specifier, or a trailing `/*` prefix rule. */\n    readonly specifier: string;\n    readonly capabilities: readonly string[];\n    /**\n     * Allow this seam to be absent. A rule that matches no import anywhere in the project is reported\n     * as `unmatched-provenance-seam` by default, because a specifier written differently from the\n     * import it means to govern (`\"./db/client.ts\"` vs `import \"./db/client\"`) governs nothing and\n     * every route touching that effect still passes. Set this only for a policy shared across projects\n     * where some of them genuinely do not use the seam.\n     */\n    readonly optional?: boolean;\n}"
   },
   {
     "name": "CapabilityInterceptor",
@@ -1829,6 +2052,18 @@
     "signature": "export declare function checkResponseContract(schema: StandardSchemaV1, result: unknown, mode: \"warn\" | \"enforce\"): ResponseContractOutcome | Promise<ResponseContractOutcome>;",
     "doc": "/**\n * Check one result against the route's declared response schema.\n *\n * Returns synchronously when the schema does (the common case), so an app that opts in does not pay a\n * microtask per response for a check that had no work to do.\n */"
   },
+  {
+    "name": "CheckRule",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface CheckRule {\n    readonly code: string;\n    readonly title: string;\n    scan(ctx: RuleContext): Promise<readonly Diagnostic[]>;\n}"
+  },
+  {
+    "name": "checkTrajectoryInvariants",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function checkTrajectoryInvariants(result: AgentRunResult<unknown>, options?: TrajectoryInvariantOptions): readonly TrajectoryInvariantResult[];"
+  },
   {
     "name": "ChunkSize",
     "kind": "interface",
@@ -1975,6 +2210,18 @@
     "signature": "export interface Codeframe {\n    readonly file: string;\n    readonly line: number;\n    readonly column?: number | undefined;\n    readonly lines: ReadonlyArray<{\n        readonly number: number;\n        readonly text: string;\n        readonly caret: boolean;\n    }>;\n}",
     "doc": "/** A source window around the offending line. `caret` marks the exact line the top frame points at. */"
   },
+  {
+    "name": "collectAssuranceReport",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function collectAssuranceReport(cwd: string, configPath?: string): Promise<AssuranceReport>;"
+  },
+  {
+    "name": "collectAssureBundle",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function collectAssureBundle(cwd: string, options?: {\n    readonly config?: string;\n    readonly strict?: boolean;\n    readonly hydration?: boolean;\n    readonly interact?: boolean;\n}): Promise<AssureBundle>;"
+  },
   {
     "name": "Collection",
     "kind": "interface",
@@ -1988,12 +2235,18 @@
     "package": "@nifrajs/content",
     "signature": "export interface CollectionConfig<S extends StandardSchemaV1> {\n    /** Directory of content files, relative to the process cwd (or absolute). */\n    readonly dir: string;\n    /** Standard Schema validating each file's frontmatter. */\n    readonly schema: S;\n    /** File extensions to include (default `[\".md\", \".markdown\"]`). */\n    readonly extensions?: readonly string[];\n}"
   },
+  {
+    "name": "collectProjectWorkGraph",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function collectProjectWorkGraph(cwd: string, options?: {\n    readonly changedFiles?: readonly string[];\n    readonly minLevel?: number;\n}): Promise<ProjectWorkGraphResult>;"
+  },
   {
     "name": "combine",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function combine(...items: readonly Composable[]): NifraPlugin;",
-    "doc": "/** Compose middleware/plugins into one reusable bundle. Individual named plugins still dedupe. */"
+    "signature": "export declare function combine(...items: readonly Composable[]): IdentityPlugin;",
+    "doc": "/**\n * Compose middleware/plugins into one reusable bundle. Individual named plugins still dedupe.\n *\n * The bundle is a type **identity**: everything it contains runs, but context a member adds via\n * `derive`/`decorate` is not threaded to the caller's handler types (there is no way to sum unknown\n * members' context at the type level). Apply such a member with its own `.use(...)` instead.\n */"
   },
   {
     "name": "combineObservationAdapters",
@@ -2030,6 +2283,12 @@
     "signature": "export declare function compareRoutePatternSpecificity(left: CompiledRoutePattern, right: CompiledRoutePattern): number;",
     "doc": "/** Core precedence: static > mixed > param > wildcard at the first differing segment, independent of\n * registration order. */"
   },
+  {
+    "name": "CompatibleReplayFile",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type CompatibleReplayFile = ReplayFile | LegacyContractReplayFile | LegacyFailureReplayFile;"
+  },
   {
     "name": "CompiledRoutePattern",
     "kind": "interface",
@@ -2062,7 +2321,7 @@
     "name": "Composable",
     "kind": "type",
     "package": "@nifrajs/middleware",
-    "signature": "export type Composable = Middleware | NifraPlugin;"
+    "signature": "export type Composable = Middleware | IdentityPlugin;"
   },
   {
     "name": "compose",
@@ -2075,8 +2334,8 @@
     "name": "compression",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function compression(options?: CompressionOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
-    "doc": "/**\n * Transparently **gzip** responses when the client sends `Accept-Encoding: gzip` and the body is a\n * compressible type larger than `threshold`. Uses the Web-standard `CompressionStream`, so it runs\n * on every nifra runtime including the edge; gzip is the one encoding `CompressionStream`\n * guarantees everywhere, so brotli isn't offered.\n *\n * Built on the portable `onResponseBody` tier for framework-serialized bytes, with a stream-safe raw\n * fallback for handler-returned/proxied Responses. The common JSON path stays on Node's direct\n * writer; raw streams are compressed incrementally without being fully buffered.\n *\n * Skips: clients that don't accept gzip, already-encoded responses, bodyless responses,\n * `Range` responses (206 / `Content-Range`), `Cache-Control: no-transform`, non-compressible\n * types, and bodies below `threshold` (gzip's ~20-byte overhead would enlarge them). Adds\n * `Vary: Accept-Encoding`.\n *\n * ```ts\n * app.use(compression())\n * ```\n */"
+    "signature": "export declare function compression(options?: CompressionOptions): import(\"@nifrajs/core\").IdentityPlugin;",
+    "doc": "/**\n * Transparently **gzip** responses when the client sends `Accept-Encoding: gzip` and the body is a\n * compressible type larger than `threshold`. Uses the Web-standard `CompressionStream`, so it runs\n * on every nifra runtime including the edge; gzip is the one encoding `CompressionStream`\n * guarantees everywhere, so brotli isn't offered.\n *\n * Built on the portable `onResponseBody` tier for framework-serialized bytes, with a stream-safe raw\n * fallback for handler-returned/proxied Responses. The common JSON path stays on Node's direct\n * writer; raw streams are compressed incrementally without being fully buffered.\n *\n * Skips: clients that don't accept gzip, already-encoded responses, bodyless responses,\n * `Range` responses (206 / `Content-Range`), `Cache-Control: no-transform`, non-compressible\n * types, and bodies below `threshold` (gzip's ~20-byte overhead would enlarge them). Adds\n * `Vary: Accept-Encoding`.\n *\n * **Security (BREACH).** Compression makes the response length depend on its content, so a response\n * that mixes a secret with attacker-reflected input leaks the secret through the compressed size\n * (the BREACH class of attacks). This applies to any HTTP compression, not this middleware\n * specifically. Nifra's own CSRF tokens are HMAC-signed per session and safe to compress, but if a\n * response body reflects request input **and** carries a per-request secret, exclude that route via\n * `compressible`/route scoping, or split the secret and the reflection into separate responses.\n *\n * ```ts\n * app.use(compression())\n * ```\n */"
   },
   {
     "name": "CompressionOptions",
@@ -2201,14 +2460,14 @@
     "name": "Context",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface Context<Path extends string = string, S extends RouteSchema = RouteSchema> {\n    readonly req: Request;\n    /**\n     * Alias of {@link req} - the same `Request`. Page loaders/actions receive their request as `request`;\n     * this alias lets route handlers and loaders share one name, so `c.request` and `ctx.req` both work\n     * everywhere (no more `c.req` vs `ctx.request` mismatch).\n     */\n    readonly request: Request;\n    /** Read one request header without materializing a Web `Request` on the Node adapter hot path. */\n    readonly header: (name: string) => string | null;\n    readonly params: ParamsOf<S, Path>;\n    readonly query: QueryOf<S>;\n    readonly body: BodyOf<S>;\n    /** The request's cookies, parsed from the `Cookie` header (values URL-decoded). Parsed lazily on\n     * first access + cached. Signed cookies arrive as `value.signature` - verify with `unsignValue`. */\n    readonly cookies: Readonly<Record<string, string>>;\n    readonly set: ResponseControls;\n    /**\n     * Aborts when the server's `requestTimeoutMs` elapses (and never, when no timeout\n     * is configured). Pass it to cancellation-aware work - DB drivers, `fetch` - so a\n     * timed-out request stops doing work instead of running on after the 503.\n     */\n    readonly signal: AbortSignal;\n    /**\n     * Absolute request deadline plus monotonic remaining time. It shares {@link signal}; the server\n     * clamps an inbound deadline to local policy when `acceptInboundDeadlines` is enabled.\n     */\n    readonly budget: RequestBudget;\n    /**\n     * Platform bindings from `app.fetch(request, { env })` - Workers `env` (KV/D1/secrets), etc.\n     * `undefined` off-edge (Bun/Node/Deno). Declare the shape with `server<Env>()` to read it typed\n     * (`c.env: Env`); otherwise `unknown`. Validate at the trust boundary before use either way.\n     */\n    readonly env: unknown;\n    /**\n     * The caller's IP. By default the raw socket peer the serving adapter observed (`listen()`,\n     * `@nifrajs/node`, `@nifrajs/deno`) - the one address a client cannot forge - or `undefined` when the\n     * runtime exposes no socket (Workers) and no trust is declared. Behind a proxy/CDN, set the\n     * `clientIp` server option (`{ trustedHops }` or `{ header }`) to derive the real caller from the\n     * forwarding chain as far as you trust it; unset, no forwarded header is ever believed. Safe to key\n     * rate limits and audit logs on.\n     */\n    readonly clientIp: string | undefined;\n    /**\n     * Schedule background work. On edge runtimes it extends the response lifetime (Workers\n     * `ctx.waitUntil`); off-edge it runs the promise fire-and-forget (a rejection is swallowed,\n     * never an unhandled rejection).\n     */\n    readonly waitUntil: (promise: Promise<unknown>) => void;\n    /**\n     * Read the raw request body as bytes, **capped** at `maxBytes` (default: the server's\n     * `maxBodyBytes`). For routes with **no body schema** - raw bodies, file uploads,\n     * BYO-validation - where the automatic schema cap doesn't apply. An over-cap body (by\n     * `Content-Length` or while streaming) throws a flat `413`; a malformed `Content-Length`\n     * throws `400`. Consumes the body stream (call once). Pass a larger `maxBytes` for an\n     * upload route, a smaller one to tighten a specific endpoint.\n     */\n    readonly boundedBody: (maxBytes?: number) => Promise<Uint8Array>;\n    /**\n     * `boundedBody` + `JSON.parse` (UTF-8). Same cap + `413`/`400` semantics; additionally\n     * throws a flat `400` on invalid JSON. Use for a schema-less JSON endpoint that still\n     * wants the body bounded.\n     */\n    readonly boundedJson: <T = unknown>(maxBytes?: number) => Promise<T>;\n    /**\n     * Build a JSON `Response`. Pass a status number or a full `ResponseInit` as the second arg. `return` it\n     * from a handler, or `throw` it from `derive`/`beforeHandle` to short-circuit - both work:\n     * `throw c.json({ error: \"unauthorized\" }, 401)`. A terser alternative to\n     * `new Response(JSON.stringify(...), { status, headers: { \"content-type\": \"application/json\" } })`.\n     */\n    readonly json: (body: unknown, init?: ResponseInit | number) => Response;\n    /** Build a `text/plain; charset=utf-8` `Response`. Like {@link json}, pass a status or `ResponseInit`. */\n    readonly text: (body: string, init?: ResponseInit | number) => Response;\n}",
+    "signature": "export interface Context<Path extends string = string, S extends RouteSchema = RouteSchema> {\n    readonly req: Request;\n    /**\n     * Alias of {@link req} - the same `Request`. Page loaders/actions receive their request as `request`;\n     * this alias lets route handlers and loaders share one name, so `c.request` and `ctx.req` both work\n     * everywhere (no more `c.req` vs `ctx.request` mismatch).\n     */\n    readonly request: Request;\n    /** Read one request header without materializing a Web `Request` on the Node adapter hot path. */\n    readonly header: (name: string) => string | null;\n    readonly params: ParamsOf<S, Path>;\n    /** Lower-case request headers, validated/coerced when `schema.headers` is declared. */\n    readonly headers: HeadersOf<S>;\n    readonly query: QueryOf<S>;\n    readonly body: BodyOf<S>;\n    /** The request's cookies, parsed from the `Cookie` header (values URL-decoded). Parsed lazily on\n     * first access + cached. Signed cookies arrive as `value.signature` - verify with `unsignValue`. */\n    readonly cookies: Readonly<Record<string, string>>;\n    readonly set: ResponseControls;\n    /**\n     * Aborts when the server's `requestTimeoutMs` elapses (and never, when no timeout\n     * is configured). Pass it to cancellation-aware work - DB drivers, `fetch` - so a\n     * timed-out request stops doing work instead of running on after the 503.\n     */\n    readonly signal: AbortSignal;\n    /**\n     * Absolute request deadline plus monotonic remaining time. It shares {@link signal}; the server\n     * clamps an inbound deadline to local policy when `acceptInboundDeadlines` is enabled.\n     */\n    readonly budget: RequestBudget;\n    /**\n     * Platform bindings from `app.fetch(request, { env })` - Workers `env` (KV/D1/secrets), etc.\n     * `undefined` off-edge (Bun/Node/Deno). Declare the shape with `server<Env>()` to read it typed\n     * (`c.env: Env`); otherwise `unknown`. Validate at the trust boundary before use either way.\n     */\n    readonly env: unknown;\n    /**\n     * The caller's IP. By default the raw socket peer the serving adapter observed (`listen()`,\n     * `@nifrajs/node`, `@nifrajs/deno`) - the one address a client cannot forge - or `undefined` when the\n     * runtime exposes no socket (Workers) and no trust is declared. Behind a proxy/CDN, set the\n     * `clientIp` server option (`{ trustedHops }` or `{ header }`) to derive the real caller from the\n     * forwarding chain as far as you trust it; unset, no forwarded header is ever believed. Safe to key\n     * rate limits and audit logs on.\n     */\n    readonly clientIp: string | undefined;\n    /**\n     * Schedule background work. On edge runtimes it extends the response lifetime (Workers\n     * `ctx.waitUntil`); off-edge it runs the promise fire-and-forget (a rejection is swallowed,\n     * never an unhandled rejection).\n     */\n    readonly waitUntil: (promise: Promise<unknown>) => void;\n    /**\n     * Read the raw request body as bytes, **capped** at `maxBytes` (default: the server's\n     * `maxBodyBytes`). For routes with **no body schema** - raw bodies, file uploads,\n     * BYO-validation - where the automatic schema cap doesn't apply. An over-cap body (by\n     * `Content-Length` or while streaming) throws a flat `413`; a malformed `Content-Length`\n     * throws `400`. Consumes the body stream (call once). Pass a larger `maxBytes` for an\n     * upload route, a smaller one to tighten a specific endpoint.\n     */\n    readonly boundedBody: (maxBytes?: number) => Promise<Uint8Array>;\n    /**\n     * `boundedBody` + `JSON.parse` (UTF-8). Same cap + `413`/`400` semantics; additionally\n     * throws a flat `400` on invalid JSON. Use for a schema-less JSON endpoint that still\n     * wants the body bounded.\n     */\n    readonly boundedJson: <T = unknown>(maxBytes?: number) => Promise<T>;\n    /**\n     * Build a JSON `Response`. Pass a status number or a full `ResponseInit` as the second arg. `return` it\n     * from a handler, or `throw` it from `derive`/`beforeHandle` to short-circuit - both work:\n     * `throw c.json({ error: \"unauthorized\" }, 401)`. A terser alternative to\n     * `new Response(JSON.stringify(...), { status, headers: { \"content-type\": \"application/json\" } })`.\n     */\n    readonly json: (body: unknown, init?: ResponseInit | number) => Response;\n    /** Build a `text/plain; charset=utf-8` `Response`. Like {@link json}, pass a status or `ResponseInit`. */\n    readonly text: (body: string, init?: ResponseInit | number) => Response;\n}",
     "doc": "/**\n * Handler context. `params` are inferred from the path; `body` and `query` are\n * the validated outputs of their schemas when declared (else `undefined` /\n * raw `URLSearchParams`).\n */"
   },
   {
     "name": "Context",
     "kind": "interface",
     "package": "nifra",
-    "signature": "export interface Context<Path extends string = string, S extends RouteSchema = RouteSchema> {\n    readonly req: Request;\n    /**\n     * Alias of {@link req} - the same `Request`. Page loaders/actions receive their request as `request`;\n     * this alias lets route handlers and loaders share one name, so `c.request` and `ctx.req` both work\n     * everywhere (no more `c.req` vs `ctx.request` mismatch).\n     */\n    readonly request: Request;\n    /** Read one request header without materializing a Web `Request` on the Node adapter hot path. */\n    readonly header: (name: string) => string | null;\n    readonly params: ParamsOf<S, Path>;\n    readonly query: QueryOf<S>;\n    readonly body: BodyOf<S>;\n    /** The request's cookies, parsed from the `Cookie` header (values URL-decoded). Parsed lazily on\n     * first access + cached. Signed cookies arrive as `value.signature` - verify with `unsignValue`. */\n    readonly cookies: Readonly<Record<string, string>>;\n    readonly set: ResponseControls;\n    /**\n     * Aborts when the server's `requestTimeoutMs` elapses (and never, when no timeout\n     * is configured). Pass it to cancellation-aware work - DB drivers, `fetch` - so a\n     * timed-out request stops doing work instead of running on after the 503.\n     */\n    readonly signal: AbortSignal;\n    /**\n     * Absolute request deadline plus monotonic remaining time. It shares {@link signal}; the server\n     * clamps an inbound deadline to local policy when `acceptInboundDeadlines` is enabled.\n     */\n    readonly budget: RequestBudget;\n    /**\n     * Platform bindings from `app.fetch(request, { env })` - Workers `env` (KV/D1/secrets), etc.\n     * `undefined` off-edge (Bun/Node/Deno). Declare the shape with `server<Env>()` to read it typed\n     * (`c.env: Env`); otherwise `unknown`. Validate at the trust boundary before use either way.\n     */\n    readonly env: unknown;\n    /**\n     * The caller's IP. By default the raw socket peer the serving adapter observed (`listen()`,\n     * `@nifrajs/node`, `@nifrajs/deno`) - the one address a client cannot forge - or `undefined` when the\n     * runtime exposes no socket (Workers) and no trust is declared. Behind a proxy/CDN, set the\n     * `clientIp` server option (`{ trustedHops }` or `{ header }`) to derive the real caller from the\n     * forwarding chain as far as you trust it; unset, no forwarded header is ever believed. Safe to key\n     * rate limits and audit logs on.\n     */\n    readonly clientIp: string | undefined;\n    /**\n     * Schedule background work. On edge runtimes it extends the response lifetime (Workers\n     * `ctx.waitUntil`); off-edge it runs the promise fire-and-forget (a rejection is swallowed,\n     * never an unhandled rejection).\n     */\n    readonly waitUntil: (promise: Promise<unknown>) => void;\n    /**\n     * Read the raw request body as bytes, **capped** at `maxBytes` (default: the server's\n     * `maxBodyBytes`). For routes with **no body schema** - raw bodies, file uploads,\n     * BYO-validation - where the automatic schema cap doesn't apply. An over-cap body (by\n     * `Content-Length` or while streaming) throws a flat `413`; a malformed `Content-Length`\n     * throws `400`. Consumes the body stream (call once). Pass a larger `maxBytes` for an\n     * upload route, a smaller one to tighten a specific endpoint.\n     */\n    readonly boundedBody: (maxBytes?: number) => Promise<Uint8Array>;\n    /**\n     * `boundedBody` + `JSON.parse` (UTF-8). Same cap + `413`/`400` semantics; additionally\n     * throws a flat `400` on invalid JSON. Use for a schema-less JSON endpoint that still\n     * wants the body bounded.\n     */\n    readonly boundedJson: <T = unknown>(maxBytes?: number) => Promise<T>;\n    /**\n     * Build a JSON `Response`. Pass a status number or a full `ResponseInit` as the second arg. `return` it\n     * from a handler, or `throw` it from `derive`/`beforeHandle` to short-circuit - both work:\n     * `throw c.json({ error: \"unauthorized\" }, 401)`. A terser alternative to\n     * `new Response(JSON.stringify(...), { status, headers: { \"content-type\": \"application/json\" } })`.\n     */\n    readonly json: (body: unknown, init?: ResponseInit | number) => Response;\n    /** Build a `text/plain; charset=utf-8` `Response`. Like {@link json}, pass a status or `ResponseInit`. */\n    readonly text: (body: string, init?: ResponseInit | number) => Response;\n}",
+    "signature": "export interface Context<Path extends string = string, S extends RouteSchema = RouteSchema> {\n    readonly req: Request;\n    /**\n     * Alias of {@link req} - the same `Request`. Page loaders/actions receive their request as `request`;\n     * this alias lets route handlers and loaders share one name, so `c.request` and `ctx.req` both work\n     * everywhere (no more `c.req` vs `ctx.request` mismatch).\n     */\n    readonly request: Request;\n    /** Read one request header without materializing a Web `Request` on the Node adapter hot path. */\n    readonly header: (name: string) => string | null;\n    readonly params: ParamsOf<S, Path>;\n    /** Lower-case request headers, validated/coerced when `schema.headers` is declared. */\n    readonly headers: HeadersOf<S>;\n    readonly query: QueryOf<S>;\n    readonly body: BodyOf<S>;\n    /** The request's cookies, parsed from the `Cookie` header (values URL-decoded). Parsed lazily on\n     * first access + cached. Signed cookies arrive as `value.signature` - verify with `unsignValue`. */\n    readonly cookies: Readonly<Record<string, string>>;\n    readonly set: ResponseControls;\n    /**\n     * Aborts when the server's `requestTimeoutMs` elapses (and never, when no timeout\n     * is configured). Pass it to cancellation-aware work - DB drivers, `fetch` - so a\n     * timed-out request stops doing work instead of running on after the 503.\n     */\n    readonly signal: AbortSignal;\n    /**\n     * Absolute request deadline plus monotonic remaining time. It shares {@link signal}; the server\n     * clamps an inbound deadline to local policy when `acceptInboundDeadlines` is enabled.\n     */\n    readonly budget: RequestBudget;\n    /**\n     * Platform bindings from `app.fetch(request, { env })` - Workers `env` (KV/D1/secrets), etc.\n     * `undefined` off-edge (Bun/Node/Deno). Declare the shape with `server<Env>()` to read it typed\n     * (`c.env: Env`); otherwise `unknown`. Validate at the trust boundary before use either way.\n     */\n    readonly env: unknown;\n    /**\n     * The caller's IP. By default the raw socket peer the serving adapter observed (`listen()`,\n     * `@nifrajs/node`, `@nifrajs/deno`) - the one address a client cannot forge - or `undefined` when the\n     * runtime exposes no socket (Workers) and no trust is declared. Behind a proxy/CDN, set the\n     * `clientIp` server option (`{ trustedHops }` or `{ header }`) to derive the real caller from the\n     * forwarding chain as far as you trust it; unset, no forwarded header is ever believed. Safe to key\n     * rate limits and audit logs on.\n     */\n    readonly clientIp: string | undefined;\n    /**\n     * Schedule background work. On edge runtimes it extends the response lifetime (Workers\n     * `ctx.waitUntil`); off-edge it runs the promise fire-and-forget (a rejection is swallowed,\n     * never an unhandled rejection).\n     */\n    readonly waitUntil: (promise: Promise<unknown>) => void;\n    /**\n     * Read the raw request body as bytes, **capped** at `maxBytes` (default: the server's\n     * `maxBodyBytes`). For routes with **no body schema** - raw bodies, file uploads,\n     * BYO-validation - where the automatic schema cap doesn't apply. An over-cap body (by\n     * `Content-Length` or while streaming) throws a flat `413`; a malformed `Content-Length`\n     * throws `400`. Consumes the body stream (call once). Pass a larger `maxBytes` for an\n     * upload route, a smaller one to tighten a specific endpoint.\n     */\n    readonly boundedBody: (maxBytes?: number) => Promise<Uint8Array>;\n    /**\n     * `boundedBody` + `JSON.parse` (UTF-8). Same cap + `413`/`400` semantics; additionally\n     * throws a flat `400` on invalid JSON. Use for a schema-less JSON endpoint that still\n     * wants the body bounded.\n     */\n    readonly boundedJson: <T = unknown>(maxBytes?: number) => Promise<T>;\n    /**\n     * Build a JSON `Response`. Pass a status number or a full `ResponseInit` as the second arg. `return` it\n     * from a handler, or `throw` it from `derive`/`beforeHandle` to short-circuit - both work:\n     * `throw c.json({ error: \"unauthorized\" }, 401)`. A terser alternative to\n     * `new Response(JSON.stringify(...), { status, headers: { \"content-type\": \"application/json\" } })`.\n     */\n    readonly json: (body: unknown, init?: ResponseInit | number) => Response;\n    /** Build a `text/plain; charset=utf-8` `Response`. Like {@link json}, pass a status or `ResponseInit`. */\n    readonly text: (body: string, init?: ResponseInit | number) => Response;\n}",
     "doc": "/**\n * Handler context. `params` are inferred from the path; `body` and `query` are\n * the validated outputs of their schemas when declared (else `undefined` /\n * raw `URLSearchParams`).\n */"
   },
   {
@@ -2218,6 +2477,20 @@
     "signature": "export type ContextForOp<O extends OperationDef> = Context<O[\"path\"], SchemaForOp<O> & RouteSchema>;",
     "doc": "/**\n * The handler context for an op - identical to the inline `Context<Path, S>`, so a\n * handler written for an inline route type-checks unchanged under `implement`\n * (the graduation guarantee).\n */"
   },
+  {
+    "name": "ContextPlugin",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ContextPlugin<D extends object> = (<R extends Registry, Ctx>(app: Server<R, Ctx>) => Server<R, Ctx & D>) & {\n    readonly pluginName?: string;\n};",
+    "doc": "/**\n * A named plugin built with {@link defineContextPlugin}: it adds the context `D` to every handler\n * downstream while threading the caller's route registry and existing context UNCHANGED. This is the\n * type {@link definePlugin} cannot express - `definePlugin` infers its parameter from an untyped\n * `(app) => ...` arrow, which lands on `AnyServer`, so `use` returns `Server<any, any>`.\n */"
+  },
+  {
+    "name": "ContextPlugin",
+    "kind": "type",
+    "package": "nifra",
+    "signature": "export type ContextPlugin<D extends object> = (<R extends Registry, Ctx>(app: Server<R, Ctx>) => Server<R, Ctx & D>) & {\n    readonly pluginName?: string;\n};",
+    "doc": "/**\n * A named plugin built with {@link defineContextPlugin}: it adds the context `D` to every handler\n * downstream while threading the caller's route registry and existing context UNCHANGED. This is the\n * type {@link definePlugin} cannot express - `definePlugin` infers its parameter from an untyped\n * `(app) => ...` arrow, which lands on `AnyServer`, so `use` returns `Server<any, any>`.\n */"
+  },
   {
     "name": "contextStorage",
     "kind": "function",
@@ -2317,6 +2590,20 @@
     "signature": "export interface CookieJar {\n    /** The current `Cookie` request-header value (`\"a=1; b=2\"`, or `\"\"` when empty). */\n    header(): string;\n    /** Set the `Cookie` header on `headers` when the jar is non-empty. */\n    applyTo(headers: Headers): void;\n    /** Absorb every `Set-Cookie` on a response (setting or, on removal, deleting each). */\n    store(response: {\n        headers: Headers;\n    }): void;\n    set(name: string, value: string): void;\n    get(name: string): string | undefined;\n    clear(): void;\n    readonly size: number;\n}",
     "doc": "/**\n * A tiny cookie jar for in-process tests - parses `Set-Cookie` off responses and emits a `Cookie`\n * request header, so a login → authenticated-request flow works without threading headers by hand. It\n * honours removal (`Max-Age=0` / a past `Expires`) so logout clears the cookie; other attributes\n * (Domain/Path/Secure/SameSite) are ignored - everything is same-origin in-process.\n */"
   },
+  {
+    "name": "cookieNamePrefix",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function cookieNamePrefix(name: string): \"secure\" | \"host\" | undefined;",
+    "doc": "/**\n * RFC 6265bis cookie-name prefix, matched **case-insensitively** the way browsers match it -\n * `__secure-x` triggers the same enforcement as `__Secure-x`. `undefined` for unprefixed names.\n * Writers (set AND delete) must satisfy the prefix contract or the user agent silently discards\n * the whole `Set-Cookie`.\n */"
+  },
+  {
+    "name": "cookieNamePrefix",
+    "kind": "function",
+    "package": "nifra",
+    "signature": "export declare function cookieNamePrefix(name: string): \"secure\" | \"host\" | undefined;",
+    "doc": "/**\n * RFC 6265bis cookie-name prefix, matched **case-insensitively** the way browsers match it -\n * `__secure-x` triggers the same enforcement as `__Secure-x`. `undefined` for unprefixed names.\n * Writers (set AND delete) must satisfy the prefix contract or the user agent silently discards\n * the whole `Set-Cookie`.\n */"
+  },
   {
     "name": "CookieOptions",
     "kind": "interface",
@@ -2331,6 +2618,20 @@
     "signature": "export interface CookieOptions {\n    /** Lifetime in seconds. `0` (with a past `expires`) deletes the cookie. */\n    readonly maxAge?: number;\n    readonly expires?: Date;\n    readonly path?: string;\n    readonly domain?: string;\n    readonly secure?: boolean;\n    readonly httpOnly?: boolean;\n    readonly sameSite?: \"strict\" | \"lax\" | \"none\";\n    readonly partitioned?: boolean;\n}",
     "doc": "/** Attributes for a `Set-Cookie`. `expires` is a `Date`; `maxAge` is in **seconds**. */"
   },
+  {
+    "name": "CookieSecret",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type CookieSecret = string | readonly string[];",
+    "doc": "/**\n * A signing secret, or a rotation list of them. With a list, **the first secret signs** and\n * verification accepts **any** entry - so rotation is: prepend the new secret, keep the old one\n * until every cookie signed by it has expired, then drop it. An empty list throws.\n */"
+  },
+  {
+    "name": "CookieSecret",
+    "kind": "type",
+    "package": "nifra",
+    "signature": "export type CookieSecret = string | readonly string[];",
+    "doc": "/**\n * A signing secret, or a rotation list of them. With a list, **the first secret signs** and\n * verification accepts **any** entry - so rotation is: prepend the new secret, keep the old one\n * until every cookie signed by it has expired, then drop it. An empty list throws.\n */"
+  },
   {
     "name": "copyPublicDir",
     "kind": "function",
@@ -2365,6 +2666,19 @@
     "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": "createAgentEvidenceStream",
+    "kind": "function",
+    "package": "@nifrajs/agent",
+    "signature": "export declare function createAgentEvidenceStream(options?: AgentEvidenceStreamOptions): AgentEvidenceStream;",
+    "doc": "/** Create an async iterable that yields the exact evidence values received by `step`. */"
+  },
+  {
+    "name": "createAgentState",
+    "kind": "function",
+    "package": "@nifrajs/agent",
+    "signature": "export declare function createAgentState(turnId: string): AgentTurnState;"
+  },
   {
     "name": "createApprovalCoordinator",
     "kind": "function",
@@ -2388,7 +2702,7 @@
     "name": "createCsrfToken",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function createCsrfToken(secret: string | Uint8Array, nonce?: string): Promise<string>;"
+    "signature": "export declare function createCsrfToken(secret: CsrfSecret, nonce?: string): Promise<string>;"
   },
   {
     "name": "createDataPort",
@@ -2443,6 +2757,12 @@
     "signature": "export declare function createEventRegistry(contracts: readonly EventContract[]): EventRegistry;",
     "doc": "/** Build a registry from a set of contracts. Throws on a duplicate `type@version`. */"
   },
+  {
+    "name": "createEvidenceBundle",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function createEvidenceBundle(graph: WorkGraph, impact: ImpactReport, plan: ProofPlan, proofs?: readonly ProofEvidence[]): EvidenceBundle;"
+  },
   {
     "name": "createFailureLab",
     "kind": "function",
@@ -2471,6 +2791,13 @@
     "signature": "export declare function createImageHandler(options?: ImageHandlerOptions): (req: Request) => Promise<Response>;",
     "doc": "/**\n * Build the resize request handler. Mount its return value at the `selfHostedLoader` endpoint:\n *\n * ```ts\n * const image = createImageHandler({ root: \"./public\", allowedOrigins: [\"https://cdn.example\"] })\n * // inside your router: if (url.pathname === \"/_image\") return image(req)\n * ```\n */"
   },
+  {
+    "name": "createLocalProcessAdapter",
+    "kind": "function",
+    "package": "@nifrajs/agent",
+    "signature": "export declare function createLocalProcessAdapter(options?: LocalProcessAdapterOptions): LocalProcessAdapter;",
+    "doc": "/**\n * Run a command with the host controls available to a normal child process. The local adapter is NOT\n * a security boundary. Without OS-level sandboxing it contains crashes and accidents, not hostile code.\n */"
+  },
   {
     "name": "createMatcher",
     "kind": "function",
@@ -2494,7 +2821,13 @@
     "name": "CreateMcpServerOptions",
     "kind": "interface",
     "package": "@nifrajs/mcp",
-    "signature": "export interface CreateMcpServerOptions {\n    readonly name: string;\n    readonly version: string;\n    readonly tools?: readonly McpTool[];\n    /** MCP Apps widgets - their resources are registered and the UI capability is advertised. */\n    readonly widgets?: readonly McpWidget[];\n    /** Extra (non-widget) resources to expose. */\n    readonly resources?: readonly McpResource[];\n    readonly prompts?: readonly McpPrompt[];\n    /** GET health-page text. */\n    readonly health?: string;\n    /** Max JSON-RPC body size in bytes (default 1 MB). */\n    readonly maxBodyBytes?: number;\n    /** Natural-language guidance for LLMs, surfaced in the modern `server/discover` result (2026-07-28). */\n    readonly instructions?: string;\n    /** Origin allowlist for the DNS-rebinding guard. Omit to allow any origin; set it to reject other\n     * browser origins with 403 (e.g. a hardened, non-public mount). */\n    readonly allowedOrigins?: readonly string[];\n}"
+    "signature": "export interface CreateMcpServerOptions {\n    readonly name: string;\n    readonly version: string;\n    readonly tools?: readonly McpTool[];\n    /** MCP Apps widgets - their resources are registered and the UI capability is advertised. */\n    readonly widgets?: readonly McpWidget[];\n    /** Extra (non-widget) resources to expose. */\n    readonly resources?: readonly McpResource[];\n    readonly prompts?: readonly McpPrompt[];\n    /** GET health-page text. */\n    readonly health?: string;\n    /** Max JSON-RPC body size in bytes (default 1 MB). */\n    readonly maxBodyBytes?: number;\n    /** Natural-language guidance for LLMs, surfaced in the modern `server/discover` result (2026-07-28). */\n    readonly instructions?: string;\n    /** Origin allowlist for the DNS-rebinding guard. Omit to allow any origin; set it to reject other\n     * browser origins with 403 (e.g. a hardened, non-public mount). */\n    readonly allowedOrigins?: readonly string[];\n    /**\n     * Per-message authorization, applied after the message parses and before any tool runs. Return\n     * `false` to answer 403 with a JSON-RPC `unauthorized` error (`MCP_ERROR.UNAUTHORIZED`) and no result.\n     *\n     * This is the seam for \"this caller may list tools but may not call the write ones\" - the HTTP\n     * layer above only sees one opaque POST, so a route guard cannot make that distinction.\n     * `fetch(request, { authorizeMessage })` overrides it per request when the decision depends on\n     * something the surrounding handler resolved (a session, a tenant).\n     */\n    readonly authorizeMessage?: (message: JsonRpcRequest, request: Request) => boolean | Promise<boolean>;\n}"
+  },
+  {
+    "name": "createMemoryAssureSink",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function createMemoryAssureSink(): MemoryAssureSink;"
   },
   {
     "name": "createMemoryCausalityStore",
@@ -2552,6 +2885,13 @@
     "signature": "export declare function createPngRasterizer(render: PngRenderer): OgImageRasterizer;",
     "doc": "/**\n * Adapt an injected SVG→PNG renderer to `ogImageResponse`.\n *\n * The renderer stays application-owned because codec/WASM choice is runtime-specific. For example:\n *\n * ```ts\n * import { Resvg } from \"@resvg/resvg-js\"\n * import { createPngRasterizer } from \"@nifrajs/image/og-png\"\n * const rasterizer = createPngRasterizer((svg) => new Resvg(svg).render().asPng())\n * ```\n *\n * This is the public reference adapter; the core package remains zero-dependency and keeps SVG as its\n * explicit default for callers that do not opt into a codec.\n */"
   },
+  {
+    "name": "createProxy",
+    "kind": "function",
+    "package": "@nifrajs/proxy",
+    "signature": "export declare function createProxy(options: ProxyOptions): ProxyHandler;",
+    "doc": "/**\n * Create a proxy handler bound to one upstream origin.\n *\n * ```ts\n * const upstream = createProxy({ upstream: \"http://127.0.0.1:8081\" })\n * app.mountFetch(\"/api\", upstream, { stripPrefix: true })\n * ```\n *\n * Streams both directions, preserves method/path/query/status, strips hop-by-hop and\n * Connection-nominated headers both ways, never follows upstream redirects, and answers flat\n * errors: `502 bad_gateway` when the upstream is unreachable, `504 gateway_timeout` on deadline.\n * WebSocket upgrade is not proxied.\n */"
+  },
   {
     "name": "createQuery",
     "kind": "function",
@@ -2645,6 +2985,38 @@
     "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": "createToolBudget",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createToolBudget(options: CreateToolBudgetOptions): ToolBudget;"
+  },
+  {
+    "name": "CreateToolBudgetOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface CreateToolBudgetOptions {\n    readonly limits: EffectCost;\n    readonly initial?: EffectCost;\n}"
+  },
+  {
+    "name": "createToolHttpHandler",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createToolHttpHandler<Input, Output>(tool: ToolContract<Input, Output>, options?: ToolHttpOptions): (request: Request) => Promise<Response>;",
+    "doc": "/**\n * Mount one contract behind a Web-standard handler. The handler accepts one JSON request body.\n * A body carrying a poisoned key (own `__proto__`, or `constructor.prototype`) is rejected with\n * the same `input_invalid` result as malformed JSON. The body is capped at\n * {@link ToolHttpOptions.maxBytes} (1 MiB by default); over-cap answers a flat `413` and a\n * malformed `Content-Length` a flat `400`, before any parse.\n */"
+  },
+  {
+    "name": "createTrajectoryTranscript",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function createTrajectoryTranscript(transcript: AgentTranscript, options?: CreateTrajectoryTranscriptOptions): Promise<TrajectoryTranscript>;",
+    "doc": "/** Record the transcript emitted by a turn without adding a second execution recording path. */"
+  },
+  {
+    "name": "CreateTrajectoryTranscriptOptions",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface CreateTrajectoryTranscriptOptions {\n    readonly faultProfile?: string;\n    readonly seed?: number;\n}"
+  },
   {
     "name": "createTransportCodecRegistry",
     "kind": "function",
@@ -2669,14 +3041,14 @@
     "name": "createWebApp",
     "kind": "function",
     "package": "@nifrajs/web",
-    "signature": "export declare function createWebApp<Env = unknown>(options: CreateWebAppOptions): ReturnType<typeof server<Env>>;",
+    "signature": "export declare function createWebApp<Env = unknown>(options: CreateWebAppOptions<Env>): ReturnType<typeof server<Env>>;",
     "doc": "/**\n * Build a nifra app from a route manifest: every route SSRs its layout chain via `renderPage`,\n * and a wildcard catch-all renders `_404` (or a plain 404). Reuses @nifrajs/core's router +\n * lifecycle, so matching, params, and precedence are battle-tested. fs-free - feed it a\n * manifest from `discoverRoutes` (`@nifrajs/web/fs`) at startup, so the served app stays portable.\n *\n * **Typed platform bindings.** Pass `Env` - `createWebApp<Env>({ … })` - to declare the app's Workers\n * bindings ONCE. It seeds the returned `Server`'s context with `{ env: Env }` (exactly as the backend's\n * `server<Env>()` does), so `app.fetch(req, { env })` / `toFetchHandler(app)` type-check the `env`\n * argument against the declared shape - no per-binding cast at the edge entry. Per-route loaders/actions\n * stay typed independently of this call: annotate them with `@nifrajs/client`'s `LoaderArgs<Api, Env>`\n * (same `Env`) so `ctx.env.MY_KV` is typed there too. Omit the parameter and `Env` is `unknown` - the\n * secure default; validate at the trust boundary before use.\n */"
   },
   {
     "name": "CreateWebAppOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface CreateWebAppOptions {\n    readonly adapter: RenderAdapter;\n    readonly manifest: Manifest;\n    /** URL of the built client entry (module script) injected into every page. */\n    readonly clientEntry: string;\n    /** Default document title for all pages. */\n    readonly title?: string;\n    /** Injected into each loader's `ctx.api` - typically an `inProcessClient(app)` (typed\n     * per-route via `@nifrajs/client`'s `createRoutes`). Opaque to the core.\n     *\n     * **Auto-mount.** Every `inProcessClient(backend)` exposes the symbol-keyed platform-aware backend\n     * mount interface from `@nifrajs/core/mount`; `createWebApp` also serves that backend over HTTP at\n     * {@link apiPrefix} (default `/api`): a request whose pathname starts with the prefix is dispatched\n     * before page routing with the same `env`/`waitUntil` platform context, and the backend's `Response`\n     * is returned untouched. The mount runs in `nifra dev` too. Pass `apiPrefix: \"\"` to disable it. */\n    readonly api?: unknown;\n    /** HTTP path prefix the {@link api} backend is auto-mounted at (default `\"/api\"`). A request whose\n     * pathname is exactly the prefix or starts with `prefix + \"/\"` is dispatched to the backend before\n     * page routing; the backend therefore defines its routes at the **full** path (`server().post(\"/api/\n     * sync\", …)`), matching the in-process `inProcessClient` call sites. Set to `\"\"` to disable the\n     * auto-mount entirely (the app serves pages only and `api` stays a loader-only `ctx.api`). Mounting\n     * is also a no-op when `api` does not expose the symbol mount. */\n    readonly apiPrefix?: string;\n    /**\n     * Strip {@link apiPrefix} from the pathname before dispatching to `api` (default `false`).\n     *\n     * The default suits a backend that declares FULL paths (`server().post(\"/api/sync\", …)`), which is\n     * right when it is only ever mounted here. Set this when the backend declares its routes WITHOUT the\n     * prefix because it also runs standalone behind its own shell, so its paths cannot carry a prefix that\n     * only exists when it is mounted. Without it every request 404s inside the backend, and the workaround\n     * is a `Proxy` that rewrites each URL.\n     */\n    readonly apiStrip?: boolean;\n    /**\n     * Sub-apps mounted ahead of page routing - an auth handler, a webhook receiver, a stack's routes.\n     *\n     * Structural on purpose: anything with `{ path, app: { fetch } }` fits, so a library that exposes its\n     * routes as such a list mounts as `mounts: theirRoutes` without `@nifrajs/web` taking a dependency on\n     * it. `better-auth` is the motivating case - it is not a `backend` route, so `/api/auth/*` used to 404\n     * silently.\n     *\n     * Tried longest-path-first and BEFORE the `api` mount, so a mount at `/api/auth` wins over a backend\n     * at `/api` no matter which was declared first. `stripPrefix` is the per-mount form of {@link apiStrip}:\n     * leave it off to pass the full path through.\n     */\n    readonly mounts?: ReadonlyArray<{\n        readonly path: string;\n        readonly app: {\n            fetch(request: Request): Response | Promise<Response>;\n        };\n        readonly stripPrefix?: boolean;\n    }>;\n    /** Secret for **draft / preview mode** (see `enableDraft`). When set, a request carrying a valid\n     * signed `__nifra_draft` cookie gets `ctx.draft === true` in loaders/actions (else always `false`).\n     * Pair with `withISR({ draftSecret })` so editors bypass the cache. Omit to disable draft mode. */\n    readonly draftSecret?: string;\n    /** Per-route chunk URLs (`buildClient`'s `BuildManifest.routes`) - `routeId → [layout chunks…, own\n     * chunk]`. When present, each page `modulepreload`s its matched route's chunks alongside the entry,\n     * so the route code downloads in parallel (no entry→route-chunk waterfall). Omit ⇒ entry-only. */\n    readonly routePreload?: Readonly<Record<string, readonly string[]>>;\n    /** The app's bundled stylesheet URLs (`buildClient`'s `BuildManifest.css`) - the aggregate, injected\n     * as `<link rel=\"stylesheet\">` in a page's `<head>`. Used as the fallback for any route absent from\n     * {@link routeStyles}. Omit ⇒ no links (dev, where Vite injects CSS, or a CSS-free app). */\n    readonly styles?: readonly string[];\n    /** Per-route stylesheet URLs (`buildClient`'s `BuildManifest.routeStyles`) - `routeId → [chain CSS]`.\n     * When a matched route has an entry here, only those (its layout chain + own CSS) are linked instead\n     * of the aggregate `styles`, so a page ships only the CSS it uses. An empty array ⇒ no `<link>` (the\n     * page imports no CSS). Routes absent here fall back to `styles`. Omit ⇒ always use `styles`. */\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>>;\n    /** SSG: the prerendered-path set (e.g. `enumerateStaticRoutes(routes).paths` or the build's\n     * `prerendered.json`). Injected as `window.__NIFRA_PRERENDERED__` on every page so a client soft-nav\n     * into a prerendered route fetches its static `_data.json` instead of hitting the worker. */\n    readonly prerenderedPaths?: readonly string[];\n    /** SSG: per dynamic route pattern, its `getStaticPaths` `fallback` (from `enumerateStaticRoutes` or\n     * the build's `prerendered.json`). A route mapped to `\"404\"` rejects any path NOT in\n     * `prerenderedPaths` with the 404 page - the unlisted path simply doesn't exist. `\"ssr\"` (the\n     * default for unmapped routes) renders unlisted paths on-demand. */\n    readonly staticFallbacks?: Readonly<Record<string, \"ssr\" | \"404\">>;\n    /** Observe every loader/action failure - for error-reporting plugins (Sentry-style). Called for\n     * real throws (not control-flow `Response`s like `redirect`), **before** the nearest `_error`\n     * boundary renders / a soft-nav 500 / a rethrow - so it sees errors that the boundary would\n     * otherwise hide. Observation only; its own throws are swallowed so a faulty reporter can't break\n     * rendering. (`beforeLoader` is intentionally omitted - the core HTTP hooks already cover\n     * pre-request work.) */\n    readonly onLoaderError?: (error: unknown, ctx: {\n        readonly request: Request;\n        readonly params: Readonly<Record<string, string>>;\n        readonly route: string;\n    }) => void;\n}"
+    "signature": "export interface CreateWebAppOptions<Env = unknown> {\n    readonly adapter: RenderAdapter;\n    readonly manifest: Manifest;\n    /** URL of the built client entry (module script) injected into every page. */\n    readonly clientEntry: string;\n    /** Default document title for all pages. */\n    readonly title?: string;\n    /**\n     * Options for the underlying `server()` - `requestTimeoutMs`, `admission`, `gracefulSignals`, and\n     * the rest of {@link ServerOptions}.\n     *\n     * Needed because the `Server` is constructed in here, so a caller has no other way to reach its\n     * constructor: a page app could set no request timeout and no capacity gate, which are exactly the\n     * two knobs a production readiness check looks for. An SSR app wants them MORE than a backend does -\n     * a render is slow and allocation-heavy, so a burst that a JSON API would absorb is the one that\n     * exhausts the pod.\n     *\n     * Applies to the whole app, {@link mounts} and the {@link api} auto-mount included: the capacity gate\n     * sits at the fetch entry, ahead of the request hooks those are dispatched from.\n     */\n    readonly server?: ServerOptions;\n    /**\n     * Runs against the app BEFORE any page route is registered - the seam for `securityHeaders()`,\n     * `requestId()`, `logger()`, a rate limit, or anything else applied with `use`.\n     *\n     * ```ts\n     * createWebApp({\n     *   …,\n     *   use: (app) => {\n     *     app.use(securityHeaders())\n     *     app.use(requestId())\n     *   },\n     * })\n     * ```\n     *\n     * A callback rather than an array because `use` is overloaded - `Middleware`, `IdentityPlugin`,\n     * `ContextPlugin` - and only the real call site instantiates the right overload. The return value\n     * is ignored: this is for cross-cutting concerns, not for declaring routes (declare those on the\n     * returned app, where they get their types).\n     *\n     * **Why the timing matters.** `beforeHandle`, `afterHandle`, `around`, `derive`/`decorate`, and\n     * `onError` are snapshotted into each route AS IT IS DECLARED, and `createWebApp` declares every\n     * page (plus the `/*` catch-all) before it returns - so a caller's `app.use(…)` afterwards binds\n     * them to nothing, silently. `requestId()` is exactly that case: it is a `derive`, so applied late\n     * it leaves every page without `c.requestId`. Route assurance evidence is order-scoped the same\n     * way, so a late `securityHeaders()` leaves the pages unable to PROVE the header to `nifra assure`\n     * even though it does still set it.\n     *\n     * `onRequest`/`onResponse` (and the response header/body hooks) are app-global arrays read at\n     * request time, so those alone DO work when added late. Using this seam for everything avoids\n     * having to remember which is which.\n     *\n     * Runs ahead of the {@link mounts} / {@link api} request hooks, so an `onRequest` middleware guards\n     * a mounted auth handler too.\n     *\n     * A `ContextPlugin` applied here takes runtime effect but cannot widen the declared return type of\n     * this function, so `c.requestId` is not typed on routes you declare afterwards. Named plugins are\n     * idempotent, so `app.use(requestId())` on the returned app recovers the TYPE without applying the\n     * plugin a second time.\n     */\n    readonly use?: (app: ReturnType<typeof server<Env>>) => void;\n    /** Injected into each loader's `ctx.api` - typically an `inProcessClient(app)` (typed\n     * per-route via `@nifrajs/client`'s `createRoutes`). Opaque to the core.\n     *\n     * **Auto-mount.** Every `inProcessClient(backend)` exposes the symbol-keyed platform-aware backend\n     * mount interface from `@nifrajs/core/mount`; `createWebApp` also serves that backend over HTTP at\n     * {@link apiPrefix} (default `/api`): a request whose pathname starts with the prefix is dispatched\n     * before page routing with the same `env`/`waitUntil` platform context, and the backend's `Response`\n     * is returned untouched. The mount runs in `nifra dev` too. Pass `apiPrefix: \"\"` to disable it. */\n    readonly api?: unknown;\n    /** HTTP path prefix the {@link api} backend is auto-mounted at (default `\"/api\"`). A request whose\n     * pathname is exactly the prefix or starts with `prefix + \"/\"` is dispatched to the backend before\n     * page routing; the backend therefore defines its routes at the **full** path (`server().post(\"/api/\n     * sync\", …)`), matching the in-process `inProcessClient` call sites. Set to `\"\"` to disable the\n     * auto-mount entirely (the app serves pages only and `api` stays a loader-only `ctx.api`). Mounting\n     * is also a no-op when `api` does not expose the symbol mount. */\n    readonly apiPrefix?: string;\n    /**\n     * Strip {@link apiPrefix} from the pathname before dispatching to `api` (default `false`).\n     *\n     * The default suits a backend that declares FULL paths (`server().post(\"/api/sync\", …)`), which is\n     * right when it is only ever mounted here. Set this when the backend declares its routes WITHOUT the\n     * prefix because it also runs standalone behind its own shell, so its paths cannot carry a prefix that\n     * only exists when it is mounted. Without it every request 404s inside the backend, and the workaround\n     * is a `Proxy` that rewrites each URL.\n     */\n    readonly apiStrip?: boolean;\n    /**\n     * Sub-apps mounted ahead of page routing - an auth handler, a webhook receiver, a stack's routes.\n     *\n     * Structural on purpose: anything with `{ path, app: { fetch } }` fits, so a library that exposes its\n     * routes as such a list mounts as `mounts: theirRoutes` without `@nifrajs/web` taking a dependency on\n     * it. `better-auth` is the motivating case - it is not a `backend` route, so `/api/auth/*` used to 404\n     * silently.\n     *\n     * Tried longest-path-first and BEFORE the `api` mount, so a mount at `/api/auth` wins over a backend\n     * at `/api` no matter which was declared first. `stripPrefix` is the per-mount form of {@link apiStrip}:\n     * leave it off to pass the full path through.\n     */\n    readonly mounts?: ReadonlyArray<{\n        readonly path: string;\n        readonly app: {\n            fetch(request: Request): Response | Promise<Response>;\n        };\n        readonly stripPrefix?: boolean;\n    }>;\n    /** Secret for **draft / preview mode** (see `enableDraft`). When set, a request carrying a valid\n     * signed `__nifra_draft` cookie gets `ctx.draft === true` in loaders/actions (else always `false`).\n     * Pair with `withISR({ draftSecret })` so editors bypass the cache. Omit to disable draft mode. */\n    readonly draftSecret?: string;\n    /** Per-route chunk URLs (`buildClient`'s `BuildManifest.routes`) - `routeId → [layout chunks…, own\n     * chunk]`. When present, each page `modulepreload`s its matched route's chunks alongside the entry,\n     * so the route code downloads in parallel (no entry→route-chunk waterfall). Omit ⇒ entry-only. */\n    readonly routePreload?: Readonly<Record<string, readonly string[]>>;\n    /** The app's bundled stylesheet URLs (`buildClient`'s `BuildManifest.css`) - the aggregate, injected\n     * as `<link rel=\"stylesheet\">` in a page's `<head>`. Used as the fallback for any route absent from\n     * {@link routeStyles}. Omit ⇒ no links (dev, where Vite injects CSS, or a CSS-free app). */\n    readonly styles?: readonly string[];\n    /** Per-route stylesheet URLs (`buildClient`'s `BuildManifest.routeStyles`) - `routeId → [chain CSS]`.\n     * When a matched route has an entry here, only those (its layout chain + own CSS) are linked instead\n     * of the aggregate `styles`, so a page ships only the CSS it uses. An empty array ⇒ no `<link>` (the\n     * page imports no CSS). Routes absent here fall back to `styles`. Omit ⇒ always use `styles`. */\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>>;\n    /** SSG: the prerendered-path set (e.g. `enumerateStaticRoutes(routes).paths` or the build's\n     * `prerendered.json`). Injected as `window.__NIFRA_PRERENDERED__` on every page so a client soft-nav\n     * into a prerendered route fetches its static `_data.json` instead of hitting the worker. */\n    readonly prerenderedPaths?: readonly string[];\n    /** Publish the project's `AGENTS.md` inside `/llms.txt` and `/llms-full.txt`. **Off by default**:\n     * those endpoints are public and unauthenticated, while `AGENTS.md` is a repo file written for the\n     * team - unreleased feature names, internal hostnames, and \"don't touch X yet\" notes live there\n     * routinely. Turn it on only for a repo whose guidelines you would publish as a page. */\n    readonly publishLocalGuidelines?: boolean;\n    /** SSG: per dynamic route pattern, its `getStaticPaths` `fallback` (from `enumerateStaticRoutes` or\n     * the build's `prerendered.json`). A route mapped to `\"404\"` rejects any path NOT in\n     * `prerenderedPaths` with the 404 page - the unlisted path simply doesn't exist. `\"ssr\"` (the\n     * default for unmapped routes) renders unlisted paths on-demand. */\n    readonly staticFallbacks?: Readonly<Record<string, \"ssr\" | \"404\">>;\n    /** Observe every loader/action failure - for error-reporting plugins (Sentry-style). Called for\n     * real throws (not control-flow `Response`s like `redirect`), **before** the nearest `_error`\n     * boundary renders / a soft-nav 500 / a rethrow - so it sees errors that the boundary would\n     * otherwise hide. Observation only; its own throws are swallowed so a faulty reporter can't break\n     * rendering. (`beforeLoader` is intentionally omitted - the core HTTP hooks already cover\n     * pre-request work.) */\n    readonly onLoaderError?: (error: unknown, ctx: {\n        readonly request: Request;\n        readonly params: Readonly<Record<string, string>>;\n        readonly route: string;\n    }) => void;\n}"
   },
   {
     "name": "createWebSocketHub",
@@ -2729,7 +3101,7 @@
     "name": "CsrfOptions",
     "kind": "interface",
     "package": "@nifrajs/middleware",
-    "signature": "export interface CsrfOptions {\n    /** HMAC secret. Must be at least 32 bytes. */\n    readonly secret: string | Uint8Array;\n    /** Cookie carrying the signed token. Default `\"csrf-token\"`. */\n    readonly cookie?: string;\n    /** Header carrying the same signed token. Default `\"x-csrf-token\"`. */\n    readonly header?: string;\n    /** Unsafe methods to protect. Default: every method except GET/HEAD/OPTIONS/TRACE. */\n    readonly methods?: readonly string[];\n    /** Allowed request origins. Default: same-origin derived from the request URL. */\n    readonly origins?: readonly string[];\n    /** Check Origin/Referer on protected requests. Default true. */\n    readonly checkOrigin?: boolean;\n}"
+    "signature": "export interface CsrfOptions {\n    /** HMAC secret (≥ 32 bytes), or a rotation list - see {@link CsrfSecret}. */\n    readonly secret: CsrfSecret;\n    /** Cookie carrying the signed token. Default `\"csrf-token\"`. */\n    readonly cookie?: string;\n    /** Header carrying the same signed token. Default `\"x-csrf-token\"`. */\n    readonly header?: string;\n    /** Unsafe methods to protect. Default: every method except GET/HEAD/OPTIONS/TRACE. */\n    readonly methods?: readonly string[];\n    /** Allowed request origins. Default: same-origin derived from the request URL. */\n    readonly origins?: readonly string[];\n    /** Check Origin/Referer on protected requests. Default true. */\n    readonly checkOrigin?: boolean;\n}"
   },
   {
     "name": "CssModuleResult",
@@ -2979,6 +3351,12 @@
     "signature": "export declare function decodeTransportText(text: string, contentType: string | null, registry?: TransportCodecRegistry, options?: TransportDecodeOptions): unknown;",
     "doc": "/**\n * Decode an ALREADY-READ transport body. The counterpart to {@link decodeTransportResponse} for a\n * caller that obtained the text through its own bounded read - notably the typed client's\n * in-process path, where the response body is same-process memory that was fully resident before\n * the read, so the native `Response.text()` is safe and the streaming byte-cap loop would protect\n * nothing while costing ~23x. The byte cap is still enforced here (identical error), just after\n * the read instead of during it.\n */"
   },
+  {
+    "name": "DEFAULT_ASSURANCE_CONFIG",
+    "kind": "const",
+    "package": "@nifrajs/cli",
+    "signature": "export declare const DEFAULT_ASSURANCE_CONFIG = \"nifra.assurance.ts\";"
+  },
   {
     "name": "DEFAULT_DEV_PORT",
     "kind": "const",
@@ -3007,6 +3385,13 @@
     "signature": "export declare const DEFAULT_MAX_ENTRIES = 1000;",
     "doc": "/** Per-request entry bound. Generous for real handlers, small enough to stop a runaway loop. */"
   },
+  {
+    "name": "DEFAULT_TOOL_MAX_BYTES",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const DEFAULT_TOOL_MAX_BYTES = 1048576;",
+    "doc": "/** Default transport body cap for {@link createToolHttpHandler}: 1 MiB. */"
+  },
   {
     "name": "DEFAULT_WIRE_DECODE_LIMITS",
     "kind": "const",
@@ -3075,6 +3460,20 @@
     "signature": "export declare function defineCollection<S extends StandardSchemaV1>(config: CollectionConfig<S>): Collection<InferSchema<S>>;",
     "doc": "/**\n * Define a content collection backed by a directory. `all()` discovers + parses every matching file;\n * `get(slug)` loads one. Frontmatter is validated against `schema`, so entries are fully typed and a\n * malformed file fails loudly. Reads the filesystem - use it at build time (SSG/prerender) or on a\n * long-lived server (Bun/Node/Deno).\n */"
   },
+  {
+    "name": "defineContextPlugin",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function defineContextPlugin<D extends object>(name: string, apply: <R extends Registry, Ctx>(app: Server<R, Ctx>) => Server<R, Ctx & D>): ContextPlugin<D>;",
+    "doc": "/**\n * Define a named plugin that **adds typed context and nothing else** - the `derive` case - without\n * collapsing the caller's types. `use` instantiates the generic signature against the concrete\n * receiver, so `R` and `Ctx` come back unchanged with `D` intersected onto the context.\n *\n * Use this instead of {@link definePlugin} for every `(app) => app.derive(...)` plugin. `definePlugin`\n * is only safe when the caller supplies `In`/`Out` explicitly; with the usual untyped arrow both\n * default to `AnyServer` and the typed client silently collapses to `any`.\n *\n * ```ts\n * export const requestId = defineContextPlugin<{ requestId: string }>(\"requestId\", (app) =>\n *   app.derive(() => ({ requestId: crypto.randomUUID() })),\n * )\n * const api = server().get(\"/a\", h).use(requestId).get(\"/b\", h) // /a AND /b stay typed; c.requestId typed\n * ```\n */"
+  },
+  {
+    "name": "defineContextPlugin",
+    "kind": "function",
+    "package": "nifra",
+    "signature": "export declare function defineContextPlugin<D extends object>(name: string, apply: <R extends Registry, Ctx>(app: Server<R, Ctx>) => Server<R, Ctx & D>): ContextPlugin<D>;",
+    "doc": "/**\n * Define a named plugin that **adds typed context and nothing else** - the `derive` case - without\n * collapsing the caller's types. `use` instantiates the generic signature against the concrete\n * receiver, so `R` and `Ctx` come back unchanged with `D` intersected onto the context.\n *\n * Use this instead of {@link definePlugin} for every `(app) => app.derive(...)` plugin. `definePlugin`\n * is only safe when the caller supplies `In`/`Out` explicitly; with the usual untyped arrow both\n * default to `AnyServer` and the typed client silently collapses to `any`.\n *\n * ```ts\n * export const requestId = defineContextPlugin<{ requestId: string }>(\"requestId\", (app) =>\n *   app.derive(() => ({ requestId: crypto.randomUUID() })),\n * )\n * const api = server().get(\"/a\", h).use(requestId).get(\"/b\", h) // /a AND /b stay typed; c.requestId typed\n * ```\n */"
+  },
   {
     "name": "defineContract",
     "kind": "function",
@@ -3109,6 +3508,19 @@
     "signature": "export declare function defineEventContract<Schema extends StandardSchemaV1>(spec: {\n    type: string;\n    version: number;\n    payload: Schema;\n}): EventContract<Schema>;",
     "doc": "/** Define a portable, versioned event contract. */"
   },
+  {
+    "name": "defineExecutionPolicy",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function defineExecutionPolicy(policy: ExecutionPolicy): ExecutionPolicy;"
+  },
+  {
+    "name": "defineFaultProfile",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function defineFaultProfile(profile: FaultProfile): FaultProfile;",
+    "doc": "/** Validate and freeze a reusable fault profile. */"
+  },
   {
     "name": "defineIdentityPlugin",
     "kind": "function",
@@ -3151,15 +3563,33 @@
     "name": "definePlugin",
     "kind": "function",
     "package": "@nifrajs/core",
-    "signature": "export declare function definePlugin<In extends AnyServer, Out extends AnyServer>(name: string, apply: (app: In) => Out): NifraPlugin<In, Out>;",
-    "doc": "/**\n * Name + ergonomics for a plugin that **adds typed context** (`derive`/`decorate`). `app.use(myPlugin)`\n * applies it once; a second `use` of the same name is skipped (idempotent), so plugins can depend on each\n * other without double-registering hooks.\n *\n * ```ts\n * export const requestId = definePlugin(\"requestId\", (app) => app.derive(() => ({ requestId: uuid() })))\n * app.use(requestId)   // downstream handlers see c.requestId\n * ```\n *\n * FOOTGUN: only use this for a plugin that adds context. For a plugin that **mounts routes/hooks but adds\n * NO context** (an auth router, an audit logger), use {@link defineRouterPlugin} ({@link defineIdentityPlugin}).\n * `definePlugin((app) => app.get(...))` infers `app: Server<any, any>`, so `.use()` returns `Server<any, any>`\n * and your whole typed client silently collapses to `any` - no type error, no runtime error.\n */"
+    "signature": "export declare function definePlugin<In extends AnyServer, Out extends AnyServer>(name: string, apply: (app: In) => Out): DefinePluginResult<In, Out>;",
+    "doc": "/**\n * Name + ergonomics for a plugin that **adds typed context** (`derive`/`decorate`). `app.use(myPlugin)`\n * applies it once; a second `use` of the same name is skipped (idempotent), so plugins can depend on each\n * other without double-registering hooks.\n *\n * ```ts\n * export const requestId = definePlugin(\"requestId\", (app: typeof api) =>\n *   app.derive(() => ({ requestId: uuid() })),\n * )\n * app.use(requestId)   // downstream handlers see c.requestId\n * ```\n *\n * This helper only threads types when the caller pins the input server type - by annotating the\n * parameter as above, or with explicit type arguments. With a bare `(app) => ...` arrow `app` infers as\n * `AnyServer`, which would widen the caller's whole route registry to `any`; that case now returns\n * {@link PluginTypeCollapsed}, so `.use()` fails to compile with one error at the call site rather than\n * producing a typed client full of `any`. Prefer a definer that cannot collapse at all:\n *\n * - adds context via `derive`/`decorate` -> {@link defineContextPlugin}\n * - mounts routes/hooks and adds NO context -> {@link defineRouterPlugin} ({@link defineIdentityPlugin})\n */"
   },
   {
     "name": "definePlugin",
     "kind": "function",
     "package": "nifra",
-    "signature": "export declare function definePlugin<In extends AnyServer, Out extends AnyServer>(name: string, apply: (app: In) => Out): NifraPlugin<In, Out>;",
-    "doc": "/**\n * Name + ergonomics for a plugin that **adds typed context** (`derive`/`decorate`). `app.use(myPlugin)`\n * applies it once; a second `use` of the same name is skipped (idempotent), so plugins can depend on each\n * other without double-registering hooks.\n *\n * ```ts\n * export const requestId = definePlugin(\"requestId\", (app) => app.derive(() => ({ requestId: uuid() })))\n * app.use(requestId)   // downstream handlers see c.requestId\n * ```\n *\n * FOOTGUN: only use this for a plugin that adds context. For a plugin that **mounts routes/hooks but adds\n * NO context** (an auth router, an audit logger), use {@link defineRouterPlugin} ({@link defineIdentityPlugin}).\n * `definePlugin((app) => app.get(...))` infers `app: Server<any, any>`, so `.use()` returns `Server<any, any>`\n * and your whole typed client silently collapses to `any` - no type error, no runtime error.\n */"
+    "signature": "export declare function definePlugin<In extends AnyServer, Out extends AnyServer>(name: string, apply: (app: In) => Out): DefinePluginResult<In, Out>;",
+    "doc": "/**\n * Name + ergonomics for a plugin that **adds typed context** (`derive`/`decorate`). `app.use(myPlugin)`\n * applies it once; a second `use` of the same name is skipped (idempotent), so plugins can depend on each\n * other without double-registering hooks.\n *\n * ```ts\n * export const requestId = definePlugin(\"requestId\", (app: typeof api) =>\n *   app.derive(() => ({ requestId: uuid() })),\n * )\n * app.use(requestId)   // downstream handlers see c.requestId\n * ```\n *\n * This helper only threads types when the caller pins the input server type - by annotating the\n * parameter as above, or with explicit type arguments. With a bare `(app) => ...` arrow `app` infers as\n * `AnyServer`, which would widen the caller's whole route registry to `any`; that case now returns\n * {@link PluginTypeCollapsed}, so `.use()` fails to compile with one error at the call site rather than\n * producing a typed client full of `any`. Prefer a definer that cannot collapse at all:\n *\n * - adds context via `derive`/`decorate` -> {@link defineContextPlugin}\n * - mounts routes/hooks and adds NO context -> {@link defineRouterPlugin} ({@link defineIdentityPlugin})\n */"
+  },
+  {
+    "name": "DefinePluginResult",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type DefinePluginResult<In extends AnyServer, Out extends AnyServer> = ServerTypeUnpinned<In> extends true ? PluginTypeCollapsed : NifraPlugin<In, Out>;"
+  },
+  {
+    "name": "DefinePluginResult",
+    "kind": "type",
+    "package": "nifra",
+    "signature": "export type DefinePluginResult<In extends AnyServer, Out extends AnyServer> = ServerTypeUnpinned<In> extends true ? PluginTypeCollapsed : NifraPlugin<In, Out>;"
+  },
+  {
+    "name": "defineReplayFile",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function defineReplayFile(input: Omit<ReplayFile, \"version\">): ReplayFile;"
   },
   {
     "name": "defineRouterPlugin",
@@ -3181,6 +3611,12 @@
     "package": "@nifrajs/core",
     "signature": "export declare function defineSaga<I, C extends Record<string, unknown>>(definition: SagaDefinition<I, C>): SagaDefinition<I, C>;"
   },
+  {
+    "name": "defineTool",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function defineTool<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1>(options: ToolContractOptions<InferOutput<InputSchema>, InferOutput<OutputSchema>, InputSchema, OutputSchema>): ToolContract<InferOutput<InputSchema>, InferOutput<OutputSchema>>;"
+  },
   {
     "name": "DehydratedState",
     "kind": "interface",
@@ -3286,7 +3722,7 @@
     "name": "devtools",
     "kind": "function",
     "package": "@nifrajs/devtools",
-    "signature": "export declare function devtools(options?: DevToolsOptions | undefined): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;"
+    "signature": "export declare function devtools(options?: DevToolsOptions | undefined): import(\"@nifrajs/core\").IdentityPlugin;"
   },
   {
     "name": "DevToolsClientOptions",
@@ -3321,6 +3757,18 @@
     "signature": "export interface DevToolsQuery {\n    readonly path?: string | undefined;\n    readonly limit?: number | undefined;\n}",
     "doc": "/** Query for a DevTools state snapshot: an optional `path` prefix and a most-recent-`limit`. */"
   },
+  {
+    "name": "diagnostic",
+    "kind": "const",
+    "package": "@nifrajs/cli",
+    "signature": "export declare const diagnostic: (value: Diagnostic) => Diagnostic;"
+  },
+  {
+    "name": "Diagnostic",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface Diagnostic {\n    /** Stable forever. Never renumber or reuse. */\n    readonly code: string;\n    readonly severity: Severity;\n    readonly message: string;\n    readonly file?: string;\n    readonly line?: number;\n    /** Short evidence strings that help an agent act without exposing payloads. */\n    readonly evidence?: readonly string[];\n    readonly fix?: DiagnosticFix;\n    /** Command that proves the fix worked. */\n    readonly verify?: string;\n}"
+  },
   {
     "name": "Diagnostic",
     "kind": "interface",
@@ -3335,6 +3783,12 @@
     "signature": "export declare const DIAGNOSTIC_CATALOG: readonly CatalogEntry[];",
     "doc": "/**\n * The recognised-failure catalog. Seeded with the highest-signal nifra failures; extend it as new\n * classes of error earn a stable code. Order matters only in that the first match wins.\n */"
   },
+  {
+    "name": "DiagnosticFix",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface DiagnosticFix {\n    readonly recipe: string;\n    readonly command?: string;\n}"
+  },
   {
     "name": "DiagnosticFrame",
     "kind": "interface",
@@ -3376,6 +3830,13 @@
     "package": "@nifrajs/core",
     "signature": "export type DiffSeverity = \"breaking\" | \"compatible\" | \"info\";"
   },
+  {
+    "name": "digestProjectEvidence",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function digestProjectEvidence(snapshot: ProjectEvidenceSnapshot): Promise<string>;",
+    "doc": "/** SHA-256 of the canonical snapshot, useful as a cheap freshness/reference token. */"
+  },
   {
     "name": "disableDraft",
     "kind": "function",
@@ -3422,7 +3883,7 @@
     "name": "durableCommand",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function durableCommand(options: DurableCommandOptions): NifraPlugin;",
+    "signature": "export declare function durableCommand(options: DurableCommandOptions): IdentityPlugin;",
     "doc": "/**\n * Journal every capability effect on the routes below it, and declare the evidence that says so.\n *\n * A capability defined `idempotency: \"durable\"` requires `nifra.durable-command` evidence, and until\n * this adapter existed nothing in the framework produced it. The only way to satisfy the tier was to\n * write `assurance: [\"nifra.durable-command\"]` on the route - an assertion with nothing behind it,\n * wrong in both directions: a route that genuinely journals its effects but omits the string fails\n * `nifra check`, and a route that journals nothing but includes it passes.\n *\n * The evidence is a by-product here rather than a claim. Installing the adapter puts the journal on\n * the request, so `executeCapability` records intent before an effect runs and exactly one terminal\n * outcome after - which is what the tier is asking about. A call that passes its own `journal` still\n * uses that one.\n *\n *     const commands = durableCommand({ journal: createDurableEffectJournal({ store }) })\n *     const app = server().use(commands).post(\"/charge\", { capabilities: [\"billing.charge\"] }, …)\n *\n * `beforeHandle` is order-scoped, like the auth plugins: routes registered before `.use(...)` are not\n * covered, and the `subsequent` scope on the evidence says the same thing to `nifra check`.\n *\n * Note what this does NOT claim. Response replay (`schema.idempotency`) is a different guarantee and\n * deliberately never proves this one: replaying a stored response after a crash mid-effect does not\n * make the effect exactly-once, and the journal is what survives the crash.\n */"
   },
   {
@@ -3571,6 +4032,12 @@
     "signature": "export declare function effectLedger(options: EffectLedgerOptions): IdentityPlugin;",
     "doc": "/**\n * Enable the per-request effect ledger. Each route that declares `schema.capabilities` gets a bounded,\n * token-only ledger; `useCapability(c, id, …)` appends one entry per effect, and the sink receives the\n * sealed ledger when the response settles (only when it recorded entries). Token-only by construction -\n * capability ids, phases, counters, digests; never payloads, values, or the concrete URL (the route\n * pattern is recorded). Without this plugin, capability-declaring routes simply carry no ledger.\n */"
   },
+  {
+    "name": "EffectLedger",
+    "kind": "type",
+    "package": "@nifrajs/testing",
+    "signature": "export type EffectLedger = SealedEffectLedger;"
+  },
   {
     "name": "effectLedgerOf",
     "kind": "function",
@@ -3847,8 +4314,8 @@
     "name": "etag",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function etag(options?: ETagOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
-    "doc": "/**\n * A {@link definePlugin} plugin that adds a content-hash `ETag` to `GET` `200` responses and returns\n * **`304 Not Modified`** when the client's `If-None-Match` matches - saving bandwidth on unchanged\n * responses. Built on the portable `onResponseBody` tier: the hook receives the final\n * framework-serialized bytes on every runtime with nothing drained, so the middleware stays on\n * Node's direct writer. Handler-returned raw `Response`s (streams, proxied fetches) use a capped,\n * replaying fallback so oversized bodies remain intact. Idempotent.\n */"
+    "signature": "export declare function etag(options?: ETagOptions): import(\"@nifrajs/core\").IdentityPlugin;",
+    "doc": "/**\n * A {@link defineRouterPlugin} plugin that adds a content-hash `ETag` to `GET` `200` responses and returns\n * **`304 Not Modified`** when the client's `If-None-Match` matches - saving bandwidth on unchanged\n * responses. Built on the portable `onResponseBody` tier: the hook receives the final\n * framework-serialized bytes on every runtime with nothing drained, so the middleware stays on\n * Node's direct writer. Handler-returned raw `Response`s (streams, proxied fetches) use a capped,\n * replaying fallback so oversized bodies remain intact. Idempotent.\n */"
   },
   {
     "name": "ETagOptions",
@@ -3856,6 +4323,12 @@
     "package": "@nifrajs/middleware",
     "signature": "export interface ETagOptions {\n    /** Emit a weak validator (`W/\"…\"`). Default `true` - it's a content hash, not a byte-for-byte promise. */\n    readonly weak?: boolean;\n    /** Maximum response bytes to hash. Default `1_000_000`; larger responses pass through unchanged. */\n    readonly maxBytes?: number;\n}"
   },
+  {
+    "name": "evaluateBuildFreshness",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function evaluateBuildFreshness(input: {\n    readonly hasArtifact: boolean;\n    readonly newestSourceMs: number;\n    readonly newestBuildMs: number;\n    readonly buildDir?: string;\n}): BuildFreshness;"
+  },
   {
     "name": "evaluateCapabilityAssurance",
     "kind": "function",
@@ -3908,6 +4381,12 @@
     "package": "@nifrajs/events",
     "signature": "export interface EventRegistry {\n    readonly contracts: readonly EventContract[];\n    /** Look up a contract by type + version (defaults to version 0). */\n    get(type: string, version?: number): EventContract | undefined;\n    /** Dispatch untrusted input to its contract by `type`/`version` and parse. Never throws. */\n    parse(input: unknown): RegistryParseResult;\n}"
   },
+  {
+    "name": "EvidenceBundle",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface EvidenceBundle {\n    readonly version: 1;\n    readonly graphDigest: string;\n    readonly changedFiles: readonly string[];\n    readonly targetLevel: number;\n    readonly plan: ProofPlan;\n    readonly proofs: readonly ProofEvidence[];\n    readonly stop: {\n        readonly done: boolean;\n        readonly missing: readonly string[];\n        readonly next?: ProofStep;\n    };\n}"
+  },
   {
     "name": "Example",
     "kind": "interface",
@@ -3936,6 +4415,12 @@
     "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": "executeTool",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function executeTool<Input, Output>(tool: ToolContract<Input, Output>, input: unknown, options?: ToolCallOptions): Promise<ToolCallResult<Output>>;"
+  },
   {
     "name": "ExecutionContext",
     "kind": "interface",
@@ -3950,6 +4435,48 @@
     "signature": "export interface ExecutionContext {\n    waitUntil(promise: Promise<unknown>): void;\n}",
     "doc": "/** A Cloudflare Workers-style execution context (the `fetch` 3rd arg). Structural - only\n * `waitUntil` is used; declared here so `@nifrajs/core` needs no Workers type dependency. */"
   },
+  {
+    "name": "ExecutionFilesystemScope",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ExecutionFilesystemScope = \"none\" | \"cwd\" | \"declared\";",
+    "doc": "/** The filesystem access a child process is expected to have. */"
+  },
+  {
+    "name": "ExecutionNetworkAccess",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ExecutionNetworkAccess = \"deny\" | \"allow\";",
+    "doc": "/** Network access requested by an execution policy. */"
+  },
+  {
+    "name": "ExecutionPolicy",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface ExecutionPolicy {\n    readonly filesystem: ExecutionFilesystemScope;\n    readonly network: ExecutionNetworkAccess;\n    readonly timeMs: number;\n    readonly capabilityCeiling: readonly string[];\n}",
+    "doc": "/**\n * A public, token-only execution policy. It describes a required capability; it is not an\n * isolation mechanism by itself.\n */"
+  },
+  {
+    "name": "ExecutionPolicy",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ExecutionPolicy {\n    readonly filesystem: ExecutionFilesystemScope;\n    readonly network: ExecutionNetworkAccess;\n    readonly timeMs: number;\n    readonly capabilityCeiling: readonly string[];\n}",
+    "doc": "/**\n * A public, token-only execution policy. It describes a required capability; it is not an\n * isolation mechanism by itself.\n */"
+  },
+  {
+    "name": "ExecutionPolicyAdapter",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface ExecutionPolicyAdapter {\n    readonly name: string;\n    canSatisfy(policy: ExecutionPolicy): boolean | PromiseLike<boolean>;\n    /** Token-only limitations are suitable for evidence and diagnostics. */\n    limitations(policy: ExecutionPolicy): readonly string[];\n}",
+    "doc": "/** An adapter that can prove whether it satisfies a contract's execution policy. */"
+  },
+  {
+    "name": "ExecutionPolicyAdapter",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ExecutionPolicyAdapter {\n    readonly name: string;\n    canSatisfy(policy: ExecutionPolicy): boolean | PromiseLike<boolean>;\n    /** Token-only limitations are suitable for evidence and diagnostics. */\n    limitations(policy: ExecutionPolicy): readonly string[];\n}",
+    "doc": "/** An adapter that can prove whether it satisfies a contract's execution policy. */"
+  },
   {
     "name": "exponentialBackoff",
     "kind": "function",
@@ -4018,6 +4545,43 @@
     "package": "@nifrajs/testing",
     "signature": "export interface FailureScenarioReport {\n    readonly name: string;\n    readonly ok: boolean;\n    readonly replay: FailureReplay;\n    readonly evidence: readonly FailureEvidence[];\n    /** Sanitized failure identity. Messages and stacks are deliberately excluded. */\n    readonly error?: {\n        readonly name: string;\n        readonly kind?: FailureInjectedError[\"kind\"];\n    };\n}"
   },
+  {
+    "name": "FaultProfile",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface FaultProfile {\n    readonly name: string;\n    readonly scenarios: readonly FaultProfileScenario[];\n    /** Optional trajectory faults consumed by the agent trajectory harness. */\n    readonly faults?: readonly FaultProfileFault[];\n    /** Existing deterministic failure-lab schedule shared by trajectory runs. */\n    readonly schedule?: readonly FailureDirective[];\n}",
+    "doc": "/** A named adapter profile composed from the deterministic failure laboratory. */"
+  },
+  {
+    "name": "FaultProfileFault",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface FaultProfileFault {\n    readonly point: \"model\" | \"tool\" | \"effect\";\n    readonly kind: FaultProfileFaultKind;\n    readonly occurrence?: number;\n}"
+  },
+  {
+    "name": "FaultProfileFaultKind",
+    "kind": "type",
+    "package": "@nifrajs/testing",
+    "signature": "export type FaultProfileFaultKind = \"tool-error\" | \"malformed-model-output\" | \"budget-pressure\" | \"approval-denial\" | \"cancellation\";"
+  },
+  {
+    "name": "FaultProfileReport",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface FaultProfileReport {\n    readonly name: string;\n    readonly ok: boolean;\n    readonly scenarios: readonly FaultProfileScenarioReport[];\n}"
+  },
+  {
+    "name": "FaultProfileScenario",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface FaultProfileScenario extends FailureScenario<unknown> {\n    readonly id: string;\n    readonly description: string;\n}"
+  },
+  {
+    "name": "FaultProfileScenarioReport",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface FaultProfileScenarioReport {\n    readonly id: string;\n    readonly description: string;\n    readonly ok: boolean;\n    readonly replay: FailureReplay;\n    readonly evidence: readonly FailureEvidence[];\n    readonly error?: {\n        readonly name: string;\n        readonly kind?: string;\n    };\n}"
+  },
   {
     "name": "FetchApp",
     "kind": "interface",
@@ -4086,6 +4650,13 @@
     "signature": "export type FetchFn = (input: string, init?: RequestInit) => Promise<Response>;",
     "doc": "/**\n * The fetch shape the client needs - looser than `typeof fetch` so an in-process bridge or a\n * test mock satisfies it without the extra members (`.preconnect`, overloads) of the global.\n */"
   },
+  {
+    "name": "FetchHandler",
+    "kind": "interface",
+    "package": "@nifrajs/aws-lambda",
+    "signature": "export interface FetchHandler {\n    fetch(request: Request, platform?: LambdaPlatform): Response | Promise<Response>;\n}",
+    "doc": "/** Anything with a fetch-shaped entry point - a nifra `server()` app satisfies this. */"
+  },
   {
     "name": "FetchHandler",
     "kind": "interface",
@@ -4175,6 +4746,12 @@
     "signature": "export declare const fixedBackoff: (ms: number) => Backoff;",
     "doc": "/** Fixed delay before every retry. */"
   },
+  {
+    "name": "FixRecipe",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface FixRecipe {\n    readonly id: string;\n    readonly description: string;\n    apply(root: string, diagnostic: Diagnostic): Promise<readonly string[]>;\n    readonly verify: string;\n}"
+  },
   {
     "name": "FontAsset",
     "kind": "interface",
@@ -4227,6 +4804,12 @@
     "package": "@nifrajs/core",
     "signature": "export interface ForbiddenCapabilityImport {\n    /** Exact module specifier, or a trailing `/*` prefix rule. */\n    readonly specifier: string;\n    readonly reason: string;\n}"
   },
+  {
+    "name": "formatAssuranceReport",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function formatAssuranceReport(report: AssuranceReport): string;"
+  },
   {
     "name": "formatBytes",
     "kind": "function",
@@ -4255,6 +4838,13 @@
     "signature": "export declare function formatServerOnlyLeak(findings: ReadonlyArray<ServerOnlyFinding>): string | undefined;",
     "doc": "/** The build-failing message for `server-only`-marked modules that reached the client. `undefined` ⇒ clean. */"
   },
+  {
+    "name": "formatStandardIssues",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function formatStandardIssues(issues: ReadonlyArray<StandardIssue>): string;",
+    "doc": "/** Format Standard Schema issues consistently across server and client contract diagnostics. */"
+  },
   {
     "name": "Formatter",
     "kind": "interface",
@@ -4335,6 +4925,12 @@
     "signature": "export declare function fromTypeBox<T extends TSchema>(schema: T, options?: {\n    readonly coerce?: boolean;\n}): NifraSchema<T>;",
     "doc": "/**\n * Wrap a TypeBox schema as a `NifraSchema`.\n *\n * **Validation is fast where it can be, and works everywhere.** The first `validate`\n * builds a compiled `TypeCompiler` validator (codegen via `new Function`) and memoizes\n * it - composing schemas (`t.object({ a: t.string() })`) never compiles the inner\n * pieces; only a schema actually used to validate a request pays the one-time codegen\n * cost. On Bun and Node this is the only path and it is untouched.\n *\n * Edge runtimes (Cloudflare Workers, Vercel Edge, Deno Deploy) **forbid dynamic code\n * generation**, so that first compile throws there. We catch it once per schema and\n * fall back to TypeBox's eval-free `Value` checker - same semantics (and same global\n * `FormatRegistry`, so `t.string({ format })` behaves identically), no `new Function`.\n * The branch is decided once and memoized, so the hot path is a single check either way.\n *\n * Exposed (not just used internally by `t`) so a TypeBox schema authored directly can\n * be adapted without leaving the Standard Schema world.\n *\n * `options.coerce` runs TypeBox's `Value.Convert` (string→number/integer/boolean, per the schema)\n * BEFORE validating. Query values always arrive as strings (`?limit=20` → `\"20\"`), so a query schema\n * with a numeric field can't validate without this - it's how `t.pageQuery` yields a real `number`.\n * Leave it OFF (the default) for body/JSON schemas: a JSON number is already a number, and coercing\n * would silently accept `\"20\"` where the contract said `20`.\n */"
   },
+  {
+    "name": "GateResult",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface GateResult {\n    readonly gate: \"check\" | \"doctor\" | \"render\" | \"hydration\" | \"contracts\" | \"size\" | \"tests\" | string;\n    readonly status: \"pass\" | \"fail\" | \"skip\";\n    readonly skipReason?: string;\n    readonly durationMs: number;\n    readonly diagnostics: readonly Diagnostic[];\n    readonly replay?: string;\n}"
+  },
   {
     "name": "Gauge",
     "kind": "class",
@@ -4392,7 +4988,7 @@
     "name": "generateServerEntry",
     "kind": "function",
     "package": "@nifrajs/web",
-    "signature": "export declare function generateServerEntry(options: {\n    readonly target: BuildTarget;\n    /** Import specifier for the module exporting `adapter` (e.g. `\"../framework.ts\"`). */\n    readonly adapterImport: string;\n    /** Import specifier for the module exporting `backend`, or `undefined` for a frontend-only app. */\n    readonly backendImport?: string;\n    /** Document `<title>` passed to `createWebApp`. */\n    readonly title?: string;\n    /** Encoded root-relative public file paths copied into the deploy directory. */\n    readonly publicFiles?: readonly string[];\n}): string;",
+    "signature": "export declare function generateServerEntry(options: {\n    readonly target: BuildTarget;\n    /** Import specifier for the module exporting `adapter` (e.g. `\"../framework.ts\"`). */\n    readonly adapterImport: string;\n    /** Import specifier for the module exporting `backend`, or `undefined` for a frontend-only app. */\n    readonly backendImport?: string;\n    /** Import specifier for the module exporting `use`, or `undefined`. Must resolve to the\n     * same edge-safe module as `adapterImport`. */\n    readonly useImport?: string;\n    /** Document `<title>` passed to `createWebApp`. */\n    readonly title?: string;\n    /** Encoded root-relative public file paths copied into the deploy directory. */\n    readonly publicFiles?: readonly string[];\n}): string;",
     "doc": "/**\n * Codegen the per-target **server entry** module (source text) for `buildServer` to bundle. It imports\n * the app's `adapter` (from `framework.ts`), the optional `backend` (from `backend.ts`), and the\n * generated `{ manifest, clientEntry }` (from `./server-manifest`), builds `createWebApp`, then wires\n * the right host:\n *   - `cf-pages` / `vercel`: `export default` the fetch handler (the platform serves /assets/* itself).\n *   - `deno`: same fetch-handler default, plus `Deno.serve` self-host when run directly.\n *   - `bun` / `node`: a self-hosting server that ALSO serves the client bundle from disk (those\n *     runtimes have a filesystem; the static `/assets/*` sit next to the entry).\n * `adapterImport`/`backendImport` are the specifiers the entry uses (relative to where it's written) -\n * `buildServer` writes the entry next to `serverEntry`, so they're resolved from there. Pure (string in,\n * string out) so the generation is unit-testable without a real build.\n */"
   },
   {
@@ -4443,6 +5039,12 @@
     "signature": "export declare function getContext<C extends Context = Context>(): C;",
     "doc": "/** Return the current request context, or throw when no context-storage wrapper is active. */"
   },
+  {
+    "name": "getFixRecipe",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function getFixRecipe(id: string): FixRecipe | undefined;"
+  },
   {
     "name": "getSession",
     "kind": "function",
@@ -4468,7 +5070,7 @@
     "name": "GoogleFontOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface GoogleFontOptions {\n    /** Family name exactly as Google lists it, e.g. `\"Inter\"`, `\"Open Sans\"`, `\"Roboto Mono\"`. */\n    readonly family: string;\n    /** Weights to request - numbers (`400`), numeric strings, a variable range (`\"100 900\"`), or the\n     * keywords `\"normal\"`/`\"bold\"`. Defaults to `[400]`. */\n    readonly weights?: readonly (number | string)[];\n    /** Styles to request. Defaults to `[\"normal\"]`. */\n    readonly styles?: readonly (\"normal\" | \"italic\")[];\n    /** Keep only these named subsets (`\"latin\"`, `\"latin-ext\"`, `\"cyrillic\"`, …). Google returns every\n     * subset it has as a separate `@font-face`; this filters to the ones you serve. Defaults to keeping\n     * all returned subsets. Ignored when {@link text} is set (glyph subsetting supersedes it). */\n    readonly subsets?: readonly string[];\n    /** `font-display` strategy for the generated faces. Defaults to `\"swap\"`. */\n    readonly display?: FontDisplay;\n    /** Glyph subsetting: request only the glyphs needed to render exactly this text (Google's `&text=`).\n     * Ideal for a logo/heading font - produces one tiny file. */\n    readonly text?: string;\n    /** CLS metric overrides forwarded to every generated `@font-face` (the layout-shift fix). */\n    readonly sizeAdjust?: string;\n    readonly ascentOverride?: string;\n    readonly descentOverride?: string;\n    readonly lineGapOverride?: string;\n}",
+    "signature": "export interface GoogleFontOptions {\n    /** Family name exactly as Google lists it, e.g. `\"Inter\"`, `\"Open Sans\"`, `\"Roboto Mono\"`. */\n    readonly family: string;\n    /** Weights to request - numbers (`400`), numeric strings, a variable range (`\"100..900\"`, the\n     * CSS-style `\"100 900\"` also accepted), or the keywords `\"normal\"`/`\"bold\"`. Defaults to `[400]`. */\n    readonly weights?: readonly (number | string)[];\n    /** Styles to request. Defaults to `[\"normal\"]`. */\n    readonly styles?: readonly (\"normal\" | \"italic\")[];\n    /** Keep only these named subsets (`\"latin\"`, `\"latin-ext\"`, `\"cyrillic\"`, …). Google returns every\n     * subset it has as a separate `@font-face`; this filters to the ones you serve. Defaults to keeping\n     * all returned subsets. Ignored when {@link text} is set (glyph subsetting supersedes it). */\n    readonly subsets?: readonly string[];\n    /** `font-display` strategy for the generated faces. Defaults to `\"swap\"`. */\n    readonly display?: FontDisplay;\n    /** Glyph subsetting: request only the glyphs needed to render exactly this text (Google's `&text=`).\n     * Ideal for a logo/heading font - produces one tiny file. */\n    readonly text?: string;\n    /** CLS metric overrides forwarded to every generated `@font-face` (the layout-shift fix). */\n    readonly sizeAdjust?: string;\n    readonly ascentOverride?: string;\n    readonly descentOverride?: string;\n    readonly lineGapOverride?: string;\n}",
     "doc": "/** Options describing the Google font to fetch + self-host. */"
   },
   {
@@ -4485,6 +5087,13 @@
     "signature": "export interface GuardOptions {\n    readonly redirectTo?: string;\n}",
     "doc": "/** What a guard does when the check fails: 302 to `redirectTo` (a same-origin path), or - omitted - a\n * 401 JSON (`{ ok: false, error: \"unauthorized\" }`). */"
   },
+  {
+    "name": "handle",
+    "kind": "function",
+    "package": "@nifrajs/aws-lambda",
+    "signature": "export declare function handle(app: FetchHandler, options?: LambdaOptions): (event: LambdaEvent, context?: LambdaContext) => Promise<LambdaResult>;",
+    "doc": "/**\n * A buffered Lambda handler for API Gateway HTTP APIs (payload v2) and Function URLs.\n *\n * ```ts\n * import { handle } from \"@nifrajs/aws-lambda\"\n * import { app } from \"./app.js\" // built once per container, at module scope\n *\n * export const handler = handle(app)\n * ```\n */"
+  },
   {
     "name": "handleMcpHttp",
     "kind": "function",
@@ -4538,7 +5147,7 @@
     "name": "healthcheck",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function healthcheck(options?: HealthcheckOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
+    "signature": "export declare function healthcheck(options?: HealthcheckOptions): IdentityPlugin;",
     "doc": "/**\n * Register **liveness** (`/health`) and **readiness** (`/ready`) endpoints. Liveness is a flat `200`\n * (the process is serving). Readiness runs each `check` and returns `200 { status: \"ok\", checks }`\n * when all pass, or `503 { status: \"error\", checks }` when any fail (a thrown check counts as failed).\n * Both are `Cache-Control: no-store`.\n *\n * Apply it **before** auth guards so the endpoints stay public (`beforeHandle` is order-scoped):\n *\n * ```ts\n * app.use(healthcheck({ checks: { db: () => db.ping() } })).use(bearer({ verify }))\n * ```\n */"
   },
   {
@@ -4589,6 +5198,13 @@
     "signature": "export type HtmlValue = string | number | bigint | boolean | null | undefined | Template | RawHtml | ReadonlyArray<HtmlValue>;",
     "doc": "/** What an interpolation may be: escaped primitives, nested templates/raw, arrays of the same.\n * `null`/`undefined`/`false` render as nothing (conditional rendering: `cond && html\\`…\\``). */"
   },
+  {
+    "name": "httpToolAdapter",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function httpToolAdapter<Input, Output>(tool: ToolContract<Input, Output>, baseOptions?: Omit<ToolCallOptions, \"signal\" | \"ledger\">): ToolAdapter;",
+    "doc": "/** Exercise the Web adapter while returning the same normalized result shape as direct calls. */"
+  },
   {
     "name": "hydrate",
     "kind": "function",
@@ -4600,8 +5216,7 @@
     "name": "hydrate",
     "kind": "function",
     "package": "@nifrajs/web-react",
-    "signature": "export declare function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown): void;",
-    "doc": "/** Hydrate a server-rendered React layout `chain` (with the loader `props`) inside `container`. */"
+    "signature": "export declare function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown, options?: HydrationAssuranceOptions): void;"
   },
   {
     "name": "hydrate",
@@ -4614,14 +5229,54 @@
     "name": "hydrate",
     "kind": "function",
     "package": "@nifrajs/web-svelte",
-    "signature": "export declare function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown): void;",
-    "doc": "/** Hydrate a server-rendered Svelte layout `chain` (with the loader `props`) inside `container`. */"
+    "signature": "export declare function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown, options?: HydrationAssuranceOptions): void;"
   },
   {
     "name": "hydrate",
     "kind": "function",
     "package": "@nifrajs/web-vue",
-    "signature": "export declare function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown): void;",
+    "signature": "export declare function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown, options?: HydrationAssuranceOptions): void;"
+  },
+  {
+    "name": "hydrationAssuranceHook",
+    "kind": "const",
+    "package": "@nifrajs/web-react",
+    "signature": "export declare const hydrationAssuranceHook: Readonly<{\n    framework: \"react\";\n    runtimeIdentity: () => object;\n}>;",
+    "doc": "/** Testing hook used by verification runners to observe React's recoverable errors and identity. */"
+  },
+  {
+    "name": "hydrationAssuranceHook",
+    "kind": "const",
+    "package": "@nifrajs/web-svelte",
+    "signature": "export declare const hydrationAssuranceHook: Readonly<{\n    framework: \"svelte\";\n    runtimeIdentity: () => object;\n}>;",
+    "doc": "/** Testing hook used by verification runners to observe Svelte warnings and identity. */"
+  },
+  {
+    "name": "hydrationAssuranceHook",
+    "kind": "const",
+    "package": "@nifrajs/web-vue",
+    "signature": "export declare const hydrationAssuranceHook: Readonly<{\n    framework: \"vue\";\n    runtimeIdentity: () => object;\n}>;",
+    "doc": "/** Testing hook used by verification runners to observe Vue warnings and identity. */"
+  },
+  {
+    "name": "HydrationAssuranceOptions",
+    "kind": "interface",
+    "package": "@nifrajs/web-react",
+    "signature": "export interface HydrationAssuranceOptions {\n    readonly onRecoverableError?: (error: unknown, info?: unknown) => void;\n}",
+    "doc": "/** Hydrate a server-rendered React layout `chain` (with the loader `props`) inside `container`. */"
+  },
+  {
+    "name": "HydrationAssuranceOptions",
+    "kind": "interface",
+    "package": "@nifrajs/web-svelte",
+    "signature": "export interface HydrationAssuranceOptions {\n    readonly onWarning?: (message: string) => void;\n}",
+    "doc": "/** Hydrate a server-rendered Svelte layout `chain` (with the loader `props`) inside `container`. */"
+  },
+  {
+    "name": "HydrationAssuranceOptions",
+    "kind": "interface",
+    "package": "@nifrajs/web-vue",
+    "signature": "export interface HydrationAssuranceOptions {\n    readonly onWarning?: (message: string) => void;\n}",
     "doc": "/** Hydrate a server-rendered Vue layout `chain` (with the loader `props`) inside `container`. */"
   },
   {
@@ -4694,7 +5349,8 @@
     "name": "idempotency",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function idempotency(options: IdempotencyOptions): Middleware;"
+    "signature": "export declare function idempotency(options: IdempotencyOptions): Middleware;",
+    "doc": "/**\n * Idempotency-key middleware. Apply with `app.use(idempotency({ store }))`.\n *\n * The store key is scoped by method + path **and** by a digest of the caller's credential headers, so\n * a key one caller chose addresses only that caller's entry - presenting someone else's key replays\n * nothing. See `principalHeaders`; a custom `key` replaces that scoping and must do it itself.\n *\n * **`Set-Cookie` is intentionally not cached or replayed** - a cookie set on the first request is\n * session-specific, so replaying it to a different caller (key collision or abuse) would leak/fixate a\n * session. Cache the body + status + the rest of the headers; let auth cookies re-issue per request.\n *\n * Caching buffers the response body, so apply this to JSON/API routes, not streaming SSR responses.\n */"
   },
   {
     "name": "IdempotencyAbandonInput",
@@ -4727,6 +5383,12 @@
     "package": "@nifrajs/core",
     "signature": "export interface IdempotencyCompletionInput extends IdempotencyEntryKey {\n    /** Opaque ownership token returned by `begin(state:\"new\")`. */\n    readonly reservation: string;\n    readonly response: StoredResponse;\n}"
   },
+  {
+    "name": "IdempotencyDivergence",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface IdempotencyDivergence {\n    readonly step: number;\n    readonly field: string;\n    readonly first: unknown;\n    readonly second: unknown;\n}"
+  },
   {
     "name": "IdempotencyEntryKey",
     "kind": "interface",
@@ -4738,7 +5400,7 @@
     "name": "IdempotencyOptions",
     "kind": "interface",
     "package": "@nifrajs/middleware",
-    "signature": "export interface IdempotencyOptions {\n    /** Where claims + cached responses live. `MemoryIdempotencyStore` for dev; a shared store in production. */\n    readonly store: IdempotencyStore;\n    /** Header carrying the key. Default `\"idempotency-key\"`. */\n    readonly header?: string;\n    /** Methods the guard applies to. Default `[\"POST\", \"PUT\", \"PATCH\", \"DELETE\"]` (unsafe methods). */\n    readonly methods?: readonly string[];\n    /** How long a completed response is replayable, in ms. Default 24h. */\n    readonly ttlMs?: number;\n    /** How long the in-flight lock survives a crashed handler, in ms. Default 60s. */\n    readonly lockTtlMs?: number;\n    /** Max response bytes to cache. A larger response is returned but **not** stored. Default 1 MiB. */\n    readonly maxBytes?: number;\n    /** Whether a response should be cached for replay. Default: status `< 500` (don't replay transient 5xx). */\n    readonly shouldCache?: (response: Response) => boolean;\n    /**\n     * Derive the store key from the request. Default: the `header` value **scoped by method + path**, so the\n     * same key on a different endpoint can't collide. Return a **principal-scoped** key (e.g.\n     * `` `${userId}:${req.headers.get(\"idempotency-key\")}` ``) so one user can't replay another's stored\n     * response on a shared key. Return `null`/`\"\"` to skip dedupe for this request.\n     */\n    readonly key?: (req: Request, header: string) => string | null;\n}"
+    "signature": "export interface IdempotencyOptions {\n    /** Where claims + cached responses live. `MemoryIdempotencyStore` for dev; a shared store in production. */\n    readonly store: IdempotencyStore;\n    /** Header carrying the key. Default `\"idempotency-key\"`. */\n    readonly header?: string;\n    /** Methods the guard applies to. Default `[\"POST\", \"PUT\", \"PATCH\", \"DELETE\"]` (unsafe methods). */\n    readonly methods?: readonly string[];\n    /** How long a completed response is replayable, in ms. Default 24h. */\n    readonly ttlMs?: number;\n    /** How long the in-flight lock survives a crashed handler, in ms. Default 60s. */\n    readonly lockTtlMs?: number;\n    /** Max response bytes to cache. A larger response is returned but **not** stored. Default 1 MiB. */\n    readonly maxBytes?: number;\n    /** Whether a response should be cached for replay. Default: status `< 500` (don't replay transient 5xx). */\n    readonly shouldCache?: (response: Response) => boolean;\n    /**\n     * Derive the store key from the request. Default: the `header` value scoped by method + path **and\n     * by a digest of the caller's credentials** (see `principalHeaders`), so neither a different\n     * endpoint nor a different caller can collide on one key. Return `null`/`\"\"` to skip dedupe for\n     * this request.\n     *\n     * Supplying your own replaces that scoping entirely - a custom key MUST fold in the principal\n     * itself (e.g. `` `${userId}:${req.headers.get(\"idempotency-key\")}` ``), or one user can replay\n     * another's stored response by guessing their key.\n     */\n    readonly key?: (req: Request, header: string) => string | null | Promise<string | null>;\n    /**\n     * Headers whose values identify the caller. Their digest scopes the default key, so the same\n     * `Idempotency-Key` from two callers addresses two entries and neither can read the other's cached\n     * response. Defaults to Authorization, Cookie, and x-api-key. Only a digest is stored - a raw\n     * credential must never become a store key, which would put it in front of every Redis `KEYS` dump\n     * and slow-log line. Ignored when `key` is supplied.\n     *\n     * The digest covers the header value verbatim, so anything that varies between two requests from the\n     * same caller - a rotated bearer token, an analytics cookie appended mid-session - lands on a fresh\n     * key and the retry executes again. Narrow the list (or supply `key`) when the app has a stable\n     * principal id to scope by; that is strictly better than digesting a whole `Cookie` header.\n     */\n    readonly principalHeaders?: readonly string[];\n}"
   },
   {
     "name": "IdempotencyPluginOptions",
@@ -4747,6 +5409,12 @@
     "signature": "export interface IdempotencyPluginOptions {\n    readonly store?: IdempotencyStore | undefined;\n}",
     "doc": "/**\n * Enable request idempotency. Routes that declare `schema.idempotency` get the dedupe lane: a repeat\n * `Idempotency-Key` replays the stored response instead of re-running the handler. Without this plugin,\n * declaring `schema.idempotency` is a registration error (the safety gate can never be silently\n * dropped). `store` is the app-wide default backing routes that do not pin their own; omit it for a\n * shared in-process store (development/tests only - inject a durable store in production).\n */"
   },
+  {
+    "name": "IdempotencyProof",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface IdempotencyProof {\n    readonly ok: boolean;\n    readonly divergences: readonly IdempotencyDivergence[];\n}"
+  },
   {
     "name": "IdempotencyRecord",
     "kind": "interface",
@@ -4781,6 +5449,12 @@
     "signature": "export interface IdempotencyStore {\n    /**\n     * Atomically claim `key`: `\"replay\"` if a completed response is stored, `\"in_flight\"` if another\n     * request holds the lock, else `\"new\"` (the caller now owns the lock and must `complete`/`release`).\n     * The in-flight lock expires after `lockTtlMs` so a crashed handler can't wedge the key forever.\n     */\n    begin(key: string, lockTtlMs: number): Promise<IdempotencyClaim>;\n    /** Store the completed response and release the lock (kept for `ttlMs`). */\n    complete(key: string, record: IdempotencyRecord, ttlMs: number): Promise<void>;\n    /** Release the lock without storing (handler errored / response not cacheable). */\n    release(key: string): Promise<void>;\n}",
     "doc": "/**\n * Store backing the idempotency guarantee. Production deploys MUST use a shared store so the key holds\n * across instances; `begin` MUST be **atomic** (e.g. Redis `SET key NX PX lockTtlMs`) or two concurrent\n * retries can both see `\"new\"`. {@link MemoryIdempotencyStore} is for dev / single-instance only.\n */"
   },
+  {
+    "name": "IdempotencyWorkload",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface IdempotencyWorkload {\n    readonly name: string;\n    readonly run: () => Promise<SealedEffectLedger> | SealedEffectLedger;\n}"
+  },
   {
     "name": "IDEMPOTENT_REPLAY_HEADER",
     "kind": "const",
@@ -4899,7 +5573,7 @@
     "name": "ImageHandlerOptions",
     "kind": "interface",
     "package": "@nifrajs/image",
-    "signature": "export interface ImageHandlerOptions {\n    /** Codec backend. Default: {@link bunImageBackend} (requires the Bun runtime). */\n    readonly backend?: ImageBackend;\n    /** Absolute directory that local (path) sources resolve under. Path-traversal- and symlink-guarded.\n     * Omit to **disable local sources** (every path source → 403). */\n    readonly root?: string;\n    /** Exact origins (`https://cdn.example`) allowed for remote sources. Omitted/empty ⇒ **no remote\n     * sources** (fail-closed against SSRF). Only `http:`/`https:` URLs are ever considered. */\n    readonly allowedOrigins?: readonly string[];\n    /** Max bytes read from a source before rejecting (413). Default 20 MiB. */\n    readonly maxSourceBytes?: number;\n    /** Max source pixels (w×h) before rejecting (413) - decompression-bomb guard. Default 40 MP. */\n    readonly maxSourcePixels?: number;\n    /** Hard cap on the requested width; larger `?w` is clamped down. Default 3840. */\n    readonly maxWidth?: number;\n    /** Max concurrent transforms (codec work is CPU/memory-heavy). Excess requests queue. Default 4. */\n    readonly concurrency?: number;\n    /** `Cache-Control: public, max-age=<n>, immutable` seconds. Default 1 year. */\n    readonly cacheMaxAge?: number;\n    /** Quality used when `?q` is absent. Default 75. */\n    readonly defaultQuality?: number;\n    /** Remote-fetch timeout (ms). Default 10 000. */\n    readonly fetchTimeoutMs?: number;\n    /** `fetch` implementation for remote sources (injectable for custom timeouts/proxy and for tests).\n     * Default: the global `fetch`. */\n    readonly fetch?: typeof fetch;\n    /** Require **signed URLs**: every request must carry a valid `&s=` HMAC over `(src, w, q[, exp])` or\n     * it's rejected with `403`. Use the SAME `secret` as your `selfHostedLoader`/`signImageUrl`. This\n     * locks the endpoint to URLs your app minted - the defense against resize-bombing. */\n    readonly signing?: {\n        readonly secret: string;\n    };\n}"
+    "signature": "export interface ImageHandlerOptions {\n    /** Codec backend. Default: {@link bunImageBackend} (requires the Bun runtime). */\n    readonly backend?: ImageBackend;\n    /** Absolute directory that local (path) sources resolve under. Path-traversal- and symlink-guarded.\n     * Omit to **disable local sources** (every path source → 403). */\n    readonly root?: string;\n    /** Exact origins (`https://cdn.example`) allowed for remote sources. Omitted/empty ⇒ **no remote\n     * sources** (fail-closed against SSRF). Only `http:`/`https:` URLs are ever considered. */\n    readonly allowedOrigins?: readonly string[];\n    /** Max bytes read from a source before rejecting (413). Default 20 MiB. */\n    readonly maxSourceBytes?: number;\n    /** Max source pixels (w×h) before rejecting (413) - decompression-bomb guard. Default 40 MP. */\n    readonly maxSourcePixels?: number;\n    /** Hard cap on the requested width; larger `?w` is clamped down. Default 3840. */\n    readonly maxWidth?: number;\n    /** Max concurrent transforms (codec work is CPU/memory-heavy). Excess requests queue. Default 4. */\n    readonly concurrency?: number;\n    /**\n     * Max requests reading a source at once - the admission width. Sized above `concurrency` on purpose:\n     * a remote source is network-bound, and holding a codec slot across a 10s fetch would let a handful\n     * of slow origins idle the CPU lane out entirely. Default `concurrency * 2`.\n     *\n     * This is also the memory bound: at most this many source buffers exist at once, so the ceiling is\n     * `sourceConcurrency * maxSourceBytes` (default 8 x 20 MiB = 160 MiB) plus the codec's own working\n     * set. Lower it, or `maxSourceBytes`, on a small instance.\n     */\n    readonly sourceConcurrency?: number;\n    /** Maximum queued image requests beyond the admission width. Default `concurrency * 16`. */\n    readonly maxQueue?: number;\n    /** `Cache-Control: public, max-age=<n>, immutable` seconds. Default 1 year. */\n    readonly cacheMaxAge?: number;\n    /** Quality used when `?q` is absent. Default 75. */\n    readonly defaultQuality?: number;\n    /** Remote-fetch timeout (ms). Default 10 000. */\n    readonly fetchTimeoutMs?: number;\n    /** `fetch` implementation for remote sources (injectable for custom timeouts/proxy and for tests).\n     * Default: the global `fetch`. */\n    readonly fetch?: typeof fetch;\n    /** Require **signed URLs**: every request must carry a valid `&s=` HMAC over `(src, w, q[, exp])` or\n     * it's rejected with `403`. Use the SAME `secret` as your `selfHostedLoader`/`signImageUrl`. This\n     * locks the endpoint to URLs your app minted - the defense against resize-bombing. */\n    readonly signing?: {\n        readonly secret: string;\n    };\n}"
   },
   {
     "name": "ImageInfo",
@@ -4941,6 +5615,12 @@
     "signature": "export interface ImageReencoder {\n    probe(bytes: Uint8Array): Promise<{\n        readonly width: number;\n        readonly height: number;\n        readonly format: string;\n    }>;\n    transform(input: {\n        readonly bytes: Uint8Array;\n        readonly width: number;\n        readonly quality: number;\n        readonly format: StripFormat;\n    }): Promise<{\n        readonly bytes: Uint8Array;\n    }>;\n}",
     "doc": "/** The slice of `@nifrajs/image`'s `ImageBackend` this needs - `probe` for dims/format, `transform` to re-encode. */"
   },
+  {
+    "name": "ImpactReport",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface ImpactReport {\n    readonly changedFiles: readonly string[];\n    readonly impactedNodes: readonly string[];\n    readonly impactedRoutes: readonly string[];\n}"
+  },
   {
     "name": "implement",
     "kind": "function",
@@ -5050,8 +5730,7 @@
     "name": "inProcessClient",
     "kind": "function",
     "package": "@nifrajs/client",
-    "signature": "export declare function inProcessClient<App extends {\n    fetch(request: Request): Response | Promise<Response>;\n}>(app: App, options?: InProcessClientOptions): InProcessClient<App>;",
-    "doc": "/**\n * A {@link client} whose `fetch` calls a nifra app's own `fetch` in-process - no network, full\n * lifecycle (validation, middleware, contracts). For SSR loaders. Typed from `App` exactly like\n * the network client. The `(url, init) → Request` bridge is required because the client calls\n * `fetch(url, init)` while `app.fetch` takes a `Request`.\n *\n * The returned proxy also implements the explicit symbol-keyed {@link BackendMount} interface, so\n * `createWebApp({ api: inProcessClient(backend) })` can auto-mount the backend while forwarding the\n * outer runtime's `env` and `waitUntil`.\n */"
+    "signature": "export declare function inProcessClient<App extends {\n    fetch(request: Request): Response | Promise<Response>;\n}>(app: App, options?: InProcessClientOptions): InProcessClient<App>;"
   },
   {
     "name": "InProcessClient",
@@ -5066,6 +5745,18 @@
     "package": "@nifrajs/client",
     "signature": "export interface InProcessClientOptions extends Omit<ClientOptions, \"fetch\"> {\n    /**\n     * Assert every JSON response against the route's declared contract - `schema.response` for 2xx,\n     * `schema.errors[status]` for declared failures - and THROW on mismatch, so a handler whose real\n     * output drifts from its schema fails the test instead of passing silently. Statuses with no\n     * declared schema, non-JSON bodies, and 204/205/HEAD pass through unchecked. Test-focused: the\n     * check parses a clone of each JSON body, a cost that belongs in tests, not production hot paths.\n     */\n    readonly validateResponses?: boolean;\n}"
   },
+  {
+    "name": "inProcessToolAdapter",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function inProcessToolAdapter<Input, Output>(tool: ToolContract<Input, Output>, baseOptions?: ToolCallOptions): ToolAdapter;"
+  },
+  {
+    "name": "inspectBuildFreshness",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function inspectBuildFreshness(cwd: string): Promise<BuildFreshness>;"
+  },
   {
     "name": "installForms",
     "kind": "function",
@@ -5467,7 +6158,7 @@
     "name": "JwtPlugin",
     "kind": "type",
     "package": "@nifrajs/middleware",
-    "signature": "export type JwtPlugin<C extends JwtClaims = JwtClaims> = NifraPlugin & {\n    claims(request: Request): C | null;\n    requireClaims(request: Request): C;\n};"
+    "signature": "export type JwtPlugin<C extends JwtClaims = JwtClaims> = IdentityPlugin & {\n    claims(request: Request): C | null;\n    requireClaims(request: Request): C;\n};"
   },
   {
     "name": "JwtVerificationKey",
@@ -5509,6 +6200,27 @@
     "signature": "export declare class KVSessionStore implements SessionStore {\n    private readonly kv;\n    constructor(kv: KVNamespaceLike);\n    get(id: string): Promise<SessionRecord | undefined>;\n    set(id: string, record: SessionRecord): Promise<void>;\n    delete(id: string): Promise<void>;\n}",
     "doc": "/**\n * A {@link SessionStore} backed by a **Cloudflare Workers KV** namespace (or any {@link KVNamespaceLike})\n * - the durable, shared production store: sessions hold across worker instances and survive restarts.\n * Records serialize to JSON; the entry's KV `expiration` is set from the record's `expiresAt` so KV\n * auto-evicts the session (a GC backstop - the manager still authoritatively checks expiry on read).\n * Every read is validated, so a corrupt/skewed entry reads as no session.\n */"
   },
+  {
+    "name": "LambdaContext",
+    "kind": "interface",
+    "package": "@nifrajs/aws-lambda",
+    "signature": "export interface LambdaContext {\n    readonly awsRequestId?: string;\n    readonly functionName?: string;\n    readonly [key: string]: unknown;\n}",
+    "doc": "/** The Lambda invocation context. The adapter only forwards it; declare fields structurally. */"
+  },
+  {
+    "name": "LambdaEnv",
+    "kind": "interface",
+    "package": "@nifrajs/aws-lambda",
+    "signature": "export interface LambdaEnv {\n    readonly event: LambdaEvent;\n    readonly context: LambdaContext | undefined;\n}",
+    "doc": "/** What handlers see as `c.env` (declare your app as `server<LambdaEnv>()` for typed access). */"
+  },
+  {
+    "name": "LambdaEvent",
+    "kind": "interface",
+    "package": "@nifrajs/aws-lambda",
+    "signature": "export interface LambdaEvent {\n    readonly rawPath?: string;\n    readonly rawQueryString?: string;\n    readonly headers?: Readonly<Record<string, string | undefined>>;\n    /** Payload v2 delivers cookies here, not in `headers` - this array is the canonical source. */\n    readonly cookies?: readonly string[];\n    readonly body?: string | null;\n    readonly isBase64Encoded?: boolean;\n    readonly requestContext?: {\n        readonly domainName?: string;\n        readonly http?: {\n            readonly method?: string;\n            readonly sourceIp?: string;\n        };\n    };\n}",
+    "doc": "/**\n * The slice of an API Gateway HTTP API / Function URL payload-v2 event the adapter reads.\n * Extra fields pass through untouched on `c.env.event`.\n */"
+  },
   {
     "name": "LambdaEvent",
     "kind": "type",
@@ -5533,6 +6245,19 @@
     "package": "nifra",
     "signature": "export type LambdaHandler = (event: LambdaEvent, context?: unknown) => Promise<LambdaResponse>;"
   },
+  {
+    "name": "LambdaOptions",
+    "kind": "interface",
+    "package": "@nifrajs/aws-lambda",
+    "signature": "export interface LambdaOptions {\n    /**\n     * Reject request bodies whose *decoded* size exceeds this many bytes with a flat 413 before a\n     * `Request` is constructed. Defaults to 1,000,000 (nifra core's default). Set it to match your\n     * app's `maxBodyBytes` if you customized that.\n     */\n    readonly maxBodyBytes?: number;\n}"
+  },
+  {
+    "name": "LambdaPlatform",
+    "kind": "interface",
+    "package": "@nifrajs/aws-lambda",
+    "signature": "export interface LambdaPlatform {\n    readonly env: LambdaEnv;\n    readonly clientIp?: string | undefined;\n    readonly waitUntil?: (promise: Promise<unknown>) => void;\n}",
+    "doc": "/** Platform fields the adapter feeds into `app.fetch` (mirrors nifra core's `Platform`). */"
+  },
   {
     "name": "LambdaResponse",
     "kind": "type",
@@ -5545,6 +6270,13 @@
     "package": "nifra",
     "signature": "export type LambdaResponse = PlatformResponse;"
   },
+  {
+    "name": "LambdaResult",
+    "kind": "interface",
+    "package": "@nifrajs/aws-lambda",
+    "signature": "export interface LambdaResult {\n    statusCode: number;\n    headers: Record<string, string>;\n    /** `Set-Cookie` values travel here (payload v2), one entry per cookie - never comma-joined. */\n    cookies?: string[];\n    body: string;\n    isBase64Encoded: boolean;\n}",
+    "doc": "/** A payload-v2 result object, as API Gateway and Function URLs consume it. */"
+  },
   {
     "name": "LambdaV1Event",
     "kind": "interface",
@@ -5573,8 +6305,8 @@
     "name": "language",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function language<const L extends readonly string[]>(options: LanguageOptions<L>): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").Server<any, any>>;",
-    "doc": "/**\n * Derives `c.language` from `Accept-Language` and emits `Content-Language` by default.\n */"
+    "signature": "export declare function language<const L extends readonly string[]>(options: LanguageOptions<L>): ContextPlugin<{\n    language: L[number];\n    languageMatch: LanguageMatch;\n}>;",
+    "doc": "/**\n * Derives `c.language` from `Accept-Language` and emits `Content-Language` by default.\n *\n * Header-only by design. For the full detector - `?lang=` query parameter → cookie →\n * `Accept-Language`, with optional cookie persistence - use `localeDetector()` from\n * `@nifrajs/i18n/detector`; use one or the other, not both.\n */"
   },
   {
     "name": "LanguageMatch",
@@ -5600,7 +6332,7 @@
     "kind": "const",
     "package": "@nifrajs/web",
     "signature": "export declare const LAYOUT_DATA_GLOBAL = \"__NIFRA_LAYOUT_DATA__\";",
-    "doc": "/** Per-layout loader data for hydration. Emitted ONLY when some layout in the chain has a loader, so\n * a page-only app's HTML is byte-identical to before layout loaders existed. */"
+    "doc": "/** Per-layout loader data for hydration. */"
   },
   {
     "name": "LayoutEntry",
@@ -5623,6 +6355,20 @@
     "signature": "export type LedgerSink = (ledger: SealedEffectLedger) => void | Promise<void>;",
     "doc": "/**\n * Receives each sealed ledger once per request (only when it has entries). Implementations must not\n * assume a payload: the ledger is token-only. A durable/tenant-scoped sink lives behind this seam.\n */"
   },
+  {
+    "name": "LegacyContractReplayFile",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface LegacyContractReplayFile {\n    readonly seed: number;\n    readonly caseId: string;\n    readonly runtime: string;\n}",
+    "doc": "/** Existing adversarial contract replay metadata. Kept as a compatibility envelope. */"
+  },
+  {
+    "name": "LegacyFailureReplayFile",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface LegacyFailureReplayFile {\n    readonly seed: number;\n    readonly schedule: readonly Record<string, unknown>[];\n}",
+    "doc": "/** Existing deterministic failure-lab replay metadata. Kept as a compatibility envelope. */"
+  },
   {
     "name": "Link",
     "kind": "const",
@@ -5644,12 +6390,24 @@
     "signature": "export interface LinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, \"href\"> {\n    /** Same-origin destination path (e.g. `/users/7?tab=posts`). Rendered as the `<a href>`. */\n    readonly to: string;\n    /** Replace the current history entry instead of pushing. */\n    readonly replace?: boolean;\n}",
     "doc": "/** {@link Link} props: every `<a>` attribute except `href` (set from `to`), plus `to` + `replace`. */"
   },
+  {
+    "name": "listFixRecipes",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function listFixRecipes(): readonly FixRecipe[];"
+  },
   {
     "name": "ListOptions",
     "kind": "interface",
     "package": "@nifrajs/storage",
     "signature": "export interface ListOptions {\n    /** Only keys starting with this prefix. */\n    readonly prefix?: string;\n    /** Cap the number of keys returned. */\n    readonly limit?: number;\n}"
   },
+  {
+    "name": "loadAssuranceConfig",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function loadAssuranceConfig(cwd: string, configPath?: string): Promise<AssuranceConfig>;"
+  },
   {
     "name": "Loader",
     "kind": "type",
@@ -5697,12 +6455,83 @@
     "package": "@nifrajs/web",
     "signature": "export interface LoadGoogleFontResult {\n    readonly family: string;\n    /** A self-hosted `@font-face` stylesheet (one rule per written file). Import it from your app. */\n    readonly css: string;\n    /** Every file written to `outDir`. */\n    readonly assets: readonly FontAsset[];\n    /** `fontPreload()` link-attribute sets - spread the ones you want into a layout's `meta.link`.\n     * Preloading *every* weight/subset is wasteful; usually preload just the primary subset + weight. */\n    readonly preloads: readonly LinkDescriptor[];\n}"
   },
+  {
+    "name": "LOCAL_PROCESS_LIMITATION",
+    "kind": "const",
+    "package": "@nifrajs/agent",
+    "signature": "export declare const LOCAL_PROCESS_LIMITATION = \"The local adapter is NOT a security boundary.\";",
+    "doc": "/** This statement is intentionally repeated in the API and runtime result. */"
+  },
   {
     "name": "Locale",
     "kind": "type",
     "package": "@nifrajs/i18n",
     "signature": "export type Locale = string;",
-    "doc": "/**\n * Locale negotiation - pick the best supported locale for a request, from (in priority order) an\n * explicit cookie, then the `Accept-Language` header (quality-ranked, with a base-tag fallback so\n * `fr-CA` matches a supported `fr`). Pure + runtime-agnostic.\n */"
+    "doc": "/**\n * Locale negotiation - pick the best supported locale for a request, from (in priority order) an\n * explicit query parameter, then a cookie, then the `Accept-Language` header (quality-ranked, with\n * a base-tag fallback so `fr-CA` matches a supported `fr`). Pure + runtime-agnostic. The result is\n * always a member of the configured `locales` allow-list (or `defaultLocale`): request input is\n * *matched against* the list, never echoed back - so a hostile `?lang=` or header value cannot\n * reach the response. Parsing is split-based and linear; no regex runs on request input.\n */"
+  },
+  {
+    "name": "LocaleContext",
+    "kind": "interface",
+    "package": "@nifrajs/i18n",
+    "signature": "export interface LocaleContext {\n    /** The negotiated locale - always one of the configured `locales`. */\n    readonly locale: Locale;\n    readonly localeSource: LocaleSource;\n}",
+    "doc": "/** Context added by {@link localeDetector}. */"
+  },
+  {
+    "name": "localeDetector",
+    "kind": "function",
+    "package": "@nifrajs/i18n",
+    "signature": "export declare function localeDetector(options: LocaleDetectorOptions): import(\"@nifrajs/core\").ContextPlugin<LocaleContext>;",
+    "doc": "/**\n * Detect the request's locale and expose it as `c.locale` / `c.localeSource`.\n *\n * ```ts\n * import { localeDetector } from \"@nifrajs/i18n/detector\"\n *\n * app.use(\n *   localeDetector({\n *     locales: [\"en\", \"fr\", \"de\"],\n *     defaultLocale: \"en\",\n *     queryParam: \"lang\",\n *     cookie: \"locale\",\n *     persist: true,\n *   }),\n * ).get(\"/\", (c) => c.json({ locale: c.locale }))\n * ```\n */"
+  },
+  {
+    "name": "LocaleDetectorOptions",
+    "kind": "interface",
+    "package": "@nifrajs/i18n",
+    "signature": "export interface LocaleDetectorOptions extends NegotiateOptions {\n    /** Persist a `queryParam` choice into the locale cookie when it differs from the cookie's current\n     * value. Requires both `queryParam` and `cookie`. Default `false`. */\n    readonly persist?: boolean;\n    /** `Max-Age` (seconds) of the persisted cookie. Default one year. */\n    readonly cookieMaxAge?: number;\n    /** Emit `Content-Language` (kept if already set by the handler). Default `true`. */\n    readonly header?: boolean;\n}"
+  },
+  {
+    "name": "LocaleParts",
+    "kind": "interface",
+    "package": "@nifrajs/i18n",
+    "signature": "export interface LocaleParts {\n    readonly header: (name: string) => string | null;\n    readonly url?: string;\n    readonly query?: URLSearchParams;\n}",
+    "doc": "/**\n * The slice of a request the negotiation reads. Pass a `Request`, or this structural shape where no\n * `Request` object exists (e.g. inside an `onResponseHeaders` hook, which sees only `url` +\n * `header`). `query`/`url` are consulted only when `queryParam` is configured; an already-parsed\n * `query` is preferred over slicing `url`.\n */"
+  },
+  {
+    "name": "LocaleSource",
+    "kind": "type",
+    "package": "@nifrajs/i18n",
+    "signature": "export type LocaleSource = \"query\" | \"cookie\" | \"header\" | \"default\";",
+    "doc": "/** Which source produced the locale, in priority order. */"
+  },
+  {
+    "name": "LocalProcessAdapter",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface LocalProcessAdapter extends ExecutionPolicyAdapter {\n    run(request: LocalProcessRequest): Promise<LocalProcessResult>;\n}"
+  },
+  {
+    "name": "LocalProcessAdapterOptions",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface LocalProcessAdapterOptions {\n    readonly cwd?: string;\n    /** Only these inherited environment names are copied. Default: PATH, LANG, and LC_ALL. */\n    readonly envAllowlist?: readonly string[];\n    readonly maxOutputBytes?: number;\n}"
+  },
+  {
+    "name": "LocalProcessPolicyError",
+    "kind": "class",
+    "package": "@nifrajs/agent",
+    "signature": "export declare class LocalProcessPolicyError extends Error {\n    readonly code: \"policy_unsatisfied\" | \"invalid_request\" | \"cancelled\";\n    constructor(code: \"policy_unsatisfied\" | \"invalid_request\" | \"cancelled\");\n}"
+  },
+  {
+    "name": "LocalProcessRequest",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface LocalProcessRequest {\n    readonly command: string;\n    readonly args?: readonly string[];\n    readonly cwd?: string;\n    readonly env?: Readonly<Record<string, string | undefined>>;\n    readonly capability?: string;\n    readonly policy: ExecutionPolicy;\n    readonly signal?: AbortSignal;\n}"
+  },
+  {
+    "name": "LocalProcessResult",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface LocalProcessResult {\n    readonly ok: boolean;\n    readonly exitCode: number | null;\n    readonly signal?: string;\n    readonly stdout: string;\n    readonly stderr: string;\n    readonly timedOut: boolean;\n    readonly cancelled: boolean;\n    readonly limitations: readonly string[];\n}"
   },
   {
     "name": "Location",
@@ -5729,8 +6558,8 @@
     "name": "logger",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function logger(options?: LoggerOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
-    "doc": "/**\n * A {@link definePlugin} plugin that logs one structured line per request - method, path, status,\n * and duration - via `onRequest`/`onResponse` (so it covers 404s and errors too). The start time is\n * paired to the request through a `WeakMap` (no per-request allocation leak). Idempotent.\n */"
+    "signature": "export declare function logger(options?: LoggerOptions): IdentityPlugin;",
+    "doc": "/**\n * A {@link defineIdentityPlugin} plugin that logs one structured line per request - method, path,\n * status, and duration - via `onRequest`/`onResponse` (so it covers 404s and errors too). The start\n * time is paired to the request through a `WeakMap` (no per-request allocation leak). Idempotent.\n *\n * It adds no context and registers no routes, so it is type-identity: routes declared after\n * `.use(logger())` keep their types. (Under `definePlugin` they would not - see that helper's\n * FOOTGUN note.)\n */"
   },
   {
     "name": "Logger",
@@ -5796,7 +6625,7 @@
     "name": "matchesAssuranceSelector",
     "kind": "function",
     "package": "@nifrajs/core",
-    "signature": "export declare function matchesAssuranceSelector(route: Pick<ReflectedRoute, \"method\" | \"path\" | \"tool\" | \"capabilities\">, selector: AssuranceRouteSelector, definitions?: ReadonlyMap<string, CapabilityDefinition>): boolean;",
+    "signature": "export declare function matchesAssuranceSelector(route: Pick<ReflectedRoute, \"method\" | \"path\" | \"tool\" | \"capabilities\" | \"classification\">, selector: AssuranceRouteSelector, definitions?: ReadonlyMap<string, CapabilityDefinition>): boolean;",
     "doc": "/**\n * Shared selector semantics for policy rules and framework adapters.\n *\n * `definitions` is only consulted by the `access`/`zone` selectors; every other selector reads\n * reflection alone. A caller that omits it while the selector needs it gets no match, so callers that\n * accept user policy must reject that combination up front - `defineAssuranceConfig` does.\n */"
   },
   {
@@ -5845,7 +6674,7 @@
     "name": "MCP_ERROR",
     "kind": "const",
     "package": "@nifrajs/mcp",
-    "signature": "export declare const MCP_ERROR: {\n    readonly HEADER_MISMATCH: -32020;\n    readonly UNSUPPORTED_VERSION: -32022;\n};",
+    "signature": "export declare const MCP_ERROR: {\n    readonly HEADER_MISMATCH: -32020;\n    readonly UNSUPPORTED_VERSION: -32022;\n    /** Rejected by `authorizeMessage`. In JSON-RPC's implementation-defined server-error band\n     * (-32099..-32000), unlike a code in the -326xx range, which is reserved for the spec's own use. */\n    readonly UNAUTHORIZED: -32001;\n};",
     "doc": "/** MCP-reserved JSON-RPC error codes (2026-07-28 error-code policy carves out -32020..-32099 for the spec). */"
   },
   {
@@ -5906,13 +6735,13 @@
     "name": "McpHttpOptions",
     "kind": "interface",
     "package": "@nifrajs/cli",
-    "signature": "export interface McpHttpOptions {\n    /** Maximum JSON-RPC request body size in bytes. Default 1 MB. */\n    readonly maxBodyBytes?: number;\n    /** Resources / prompts / the MCP Apps UI extension served alongside the tools. */\n    readonly features?: McpServerFeatures;\n    /** Shown on the GET health page so each host can describe itself. */\n    readonly health?: string;\n    /**\n     * Origin allowlist for the DNS-rebinding guard. Omit (the default) to allow any origin - the right\n     * choice for a public, unauthenticated docs server that can't enumerate its browser clients' origins.\n     * Set it (e.g. a localhost origin for a hardened local host) to reject any other browser origin with 403.\n     */\n    readonly allowedOrigins?: readonly string[];\n}"
+    "signature": "export interface McpHttpOptions {\n    /** Maximum JSON-RPC request body size in bytes. Default 1 MB. */\n    readonly maxBodyBytes?: number;\n    /** Resources / prompts / the MCP Apps UI extension served alongside the tools. */\n    readonly features?: McpServerFeatures;\n    /** Shown on the GET health page so each host can describe itself. */\n    readonly health?: string;\n    /**\n     * Origin allowlist for the DNS-rebinding guard. Omit (the default) to allow any origin - the right\n     * choice for a public, unauthenticated docs server that can't enumerate its browser clients' origins.\n     * Set it (e.g. a localhost origin for a hardened local host) to reject any other browser origin with 403.\n     */\n    readonly allowedOrigins?: readonly string[];\n    /**\n     * Optional authorization, run once per request against the parsed message - after the body has been\n     * read under the size cap, so it never costs a second read of the stream. Returning `false` answers\n     * `403` with a JSON-RPC error (`MCP_ERROR.UNAUTHORIZED`) and the handler never sees the message.\n     */\n    readonly authorizeMessage?: (message: JsonRpcRequest, request: Request) => boolean | Promise<boolean>;\n}"
   },
   {
     "name": "McpHttpOptions",
     "kind": "interface",
     "package": "@nifrajs/mcp",
-    "signature": "export interface McpHttpOptions {\n    /** Maximum JSON-RPC request body size in bytes. Default 1 MB. */\n    readonly maxBodyBytes?: number;\n    /** Resources / prompts / the MCP Apps UI extension served alongside the tools. */\n    readonly features?: McpServerFeatures;\n    /** Shown on the GET health page so each host can describe itself. */\n    readonly health?: string;\n    /**\n     * Origin allowlist for the DNS-rebinding guard. Omit (the default) to allow any origin - the right\n     * choice for a public, unauthenticated docs server that can't enumerate its browser clients' origins.\n     * Set it (e.g. a localhost origin for a hardened local host) to reject any other browser origin with 403.\n     */\n    readonly allowedOrigins?: readonly string[];\n}"
+    "signature": "export interface McpHttpOptions {\n    /** Maximum JSON-RPC request body size in bytes. Default 1 MB. */\n    readonly maxBodyBytes?: number;\n    /** Resources / prompts / the MCP Apps UI extension served alongside the tools. */\n    readonly features?: McpServerFeatures;\n    /** Shown on the GET health page so each host can describe itself. */\n    readonly health?: string;\n    /**\n     * Origin allowlist for the DNS-rebinding guard. Omit (the default) to allow any origin - the right\n     * choice for a public, unauthenticated docs server that can't enumerate its browser clients' origins.\n     * Set it (e.g. a localhost origin for a hardened local host) to reject any other browser origin with 403.\n     */\n    readonly allowedOrigins?: readonly string[];\n    /**\n     * Optional authorization, run once per request against the parsed message - after the body has been\n     * read under the size cap, so it never costs a second read of the stream. Returning `false` answers\n     * `403` with a JSON-RPC error (`MCP_ERROR.UNAUTHORIZED`) and the handler never sees the message.\n     */\n    readonly authorizeMessage?: (message: JsonRpcRequest, request: Request) => boolean | Promise<boolean>;\n}"
   },
   {
     "name": "mcpJson",
@@ -5983,7 +6812,7 @@
     "name": "McpServer",
     "kind": "interface",
     "package": "@nifrajs/mcp",
-    "signature": "export interface McpServer {\n    readonly tools: McpTool[];\n    readonly features: McpServerFeatures;\n    readonly serverInfo: {\n        name: string;\n        version: string;\n    };\n    /** Web `fetch` handler - mount at `POST /mcp` (GET is a health page, OPTIONS the CORS preflight). */\n    fetch(request: Request): Promise<Response>;\n    /** Dispatch one JSON-RPC message directly (no HTTP) - for headless verification and unit tests. */\n    handle(message: JsonRpcRequest): Promise<JsonRpcResponse | null>;\n}"
+    "signature": "export interface McpServer {\n    readonly tools: McpTool[];\n    readonly features: McpServerFeatures;\n    readonly serverInfo: {\n        name: string;\n        version: string;\n    };\n    /** Web `fetch` handler - mount at `POST /mcp` (GET is a health page, OPTIONS the CORS preflight). */\n    fetch(request: Request, overrides?: Pick<McpHttpOptions, \"authorizeMessage\">): Promise<Response>;\n    /** Dispatch one JSON-RPC message directly (no HTTP) - for headless verification and unit tests. */\n    handle(message: JsonRpcRequest): Promise<JsonRpcResponse | null>;\n}"
   },
   {
     "name": "McpServerConfig",
@@ -5996,7 +6825,7 @@
     "name": "McpServerFeatures",
     "kind": "interface",
     "package": "@nifrajs/mcp",
-    "signature": "export interface McpServerFeatures {\n    readonly resources?: readonly McpResource[];\n    readonly prompts?: readonly McpPrompt[];\n    /** Advertise the MCP Apps UI extension in `initialize`. Present when the server serves `ui://` widgets;\n     * `mimeTypes` defaults to `[UI_MIME]`. */\n    readonly ui?: {\n        readonly mimeTypes?: readonly string[];\n    };\n    /** Natural-language guidance for LLMs on how to use this server. Surfaced in the modern\n     * `server/discover` result (2026-07-28); legacy `initialize` does not carry it. */\n    readonly instructions?: string;\n}"
+    "signature": "export interface McpServerFeatures {\n    readonly resources?: readonly McpResource[];\n    readonly prompts?: readonly McpPrompt[];\n    /** Advertise the MCP Apps UI extension in `initialize`. Present when the server serves `ui://` widgets;\n     * `mimeTypes` defaults to `[UI_MIME]`. */\n    readonly ui?: {\n        readonly mimeTypes?: readonly string[];\n    };\n    /** Natural-language guidance for LLMs on how to use this server. Surfaced in the modern\n     * `server/discover` result (2026-07-28) and in the legacy `initialize` result (`instructions` is an\n     * optional field of that result in every handshake-era revision this server speaks). */\n    readonly instructions?: string;\n}"
   },
   {
     "name": "McpTool",
@@ -6004,6 +6833,12 @@
     "package": "@nifrajs/mcp",
     "signature": "export interface McpTool {\n    readonly name: string;\n    readonly description: string;\n    readonly inputSchema: Record<string, unknown>;\n    readonly annotations?: McpToolAnnotations;\n    readonly _meta?: Record<string, unknown>;\n    readonly handler: (args: Record<string, unknown>, context: McpToolContext) => Promise<string | McpToolResult>;\n}"
   },
+  {
+    "name": "mcpToolAdapter",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function mcpToolAdapter<Input, Output>(tool: ToolContract<Input, Output>, baseOptions?: Omit<ToolCallOptions, \"signal\" | \"ledger\">): ToolAdapter;"
+  },
   {
     "name": "McpToolAnnotations",
     "kind": "interface",
@@ -6017,6 +6852,12 @@
     "package": "@nifrajs/mcp",
     "signature": "export interface McpToolContext {\n    readonly signal: AbortSignal;\n    readonly requestId: JsonRpcId;\n    readonly progressToken?: ProgressToken;\n    readonly reportProgress: (progress: number, total?: number) => void;\n}"
   },
+  {
+    "name": "McpToolContractOptions",
+    "kind": "interface",
+    "package": "@nifrajs/mcp",
+    "signature": "export interface McpToolContractOptions extends Omit<ToolCallOptions, \"signal\" | \"ledger\"> {\n    readonly capabilities?: readonly string[];\n}"
+  },
   {
     "name": "McpToolHandlerResult",
     "kind": "type",
@@ -6058,12 +6899,24 @@
     "package": "@nifrajs/content",
     "signature": "export interface MdxPluginOptions {\n    /** JSX runtime source the compiled MDX imports from - `\"react\"` (default), `\"preact\"`, `\"solid-js\"`. */\n    readonly jsxImportSource?: string;\n    /** Emit development JSX (line numbers, `jsxDEV`). Default `false`. */\n    readonly development?: boolean;\n    /** Extra `@mdx-js/mdx` `compile` options - e.g. `remarkPlugins`/`rehypePlugins` (GFM, slugs, …). */\n    readonly compileOptions?: Record<string, unknown>;\n    /** Advanced: override the compiler module specifier (default `\"@mdx-js/mdx\"`) - e.g. to use a fork. */\n    readonly moduleName?: string;\n}"
   },
+  {
+    "name": "MemoryAgentStateStore",
+    "kind": "class",
+    "package": "@nifrajs/agent",
+    "signature": "export declare class MemoryAgentStateStore implements AgentStateStore {\n    private readonly states;\n    load(turnId: string): AgentTurnState | undefined;\n    save(state: AgentTurnState): void;\n}"
+  },
   {
     "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": "MemoryAssureSink",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface MemoryAssureSink extends AssureSink {\n    readonly bundles: readonly AssureBundle[];\n    clear(): void;\n}"
+  },
   {
     "name": "MemoryCache",
     "kind": "class",
@@ -6132,7 +6985,7 @@
     "name": "MemoryIdempotencyStore",
     "kind": "class",
     "package": "@nifrajs/middleware",
-    "signature": "export declare class MemoryIdempotencyStore implements IdempotencyStore {\n    private readonly entries;\n    constructor(options?: MemoryIdempotencyStoreOptions);\n    begin(key: string, lockTtlMs: number): Promise<IdempotencyClaim>;\n    complete(key: string, record: IdempotencyRecord, ttlMs: number): Promise<void>;\n    release(key: string): Promise<void>;\n}",
+    "signature": "export declare class MemoryIdempotencyStore implements IdempotencyStore {\n    private readonly entries;\n    private readonly maxEntries;\n    private readonly maxKeyBytes;\n    constructor(options?: MemoryIdempotencyStoreOptions);\n    private validateKey;\n    private maintain;\n    private reserve;\n    begin(key: string, lockTtlMs: number): Promise<IdempotencyClaim>;\n    complete(key: string, record: IdempotencyRecord, ttlMs: number): Promise<void>;\n    release(key: string): Promise<void>;\n}",
     "doc": "/** In-process store. Refuses to run in production unless explicitly allowed (per-instance ⇒ no cross-instance dedupe). */"
   },
   {
@@ -6145,7 +6998,7 @@
     "name": "MemoryIdempotencyStoreOptions",
     "kind": "interface",
     "package": "@nifrajs/middleware",
-    "signature": "export interface MemoryIdempotencyStoreOptions {\n    /** Allow the in-memory store in production. Off by default - a per-instance store can't dedupe across instances. */\n    readonly allowInProduction?: boolean;\n}"
+    "signature": "export interface MemoryIdempotencyStoreOptions {\n    /** Allow the in-memory store in production. Off by default - a per-instance store can't dedupe across instances. */\n    readonly allowInProduction?: boolean;\n    /** Maximum retained locks + records. Default `10_000`. */\n    readonly maxEntries?: number;\n    /** Maximum key length in UTF-8 bytes. Default `1024`. */\n    readonly maxKeyBytes?: number;\n}"
   },
   {
     "name": "MemoryJobStore",
@@ -6222,6 +7075,18 @@
     "package": "@nifrajs/middleware",
     "signature": "export interface MemoryStoreOptions {\n    /** Allow the in-memory store in production. Off by default - a per-instance limiter is unsafe across instances. */\n    readonly allowInProduction?: boolean;\n    /** Hard cap on tracked client keys; expired keys are evicted first, then oldest active keys. Default `100_000`.\n     * Bounds memory against an unbounded key space (bot scans, per-IP buckets). */\n    readonly maxKeys?: number;\n    /** Minimum interval (ms) between amortized sweeps of expired windows. Default `30_000`. */\n    readonly sweepIntervalMs?: number;\n}"
   },
+  {
+    "name": "MemoryToolIdempotencyStore",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class MemoryToolIdempotencyStore implements ToolIdempotencyStore {\n    readonly durability: \"memory\";\n    private readonly entries;\n    private readonly maxEntries;\n    private readonly ttlMs;\n    private readonly now;\n    constructor(options?: MemoryToolIdempotencyStoreOptions);\n    begin(input: ToolIdempotencyBeginInput): ToolIdempotencyBeginResult;\n    complete(input: {\n        readonly namespace: string;\n        readonly key: string;\n        readonly reservation: string;\n    }): boolean;\n    abandon(input: {\n        readonly namespace: string;\n        readonly key: string;\n        readonly reservation: string;\n    }): boolean;\n    sweep(): void;\n}"
+  },
+  {
+    "name": "MemoryToolIdempotencyStoreOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface MemoryToolIdempotencyStoreOptions {\n    readonly maxEntries?: number;\n    readonly ttlMs?: number;\n    readonly now?: () => number;\n}"
+  },
   {
     "name": "mergeHeads",
     "kind": "function",
@@ -6250,6 +7115,13 @@
     "signature": "export interface MetaArgs<Data = unknown> {\n    readonly data: Data;\n    readonly params: Record<string, string>;\n    /**\n     * The site origin - scheme + host (+ port), e.g. `\"https://news.example.com\"`, **with no trailing\n     * slash**. The single piece of server/env knowledge `meta()` otherwise can't see: it runs in BOTH\n     * SSR and client navigation, so it has no `request`/`process.env`. The framework resolves it from the\n     * request URL during SSR and from `location.origin` on client nav - and they match, so an absolute\n     * `og:url`/`canonical`/`og:image` built from it never drifts between the server-rendered `<head>` and\n     * a soft-nav. Use it for absolute URLs (`origin + \"/posts/\" + slug`) instead of threading `siteUrl`\n     * through loader data. Empty string (`\"\"`) when the origin is unknown (e.g. a hand-built test render\n     * with no request URL). A `meta()` that ignores `origin` is unchanged.\n     */\n    readonly origin: string;\n}",
     "doc": "/**\n * Args for a route's `meta` function: the loader's `data` + the route `params` + the request `origin`.\n * `meta()` runs in BOTH SSR and client navigation, so it has **no `request`/`process.env`/server access** -\n * `origin` is the only server-resolved fact it gets (so you needn't thread `siteUrl` through loader data\n * for absolute `og:url`/`canonical`/`og:image` URLs). See {@link origin}.\n */"
   },
+  {
+    "name": "MetaDescriptor",
+    "kind": "interface",
+    "package": "@nifrajs/web",
+    "signature": "export interface MetaDescriptor {\n    readonly charset?: string;\n    readonly content?: string;\n    readonly \"http-equiv\"?: string;\n    readonly itemprop?: string;\n    readonly media?: string;\n    readonly name?: string;\n    readonly property?: string;\n    readonly scheme?: string;\n    readonly [attr: `data-${string}`]: string | undefined;\n}",
+    "doc": "/** One managed `<meta>` tag. Standard attributes and inert `data-*` metadata only. */"
+  },
   {
     "name": "MetaInput",
     "kind": "type",
@@ -6273,7 +7145,7 @@
     "name": "methodOverride",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function methodOverride(options?: MethodOverrideOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
+    "signature": "export declare function methodOverride(options?: MethodOverrideOptions): import(\"@nifrajs/core\").IdentityPlugin;",
     "doc": "/**\n * HTTP method override for clients that can only send `POST`. The middleware rewrites the request\n * before routing, so handlers, validation, and response hooks all see the overridden method.\n *\n * Header override is enabled by default; query override is opt-in. Form-body override is deliberately\n * not implemented because reading the body before routing would consume or buffer it for every write.\n */"
   },
   {
@@ -6300,7 +7172,7 @@
     "name": "metrics",
     "kind": "function",
     "package": "@nifrajs/otel",
-    "signature": "export declare function metrics(options?: MetricsOptions): NifraPlugin;",
+    "signature": "export declare function metrics(options?: MetricsOptions): IdentityPlugin;",
     "doc": "/**\n * Enable RED metrics + a `/metrics` Prometheus endpoint. Records `nifra_http_requests_total`,\n * `nifra_http_request_duration_seconds`, and `nifra_http_requests_in_flight`, labeled by method,\n * matched route template, and status. Apply once (named-plugin dedupe).\n */"
   },
   {
@@ -6517,7 +7389,7 @@
     "name": "namedCombine",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function namedCombine(name: string, ...items: readonly Composable[]): NifraPlugin;",
+    "signature": "export declare function namedCombine(name: string, ...items: readonly Composable[]): IdentityPlugin;",
     "doc": "/** Compose middleware/plugins into one idempotent named bundle. */"
   },
   {
@@ -6538,49 +7410,49 @@
     "name": "NavigateFunction",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n    }): void;\n}",
+    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n        readonly state?: unknown;\n    }): void;\n}",
     "doc": "/**\n * A programmatic navigate, shared by every adapter's `useNavigate`. Three forms: a string path (push, or\n * replace via `{ replace: true }`), a history delta (`-1`/`1`), or an object target `{ to, search, replace }`\n * whose `search` is typed against `to`'s route schema via {@link NavigateSearchOf} (a wrong shape for a\n * mapped route is a compile error; an unmapped path takes a loose `search`). The object form's `search` is\n * serialized onto `to`. A no-op on the server / before hydration.\n */"
   },
   {
     "name": "NavigateFunction",
     "kind": "interface",
     "package": "@nifrajs/web-preact",
-    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n    }): void;\n}",
+    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n        readonly state?: unknown;\n    }): void;\n}",
     "doc": "/**\n * A programmatic navigate, shared by every adapter's `useNavigate`. Three forms: a string path (push, or\n * replace via `{ replace: true }`), a history delta (`-1`/`1`), or an object target `{ to, search, replace }`\n * whose `search` is typed against `to`'s route schema via {@link NavigateSearchOf} (a wrong shape for a\n * mapped route is a compile error; an unmapped path takes a loose `search`). The object form's `search` is\n * serialized onto `to`. A no-op on the server / before hydration.\n */"
   },
   {
     "name": "NavigateFunction",
     "kind": "interface",
     "package": "@nifrajs/web-react",
-    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n    }): void;\n}",
+    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n        readonly state?: unknown;\n    }): void;\n}",
     "doc": "/**\n * A programmatic navigate, shared by every adapter's `useNavigate`. Three forms: a string path (push, or\n * replace via `{ replace: true }`), a history delta (`-1`/`1`), or an object target `{ to, search, replace }`\n * whose `search` is typed against `to`'s route schema via {@link NavigateSearchOf} (a wrong shape for a\n * mapped route is a compile error; an unmapped path takes a loose `search`). The object form's `search` is\n * serialized onto `to`. A no-op on the server / before hydration.\n */"
   },
   {
     "name": "NavigateFunction",
     "kind": "interface",
     "package": "@nifrajs/web-solid",
-    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n    }): void;\n}",
+    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n        readonly state?: unknown;\n    }): void;\n}",
     "doc": "/**\n * A programmatic navigate, shared by every adapter's `useNavigate`. Three forms: a string path (push, or\n * replace via `{ replace: true }`), a history delta (`-1`/`1`), or an object target `{ to, search, replace }`\n * whose `search` is typed against `to`'s route schema via {@link NavigateSearchOf} (a wrong shape for a\n * mapped route is a compile error; an unmapped path takes a loose `search`). The object form's `search` is\n * serialized onto `to`. A no-op on the server / before hydration.\n */"
   },
   {
     "name": "NavigateFunction",
     "kind": "interface",
     "package": "@nifrajs/web-svelte",
-    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n    }): void;\n}",
+    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n        readonly state?: unknown;\n    }): void;\n}",
     "doc": "/**\n * A programmatic navigate, shared by every adapter's `useNavigate`. Three forms: a string path (push, or\n * replace via `{ replace: true }`), a history delta (`-1`/`1`), or an object target `{ to, search, replace }`\n * whose `search` is typed against `to`'s route schema via {@link NavigateSearchOf} (a wrong shape for a\n * mapped route is a compile error; an unmapped path takes a loose `search`). The object form's `search` is\n * serialized onto `to`. A no-op on the server / before hydration.\n */"
   },
   {
     "name": "NavigateFunction",
     "kind": "interface",
     "package": "@nifrajs/web-vue",
-    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n    }): void;\n}",
+    "signature": "export interface NavigateFunction {\n    (to: string | number, options?: NavigateOptions): void;\n    <To extends string>(target: {\n        readonly to: To;\n        readonly search?: NavigateSearchOf<To>;\n        readonly replace?: boolean;\n        readonly state?: unknown;\n    }): void;\n}",
     "doc": "/**\n * A programmatic navigate, shared by every adapter's `useNavigate`. Three forms: a string path (push, or\n * replace via `{ replace: true }`), a history delta (`-1`/`1`), or an object target `{ to, search, replace }`\n * whose `search` is typed against `to`'s route schema via {@link NavigateSearchOf} (a wrong shape for a\n * mapped route is a compile error; an unmapped path takes a loose `search`). The object form's `search` is\n * serialized onto `to`. A no-op on the server / before hydration.\n */"
   },
   {
     "name": "NavigateOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface NavigateOptions {\n    /** Replace the current history entry instead of pushing a new one (like `history.replaceState`). */\n    readonly replace?: boolean;\n}",
+    "signature": "export interface NavigateOptions {\n    /** Replace the current history entry instead of pushing a new one (like `history.replaceState`). */\n    readonly replace?: boolean;\n    /**\n     * Opaque per-entry state stored on the created history entry (under `history.state.nifraState`, so\n     * it never collides with the router's own bookkeeping keys). Structured-cloneable only, like\n     * `history.pushState`'s first argument. Read it back via `history.state.nifraState`; the browser\n     * restores it automatically on back/forward. Ignored for history-delta navigations.\n     */\n    readonly state?: unknown;\n}",
     "doc": "/** Options for a programmatic navigation. */"
   },
   {
@@ -6601,7 +7473,7 @@
     "name": "NavigateTargetInput",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface NavigateTargetInput {\n    readonly to: string;\n    readonly search?: Record<string, unknown>;\n    readonly replace?: boolean;\n}",
+    "signature": "export interface NavigateTargetInput {\n    readonly to: string;\n    readonly search?: Record<string, unknown>;\n    readonly replace?: boolean;\n    readonly state?: unknown;\n}",
     "doc": "/** The runtime shape of an object-form navigate target (loose - the typed narrowing lives in\n * {@link NavigateFunction}'s generic call signature). `to` is a bare pathname; `search` is serialized\n * onto it; `replace` folds into the options. */"
   },
   {
@@ -6643,14 +7515,14 @@
     "name": "negotiateLocale",
     "kind": "function",
     "package": "@nifrajs/i18n",
-    "signature": "export declare function negotiateLocale(request: Request, options: NegotiateOptions): Locale;",
-    "doc": "/**\n * Negotiate the request's locale. Order: a valid {@link NegotiateOptions.cookie} value →\n * `Accept-Language` (each `q`-ranked tag, exact then base-subtag) → `defaultLocale`.\n */"
+    "signature": "export declare function negotiateLocale(request: Request | LocaleParts, options: NegotiateOptions): Locale;",
+    "doc": "/**\n * Negotiate the request's locale. Order: a valid {@link NegotiateOptions.queryParam} value → a\n * valid {@link NegotiateOptions.cookie} value → `Accept-Language` (each `q`-ranked tag, exact then\n * base-subtag) → `defaultLocale`. {@link resolveLocale} additionally reports the winning source.\n */"
   },
   {
     "name": "NegotiateOptions",
     "kind": "interface",
     "package": "@nifrajs/i18n",
-    "signature": "export interface NegotiateOptions {\n    /** The locales the app supports, e.g. `[\"en\", \"fr\", \"de\"]`. Matched case-insensitively. */\n    readonly locales: readonly Locale[];\n    /** Returned when nothing matches. */\n    readonly defaultLocale: Locale;\n    /** A cookie name whose value (if a supported locale) wins over `Accept-Language` (a user's explicit\n     * choice). Omit to skip the cookie. */\n    readonly cookie?: string;\n}"
+    "signature": "export interface NegotiateOptions {\n    /** The locales the app supports, e.g. `[\"en\", \"fr\", \"de\"]`. Matched case-insensitively. */\n    readonly locales: readonly Locale[];\n    /** Returned when nothing matches. */\n    readonly defaultLocale: Locale;\n    /** A query parameter whose value (if a supported locale) wins over everything - a link carrying\n     * `?lang=fr` is an explicit ask. Omit to skip the query string. */\n    readonly queryParam?: string;\n    /** A cookie name whose value (if a supported locale) wins over `Accept-Language` (a user's explicit\n     * choice). Omit to skip the cookie. */\n    readonly cookie?: string;\n}"
   },
   {
     "name": "NetlifyEvent",
@@ -6687,7 +7559,7 @@
     "name": "NIFRA_ASSURANCE",
     "kind": "const",
     "package": "@nifrajs/core",
-    "signature": "export declare const NIFRA_ASSURANCE: Readonly<{\n    readonly AUTHENTICATED: \"nifra.authenticated\";\n    readonly BODY_BOUNDED: \"nifra.body-bounded\";\n    readonly CSRF: \"nifra.csrf\";\n    readonly DURABLE_COMMAND: \"nifra.durable-command\";\n    readonly IDEMPOTENCY_KEY: \"nifra.idempotency-key\";\n    readonly IP_RESTRICTED: \"nifra.ip-restricted\";\n    readonly RATE_LIMITED: \"nifra.rate-limited\";\n    readonly SECURITY_HEADERS: \"nifra.security-headers\";\n}>;",
+    "signature": "export declare const NIFRA_ASSURANCE: Readonly<{\n    readonly AUTHENTICATED: \"nifra.authenticated\";\n    readonly BODY_BOUNDED: \"nifra.body-bounded\";\n    readonly CSRF: \"nifra.csrf\";\n    readonly DURABLE_COMMAND: \"nifra.durable-command\";\n    readonly IDEMPOTENCY_KEY: \"nifra.idempotency-key\";\n    readonly IP_RESTRICTED: \"nifra.ip-restricted\";\n    readonly RATE_LIMITED: \"nifra.rate-limited\";\n    readonly SECURITY_HEADERS: \"nifra.security-headers\";\n    readonly RESPONSE_CONTRACT: \"nifra.response-contract\";\n}>;",
     "doc": "/** Canonical evidence ids emitted by Nifra's official middleware modules. */"
   },
   {
@@ -6711,6 +7583,20 @@
     "signature": "export declare const NIFRA_DEADLINE_HEADER = \"x-nifra-deadline\";",
     "doc": "/** Canonical wire header carrying an absolute Unix epoch deadline in milliseconds. */"
   },
+  {
+    "name": "NifraFeatureVersion",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type NifraFeatureVersion = FeatureVersionOf<Version>;",
+    "doc": "/**\n * The feature version of the `@nifrajs/core` copy that declared these types, derived from the single\n * `VERSION` literal (type-only import - erased, so no runtime cycle with the package root).\n */"
+  },
+  {
+    "name": "NifraFeatureVersion",
+    "kind": "type",
+    "package": "nifra",
+    "signature": "export type NifraFeatureVersion = FeatureVersionOf<Version>;",
+    "doc": "/**\n * The feature version of the `@nifrajs/core` copy that declared these types, derived from the single\n * `VERSION` literal (type-only import - erased, so no runtime cycle with the package root).\n */"
+  },
   {
     "name": "NifraManifest",
     "kind": "interface",
@@ -6912,6 +7798,12 @@
     "signature": "export declare function normalizeRolldownPlugins(plugins: readonly unknown[], isRolldown: boolean): readonly unknown[];",
     "doc": "/**\n * Strip `optimizeDeps.rollupOptions.jsx` from a plugin's `config` hook output when running under\n * rolldown-vite - the source of the scary, harmless `Warning: Invalid input options … \"jsx\" Invalid\n * key: Expected never but received \"jsx\"` on `nifra dev`.\n *\n * Why it happens: `@vitejs/plugin-react@4.x` (and peers) target an *older* rolldown-vite optimizeDeps\n * API - they inject `optimizeDeps.rollupOptions.jsx` to tell the dep pre-bundler to transform JSX. Vite\n * 8's rolldown dep-optimizer renamed that surface to `optimizeDeps.rolldownOptions` (and moved jsx under\n * `transform.jsx`), so the stale `rollupOptions.jsx` is an unrecognized input option → the warning. It's\n * a version-skew artifact, not a real misconfig: the route source JSX transform runs through the\n * plugin's own `transform` hook (untouched here), and node_modules deps that get pre-bundled almost\n * never contain raw JSX - so dropping the dead key changes no behavior and keeps HMR/Fast Refresh\n * intact. We *strip* (rather than translate to `rolldownOptions`) so the fix is version-agnostic: a\n * plugin already emitting the correct `rolldownOptions` is left untouched, and a future plugin bump that\n * stops emitting `rollupOptions.jsx` makes this a no-op.\n *\n * Scoped narrowly: only the `optimizeDeps.rollupOptions.jsx` key is removed, only under rolldown-vite,\n * and only from the value a plugin's `config` hook returns. Non-rolldown Vite is passed through verbatim.\n *\n * FLATTEN FIRST: a Vite plugin factory may return an ARRAY of plugins - `@vitejs/plugin-react`'s `react()`\n * returns `[vite:react-babel, vite:react-refresh]`, and it's `react:react-babel`'s `config` hook that emits\n * the offending `optimizeDeps.rollupOptions.jsx`. `nifra.config.ts` writes `vitePlugins = [react()]`, so the\n * plugin list arrives NESTED (`[[babel, refresh]]`). Without flattening, `.map` sees the inner array (which\n * has no `config`), leaves it untouched, and Vite - which flattens plugin arrays itself before running them\n * - then executes the un-stripped babel hook, so the warning survives. Flattening here (Vite accepts a flat\n * list identically) is what lets the strip reach every real plugin.\n */"
   },
+  {
+    "name": "normalizeSeverity",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function normalizeSeverity(value: \"error\" | \"warning\" | \"warn\" | \"info\"): Severity;"
+  },
   {
     "name": "notFound",
     "kind": "function",
@@ -7012,7 +7904,7 @@
     "name": "openapi",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function openapi(options?: OpenApiOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
+    "signature": "export declare function openapi(options?: OpenApiOptions): IdentityPlugin;",
     "doc": "/**\n * Serve an OpenAPI 3.1 document (a structural subset - see {@link buildOpenApiDocument}) at\n * `options.path` (default `/openapi.json`), generated from the app's registered routes. Generation is\n * **lazy + memoized**: it reads `app.routes()` on the first request, by which point every route is\n * registered - so the plugin's own position in the chain doesn't matter.\n *\n * Pass `ui: true` (or `ui: { path, title, cdn }`) to also serve a Scalar API-reference page (default\n * `/reference`) that renders the spec. The page loads Scalar from a CDN; pin/self-host via `ui.cdn`,\n * and remember to allow that origin if you ship a `script-src` Content-Security-Policy.\n *\n * ```ts\n * app.use(openapi({ info: { title: \"My API\", version: \"1.0.0\" }, ui: true }))\n * ```\n */"
   },
   {
@@ -7089,7 +7981,7 @@
     "name": "OperationDef",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface OperationDef {\n    readonly method: Method;\n    readonly path: string;\n    /** Optional path-params schema (validated + coercible at the boundary; see {@link RouteSchema.params}). */\n    readonly params?: StandardSchemaV1;\n    readonly body?: StandardSchemaV1;\n    readonly query?: StandardSchemaV1;\n    readonly response?: StandardSchemaV1;\n    /** Declared effect tokens, carried into route reflection and capability assurance. */\n    readonly capabilities?: readonly string[];\n    /** Dedupe retries of this operation on an `Idempotency-Key` header (see {@link RouteSchema.idempotency}). */\n    readonly idempotency?: IdempotencyConfig;\n    /** Highest data-sensitivity the response carries (see {@link RouteSchema.classification}). */\n    readonly classification?: DataClassification;\n    /** Inline route-assurance evidence this operation carries (see {@link RouteSchema.assurance}). */\n    readonly assurance?: readonly string[];\n    /** Mark this operation a dynamic route family (see {@link RouteSchema.family}). */\n    readonly family?: boolean;\n    /** Short summary (OpenAPI `summary`). */\n    readonly summary?: string;\n    /** Longer description (OpenAPI `description`, CommonMark). */\n    readonly description?: string;\n    /** Grouping tags (OpenAPI `tags`). */\n    readonly tags?: readonly string[];\n    /** Mark the operation deprecated. */\n    readonly deprecated?: boolean;\n    /** Security requirements (names ref `securitySchemes`); `[]` = explicitly public. Omit ⇒ inherit the document default. */\n    readonly security?: ReadonlyArray<Readonly<Record<string, readonly string[]>>>;\n    /** Request body content type. Default `application/json`. */\n    readonly requestContentType?: string;\n    /** Content type of the success (`200`) response. Default `application/json`. */\n    readonly responseContentType?: string;\n    /** Additional responses by status code, e.g. `{ \"404\": { description: \"Not found\" } }`. */\n    readonly responses?: Readonly<Record<string, ResponseDef>>;\n}",
+    "signature": "export interface OperationDef {\n    readonly method: Method;\n    readonly path: string;\n    /** Optional path-params schema (validated + coercible at the boundary; see {@link RouteSchema.params}). */\n    readonly params?: StandardSchemaV1;\n    /** Optional request-header schema (header names are normalized to lower-case). */\n    readonly headers?: StandardSchemaV1;\n    readonly body?: StandardSchemaV1;\n    readonly query?: StandardSchemaV1;\n    readonly response?: StandardSchemaV1;\n    /** Declared effect tokens, carried into route reflection and capability assurance. */\n    readonly capabilities?: readonly string[];\n    /** Dedupe retries of this operation on an `Idempotency-Key` header (see {@link RouteSchema.idempotency}). */\n    readonly idempotency?: IdempotencyConfig;\n    /** Per-route transport body cap; see RouteSchema.bodyLimit. */\n    readonly bodyLimit?: number | \"unlimited\";\n    readonly bodyLimitReason?: string;\n    /** Highest data-sensitivity the response carries (see {@link RouteSchema.classification}). */\n    readonly classification?: DataClassification;\n    /** Inline route-assurance evidence this operation carries (see {@link RouteSchema.assurance}). */\n    readonly assurance?: readonly string[];\n    /** Mark this operation a dynamic route family (see {@link RouteSchema.family}). */\n    readonly family?: boolean;\n    /** Short summary (OpenAPI `summary`). */\n    readonly summary?: string;\n    /** Longer description (OpenAPI `description`, CommonMark). */\n    readonly description?: string;\n    /** Grouping tags (OpenAPI `tags`). */\n    readonly tags?: readonly string[];\n    /** Mark the operation deprecated. */\n    readonly deprecated?: boolean;\n    /** Security requirements (names ref `securitySchemes`); `[]` = explicitly public. Omit ⇒ inherit the document default. */\n    readonly security?: ReadonlyArray<Readonly<Record<string, readonly string[]>>>;\n    /** Request body content type. Default `application/json`. */\n    readonly requestContentType?: string;\n    /** Content type of the success (`200`) response. Default `application/json`. */\n    readonly responseContentType?: string;\n    /** Additional responses by status code, e.g. `{ \"404\": { description: \"Not found\" } }`. */\n    readonly responses?: Readonly<Record<string, ResponseDef>>;\n}",
     "doc": "/**\n * One operation in a contract. Input schemas are any Standard Schema; `response` is optional.\n *\n * The fields below `response` are **optional OpenAPI metadata** - they don't affect runtime\n * validation or the inferred handler types, they enrich the document `toOpenAPI` emits. A contract is\n * the natural home for them: it's the versionable description of the API, decoupled from the impl.\n */"
   },
   {
@@ -7210,6 +8102,13 @@
     "signature": "export declare function parseCausalityRecord(input: unknown): CausalityRecordParseResult;",
     "doc": "/** Parse an untrusted durable graph record. Unknown fields fail closed at every nesting level. */"
   },
+  {
+    "name": "parseCompatibleReplayFile",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function parseCompatibleReplayFile(value: unknown): CompatibleReplayFile;",
+    "doc": "/** Parse the unified format while preserving the two pre-existing token-only replay shapes. */"
+  },
   {
     "name": "parseCookies",
     "kind": "function",
@@ -7328,6 +8227,18 @@
     "signature": "export declare function parseNifraManifestSignature(content: string, source?: string): NifraManifestSignature;",
     "doc": "/** Parse the detached sidecar before selecting its operator-controlled public key. */"
   },
+  {
+    "name": "parseReplayFile",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function parseReplayFile(value: unknown): ReplayFile;"
+  },
+  {
+    "name": "parseRulePacks",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function parseRulePacks(value: unknown): readonly RulePack[];"
+  },
   {
     "name": "parseTraceparent",
     "kind": "function",
@@ -7367,6 +8278,12 @@
     "package": "@nifrajs/core",
     "signature": "export declare const plainJsonCodec: TransportCodec;"
   },
+  {
+    "name": "planProofs",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function planProofs(graph: WorkGraph, impact: ImpactReport, targetLevel?: number): ProofPlan;"
+  },
   {
     "name": "Platform",
     "kind": "interface",
@@ -7400,6 +8317,20 @@
     "signature": "export type PluginBuilder = Parameters<BunPlugin[\"setup\"]>[0];",
     "doc": "/** The argument Bun passes to a plugin's `setup` - Bun doesn't export the type, so derive it. */"
   },
+  {
+    "name": "PluginTypeCollapsed",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface PluginTypeCollapsed {\n    readonly [COLLAPSED]: \"definePlugin erased the caller's server type: use defineContextPlugin (adds context) or defineRouterPlugin (routes/hooks only), or pin the input type\";\n}",
+    "doc": "/**\n * What {@link definePlugin} returns when its `apply` argument never pinned the input server type -\n * the `definePlugin(\"x\", (app) => ...)` arrow, where `app` falls back to `AnyServer`.\n *\n * It is deliberately **not callable**, so `app.use(thatPlugin)` is a type error at the call site\n * instead of a silent widening to `Server<any, any>` that surfaces hundreds of lines away as\n * `Property 'x' does not exist on type 'Promise<Result<unknown, unknown>>'` in the typed client.\n *\n * The plugin still works at runtime. To fix the type, pick the definer that matches what it does:\n *\n * - adds context via `derive`/`decorate` -> {@link defineContextPlugin}\n * - mounts routes/hooks and adds NO context -> {@link defineRouterPlugin} ({@link defineIdentityPlugin})\n * - genuinely needs `definePlugin`: annotate the parameter (`(app: typeof api) => ...`) or pass\n *   explicit type arguments (`definePlugin<typeof api, typeof api>(...)`).\n */"
+  },
+  {
+    "name": "PluginTypeCollapsed",
+    "kind": "interface",
+    "package": "nifra",
+    "signature": "export interface PluginTypeCollapsed {\n    readonly [COLLAPSED]: \"definePlugin erased the caller's server type: use defineContextPlugin (adds context) or defineRouterPlugin (routes/hooks only), or pin the input type\";\n}",
+    "doc": "/**\n * What {@link definePlugin} returns when its `apply` argument never pinned the input server type -\n * the `definePlugin(\"x\", (app) => ...)` arrow, where `app` falls back to `AnyServer`.\n *\n * It is deliberately **not callable**, so `app.use(thatPlugin)` is a type error at the call site\n * instead of a silent widening to `Server<any, any>` that surfaces hundreds of lines away as\n * `Property 'x' does not exist on type 'Promise<Result<unknown, unknown>>'` in the typed client.\n *\n * The plugin still works at runtime. To fix the type, pick the definer that matches what it does:\n *\n * - adds context via `derive`/`decorate` -> {@link defineContextPlugin}\n * - mounts routes/hooks and adds NO context -> {@link defineRouterPlugin} ({@link defineIdentityPlugin})\n * - genuinely needs `definePlugin`: annotate the parameter (`(app: typeof api) => ...`) or pass\n *   explicit type arguments (`definePlugin<typeof api, typeof api>(...)`).\n */"
+  },
   {
     "name": "PngRenderer",
     "kind": "type",
@@ -7562,7 +8493,7 @@
     "name": "prettyJson",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function prettyJson(options?: PrettyJsonOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
+    "signature": "export declare function prettyJson(options?: PrettyJsonOptions): import(\"@nifrajs/core\").IdentityPlugin;",
     "doc": "/**\n * Pretty-print JSON responses for debugging and developer-facing APIs. It only touches JSON content,\n * skips encoded responses, caps inspection size, and leaves invalid JSON untouched.\n */"
   },
   {
@@ -7603,7 +8534,7 @@
     "name": "problemDetails",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function problemDetails(options?: ProblemDetailsOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
+    "signature": "export declare function problemDetails(options?: ProblemDetailsOptions): import(\"@nifrajs/core\").IdentityPlugin;",
     "doc": "/**\n * Opt-in RFC 9457 formatting for Nifra's structured error envelope.\n *\n * The default `{ ok: false, error }` response remains unchanged. This plugin only converts that\n * framework envelope, so custom JSON errors and already-formatted problem documents pass through.\n * Raw JSON error Responses are supported through a capped clone; encoded responses are never drained.\n */"
   },
   {
@@ -7612,6 +8543,79 @@
     "package": "@nifrajs/middleware",
     "signature": "export interface ProblemDetailsOptions {\n    /** Include only the request pathname as `instance`. Query strings are never included. Default false. */\n    readonly includeInstance?: boolean;\n    /** Prefix for code-specific problem types. Default `about:blank`. */\n    readonly typeBase?: string;\n    /** Maximum JSON error body inspected. Default 64 KiB. */\n    readonly maxBytes?: number;\n}"
   },
+  {
+    "name": "ProjectEvidenceAssurance",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ProjectEvidenceAssurance {\n    readonly ok: boolean;\n    readonly routes: readonly ProjectEvidenceAssuranceRoute[];\n    readonly findings: readonly AssuranceFinding[];\n}"
+  },
+  {
+    "name": "ProjectEvidenceAssuranceRoute",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ProjectEvidenceAssuranceRoute {\n    readonly method: string;\n    readonly path: string;\n    readonly rule?: string;\n    readonly evidence: readonly AssuranceEvidence[];\n    readonly missing: readonly string[];\n    readonly forbidden: readonly string[];\n}"
+  },
+  {
+    "name": "ProjectEvidenceCapabilities",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ProjectEvidenceCapabilities {\n    readonly ok: boolean;\n    readonly routes: readonly ProjectEvidenceCapabilityRoute[];\n    readonly findings: readonly CapabilityFinding[];\n}"
+  },
+  {
+    "name": "ProjectEvidenceCapabilityRoute",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ProjectEvidenceCapabilityRoute {\n    readonly method: string;\n    readonly path: string;\n    readonly declared: readonly string[];\n    readonly evidence: readonly CapabilityEvidence[];\n    readonly unproven: readonly string[];\n    readonly covered: boolean;\n    readonly classification?: AssuredCapabilityRoute[\"classification\"];\n}"
+  },
+  {
+    "name": "ProjectEvidenceOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ProjectEvidenceOptions {\n    readonly assurance?: AssuranceReport;\n    readonly capabilities?: CapabilityAssuranceReport;\n    /** Optional static source locations keyed by `${METHOD}\\n${path}`. */\n    readonly sourceLocations?: ReadonlyMap<string, readonly ProjectEvidenceSourceLocation[]>;\n}"
+  },
+  {
+    "name": "ProjectEvidenceRoute",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ProjectEvidenceRoute {\n    readonly method: string;\n    readonly path: string;\n    readonly schema?: ProjectEvidenceSchema;\n    readonly assurance?: readonly AssuranceEvidence[];\n    readonly capabilities?: readonly string[];\n    readonly family?: boolean;\n    readonly classification?: ResponseClassification;\n    readonly tool?: ReflectedRoute[\"tool\"];\n    readonly source?: readonly ProjectEvidenceSourceLocation[];\n}"
+  },
+  {
+    "name": "ProjectEvidenceSchema",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ProjectEvidenceSchema {\n    readonly bodyLimit?: number | \"unlimited\";\n    readonly bodyLimitReason?: string;\n    readonly headers?: ProjectEvidenceSchemaPart;\n    readonly body?: ProjectEvidenceSchemaPart;\n    readonly query?: ProjectEvidenceSchemaPart;\n    readonly params?: ProjectEvidenceSchemaPart;\n    readonly response?: ProjectEvidenceSchemaPart;\n    readonly errors?: Readonly<Record<string, ProjectEvidenceSchemaPart>>;\n    readonly sse?: ProjectEvidenceSchemaPart;\n}"
+  },
+  {
+    "name": "ProjectEvidenceSchemaPart",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ProjectEvidenceSchemaPart {\n    readonly jsonSchema?: JsonSchema;\n    readonly fields?: readonly ReflectedSchemaField[];\n}"
+  },
+  {
+    "name": "ProjectEvidenceSnapshot",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ProjectEvidenceSnapshot {\n    readonly version: 1;\n    readonly routes: readonly ProjectEvidenceRoute[];\n    readonly assurance?: ProjectEvidenceAssurance;\n    readonly capabilities?: ProjectEvidenceCapabilities;\n}",
+    "doc": "/** One deterministic, persistence-safe view of a project's public and trust-relevant facts. */"
+  },
+  {
+    "name": "ProjectEvidenceSourceLocation",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ProjectEvidenceSourceLocation {\n    readonly file: string;\n    readonly line?: number;\n    readonly column?: number;\n}"
+  },
+  {
+    "name": "ProjectFacts",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface ProjectFacts {\n    readonly [key: string]: unknown;\n}"
+  },
+  {
+    "name": "ProjectWorkGraphResult",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface ProjectWorkGraphResult {\n    readonly graph: WorkGraph;\n    readonly impact: ImpactReport;\n    readonly plan: ProofPlan;\n    readonly evidence: EvidenceBundle;\n}"
+  },
   {
     "name": "prompt",
     "kind": "function",
@@ -7688,6 +8692,36 @@
     "signature": "export interface PromptResponseFormat {\n    readonly name: string;\n    readonly strict: true;\n    readonly schema: JsonSchema;\n}",
     "doc": "/** The structured-output format handed to the provider (OpenAI `json_schema` shape; trivially\n * adaptable to Anthropic tool-input or Gemini `responseSchema`). */"
   },
+  {
+    "name": "ProofEvidence",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface ProofEvidence {\n    readonly id: string;\n    readonly status: ProofStatus;\n    readonly level: number;\n    readonly nodeIds: readonly string[];\n    readonly command: string;\n    readonly fix?: string;\n}"
+  },
+  {
+    "name": "ProofKind",
+    "kind": "type",
+    "package": "@nifrajs/cli",
+    "signature": "export type ProofKind = \"typecheck\" | \"contract\" | \"assurance\" | \"suite\";"
+  },
+  {
+    "name": "ProofPlan",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface ProofPlan {\n    readonly steps: readonly ProofStep[];\n    readonly targetLevel: number;\n}"
+  },
+  {
+    "name": "ProofStatus",
+    "kind": "type",
+    "package": "@nifrajs/cli",
+    "signature": "export type ProofStatus = \"pass\" | \"fail\" | \"skip\" | \"pending\";"
+  },
+  {
+    "name": "ProofStep",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface ProofStep {\n    readonly id: string;\n    readonly kind: ProofKind;\n    readonly level: number;\n    readonly cost: number;\n    readonly command: string;\n    readonly nodeIds: readonly string[];\n    readonly fix?: string;\n}"
+  },
   {
     "name": "PROTOCOL_VERSION",
     "kind": "const",
@@ -7695,6 +8729,33 @@
     "signature": "export declare const PROTOCOL_VERSION = \"2025-06-18\";",
     "doc": "/** The protocol revision this server advertises by default. A handshake-era version - the HTTP transport\n * still uses `initialize`; current clients reach it through their backward-compatibility fallback.\n * `initialize` echoes the client's own requested version instead when it's one this server also speaks\n * ({@link SUPPORTED_PROTOCOL_VERSIONS}). */"
   },
+  {
+    "name": "proveIdempotency",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function proveIdempotency(options: {\n    readonly run: () => Promise<EffectLedger> | EffectLedger;\n    readonly runs?: number;\n}): Promise<IdempotencyProof>;",
+    "doc": "/** Run a token-only effect workload repeatedly and report the first stable replay differences. */"
+  },
+  {
+    "name": "ProxyContext",
+    "kind": "interface",
+    "package": "@nifrajs/proxy",
+    "signature": "export interface ProxyContext {\n    readonly req: Request;\n    readonly clientIp?: string | undefined;\n    readonly signal?: AbortSignal | undefined;\n}",
+    "doc": "/** Structural slice of a nifra `Context` the proxy reads - a plain `Request` works too. */"
+  },
+  {
+    "name": "ProxyHandler",
+    "kind": "type",
+    "package": "@nifrajs/proxy",
+    "signature": "export type ProxyHandler = (input: Request | ProxyContext) => Promise<Response>;",
+    "doc": "/** Forward a request (or a nifra context) to the configured upstream. */"
+  },
+  {
+    "name": "ProxyOptions",
+    "kind": "interface",
+    "package": "@nifrajs/proxy",
+    "signature": "export interface ProxyOptions {\n    /**\n     * The upstream to forward every request to, as a **bare origin** (`https://api.internal:8443`).\n     * A path, query, fragment, or credentials in the URL throws at construction; only `http:` and\n     * `https:` are accepted. The forwarded URL is this origin + the incoming path and query.\n     */\n    readonly upstream: string;\n    /** Mount prefix to remove from the incoming path before forwarding (`/api` + request\n     * `/api/users` → upstream `/users`). A path outside the prefix is forwarded unchanged. */\n    readonly stripPrefix?: string;\n    /**\n     * Forward caller metadata upstream. Default **false**: `Forwarded` and `X-Forwarded-*` headers\n     * are stripped, so a client-forged chain never reaches the upstream. When true, the inbound\n     * `X-Forwarded-For` is kept with the observed caller IP appended (pass a `ProxyContext` so\n     * `c.clientIp` - already filtered by the app's trust declaration - is what gets appended). With a\n     * bare `Request`, forwarding metadata is suppressed rather than passed through.\n     */\n    readonly forwardClientIp?: boolean;\n    /** Upstream response deadline in milliseconds. Default `30_000`; expiry answers `504`. */\n    readonly timeoutMs?: number;\n    /** Static headers to set on every forwarded request (after hygiene, so they always win). */\n    readonly headers?: Readonly<Record<string, string>>;\n}"
+  },
   {
     "name": "PublicDirCache",
     "kind": "interface",
@@ -7749,6 +8810,12 @@
     "signature": "export interface QueryHandle<T = unknown> {\n    snapshot: () => QueryState<T>;\n    subscribe: (listener: () => void) => () => void;\n    /** Fetch when stale or absent (fresh ⇒ no-op); joins an in-flight fetch (dedup). Resolves to the\n     * data, or rejects if the fetch threw. */\n    fetch: () => Promise<T>;\n    /** Refetch regardless of staleness (still joins an in-flight fetch). */\n    refetch: () => Promise<T>;\n}",
     "doc": "/** A stable per-key handle: subscribe to its state, read a snapshot, trigger a fetch/refetch. */"
   },
+  {
+    "name": "queryImpact",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function queryImpact(graph: WorkGraph, changedFiles: readonly string[]): ImpactReport;"
+  },
   {
     "name": "QueryOptions",
     "kind": "interface",
@@ -7995,6 +9062,19 @@
     "signature": "export declare function recordCapabilityOutcome(context: object, capability: string, options: CapabilityOutcomeOptions): void;",
     "doc": "/** Record the terminal outcome of an already-admitted capability without debiting admission twice. */"
   },
+  {
+    "name": "recordProof",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function recordProof(bundle: EvidenceBundle, proof: ProofEvidence): EvidenceBundle;"
+  },
+  {
+    "name": "recordTrajectory",
+    "kind": "const",
+    "package": "@nifrajs/testing",
+    "signature": "export declare const recordTrajectory: typeof createTrajectoryTranscript;",
+    "doc": "/** Alias that reads naturally at a call site which has just completed a run. */"
+  },
   {
     "name": "redactForEmission",
     "kind": "function",
@@ -8051,6 +9131,13 @@
     "signature": "export interface RedirectOptions {\n    /** HTTP status (default 303 See Other; pass 307/308 to preserve the method). */\n    readonly status?: number;\n    /** Allow an off-origin / absolute destination. Off by default: only a same-origin path (a single\n     * leading `/`) is permitted, so an action can't be turned into an open redirect by passing\n     * attacker-controlled input straight through. Set `true` for a deliberate external redirect. */\n    readonly external?: boolean;\n}",
     "doc": "/** Options for {@link redirect}. */"
   },
+  {
+    "name": "referenceFaultProfile",
+    "kind": "const",
+    "package": "@nifrajs/testing",
+    "signature": "export declare const referenceFaultProfile: FaultProfile;",
+    "doc": "/** A small smoke profile for consumers that only need to verify the harness wiring. */"
+  },
   {
     "name": "reflectClassification",
     "kind": "function",
@@ -8068,7 +9155,7 @@
     "name": "ReflectedRouteSchema",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface ReflectedRouteSchema {\n    readonly body?: SchemaReflection;\n    readonly query?: SchemaReflection;\n    /** Path-params schema - constraints (uuid format, integer min/max) declared via `params: t.object(…)`. */\n    readonly params?: SchemaReflection;\n    readonly response?: SchemaReflection;\n    readonly errors?: Readonly<Record<string, SchemaReflection>>;\n    /** The SSE event-payload schema of a typed streaming route (`app.sse()`). */\n    readonly sse?: SchemaReflection;\n}"
+    "signature": "export interface ReflectedRouteSchema {\n    /** Effective transport body policy; surfaced so upload/streaming exemptions are auditable. */\n    readonly bodyLimit?: number | \"unlimited\";\n    readonly bodyLimitReason?: string;\n    /** Request-header schema; names are normalized to lower-case at runtime. */\n    readonly headers?: SchemaReflection;\n    readonly body?: SchemaReflection;\n    readonly query?: SchemaReflection;\n    /** Path-params schema - constraints (uuid format, integer min/max) declared via `params: t.object(…)`. */\n    readonly params?: SchemaReflection;\n    readonly response?: SchemaReflection;\n    readonly errors?: Readonly<Record<string, SchemaReflection>>;\n    /** The SSE event-payload schema of a typed streaming route (`app.sse()`). */\n    readonly sse?: SchemaReflection;\n}"
   },
   {
     "name": "ReflectedSchemaField",
@@ -8098,6 +9185,12 @@
     "signature": "export declare function registerBlocker(shouldBlock: BlockerFunction, onChange: (blocker: Blocker) => void): () => void;",
     "doc": "/**\n * Register a navigation guard, returning an unregister function. `onChange` is called with the current\n * {@link Blocker} whenever its state changes (so the adapter can re-render its confirmation UI). Before\n * `installHistory` has run (SSR, pre-hydration), there's no controller: registration is a no-op and the\n * caller stays on {@link IDLE_BLOCKER}, degrading to native navigation. Called by an adapter's\n * `useBlocker`, not by app code directly.\n */"
   },
+  {
+    "name": "registerFixRecipe",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function registerFixRecipe(recipe: FixRecipe): void;"
+  },
   {
     "name": "registerFormat",
     "kind": "function",
@@ -8150,8 +9243,8 @@
     "name": "RenderAdapter",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface RenderAdapter {\n    /**\n     * Server: render a route's layout `chain` (outermost layout → page) to a **stream** of HTML\n     * bytes, including the framework's hydration markers. The page (innermost) receives `props`\n     * (the loader data); each layout wraps the child via its `children`. Returns (or resolves to)\n     * a Web `ReadableStream<Uint8Array>`: a streaming renderer flushes the shell first and streams\n     * Suspense boundaries as they resolve; a non-streaming renderer may return a one-chunk stream.\n     * May be async - e.g. React resolves once the shell is renderable, so a shell-render throw can\n     * still map to an error status before any byte is sent.\n     */\n    renderToStream(chain: readonly unknown[], props: RenderProps): ReadableStream<Uint8Array> | Promise<ReadableStream<Uint8Array>>;\n    /**\n     * Server (optional): render the chain to a complete HTML **string** in one pass, with the same\n     * hydration markers `renderToStream` produces. When provided, `renderPage` uses it for any page\n     * that does **not** `defer()` - buffering the document is faster than the streaming pipeline there,\n     * because the framework's synchronous renderer (React `renderToString`, Solid `renderToString`,\n     * Preact `render`, Vue `renderToString`, Svelte `render`) is markedly cheaper than its streaming\n     * renderer - most visibly on Bun, where React Fizz / Solid `renderToStream` are the heaviest. Pages\n     * that `defer()` keep the streaming path (progressive `<Await>` needs it). Markup MUST be\n     * hydration-equivalent to `renderToStream`; a throw surfaces like the streaming shell-readiness\n     * await (the `_error` boundary maps it to a status). Omit it to always stream.\n     */\n    renderToString?(chain: readonly unknown[], props: RenderProps): string | Promise<string>;\n    /**\n     * Server: per-document bootstrap markup injected into `<head>` that the client\n     * `hydrate` requires (Solid: `generateHydrationScript()`). Empty string if none.\n     */\n    hydrationHead(nonce?: string): string;\n}",
-    "doc": "/**\n * The seam every render adapter implements. New adapters should prove these invariants with\n * {@link assertRenderAdapterConformance}; framework-specific behavior remains locally tested.\n */"
+    "signature": "export interface RenderAdapter {\n    /**\n     * Render a route's layout `chain` (outermost layout → page) to a Web stream of HTML bytes,\n     * including the framework's hydration markers.\n     */\n    renderToStream(chain: readonly unknown[], props: RenderProps): ReadableStream<Uint8Array> | Promise<ReadableStream<Uint8Array>>;\n    /** Render the chain to a complete HTML string when no content is deferred. */\n    renderToString?(chain: readonly unknown[], props: RenderProps): string | Promise<string>;\n    /** Per-document bootstrap markup injected into `<head>` for client hydration. */\n    hydrationHead(nonce?: string): string;\n}",
+    "doc": "/**\n * The seam every render adapter implements. New adapters should prove these invariants with\n * `assertRenderAdapterConformance`; framework-specific behavior remains locally tested.\n */"
   },
   {
     "name": "RenderAdapterConformanceError",
@@ -8224,8 +9317,8 @@
     "name": "RenderProps",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface RenderProps {\n    readonly data: unknown;\n    /**\n     * Per-layout loader data, aligned index-for-index with the layout prefix of `chain`.\n     *\n     * Absent when no layout in the chain exports a `loader`, so a page-only app is byte-identical to\n     * before. An adapter that does not read it renders exactly as it did; one that does passes\n     * `layoutData[i]` to `chain[i]`.\n     */\n    readonly layoutData?: readonly unknown[];\n    readonly actionData?: unknown;\n    /** True while a client navigation or submit is in flight (client-only; absent/false on SSR). */\n    readonly pending?: boolean;\n    /** The path a client navigation is transitioning TO while `pending` (client-only; absent on SSR and\n     * when idle). Lets an adapter tell a `NavLink` whether its own target is the one loading. */\n    readonly pendingPath?: string;\n    /** The in-flight client submit, for optimistic UI (client-only; absent on SSR + when idle). */\n    readonly submission?: Submission;\n    /** The matched route's decoded path params (`/users/:id` → `{ id: \"7\" }`). Threaded identically on\n     * SSR (from the request match) and on client navigation (from router state) so an adapter's\n     * `useParams` reads the same value on both, with no hydration mismatch. Absent ⇒ no params (`{}`). */\n    readonly params?: Readonly<Record<string, string>>;\n    /** The current URL's `pathname + search` (no hash - the hash never reaches the server). Threaded on\n     * SSR and client alike so an adapter's `useLocation`/`useSearchParams` hydrate consistently. Absent\n     * on adapters/callers that don't supply it (treated as `\"\"`). */\n    readonly path?: string;\n    /** The route's typed, validated search params (the value the loader also gets as `ctx.search`),\n     * threaded to the adapter's `useSearch`. Derived identically on SSR (from the request) and on client\n     * navigation (adapter mount) via the shared `searchOf`, so a component reading it hydrates with no\n     * drift. Absent ⇒ no search context (`{}`). */\n    readonly search?: Record<string, unknown>;\n}",
-    "doc": "/** The data handed to a route component. Opaque to the core. `actionData` is the return of a\n * route `action` after a POST (absent on plain GETs). `pending` + `submission` are client-only\n * (absent on SSR): they drive **optimistic UI** - render from `submission.formData` while `pending`. */"
+    "signature": "export interface RenderProps {\n    readonly data: unknown;\n    /** Per-layout loader data, aligned index-for-index with the layout prefix of `chain`. */\n    readonly layoutData?: readonly unknown[];\n    readonly actionData?: unknown;\n    /** True while a client navigation or submit is in flight (client-only; absent/false on SSR). */\n    readonly pending?: boolean;\n    /** The path a client navigation is transitioning TO while `pending` (client-only; absent on SSR). */\n    readonly pendingPath?: string;\n    /** The in-flight client submit, for optimistic UI (client-only; absent on SSR). */\n    readonly submission?: Submission;\n    /** The matched route's decoded path params. */\n    readonly params?: Readonly<Record<string, string>>;\n    /** The current URL's `pathname + search` (no hash). */\n    readonly path?: string;\n    /** The route's typed, validated search params. */\n    readonly search?: Record<string, unknown>;\n}",
+    "doc": "/** The data handed to a route component. */"
   },
   {
     "name": "renderRouteManifest",
@@ -8241,6 +9334,31 @@
     "signature": "export declare function renderSizeReport(report: SizeReport): string;",
     "doc": "/**\n * Render a {@link SizeReport} as a terse aligned table (biggest first) with a totals row - the text\n * `nifra build --report` prints. Pure (string in, string out) so the formatting is unit-testable.\n */"
   },
+  {
+    "name": "renderWorkGraphJson",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function renderWorkGraphJson(result: ProjectWorkGraphResult): string;"
+  },
+  {
+    "name": "renderWorkGraphText",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function renderWorkGraphText(result: ProjectWorkGraphResult): string;"
+  },
+  {
+    "name": "replayAgent",
+    "kind": "function",
+    "package": "@nifrajs/agent",
+    "signature": "export declare function replayAgent<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1>(definition: AgentDefinition<InputSchema, OutputSchema>, input: AgentTurnInput, ports: Omit<AgentPorts, \"model\">, transcript: AgentTranscript, options: RunAgentOptions): Promise<AgentRunResult<NonNullable<OutputSchema[\"~standard\"][\"types\"]>[\"output\"]>>;"
+  },
+  {
+    "name": "ReplayFile",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ReplayFile {\n    readonly version: 1;\n    readonly gate: string;\n    readonly case: string;\n    readonly seed: string;\n    readonly inputsDigest: string;\n    readonly meta: Readonly<Record<string, unknown>>;\n}",
+    "doc": "/** Versioned, token-only replay metadata shared by verification tools. */"
+  },
   {
     "name": "replayIncident",
     "kind": "function",
@@ -8254,6 +9372,19 @@
     "package": "@nifrajs/testing",
     "signature": "export interface ReplayIncidentOptions {\n    readonly origin?: string;\n    /** Also require the response body SHAPE to match the captured shape (not just status). Default false. */\n    readonly assertShape?: boolean;\n}"
   },
+  {
+    "name": "replayTrajectory",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function replayTrajectory<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1>(definition: AgentDefinition<InputSchema, OutputSchema>, input: AgentTurnInput, ports: Omit<AgentPorts, \"model\">, transcript: TrajectoryTranscript, options: ReplayTrajectoryOptions): Promise<TrajectoryReplayResult<NonNullable<OutputSchema[\"~standard\"][\"types\"]>[\"output\"]>>;",
+    "doc": "/**\n * Replay a recorded run with local model decisions and dry-run tools. The supplied model port is\n * never called. Fault schedules use the existing deterministic failure-lab controller.\n */"
+  },
+  {
+    "name": "ReplayTrajectoryOptions",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface ReplayTrajectoryOptions {\n    readonly state: AgentTurnState;\n    readonly maxTurns?: number;\n    readonly goal?: (output: unknown) => boolean;\n    readonly faultProfile?: FaultProfile;\n    readonly seed?: number;\n}"
+  },
   {
     "name": "reproduciblePath",
     "kind": "function",
@@ -8272,8 +9403,8 @@
     "name": "requestId",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function requestId(options?: RequestIdOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").Server<any, any>>;",
-    "doc": "/**\n * A {@link definePlugin} plugin that gives every request a stable id: it reuses an inbound\n * `x-request-id` (or generates one), exposes it on the handler context as **`c.requestId`** (typed,\n * threaded by `derive`), and echoes it on the response header. Idempotent - applying it twice is a\n * no-op.\n *\n * ```ts\n * app.use(requestId())          // c.requestId available downstream; X-Request-Id on responses\n * ```\n */"
+    "signature": "export declare function requestId(options?: RequestIdOptions): ContextPlugin<{\n    requestId: string;\n}>;",
+    "doc": "/**\n * A {@link defineContextPlugin} plugin that gives every request a stable id: it reuses an inbound\n * `x-request-id` (or generates one), exposes it on the handler context as **`c.requestId`** (typed,\n * threaded by `derive`), and echoes it on EVERY response leaving the app - handler-returned raw\n * `Response`s and redirects, `onRequest` short-circuits (an auth 401, an admission 429), and\n * framework-generated 404/405/422/timeout responses included. Core deliberately does not merge\n * `c.set.headers` onto a handler-returned `Response`, so the echo lives in an app-global\n * `onResponse` hook (paired with the derive through a `WeakMap` keyed on the request) with a node\n * twin, keeping the Node adapter on its direct writer with no request-walk cost. Idempotent -\n * applying it twice is a no-op.\n *\n * ```ts\n * app.use(requestId())          // c.requestId available downstream; X-Request-Id on responses\n * ```\n */"
   },
   {
     "name": "RequestIdOptions",
@@ -8381,6 +9512,12 @@
     "package": "@nifrajs/image",
     "signature": "export interface ResolvedImage {\n    readonly src: string;\n    readonly srcSet?: string;\n    readonly sizes?: string;\n    readonly width: number;\n    readonly height: number;\n    readonly alt: string;\n    readonly loading: \"lazy\" | \"eager\";\n    readonly decoding: \"async\";\n    readonly fetchPriority?: \"high\";\n}"
   },
+  {
+    "name": "ResolvedLocale",
+    "kind": "interface",
+    "package": "@nifrajs/i18n",
+    "signature": "export interface ResolvedLocale {\n    /** Always a member of `locales` (or `defaultLocale`) - never raw request input. */\n    readonly locale: Locale;\n    readonly source: LocaleSource;\n    /** The supported locale the request's cookie currently resolves to, when\n     * {@link NegotiateOptions.cookie} is configured and the cookie holds a valid value. Lets a caller\n     * persist a new choice only when it actually differs. */\n    readonly cookie?: Locale;\n}"
+  },
   {
     "name": "resolveImage",
     "kind": "function",
@@ -8388,6 +9525,13 @@
     "signature": "export declare function resolveImage(props: ImageProps, loader?: ImageLoader): ResolvedImage;",
     "doc": "/**\n * Resolve {@link ImageProps} + an {@link ImageLoader} into `<img>` attributes. CLS-safe (`width`/\n * `height` required + > 0, else a dev error), lazy + async-decoding by default, with a responsive\n * `srcSet` built from `widths` via the loader. If every width produces the same URL (e.g.\n * {@link identityLoader}), `srcSet` is omitted (it'd be redundant).\n */"
   },
+  {
+    "name": "resolveLocale",
+    "kind": "function",
+    "package": "@nifrajs/i18n",
+    "signature": "export declare function resolveLocale(request: Request | LocaleParts, options: NegotiateOptions): ResolvedLocale;",
+    "doc": "/**\n * Negotiate the request's locale and report which source chose it. Order: a valid\n * {@link NegotiateOptions.queryParam} value → a valid {@link NegotiateOptions.cookie} value →\n * `Accept-Language` (each `q`-ranked tag, exact then base-subtag) → `defaultLocale`.\n */"
+  },
   {
     "name": "resolveMeta",
     "kind": "function",
@@ -8582,6 +9726,13 @@
     "signature": "export interface ResponseHeadersView {\n    get(name: string): string | null;\n    has(name: string): boolean;\n    set(name: string, value: string): void;\n    append(name: string, value: string): void;\n    delete(name: string): void;\n}",
     "doc": "/**\n * The mutable, case-insensitive header surface a portable {@link ResponseHeadersHook} writes\n * through. Deliberately the subset of the Web `Headers` interface every runtime can satisfy\n * natively: on the Web paths the hook receives the response's own `Headers` object directly (which\n * structurally implements this), and on the Node direct-writer path it receives a thin view over\n * the outcome's plain header record - so ONE hook implementation is fast everywhere.\n */"
   },
+  {
+    "name": "ResponseStream",
+    "kind": "interface",
+    "package": "@nifrajs/aws-lambda",
+    "signature": "export interface ResponseStream {\n    write(chunk: Uint8Array | string): unknown;\n    end(): unknown;\n    once?(event: string, listener: () => void): unknown;\n}",
+    "doc": "/** The Node `Writable`-shaped stream Lambda hands a streaming handler. Declared structurally. */"
+  },
   {
     "name": "Result",
     "kind": "type",
@@ -8589,6 +9740,13 @@
     "signature": "export type Result<Data, Errors = unknown> = {\n    readonly ok: true;\n    readonly status: number;\n    readonly data: Data;\n    readonly error: null;\n} | ([Errors] extends [Record<number, unknown>] ? DeclaredFailures<Errors> | {\n    readonly ok: false;\n    readonly status: Exclude<ErrorStatus, Extract<keyof Errors, number>> | 0;\n    readonly data: unknown;\n    readonly error: ApiError;\n} : {\n    readonly ok: false;\n    readonly status: number;\n    readonly data: Errors;\n    readonly error: ApiError;\n});",
     "doc": "/**\n * The outcome of a client call. The client never throws - inspect `ok` to branch.\n *\n * On success, `data` is the route's response type. On failure the union is DISCRIMINATED BY\n * `status` when the route declares an `errors` record: `status === 404` narrows `data` to the\n * declared 404 body; every undeclared status (plus `0` for a transport error with no response)\n * falls into a fallback arm whose `data` is `unknown`. A route with no `errors` contract keeps a\n * single failure arm with `data: Errors` (`unknown`). `error` is always the server's normalized\n * `{ error, issues? }` summary on failure, `null` on success.\n */"
   },
+  {
+    "name": "resumeAgent",
+    "kind": "function",
+    "package": "@nifrajs/agent",
+    "signature": "export declare function resumeAgent<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1>(definition: AgentDefinition<InputSchema, OutputSchema>, turnId: string, input: AgentTurnInput, ports: AgentPorts, options?: Omit<RunAgentOptions, \"state\">): Promise<AgentRunResult<NonNullable<OutputSchema[\"~standard\"][\"types\"]>[\"output\"]>>;",
+    "doc": "/** Load a saved token-only state record and continue a bounded run. */"
+  },
   {
     "name": "ResvgConstructor",
     "kind": "type",
@@ -8712,14 +9870,14 @@
     "kind": "const",
     "package": "@nifrajs/web",
     "signature": "export declare const ROOT_ATTRIBUTE = \"data-nifra-root\";",
-    "doc": "/**\n * Marker attribute on the app container, emitted ONLY when `rootId` is not the default.\n *\n * `rootId` is a per-RENDER option; the client entry is a per-BUILD artifact, so it cannot be\n * generated knowing which id a given render will use. The container therefore announces itself, and\n * the entry finds it by this attribute before falling back to `#root`. It has to be the DOM rather\n * than another `window.__NIFRA_*` global: a second copy of the id can drift from the markup, while\n * this is written by the same expression that writes the id and cannot.\n *\n * Absent on a default render, so an app that never sets `rootId` emits the same bytes it always has.\n */"
+    "doc": "/** Marker attribute used to find a non-default hydration container. */"
   },
   {
     "name": "ROUTE_GLOBAL",
     "kind": "const",
     "package": "@nifrajs/web",
     "signature": "export declare const ROUTE_GLOBAL = \"__NIFRA_ROUTE__\";",
-    "doc": "/** Global the server writes the matched route id into; the client uses it to pick the chain. */"
+    "doc": "/** Global the server writes the matched route id into. */"
   },
   {
     "name": "RouteBody",
@@ -8745,7 +9903,7 @@
     "name": "RouteChange",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface RouteChange {\n    readonly severity: DiffSeverity;\n    readonly method: string;\n    readonly path: string;\n    /** Which part of the contract changed; \"route\" for add/remove of the whole route. */\n    readonly section: \"route\" | \"body\" | \"query\" | \"response\" | \"sse\" | \"errors\";\n    /** The top-level field (or error status) the change is about, when field-granular. */\n    readonly field?: string;\n    readonly message: string;\n}"
+    "signature": "export interface RouteChange {\n    readonly severity: DiffSeverity;\n    readonly method: string;\n    readonly path: string;\n    /** Which part of the contract changed; \"route\" for add/remove of the whole route. */\n    readonly section: \"route\" | \"headers\" | \"body\" | \"query\" | \"response\" | \"sse\" | \"errors\";\n    /** The top-level field (or error status) the change is about, when field-granular. */\n    readonly field?: string;\n    readonly message: string;\n}"
   },
   {
     "name": "routeClassification",
@@ -8772,14 +9930,14 @@
     "name": "RouteConfigErrorCode",
     "kind": "type",
     "package": "@nifrajs/core",
-    "signature": "export type RouteConfigErrorCode = \"DUPLICATE_ROUTE\" | \"DUPLICATE_PARAM\" | \"PARAM_NAME_CONFLICT\" | \"INVALID_PATH\" | \"INVALID_PARAM_NAME\" | \"WILDCARD_NOT_LAST\" | \"INVALID_METHOD\" | \"INVALID_ASSURANCE\" | \"INVALID_IDEMPOTENCY\";",
+    "signature": "export type RouteConfigErrorCode = \"DUPLICATE_ROUTE\" | \"DUPLICATE_PARAM\" | \"PARAM_NAME_CONFLICT\" | \"INVALID_PATH\" | \"INVALID_PARAM_NAME\" | \"WILDCARD_NOT_LAST\" | \"INVALID_METHOD\" | \"INVALID_ASSURANCE\" | \"INVALID_IDEMPOTENCY\" | \"INVALID_BODY_LIMIT\";",
     "doc": "/** Stable codes for boot-time (L2) route configuration failures. */"
   },
   {
     "name": "RouteConfigErrorCode",
     "kind": "type",
     "package": "nifra",
-    "signature": "export type RouteConfigErrorCode = \"DUPLICATE_ROUTE\" | \"DUPLICATE_PARAM\" | \"PARAM_NAME_CONFLICT\" | \"INVALID_PATH\" | \"INVALID_PARAM_NAME\" | \"WILDCARD_NOT_LAST\" | \"INVALID_METHOD\" | \"INVALID_ASSURANCE\" | \"INVALID_IDEMPOTENCY\";",
+    "signature": "export type RouteConfigErrorCode = \"DUPLICATE_ROUTE\" | \"DUPLICATE_PARAM\" | \"PARAM_NAME_CONFLICT\" | \"INVALID_PATH\" | \"INVALID_PARAM_NAME\" | \"WILDCARD_NOT_LAST\" | \"INVALID_METHOD\" | \"INVALID_ASSURANCE\" | \"INVALID_IDEMPOTENCY\" | \"INVALID_BODY_LIMIT\";",
     "doc": "/** Stable codes for boot-time (L2) route configuration failures. */"
   },
   {
@@ -8863,7 +10021,7 @@
     "name": "RouteModule",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface RouteModule {\n    readonly default: unknown;\n    readonly loader?: Loader;\n    readonly action?: Action;\n    /** A Standard Schema validating this route's URL search params. When present, `ctx.search` is parsed +\n     * validated against it (failing closed to the schema's defaults on invalid input); type it into the\n     * loader with `LoaderArgs<Api, Env, typeof searchSchema>`. */\n    readonly searchSchema?: StandardSchemaV1<unknown, Record<string, unknown>>;\n    /** Search keys that are purely client-side UI (`\"tab\"`, a client-side `\"sort\"`, `\"modal\"`) and do NOT\n     * affect this route's loader. When a client navigation stays on the same route + pathname and changes\n     * ONLY these keys, the router updates the URL (so `useSearch` re-renders) WITHOUT re-running the loader.\n     * Any other key change revalidates as usual - so omitting a data-affecting key here can never serve\n     * stale data, it only forgoes the optimization. Client-only: the server always renders fresh. */\n    readonly searchClientKeys?: readonly string[];\n    readonly meta?: MetaInput;\n    /**\n     * Opt this route out of nifra's full-document client hydration. The server still renders the full\n     * HTML document, loaders/actions still run, and native links/forms still work; the generated app\n     * client, route chunks, and loader globals are omitted for hard navigations. Intended for static or\n     * island-hydrated pages where interactivity is mounted by smaller, explicit client entries.\n     */\n    readonly hydrate?: boolean;\n    /**\n     * Opt a **static** route (no `:param`/`*`) into build-time prerendering (SSG): `prerenderRoutes`\n     * (from `@nifrajs/web/build`) renders it to a static `index.html` at build. The loader runs at build\n     * with the in-process `api` (build-safe data only - no per-request cookies/secrets); `defer()` on a\n     * prerendered route resolves at build. For **dynamic** routes use {@link getStaticPaths} instead.\n     */\n    readonly prerender?: boolean;\n    /**\n     * Enumerate the concrete params to prerender for a **dynamic** (`:param`) route - the SSG path list\n     * (blogs/docs/etc.). Runs at build; `prerenderRoutes` renders one `index.html` per returned path.\n     */\n    readonly getStaticPaths?: GetStaticPaths;\n    /**\n     * ISR freshness for this route, in **seconds**. `createWebApp` emits it as an `x-nifra-revalidate`\n     * response header that `withISR` reads to set the page's cache TTL (overriding the wrapper's\n     * default). Older-than-`revalidate` cached pages are served stale while regenerating.\n     */\n    readonly revalidate?: number;\n    /** Optional bounded tags used by ISR on-demand invalidation (`?tag=...`). */\n    readonly revalidateTags?: readonly string[];\n    /**\n     * No-framework island bundles (`@nifrajs/web/islands`) to load on this route, as `<script\n     * type=\"module\">` in the document tail. Loaded **regardless of `hydrate`** - pair with\n     * `export const hydrate = false` for a static page that ships zero framework JS and mounts\n     * interactivity through `<Island>` markers + `mountIslands` enhancers instead.\n     */\n    readonly islandScripts?: readonly string[];\n}",
+    "signature": "export interface RouteModule {\n    readonly default: unknown;\n    readonly loader?: Loader;\n    readonly action?: Action;\n    /** A Standard Schema validating this route's URL search params. When present, `ctx.search` is parsed +\n     * validated against it (failing closed to the schema's defaults on invalid input); type it into the\n     * loader with `LoaderArgs<Api, Env, typeof searchSchema>`. */\n    readonly searchSchema?: StandardSchemaV1<unknown, Record<string, unknown>>;\n    /** Search keys that are purely client-side UI (`\"tab\"`, a client-side `\"sort\"`, `\"modal\"`) and do NOT\n     * affect this route's loader. When a client navigation stays on the same route + pathname and changes\n     * ONLY these keys, the router updates the URL (so `useSearch` re-renders) WITHOUT re-running the loader.\n     * Any other key change revalidates as usual - so omitting a data-affecting key here can never serve\n     * stale data, it only forgoes the optimization. Client-only: the server always renders fresh. */\n    readonly searchClientKeys?: readonly string[];\n    readonly meta?: MetaInput;\n    /**\n     * Opt this route out of nifra's full-document client hydration. The server still renders the full\n     * HTML document, loaders/actions still run, and native links/forms still work; the generated app\n     * client, route chunks, and loader globals are omitted for hard navigations. Intended for static or\n     * island-hydrated pages where interactivity is mounted by smaller, explicit client entries.\n     */\n    readonly hydrate?: boolean;\n    /**\n     * Opt a **static** route (no `:param`/`*`) into build-time prerendering (SSG): `prerenderRoutes`\n     * (from `@nifrajs/web/build`) renders it to a static `index.html` at build. The loader runs at build\n     * with the in-process `api` (build-safe data only - no per-request cookies/secrets); `defer()` on a\n     * prerendered route resolves at build. For **dynamic** routes use {@link getStaticPaths} instead.\n     */\n    readonly prerender?: boolean;\n    /**\n     * Enumerate the concrete params to prerender for a **dynamic** (`:param`) route - the SSG path list\n     * (blogs/docs/etc.). Runs at build; `prerenderRoutes` renders one `index.html` per returned path.\n     */\n    readonly getStaticPaths?: GetStaticPaths;\n    /**\n     * ISR freshness for this route, in **seconds**. `createWebApp` emits it as an\n     * `x-nifra-isr-revalidate` response header that `withISR` reads to set the page's cache TTL\n     * (overriding the wrapper's default). Older-than-`revalidate` cached pages are served stale while\n     * regenerating. (Distinct from the action-revalidation `x-nifra-revalidate` header - a CSV path\n     * list the client parses to refetch - so the two channels never alias.)\n     */\n    readonly revalidate?: number;\n    /** Optional bounded tags used by ISR on-demand invalidation (`?tag=...`). */\n    readonly revalidateTags?: readonly string[];\n    /**\n     * No-framework island bundles (`@nifrajs/web/islands`) to load on this route, as `<script\n     * type=\"module\">` in the document tail. Loaded **regardless of `hydrate`** - pair with\n     * `export const hydrate = false` for a static page that ships zero framework JS and mounts\n     * interactivity through `<Island>` markers + `mountIslands` enhancers instead.\n     */\n    readonly islandScripts?: readonly string[];\n}",
     "doc": "/** A route module - the default component + optional loader / action / meta. */"
   },
   {
@@ -8944,14 +10102,14 @@
     "name": "RouteSchema",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface RouteSchema {\n    /** Declared effect tokens. Reflected for assurance; never read by validation or serialization. */\n    readonly capabilities?: readonly string[];\n    /**\n     * Dedupe retries of this (mutating) route on an `Idempotency-Key` header. The first request runs and\n     * its response is stored; a retry with the same key replays that response without re-running the\n     * handler, and a key reused with a different body is rejected (409). A missing key on an\n     * idempotency-required route fails closed (400). Off the hot path - routes without it are unchanged.\n     */\n    readonly idempotency?: IdempotencyConfig;\n    /**\n     * Highest data-sensitivity this route's response body carries (`public` | `pii` | `secret`). A\n     * declarative, compile-time + introspection fact - never validated at runtime. Reflected for tooling,\n     * recorded in the capability lockfile (so a route that starts returning PII is a reviewable change),\n     * and read by downstream policy (e.g. a partner-API surface refusing to expose `pii`/`secret`).\n     */\n    readonly classification?: DataClassification;\n    /**\n     * Inline **route-assurance evidence**: the enforcement posture this route carries, declared adjacent to\n     * the handler (e.g. `[NIFRA_ASSURANCE.AUTHENTICATED]`). Each id becomes route-scoped `declared` evidence\n     * in reflection, so a `nifra.assurance.ts` policy `require:` clause is satisfiable WITHOUT rewriting an\n     * in-handler guard into a `withRouteAssurance`-marked middleware. Ids are lowercase dot/dash segments\n     * (invalid ids throw at registration). Reflected for the assurance gate; never read on the hot path.\n     *\n     * This is an author ASSERTION (recorded as `source: \"declared\"`), not runtime proof - like every\n     * assurance marker it is trusted by the static gate, which matches on the evidence id, not its source.\n     * Declare an id only on a route whose guard actually enforces it; a false declaration silently satisfies\n     * the policy. (`source` is retained in reflection, so a stricter policy or reviewer can still tell\n     * declared evidence from enforcement-module evidence.)\n     */\n    readonly assurance?: readonly string[];\n    /**\n     * Mark this route a **dynamic route family**: a template (`/api/:slug/:resource`) whose concrete\n     * resources are resolved at runtime (auto-CRUD over tenant-defined tables, a catch-all dispatcher).\n     * Purely declarative - it does not change dispatch. It surfaces in reflection so the assurance gate and\n     * tooling treat the one templated route as a deliberate family whose evidence covers every runtime-\n     * resolved resource, instead of reading it as a single forgotten route.\n     */\n    readonly family?: boolean;\n    /** Optional **path-params schema**. Path params arrive as strings (`/users/:id` -> `c.params.id`);\n     * declaring a schema validates them at the boundary (a malformed `:id` is a `422` before the handler,\n     * like `body`/`query`) and can coerce them (use `t.query({ id: t.integer() })` for a numeric param).\n     * The schema must cover every path param; with the strict default an undeclared path param is rejected.\n     * When omitted, `c.params` stays the path-inferred `Record<name, string>`. */\n    readonly params?: StandardSchemaV1;\n    readonly body?: StandardSchemaV1;\n    readonly query?: StandardSchemaV1;\n    /** Optional **response contract**. When declared: the handler's return is type-checked against it\n     * (the implementation can't drift from the contract), the typed client sees THIS as the response type\n     * (the contract - not the handler's incidental return), and it's emitted into OpenAPI/JSON-Schema so\n     * tooling and coding agents can read the exact shape. It is **not** validated at runtime (zero\n     * hot-path cost) - purely a compile-time + introspection contract. */\n    readonly response?: StandardSchemaV1;\n    /**\n     * Optional **error-response contract**: a map of HTTP status code → the Standard Schema of that error's\n     * body. Declares a route's failure modes so they flow into OpenAPI (as non-2xx `responses`), the\n     * `/llms.txt` context, and other introspection - the whole contract, not just the happy path, is legible\n     * to tooling and coding agents. Like `response`, it is **not** validated at runtime (zero hot-path cost);\n     * it's a compile-time + introspection contract. Example: `{ 404: NotFound, 409: Conflict }`. */\n    readonly errors?: Readonly<Record<number, StandardSchemaV1>>;\n    /**\n     * Optional **SSE event contract**: the Standard Schema of each event's `data` payload on a\n     * streaming route (declared via `app.sse()`). Marks the route as a typed event stream - the\n     * typed client grows a `.subscribe()` for it, and the schema flows into reflection. Like\n     * `response`, it is **not** validated at runtime (zero hot-path cost); the server-side\n     * `stream.send()` is compile-time-checked against it instead.\n     */\n    readonly sse?: StandardSchemaV1;\n    /**\n     * Hook fired when the request fails `body`/`query` validation, before the handler runs. `kind` says\n     * which input failed (`\"body\"` | `\"query\"`). Its return value selects one of three outcomes (may be async):\n     *   - a **`Response`** → returned as-is, short-circuiting the route (custom error envelope, redirect, …).\n     *   - **any other value** → treated as a repaired payload and **re-validated once** against the same\n     *     schema. If it now passes, the handler runs with it; if it still fails, the original `422` stands.\n     *     Re-validation means a bad return can't bypass the schema - the trust boundary holds.\n     *   - **`undefined`** → give up; the original validation `422` is returned unchanged.\n     * A route hook **overrides** the app-wide default set via `server({ onValidationError })`; return\n     * `undefined` to fall through to the plain `422` even when an app default exists. Typical uses: a custom\n     * error envelope, coercing the input, or prompting an LLM to repair the payload (re-validated, so it can't\n     * bypass the schema).\n     */\n    readonly onValidationError?: (issues: ReadonlyArray<StandardIssue>, ctx: Context, kind: \"body\" | \"query\" | \"params\") => Response | unknown | Promise<Response | unknown>;\n}",
+    "signature": "export interface RouteSchema {\n    /** Transport body cap for this route. Defaults to the server's maxBodyBytes. Use a finite\n     * smaller/larger limit for a specific endpoint. The 'unlimited' value is an explicit\n     * streaming/upload exemption and requires a non-empty bodyLimitReason for auditability. */\n    readonly bodyLimit?: number | \"unlimited\";\n    /** Required explanation when bodyLimit is 'unlimited' (for example, a streaming upload is\n     * bounded by an upstream object-store protocol). */\n    readonly bodyLimitReason?: string;\n    /** Declared effect tokens. Reflected for assurance; never read by validation or serialization. */\n    readonly capabilities?: readonly string[];\n    /**\n     * Dedupe retries of this (mutating) route on an `Idempotency-Key` header. The first request runs and\n     * its response is stored; a retry with the same key replays that response without re-running the\n     * handler, and a key reused with a different body is rejected (409). A missing key on an\n     * idempotency-required route fails closed (400). Off the hot path - routes without it are unchanged.\n     */\n    readonly idempotency?: IdempotencyConfig;\n    /**\n     * Highest data-sensitivity this route's response body carries (`public` | `pii` | `secret`). A\n     * declarative, compile-time + introspection fact - never validated at runtime. Reflected for tooling,\n     * recorded in the capability lockfile (so a route that starts returning PII is a reviewable change),\n     * and read by downstream policy (e.g. a partner-API surface refusing to expose `pii`/`secret`).\n     */\n    readonly classification?: DataClassification;\n    /**\n     * Inline **route-assurance evidence**: the enforcement posture this route carries, declared adjacent to\n     * the handler (e.g. `[NIFRA_ASSURANCE.AUTHENTICATED]`). Each id becomes route-scoped `declared` evidence\n     * in reflection, so a `nifra.assurance.ts` policy `require:` clause is satisfiable WITHOUT rewriting an\n     * in-handler guard into a `withRouteAssurance`-marked middleware. Ids are lowercase dot/dash segments\n     * (invalid ids throw at registration). Reflected for the assurance gate; never read on the hot path.\n     *\n     * This is an author ASSERTION (recorded as `source: \"declared\"`), not runtime proof - like every\n     * assurance marker it is trusted by the static gate, which matches on the evidence id, not its source.\n     * Declare an id only on a route whose guard actually enforces it; a false declaration silently satisfies\n     * the policy. (`source` is retained in reflection, so a stricter policy or reviewer can still tell\n     * declared evidence from enforcement-module evidence.)\n     */\n    readonly assurance?: readonly string[];\n    /**\n     * Mark this route a **dynamic route family**: a template (`/api/:slug/:resource`) whose concrete\n     * resources are resolved at runtime (auto-CRUD over tenant-defined tables, a catch-all dispatcher).\n     * Purely declarative - it does not change dispatch. It surfaces in reflection so the assurance gate and\n     * tooling treat the one templated route as a deliberate family whose evidence covers every runtime-\n     * resolved resource, instead of reading it as a single forgotten route.\n     */\n    readonly family?: boolean;\n    /** Optional **path-params schema**. Path params arrive as strings (`/users/:id` -> `c.params.id`);\n     * declaring a schema validates them at the boundary (a malformed `:id` is a `422` before the handler,\n     * like `body`/`query`) and can coerce them (use `t.query({ id: t.integer() })` for a numeric param).\n     * The schema must cover every path param; with the strict default an undeclared path param is rejected.\n     * When omitted, `c.params` stays the path-inferred `Record<name, string>`. */\n    readonly params?: StandardSchemaV1;\n    /** Optional request-header schema. Header names are normalized to lower-case and the validated\n     * output is exposed as `c.headers`; use lower-case keys because HTTP header names are\n     * case-insensitive. */\n    readonly headers?: StandardSchemaV1;\n    readonly body?: StandardSchemaV1;\n    readonly query?: StandardSchemaV1;\n    /** Optional **response contract**. When declared: the handler's return is type-checked against it\n     * (the implementation can't drift from the contract), the typed client sees THIS as the response type\n     * (the contract - not the handler's incidental return), and it's emitted into OpenAPI/JSON-Schema so\n     * tooling and coding agents can read the exact shape. It is **not** validated at runtime (zero\n     * hot-path cost) - purely a compile-time + introspection contract. */\n    readonly response?: StandardSchemaV1;\n    /**\n     * Optional **error-response contract**: a map of HTTP status code → the Standard Schema of that error's\n     * body. Declares a route's failure modes so they flow into OpenAPI (as non-2xx `responses`), the\n     * `/llms.txt` context, and other introspection - the whole contract, not just the happy path, is legible\n     * to tooling and coding agents. Like `response`, it is **not** validated at runtime (zero hot-path cost);\n     * it's a compile-time + introspection contract. Example: `{ 404: NotFound, 409: Conflict }`. */\n    readonly errors?: Readonly<Record<number, StandardSchemaV1>>;\n    /**\n     * Optional **SSE event contract**: the Standard Schema of each event's `data` payload on a\n     * streaming route (declared via `app.sse()`). Marks the route as a typed event stream - the\n     * typed client grows a `.subscribe()` for it, and the schema flows into reflection. Like\n     * `response`, it is **not** validated at runtime (zero hot-path cost); the server-side\n     * `stream.send()` is compile-time-checked against it instead.\n     */\n    readonly sse?: StandardSchemaV1;\n    /**\n     * Hook fired when the request fails `headers`/`params`/`body`/`query` validation, before the handler\n     * runs. `kind` says which input failed. Its return value selects one of three outcomes (may be async):\n     *   - a **`Response`** → returned as-is, short-circuiting the route (custom error envelope, redirect, …).\n     *   - **any other value** → treated as a repaired payload and **re-validated once** against the same\n     *     schema. If it now passes, the handler runs with it; if it still fails, the original `422` stands.\n     *     Re-validation means a bad return can't bypass the schema - the trust boundary holds.\n     *   - **`undefined`** → give up; the original validation `422` is returned unchanged.\n     * A route hook **overrides** the app-wide default set via `server({ onValidationError })`; return\n     * `undefined` to fall through to the plain `422` even when an app default exists. Typical uses: a custom\n     * error envelope, coercing the input, or prompting an LLM to repair the payload (re-validated, so it can't\n     * bypass the schema).\n     */\n    readonly onValidationError?: (issues: ReadonlyArray<StandardIssue>, ctx: Context, kind: \"body\" | \"query\" | \"params\" | \"headers\") => Response | unknown | Promise<Response | unknown>;\n}",
     "doc": "/** Per-route input schemas. Each is any Standard Schema (zod/valibot/arktype/…). */"
   },
   {
     "name": "RouteSchema",
     "kind": "interface",
     "package": "nifra",
-    "signature": "export interface RouteSchema {\n    /** Declared effect tokens. Reflected for assurance; never read by validation or serialization. */\n    readonly capabilities?: readonly string[];\n    /**\n     * Dedupe retries of this (mutating) route on an `Idempotency-Key` header. The first request runs and\n     * its response is stored; a retry with the same key replays that response without re-running the\n     * handler, and a key reused with a different body is rejected (409). A missing key on an\n     * idempotency-required route fails closed (400). Off the hot path - routes without it are unchanged.\n     */\n    readonly idempotency?: IdempotencyConfig;\n    /**\n     * Highest data-sensitivity this route's response body carries (`public` | `pii` | `secret`). A\n     * declarative, compile-time + introspection fact - never validated at runtime. Reflected for tooling,\n     * recorded in the capability lockfile (so a route that starts returning PII is a reviewable change),\n     * and read by downstream policy (e.g. a partner-API surface refusing to expose `pii`/`secret`).\n     */\n    readonly classification?: DataClassification;\n    /**\n     * Inline **route-assurance evidence**: the enforcement posture this route carries, declared adjacent to\n     * the handler (e.g. `[NIFRA_ASSURANCE.AUTHENTICATED]`). Each id becomes route-scoped `declared` evidence\n     * in reflection, so a `nifra.assurance.ts` policy `require:` clause is satisfiable WITHOUT rewriting an\n     * in-handler guard into a `withRouteAssurance`-marked middleware. Ids are lowercase dot/dash segments\n     * (invalid ids throw at registration). Reflected for the assurance gate; never read on the hot path.\n     *\n     * This is an author ASSERTION (recorded as `source: \"declared\"`), not runtime proof - like every\n     * assurance marker it is trusted by the static gate, which matches on the evidence id, not its source.\n     * Declare an id only on a route whose guard actually enforces it; a false declaration silently satisfies\n     * the policy. (`source` is retained in reflection, so a stricter policy or reviewer can still tell\n     * declared evidence from enforcement-module evidence.)\n     */\n    readonly assurance?: readonly string[];\n    /**\n     * Mark this route a **dynamic route family**: a template (`/api/:slug/:resource`) whose concrete\n     * resources are resolved at runtime (auto-CRUD over tenant-defined tables, a catch-all dispatcher).\n     * Purely declarative - it does not change dispatch. It surfaces in reflection so the assurance gate and\n     * tooling treat the one templated route as a deliberate family whose evidence covers every runtime-\n     * resolved resource, instead of reading it as a single forgotten route.\n     */\n    readonly family?: boolean;\n    /** Optional **path-params schema**. Path params arrive as strings (`/users/:id` -> `c.params.id`);\n     * declaring a schema validates them at the boundary (a malformed `:id` is a `422` before the handler,\n     * like `body`/`query`) and can coerce them (use `t.query({ id: t.integer() })` for a numeric param).\n     * The schema must cover every path param; with the strict default an undeclared path param is rejected.\n     * When omitted, `c.params` stays the path-inferred `Record<name, string>`. */\n    readonly params?: StandardSchemaV1;\n    readonly body?: StandardSchemaV1;\n    readonly query?: StandardSchemaV1;\n    /** Optional **response contract**. When declared: the handler's return is type-checked against it\n     * (the implementation can't drift from the contract), the typed client sees THIS as the response type\n     * (the contract - not the handler's incidental return), and it's emitted into OpenAPI/JSON-Schema so\n     * tooling and coding agents can read the exact shape. It is **not** validated at runtime (zero\n     * hot-path cost) - purely a compile-time + introspection contract. */\n    readonly response?: StandardSchemaV1;\n    /**\n     * Optional **error-response contract**: a map of HTTP status code → the Standard Schema of that error's\n     * body. Declares a route's failure modes so they flow into OpenAPI (as non-2xx `responses`), the\n     * `/llms.txt` context, and other introspection - the whole contract, not just the happy path, is legible\n     * to tooling and coding agents. Like `response`, it is **not** validated at runtime (zero hot-path cost);\n     * it's a compile-time + introspection contract. Example: `{ 404: NotFound, 409: Conflict }`. */\n    readonly errors?: Readonly<Record<number, StandardSchemaV1>>;\n    /**\n     * Optional **SSE event contract**: the Standard Schema of each event's `data` payload on a\n     * streaming route (declared via `app.sse()`). Marks the route as a typed event stream - the\n     * typed client grows a `.subscribe()` for it, and the schema flows into reflection. Like\n     * `response`, it is **not** validated at runtime (zero hot-path cost); the server-side\n     * `stream.send()` is compile-time-checked against it instead.\n     */\n    readonly sse?: StandardSchemaV1;\n    /**\n     * Hook fired when the request fails `body`/`query` validation, before the handler runs. `kind` says\n     * which input failed (`\"body\"` | `\"query\"`). Its return value selects one of three outcomes (may be async):\n     *   - a **`Response`** → returned as-is, short-circuiting the route (custom error envelope, redirect, …).\n     *   - **any other value** → treated as a repaired payload and **re-validated once** against the same\n     *     schema. If it now passes, the handler runs with it; if it still fails, the original `422` stands.\n     *     Re-validation means a bad return can't bypass the schema - the trust boundary holds.\n     *   - **`undefined`** → give up; the original validation `422` is returned unchanged.\n     * A route hook **overrides** the app-wide default set via `server({ onValidationError })`; return\n     * `undefined` to fall through to the plain `422` even when an app default exists. Typical uses: a custom\n     * error envelope, coercing the input, or prompting an LLM to repair the payload (re-validated, so it can't\n     * bypass the schema).\n     */\n    readonly onValidationError?: (issues: ReadonlyArray<StandardIssue>, ctx: Context, kind: \"body\" | \"query\" | \"params\") => Response | unknown | Promise<Response | unknown>;\n}",
+    "signature": "export interface RouteSchema {\n    /** Transport body cap for this route. Defaults to the server's maxBodyBytes. Use a finite\n     * smaller/larger limit for a specific endpoint. The 'unlimited' value is an explicit\n     * streaming/upload exemption and requires a non-empty bodyLimitReason for auditability. */\n    readonly bodyLimit?: number | \"unlimited\";\n    /** Required explanation when bodyLimit is 'unlimited' (for example, a streaming upload is\n     * bounded by an upstream object-store protocol). */\n    readonly bodyLimitReason?: string;\n    /** Declared effect tokens. Reflected for assurance; never read by validation or serialization. */\n    readonly capabilities?: readonly string[];\n    /**\n     * Dedupe retries of this (mutating) route on an `Idempotency-Key` header. The first request runs and\n     * its response is stored; a retry with the same key replays that response without re-running the\n     * handler, and a key reused with a different body is rejected (409). A missing key on an\n     * idempotency-required route fails closed (400). Off the hot path - routes without it are unchanged.\n     */\n    readonly idempotency?: IdempotencyConfig;\n    /**\n     * Highest data-sensitivity this route's response body carries (`public` | `pii` | `secret`). A\n     * declarative, compile-time + introspection fact - never validated at runtime. Reflected for tooling,\n     * recorded in the capability lockfile (so a route that starts returning PII is a reviewable change),\n     * and read by downstream policy (e.g. a partner-API surface refusing to expose `pii`/`secret`).\n     */\n    readonly classification?: DataClassification;\n    /**\n     * Inline **route-assurance evidence**: the enforcement posture this route carries, declared adjacent to\n     * the handler (e.g. `[NIFRA_ASSURANCE.AUTHENTICATED]`). Each id becomes route-scoped `declared` evidence\n     * in reflection, so a `nifra.assurance.ts` policy `require:` clause is satisfiable WITHOUT rewriting an\n     * in-handler guard into a `withRouteAssurance`-marked middleware. Ids are lowercase dot/dash segments\n     * (invalid ids throw at registration). Reflected for the assurance gate; never read on the hot path.\n     *\n     * This is an author ASSERTION (recorded as `source: \"declared\"`), not runtime proof - like every\n     * assurance marker it is trusted by the static gate, which matches on the evidence id, not its source.\n     * Declare an id only on a route whose guard actually enforces it; a false declaration silently satisfies\n     * the policy. (`source` is retained in reflection, so a stricter policy or reviewer can still tell\n     * declared evidence from enforcement-module evidence.)\n     */\n    readonly assurance?: readonly string[];\n    /**\n     * Mark this route a **dynamic route family**: a template (`/api/:slug/:resource`) whose concrete\n     * resources are resolved at runtime (auto-CRUD over tenant-defined tables, a catch-all dispatcher).\n     * Purely declarative - it does not change dispatch. It surfaces in reflection so the assurance gate and\n     * tooling treat the one templated route as a deliberate family whose evidence covers every runtime-\n     * resolved resource, instead of reading it as a single forgotten route.\n     */\n    readonly family?: boolean;\n    /** Optional **path-params schema**. Path params arrive as strings (`/users/:id` -> `c.params.id`);\n     * declaring a schema validates them at the boundary (a malformed `:id` is a `422` before the handler,\n     * like `body`/`query`) and can coerce them (use `t.query({ id: t.integer() })` for a numeric param).\n     * The schema must cover every path param; with the strict default an undeclared path param is rejected.\n     * When omitted, `c.params` stays the path-inferred `Record<name, string>`. */\n    readonly params?: StandardSchemaV1;\n    /** Optional request-header schema. Header names are normalized to lower-case and the validated\n     * output is exposed as `c.headers`; use lower-case keys because HTTP header names are\n     * case-insensitive. */\n    readonly headers?: StandardSchemaV1;\n    readonly body?: StandardSchemaV1;\n    readonly query?: StandardSchemaV1;\n    /** Optional **response contract**. When declared: the handler's return is type-checked against it\n     * (the implementation can't drift from the contract), the typed client sees THIS as the response type\n     * (the contract - not the handler's incidental return), and it's emitted into OpenAPI/JSON-Schema so\n     * tooling and coding agents can read the exact shape. It is **not** validated at runtime (zero\n     * hot-path cost) - purely a compile-time + introspection contract. */\n    readonly response?: StandardSchemaV1;\n    /**\n     * Optional **error-response contract**: a map of HTTP status code → the Standard Schema of that error's\n     * body. Declares a route's failure modes so they flow into OpenAPI (as non-2xx `responses`), the\n     * `/llms.txt` context, and other introspection - the whole contract, not just the happy path, is legible\n     * to tooling and coding agents. Like `response`, it is **not** validated at runtime (zero hot-path cost);\n     * it's a compile-time + introspection contract. Example: `{ 404: NotFound, 409: Conflict }`. */\n    readonly errors?: Readonly<Record<number, StandardSchemaV1>>;\n    /**\n     * Optional **SSE event contract**: the Standard Schema of each event's `data` payload on a\n     * streaming route (declared via `app.sse()`). Marks the route as a typed event stream - the\n     * typed client grows a `.subscribe()` for it, and the schema flows into reflection. Like\n     * `response`, it is **not** validated at runtime (zero hot-path cost); the server-side\n     * `stream.send()` is compile-time-checked against it instead.\n     */\n    readonly sse?: StandardSchemaV1;\n    /**\n     * Hook fired when the request fails `headers`/`params`/`body`/`query` validation, before the handler\n     * runs. `kind` says which input failed. Its return value selects one of three outcomes (may be async):\n     *   - a **`Response`** → returned as-is, short-circuiting the route (custom error envelope, redirect, …).\n     *   - **any other value** → treated as a repaired payload and **re-validated once** against the same\n     *     schema. If it now passes, the handler runs with it; if it still fails, the original `422` stands.\n     *     Re-validation means a bad return can't bypass the schema - the trust boundary holds.\n     *   - **`undefined`** → give up; the original validation `422` is returned unchanged.\n     * A route hook **overrides** the app-wide default set via `server({ onValidationError })`; return\n     * `undefined` to fall through to the plain `422` even when an app default exists. Typical uses: a custom\n     * error envelope, coercing the input, or prompting an LLM to repair the payload (re-validated, so it can't\n     * bypass the schema).\n     */\n    readonly onValidationError?: (issues: ReadonlyArray<StandardIssue>, ctx: Context, kind: \"body\" | \"query\" | \"params\" | \"headers\") => Response | unknown | Promise<Response | unknown>;\n}",
     "doc": "/** Per-route input schemas. Each is any Standard Schema (zod/valibot/arktype/…). */"
   },
   {
@@ -8978,7 +10136,7 @@
     "name": "RouteSnapshotSchema",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface RouteSnapshotSchema {\n    readonly body?: SchemaSnapshot;\n    readonly query?: SchemaSnapshot;\n    readonly response?: SchemaSnapshot;\n    readonly sse?: SchemaSnapshot;\n    readonly errors?: Readonly<Record<string, SchemaSnapshot>>;\n}"
+    "signature": "export interface RouteSnapshotSchema {\n    readonly headers?: SchemaSnapshot;\n    readonly body?: SchemaSnapshot;\n    readonly query?: SchemaSnapshot;\n    readonly response?: SchemaSnapshot;\n    readonly sse?: SchemaSnapshot;\n    readonly errors?: Readonly<Record<string, SchemaSnapshot>>;\n}"
   },
   {
     "name": "rpcError",
@@ -8992,6 +10150,18 @@
     "package": "@nifrajs/mcp",
     "signature": "export declare const rpcResult: (id: JsonRpcId, value: unknown) => JsonRpcResponse;"
   },
+  {
+    "name": "RuleContext",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface RuleContext {\n    readonly root: string;\n    readonly sources: SourceIndex;\n    readonly project: ProjectFacts;\n}"
+  },
+  {
+    "name": "RulePack",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface RulePack {\n    readonly name: string;\n    readonly rules: readonly CheckRule[];\n}"
+  },
   {
     "name": "runAdversarialContract",
     "kind": "function",
@@ -8999,6 +10169,18 @@
     "signature": "export declare function runAdversarialContract(app: ContractTestApp, options?: AdversarialContractOptions): Promise<AdversarialContractReport>;",
     "doc": "/**\n * Execute contract-derived hostile inputs and declared-response conformance against a runtime matrix.\n * Runtime/request failures are captured in the report; inspect `report.ok`, `failures`, and `gaps`\n * (or use {@link assertAdversarialContract} for a throwing test assertion).\n */"
   },
+  {
+    "name": "runAgent",
+    "kind": "function",
+    "package": "@nifrajs/agent",
+    "signature": "export declare function runAgent<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1>(definition: AgentDefinition<InputSchema, OutputSchema>, input: AgentTurnInput, ports: AgentPorts, options: RunAgentOptions): Promise<AgentRunResult<NonNullable<OutputSchema[\"~standard\"][\"types\"]>[\"output\"]>>;"
+  },
+  {
+    "name": "RunAgentOptions",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface RunAgentOptions {\n    readonly state: AgentTurnState;\n    readonly maxTurns?: number;\n    readonly goal?: (output: unknown) => boolean;\n}"
+  },
   {
     "name": "runApp",
     "kind": "function",
@@ -9006,6 +10188,12 @@
     "signature": "export declare function runApp(app: AppLike, requests: readonly RequestSpec[], options?: RunOptions): Promise<RunResult[]>;",
     "doc": "/**\n * Run a batch of requests through the app, in order, and return a result per request. Never throws:\n * an app crash on any request is captured as that result's `error` and the run continues.\n */"
   },
+  {
+    "name": "runAssurance",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function runAssurance(cwd: string, options?: {\n    readonly json?: boolean;\n    readonly config?: string;\n    readonly bundle?: boolean;\n    readonly strict?: boolean;\n    readonly out?: string;\n    readonly hydration?: boolean;\n    readonly interact?: boolean;\n}): Promise<boolean>;"
+  },
   {
     "name": "runDurableExecutionAdapterConformance",
     "kind": "function",
@@ -9026,6 +10214,19 @@
     "signature": "export declare function runFailureScenario<Output>(scenario: FailureScenario<Output>, options: FailureLabOptions): Promise<FailureScenarioReport>;",
     "doc": "/** Run one scenario and evaluate its post-failure invariant without leaking its result or error text. */"
   },
+  {
+    "name": "runFaultProfile",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function runFaultProfile(profile: FaultProfile, options?: RunFaultProfileOptions): Promise<FaultProfileReport>;",
+    "doc": "/** Run every profile scenario with the same deterministic seed and failure schedule. */"
+  },
+  {
+    "name": "RunFaultProfileOptions",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface RunFaultProfileOptions {\n    readonly seed?: number;\n    readonly schedule?: readonly FailureDirective[];\n}"
+  },
   {
     "name": "RunningServer",
     "kind": "interface",
@@ -9056,7 +10257,7 @@
     "name": "RunQueryOptions",
     "kind": "interface",
     "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}"
+    "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    /**\n     * Maximum wall-clock time for planning, execution, and optional counting (default 5 seconds).\n     * The deadline always bounds the RESPONSE. Whether it also stops the WORK depends on where the\n     * query runs: a file-backed database runs it in a reusable read-only worker that is terminated\n     * on expiry, while an in-memory database (or a shim with no `filename`) runs it on this thread,\n     * where a synchronous statement cannot be preempted and the overrun is only reported after it\n     * returns.\n     */\n    readonly queryTimeoutMs?: number;\n    /** Return an exact total after row truncation. Off by default because it re-executes the query. */\n    readonly exactTotal?: boolean;\n    /** Maximum simultaneous run_query calls on this database connection (default 1). */\n    readonly maxConcurrentQueries?: number;\n}"
   },
   {
     "name": "runReconciliationWorker",
@@ -9078,6 +10279,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": "runRuleRegistry",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function runRuleRegistry(ctx: RuleContext, builtIns: readonly CheckRule[], packs?: readonly RulePack[]): Promise<Diagnostic[]>;"
+  },
   {
     "name": "runSagaReconciliationWorker",
     "kind": "function",
@@ -9090,6 +10297,25 @@
     "package": "@nifrajs/testing",
     "signature": "export declare function runtimeAdapterCertificationProfile(): AdapterCertificationProfile<CertifiableRuntimeAdapter>;"
   },
+  {
+    "name": "runToolContractConformance",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function runToolContractConformance(adapter: ToolAdapter, options: {\n    readonly input: unknown;\n    readonly capability: string;\n    readonly approval: ToolApproval;\n    readonly dryRun: ToolCallOptions;\n}): Promise<ToolConformanceResult>;",
+    "doc": "/** Shared conformance assertions for adapters. It intentionally checks only public, token-only behavior. */"
+  },
+  {
+    "name": "runTrajectory",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function runTrajectory<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1>(definition: AgentDefinition<InputSchema, OutputSchema>, input: AgentTurnInput, ports: AgentPorts, options: {\n    readonly state: AgentTurnState;\n    readonly maxTurns?: number;\n    readonly goal?: (output: unknown) => boolean;\n}): Promise<TrajectoryRun<NonNullable<OutputSchema[\"~standard\"][\"types\"]>[\"output\"]>>;"
+  },
+  {
+    "name": "runWorkGraph",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function runWorkGraph(cwd: string, options?: {\n    readonly changedFiles?: readonly string[];\n    readonly minLevel?: number;\n    readonly json?: boolean;\n}): Promise<boolean>;"
+  },
   {
     "name": "SagaAmbiguityResolution",
     "kind": "type",
@@ -9345,7 +10571,7 @@
     "name": "SecurityHeadersOptions",
     "kind": "interface",
     "package": "@nifrajs/middleware",
-    "signature": "export interface SecurityHeadersOptions {\n    /** `Strict-Transport-Security`. Off by default - opt in once you're sure you're HTTPS-only. */\n    readonly hsts?: {\n        readonly maxAge: number;\n        readonly includeSubDomains?: boolean;\n        readonly preload?: boolean;\n    };\n    /** `Content-Security-Policy` value. Off by default (app-specific). */\n    readonly contentSecurityPolicy?: string;\n    /** `X-Frame-Options`. Default `\"DENY\"`. */\n    readonly frameOptions?: \"DENY\" | \"SAMEORIGIN\";\n    /** `Referrer-Policy`. Default `\"no-referrer\"`. */\n    readonly referrerPolicy?: string;\n}"
+    "signature": "export interface SecurityHeadersOptions {\n    /** `Strict-Transport-Security`. Off by default - opt in once you're sure you're HTTPS-only. */\n    readonly hsts?: {\n        readonly maxAge: number;\n        readonly includeSubDomains?: boolean;\n        readonly preload?: boolean;\n    };\n    /** `Content-Security-Policy` value. Off by default (app-specific). */\n    readonly contentSecurityPolicy?: string;\n    /** `X-Frame-Options`. Default `\"DENY\"`. */\n    readonly frameOptions?: \"DENY\" | \"SAMEORIGIN\";\n    /** `Referrer-Policy`. Default `\"no-referrer\"`. */\n    readonly referrerPolicy?: string;\n    /** `Cross-Origin-Opener-Policy`. Off by default - isolates the browsing context group; opt in\n     * when the app tolerates losing `window.opener` links from cross-origin pages. */\n    readonly crossOriginOpenerPolicy?: \"same-origin\" | \"same-origin-allow-popups\" | \"unsafe-none\";\n    /** `Cross-Origin-Embedder-Policy`. Off by default - `require-corp` breaks embedding of\n     * cross-origin resources that do not opt in, so this is a deliberate decision. */\n    readonly crossOriginEmbedderPolicy?: \"require-corp\" | \"credentialless\" | \"unsafe-none\";\n    /** `Cross-Origin-Resource-Policy`. Off by default (app-specific: assets meant for other\n     * origins need `cross-origin`). */\n    readonly crossOriginResourcePolicy?: \"same-origin\" | \"same-site\" | \"cross-origin\";\n    /** `Permissions-Policy` value, e.g. `\"camera=(), geolocation=()\"`. Off by default (app-specific). */\n    readonly permissionsPolicy?: string;\n}"
   },
   {
     "name": "SecurityRequirement",
@@ -9379,14 +10605,14 @@
     "kind": "function",
     "package": "@nifrajs/core",
     "signature": "export declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;",
-    "doc": "/**\n * Serialize a `Set-Cookie` header value. Pure - applies **no** security defaults (the caller, e.g.\n * `c.set.cookie`, layers `HttpOnly`/`Secure`/`SameSite` on). Throws on an invalid cookie name, a\n * header-injecting `Path`/`Domain`, a non-integer `maxAge`, or an oversized result - a serialization\n * bug should fail loudly, not silently emit a cookie the browser drops.\n */"
+    "doc": "/**\n * Serialize a `Set-Cookie` header value. Pure - applies **no** security defaults (the caller, e.g.\n * `c.set.cookie`, layers `HttpOnly`/`Secure`/`SameSite` on). Throws on an invalid cookie name, a\n * header-injecting `Path`/`Domain`, a non-integer `maxAge`, a `__Secure-`/`__Host-` name whose\n * attributes violate its prefix contract, or an oversized result - a serialization bug should fail\n * loudly, not silently emit a cookie the browser drops.\n */"
   },
   {
     "name": "serializeCookie",
     "kind": "function",
     "package": "nifra",
     "signature": "export declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;",
-    "doc": "/**\n * Serialize a `Set-Cookie` header value. Pure - applies **no** security defaults (the caller, e.g.\n * `c.set.cookie`, layers `HttpOnly`/`Secure`/`SameSite` on). Throws on an invalid cookie name, a\n * header-injecting `Path`/`Domain`, a non-integer `maxAge`, or an oversized result - a serialization\n * bug should fail loudly, not silently emit a cookie the browser drops.\n */"
+    "doc": "/**\n * Serialize a `Set-Cookie` header value. Pure - applies **no** security defaults (the caller, e.g.\n * `c.set.cookie`, layers `HttpOnly`/`Secure`/`SameSite` on). Throws on an invalid cookie name, a\n * header-injecting `Path`/`Domain`, a non-integer `maxAge`, a `__Secure-`/`__Host-` name whose\n * attributes violate its prefix contract, or an oversized result - a serialization bug should fail\n * loudly, not silently emit a cookie the browser drops.\n */"
   },
   {
     "name": "serializeData",
@@ -9409,6 +10635,13 @@
     "signature": "export declare function serializeNifraManifestSignature(signature: NifraManifestSignature): string;",
     "doc": "/** Byte-stable serialization for the detached signature sidecar. */"
   },
+  {
+    "name": "serializeProjectEvidence",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function serializeProjectEvidence(snapshot: ProjectEvidenceSnapshot): string;",
+    "doc": "/** Stable JSON for logs, MCP, generated artifacts, and snapshot tests. */"
+  },
   {
     "name": "serializeResponse",
     "kind": "function",
@@ -9459,7 +10692,7 @@
     "name": "ServeOptions",
     "kind": "interface",
     "package": "@nifrajs/node",
-    "signature": "export interface ServeOptions {\n    readonly port: number;\n    readonly hostname?: string;\n    /**\n     * Protocol used when the adapter constructs `Request.url`.\n     *\n     * `@nifrajs/node` creates a plain Node `http` server, so the safe default is `\"http\"`. Deployments behind\n     * TLS termination can set `\"https\"` (or a trusted infra-aware function) so app code that reads\n     * `request.url` sees the public scheme. Forwarded headers are not trusted implicitly.\n     */\n    readonly protocol?: RequestProtocolOption;\n    /**\n     * Install SIGTERM/SIGINT handlers that call `stop()` for a graceful drain on\n     * `docker stop` / Ctrl-C. Off by default - taking over process signals is opt-in,\n     * mirroring nifra's Bun `listen({ gracefulSignals })`.\n     *\n     * The app-level request timeout (`server({ requestTimeoutMs })` → 503) and body cap\n     * are *not* set here - they live inside `app.fetch`, so they already apply through\n     * this adapter. Slow-client protection is Node's built-in `requestTimeout` (300s) /\n     * `headersTimeout` (60s) defaults.\n     */\n    readonly signals?: boolean;\n    /**\n     * Serve static files from disk for matching GET/HEAD requests *before* the app runs - non-matching\n     * requests fall through to `app.fetch` with the node-direct fast path intact (no perf regression on\n     * SSR/API routes). Replaces the hand-rolled `/assets/*` reader in self-hosted entries.\n     */\n    readonly static?: ServeStaticOptions;\n}"
+    "signature": "export interface ServeOptions {\n    readonly port: number;\n    readonly hostname?: string;\n    /**\n     * Protocol used when the adapter constructs `Request.url`.\n     *\n     * `@nifrajs/node` creates a plain Node `http` server, so the safe default is `\"http\"`. Deployments behind\n     * TLS termination can set `\"https\"` (or a trusted infra-aware function) so app code that reads\n     * `request.url` sees the public scheme. Forwarded headers are not trusted implicitly.\n     */\n    readonly protocol?: RequestProtocolOption;\n    /** Reject requests whose normalized Host authority is not in this allowlist or callback result. */\n    readonly allowedHosts?: readonly string[] | ((host: string) => boolean);\n    /** Use this validated authority when constructing Request.url, ignoring the inbound Host value. */\n    readonly canonicalHost?: string;\n    /**\n     * Install SIGTERM/SIGINT handlers that call `stop()` for a graceful drain on\n     * `docker stop` / Ctrl-C. Off by default - taking over process signals is opt-in,\n     * mirroring nifra's Bun `listen({ gracefulSignals })`.\n     *\n     * The app-level request timeout (`server({ requestTimeoutMs })` → 503) and body cap\n     * are *not* set here - they live inside `app.fetch`, so they already apply through\n     * this adapter. Slow-client protection is Node's built-in `requestTimeout` (300s) /\n     * `headersTimeout` (60s) defaults.\n     */\n    readonly signals?: boolean;\n    /**\n     * Serve static files from disk for matching GET/HEAD requests *before* the app runs - non-matching\n     * requests fall through to `app.fetch` with the node-direct fast path intact (no perf regression on\n     * SSR/API routes). Replaces the hand-rolled `/assets/*` reader in self-hosted entries.\n     */\n    readonly static?: ServeStaticOptions;\n}"
   },
   {
     "name": "servePublicDir",
@@ -9492,14 +10725,14 @@
     "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    /** Installed by the `responseContract()` plugin; `undefined` = not installed, which is the default\n     * and the state in which a declared `response` schema stays a compile-time contract only. */\n    private responseContractRuntime;\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 onNodeRequestHooks;\n    /** Registration-time eligibility for the Node request twin lane. */\n    private nodeRequestHooksComplete;\n    private readonly onResponseHooks;\n    private readonly onNodeResponseHooks;\n    /** Registration-time eligibility for the Node response twin lane. */\n    private nodeResponseHooksComplete;\n    private readonly onResponseFinalizedHooks;\n    /**\n     * Statically declared response headers, merged and prebuilt at registration; `undefined` (the\n     * default) leaves every render path in its original shape. These are NOT response hooks - they are\n     * folded into response construction - so declaring them keeps the fused native lanes an\n     * `onResponse` hook would have disabled.\n     */\n    private staticResponseHeaders;\n    /** `wrapResponse` for the Web lanes: identity until static headers exist to fold into the\n     * framework's own error/404/timeout renders, which are built outside the header init. */\n    private wrapWebResponse;\n    private webResponseTimeout;\n    /** Body/raw response hooks need a framework-payload marker; keep that decision per app. */\n    private responseBodyTag;\n    private readonly responseBodyOwners;\n    private readonly finalizeResponse;\n    private readonly responseRequests;\n    /** Original source → request observed by generic request hooks, including in-place mutations. */\n    private readonly responseSources;\n    /** Memoized NodeRequestContext per plain-`Request` source - see {@link nodeRequestContextOf}. */\n    private readonly nodeContexts;\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    /**\n     * Declare response headers with NO per-request decision behind them - and pay nothing for them on\n     * the request path.\n     *\n     * These are not a hook. Because the values are known at wire-up, they are folded into response\n     * construction (one prebuilt init for JSON renders, one record merge where the request set its own\n     * headers), so an app whose only response middleware is static keeps every fused and native lane -\n     * `onResponse`/`onResponseHeaders` disable Bun's fused native routes and, for a full `onResponse`,\n     * the Node direct writer. They apply to EVERY response, exactly as a response hook would: success,\n     * error, 404/405, timeout, and short-circuit alike.\n     *\n     *   app.responseHeaders({ \"x-frame-options\": \"DENY\", \"referrer-policy\": \"no-referrer\" })\n     *\n     * They are DEFAULTS: a value the request itself produced (`c.set.headers`, or a response hook)\n     * wins, whatever casing it used. Names are lowercased once here; a non-string value, an invalid\n     * name, `__proto__`, or a name the render owns (`content-type`, `content-length`,\n     * `transfer-encoding`, `set-cookie`) throws a `TypeError` at wire-up.\n     *\n     * ORDERING: declarations made before any response hook fold into one static record. One made AFTER\n     * a response hook cannot - the hook may already have written that name and must keep winning - so\n     * it registers as an ordinary `onResponseHeaders` hook instead, preserving registration order at\n     * the cost of the static tier's speed. Declare static headers first.\n     */\n    responseHeaders(record: Readonly<Record<string, string>>): this;\n    /** Wire an already-validated lowercase record into the static tier, or - once a dynamic response\n     * hook owns part of the header state - into a hook that runs in the right order. */\n    private addStaticResponseHeaders;\n    private enableResponseBodyTagging;\n    /**\n     * Register a response transform for raw/streamed Responses. Framework-serialized payloads stay on\n     * the body tier; this hook is only entered for untagged Responses (streams, proxied fetches, and\n     * framework-generated error responses). A no-op native twin keeps buffered JSON on the direct lane.\n     */\n    onResponseRaw(fn: (response: Response, req: Request) => MaybePromise<Response>): this;\n    /**\n     * Register a PORTABLE header-only response hook - one implementation, fast on every runtime.\n     *\n     * The hook receives a mutable case-insensitive header view, a minimal request view, and the\n     * status. On the Web serving paths it runs inside the normal `onResponse` walk against the\n     * response's own `Headers` (mutating in place - no clone). On Node it self-pairs as a native\n     * response hook against the outcome's plain header record, so registering one NEVER forces the\n     * Node adapter off its direct socket writer the way a full `onResponse(res: Response)` hook does.\n     * Prefer this over `onResponse` whenever the middleware only reads/writes headers.\n     */\n    onResponseHeaders(fn: ResponseHeadersHook): this;\n    /**\n     * Register a PORTABLE post-serialization body hook - the payload tier. The hook receives the\n     * FINAL framework-serialized bytes (plus the mutable header view and status) and may return\n     * replacement bytes; `undefined` keeps the body. On the Node direct writer the bytes come\n     * straight off the outcome record; on the Web serving paths they ride the framework-built\n     * Response as a tag, so no body stream is ever drained on any runtime. A handler-returned raw\n     * `Response` (proxied fetch, SSE, streamed SSR) is skipped by contract - transforming those is\n     * what the full `onResponse` hook is for.\n     */\n    onResponseBody(fn: ResponseBodyHook): 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 `responseContract()` plugin. Off the public typed surface. */\n    [INSTALL_RESPONSE_CONTRACT](runtime: ResponseContractRuntime): void;\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 a response hook that replaces/consumes the buffered\n     * body stays on the full Web path; an in-place response hook can still use the direct writer. Same\n     * lifecycle as {@link fetch} (body cap, validation, hooks all run); only the final 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    /** Run generic Web response middleware while retaining direct writes for untouched buffered bodies. */\n    private finishNodeWebResponse;\n    /** True only when every transforming Web response hook has a header-only Node equivalent. */\n    private canUseNodeResponseHooks;\n    /** Apply paired native hooks to data outcomes; preserve the complete Web hook pipeline for Response outcomes. */\n    private finishNodeResponse;\n    private withNodeResponseHeaders;\n    /** Synchronous until a native response hook actually returns a Promise. */\n    private applyNodeResponseHooks;\n    private continueNodeResponseHooks;\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    /** Node-native request hook walk. A header-only hook can inspect the lazy source without forcing a\n     * Web `Request`; arbitrary request rewrites and full Web hooks use {@link runWithOnRequest}. */\n    private runWithNodeRequest;\n    private continueNodeRequest;\n    private canUseNodeRequestHooks;\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     * The NodeRequestContext for a source, MEMOIZED per source so the request twins and the response\n     * twins receive the exact same object within one request - that identity is the documented\n     * contract stateful twins key their WeakMaps on. An adapter source (which already speaks the\n     * interface) is returned as-is; a plain `Request` source (a direct `resolveNode` caller) gets one\n     * cached wrapper.\n     */\n    private nodeRequestContextOf;\n    /** Preserve the request visible to generic onRequest hooks for paired native response hooks. */\n    private takeNodeResponseRequest;\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    /** Compile the eligible body-only route's parser → validator → handler continuation once. The\n     * bounded parser remains shared with the generic lane; only the route-invariant entry lookups and\n     * lifecycle dispatch disappear from the common synchronous-validator/synchronous-handler case. */\n    private buildFusedBodyRunner;\n    /** Web adapter wrapper for the shared body runner. Node passes its native finalizer directly through\n     * the execution plan, while Web needs the live context to preserve lazy `c.set` controls. */\n    private buildFusedBodyWeb;\n    /** The fused Web lane for a route whose only lifecycle step is a query schema: parse + validate +\n     * handler + respond in one closure, no lifecycle promise when the validator and handler are sync.\n     * Eligibility is decided at registration (see `fusedQuery` in {@link register}); the semantics here\n     * are exactly `runQueryOnly`'s for that eligible shape - invalid input returns\n     * `validationError(issues)` (recovery hooks disqualify the route from this lane), a thrown\n     * `Response` passes through, anything else logs and returns a flat 500, and an async validator\n     * falls to a then-chain with the same steps. */\n    private buildFusedQueryWeb;\n    private bareError;\n    private runWithAround;\n    private runAround;\n    private runBodyOnly;\n    /** Shared bounded body framing/parser. Both body lanes use the same trust-boundary checks; only\n     * the validation + handler continuation differs. */\n    private readBodyInput;\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    /** Synchronous until a validator, lifecycle hook, handler, or contract check actually returns a Promise. */\n    private runLifecycle;\n    /** Registration-specialized query lifecycle: query validation (including recovery) → hooks. */\n    private runLifecycleQuery;\n    /** Registration-specialized body lifecycle: bounded body validation (including recovery) → hooks. */\n    private runLifecycleBody;\n    /** Registration-specialized body + query lifecycle: bounded body validation → query validation → hooks. */\n    private runLifecycleBodyQuery;\n    /** Registration-specialized no-body lifecycle: query validation (if present) → derives/hooks. */\n    private runQueryAndLifecycle;\n    private runQueryAndLifecycleResult;\n    private runLifecycleAfterParamsResult;\n    private runLifecycleAfterParams;\n    private runLifecycleAfterParamsSettled;\n    private runLifecycleAfterBody;\n    private runLifecycleAfterQueryResult;\n    private runLifecycleAfterQuery;\n    private runLifecycleHooks;\n    /** Registration-specialized derive → before → handler lifecycle. */\n    private runLifecycleDeriveBefore;\n    /** Finalize the specialized lane without rechecking its registration-proven invariants. */\n    private finishSimpleLifecycleResult;\n    private continueLifecycleAfterDerive;\n    private runLifecycleHooksAsync;\n    private continueLifecycleAfterBefore;\n    private runLifecycleHandlerAsync;\n    private finishLifecycleResult;\n    private continueLifecycleAfterHandle;\n    private finishLifecycleContract;\n    private finishContractOutcome;\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    private finishLifecycleValidationRecovery;\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    /**\n     * Which copy of `@nifrajs/core` declared this type. Two copies in one build (a linked sibling repo,\n     * a hoisting split) produce two unrelated `Server` types whose assignment error is a wall of\n     * missing internals; the brand puts the feature version in the type itself, so `typeof app` on\n     * hover - and `NifraFeatureVersion` in an assertion - says which core an app is talking to.\n     * `nifra doctor` is the diagnosis that names both install paths.\n     *\n     * `declare` = type-only: no field is emitted, nothing is allocated per server.\n     */\n    readonly __nifraCoreVersion: NifraFeatureVersion;\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 protoPoisoning;\n    /** `trustBodyFraming`: mark every `app.fetch` request as runtime-framed (see ServerOptions). */\n    private readonly trustBodyFraming;\n    private readonly wsMaxPayloadBytes;\n    private readonly requestTimeoutMs;\n    /** Installed by the `responseContract()` plugin; `undefined` = not installed, which is the default\n     * and the state in which a declared `response` schema stays a compile-time contract only. */\n    private responseContractRuntime;\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    private readonly stopHooks;\n    private readonly fetchMounts;\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    /** How much of an unhandled error {@link logRequestError} records. See `ServerOptions.errorLogDetail`. */\n    private readonly errorLogDetail;\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 onNodeRequestHooks;\n    /** Registration-time eligibility for the Node request twin lane. */\n    private nodeRequestHooksComplete;\n    private readonly onResponseHooks;\n    private readonly onNodeResponseHooks;\n    /** Registration-time eligibility for the Node response twin lane. */\n    private nodeResponseHooksComplete;\n    /**\n     * True once a bundle registers a RAW `onNodeResponse` twin - one handed the outcome's header\n     * record itself rather than the case-normalizing view. Their names are contractually the wire\n     * spelling, but registration cannot PROVE it, so such an app forgoes the all-lowercase mark and\n     * every reader re-derives the answer, exactly as before the mark existed.\n     */\n    private hasRawNodeResponseHook;\n    private readonly onResponseFinalizedHooks;\n    /**\n     * Statically declared response headers, merged and prebuilt at registration; `undefined` (the\n     * default) leaves every render path in its original shape. These are NOT response hooks - they are\n     * folded into response construction - so declaring them keeps the fused native lanes an\n     * `onResponse` hook would have disabled.\n     */\n    private staticResponseHeaders;\n    /** `wrapResponse` for the Web lanes: identity until static headers exist to fold into the\n     * framework's own error/404/timeout renders, which are built outside the header init. */\n    private wrapWebResponse;\n    private webResponseTimeout;\n    /** Body/raw response hooks need a framework-payload marker; keep that decision per app. */\n    private responseBodyTag;\n    private readonly responseBodyOwners;\n    private readonly finalizeResponse;\n    private readonly responseRequests;\n    /** Original source → request observed by generic request hooks, including in-place mutations. */\n    private readonly responseSources;\n    /** Memoized NodeRequestContext per plain-`Request` source - see {@link nodeRequestContextOf}. */\n    private readonly nodeContexts;\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    /** Register a callback awaited after graceful drain and server stop. Hung callbacks are bounded. */\n    onStop(fn: StopHook): this;\n    /**\n     * Mount a legacy fetch handler under a literal path prefix. Mounted handlers sit behind typed\n     * routes, so routes can move one at a time while the remaining legacy surface stays live.\n     * Mounted responses are outside Nifra's typed route and response-contract checks.\n     */\n    mountFetch(path: string, handler: FetchHandler<EnvOf<Ctx>>, options?: MountFetchOptions): this;\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    /**\n     * Declare response headers with NO per-request decision behind them - and pay nothing for them on\n     * the request path.\n     *\n     * These are not a hook. Because the values are known at wire-up, they are folded into response\n     * construction (one prebuilt init for JSON renders, one record merge where the request set its own\n     * headers), so an app whose only response middleware is static keeps every fused and native lane -\n     * `onResponse`/`onResponseHeaders` disable Bun's fused native routes and, for a full `onResponse`,\n     * the Node direct writer. They apply to EVERY response, exactly as a response hook would: success,\n     * error, 404/405, timeout, and short-circuit alike.\n     *\n     *   app.responseHeaders({ \"x-frame-options\": \"DENY\", \"referrer-policy\": \"no-referrer\" })\n     *\n     * They are DEFAULTS: a value the request itself produced (`c.set.headers`, or a response hook)\n     * wins, whatever casing it used. Names are lowercased once here; a non-string value, an invalid\n     * name, `__proto__`, or a name the render owns (`content-type`, `content-length`,\n     * `transfer-encoding`, `set-cookie`) throws a `TypeError` at wire-up.\n     *\n     * ORDERING: declarations made before any response hook fold into one static record. One made AFTER\n     * a response hook cannot - the hook may already have written that name and must keep winning - so\n     * it registers as an ordinary `onResponseHeaders` hook instead, preserving registration order at\n     * the cost of the static tier's speed. Declare static headers first.\n     */\n    responseHeaders(record: Readonly<Record<string, string>>): this;\n    /** Wire an already-validated lowercase record into the static tier, or - once a dynamic response\n     * hook owns part of the header state - into a hook that runs in the right order. */\n    private addStaticResponseHeaders;\n    private enableResponseBodyTagging;\n    /**\n     * Register a response transform for raw/streamed Responses. Framework-serialized payloads stay on\n     * the body tier; this hook is only entered for untagged Responses (streams, proxied fetches, and\n     * framework-generated error responses). A no-op native twin keeps buffered JSON on the direct lane.\n     */\n    onResponseRaw(fn: (response: Response, req: Request) => MaybePromise<Response>): this;\n    /**\n     * Register a PORTABLE header-only response hook - one implementation, fast on every runtime.\n     *\n     * The hook receives a mutable case-insensitive header view, a minimal request view, and the\n     * status. On the Web serving paths it runs inside the normal `onResponse` walk against the\n     * response's own `Headers` (mutating in place - no clone). On Node it self-pairs as a native\n     * response hook against the outcome's plain header record, so registering one NEVER forces the\n     * Node adapter off its direct socket writer the way a full `onResponse(res: Response)` hook does.\n     * Prefer this over `onResponse` whenever the middleware only reads/writes headers.\n     */\n    onResponseHeaders(fn: ResponseHeadersHook): this;\n    /**\n     * Register a PORTABLE post-serialization body hook - the payload tier. The hook receives the\n     * FINAL framework-serialized bytes (plus the mutable header view and status) and may return\n     * replacement bytes; `undefined` keeps the body. On the Node direct writer the bytes come\n     * straight off the outcome record; on the Web serving paths they ride the framework-built\n     * Response as a tag, so no body stream is ever drained on any runtime. A handler-returned raw\n     * `Response` (proxied fetch, SSE, streamed SSR) is skipped by contract - transforming those is\n     * what the full `onResponse` hook is for.\n     */\n    onResponseBody(fn: ResponseBodyHook): 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 **context** plugin ({@link ContextPlugin}, from {@link defineContextPlugin}) - it adds `D`\n     * to the handler context and changes nothing else, so the route registry `R` and the existing context\n     * `Ctx` thread through untouched. Like the identity overload above, this exists because the generic\n     * `(app: this) => Out` overload below cannot infer through a *generic* plugin signature: it erases the\n     * plugin's own type parameters to their constraints, which silently widens `R` to `Registry`.\n     */\n    use<D extends object>(plugin: ContextPlugin<D>): Server<R, Ctx & D>;\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    /** 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 `responseContract()` plugin. Off the public typed surface. */\n    [INSTALL_RESPONSE_CONTRACT](runtime: ResponseContractRuntime): void;\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 same locality rule\n     * covers the group's `onRequest` hooks: they run only for requests that route to the GROUP's\n     * routes (a `bodyLimit()` mounted on an uploads group must not start gating the whole app\n     * because the app composed it in), and the group's global assurance follows its hooks onto\n     * exactly those routes. A group with hooks but NO routes is a middleware bundle - its hooks\n     * can only mean app-wide intent, so they are appended globally, unchanged. Response-side hooks\n     * (`onResponse`/`onResponseFinalized`) are appended to this server's. This server's\n     * route-scoped chains do NOT retroactively wrap merged routes (order-scoped, like routes\n     * 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 a response hook that replaces/consumes the buffered\n     * body stays on the full Web path; an in-place response hook can still use the direct writer. Same\n     * lifecycle as {@link fetch} (body cap, validation, hooks all run); only the final 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    /** Run generic Web response middleware while retaining direct writes for untouched buffered bodies. */\n    private finishNodeWebResponse;\n    /** True only when every transforming Web response hook has a header-only Node equivalent. */\n    private canUseNodeResponseHooks;\n    /** Apply paired native hooks to data outcomes; preserve the complete Web hook pipeline for Response outcomes. */\n    private finishNodeResponse;\n    private withNodeResponseHeaders;\n    /** Synchronous until a native response hook actually returns a Promise. */\n    private applyNodeResponseHooks;\n    private continueNodeResponseHooks;\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    /** Node-native request hook walk. A header-only hook can inspect the lazy source without forcing a\n     * Web `Request`; arbitrary request rewrites and full Web hooks use {@link runWithOnRequest}. */\n    private runWithNodeRequest;\n    private continueNodeRequest;\n    private canUseNodeRequestHooks;\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     * The NodeRequestContext for a source, MEMOIZED per source so the request twins and the response\n     * twins receive the exact same object within one request - that identity is the documented\n     * contract stateful twins key their WeakMaps on. An adapter source (which already speaks the\n     * interface) is returned as-is; a plain `Request` source (a direct `resolveNode` caller) gets one\n     * cached wrapper.\n     */\n    private nodeRequestContextOf;\n    /** Preserve the request visible to generic onRequest hooks for paired native response hooks. */\n    private takeNodeResponseRequest;\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    private fetchMount;\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    /** Compile the eligible body-only route's parser → validator → handler continuation once. The\n     * bounded parser remains shared with the generic lane; only the route-invariant entry lookups and\n     * lifecycle dispatch disappear from the common synchronous-validator/synchronous-handler case. */\n    private buildFusedBodyRunner;\n    /** Web adapter wrapper for the shared body runner. Node passes its native finalizer directly through\n     * the execution plan, while Web needs the live context to preserve lazy `c.set` controls. */\n    private buildFusedBodyWeb;\n    /** The fused Web lane for a route whose only lifecycle step is a query schema: parse + validate +\n     * handler + respond in one closure, no lifecycle promise when the validator and handler are sync.\n     * Eligibility is decided at registration (see `fusedQuery` in {@link register}); the semantics here\n     * are exactly `runQueryOnly`'s for that eligible shape - invalid input returns\n     * `validationError(issues)` (recovery hooks disqualify the route from this lane), a thrown\n     * `Response` passes through, anything else logs and returns a flat 500, and an async validator\n     * falls to a then-chain with the same steps. */\n    private buildFusedQueryWeb;\n    private bareError;\n    private runWithAround;\n    private runAround;\n    private runBodyOnly;\n    /** Shared bounded body framing/parser. Both body lanes use the same trust-boundary checks; only\n     * the validation + handler continuation differs. */\n    private readBodyInput;\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    /** Synchronous until a validator, lifecycle hook, handler, or contract check actually returns a Promise. */\n    private runLifecycle;\n    private runLifecycleAfterHeadersResult;\n    private runLifecycleAfterHeaders;\n    /** Registration-specialized query lifecycle: query validation (including recovery) → hooks. */\n    private runLifecycleQuery;\n    /** Registration-specialized body lifecycle: bounded body validation (including recovery) → hooks. */\n    private runLifecycleBody;\n    /** Registration-specialized body + query lifecycle: bounded body validation → query validation → hooks. */\n    private runLifecycleBodyQuery;\n    /** Registration-specialized no-body lifecycle: query validation (if present) → derives/hooks. */\n    private runQueryAndLifecycle;\n    private runQueryAndLifecycleResult;\n    private runLifecycleAfterParamsResult;\n    private runLifecycleAfterParams;\n    private runLifecycleAfterParamsSettled;\n    private runLifecycleAfterBody;\n    private runLifecycleAfterQueryResult;\n    private runLifecycleAfterQuery;\n    private runLifecycleHooks;\n    /** Registration-specialized derive → before → handler lifecycle. */\n    private runLifecycleDeriveBefore;\n    /** Finalize the specialized lane without rechecking its registration-proven invariants. */\n    private finishSimpleLifecycleResult;\n    private continueLifecycleAfterDerive;\n    private runLifecycleHooksAsync;\n    private continueLifecycleAfterBefore;\n    private runLifecycleHandlerAsync;\n    private finishLifecycleResult;\n    private continueLifecycleAfterHandle;\n    private finishLifecycleContract;\n    private finishContractOutcome;\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    private finishLifecycleValidationRecovery;\n    /**\n     * Read + parse the JSON body, capped at `maxBodyBytes` and screened by the server's\n     * `protoPoisoning` policy. Rejects a `Content-Length` over the cap *before* buffering,\n     * re-checks what was actually delivered after the read, and aborts a chunked or\n     * length-less body mid-stream once the running byte count exceeds the cap - so a lying\n     * or absent length can't force us to buffer an oversized payload.\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     * `idleTimeoutSec` is how long Bun tolerates a connection with no bytes moving before it closes\n     * the socket. Bun's default is **10 seconds**, and a request whose handler is still working sends\n     * nothing - so any endpoint slower than 10s (a render, an export, a long upstream call) has its\n     * connection cut mid-flight regardless of `requestTimeoutMs`. Apps with such endpoints must raise\n     * this above their slowest expected response, which is why it is a first-class option and not a\n     * reason to drop down to `Bun.serve`. `0` disables the timeout entirely; max 255.\n     */\n    listen(port: number, options?: {\n        readonly reusePort?: boolean;\n        readonly hostname?: string;\n        readonly idleTimeoutSec?: number;\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 */"
   },
   {
     "name": "Server",
     "kind": "class",
     "package": "nifra",
-    "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    /** Installed by the `responseContract()` plugin; `undefined` = not installed, which is the default\n     * and the state in which a declared `response` schema stays a compile-time contract only. */\n    private responseContractRuntime;\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 onNodeRequestHooks;\n    /** Registration-time eligibility for the Node request twin lane. */\n    private nodeRequestHooksComplete;\n    private readonly onResponseHooks;\n    private readonly onNodeResponseHooks;\n    /** Registration-time eligibility for the Node response twin lane. */\n    private nodeResponseHooksComplete;\n    private readonly onResponseFinalizedHooks;\n    /**\n     * Statically declared response headers, merged and prebuilt at registration; `undefined` (the\n     * default) leaves every render path in its original shape. These are NOT response hooks - they are\n     * folded into response construction - so declaring them keeps the fused native lanes an\n     * `onResponse` hook would have disabled.\n     */\n    private staticResponseHeaders;\n    /** `wrapResponse` for the Web lanes: identity until static headers exist to fold into the\n     * framework's own error/404/timeout renders, which are built outside the header init. */\n    private wrapWebResponse;\n    private webResponseTimeout;\n    /** Body/raw response hooks need a framework-payload marker; keep that decision per app. */\n    private responseBodyTag;\n    private readonly responseBodyOwners;\n    private readonly finalizeResponse;\n    private readonly responseRequests;\n    /** Original source → request observed by generic request hooks, including in-place mutations. */\n    private readonly responseSources;\n    /** Memoized NodeRequestContext per plain-`Request` source - see {@link nodeRequestContextOf}. */\n    private readonly nodeContexts;\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    /**\n     * Declare response headers with NO per-request decision behind them - and pay nothing for them on\n     * the request path.\n     *\n     * These are not a hook. Because the values are known at wire-up, they are folded into response\n     * construction (one prebuilt init for JSON renders, one record merge where the request set its own\n     * headers), so an app whose only response middleware is static keeps every fused and native lane -\n     * `onResponse`/`onResponseHeaders` disable Bun's fused native routes and, for a full `onResponse`,\n     * the Node direct writer. They apply to EVERY response, exactly as a response hook would: success,\n     * error, 404/405, timeout, and short-circuit alike.\n     *\n     *   app.responseHeaders({ \"x-frame-options\": \"DENY\", \"referrer-policy\": \"no-referrer\" })\n     *\n     * They are DEFAULTS: a value the request itself produced (`c.set.headers`, or a response hook)\n     * wins, whatever casing it used. Names are lowercased once here; a non-string value, an invalid\n     * name, `__proto__`, or a name the render owns (`content-type`, `content-length`,\n     * `transfer-encoding`, `set-cookie`) throws a `TypeError` at wire-up.\n     *\n     * ORDERING: declarations made before any response hook fold into one static record. One made AFTER\n     * a response hook cannot - the hook may already have written that name and must keep winning - so\n     * it registers as an ordinary `onResponseHeaders` hook instead, preserving registration order at\n     * the cost of the static tier's speed. Declare static headers first.\n     */\n    responseHeaders(record: Readonly<Record<string, string>>): this;\n    /** Wire an already-validated lowercase record into the static tier, or - once a dynamic response\n     * hook owns part of the header state - into a hook that runs in the right order. */\n    private addStaticResponseHeaders;\n    private enableResponseBodyTagging;\n    /**\n     * Register a response transform for raw/streamed Responses. Framework-serialized payloads stay on\n     * the body tier; this hook is only entered for untagged Responses (streams, proxied fetches, and\n     * framework-generated error responses). A no-op native twin keeps buffered JSON on the direct lane.\n     */\n    onResponseRaw(fn: (response: Response, req: Request) => MaybePromise<Response>): this;\n    /**\n     * Register a PORTABLE header-only response hook - one implementation, fast on every runtime.\n     *\n     * The hook receives a mutable case-insensitive header view, a minimal request view, and the\n     * status. On the Web serving paths it runs inside the normal `onResponse` walk against the\n     * response's own `Headers` (mutating in place - no clone). On Node it self-pairs as a native\n     * response hook against the outcome's plain header record, so registering one NEVER forces the\n     * Node adapter off its direct socket writer the way a full `onResponse(res: Response)` hook does.\n     * Prefer this over `onResponse` whenever the middleware only reads/writes headers.\n     */\n    onResponseHeaders(fn: ResponseHeadersHook): this;\n    /**\n     * Register a PORTABLE post-serialization body hook - the payload tier. The hook receives the\n     * FINAL framework-serialized bytes (plus the mutable header view and status) and may return\n     * replacement bytes; `undefined` keeps the body. On the Node direct writer the bytes come\n     * straight off the outcome record; on the Web serving paths they ride the framework-built\n     * Response as a tag, so no body stream is ever drained on any runtime. A handler-returned raw\n     * `Response` (proxied fetch, SSE, streamed SSR) is skipped by contract - transforming those is\n     * what the full `onResponse` hook is for.\n     */\n    onResponseBody(fn: ResponseBodyHook): 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 `responseContract()` plugin. Off the public typed surface. */\n    [INSTALL_RESPONSE_CONTRACT](runtime: ResponseContractRuntime): void;\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 a response hook that replaces/consumes the buffered\n     * body stays on the full Web path; an in-place response hook can still use the direct writer. Same\n     * lifecycle as {@link fetch} (body cap, validation, hooks all run); only the final 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    /** Run generic Web response middleware while retaining direct writes for untouched buffered bodies. */\n    private finishNodeWebResponse;\n    /** True only when every transforming Web response hook has a header-only Node equivalent. */\n    private canUseNodeResponseHooks;\n    /** Apply paired native hooks to data outcomes; preserve the complete Web hook pipeline for Response outcomes. */\n    private finishNodeResponse;\n    private withNodeResponseHeaders;\n    /** Synchronous until a native response hook actually returns a Promise. */\n    private applyNodeResponseHooks;\n    private continueNodeResponseHooks;\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    /** Node-native request hook walk. A header-only hook can inspect the lazy source without forcing a\n     * Web `Request`; arbitrary request rewrites and full Web hooks use {@link runWithOnRequest}. */\n    private runWithNodeRequest;\n    private continueNodeRequest;\n    private canUseNodeRequestHooks;\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     * The NodeRequestContext for a source, MEMOIZED per source so the request twins and the response\n     * twins receive the exact same object within one request - that identity is the documented\n     * contract stateful twins key their WeakMaps on. An adapter source (which already speaks the\n     * interface) is returned as-is; a plain `Request` source (a direct `resolveNode` caller) gets one\n     * cached wrapper.\n     */\n    private nodeRequestContextOf;\n    /** Preserve the request visible to generic onRequest hooks for paired native response hooks. */\n    private takeNodeResponseRequest;\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    /** Compile the eligible body-only route's parser → validator → handler continuation once. The\n     * bounded parser remains shared with the generic lane; only the route-invariant entry lookups and\n     * lifecycle dispatch disappear from the common synchronous-validator/synchronous-handler case. */\n    private buildFusedBodyRunner;\n    /** Web adapter wrapper for the shared body runner. Node passes its native finalizer directly through\n     * the execution plan, while Web needs the live context to preserve lazy `c.set` controls. */\n    private buildFusedBodyWeb;\n    /** The fused Web lane for a route whose only lifecycle step is a query schema: parse + validate +\n     * handler + respond in one closure, no lifecycle promise when the validator and handler are sync.\n     * Eligibility is decided at registration (see `fusedQuery` in {@link register}); the semantics here\n     * are exactly `runQueryOnly`'s for that eligible shape - invalid input returns\n     * `validationError(issues)` (recovery hooks disqualify the route from this lane), a thrown\n     * `Response` passes through, anything else logs and returns a flat 500, and an async validator\n     * falls to a then-chain with the same steps. */\n    private buildFusedQueryWeb;\n    private bareError;\n    private runWithAround;\n    private runAround;\n    private runBodyOnly;\n    /** Shared bounded body framing/parser. Both body lanes use the same trust-boundary checks; only\n     * the validation + handler continuation differs. */\n    private readBodyInput;\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    /** Synchronous until a validator, lifecycle hook, handler, or contract check actually returns a Promise. */\n    private runLifecycle;\n    /** Registration-specialized query lifecycle: query validation (including recovery) → hooks. */\n    private runLifecycleQuery;\n    /** Registration-specialized body lifecycle: bounded body validation (including recovery) → hooks. */\n    private runLifecycleBody;\n    /** Registration-specialized body + query lifecycle: bounded body validation → query validation → hooks. */\n    private runLifecycleBodyQuery;\n    /** Registration-specialized no-body lifecycle: query validation (if present) → derives/hooks. */\n    private runQueryAndLifecycle;\n    private runQueryAndLifecycleResult;\n    private runLifecycleAfterParamsResult;\n    private runLifecycleAfterParams;\n    private runLifecycleAfterParamsSettled;\n    private runLifecycleAfterBody;\n    private runLifecycleAfterQueryResult;\n    private runLifecycleAfterQuery;\n    private runLifecycleHooks;\n    /** Registration-specialized derive → before → handler lifecycle. */\n    private runLifecycleDeriveBefore;\n    /** Finalize the specialized lane without rechecking its registration-proven invariants. */\n    private finishSimpleLifecycleResult;\n    private continueLifecycleAfterDerive;\n    private runLifecycleHooksAsync;\n    private continueLifecycleAfterBefore;\n    private runLifecycleHandlerAsync;\n    private finishLifecycleResult;\n    private continueLifecycleAfterHandle;\n    private finishLifecycleContract;\n    private finishContractOutcome;\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    private finishLifecycleValidationRecovery;\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    /**\n     * Which copy of `@nifrajs/core` declared this type. Two copies in one build (a linked sibling repo,\n     * a hoisting split) produce two unrelated `Server` types whose assignment error is a wall of\n     * missing internals; the brand puts the feature version in the type itself, so `typeof app` on\n     * hover - and `NifraFeatureVersion` in an assertion - says which core an app is talking to.\n     * `nifra doctor` is the diagnosis that names both install paths.\n     *\n     * `declare` = type-only: no field is emitted, nothing is allocated per server.\n     */\n    readonly __nifraCoreVersion: NifraFeatureVersion;\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 protoPoisoning;\n    /** `trustBodyFraming`: mark every `app.fetch` request as runtime-framed (see ServerOptions). */\n    private readonly trustBodyFraming;\n    private readonly wsMaxPayloadBytes;\n    private readonly requestTimeoutMs;\n    /** Installed by the `responseContract()` plugin; `undefined` = not installed, which is the default\n     * and the state in which a declared `response` schema stays a compile-time contract only. */\n    private responseContractRuntime;\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    private readonly stopHooks;\n    private readonly fetchMounts;\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    /** How much of an unhandled error {@link logRequestError} records. See `ServerOptions.errorLogDetail`. */\n    private readonly errorLogDetail;\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 onNodeRequestHooks;\n    /** Registration-time eligibility for the Node request twin lane. */\n    private nodeRequestHooksComplete;\n    private readonly onResponseHooks;\n    private readonly onNodeResponseHooks;\n    /** Registration-time eligibility for the Node response twin lane. */\n    private nodeResponseHooksComplete;\n    /**\n     * True once a bundle registers a RAW `onNodeResponse` twin - one handed the outcome's header\n     * record itself rather than the case-normalizing view. Their names are contractually the wire\n     * spelling, but registration cannot PROVE it, so such an app forgoes the all-lowercase mark and\n     * every reader re-derives the answer, exactly as before the mark existed.\n     */\n    private hasRawNodeResponseHook;\n    private readonly onResponseFinalizedHooks;\n    /**\n     * Statically declared response headers, merged and prebuilt at registration; `undefined` (the\n     * default) leaves every render path in its original shape. These are NOT response hooks - they are\n     * folded into response construction - so declaring them keeps the fused native lanes an\n     * `onResponse` hook would have disabled.\n     */\n    private staticResponseHeaders;\n    /** `wrapResponse` for the Web lanes: identity until static headers exist to fold into the\n     * framework's own error/404/timeout renders, which are built outside the header init. */\n    private wrapWebResponse;\n    private webResponseTimeout;\n    /** Body/raw response hooks need a framework-payload marker; keep that decision per app. */\n    private responseBodyTag;\n    private readonly responseBodyOwners;\n    private readonly finalizeResponse;\n    private readonly responseRequests;\n    /** Original source → request observed by generic request hooks, including in-place mutations. */\n    private readonly responseSources;\n    /** Memoized NodeRequestContext per plain-`Request` source - see {@link nodeRequestContextOf}. */\n    private readonly nodeContexts;\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    /** Register a callback awaited after graceful drain and server stop. Hung callbacks are bounded. */\n    onStop(fn: StopHook): this;\n    /**\n     * Mount a legacy fetch handler under a literal path prefix. Mounted handlers sit behind typed\n     * routes, so routes can move one at a time while the remaining legacy surface stays live.\n     * Mounted responses are outside Nifra's typed route and response-contract checks.\n     */\n    mountFetch(path: string, handler: FetchHandler<EnvOf<Ctx>>, options?: MountFetchOptions): this;\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    /**\n     * Declare response headers with NO per-request decision behind them - and pay nothing for them on\n     * the request path.\n     *\n     * These are not a hook. Because the values are known at wire-up, they are folded into response\n     * construction (one prebuilt init for JSON renders, one record merge where the request set its own\n     * headers), so an app whose only response middleware is static keeps every fused and native lane -\n     * `onResponse`/`onResponseHeaders` disable Bun's fused native routes and, for a full `onResponse`,\n     * the Node direct writer. They apply to EVERY response, exactly as a response hook would: success,\n     * error, 404/405, timeout, and short-circuit alike.\n     *\n     *   app.responseHeaders({ \"x-frame-options\": \"DENY\", \"referrer-policy\": \"no-referrer\" })\n     *\n     * They are DEFAULTS: a value the request itself produced (`c.set.headers`, or a response hook)\n     * wins, whatever casing it used. Names are lowercased once here; a non-string value, an invalid\n     * name, `__proto__`, or a name the render owns (`content-type`, `content-length`,\n     * `transfer-encoding`, `set-cookie`) throws a `TypeError` at wire-up.\n     *\n     * ORDERING: declarations made before any response hook fold into one static record. One made AFTER\n     * a response hook cannot - the hook may already have written that name and must keep winning - so\n     * it registers as an ordinary `onResponseHeaders` hook instead, preserving registration order at\n     * the cost of the static tier's speed. Declare static headers first.\n     */\n    responseHeaders(record: Readonly<Record<string, string>>): this;\n    /** Wire an already-validated lowercase record into the static tier, or - once a dynamic response\n     * hook owns part of the header state - into a hook that runs in the right order. */\n    private addStaticResponseHeaders;\n    private enableResponseBodyTagging;\n    /**\n     * Register a response transform for raw/streamed Responses. Framework-serialized payloads stay on\n     * the body tier; this hook is only entered for untagged Responses (streams, proxied fetches, and\n     * framework-generated error responses). A no-op native twin keeps buffered JSON on the direct lane.\n     */\n    onResponseRaw(fn: (response: Response, req: Request) => MaybePromise<Response>): this;\n    /**\n     * Register a PORTABLE header-only response hook - one implementation, fast on every runtime.\n     *\n     * The hook receives a mutable case-insensitive header view, a minimal request view, and the\n     * status. On the Web serving paths it runs inside the normal `onResponse` walk against the\n     * response's own `Headers` (mutating in place - no clone). On Node it self-pairs as a native\n     * response hook against the outcome's plain header record, so registering one NEVER forces the\n     * Node adapter off its direct socket writer the way a full `onResponse(res: Response)` hook does.\n     * Prefer this over `onResponse` whenever the middleware only reads/writes headers.\n     */\n    onResponseHeaders(fn: ResponseHeadersHook): this;\n    /**\n     * Register a PORTABLE post-serialization body hook - the payload tier. The hook receives the\n     * FINAL framework-serialized bytes (plus the mutable header view and status) and may return\n     * replacement bytes; `undefined` keeps the body. On the Node direct writer the bytes come\n     * straight off the outcome record; on the Web serving paths they ride the framework-built\n     * Response as a tag, so no body stream is ever drained on any runtime. A handler-returned raw\n     * `Response` (proxied fetch, SSE, streamed SSR) is skipped by contract - transforming those is\n     * what the full `onResponse` hook is for.\n     */\n    onResponseBody(fn: ResponseBodyHook): 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 **context** plugin ({@link ContextPlugin}, from {@link defineContextPlugin}) - it adds `D`\n     * to the handler context and changes nothing else, so the route registry `R` and the existing context\n     * `Ctx` thread through untouched. Like the identity overload above, this exists because the generic\n     * `(app: this) => Out` overload below cannot infer through a *generic* plugin signature: it erases the\n     * plugin's own type parameters to their constraints, which silently widens `R` to `Registry`.\n     */\n    use<D extends object>(plugin: ContextPlugin<D>): Server<R, Ctx & D>;\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    /** 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 `responseContract()` plugin. Off the public typed surface. */\n    [INSTALL_RESPONSE_CONTRACT](runtime: ResponseContractRuntime): void;\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 same locality rule\n     * covers the group's `onRequest` hooks: they run only for requests that route to the GROUP's\n     * routes (a `bodyLimit()` mounted on an uploads group must not start gating the whole app\n     * because the app composed it in), and the group's global assurance follows its hooks onto\n     * exactly those routes. A group with hooks but NO routes is a middleware bundle - its hooks\n     * can only mean app-wide intent, so they are appended globally, unchanged. Response-side hooks\n     * (`onResponse`/`onResponseFinalized`) are appended to this server's. This server's\n     * route-scoped chains do NOT retroactively wrap merged routes (order-scoped, like routes\n     * 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 a response hook that replaces/consumes the buffered\n     * body stays on the full Web path; an in-place response hook can still use the direct writer. Same\n     * lifecycle as {@link fetch} (body cap, validation, hooks all run); only the final 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    /** Run generic Web response middleware while retaining direct writes for untouched buffered bodies. */\n    private finishNodeWebResponse;\n    /** True only when every transforming Web response hook has a header-only Node equivalent. */\n    private canUseNodeResponseHooks;\n    /** Apply paired native hooks to data outcomes; preserve the complete Web hook pipeline for Response outcomes. */\n    private finishNodeResponse;\n    private withNodeResponseHeaders;\n    /** Synchronous until a native response hook actually returns a Promise. */\n    private applyNodeResponseHooks;\n    private continueNodeResponseHooks;\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    /** Node-native request hook walk. A header-only hook can inspect the lazy source without forcing a\n     * Web `Request`; arbitrary request rewrites and full Web hooks use {@link runWithOnRequest}. */\n    private runWithNodeRequest;\n    private continueNodeRequest;\n    private canUseNodeRequestHooks;\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     * The NodeRequestContext for a source, MEMOIZED per source so the request twins and the response\n     * twins receive the exact same object within one request - that identity is the documented\n     * contract stateful twins key their WeakMaps on. An adapter source (which already speaks the\n     * interface) is returned as-is; a plain `Request` source (a direct `resolveNode` caller) gets one\n     * cached wrapper.\n     */\n    private nodeRequestContextOf;\n    /** Preserve the request visible to generic onRequest hooks for paired native response hooks. */\n    private takeNodeResponseRequest;\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    private fetchMount;\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    /** Compile the eligible body-only route's parser → validator → handler continuation once. The\n     * bounded parser remains shared with the generic lane; only the route-invariant entry lookups and\n     * lifecycle dispatch disappear from the common synchronous-validator/synchronous-handler case. */\n    private buildFusedBodyRunner;\n    /** Web adapter wrapper for the shared body runner. Node passes its native finalizer directly through\n     * the execution plan, while Web needs the live context to preserve lazy `c.set` controls. */\n    private buildFusedBodyWeb;\n    /** The fused Web lane for a route whose only lifecycle step is a query schema: parse + validate +\n     * handler + respond in one closure, no lifecycle promise when the validator and handler are sync.\n     * Eligibility is decided at registration (see `fusedQuery` in {@link register}); the semantics here\n     * are exactly `runQueryOnly`'s for that eligible shape - invalid input returns\n     * `validationError(issues)` (recovery hooks disqualify the route from this lane), a thrown\n     * `Response` passes through, anything else logs and returns a flat 500, and an async validator\n     * falls to a then-chain with the same steps. */\n    private buildFusedQueryWeb;\n    private bareError;\n    private runWithAround;\n    private runAround;\n    private runBodyOnly;\n    /** Shared bounded body framing/parser. Both body lanes use the same trust-boundary checks; only\n     * the validation + handler continuation differs. */\n    private readBodyInput;\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    /** Synchronous until a validator, lifecycle hook, handler, or contract check actually returns a Promise. */\n    private runLifecycle;\n    private runLifecycleAfterHeadersResult;\n    private runLifecycleAfterHeaders;\n    /** Registration-specialized query lifecycle: query validation (including recovery) → hooks. */\n    private runLifecycleQuery;\n    /** Registration-specialized body lifecycle: bounded body validation (including recovery) → hooks. */\n    private runLifecycleBody;\n    /** Registration-specialized body + query lifecycle: bounded body validation → query validation → hooks. */\n    private runLifecycleBodyQuery;\n    /** Registration-specialized no-body lifecycle: query validation (if present) → derives/hooks. */\n    private runQueryAndLifecycle;\n    private runQueryAndLifecycleResult;\n    private runLifecycleAfterParamsResult;\n    private runLifecycleAfterParams;\n    private runLifecycleAfterParamsSettled;\n    private runLifecycleAfterBody;\n    private runLifecycleAfterQueryResult;\n    private runLifecycleAfterQuery;\n    private runLifecycleHooks;\n    /** Registration-specialized derive → before → handler lifecycle. */\n    private runLifecycleDeriveBefore;\n    /** Finalize the specialized lane without rechecking its registration-proven invariants. */\n    private finishSimpleLifecycleResult;\n    private continueLifecycleAfterDerive;\n    private runLifecycleHooksAsync;\n    private continueLifecycleAfterBefore;\n    private runLifecycleHandlerAsync;\n    private finishLifecycleResult;\n    private continueLifecycleAfterHandle;\n    private finishLifecycleContract;\n    private finishContractOutcome;\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    private finishLifecycleValidationRecovery;\n    /**\n     * Read + parse the JSON body, capped at `maxBodyBytes` and screened by the server's\n     * `protoPoisoning` policy. Rejects a `Content-Length` over the cap *before* buffering,\n     * re-checks what was actually delivered after the read, and aborts a chunked or\n     * length-less body mid-stream once the running byte count exceeds the cap - so a lying\n     * or absent length can't force us to buffer an oversized payload.\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     * `idleTimeoutSec` is how long Bun tolerates a connection with no bytes moving before it closes\n     * the socket. Bun's default is **10 seconds**, and a request whose handler is still working sends\n     * nothing - so any endpoint slower than 10s (a render, an export, a long upstream call) has its\n     * connection cut mid-flight regardless of `requestTimeoutMs`. Apps with such endpoints must raise\n     * this above their slowest expected response, which is why it is a first-class option and not a\n     * reason to drop down to `Bun.serve`. `0` disables the timeout entirely; max 255.\n     */\n    listen(port: number, options?: {\n        readonly reusePort?: boolean;\n        readonly hostname?: string;\n        readonly idleTimeoutSec?: number;\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 */"
   },
   {
@@ -9695,19 +10928,19 @@
     "name": "ServerOptions",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface ServerOptions {\n    /**\n     * Max request body size (bytes), enforced **only when a route declares a body schema** - the cap\n     * lives in the schema-validated read path. Default 1_000_000.\n     *\n     * A route WITHOUT a body schema (raw body, file upload, BYO-validation) that reads `c.req` directly\n     * is not auto-bounded - use **`c.boundedBody(maxBytes?)`** / **`c.boundedJson(maxBytes?)`**, which\n     * apply this same cap (override per route by passing `maxBytes` - larger for an upload endpoint,\n     * smaller to tighten one).\n     */\n    readonly maxBodyBytes?: number;\n    /** Max inbound WebSocket message size (bytes) when `listen()`ing on Bun - frames over this are rejected\n     * by the runtime before reaching your handler (so a huge frame can't be JSON-parsed into memory).\n     * Default: `maxBodyBytes` (1 MB). */\n    readonly wsMaxPayloadBytes?: number;\n    /** Per-request timeout (ms): a slower request gets a 503 and `ctx.signal` aborts. 0 disables (default). */\n    readonly requestTimeoutMs?: number;\n    /**\n     * How to derive `c.clientIp` behind a reverse proxy or CDN. Omit (default) to trust only the raw\n     * socket peer and never believe a forwarded header. Set `{ trustedHops: n }` when the app sits\n     * behind `n` proxies you operate (the caller is read from `X-Forwarded-For` past those hops), or\n     * `{ header: name }` to trust one edge-set header's first value. Declaring trust the app can't\n     * actually enforce lets clients forge their IP, so leave it unset unless a proxy really fronts you.\n     */\n    readonly clientIp?: ClientIpTrust;\n    /**\n     * Admit the public `x-nifra-deadline` header and let it shorten local work. Disabled by default:\n     * services that participate in trusted cross-service deadline propagation opt in explicitly,\n     * while ordinary/public HTTP routes pay no header-admission tax and ignore hostile client values.\n     */\n    readonly acceptInboundDeadlines?: boolean;\n    /**\n     * Maximum time accepted from an inbound `x-nifra-deadline`, in milliseconds. An incoming absolute\n     * deadline may shorten this cap (and `requestTimeoutMs`, when configured), never extend it.\n     * Default 30_000; applies only when `acceptInboundDeadlines` is enabled and the header is present.\n     */\n    readonly maxInboundDeadlineMs?: number;\n    /** When `listen()`ing, install SIGTERM/SIGINT handlers that gracefully `stop()`. Default false. */\n    readonly gracefulSignals?: boolean;\n    /**\n     * Capacity-admission gate (see {@link AdmissionController}). Bounds concurrent in-flight work so a\n     * healthy instance sheds load (`429` + `Retry-After`) instead of accepting more than it can finish.\n     * Off by default. Enabling it disables the fused native-route fast path (requests route through the\n     * shared matched lane where the gate runs); when unset, the request path pays nothing.\n     */\n    readonly admission?: AdmissionController;\n    /**\n     * Optional token-only observation hook called by `useCapability(c, id)`. It receives no request,\n     * parameters, body, tenant, or values. Routes without capability declarations keep the old hot path.\n     */\n    readonly onCapabilityUse?: (event: CapabilityUseEvent) => void;\n    /** Structured logger for framework events (redacts secrets). Default: JSON to stderr. */\n    readonly logger?: Logger;\n    /**\n     * App-wide fallback fired when a route **without its own `onValidationError`** fails body/query\n     * validation. Same contract as the per-route hook (`(issues, ctx, kind) => Response | repaired-value |\n     * undefined`): a route's own hook takes precedence, and a route can fall through to the plain `422` by\n     * returning `undefined`. Use it for one app-wide error envelope (like tRPC's `errorFormatter` /\n     * Fastify's `setErrorHandler`) instead of repeating a formatter per route.\n     */\n    readonly onValidationError?: RouteSchema[\"onValidationError\"];\n}"
+    "signature": "export interface ServerOptions {\n    /**\n     * Max request body size (bytes), the default transport cap for every route. Default 1_000_000.\n     * A route can choose a finite `schema.bodyLimit` of its own; an explicit `'unlimited'` route\n     * requires `schema.bodyLimitReason` and is intended only for a separately bounded streaming or\n     * upload integration.\n     *\n     * Framework readers (the body-schema lane, `c.boundedJson`) enforce the cap when they read. A\n     * route WITHOUT a body schema (raw body, file upload, BYO-validation) is covered too: direct\n     * `c.req` reads (`json()`, `arrayBuffer()`, the raw `body` stream, ...) are capped in place -\n     * lazily, nothing is buffered until code actually reads - and answer 413 past the limit.\n     * `c.boundedBody(n)` states its own explicit per-read limit, above or below the route's cap.\n     */\n    readonly maxBodyBytes?: number;\n    /**\n     * Prototype-poisoning policy for JSON bodies (the schema path and `c.boundedJson`). An own\n     * `__proto__` key, or a `constructor` carrying a `prototype`, is the payload shape that turns a\n     * later innocent merge/assign into prototype pollution. `\"reject\"` (default) answers the same\n     * flat 400 as malformed JSON; `\"strip\"` removes the offending keys and continues; `\"ignore\"`\n     * parses as-is (only for routes that never merge body input into other objects). Clean payloads\n     * pay a substring pre-scan only - the deep walk runs solely on suspect text.\n     */\n    readonly protoPoisoning?: \"reject\" | \"strip\" | \"ignore\";\n    /**\n     * Declare that every `Request` reaching `app.fetch` was framed by a runtime HTTP parser, so its\n     * `Content-Length` is an exact transport boundary rather than a hint. Set this ONLY when the\n     * runtime's own request object is handed through untouched with no adapter in between to mark it -\n     * a bare `export default app` on an edge runtime. Every supported ingress already marks itself:\n     * `listen()` on Bun, `toFetchHandler(app)` on Workers/edge, `@nifrajs/deno`, and `@nifrajs/node`\n     * (which reads exact bytes and never needs the mark). Reach for this option only for an ingress\n     * nifra does not ship an adapter for.\n     *\n     * Left off (default), the JSON body lane copies the body out and enforces the cap on DELIVERED\n     * bytes, because an unmarked request may have been rebuilt by an adapter that kept a caller's\n     * `content-length` while decoding a payload of a different size. That check costs an extra pass\n     * over the body, which is why an edge deployment that cannot be lied to may opt out of it.\n     *\n     * Do not set this on an app whose `fetch` is also called with `Request`s assembled from\n     * untrusted input.\n     */\n    readonly trustBodyFraming?: boolean;\n    /** Max inbound WebSocket message size (bytes) when `listen()`ing on Bun - frames over this are rejected\n     * by the runtime before reaching your handler (so a huge frame can't be JSON-parsed into memory).\n     * Default: `maxBodyBytes` (1 MB). */\n    readonly wsMaxPayloadBytes?: number;\n    /** Per-request timeout (ms): a slower request gets a 503 and `ctx.signal` aborts. 0 disables (default). */\n    readonly requestTimeoutMs?: number;\n    /**\n     * How to derive `c.clientIp` behind a reverse proxy or CDN. Omit (default) to trust only the raw\n     * socket peer and never believe a forwarded header. Set `{ trustedHops: n }` when the app sits\n     * behind `n` proxies you operate (the caller is read from `X-Forwarded-For` past those hops), or\n     * `{ header: name }` to trust one edge-set header's first value. Declaring trust the app can't\n     * actually enforce lets clients forge their IP, so leave it unset unless a proxy really fronts you.\n     */\n    readonly clientIp?: ClientIpTrust;\n    /**\n     * Admit the public `x-nifra-deadline` header and let it shorten local work. Disabled by default:\n     * services that participate in trusted cross-service deadline propagation opt in explicitly,\n     * while ordinary/public HTTP routes pay no header-admission tax and ignore hostile client values.\n     */\n    readonly acceptInboundDeadlines?: boolean;\n    /**\n     * Maximum time accepted from an inbound `x-nifra-deadline`, in milliseconds. An incoming absolute\n     * deadline may shorten this cap (and `requestTimeoutMs`, when configured), never extend it.\n     * Default 30_000; applies only when `acceptInboundDeadlines` is enabled and the header is present.\n     */\n    readonly maxInboundDeadlineMs?: number;\n    /** When `listen()`ing, install SIGTERM/SIGINT handlers that gracefully `stop()`. Default false. */\n    readonly gracefulSignals?: boolean;\n    /**\n     * Capacity-admission gate (see {@link AdmissionController}). Bounds concurrent in-flight work so a\n     * healthy instance sheds load (`429` + `Retry-After`) instead of accepting more than it can finish.\n     * Off by default. Enabling it disables the fused native-route fast path (requests route through the\n     * shared matched lane where the gate runs); when unset, the request path pays nothing.\n     */\n    readonly admission?: AdmissionController;\n    /**\n     * Optional token-only observation hook called by `useCapability(c, id)`. It receives no request,\n     * parameters, body, tenant, or values. Routes without capability declarations keep the old hot path.\n     */\n    readonly onCapabilityUse?: (event: CapabilityUseEvent) => void;\n    /** Structured logger for framework events (redacts secrets). Default: JSON to stderr. */\n    readonly logger?: Logger;\n    /**\n     * How much of an unhandled error reaches the log for a 500. Never reaches the client either way -\n     * the response is always a bare `internal_error`.\n     *\n     * - `\"full\"` (default) - `name`, the error's own text as `detail`, and `stack`.\n     * - `\"message\"` - `name` and `detail`, no stack.\n     * - `\"none\"` - `name` only.\n     *\n     * An error's text can quote the input that produced it, which is how request data ends up in a log\n     * sink. The framework's answer is the redacting logger rather than blanket suppression: pass\n     * `logger: jsonLogger({ valuePatterns: commonSecretPatterns })` to scrub tokens, JWTs, and emails\n     * out of `detail` and `stack` while keeping the diagnosis. Reach for `\"none\"` when the sink itself\n     * is the thing you don't trust.\n     */\n    readonly errorLogDetail?: \"full\" | \"message\" | \"none\";\n    /**\n     * App-wide fallback fired when a route **without its own `onValidationError`** fails body/query\n     * validation. Same contract as the per-route hook (`(issues, ctx, kind) => Response | repaired-value |\n     * undefined`): a route's own hook takes precedence, and a route can fall through to the plain `422` by\n     * returning `undefined`. Use it for one app-wide error envelope (like tRPC's `errorFormatter` /\n     * Fastify's `setErrorHandler`) instead of repeating a formatter per route.\n     */\n    readonly onValidationError?: RouteSchema[\"onValidationError\"];\n}"
   },
   {
     "name": "ServerOptions",
     "kind": "interface",
     "package": "nifra",
-    "signature": "export interface ServerOptions {\n    /**\n     * Max request body size (bytes), enforced **only when a route declares a body schema** - the cap\n     * lives in the schema-validated read path. Default 1_000_000.\n     *\n     * A route WITHOUT a body schema (raw body, file upload, BYO-validation) that reads `c.req` directly\n     * is not auto-bounded - use **`c.boundedBody(maxBytes?)`** / **`c.boundedJson(maxBytes?)`**, which\n     * apply this same cap (override per route by passing `maxBytes` - larger for an upload endpoint,\n     * smaller to tighten one).\n     */\n    readonly maxBodyBytes?: number;\n    /** Max inbound WebSocket message size (bytes) when `listen()`ing on Bun - frames over this are rejected\n     * by the runtime before reaching your handler (so a huge frame can't be JSON-parsed into memory).\n     * Default: `maxBodyBytes` (1 MB). */\n    readonly wsMaxPayloadBytes?: number;\n    /** Per-request timeout (ms): a slower request gets a 503 and `ctx.signal` aborts. 0 disables (default). */\n    readonly requestTimeoutMs?: number;\n    /**\n     * How to derive `c.clientIp` behind a reverse proxy or CDN. Omit (default) to trust only the raw\n     * socket peer and never believe a forwarded header. Set `{ trustedHops: n }` when the app sits\n     * behind `n` proxies you operate (the caller is read from `X-Forwarded-For` past those hops), or\n     * `{ header: name }` to trust one edge-set header's first value. Declaring trust the app can't\n     * actually enforce lets clients forge their IP, so leave it unset unless a proxy really fronts you.\n     */\n    readonly clientIp?: ClientIpTrust;\n    /**\n     * Admit the public `x-nifra-deadline` header and let it shorten local work. Disabled by default:\n     * services that participate in trusted cross-service deadline propagation opt in explicitly,\n     * while ordinary/public HTTP routes pay no header-admission tax and ignore hostile client values.\n     */\n    readonly acceptInboundDeadlines?: boolean;\n    /**\n     * Maximum time accepted from an inbound `x-nifra-deadline`, in milliseconds. An incoming absolute\n     * deadline may shorten this cap (and `requestTimeoutMs`, when configured), never extend it.\n     * Default 30_000; applies only when `acceptInboundDeadlines` is enabled and the header is present.\n     */\n    readonly maxInboundDeadlineMs?: number;\n    /** When `listen()`ing, install SIGTERM/SIGINT handlers that gracefully `stop()`. Default false. */\n    readonly gracefulSignals?: boolean;\n    /**\n     * Capacity-admission gate (see {@link AdmissionController}). Bounds concurrent in-flight work so a\n     * healthy instance sheds load (`429` + `Retry-After`) instead of accepting more than it can finish.\n     * Off by default. Enabling it disables the fused native-route fast path (requests route through the\n     * shared matched lane where the gate runs); when unset, the request path pays nothing.\n     */\n    readonly admission?: AdmissionController;\n    /**\n     * Optional token-only observation hook called by `useCapability(c, id)`. It receives no request,\n     * parameters, body, tenant, or values. Routes without capability declarations keep the old hot path.\n     */\n    readonly onCapabilityUse?: (event: CapabilityUseEvent) => void;\n    /** Structured logger for framework events (redacts secrets). Default: JSON to stderr. */\n    readonly logger?: Logger;\n    /**\n     * App-wide fallback fired when a route **without its own `onValidationError`** fails body/query\n     * validation. Same contract as the per-route hook (`(issues, ctx, kind) => Response | repaired-value |\n     * undefined`): a route's own hook takes precedence, and a route can fall through to the plain `422` by\n     * returning `undefined`. Use it for one app-wide error envelope (like tRPC's `errorFormatter` /\n     * Fastify's `setErrorHandler`) instead of repeating a formatter per route.\n     */\n    readonly onValidationError?: RouteSchema[\"onValidationError\"];\n}"
+    "signature": "export interface ServerOptions {\n    /**\n     * Max request body size (bytes), the default transport cap for every route. Default 1_000_000.\n     * A route can choose a finite `schema.bodyLimit` of its own; an explicit `'unlimited'` route\n     * requires `schema.bodyLimitReason` and is intended only for a separately bounded streaming or\n     * upload integration.\n     *\n     * Framework readers (the body-schema lane, `c.boundedJson`) enforce the cap when they read. A\n     * route WITHOUT a body schema (raw body, file upload, BYO-validation) is covered too: direct\n     * `c.req` reads (`json()`, `arrayBuffer()`, the raw `body` stream, ...) are capped in place -\n     * lazily, nothing is buffered until code actually reads - and answer 413 past the limit.\n     * `c.boundedBody(n)` states its own explicit per-read limit, above or below the route's cap.\n     */\n    readonly maxBodyBytes?: number;\n    /**\n     * Prototype-poisoning policy for JSON bodies (the schema path and `c.boundedJson`). An own\n     * `__proto__` key, or a `constructor` carrying a `prototype`, is the payload shape that turns a\n     * later innocent merge/assign into prototype pollution. `\"reject\"` (default) answers the same\n     * flat 400 as malformed JSON; `\"strip\"` removes the offending keys and continues; `\"ignore\"`\n     * parses as-is (only for routes that never merge body input into other objects). Clean payloads\n     * pay a substring pre-scan only - the deep walk runs solely on suspect text.\n     */\n    readonly protoPoisoning?: \"reject\" | \"strip\" | \"ignore\";\n    /**\n     * Declare that every `Request` reaching `app.fetch` was framed by a runtime HTTP parser, so its\n     * `Content-Length` is an exact transport boundary rather than a hint. Set this ONLY when the\n     * runtime's own request object is handed through untouched with no adapter in between to mark it -\n     * a bare `export default app` on an edge runtime. Every supported ingress already marks itself:\n     * `listen()` on Bun, `toFetchHandler(app)` on Workers/edge, `@nifrajs/deno`, and `@nifrajs/node`\n     * (which reads exact bytes and never needs the mark). Reach for this option only for an ingress\n     * nifra does not ship an adapter for.\n     *\n     * Left off (default), the JSON body lane copies the body out and enforces the cap on DELIVERED\n     * bytes, because an unmarked request may have been rebuilt by an adapter that kept a caller's\n     * `content-length` while decoding a payload of a different size. That check costs an extra pass\n     * over the body, which is why an edge deployment that cannot be lied to may opt out of it.\n     *\n     * Do not set this on an app whose `fetch` is also called with `Request`s assembled from\n     * untrusted input.\n     */\n    readonly trustBodyFraming?: boolean;\n    /** Max inbound WebSocket message size (bytes) when `listen()`ing on Bun - frames over this are rejected\n     * by the runtime before reaching your handler (so a huge frame can't be JSON-parsed into memory).\n     * Default: `maxBodyBytes` (1 MB). */\n    readonly wsMaxPayloadBytes?: number;\n    /** Per-request timeout (ms): a slower request gets a 503 and `ctx.signal` aborts. 0 disables (default). */\n    readonly requestTimeoutMs?: number;\n    /**\n     * How to derive `c.clientIp` behind a reverse proxy or CDN. Omit (default) to trust only the raw\n     * socket peer and never believe a forwarded header. Set `{ trustedHops: n }` when the app sits\n     * behind `n` proxies you operate (the caller is read from `X-Forwarded-For` past those hops), or\n     * `{ header: name }` to trust one edge-set header's first value. Declaring trust the app can't\n     * actually enforce lets clients forge their IP, so leave it unset unless a proxy really fronts you.\n     */\n    readonly clientIp?: ClientIpTrust;\n    /**\n     * Admit the public `x-nifra-deadline` header and let it shorten local work. Disabled by default:\n     * services that participate in trusted cross-service deadline propagation opt in explicitly,\n     * while ordinary/public HTTP routes pay no header-admission tax and ignore hostile client values.\n     */\n    readonly acceptInboundDeadlines?: boolean;\n    /**\n     * Maximum time accepted from an inbound `x-nifra-deadline`, in milliseconds. An incoming absolute\n     * deadline may shorten this cap (and `requestTimeoutMs`, when configured), never extend it.\n     * Default 30_000; applies only when `acceptInboundDeadlines` is enabled and the header is present.\n     */\n    readonly maxInboundDeadlineMs?: number;\n    /** When `listen()`ing, install SIGTERM/SIGINT handlers that gracefully `stop()`. Default false. */\n    readonly gracefulSignals?: boolean;\n    /**\n     * Capacity-admission gate (see {@link AdmissionController}). Bounds concurrent in-flight work so a\n     * healthy instance sheds load (`429` + `Retry-After`) instead of accepting more than it can finish.\n     * Off by default. Enabling it disables the fused native-route fast path (requests route through the\n     * shared matched lane where the gate runs); when unset, the request path pays nothing.\n     */\n    readonly admission?: AdmissionController;\n    /**\n     * Optional token-only observation hook called by `useCapability(c, id)`. It receives no request,\n     * parameters, body, tenant, or values. Routes without capability declarations keep the old hot path.\n     */\n    readonly onCapabilityUse?: (event: CapabilityUseEvent) => void;\n    /** Structured logger for framework events (redacts secrets). Default: JSON to stderr. */\n    readonly logger?: Logger;\n    /**\n     * How much of an unhandled error reaches the log for a 500. Never reaches the client either way -\n     * the response is always a bare `internal_error`.\n     *\n     * - `\"full\"` (default) - `name`, the error's own text as `detail`, and `stack`.\n     * - `\"message\"` - `name` and `detail`, no stack.\n     * - `\"none\"` - `name` only.\n     *\n     * An error's text can quote the input that produced it, which is how request data ends up in a log\n     * sink. The framework's answer is the redacting logger rather than blanket suppression: pass\n     * `logger: jsonLogger({ valuePatterns: commonSecretPatterns })` to scrub tokens, JWTs, and emails\n     * out of `detail` and `stack` while keeping the diagnosis. Reach for `\"none\"` when the sink itself\n     * is the thing you don't trust.\n     */\n    readonly errorLogDetail?: \"full\" | \"message\" | \"none\";\n    /**\n     * App-wide fallback fired when a route **without its own `onValidationError`** fails body/query\n     * validation. Same contract as the per-route hook (`(issues, ctx, kind) => Response | repaired-value |\n     * undefined`): a route's own hook takes precedence, and a route can fall through to the plain `422` by\n     * returning `undefined`. Use it for one app-wide error envelope (like tRPC's `errorFormatter` /\n     * Fastify's `setErrorHandler`) instead of repeating a formatter per route.\n     */\n    readonly onValidationError?: RouteSchema[\"onValidationError\"];\n}"
   },
   {
     "name": "ServeStaticOptions",
     "kind": "interface",
     "package": "@nifrajs/node",
-    "signature": "export interface ServeStaticOptions {\n    /** Directory to read files from - an absolute path or a `file://` URL (`new URL(\"./assets/\", import.meta.url)`). */\n    readonly dir: string | URL;\n    /** URL prefix these files are served under. Default `\"/assets\"`. Use `\"/\"` to serve the whole dir. */\n    readonly prefix?: string;\n    /** Emit `cache-control: public, max-age=31536000, immutable` - correct for content-hashed files. Default `true`. */\n    readonly immutable?: boolean;\n    /** Extra headers merged onto every served file. */\n    readonly headers?: Readonly<Record<string, string>>;\n}",
+    "signature": "export interface ServeStaticOptions {\n    /** Directory to read files from - an absolute path or a `file://` URL (`new URL(\"./assets/\", import.meta.url)`). */\n    readonly dir: string | URL;\n    /** URL prefix these files are served under. Default `\"/assets\"`. Use `\"/\"` to serve the whole dir. */\n    readonly prefix?: string;\n    /** Emit `cache-control: public, max-age=31536000, immutable` - correct for content-hashed files. Default `true`. */\n    readonly immutable?: boolean;\n    /** Extra headers merged onto every served file. */\n    readonly headers?: Readonly<Record<string, string>>;\n    /**\n     * Whether a path with a dot-leading segment (`/.env`, `/.git/config`, `/.hidden/app.js`) is\n     * served. Default `\"deny\"`: answered `404` - the same response as a missing file, so probing\n     * can't distinguish \"hidden\" from \"absent\". Dotfiles land in build output by accident, not by\n     * design (`.env` next to the bundle, a `.git` dir in a copied tree), so serving them is opt-in.\n     * Set `\"allow\"` if the directory deliberately contains them (e.g. `/.well-known`).\n     */\n    readonly dotfiles?: \"deny\" | \"allow\";\n}",
     "doc": "/**\n * Serve static files from a directory (e.g. the client build) under a URL prefix - so a self-hosted\n * Node deploy doesn't need a CDN or a hand-rolled `/assets/*` handler. (On Cloudflare/Vercel the\n * platform serves assets; this is for `node server.js`.)\n */"
   },
   {
@@ -9768,7 +11001,7 @@
     "name": "SessionOptions",
     "kind": "interface",
     "package": "@nifrajs/auth",
-    "signature": "export interface SessionOptions {\n    /** Signing secret (≥ 16 chars). Rotating it invalidates all existing sessions. */\n    readonly secret: string;\n    /** Provide a store for **store mode**; omit for **cookie mode** (stateless). */\n    readonly store?: SessionStore;\n    /** Cookie name. Default `nifra_session`. */\n    readonly cookieName?: string;\n    /** Session lifetime in **seconds**. Default 7 days. */\n    readonly maxAge?: number;\n    /** Slide the expiry forward on every commit (default `true`); `false` = fixed absolute expiry. */\n    readonly rolling?: boolean;\n    /** Extra cookie attributes (the session cookie is always HttpOnly; `Secure`/`SameSite=Lax`/`Path=/`\n     * default via `c.set.cookie`). Pass `{ secure: false }` for local http dev. */\n    readonly cookie?: SessionCookieOptions;\n    /** Clock (ms) - injected for testability; production passes `() => Date.now()` (the default). */\n    readonly now?: () => number;\n}"
+    "signature": "export interface SessionOptions {\n    /** Signing secret (≥ 32 bytes), or a rotation list: the **first** secret signs new cookies and\n     * any listed secret verifies, so rotating without invalidating live sessions is: prepend the new\n     * secret, drop the old one after `maxAge` has elapsed. A bare secret swap (no list) invalidates\n     * all existing sessions. */\n    readonly secret: string | readonly string[];\n    /** Provide a store for **store mode**; omit for **cookie mode** (stateless). */\n    readonly store?: SessionStore;\n    /** Cookie name. Default `nifra_session`. */\n    readonly cookieName?: string;\n    /** Session lifetime in **seconds**. Default 7 days. */\n    readonly maxAge?: number;\n    /** Slide the expiry forward on every commit (default `true`); `false` = fixed absolute expiry. */\n    readonly rolling?: boolean;\n    /** Extra cookie attributes (the session cookie is always HttpOnly; `Secure`/`SameSite=Lax`/`Path=/`\n     * default via `c.set.cookie`). Pass `{ secure: false }` for local http dev. */\n    readonly cookie?: SessionCookieOptions;\n    /** Clock (ms) - injected for testability; production passes `() => Date.now()` (the default). */\n    readonly now?: () => number;\n}"
   },
   {
     "name": "SessionRecord",
@@ -9858,7 +11091,20 @@
     "kind": "function",
     "package": "@nifrajs/web",
     "signature": "export declare function setSsrModuleLoader(load: SsrModuleLoader | undefined): void;",
-    "doc": "/**\n * Publishes the dev server's SSR module loader. Called by a dev server that owns SSR resolution\n * itself; pass `undefined` to clear it on shutdown.\n */"
+    "doc": "/** Publish or clear the dev server's SSR module loader. */"
+  },
+  {
+    "name": "Severity",
+    "kind": "type",
+    "package": "@nifrajs/cli",
+    "signature": "export type Severity = \"error\" | \"warn\" | \"info\";",
+    "doc": "/** Stable, machine-actionable diagnostics shared by CLI gates and MCP renderers. */"
+  },
+  {
+    "name": "severityFails",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function severityFails(severity: Severity, strict?: boolean): boolean;"
   },
   {
     "name": "shapeOf",
@@ -9953,15 +11199,15 @@
     "name": "signValue",
     "kind": "function",
     "package": "@nifrajs/core",
-    "signature": "export declare function signValue(value: string, secret: string): Promise<string>;",
-    "doc": "/** Append an HMAC-SHA256 signature to a value → `value.signature` (base64url). For signed cookies. */"
+    "signature": "export declare function signValue(value: string, secret: CookieSecret): Promise<string>;",
+    "doc": "/** Append an HMAC-SHA256 signature to a value → `value.signature` (base64url). For signed cookies.\n * With a {@link CookieSecret} rotation list, signs with the first secret. */"
   },
   {
     "name": "signValue",
     "kind": "function",
     "package": "nifra",
-    "signature": "export declare function signValue(value: string, secret: string): Promise<string>;",
-    "doc": "/** Append an HMAC-SHA256 signature to a value → `value.signature` (base64url). For signed cookies. */"
+    "signature": "export declare function signValue(value: string, secret: CookieSecret): Promise<string>;",
+    "doc": "/** Append an HMAC-SHA256 signature to a value → `value.signature` (base64url). For signed cookies.\n * With a {@link CookieSecret} rotation list, signs with the first secret. */"
   },
   {
     "name": "silentLogger",
@@ -10024,6 +11270,13 @@
     "signature": "export declare function snapshotDataContract(contract: DataContract): DataContractSnapshot;",
     "doc": "/** Strip a contract to its token-only version/access snapshot for CI or adapter drift checks. */"
   },
+  {
+    "name": "snapshotProjectEvidence",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function snapshotProjectEvidence(source: unknown, options?: ProjectEvidenceOptions): ProjectEvidenceSnapshot;",
+    "doc": "/** Build the canonical snapshot from reflection and already-evaluated offline reports. */"
+  },
   {
     "name": "snapshotRoutes",
     "kind": "function",
@@ -10066,6 +11319,24 @@
     "signature": "export declare function sortRoutesBySpecificity<T extends {\n    readonly pattern: CompiledRoutePattern;\n}>(routes: T[]): T[];",
     "doc": "/**\n * Sort compiled routes most-specific-first - a static segment beats a dynamic one, the order the router\n * resolves a path in. The single home for that precedence: the web router, the mock server, and the\n * editor plugin all order routes through this one comparator, so which file a path resolves to can never\n * diverge between runtime, client, and editor. Sorts in place and returns the same array.\n */"
   },
+  {
+    "name": "SourceFile",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface SourceFile {\n    readonly file: string;\n    readonly content: string;\n}"
+  },
+  {
+    "name": "sourceIndex",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function sourceIndex(files: readonly SourceFile[]): SourceIndex;"
+  },
+  {
+    "name": "SourceIndex",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface SourceIndex {\n    readonly files: readonly string[];\n    read(file: string): string | undefined;\n}"
+  },
   {
     "name": "SourceReader",
     "kind": "type",
@@ -10090,7 +11361,7 @@
     "name": "SqliteDatabaseLike",
     "kind": "interface",
     "package": "@nifrajs/mcp-db",
-    "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}",
+    "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    /** Optional path this database was opened from; a file-backed one can be reopened read-only in a\n     * worker so `run_query` runs off the serving connection. `:memory:` and the empty anonymous\n     * database cannot, and run in process. */\n    readonly filename?: string;\n}",
     "doc": "/** The structural slice of `bun:sqlite`'s `Database` this package needs. */"
   },
   {
@@ -10182,14 +11453,20 @@
     "kind": "function",
     "package": "@nifrajs/web",
     "signature": "export declare function ssrModuleLoader(): SsrModuleLoader | undefined;",
-    "doc": "/**\n * The dev server's SSR module loader, or `undefined` when nothing owns SSR resolution but the runtime\n * - the Bun dev pipeline, and every production build, where the adapter's assets are compiled ahead\n * of time and a plain `import` is already the right thing.\n *\n * An adapter that must load a COMPILED asset at runtime (a `.svelte` component, say) has to prefer\n * this over a bare `import`, and has to take the framework's SERVER RENDERER from it as well, not\n * just the component. A component compiled by the dev server renders through the renderer the dev\n * server resolved; mixing the two puts two copies of the framework runtime in one component tree,\n * where context written by one half is invisible to the other.\n */"
+    "doc": "/** Return the dev server's SSR module loader, when one owns SSR resolution. */"
   },
   {
     "name": "SsrModuleLoader",
     "kind": "type",
     "package": "@nifrajs/web",
     "signature": "export type SsrModuleLoader = (id: string) => Promise<unknown>;",
-    "doc": "/**\n * Loads a module through the DEV SERVER'S module graph rather than the runtime's. Takes an absolute\n * file path or a bare specifier; resolution, compilation and caching are the dev server's.\n */"
+    "doc": "/** Loads a module through the dev server's module graph rather than the runtime's resolver. */"
+  },
+  {
+    "name": "StaleBuildError",
+    "kind": "class",
+    "package": "@nifrajs/cli",
+    "signature": "export declare class StaleBuildError extends Error {\n    readonly freshness: BuildFreshness;\n    constructor(freshness: BuildFreshness);\n}"
   },
   {
     "name": "StandardFailure",
@@ -10516,6 +11793,13 @@
     "signature": "export interface StoredResponse {\n    readonly status: number;\n    readonly headers: readonly (readonly [string, string])[];\n    /** Base64-encoded response body; `\"\"` when the response had no body. */\n    readonly body: string;\n}",
     "doc": "/** A serialized response held by a store. `body` is base64 so binary payloads round-trip intact. */"
   },
+  {
+    "name": "streamHandle",
+    "kind": "function",
+    "package": "@nifrajs/aws-lambda",
+    "signature": "export declare function streamHandle(app: FetchHandler, options?: LambdaOptions): (event: LambdaEvent, responseStream: ResponseStream, context?: LambdaContext) => Promise<void>;",
+    "doc": "/**\n * A streaming Lambda handler for Function URLs with `InvokeMode: RESPONSE_STREAM`, via the\n * runtime's `awslambda.streamifyResponse`. Response bytes flow as the app produces them - no\n * buffering, no base64. Requires the managed AWS Lambda Node runtime (the `awslambda` global);\n * API Gateway does not support response streaming - use {@link handle} there.\n */"
+  },
   {
     "name": "streaming",
     "kind": "function",
@@ -10739,11 +12023,17 @@
     "package": "@nifrajs/testing",
     "signature": "export interface TestSessionOptions extends Omit<ClientOptions, \"fetch\"> {\n    /** Origin used to resolve relative paths. Default `\"http://nifra.internal\"`. */\n    readonly origin?: string;\n    /** Reuse an existing jar (e.g. seed a session cookie, or share one across sessions). */\n    readonly cookies?: CookieJar;\n}"
   },
+  {
+    "name": "testToolAdapter",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function testToolAdapter<Input, Output>(tool: ToolContract<Input, Output>, baseOptions?: ToolCallOptions): ToolAdapter;"
+  },
   {
     "name": "timing",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function timing(options?: TimingOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").Server<any, any>>;",
+    "signature": "export declare function timing(options?: TimingOptions): ContextPlugin<{\n    timing: TimingControls;\n}>;",
     "doc": "/**\n * Adds a `Server-Timing` response header and typed `c.timing` controls for custom metrics.\n * Put request-rewriting middleware (for example `methodOverride`) before `timing()` so timing is\n * attached to the final routed request.\n */"
   },
   {
@@ -10771,6 +12061,13 @@
     "signature": "export declare function toBytes(data: StorageData): Uint8Array;",
     "doc": "/** Normalize any accepted payload to bytes. */"
   },
+  {
+    "name": "toCatalogEntry",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function toCatalogEntry<Input, Output>(tool: ToolContract<Input, Output>): ToolCatalogEntry;",
+    "doc": "/** Build the single descriptive projection shared by agent, MCP, and test adapters. */"
+  },
   {
     "name": "toFetchHandler",
     "kind": "function",
@@ -10806,6 +12103,13 @@
     "signature": "export declare function toLambdaHandler<Env = unknown>(app: FetchApp<Env>): LambdaHandler;",
     "doc": "/** Adapt API Gateway HTTP API (v2) and REST API (v1) events to a Web-standard app. */"
   },
+  {
+    "name": "toMcpTool",
+    "kind": "function",
+    "package": "@nifrajs/mcp",
+    "signature": "export declare function toMcpTool<Input, Output>(tool: ToolContract<Input, Output>, options?: McpToolContractOptions): McpTool;",
+    "doc": "/** Adapt a contract to MCP without creating a second validation or enforcement path. */"
+  },
   {
     "name": "toNetlifyHandler",
     "kind": "function",
@@ -10820,6 +12124,18 @@
     "signature": "export declare function toNetlifyHandler<Env = unknown>(app: FetchApp<Env>): NetlifyHandler;",
     "doc": "/** Adapt a Web-standard app to a Netlify Functions event handler. */"
   },
+  {
+    "name": "ToolAdapter",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolAdapter {\n    readonly name: string;\n    call(input: unknown, options?: ToolCallOptions): Promise<ToolAdapterResult>;\n}"
+  },
+  {
+    "name": "ToolAdapterResult",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ToolAdapterResult<Output = unknown> = {\n    readonly ok: true;\n    readonly output?: Output;\n    readonly dryRun: boolean;\n    readonly evidence: readonly ToolEvidence[];\n} | {\n    readonly ok: false;\n    readonly dryRun: boolean;\n    readonly error: ToolError;\n    readonly evidence: readonly ToolEvidence[];\n};"
+  },
   {
     "name": "ToolAnnotations",
     "kind": "interface",
@@ -10834,6 +12150,151 @@
     "signature": "export interface ToolAnnotations {\n    /** Human-readable display title for the tool, distinct from the machine `name`. */\n    readonly title?: string;\n    /** The tool does not modify its environment (a pure read). */\n    readonly readOnlyHint?: boolean;\n    /** The tool may perform destructive updates - only meaningful when `readOnlyHint` is not `true`. */\n    readonly destructiveHint?: boolean;\n    /** Repeated calls with the same arguments have no additional effect beyond the first. */\n    readonly idempotentHint?: boolean;\n    /** The tool interacts with external entities (an \"open world\" beyond this server). */\n    readonly openWorldHint?: boolean;\n}",
     "doc": "/**\n * MCP tool safety hints, surfaced in `tools/list`, that tell an agent how risky a `.tool()` call is - so it\n * can decide whether to auto-invoke or confirm first. All optional; an omitted hint means \"unknown\". Mirrors\n * the MCP spec's tool `annotations`.\n */"
   },
+  {
+    "name": "ToolApproval",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ToolApproval = {\n    readonly granted: true;\n    readonly level?: number;\n} | {\n    readonly granted: false;\n    readonly reason?: string;\n};"
+  },
+  {
+    "name": "ToolApprovalPolicy",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ToolApprovalPolicy = {\n    readonly kind: \"none\";\n} | {\n    readonly kind: \"required\";\n} | {\n    readonly kind: \"threshold\";\n    readonly level: number;\n};"
+  },
+  {
+    "name": "ToolBudget",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolBudget {\n    readonly consume: (cost: EffectCost | undefined) => boolean;\n    readonly snapshot: () => EffectCost;\n}"
+  },
+  {
+    "name": "ToolCallOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolCallOptions {\n    readonly effectId?: string;\n    readonly clock?: () => number;\n    readonly signal?: AbortSignal;\n    /** Wall-clock budget shared with the parent request, distinct from the cost `budget`. */\n    readonly deadline?: RequestBudget;\n    readonly capabilities?: readonly string[];\n    readonly approval?: ToolApproval;\n    readonly budget?: ToolBudget;\n    readonly idempotency?: ToolIdempotencyStore;\n    readonly namespace?: string;\n    readonly dryRun?: boolean;\n    readonly ledger?: RequestLedger;\n    readonly executionPolicy?: ExecutionPolicyAdapter;\n}"
+  },
+  {
+    "name": "ToolCallOptions",
+    "kind": "interface",
+    "package": "@nifrajs/mcp",
+    "signature": "export interface ToolCallOptions {\n    readonly effectId?: string;\n    readonly clock?: () => number;\n    readonly signal?: AbortSignal;\n    /** Wall-clock budget shared with the parent request, distinct from the cost `budget`. */\n    readonly deadline?: RequestBudget;\n    readonly capabilities?: readonly string[];\n    readonly approval?: ToolApproval;\n    readonly budget?: ToolBudget;\n    readonly idempotency?: ToolIdempotencyStore;\n    readonly namespace?: string;\n    readonly dryRun?: boolean;\n    readonly ledger?: RequestLedger;\n    readonly executionPolicy?: ExecutionPolicyAdapter;\n}"
+  },
+  {
+    "name": "ToolCallResult",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ToolCallResult<Output> = {\n    readonly ok: true;\n    readonly output?: Output;\n    readonly dryRun: boolean;\n    readonly evidence: readonly ToolEvidence[];\n    readonly ledger: SealedEffectLedger;\n} | {\n    readonly ok: false;\n    readonly dryRun: boolean;\n    readonly output?: undefined;\n    readonly error: ToolError;\n    readonly evidence: readonly ToolEvidence[];\n    readonly ledger: SealedEffectLedger;\n};"
+  },
+  {
+    "name": "ToolCatalogEntry",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolCatalogEntry {\n    readonly name: string;\n    readonly description: string;\n    readonly inputSchema: Record<string, unknown>;\n    readonly capability: string;\n    readonly sensitivity: ToolSensitivity;\n    readonly approval: ToolApprovalPolicy;\n    readonly idempotent: boolean;\n    readonly annotations: ToolAnnotations;\n}",
+    "doc": "/**\n * A read-only, transport-neutral view of a tool contract.\n *\n * This module is descriptive only. It never validates input, checks capabilities, requests approval,\n * reserves idempotency, consumes cost, or executes the tool. Those policies stay in `executeTool`.\n */"
+  },
+  {
+    "name": "ToolConformanceResult",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolConformanceResult {\n    readonly adapter: string;\n    readonly checks: readonly string[];\n}"
+  },
+  {
+    "name": "ToolContract",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolContract<Input = unknown, Output = unknown> {\n    readonly name: string;\n    readonly description: string;\n    readonly input: StandardSchemaV1<unknown, Input>;\n    readonly output: StandardSchemaV1<unknown, Output>;\n    readonly capability: string;\n    readonly approval: ToolApprovalPolicy;\n    readonly idempotency?: ToolIdempotencyPolicy<Input>;\n    readonly cost?: EffectCost;\n    readonly sensitivity: ToolSensitivity;\n    readonly annotations: ToolAnnotations;\n    readonly policy?: ExecutionPolicy;\n    readonly execute: (input: Input, context: ToolExecutionContext) => Output | PromiseLike<Output>;\n}"
+  },
+  {
+    "name": "ToolContract",
+    "kind": "interface",
+    "package": "@nifrajs/mcp",
+    "signature": "export interface ToolContract<Input = unknown, Output = unknown> {\n    readonly name: string;\n    readonly description: string;\n    readonly input: StandardSchemaV1<unknown, Input>;\n    readonly output: StandardSchemaV1<unknown, Output>;\n    readonly capability: string;\n    readonly approval: ToolApprovalPolicy;\n    readonly idempotency?: ToolIdempotencyPolicy<Input>;\n    readonly cost?: EffectCost;\n    readonly sensitivity: ToolSensitivity;\n    readonly annotations: ToolAnnotations;\n    readonly policy?: ExecutionPolicy;\n    readonly execute: (input: Input, context: ToolExecutionContext) => Output | PromiseLike<Output>;\n}"
+  },
+  {
+    "name": "ToolContractOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolContractOptions<Input, Output, InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1> {\n    readonly name: string;\n    readonly description: string;\n    readonly input: InputSchema;\n    readonly output: OutputSchema;\n    readonly capability?: string;\n    readonly approval?: ToolApprovalPolicy;\n    readonly idempotency?: ToolIdempotencyPolicy<Input>;\n    /** Dimensionless counters such as `{ calls: 1, ms: 20 }`; never prices. */\n    readonly cost?: EffectCost;\n    readonly sensitivity?: ToolSensitivity;\n    readonly annotations?: ToolAnnotations;\n    readonly policy?: ExecutionPolicy;\n    readonly execute: (input: Input, context: ToolExecutionContext) => Output | PromiseLike<Output>;\n}"
+  },
+  {
+    "name": "ToolError",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolError {\n    readonly code: \"input_invalid\" | \"capability_denied\" | \"execution_policy_unsatisfied\" | \"approval_required\" | \"approval_denied\" | \"idempotency_store_missing\" | \"idempotency_durability\" | \"idempotency_duplicate\" | \"idempotency_in_flight\" | \"idempotency_capacity\" | \"budget_exceeded\" | \"cancelled\" | \"execution_failed\" | \"output_invalid\" | \"ledger_failed\";\n    readonly stage: ToolEvidenceStage;\n    readonly issues?: readonly StandardIssue[];\n}"
+  },
+  {
+    "name": "ToolEvidence",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolEvidence {\n    readonly seq: number;\n    readonly stage: ToolEvidenceStage;\n    readonly outcome: ToolEvidenceOutcome;\n    readonly code?: string;\n}"
+  },
+  {
+    "name": "ToolEvidenceOutcome",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ToolEvidenceOutcome = \"passed\" | \"denied\" | \"failed\" | \"skipped\" | \"committed\" | \"dry-run\";"
+  },
+  {
+    "name": "ToolEvidenceStage",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ToolEvidenceStage = \"input\" | \"capability\" | \"policy\" | \"approval\" | \"idempotency\" | \"budget\" | \"execution\" | \"output\";"
+  },
+  {
+    "name": "ToolExecutionContext",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolExecutionContext {\n    readonly effectId: string;\n    readonly signal: AbortSignal;\n    /** Wall-clock budget shared with the parent request, when an agent supplies one. */\n    readonly deadline?: RequestBudget;\n    readonly dryRun: boolean;\n    readonly policy?: ExecutionPolicy;\n}"
+  },
+  {
+    "name": "ToolHttpOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolHttpOptions extends Omit<ToolCallOptions, \"signal\" | \"ledger\"> {\n    readonly method?: string;\n    /** Prototype-poisoning policy for the JSON request body - mirrors the server option (this\n     * handler is standalone, so it carries its own). Default `\"reject\"`. */\n    readonly protoPoisoning?: ProtoPoisoning;\n    /** Transport body cap in bytes for the JSON request body. Default {@link DEFAULT_TOOL_MAX_BYTES}\n     * (1 MiB). `\"unlimited\"` removes the cap and requires a written {@link maxBytesReason}: the\n     * mounting platform then owns the limit, and the exemption is reviewable rather than implicit. */\n    readonly maxBytes?: number | \"unlimited\";\n    /** Why this handler runs uncapped. Required with `maxBytes: \"unlimited\"`, rejected without it. */\n    readonly maxBytesReason?: string;\n}"
+  },
+  {
+    "name": "toolHttpResult",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function toolHttpResult<Output>(result: ToolCallResult<Output>): Response;"
+  },
+  {
+    "name": "ToolIdempotencyBeginInput",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolIdempotencyBeginInput {\n    readonly namespace: string;\n    readonly key: string;\n}"
+  },
+  {
+    "name": "ToolIdempotencyBeginResult",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ToolIdempotencyBeginResult = {\n    readonly state: \"new\";\n    readonly reservation: string;\n} | {\n    readonly state: \"duplicate\";\n} | {\n    readonly state: \"in-flight\";\n} | {\n    readonly state: \"capacity\";\n};"
+  },
+  {
+    "name": "ToolIdempotencyPolicy",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolIdempotencyPolicy<Input = unknown> {\n    readonly scope: Exclude<IdempotencyScope, \"none\">;\n    /** Return an opaque bounded key. The key must not contain a request body or secret. */\n    readonly key: (input: Input) => string | PromiseLike<string>;\n}"
+  },
+  {
+    "name": "ToolIdempotencyStore",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ToolIdempotencyStore {\n    readonly durability?: \"memory\" | \"durable\";\n    begin(input: ToolIdempotencyBeginInput): ToolIdempotencyBeginResult | PromiseLike<ToolIdempotencyBeginResult>;\n    complete(input: {\n        readonly namespace: string;\n        readonly key: string;\n        readonly reservation: string;\n    }): boolean | PromiseLike<boolean>;\n    abandon(input: {\n        readonly namespace: string;\n        readonly key: string;\n        readonly reservation: string;\n    }): boolean | PromiseLike<boolean>;\n}"
+  },
+  {
+    "name": "toolInputJsonSchema",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function toolInputJsonSchema<Input, Output>(tool: ToolContract<Input, Output>): Record<string, unknown>;"
+  },
+  {
+    "name": "ToolSensitivity",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ToolSensitivity = \"public\" | \"internal\" | \"sensitive\" | \"secret\";"
+  },
   {
     "name": "toOpenAPI",
     "kind": "function",
@@ -10893,7 +12354,7 @@
     "name": "tracing",
     "kind": "function",
     "package": "@nifrajs/otel",
-    "signature": "export declare function tracing(options?: TracingOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").Server<any, any>>;",
+    "signature": "export declare function tracing(options?: TracingOptions): ContextPlugin<TracingContext>;",
     "doc": "/**\n * Distributed-tracing plugin. Each request continues the inbound trace (or starts one), opens a\n * server span, and ends it on response with the status + HTTP attributes. Idempotent.\n *\n * ```ts\n * app.use(tracing({ exporter: myOtelExporter, serviceName: \"orders-api\" }))\n * // in a handler: fetch(url, { headers: traceHeaders(c.trace) })  // continue the trace downstream\n * ```\n */"
   },
   {
@@ -10908,6 +12369,48 @@
     "package": "@nifrajs/middleware",
     "signature": "export interface TrailingSlashOptions {\n    /** Redirect (default) or route internally with a rewritten URL. */\n    readonly mode?: \"redirect\" | \"rewrite\";\n    /** Redirect status. Default `308` (method-preserving permanent redirect). */\n    readonly status?: 301 | 302 | 307 | 308;\n    /** Methods affected. Default `[\"GET\", \"HEAD\"]`; add write methods only when you want 308 redirects. */\n    readonly methods?: readonly string[];\n    /** Skip paths whose last segment looks like a file (`/app.css`). Default `true` for append mode. */\n    readonly ignoreFileExtensions?: boolean;\n    /** App-specific skip predicate. */\n    readonly ignore?: (path: string, request: Request) => boolean;\n}"
   },
+  {
+    "name": "TrajectoryInvariantId",
+    "kind": "type",
+    "package": "@nifrajs/testing",
+    "signature": "export type TrajectoryInvariantId = \"ledger-evidence\" | \"capability-admission\" | \"budget-monotonic\" | \"bounded-stop\" | \"resumable-suspension\";"
+  },
+  {
+    "name": "TrajectoryInvariantOptions",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface TrajectoryInvariantOptions {\n    readonly maxSteps?: number;\n    /** Remaining budget snapshots, used when the caller owns a budget adapter. */\n    readonly budgetSnapshots?: readonly Readonly<Record<string, number>>[];\n}"
+  },
+  {
+    "name": "TrajectoryInvariantResult",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface TrajectoryInvariantResult {\n    readonly id: TrajectoryInvariantId;\n    readonly ok: boolean;\n    readonly code?: string;\n}"
+  },
+  {
+    "name": "trajectoryRegressionId",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function trajectoryRegressionId(transcript: TrajectoryTranscript, faultProfile: string, invariant: TrajectoryInvariantId): Promise<string>;"
+  },
+  {
+    "name": "TrajectoryReplayResult",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface TrajectoryReplayResult<Output> {\n    readonly result: AgentRunResult<Output>;\n    readonly transcript: TrajectoryTranscript;\n    readonly faults: readonly FailureEvidence[];\n    readonly invariants: readonly TrajectoryInvariantResult[];\n    readonly regressionIds: readonly string[];\n}"
+  },
+  {
+    "name": "TrajectoryRun",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface TrajectoryRun<Output> {\n    readonly result: AgentRunResult<Output>;\n    readonly transcript: TrajectoryTranscript;\n}"
+  },
+  {
+    "name": "TrajectoryTranscript",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface TrajectoryTranscript {\n    readonly version: 1;\n    readonly digest: string;\n    readonly turn: AgentTranscript;\n    readonly faultProfile?: string;\n    readonly seed?: number;\n}"
+  },
   {
     "name": "transformCssModule",
     "kind": "function",
@@ -10964,7 +12467,7 @@
     "name": "trimTrailingSlash",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function trimTrailingSlash(options?: TrailingSlashOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
+    "signature": "export declare function trimTrailingSlash(options?: TrailingSlashOptions): import(\"@nifrajs/core\").IdentityPlugin;",
     "doc": "/**\n * Remove trailing slashes from non-root paths. Redirect mode is the production default because it\n * canonicalizes URLs for clients and caches; rewrite mode is available for compatibility migrations.\n */"
   },
   {
@@ -10980,6 +12483,12 @@
     "package": "@nifrajs/middleware",
     "signature": "export declare function tryVerifyJwt<C extends JwtClaims = JwtClaims>(token: string, options: VerifyJwtOptions): Promise<VerifyJwtResult<C>>;"
   },
+  {
+    "name": "turn",
+    "kind": "function",
+    "package": "@nifrajs/agent",
+    "signature": "export declare function turn<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1>(definition: AgentDefinition<InputSchema, OutputSchema>, state: AgentTurnState, input: AgentTurnInput, ports: AgentPorts): Promise<AgentTurnResult<NonNullable<OutputSchema[\"~standard\"][\"types\"]>[\"output\"]>>;"
+  },
   {
     "name": "TypedDataPort",
     "kind": "interface",
@@ -11060,15 +12569,15 @@
     "name": "unsignValue",
     "kind": "function",
     "package": "@nifrajs/core",
-    "signature": "export declare function unsignValue(signed: string, secret: string): Promise<string | null>;",
-    "doc": "/**\n * Verify a `value.signature` produced by {@link signValue} and return the value, or `null` if the\n * signature is missing, malformed, or doesn't match. Verification is **constant-time**\n * (`crypto.subtle.verify`), so a wrong signature can't be discovered byte-by-byte via timing.\n */"
+    "signature": "export declare function unsignValue(signed: string, secret: CookieSecret): Promise<string | null>;",
+    "doc": "/**\n * Verify a `value.signature` produced by {@link signValue} and return the value, or `null` if the\n * signature is missing, malformed, or doesn't match. Verification is **constant-time**\n * (`crypto.subtle.verify`), so a wrong signature can't be discovered byte-by-byte via timing.\n *\n * With a {@link CookieSecret} rotation list, tries each secret in order and accepts the first\n * match. Every listed secret must meet the 32-byte floor - a weak entry throws even when an\n * earlier secret would have matched, so a rotation list can't quietly carry a weak key. (Which\n * rotation generation matched is not attacker-meaningful, so the early exit between secrets leaks\n * nothing useful; each individual comparison stays constant-time.)\n */"
   },
   {
     "name": "unsignValue",
     "kind": "function",
     "package": "nifra",
-    "signature": "export declare function unsignValue(signed: string, secret: string): Promise<string | null>;",
-    "doc": "/**\n * Verify a `value.signature` produced by {@link signValue} and return the value, or `null` if the\n * signature is missing, malformed, or doesn't match. Verification is **constant-time**\n * (`crypto.subtle.verify`), so a wrong signature can't be discovered byte-by-byte via timing.\n */"
+    "signature": "export declare function unsignValue(signed: string, secret: CookieSecret): Promise<string | null>;",
+    "doc": "/**\n * Verify a `value.signature` produced by {@link signValue} and return the value, or `null` if the\n * signature is missing, malformed, or doesn't match. Verification is **constant-time**\n * (`crypto.subtle.verify`), so a wrong signature can't be discovered byte-by-byte via timing.\n *\n * With a {@link CookieSecret} rotation list, tries each secret in order and accepts the first\n * match. Every listed secret must meet the 32-byte floor - a weak entry throws even when an\n * earlier secret would have matched, so a rotation list can't quietly carry a weak key. (Which\n * rotation generation matched is not attacker-meaningful, so the early exit between secrets leaks\n * nothing useful; each individual comparison stays constant-time.)\n */"
   },
   {
     "name": "UnsupportedMockSchemaError",
@@ -11534,6 +13043,12 @@
     "signature": "export declare function useT(): Formatter;",
     "doc": "/** Read the current {@link Formatter} (`{ locale, t, n, d }`). Throws if no `<I18nProvider>` is above. */"
   },
+  {
+    "name": "validateRulePacks",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function validateRulePacks(packs: readonly RulePack[] | undefined): readonly RulePack[];"
+  },
   {
     "name": "validateStandard",
     "kind": "function",
@@ -11629,7 +13144,7 @@
     "name": "verifyCsrfToken",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function verifyCsrfToken(token: string, secret: string | Uint8Array): Promise<boolean>;"
+    "signature": "export declare function verifyCsrfToken(token: string, secret: CsrfSecret): Promise<boolean>;"
   },
   {
     "name": "verifyDownloadUrl",
@@ -11692,14 +13207,14 @@
     "name": "VERSION",
     "kind": "const",
     "package": "@nifrajs/core",
-    "signature": "export declare const VERSION: \"2.11.0\";",
+    "signature": "export declare const VERSION: \"2.12.1\";",
     "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 */"
   },
   {
     "name": "VERSION",
     "kind": "const",
     "package": "nifra",
-    "signature": "export declare const VERSION: \"2.11.0\";",
+    "signature": "export declare const VERSION: \"2.12.1\";",
     "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 */"
   },
   {
@@ -11870,14 +13385,14 @@
     "name": "WebSocketUpgradeOutcome",
     "kind": "type",
     "package": "@nifrajs/core",
-    "signature": "export type WebSocketUpgradeOutcome = {\n    readonly kind: \"pass\";\n} | {\n    readonly kind: \"reject\";\n    readonly response: Response;\n} | {\n    readonly kind: \"upgrade\";\n    readonly handler: WebSocketHandler;\n    readonly data: unknown;\n    /** The app's pub/sub registry - the adapter wires `ws.subscribe` + close-cleanup to it. */\n    readonly pubsub: TopicRegistry;\n    /** The installed runtime's {@link attachWebSocket}, carried on the outcome so an adapter can wire\n     * a standard socket without a static import of the WS implementation (which would defeat the\n     * `.use(websocket())` tree-shaking). `@nifrajs/workers` may import `attachWebSocket` directly instead. */\n    readonly attach: WsAttach;\n};",
+    "signature": "export type WebSocketUpgradeOutcome = {\n    readonly kind: \"pass\";\n} | {\n    readonly kind: \"reject\";\n    readonly response: Response;\n} | {\n    readonly kind: \"upgrade\";\n    readonly handler: WebSocketHandler;\n    readonly data: unknown;\n    /** The app's pub/sub registry - the adapter wires `ws.subscribe` + close-cleanup to it. */\n    readonly pubsub: TopicRegistry;\n    /** The installed runtime's {@link attachWebSocket}, carried on the outcome so an adapter can wire\n     * a standard socket without a static import of the WS implementation (which would defeat the\n     * `.use(websocket())` tree-shaking). `@nifrajs/workers` may import `attachWebSocket` directly instead. */\n    readonly attach: WsAttach;\n    readonly maxPayloadBytes?: number;\n};",
     "doc": "/**\n * The outcome of `app.resolveWebSocketUpgrade(req)` - for serving adapters:\n * - `pass` - not a WS upgrade for a registered WS route; handle as a normal HTTP request.\n * - `reject` - a WS route matched but `upgrade()` rejected (or the path was malformed); return `response`.\n * - `upgrade` - perform the runtime upgrade, then dispatch the native socket's events to `handler`,\n *   seeding `ws.data` with `data`.\n */"
   },
   {
     "name": "WebSocketUpgradeOutcome",
     "kind": "type",
     "package": "nifra",
-    "signature": "export type WebSocketUpgradeOutcome = {\n    readonly kind: \"pass\";\n} | {\n    readonly kind: \"reject\";\n    readonly response: Response;\n} | {\n    readonly kind: \"upgrade\";\n    readonly handler: WebSocketHandler;\n    readonly data: unknown;\n    /** The app's pub/sub registry - the adapter wires `ws.subscribe` + close-cleanup to it. */\n    readonly pubsub: TopicRegistry;\n    /** The installed runtime's {@link attachWebSocket}, carried on the outcome so an adapter can wire\n     * a standard socket without a static import of the WS implementation (which would defeat the\n     * `.use(websocket())` tree-shaking). `@nifrajs/workers` may import `attachWebSocket` directly instead. */\n    readonly attach: WsAttach;\n};",
+    "signature": "export type WebSocketUpgradeOutcome = {\n    readonly kind: \"pass\";\n} | {\n    readonly kind: \"reject\";\n    readonly response: Response;\n} | {\n    readonly kind: \"upgrade\";\n    readonly handler: WebSocketHandler;\n    readonly data: unknown;\n    /** The app's pub/sub registry - the adapter wires `ws.subscribe` + close-cleanup to it. */\n    readonly pubsub: TopicRegistry;\n    /** The installed runtime's {@link attachWebSocket}, carried on the outcome so an adapter can wire\n     * a standard socket without a static import of the WS implementation (which would defeat the\n     * `.use(websocket())` tree-shaking). `@nifrajs/workers` may import `attachWebSocket` directly instead. */\n    readonly attach: WsAttach;\n    readonly maxPayloadBytes?: number;\n};",
     "doc": "/**\n * The outcome of `app.resolveWebSocketUpgrade(req)` - for serving adapters:\n * - `pass` - not a WS upgrade for a registered WS route; handle as a normal HTTP request.\n * - `reject` - a WS route matched but `upgrade()` rejected (or the path was malformed); return `response`.\n * - `upgrade` - perform the runtime upgrade, then dispatch the native socket's events to `handler`,\n *   seeding `ws.data` with `data`.\n */"
   },
   {
@@ -11962,6 +13477,43 @@
     "package": "@nifrajs/jobs",
     "signature": "export interface WorkerOptions {\n    /** Max jobs in flight at once. Default 1. */\n    readonly concurrency?: number;\n    /** How often to poll the store for due jobs (ms). Default 250. */\n    readonly pollIntervalMs?: number;\n    /** How long a leased job is hidden before it's considered abandoned and re-leased (ms). Default 30_000. */\n    readonly leaseMs?: number;\n}"
   },
+  {
+    "name": "WorkGraph",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface WorkGraph {\n    readonly version: 1;\n    readonly digest: string;\n    readonly nodes: readonly WorkGraphNode[];\n    readonly edges: readonly WorkGraphEdge[];\n    readonly freshness: BuildFreshness;\n}"
+  },
+  {
+    "name": "WorkGraphBuildInput",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface WorkGraphBuildInput {\n    readonly source: unknown;\n    readonly files?: readonly WorkGraphSourceFile[];\n    readonly freshness?: BuildFreshness;\n}"
+  },
+  {
+    "name": "WorkGraphEdge",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface WorkGraphEdge {\n    readonly from: string;\n    readonly to: string;\n    readonly relation: \"contains\" | \"declares\" | \"enforces\" | \"implements\" | \"tests\" | \"describes\";\n}"
+  },
+  {
+    "name": "WorkGraphNode",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface WorkGraphNode {\n    readonly id: string;\n    readonly kind: WorkGraphNodeKind;\n    readonly label: string;\n    readonly digest: string;\n    readonly files: readonly string[];\n}"
+  },
+  {
+    "name": "WorkGraphNodeKind",
+    "kind": "type",
+    "package": "@nifrajs/cli",
+    "signature": "export type WorkGraphNodeKind = \"route\" | \"schema\" | \"capability\" | \"assurance\" | \"test\" | \"file\" | \"manifest\";",
+    "doc": "/**\n * Static verification work graph for agents.\n *\n * The graph is intentionally a compact, token-only description of project structure. It connects\n * reflected routes to schemas, capabilities, assurance evidence, source/test files, and static\n * manifests. It never probes a running application and never persists payloads.\n */"
+  },
+  {
+    "name": "WorkGraphSourceFile",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface WorkGraphSourceFile {\n    readonly path: string;\n    readonly content: string;\n    readonly kind?: \"source\" | \"test\" | \"manifest\";\n}"
+  },
   {
     "name": "WrapOptions",
     "kind": "type",