@nifrajs/cli 3.3.0 → 3.5.0

package/docs/types.json

@@ -100,7 +100,7 @@
     "name": "AdapterCertificationReport",
     "kind": "interface",
     "package": "@nifrajs/testing",
-    "signature": "export interface AdapterCertificationReport {\n    readonly schemaVersion: 1;\n    readonly ok: boolean;\n    readonly profile: {\n        readonly id: string;\n        readonly version: number;\n    };\n    readonly adapterId: string;\n    readonly checks: readonly CertificationCheckEvidence[];\n    readonly capabilities: readonly CertificationCapabilityEvidence[];\n    readonly evidenceHash: string;\n}"
+    "signature": "export interface AdapterCertificationReport {\n    readonly schemaVersion: 1;\n    readonly ok: boolean;\n    readonly profile: {\n        readonly id: string;\n        readonly version: number;\n    };\n    readonly adapterId: string;\n    readonly target?: CertificationTarget;\n    readonly checks: readonly CertificationCheckEvidence[];\n    readonly capabilities: readonly CertificationCapabilityEvidence[];\n    readonly evidenceHash: string;\n}"
   },
   {
     "name": "Admission",
@@ -217,7 +217,7 @@
     "name": "AGENT_APP_FEATURES",
     "kind": "const",
     "package": "@nifrajs/agent-app",
-    "signature": "export declare const AGENT_APP_FEATURES: readonly [\"approvals\", \"checkpoint\", \"fork\", \"handoff\", \"inbox\", \"reload\", \"resume\", \"workflows\"];",
+    "signature": "export declare const AGENT_APP_FEATURES: readonly [\"approvals\", \"checkpoint\", \"fork\", \"handoff\", \"inbox\", \"reload\", \"resume\", \"run-studio\", \"workflows\"];",
     "doc": "/** Interaction features the client knows how to drive. A host grants the subset it supports. */"
   },
   {
@@ -318,12 +318,25 @@
     "package": "@nifrajs/coding-agent",
     "signature": "export type AgentCapability = \"filesystem.read\" | \"filesystem.write\" | \"process.exec\" | \"network.request\" | \"credentials.read\";"
   },
+  {
+    "name": "AgentCapability",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface AgentCapability<Input, Output, State = unknown> {\n    readonly tool: ToolContract<Input, Output>;\n    readonly surface: AgentSurfaceDescriptor;\n    readonly predict?: AgentSurfacePredictor<Input, State>;\n    readonly reconcile?: AgentSurfaceReconciler<Input, Output, State>;\n}"
+  },
   {
     "name": "AgentCapabilityManifest",
     "kind": "interface",
     "package": "@nifrajs/coding-agent",
     "signature": "export interface AgentCapabilityManifest {\n    readonly version: typeof AGENT_CAPABILITY_MANIFEST_VERSION;\n    readonly requested: readonly AgentCapability[];\n    readonly trusted: readonly AgentCapability[];\n    readonly reason?: string;\n}"
   },
+  {
+    "name": "AgentCapabilityReference",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "signature": "export type AgentCapabilityReference = {\n    readonly tool: Omit<ToolContract, \"input\" | \"output\" | \"execute\" | \"idempotency\" | \"cost\" | \"policy\"> & {\n        readonly input: StandardSchemaV1;\n        readonly output: StandardSchemaV1;\n        readonly execute: (...args: never[]) => unknown | PromiseLike<unknown>;\n        readonly idempotency?: unknown;\n        readonly cost?: unknown;\n        readonly policy?: unknown;\n    };\n    readonly surface: AgentSurfaceDescriptor;\n};",
+    "doc": "/**\n * The erased, read-only handle accepted by capability registries.\n *\n * A real application commonly registers tools with unrelated input and output types. Registry\n * boundaries therefore use this structural view instead of pretending the whole array has one\n * homogeneous generic type. Individual calls remain validated and typed at their capability's\n * `tool` boundary.\n */"
+  },
   {
     "name": "agentCard",
     "kind": "function",
@@ -746,6 +759,78 @@
     "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": "AgentSurfaceAuthoritativeState",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface AgentSurfaceAuthoritativeState<State> {\n    readonly state: State;\n    readonly version: string;\n}"
+  },
+  {
+    "name": "AgentSurfaceConformanceCase",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface AgentSurfaceConformanceCase {\n    readonly capability: AgentCapabilityReference;\n    readonly input: unknown;\n    readonly assert?: (result: unknown) => void | PromiseLike<void>;\n}"
+  },
+  {
+    "name": "AgentSurfaceConformanceOptions",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface AgentSurfaceConformanceOptions {\n    readonly target?: WebMcpTarget;\n    readonly registration?: WebMcpExecutionOptions;\n    readonly cases?: readonly AgentSurfaceConformanceCase[];\n}"
+  },
+  {
+    "name": "AgentSurfaceConformanceResult",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface AgentSurfaceConformanceResult {\n    readonly supported: boolean;\n    readonly registered: readonly string[];\n    readonly failed: readonly WebMcpRegistrationFailure[];\n    readonly checks: readonly string[];\n}"
+  },
+  {
+    "name": "AgentSurfaceDescriptor",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface AgentSurfaceDescriptor {\n    readonly scope: AgentSurfaceScope;\n    readonly reads: readonly string[];\n    readonly writes: readonly string[];\n    readonly reconciliation: ReconciliationMode;\n}"
+  },
+  {
+    "name": "AgentSurfacePrediction",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface AgentSurfacePrediction {\n    readonly baseVersion: string;\n    readonly patch: readonly PredictionPatchOperation[];\n    readonly expiresAt?: number;\n}"
+  },
+  {
+    "name": "AgentSurfacePredictionContext",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface AgentSurfacePredictionContext<State, Input> {\n    readonly input: Input;\n    readonly snapshot: State;\n    readonly version: string;\n    readonly now: number;\n}"
+  },
+  {
+    "name": "AgentSurfacePredictor",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "signature": "export type AgentSurfacePredictor<Input, State> = (context: AgentSurfacePredictionContext<State, Input>) => AgentSurfacePrediction | PromiseLike<AgentSurfacePrediction>;"
+  },
+  {
+    "name": "AgentSurfaceReconcileContext",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface AgentSurfaceReconcileContext<Input, Output, State> {\n    readonly input: Input;\n    readonly output: Output;\n    readonly previous: AgentSurfaceSnapshot<State>;\n    readonly prediction: AgentSurfacePrediction;\n    readonly now: number;\n}"
+  },
+  {
+    "name": "AgentSurfaceReconciler",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "signature": "export type AgentSurfaceReconciler<Input, Output, State> = (context: AgentSurfaceReconcileContext<Input, Output, State>) => AgentSurfaceAuthoritativeState<State> | PromiseLike<AgentSurfaceAuthoritativeState<State>>;"
+  },
+  {
+    "name": "AgentSurfaceScope",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "signature": "export type AgentSurfaceScope = \"page\" | \"session\" | \"server\";"
+  },
+  {
+    "name": "AgentSurfaceSnapshot",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface AgentSurfaceSnapshot<State> {\n    readonly state: State;\n    readonly version: string;\n}"
+  },
   {
     "name": "agentTelemetry",
     "kind": "function",
@@ -1145,6 +1230,13 @@
     "package": "@nifrajs/core",
     "signature": "export declare class ApprovalTokenReplayError extends Error {\n    constructor();\n}"
   },
+  {
+    "name": "approximateContextTokens",
+    "kind": "function",
+    "package": "@nifrajs/agent",
+    "signature": "export declare function approximateContextTokens(text: string): number;",
+    "doc": "/** A deterministic, provider-free token estimate suitable for local reference behavior. */"
+  },
   {
     "name": "AroundCapabilityOptions",
     "kind": "interface",
@@ -1193,6 +1285,13 @@
     "signature": "export interface ArtifactRef {\n    /** Caller-namespaced id. Opaque to nifra. */\n    readonly id: string;\n    /** SHA-256 hex of the payload, for integrity and correlation. Content-free. */\n    readonly digest: string;\n    readonly bytes: number;\n    readonly mediaType: string;\n    /** Optional caller-opaque locator (e.g. a private URI). nifra never dereferences it. */\n    readonly locator?: string;\n}",
     "doc": "/** A content-free pointer to a payload the caller chose to retain out of band. */"
   },
+  {
+    "name": "assembleContext",
+    "kind": "function",
+    "package": "@nifrajs/agent",
+    "signature": "export declare function assembleContext(items: readonly ContextItem[], options: ContextAssemblyOptions): ContextAssembly;",
+    "doc": "/** Assemble already-collected items under a hard budget without mutating caller data. */"
+  },
   {
     "name": "assertAdapterCertification",
     "kind": "function",
@@ -1239,6 +1338,13 @@
     "signature": "export declare function assertBudgetRemaining(budget: RequestBudget, requiredMs?: number): void;",
     "doc": "/** Fail before starting work that cannot fit inside the remaining time. */"
   },
+  {
+    "name": "assertCssLoadingCompatible",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function assertCssLoadingCompatible(cssCodeSplit: boolean, cssLoading: CssLoadingMode): void;",
+    "doc": "/**\n * Guard the only Vite combination that would claim to solve the stylesheet-insertion regression while\n * leaving the cause in place. A deferred split build can still attach CSS when a prefetched lazy chunk\n * evaluates, so it must fail closed instead of producing a misleadingly healthy deployment.\n */"
+  },
   {
     "name": "assertDeploymentAuthorityMonotonic",
     "kind": "function",
@@ -1267,6 +1373,13 @@
     "signature": "export declare function assertIncidentReplays(app: AppLike, capsule: IncidentCapsule, options?: ReplayIncidentOptions): Promise<void>;",
     "doc": "/** Assert a captured incident still reproduces against the current app. Throws {@link IncidentReplayError}. */"
   },
+  {
+    "name": "assertPredictionLab",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function assertPredictionLab(options?: PredictionLabOptions): Promise<PredictionLabReport>;",
+    "doc": "/** Run the lab and throw a joined error on failure - the `assertAdversarialContract` shape. */"
+  },
   {
     "name": "assertRenderAdapterConformance",
     "kind": "function",
@@ -1301,6 +1414,12 @@
     "package": "@nifrajs/testing",
     "signature": "export declare function assertTrajectoryInvariants(result: AgentRunResult<unknown>, options?: TrajectoryInvariantOptions): void;"
   },
+  {
+    "name": "assertTransportByteLimit",
+    "kind": "function",
+    "package": "@nifrajs/agent-protocol",
+    "signature": "export declare function assertTransportByteLimit(value: number, options?: TransportByteLimitOptions): void;"
+  },
   {
     "name": "assertTransportTextBounded",
     "kind": "function",
@@ -2099,6 +2218,12 @@
     "package": "@nifrajs/coding-agent",
     "signature": "export interface BoundedText {\n    readonly text: string;\n    readonly truncated: boolean;\n}"
   },
+  {
+    "name": "BoundedTransportRead",
+    "kind": "type",
+    "package": "@nifrajs/agent-protocol",
+    "signature": "export type BoundedTransportRead = {\n    readonly ok: true;\n    readonly bytes: Uint8Array;\n} | {\n    readonly ok: false;\n    readonly reason: \"too-large\" | \"read-error\";\n    readonly error?: unknown;\n};"
+  },
   {
     "name": "bridgeScript",
     "kind": "function",
@@ -2151,7 +2276,7 @@
     "name": "BuildClientViteOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface BuildClientViteOptions extends Omit<BuildClientOptions, \"plugins\"> {\n    /** Vite plugins for the app's client transforms (e.g. `react()`, `vue()`). */\n    readonly vitePlugins?: readonly unknown[];\n    /** Vite project root (default: the parent of `routesDir`). Manifest keys are relative to it. */\n    readonly root?: string;\n}",
+    "signature": "export interface BuildClientViteOptions extends Omit<BuildClientOptions, \"plugins\"> {\n    /** Vite plugins for the app's client transforms (e.g. `react()`, `vue()`). */\n    readonly vitePlugins?: readonly unknown[];\n    /** Vite project root (default: the parent of `routesDir`). Manifest keys are relative to it. */\n    readonly root?: string;\n    /**\n     * Vite's CSS output strategy (default `true`). Set to `false` to emit one aggregate stylesheet for\n     * the whole client, preventing lazy-route prefetch from attaching additional stylesheets.\n     */\n    readonly cssCodeSplit?: boolean;\n    /**\n     * Activation policy for framework-owned SSR stylesheet links (default `\"blocking\"`). `\"deferred\"`\n     * fetches with `media=\"print\"` and the generated client promotes the links before mounting. It must\n     * be paired with `cssCodeSplit: false`; split lazy chunks can otherwise attach CSS during prefetch.\n     */\n    readonly cssLoading?: CssLoadingMode;\n}",
     "doc": "/** Options for {@link buildClientVite} - the Bun {@link BuildClientOptions} minus Bun-plugin specifics,\n * plus the Vite plugin list the app injects for its transforms. */"
   },
   {
@@ -2205,7 +2330,7 @@
     "name": "BuildManifest",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface BuildManifest {\n    /** URL of the client entry module (content-hashed). */\n    readonly entry: string;\n    /** URLs of every emitted asset (entry + chunks) - for serving + preloading. */\n    readonly assets: readonly string[];\n    /** `routeId → [layout chunk URLs…, own chunk URL]` - the chunks a route needs, for `createWebApp`'s\n     * `routePreload` (`<link rel=\"modulepreload\">` the matched route alongside the entry). Each route +\n     * layout is also a build entrypoint, so it gets a named chunk the bootstrap's lazy import dedupes to. */\n    readonly routes: Readonly<Record<string, readonly string[]>>;\n    /** URL paths copied from `publicDir`, sorted. Lets the server entry serve them without scanning a\n     * directory per request, and lets an adapter that needs a file list (CDN upload, platform static\n     * assets) consume one. Omitted when there is no `public/`. */\n    readonly publicFiles?: readonly string[];\n    /** The app's bundled, content-hashed stylesheet(s) - the bootstrap's **aggregate** CSS (every\n     * `import './x.css'` reachable from the app). The complete stylesheet regardless of which file\n     * imported the CSS; the always-safe fallback `createWebApp` links when a route has no per-route entry\n     * in {@link routeStyles}. Omitted when the app imports no CSS. */\n    readonly css?: readonly string[];\n    /** `routeId → [chain CSS URLs]` - only the stylesheets the matched route's layout chain + own file\n     * actually use (Bun emits a per-entrypoint CSS bundle per route/layout, with shared-component CSS\n     * inlined into each consumer). `createWebApp` links these instead of the aggregate, so a page ships\n     * only its own CSS. A route is omitted (→ aggregate fallback) when its `[name]` collides with another\n     * route's basename (ambiguous CSS↔route) or the build emitted orphan shared-chunk CSS - correctness\n     * over minimality. Absent entirely when the app imports no CSS. */\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>>;\n}"
+    "signature": "export interface BuildManifest {\n    /** URL of the client entry module (content-hashed). */\n    readonly entry: string;\n    /** URLs of every emitted asset (entry + chunks) - for serving + preloading. */\n    readonly assets: readonly string[];\n    /** `routeId → [layout chunk URLs…, own chunk URL]` - the chunks a route needs, for `createWebApp`'s\n     * `routePreload` (`<link rel=\"modulepreload\">` the matched route alongside the entry). Each route +\n     * layout is also a build entrypoint, so it gets a named chunk the bootstrap's lazy import dedupes to. */\n    readonly routes: Readonly<Record<string, readonly string[]>>;\n    /** URL paths copied from `publicDir`, sorted. Lets the server entry serve them without scanning a\n     * directory per request, and lets an adapter that needs a file list (CDN upload, platform static\n     * assets) consume one. Omitted when there is no `public/`. */\n    readonly publicFiles?: readonly string[];\n    /** The app's bundled, content-hashed stylesheet(s) - the bootstrap's **aggregate** CSS (every\n     * `import './x.css'` reachable from the app). The complete stylesheet regardless of which file\n     * imported the CSS; the always-safe fallback `createWebApp` links when a route has no per-route entry\n     * in {@link routeStyles}. Omitted when the app imports no CSS. */\n    readonly css?: readonly string[];\n    /** Whether the Vite client build kept CSS split by entry/chunk. Absent for the native Bun build. */\n    readonly cssCodeSplit?: boolean;\n    /** How framework-owned SSR stylesheet links should become active. Defaults to `blocking`. */\n    readonly cssLoading?: CssLoadingMode;\n    /** `routeId → [chain CSS URLs]` - only the stylesheets the matched route's layout chain + own file\n     * actually use (Bun emits a per-entrypoint CSS bundle per route/layout, with shared-component CSS\n     * inlined into each consumer). `createWebApp` links these instead of the aggregate, so a page ships\n     * only its own CSS. A route is omitted (→ aggregate fallback) when its `[name]` collides with another\n     * route's basename (ambiguous CSS↔route) or the build emitted orphan shared-chunk CSS - correctness\n     * over minimality. Absent entirely when the app imports no CSS. */\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>>;\n}"
   },
   {
     "name": "buildNifraManifest",
@@ -2251,7 +2376,7 @@
     "name": "BuildServerOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface BuildServerOptions {\n    /** The `routes/` directory to discover (absolute path). */\n    readonly routesDir: string;\n    /** The worker entry module (absolute path) - your `worker.ts`. It imports `{ manifest, clientEntry }`\n     * from the generated `./server-manifest`, builds `createWebApp`, and `export default toFetchHandler(app)`. */\n    readonly serverEntry: string;\n    /** Output directory for the bundled worker (absolute path). */\n    readonly outDir: string;\n    /** The content-hashed client entry URL (from `buildClient`'s manifest) - **baked** into the generated\n     * server manifest, since a disk-less worker can't read `manifest.json` at runtime. */\n    readonly clientEntry: string;\n    /** The app's aggregate stylesheet URLs (`buildClient`'s `BuildManifest.css`) - baked into the generated\n     * manifest so the server entry hands them to `createWebApp` (→ `<link rel=\"stylesheet\">`). Omit ⇒ no CSS\n     * link (the built SSR page would otherwise render unstyled). */\n    readonly styles?: readonly string[] | undefined;\n    /** Per-route stylesheet URLs (`buildClient`'s `BuildManifest.routeStyles`) - baked alongside `styles`. */\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>> | undefined;\n    /** Route/layout file → import specifier in the generated manifest (default: a relative path from the\n     * manifest's location - written next to `serverEntry` - to `routesDir`). */\n    readonly resolve?: (file: string) => string;\n    /** Filename for the generated server-manifest module, written next to `serverEntry` (default\n     * `\"server-manifest.ts\"`); your `serverEntry` imports it as `./server-manifest`. */\n    readonly manifestFile?: string;\n    /** Adapter build plugins (e.g. `solidBunPlugin(\"ssr\")` - Solid routes need their SSR transform at\n     * build time; React's JSX is Bun-native and needs none). */\n    readonly plugins?: readonly BunPlugin[];\n    /** `Bun.build` resolution conditions (default `[\"workerd\", \"edge-light\", \"browser\"]`) - selects each\n     * dependency's edge build. */\n    readonly conditions?: readonly string[];\n    /** Compile-time replacements (default `{ \"process.env.NODE_ENV\": '\"production\"' }` → production\n     * React/Solid on the edge). Pass an explicit object to override (e.g. `{}` to opt out). */\n    readonly define?: Readonly<Record<string, string>>;\n    /** Minify the output (default `true`). */\n    readonly minify?: boolean;\n    /** `Bun.build` target (default `\"browser\"` - the right shape for edge runtimes: Cloudflare Workers,\n     * Vercel Edge, Deno, Deno Deploy). Use `\"node\"` for a `@nifrajs/node` server (so `node:*` built-ins\n     * stay external), or `\"bun\"` for a Bun server. The default `conditions` + the edge resolve shims\n     * only apply to the `\"browser\"` target; `\"node\"`/`\"bun\"` resolve their own renderer builds via the\n     * matching condition. */\n    readonly target?: \"browser\" | \"node\" | \"bun\";\n    /** **Lazy/code-split routes** (default `false`): emit `() => import(route)` loaders + bundle with\n     * `splitting`, so each route is its own chunk loaded on first request (smaller cold-start parse)\n     * instead of all parsed at boot. The output becomes the worker entry **+ chunk files** in `outDir`\n     * - on Cloudflare, ship them with wrangler's `no_bundle` + `find_additional_modules` + an ESModule\n     * `rule` (Node/Deno import the chunks natively). Eager (one self-contained file) stays the default. */\n    readonly lazy?: boolean;\n}"
+    "signature": "export interface BuildServerOptions {\n    /** The `routes/` directory to discover (absolute path). */\n    readonly routesDir: string;\n    /** The worker entry module (absolute path) - your `worker.ts`. It imports `{ manifest, clientEntry }`\n     * from the generated `./server-manifest`, builds `createWebApp`, and `export default toFetchHandler(app)`. */\n    readonly serverEntry: string;\n    /** Output directory for the bundled worker (absolute path). */\n    readonly outDir: string;\n    /** The content-hashed client entry URL (from `buildClient`'s manifest) - **baked** into the generated\n     * server manifest, since a disk-less worker can't read `manifest.json` at runtime. */\n    readonly clientEntry: string;\n    /** The app's aggregate stylesheet URLs (`buildClient`'s `BuildManifest.css`) - baked into the generated\n     * manifest so the server entry hands them to `createWebApp` (→ `<link rel=\"stylesheet\">`). Omit ⇒ no CSS\n     * link (the built SSR page would otherwise render unstyled). */\n    readonly styles?: readonly string[] | undefined;\n    /** Per-route stylesheet URLs (`buildClient`'s `BuildManifest.routeStyles`) - baked alongside `styles`. */\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>> | undefined;\n    /** How framework-owned stylesheet links should activate before hydration (default `\"blocking\"`). */\n    readonly cssLoading?: CssLoadingMode;\n    /** Route/layout file → import specifier in the generated manifest (default: a relative path from the\n     * manifest's location - written next to `serverEntry` - to `routesDir`). */\n    readonly resolve?: (file: string) => string;\n    /** Filename for the generated server-manifest module, written next to `serverEntry` (default\n     * `\"server-manifest.ts\"`); your `serverEntry` imports it as `./server-manifest`. */\n    readonly manifestFile?: string;\n    /** Adapter build plugins (e.g. `solidBunPlugin(\"ssr\")` - Solid routes need their SSR transform at\n     * build time; React's JSX is Bun-native and needs none). */\n    readonly plugins?: readonly BunPlugin[];\n    /** `Bun.build` resolution conditions (default `[\"workerd\", \"edge-light\", \"browser\"]`) - selects each\n     * dependency's edge build. */\n    readonly conditions?: readonly string[];\n    /** Compile-time replacements (default `{ \"process.env.NODE_ENV\": '\"production\"' }` → production\n     * React/Solid on the edge). Pass an explicit object to override (e.g. `{}` to opt out). */\n    readonly define?: Readonly<Record<string, string>>;\n    /** Minify the output (default `true`). */\n    readonly minify?: boolean;\n    /** `Bun.build` target (default `\"browser\"` - the right shape for edge runtimes: Cloudflare Workers,\n     * Vercel Edge, Deno, Deno Deploy). Use `\"node\"` for a `@nifrajs/node` server (so `node:*` built-ins\n     * stay external), or `\"bun\"` for a Bun server. The default `conditions` + the edge resolve shims\n     * only apply to the `\"browser\"` target; `\"node\"`/`\"bun\"` resolve their own renderer builds via the\n     * matching condition. */\n    readonly target?: \"browser\" | \"node\" | \"bun\";\n    /** **Lazy/code-split routes** (default `false`): emit `() => import(route)` loaders + bundle with\n     * `splitting`, so each route is its own chunk loaded on first request (smaller cold-start parse)\n     * instead of all parsed at boot. The output becomes the worker entry **+ chunk files** in `outDir`\n     * - on Cloudflare, ship them with wrangler's `no_bundle` + `find_additional_modules` + an ESModule\n     * `rule` (Node/Deno import the chunks natively). Eager (one self-contained file) stays the default. */\n    readonly lazy?: boolean;\n}"
   },
   {
     "name": "buildServerVite",
@@ -2264,7 +2389,7 @@
     "name": "BuildServerViteOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface BuildServerViteOptions {\n    readonly routesDir: string;\n    readonly serverEntry: string;\n    readonly outDir: string;\n    readonly clientEntry: string;\n    readonly styles?: readonly string[] | undefined;\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>> | undefined;\n    readonly resolve?: (file: string) => string;\n    readonly manifestFile?: string;\n    readonly vitePlugins?: readonly unknown[];\n    readonly conditions?: readonly string[];\n    readonly define?: Readonly<Record<string, string>>;\n    readonly minify?: boolean;\n    /** The runtime the worker targets - mirrors `buildServer`. `browser` = the edge (workerd/edge-light). */\n    readonly target?: \"browser\" | \"node\" | \"bun\";\n    /** Vite project root (default: the parent of `routesDir`). */\n    readonly root?: string;\n}",
+    "signature": "export interface BuildServerViteOptions {\n    readonly routesDir: string;\n    readonly serverEntry: string;\n    readonly outDir: string;\n    readonly clientEntry: string;\n    readonly styles?: readonly string[] | undefined;\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>> | undefined;\n    /** How framework-owned stylesheet links should activate before hydration (default `\"blocking\"`). */\n    readonly cssLoading?: CssLoadingMode;\n    readonly resolve?: (file: string) => string;\n    readonly manifestFile?: string;\n    readonly vitePlugins?: readonly unknown[];\n    readonly conditions?: readonly string[];\n    readonly define?: Readonly<Record<string, string>>;\n    readonly minify?: boolean;\n    /** The runtime the worker targets - mirrors `buildServer`. `browser` = the edge (workerd/edge-light). */\n    readonly target?: \"browser\" | \"node\" | \"bun\";\n    /** Vite project root (default: the parent of `routesDir`). */\n    readonly root?: string;\n}",
     "doc": "/** Options for {@link buildServerVite} - the same surface as `buildServer` minus Bun-plugin specifics. */"
   },
   {
@@ -2284,7 +2409,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    /** 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}"
+    "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    /**\n     * Vite-only CSS output policy. `false` emits one aggregate stylesheet. The native Bun build does not\n     * support this switch and fails closed if it is supplied instead of silently ignoring it.\n     */\n    readonly cssCodeSplit?: boolean;\n    /**\n     * Activation policy for framework-owned SSR stylesheet links. Defaults to `\"blocking\"`; `\"deferred\"`\n     * fetches with `media=\"print\"` and promotes before hydration. With Vite, pair it with\n     * `cssCodeSplit: false`; the native Bun build supports the activation policy but keeps its existing\n     * CSS output strategy.\n     */\n    readonly cssLoading?: CssLoadingMode;\n    /** Document `<title>` for the generated server entry. */\n    readonly title?: string;\n}"
   },
   {
     "name": "BuildTargetPlan",
@@ -2330,7 +2455,7 @@
     "name": "Bundler",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface Bundler {\n    /** Build the client bundle → the shared {@link BuildManifest}. */\n    buildClient(input: {\n        readonly routesDir: string;\n        readonly outDir: string;\n        readonly clientModule: string;\n        readonly plugins?: readonly unknown[];\n        readonly conditions?: readonly string[];\n        readonly define?: Readonly<Record<string, string>>;\n        readonly publicDir?: string | false;\n        readonly publicEnvPrefix?: string;\n        /** Project root (Vite needs it; the Bun strategy ignores it). */\n        readonly root?: string;\n    }): Promise<BuildManifest>;\n    /** Build the server worker → the shared {@link ServerBuild}. */\n    buildServer(input: {\n        readonly routesDir: string;\n        readonly serverEntry: string;\n        readonly outDir: string;\n        readonly clientEntry: string;\n        readonly target: \"browser\" | \"node\" | \"bun\";\n        readonly plugins?: readonly unknown[];\n        readonly define?: Readonly<Record<string, string>>;\n        readonly root?: string;\n    }): Promise<ServerBuild>;\n}",
+    "signature": "export interface Bundler {\n    /** Build the client bundle → the shared {@link BuildManifest}. */\n    buildClient(input: {\n        readonly routesDir: string;\n        readonly outDir: string;\n        readonly clientModule: string;\n        readonly plugins?: readonly unknown[];\n        readonly conditions?: readonly string[];\n        readonly define?: Readonly<Record<string, string>>;\n        readonly publicDir?: string | false;\n        readonly publicEnvPrefix?: string;\n        /** Vite CSS splitting policy; the Bun strategy rejects `false` and otherwise preserves its native behavior. */\n        readonly cssCodeSplit?: boolean;\n        /** Framework-owned stylesheet activation policy; supported by both server strategies. */\n        readonly cssLoading?: CssLoadingMode;\n        /** Project root (Vite needs it; the Bun strategy ignores it). */\n        readonly root?: string;\n    }): Promise<BuildManifest>;\n    /** Build the server worker → the shared {@link ServerBuild}. */\n    buildServer(input: {\n        readonly routesDir: string;\n        readonly serverEntry: string;\n        readonly outDir: string;\n        readonly clientEntry: string;\n        readonly target: \"browser\" | \"node\" | \"bun\";\n        /** The client build's aggregate stylesheet URLs to bake into the server manifest. */\n        readonly styles?: readonly string[];\n        /** The client build's per-route stylesheet map to bake into the server manifest. */\n        readonly routeStyles?: Readonly<Record<string, readonly string[]>>;\n        readonly plugins?: readonly unknown[];\n        readonly define?: Readonly<Record<string, string>>;\n        /** CSS activation policy to bake into the generated server manifest. */\n        readonly cssLoading?: CssLoadingMode;\n        readonly root?: string;\n    }): Promise<ServerBuild>;\n}",
     "doc": "/**\n * A build-tool STRATEGY for {@link buildTargetWith} - the two bundling steps, and nothing else. Everything\n * around them (server-entry codegen, deploy assembly, prerender, size report) is bundler-agnostic and\n * lives in `buildTargetWith`, so a second bundler (Vite) is this interface, not a second orchestrator.\n *\n * Plugin lists are `readonly unknown[]` because a Bun plugin and a Vite plugin are different types; each\n * strategy casts to its own. `buildTargetWith` only forwards them.\n */"
   },
   {
@@ -2477,6 +2602,13 @@
     "signature": "export declare function canonicalizeIdempotencyBody(body: Uint8Array, contentType: string | null): Uint8Array;",
     "doc": "/** Canonicalize JSON bodies so whitespace/property-order retries bind to the same semantic request. */"
   },
+  {
+    "name": "canonicalizeReviewReport",
+    "kind": "function",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare function canonicalizeReviewReport(report: ReviewReport): string;",
+    "doc": "/**\n * Return the stable UTF-8 text that identifies a review report's structural result.\n *\n * The report digest and check duration are omitted. Arrays are copied into their contract-defined\n * order, while object keys are sorted recursively. No caller-owned object is mutated.\n */"
+  },
   {
     "name": "canonicalJson",
     "kind": "function",
@@ -3053,13 +3185,13 @@
     "name": "CertificationCheck",
     "kind": "interface",
     "package": "@nifrajs/testing",
-    "signature": "export interface CertificationCheck<Adapter> {\n    readonly id: string;\n    readonly capability: string;\n    readonly run: (adapter: Adapter, context: CertificationContext) => void | Promise<void>;\n}"
+    "signature": "export interface CertificationCheck<Adapter> {\n    readonly id: string;\n    readonly capability: string;\n    readonly target?: CertificationTarget;\n    readonly run: (adapter: Adapter, context: CertificationContext) => void | Promise<void>;\n}"
   },
   {
     "name": "CertificationCheckEvidence",
     "kind": "interface",
     "package": "@nifrajs/testing",
-    "signature": "export interface CertificationCheckEvidence {\n    readonly id: string;\n    readonly capability: string;\n    readonly ok: boolean;\n    /** Error class only. Messages may contain credentials/provider payloads and are never evidence. */\n    readonly errorName?: string;\n}"
+    "signature": "export interface CertificationCheckEvidence {\n    readonly id: string;\n    readonly capability: string;\n    readonly ok: boolean;\n    readonly target?: CertificationTarget;\n    /** Error class only. Messages may contain credentials/provider payloads and are never evidence. */\n    readonly errorName?: string;\n}"
   },
   {
     "name": "CertificationContext",
@@ -3068,11 +3200,18 @@
     "signature": "export interface CertificationContext {\n    /** Deterministic per-check key safe for shared test backends and stable re-runs. */\n    readonly key: (suffix: string) => string;\n}",
     "doc": "/**\n * Profile-based adapter certification. Profiles are structural and dependency-free: an adapter package\n * uses this only in its test/CI surface, while the resulting capability matrix is portable JSON evidence.\n */"
   },
+  {
+    "name": "CertificationTarget",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface CertificationTarget {\n    /** Published adapter/package name, for example `@nifrajs/node`. */\n    readonly adapter?: string;\n    /** Runtime that executed the witness, for example `node`, `deno`, or `workerd`. */\n    readonly runtime?: string;\n    /** Checked-in or built artifact path, when the witness exercises one. */\n    readonly artifact?: string;\n    /** Source path that owns the behavior, when it differs from the artifact. */\n    readonly source?: string;\n    /** Stable category of witness, useful when one report mixes several targets. */\n    readonly witnessKind?: string;\n}",
+    "doc": "/** Portable identity for the artifact, runtime, and witness that produced one check result. */"
+  },
   {
     "name": "certifyAdapter",
     "kind": "function",
     "package": "@nifrajs/testing",
-    "signature": "export declare function certifyAdapter<Adapter>(options: {\n    readonly profile: AdapterCertificationProfile<Adapter>;\n    readonly adapterId: string;\n    /** A fresh adapter per check prevents one failed check from contaminating the next. */\n    readonly createAdapter: () => Adapter | Promise<Adapter>;\n    readonly cleanup?: (adapter: Adapter) => void | Promise<void>;\n}): Promise<AdapterCertificationReport>;"
+    "signature": "export declare function certifyAdapter<Adapter>(options: {\n    readonly profile: AdapterCertificationProfile<Adapter>;\n    readonly adapterId: string;\n    /** Optional identity shared by all checks; a check target can add or override its fields. */\n    readonly target?: CertificationTarget;\n    /** A fresh adapter per check prevents one failed check from contaminating the next. */\n    readonly createAdapter: () => Adapter | Promise<Adapter>;\n    readonly cleanup?: (adapter: Adapter) => void | Promise<void>;\n}): Promise<AdapterCertificationReport>;"
   },
   {
     "name": "ChannelCloseReason",
@@ -3221,7 +3360,7 @@
     "name": "ClientAction",
     "kind": "type",
     "package": "@nifrajs/web",
-    "signature": "export type ClientAction = (args: ClientActionArgs) => ClientActionResult | void | Promise<ClientActionResult | void>;",
+    "signature": "export type ClientAction = (args: ClientActionArgs) => ClientActionResult | undefined | Promise<ClientActionResult | undefined>;",
     "doc": "/** A client-only action wrapper; it never replaces the server action. */"
   },
   {
@@ -3375,7 +3514,7 @@
     "name": "CodingAgentRpcServer",
     "kind": "class",
     "package": "@nifrajs/coding-agent",
-    "signature": "export declare class CodingAgentRpcServer {\n    readonly host: CodingAgentHost;\n    private readonly options;\n    private readonly token;\n    private readonly maxBodyBytes;\n    private listener;\n    constructor(options: CodingAgentRpcServerOptions);\n    start(): Promise<CodingAgentRpcServerHandle>;\n    stop(): Promise<void>;\n    private fetch;\n    private dispatch;\n    private requireSnapshot;\n    private protocolError;\n    private readRequest;\n}",
+    "signature": "export declare class CodingAgentRpcServer {\n    readonly host: CodingAgentHost;\n    private readonly options;\n    private readonly token;\n    private readonly maxBodyBytes;\n    private readonly maxResponseBytes;\n    private listener;\n    private authFailures;\n    private authLastFailureAt;\n    private authBackoffUntil;\n    constructor(options: CodingAgentRpcServerOptions);\n    start(): Promise<CodingAgentRpcServerHandle>;\n    stop(): Promise<void>;\n    private fetch;\n    private dispatch;\n    private requireSnapshot;\n    private authBackoffMs;\n    private noteAuthFailure;\n    private noteAuthSuccess;\n    private response;\n    private protocolError;\n    private readRequest;\n}",
     "doc": "/**\n * Minimal loopback RPC surface for the CLI, Workbench, CI clients, and a future mobile companion.\n * Turn output is SSE so clients do not need a WebSocket dependency; every event is still a versioned\n * protocol event from the backend.\n */"
   },
   {
@@ -3388,7 +3527,7 @@
     "name": "CodingAgentRpcServerOptions",
     "kind": "interface",
     "package": "@nifrajs/coding-agent",
-    "signature": "export interface CodingAgentRpcServerOptions {\n    readonly backend: AgentBackend;\n    readonly cwd: string;\n    readonly hostname?: string;\n    /** Remote binding is opt-in; the default only permits loopback hosts. */\n    readonly allowRemote?: boolean;\n    readonly port?: number;\n    /** A random token is generated when omitted. Use an explicit token only for managed local launchers. */\n    readonly authToken?: string;\n    /** Include bounded exception stacks in RPC failures only for trusted loopback debugging. */\n    readonly exposeErrorStacks?: boolean;\n    readonly maxBodyBytes?: number;\n    readonly sessionStore?: SessionStore;\n    readonly contextWindow?: ContextWindowOptions;\n    readonly extensions?: ExtensionHost;\n    readonly ui?: UiExtensionHost;\n    readonly verifyAfterTurn?: readonly (\"check\" | \"assure\" | \"test\")[];\n    readonly maxRepairAttempts?: number;\n    readonly verification?: CodingAgentHostOptions[\"verification\"];\n}"
+    "signature": "export interface CodingAgentRpcServerOptions {\n    readonly backend: AgentBackend;\n    readonly cwd: string;\n    readonly hostname?: string;\n    /** Remote binding is opt-in; the default only permits loopback hosts. */\n    readonly allowRemote?: boolean;\n    readonly port?: number;\n    /** A random token is generated when omitted. Use an explicit token only for managed local launchers. */\n    readonly authToken?: string;\n    /** Include bounded exception stacks in RPC failures only for trusted loopback debugging. */\n    readonly exposeErrorStacks?: boolean;\n    readonly maxBodyBytes?: number;\n    /** Maximum UTF-8 bytes in one non-streaming JSON response. Defaults to 4 MiB. */\n    readonly maxResponseBytes?: number;\n    readonly sessionStore?: SessionStore;\n    readonly contextWindow?: ContextWindowOptions;\n    readonly extensions?: ExtensionHost;\n    readonly ui?: UiExtensionHost;\n    readonly verifyAfterTurn?: readonly (\"check\" | \"assure\" | \"test\")[];\n    readonly maxRepairAttempts?: number;\n    readonly verification?: CodingAgentHostOptions[\"verification\"];\n}"
   },
   {
     "name": "collectAssuranceReport",
@@ -3402,6 +3541,13 @@
     "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": "collectContext",
+    "kind": "function",
+    "package": "@nifrajs/agent",
+    "signature": "export declare function collectContext<Input>(input: Input, sources: readonly ContextSource<Input>[], options: ContextAssemblyOptions): Promise<ContextAssembly>;",
+    "doc": "/** Collect source-owned items in source order, then apply the same deterministic assembly rules. */"
+  },
   {
     "name": "Collection",
     "kind": "interface",
@@ -3599,6 +3745,13 @@
     "signature": "export declare function composeRegistrySnapshot(descriptors: readonly CapabilityDescriptor[]): Promise<RegistrySnapshot>;",
     "doc": "/**\n * Compose a deterministic registry snapshot. Descriptors are validated, checked for identity\n * collisions, canonically ordered, and digested. Two descriptors that share a (kind, name) identity\n * fail `descriptor_collision` when their schema digests agree and `schema_drift` when they differ -\n * a drifted schema is a distinct, addressable failure from a duplicate registration. Because the set\n * is sorted before it is digested, the snapshot digest is independent of the input order.\n */"
   },
+  {
+    "name": "composeReviewReport",
+    "kind": "function",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare function composeReviewReport(input: ReviewReportDraft): Promise<ReviewReport>;",
+    "doc": "/**\n * Compose a report from already-sanitized structural values. This function has no repository,\n * collector, CLI, filesystem, provider, or persistence access. The parser is run once more over\n * the assembled value so the returned report has the same boundary guarantees as external input.\n */"
+  },
   {
     "name": "compression",
     "kind": "function",
@@ -3692,7 +3845,7 @@
     "name": "Content",
     "kind": "const",
     "package": "@nifrajs/web-vue",
-    "signature": "export declare const Content: import(\"vue\").DefineComponent<import(\"vue\").ExtractPropTypes<{\n    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n    html: {\n        type: StringConstructor;\n        required: true;\n    };\n    /** Wrapper element (default `\"div\"`). */\n    as: {\n        type: StringConstructor;\n        default: string;\n    };\n}>, () => import(\"vue\").VNode<import(\"vue\").RendererNode, import(\"vue\").RendererElement, {\n    [key: string]: any;\n}>, {}, {}, {}, import(\"vue\").ComponentOptionsMixin, import(\"vue\").ComponentOptionsMixin, {}, string, import(\"vue\").PublicProps, Readonly<import(\"vue\").ExtractPropTypes<{\n    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n    html: {\n        type: StringConstructor;\n        required: true;\n    };\n    /** Wrapper element (default `\"div\"`). */\n    as: {\n        type: StringConstructor;\n        default: string;\n    };\n}>> & Readonly<{}>, {\n    as: string;\n}, {}, {}, {}, string, import(\"vue\").ComponentProvideOptions, true, {}, any>;",
+    "signature": "export declare const Content: import(\"vue\").DefineComponent<import(\"vue\").ExtractPropTypes<{\n    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n    html: {\n        type: () => TrustedHtml;\n        required: true;\n    };\n    /** Wrapper element (default `\"div\"`). */\n    as: {\n        type: StringConstructor;\n        default: string;\n    };\n}>, () => import(\"vue\").VNode<import(\"vue\").RendererNode, import(\"vue\").RendererElement, {\n    [key: string]: any;\n}>, {}, {}, {}, import(\"vue\").ComponentOptionsMixin, import(\"vue\").ComponentOptionsMixin, {}, string, import(\"vue\").PublicProps, Readonly<import(\"vue\").ExtractPropTypes<{\n    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n    html: {\n        type: () => TrustedHtml;\n        required: true;\n    };\n    /** Wrapper element (default `\"div\"`). */\n    as: {\n        type: StringConstructor;\n        default: string;\n    };\n}>> & Readonly<{}>, {\n    as: string;\n}, {}, {}, {}, string, import(\"vue\").ComponentProvideOptions, true, {}, any>;",
     "doc": "/** Render trusted HTML into a wrapper element. `inheritAttrs: false` + manual attr spread so passthrough\n * (`class`, `id`, `style`, …) lands on the wrapper exactly once. */"
   },
   {
@@ -3718,25 +3871,25 @@
     "name": "ContentProps",
     "kind": "interface",
     "package": "@nifrajs/web-preact",
-    "signature": "export interface ContentProps extends Omit<JSX.HTMLAttributes<HTMLElement>, \"dangerouslySetInnerHTML\"> {\n    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n    readonly html: string;\n    /** Wrapper element (default `\"div\"`). */\n    readonly as?: string;\n}"
+    "signature": "export interface ContentProps extends Omit<JSX.HTMLAttributes<HTMLElement>, \"dangerouslySetInnerHTML\"> {\n    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n    readonly html: TrustedHtml;\n    /** Wrapper element (default `\"div\"`). */\n    readonly as?: string;\n}"
   },
   {
     "name": "ContentProps",
     "kind": "interface",
     "package": "@nifrajs/web-react",
-    "signature": "export interface ContentProps extends Omit<ComponentPropsWithoutRef<\"div\">, \"dangerouslySetInnerHTML\" | \"children\"> {\n    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n    readonly html: string;\n    /** Wrapper element (default `\"div\"`). */\n    readonly as?: ElementType;\n}"
+    "signature": "export interface ContentProps extends Omit<ComponentPropsWithoutRef<\"div\">, \"dangerouslySetInnerHTML\" | \"children\"> {\n    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n    readonly html: TrustedHtml;\n    /** Wrapper element (default `\"div\"`). */\n    readonly as?: ElementType;\n}"
   },
   {
     "name": "ContentProps",
     "kind": "interface",
     "package": "@nifrajs/web-solid",
-    "signature": "export interface ContentProps {\n    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n    readonly html: string;\n    /** Wrapper element (default `\"div\"`). */\n    readonly as?: string;\n    /** DOM passthrough (`class`, `style`, `id`, `data-*`, handlers). */\n    readonly [key: string]: unknown;\n}"
+    "signature": "export interface ContentProps {\n    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n    readonly html: TrustedHtml;\n    /** Wrapper element (default `\"div\"`). */\n    readonly as?: string;\n    /** DOM passthrough (`class`, `style`, `id`, `data-*`, handlers). */\n    readonly [key: string]: unknown;\n}"
   },
   {
     "name": "ContentProps",
     "kind": "interface",
     "package": "@nifrajs/web-svelte",
-    "signature": "export interface ContentProps {\n  /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n  html: string\n  /** Wrapper element (default `\"div\"`). */\n  as?: string\n  /** DOM passthrough (`class`, `style`, `id`, `data-*`, …). */\n  [key: string]: unknown\n}",
+    "signature": "export interface ContentProps {\n  /** Trusted, pre-rendered HTML (e.g. `entry.html`). */\n  html: TrustedHtml\n  /** Wrapper element (default `\"div\"`). */\n  as?: string\n  /** DOM passthrough (`class`, `style`, `id`, `data-*`, …). */\n  [key: string]: unknown\n}",
     "doc": "/**\n * Hand-written types for `Content.svelte` (svelte-package would generate this). Consumers resolve this\n * through the `./content` export's `types` condition.\n */"
   },
   {
@@ -3753,6 +3906,30 @@
     "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": "ContextAssembly",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface ContextAssembly {\n    readonly version: 1;\n    readonly text: string;\n    readonly items: readonly ContextItem[];\n    readonly includedIds: readonly string[];\n    readonly omittedIds: readonly string[];\n    readonly tokens: number;\n    readonly budget: {\n        readonly maxTokens: number;\n        readonly reserveTokens: number;\n        readonly availableTokens: number;\n    };\n}"
+  },
+  {
+    "name": "ContextAssemblyOptions",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface ContextAssemblyOptions {\n    readonly budget: ContextBudget;\n    /** Defaults to a bounded deterministic chars/4 estimate. */\n    readonly tokenCounter?: ContextTokenCounter;\n    /** Separator inserted between selected item contents. Defaults to two newlines. */\n    readonly separator?: string;\n}"
+  },
+  {
+    "name": "ContextBudget",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface ContextBudget {\n    /** Absolute budget for the assembled context, including separators. */\n    readonly maxTokens: number;\n    /** Tokens reserved for caller-owned content outside this assembly. */\n    readonly reserveTokens?: number;\n}"
+  },
+  {
+    "name": "ContextBudgetError",
+    "kind": "class",
+    "package": "@nifrajs/agent",
+    "signature": "export declare class ContextBudgetError extends Error {\n    readonly requiredTokens: number;\n    readonly availableTokens: number;\n    readonly code: \"context_budget_exceeded\";\n    constructor(requiredTokens: number, availableTokens: number);\n}"
+  },
   {
     "name": "ContextForOp",
     "kind": "type",
@@ -3760,6 +3937,13 @@
     "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": "ContextItem",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface ContextItem {\n    /** Stable caller-owned identity used in inclusion/omission reports. */\n    readonly id: string;\n    /** Caller-defined category such as `memory`, `retrieval`, `conversation`, or `tools`. */\n    readonly kind: string;\n    /** Transient text inserted into the assembled context. */\n    readonly content: string;\n    /** Required items are admitted before optional items and fail closed when they do not fit. */\n    readonly required?: boolean;\n    /** Higher-priority optional items are admitted first. */\n    readonly priority?: number;\n    /** Optional tie-breaker for recency-aware sources. */\n    readonly recency?: number;\n    /** Stable source label; it is metadata, not an authorization decision. */\n    readonly source?: string;\n}",
+    "doc": "/**\n * Provider-neutral context assembly.\n *\n * The assembler owns deterministic selection and token accounting only. Items are transient\n * caller data: this module does not persist, embed, redact, or log their contents. Durable memory,\n * retrieval indexes, and provider-specific tokenizers belong behind caller-owned adapters.\n */"
+  },
   {
     "name": "ContextPlugin",
     "kind": "type",
@@ -3780,6 +3964,12 @@
     "package": "@nifrajs/coding-agent",
     "signature": "export interface ContextRecord {\n    readonly kind: string;\n    readonly content: string;\n    readonly pinned?: boolean;\n}"
   },
+  {
+    "name": "ContextSource",
+    "kind": "interface",
+    "package": "@nifrajs/agent",
+    "signature": "export interface ContextSource<Input = unknown> {\n    /** Stable source identity used for diagnostics and default item attribution. */\n    readonly id: string;\n    load(input: Input): readonly ContextItem[] | PromiseLike<readonly ContextItem[]>;\n}"
+  },
   {
     "name": "contextStorage",
     "kind": "function",
@@ -3787,6 +3977,12 @@
     "signature": "export declare function contextStorage(): Middleware;",
     "doc": "/**\n * Store the current nifra `Context` in `AsyncLocalStorage` for helpers that run away from the handler\n * argument, e.g. repository/logger functions called deep in the stack.\n *\n * Import from `@nifrajs/middleware/context-storage` so ordinary `@nifrajs/middleware` imports stay\n * node-compat-free on edge runtimes. The runtime must support `node:async_hooks` AsyncLocalStorage.\n */"
   },
+  {
+    "name": "ContextTokenCounter",
+    "kind": "type",
+    "package": "@nifrajs/agent",
+    "signature": "export type ContextTokenCounter = (text: string) => number;"
+  },
   {
     "name": "ContextWindow",
     "kind": "class",
@@ -4220,7 +4416,7 @@
     "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    /**\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}"
+    "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    /** Max serialized JSON-RPC response or SSE frame size (default 1 MB). */\n    readonly maxResponseBytes?: number;\n    /** Natural-language guidance for LLMs, surfaced in the modern `server/discover` result (2026-07-28). */\n    readonly instructions?: string;\n    /** Explicitly allow browser clients from any origin. Omit for the secure same-origin default. */\n    readonly allowAnyOrigin?: boolean;\n    /** Origin allowlist for the DNS-rebinding guard. Set it to permit exact cross-origin clients. */\n    readonly allowedOrigins?: readonly string[];\n    /** Shared state for one authenticated MCP session; prefer `resolveState` for multi-session hosts. */\n    readonly state?: McpProtocolState;\n    /** Resolve a session-scoped request registry after per-message authorization. */\n    readonly resolveState?: McpHttpOptions[\"resolveState\"];\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": "createMemoryAgentEvidenceLog",
@@ -4312,6 +4508,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": "createPredictionStore",
+    "kind": "function",
+    "package": "@nifrajs/webmcp",
+    "signature": "export declare function createPredictionStore<State>(initial: AgentSurfaceAuthoritativeState<State>): PredictionStore<State>;",
+    "doc": "/**\n * An atomic, defensive prediction store. Predictions are overlays over authoritative state; a server\n * commit replaces the base and remaining overlays are replayed or conflict-dropped.\n */"
+  },
   {
     "name": "createPresetSpec",
     "kind": "function",
@@ -4541,7 +4744,7 @@
     "name": "CreateWebAppOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "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    /** In-memory reference cache for explicitly `static` boundary values. It never persists payloads\n     * across processes; operated/durable cache implementations stay outside the public framework. */\n    readonly staticBoundaryCache?: import(\"../boundary.js\").StaticBoundaryCache;\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     * Resolve a fresh CSP nonce for each document request. The value is applied to every\n     * framework-owned executable script; return `undefined` to keep the default nonce-free output.\n     * Nonce-bearing documents are marked `private, no-store` so the request-specific value is not\n     * replayed by browser, CDN, or ISR caches. The resolver does not declare a CSP header because the\n     * policy's allowed sources are app-specific.\n     */\n    readonly nonce?: NonceResolver<Env>;\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, platform?: Platform<Env>): 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    /**\n     * Activation policy for framework-owned stylesheet links (default `\"blocking\"`). `\"deferred\"`\n     * emits `media=\"print\"` links; the generated client waits for them and switches them to `all` before\n     * mounting. Pair with an aggregate Vite stylesheet (`cssCodeSplit: false`) to prevent lazy-prefetch\n     * CSS insertion. Non-hydrated pages always keep their stylesheet links blocking.\n     */\n    readonly cssLoading?: CssLoadingMode;\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    /** In-memory reference cache for explicitly `static` boundary values. It never persists payloads\n     * across processes; operated/durable cache implementations stay outside the public framework. */\n    readonly staticBoundaryCache?: import(\"../boundary.js\").StaticBoundaryCache;\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",
@@ -4596,6 +4799,13 @@
     "package": "@nifrajs/middleware",
     "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": "CssLoadingMode",
+    "kind": "type",
+    "package": "@nifrajs/web",
+    "signature": "export type CssLoadingMode = \"blocking\" | \"deferred\";",
+    "doc": "/**\n * How framework-owned stylesheets are made active during the first document load.\n *\n * `blocking` is the backwards-compatible default. `deferred` is intended for an aggregate\n * stylesheet: the document fetches it with `media=\"print\"`, then the generated client promotes it\n * to `media=\"all\"` after the resource settles and before mounting the app.\n */"
+  },
   {
     "name": "CssModuleResult",
     "kind": "interface",
@@ -4799,6 +5009,20 @@
     "signature": "export type DataScope = RlsScope;",
     "doc": "/** Backward-compatible name for the request scope carried by every data operation. */"
   },
+  {
+    "name": "DeadLetterRecord",
+    "kind": "interface",
+    "package": "@nifrajs/jobs",
+    "signature": "export interface DeadLetterRecord {\n    readonly id: string;\n    readonly name: string;\n    readonly error: string;\n}",
+    "doc": "/** The store-side shape this projects. Structural so durable adapters need no jobs import. */"
+  },
+  {
+    "name": "DeadLetterView",
+    "kind": "interface",
+    "package": "@nifrajs/jobs",
+    "signature": "export interface DeadLetterView {\n    readonly id: string;\n    readonly name: string;\n    /** FNV-1a 32-bit hex of the error text. This is grouping metadata, not a confidentiality boundary. */\n    readonly errorFingerprint: string;\n}",
+    "doc": "/** What leaves the server: identity plus a grouping key. Never the error text. */"
+  },
   {
     "name": "DeadlineAdmission",
     "kind": "type",
@@ -4897,6 +5121,13 @@
     "package": "@nifrajs/cli",
     "signature": "export declare const DEFAULT_ASSURANCE_CONFIG = \"nifra.assurance.ts\";"
   },
+  {
+    "name": "DEFAULT_CSS_LOADING",
+    "kind": "const",
+    "package": "@nifrajs/web",
+    "signature": "export declare const DEFAULT_CSS_LOADING: CssLoadingMode;",
+    "doc": "/** The default remains the ordinary render-blocking stylesheet link. */"
+  },
   {
     "name": "DEFAULT_DEV_PORT",
     "kind": "const",
@@ -4958,6 +5189,19 @@
     "signature": "export interface Deferred<T> {\n    readonly __nifra_deferred: true;\n    readonly id: number;\n    readonly promise: Promise<T>;\n}",
     "doc": "/**\n * A loader value marked to stream in after the shell. The component consumes it with the adapter's\n * `<Await resolve={...}>`; until the promise settles the shell shows the `<Suspense>` fallback.\n * `id` is assigned by the server at serialization time - the streamed resolve script keys off it.\n */"
   },
+  {
+    "name": "defineAgentCapability",
+    "kind": "function",
+    "package": "@nifrajs/webmcp",
+    "signature": "export declare function defineAgentCapability<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1, State = unknown>(options: DefineAgentCapabilityOptions<InputSchema, OutputSchema, State>): AgentCapability<InferOutput<InputSchema>, InferOutput<OutputSchema>, State>;",
+    "doc": "/** Create a capability from the same core tool contract used by Nifra's other adapters. */"
+  },
+  {
+    "name": "DefineAgentCapabilityOptions",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "signature": "export type DefineAgentCapabilityOptions<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1, State> = ToolContractOptions<InferOutput<InputSchema>, InferOutput<OutputSchema>, InputSchema, OutputSchema> & {\n    readonly scope?: AgentSurfaceScope;\n    readonly reads?: readonly string[];\n    readonly writes?: readonly string[];\n    readonly reconciliation?: ReconciliationMode;\n    readonly predict?: AgentSurfacePredictor<InferOutput<InputSchema>, State>;\n    readonly reconcile?: AgentSurfaceReconciler<InferOutput<InputSchema>, InferOutput<OutputSchema>, State>;\n};"
+  },
   {
     "name": "defineAgentEvalSuite",
     "kind": "function",
@@ -5535,6 +5779,20 @@
     "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": "DiagnosticCompatibility",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface DiagnosticCompatibility {\n    /** The pre-registry rule name used by the human/legacy check result. */\n    readonly rule: string;\n    /** The old human-facing fix text, when the rule had one. */\n    readonly fix?: string;\n    /** A richer legacy suggestion (diff, command, or manual steps). */\n    readonly suggestion?: DiagnosticSuggestion;\n    /** The import path evidence used by the legacy server-only-import view. */\n    readonly chain?: readonly string[];\n    /** Preserve the old optional `CheckDiagnostic.code` field exactly where it existed. */\n    readonly includeCode?: boolean;\n}",
+    "doc": "/**\n * The richer compatibility view used by the original `nifra check` renderer. It is deliberately\n * kept out of the enumerable diagnostic shape: SARIF, MCP structured output, and JSON consumers get\n * the small stable diagnostic contract, while the legacy text view can still explain an exact edit.\n */"
+  },
+  {
+    "name": "diagnosticCompatibilityOf",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function diagnosticCompatibilityOf(value: Diagnostic): DiagnosticCompatibility | undefined;",
+    "doc": "/** Read legacy-only rendering metadata. Undefined means the diagnostic has no compatibility view. */"
+  },
   {
     "name": "DiagnosticFix",
     "kind": "interface",
@@ -5548,6 +5806,19 @@
     "signature": "export interface DiagnosticFrame {\n    readonly raw: string;\n    readonly file?: string;\n    readonly line?: number;\n    readonly column?: number;\n}",
     "doc": "/** One parsed stack frame. `file`/`line`/`column` are present only when the frame could be located. */"
   },
+  {
+    "name": "DiagnosticSuggestion",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface DiagnosticSuggestion {\n    readonly kind: \"edit\" | \"command\" | \"manual\";\n    readonly title: string;\n    readonly diff?: string;\n    readonly command?: readonly string[];\n    readonly steps?: readonly string[];\n}"
+  },
+  {
+    "name": "diagnosticWithCompatibility",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function diagnosticWithCompatibility(value: Diagnostic, compatibility: DiagnosticCompatibility): Diagnostic;",
+    "doc": "/** Attach legacy-only rendering metadata without widening the serialized diagnostic protocol. */"
+  },
   {
     "name": "diffDataContract",
     "kind": "function",
@@ -5569,6 +5840,13 @@
     "signature": "export declare function diffNifraManifests(before: NifraManifest, after: NifraManifest): NifraManifestDiff;",
     "doc": "/** Contract changes reuse the route-diff engine; governance changes fail closed on expanded risk. */"
   },
+  {
+    "name": "diffOpenApiInventory",
+    "kind": "function",
+    "package": "@nifrajs/schema",
+    "signature": "export declare function diffOpenApiInventory(expected: ImportedApiInventory, actual: ImportedApiInventory): readonly OpenApiInventoryDrift[];",
+    "doc": "/** Compare two inventories. Empty means the export/import cycle preserved the route table. */"
+  },
   {
     "name": "diffRouteSnapshots",
     "kind": "function",
@@ -5589,6 +5867,13 @@
     "signature": "export declare function digestProjectEvidence(snapshot: ProjectEvidenceSnapshot): Promise<string>;",
     "doc": "/** SHA-256 of the canonical snapshot, useful as a cheap freshness/reference token. */"
   },
+  {
+    "name": "digestReviewReport",
+    "kind": "function",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare function digestReviewReport(report: ReviewReport): Promise<string>;",
+    "doc": "/** Compute a lowercase Web Crypto SHA-256 digest of the canonical report representation. */"
+  },
   {
     "name": "digestRunPlan",
     "kind": "function",
@@ -6338,6 +6623,13 @@
     "signature": "export declare const examplesWidget: import(\"@nifrajs/mcp\").McpWidget;",
     "doc": "/** The widget: renders `structuredContent.examples` as a filterable list of example cards. */"
   },
+  {
+    "name": "executeAgentCapability",
+    "kind": "function",
+    "package": "@nifrajs/webmcp",
+    "signature": "export declare function executeAgentCapability<Input, Output, State>(capability: AgentCapability<Input, Output, State>, input: unknown, options?: ToolCallOptions): Promise<ToolCallResult<Output>>;",
+    "doc": "/** Execute through Nifra's existing validation, policy, approval, idempotency, and evidence path. */"
+  },
   {
     "name": "executeCapability",
     "kind": "function",
@@ -6345,6 +6637,19 @@
     "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": "executePredicted",
+    "kind": "function",
+    "package": "@nifrajs/webmcp",
+    "signature": "export declare function executePredicted<Input, Output, State>(capability: AgentCapability<Input, Output, State>, input: unknown, store: PredictionStore<State>, options?: ExecutePredictedOptions): Promise<PredictedExecutionResult<Output, State>>;",
+    "doc": "/** Apply a pure prediction, execute the core tool, then commit or roll it back atomically. */"
+  },
+  {
+    "name": "ExecutePredictedOptions",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface ExecutePredictedOptions extends Omit<ToolCallOptions, \"capabilities\"> {\n    readonly capabilities?: readonly string[];\n    readonly predictionId?: string;\n    readonly now?: () => number;\n}"
+  },
   {
     "name": "executeTool",
     "kind": "function",
@@ -6712,14 +7017,14 @@
     "name": "FetchHandler",
     "kind": "interface",
     "package": "@nifrajs/deno",
-    "signature": "export interface FetchHandler {\n    fetch(request: Request, platform?: {\n        readonly clientIp?: string;\n    }): Response | Promise<Response>;\n    /** A nifra app also exposes this WS-upgrade seam; present → this adapter serves `app.ws()` routes\n     * via `Deno.upgradeWebSocket`. Absent (a plain `{ fetch }` handler) → HTTP only. */\n    resolveWebSocketUpgrade?(request: Request): WsUpgradeOutcome | Promise<WsUpgradeOutcome>;\n}",
+    "signature": "export interface FetchHandler {\n    fetch(request: Request, platform?: {\n        readonly clientIp?: string;\n    }): Response | Promise<Response>;\n    /** A nifra app also exposes this WS-upgrade seam; present → this adapter serves `app.ws()` routes\n     * via `Deno.upgradeWebSocket`. Absent (a plain `{ fetch }` handler) → HTTP only. */\n    resolveWebSocketUpgrade?(request: Request, platform?: {\n        readonly clientIp?: string;\n    }): WsUpgradeOutcome | Promise<WsUpgradeOutcome>;\n}",
     "doc": "/** Anything exposing a Web `fetch` handler - a nifra `app`, for instance. */"
   },
   {
     "name": "FetchHandler",
     "kind": "interface",
     "package": "@nifrajs/node",
-    "signature": "export interface FetchHandler {\n    fetch(request: Request, platform?: NodePlatform): Response | Promise<Response>;\n    /** Nifra apps also expose this WS-upgrade seam; present → this adapter serves `app.ws()` routes via\n     * the optional `ws` package (lazy-imported on the first upgrade). Absent (a plain `{ fetch }`\n     * handler) → HTTP only, and an upgrade request gets a 404. */\n    resolveWebSocketUpgrade?(request: Request): WsUpgradeOutcome | Promise<WsUpgradeOutcome>;\n}",
+    "signature": "export interface FetchHandler {\n    fetch(request: Request, platform?: NodePlatform): Response | Promise<Response>;\n    /** Nifra apps also expose this WS-upgrade seam; present → this adapter serves `app.ws()` routes via\n     * the optional `ws` package (lazy-imported on the first upgrade). Absent (a plain `{ fetch }`\n     * handler) → HTTP only, and an upgrade request gets a 404. */\n    resolveWebSocketUpgrade?(request: Request, platform?: NodePlatform): WsUpgradeOutcome | Promise<WsUpgradeOutcome>;\n}",
     "doc": "/** Anything exposing a Web `fetch` handler - a nifra `app`, for instance. */"
   },
   {
@@ -6787,14 +7092,14 @@
     "name": "FileSessionStore",
     "kind": "class",
     "package": "@nifrajs/coding-agent",
-    "signature": "export declare class FileSessionStore implements SessionStore {\n    private readonly root;\n    private readonly maxEntryBytes;\n    private readonly sequences;\n    constructor(options: FileSessionStoreOptions);\n    append(sessionId: string, type: string, payload?: unknown, options?: {\n        readonly pinned?: boolean;\n    }): Promise<SessionLogEntry>;\n    read(sessionId: string): Promise<readonly SessionLogEntry[]>;\n    checkpoint(sessionId: string, payload: unknown): Promise<void>;\n    fork(sessionId: string, targetSessionId?: string): Promise<string>;\n    private pathFor;\n    private nextSequence;\n}",
+    "signature": "export declare class FileSessionStore implements SessionStore {\n    private readonly root;\n    private readonly maxEntryBytes;\n    private readonly maxEntries;\n    private readonly maxBytes;\n    private readonly sequences;\n    private readonly locks;\n    constructor(options: FileSessionStoreOptions);\n    append(sessionId: string, type: string, payload?: unknown, options?: {\n        readonly pinned?: boolean;\n    }): Promise<SessionLogEntry>;\n    read(sessionId: string, limit?: number): Promise<readonly SessionLogEntry[]>;\n    checkpoint(sessionId: string, payload: unknown): Promise<void>;\n    fork(sessionId: string, targetSessionId?: string): Promise<string>;\n    private pathFor;\n    private nextSequence;\n    private compactIfNeeded;\n    private readTailText;\n    private readUnlocked;\n    private withSessionLock;\n}",
     "doc": "/**\n * Small append-only JSONL store. It stores redacted, bounded event evidence rather than raw model\n * transcripts, so session recovery is useful without turning the agent into a memory sink.\n */"
   },
   {
     "name": "FileSessionStoreOptions",
     "kind": "interface",
     "package": "@nifrajs/coding-agent",
-    "signature": "export interface FileSessionStoreOptions {\n    readonly root: string;\n    readonly maxEntryBytes?: number;\n}"
+    "signature": "export interface FileSessionStoreOptions {\n    readonly root: string;\n    readonly maxEntryBytes?: number;\n    /** Maximum retained JSONL entries per session. Defaults to 4,096. */\n    readonly maxEntries?: number;\n    /** Maximum retained JSONL bytes per session. Defaults to 8 MiB. */\n    readonly maxBytes?: number;\n}"
   },
   {
     "name": "FileStorage",
@@ -7139,7 +7444,7 @@
     "name": "GenerateServerManifestOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface GenerateServerManifestOptions {\n    /** Turn a route/layout source file (relative to the routes dir) into an import specifier -\n     * same contract as `generateClientEntry`'s `resolve`. */\n    readonly resolve: (file: string) => string;\n    /** The content-hashed client entry URL (from `buildClient`'s manifest), **baked** into the emitted\n     * module - a disk-less worker can't read `manifest.json` at runtime. */\n    readonly clientEntry: string;\n    /** The app's aggregate stylesheet URLs (`buildClient`'s `BuildManifest.css`) - baked as\n     * `export const styles` so the server entry can hand them to `createWebApp` (→ `<link rel=\"stylesheet\">`\n     * in `<head>`). Without this the built SSR page ships no CSS link and renders unstyled. */\n    readonly styles?: readonly string[] | undefined;\n    /** Per-route stylesheet URLs (`buildClient`'s `BuildManifest.routeStyles`) - baked as\n     * `export const routeStyles` so a page links only the CSS its route chain uses. */\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>> | undefined;\n    /** Emit **lazy** per-route loaders (`() => import(\"./routes/x\")`, a static specifier) instead of\n     * eager `import * as`, so a bundler with code-splitting emits one chunk per route - loaded on the\n     * first request to it, not all at boot (smaller cold-start parse). Default `false` (eager). Both\n     * modes are fs-free with statically-analyzable specifiers; only the *when* differs. */\n    readonly lazy?: boolean;\n}"
+    "signature": "export interface GenerateServerManifestOptions {\n    /** Turn a route/layout source file (relative to the routes dir) into an import specifier -\n     * same contract as `generateClientEntry`'s `resolve`. */\n    readonly resolve: (file: string) => string;\n    /** The content-hashed client entry URL (from `buildClient`'s manifest), **baked** into the emitted\n     * module - a disk-less worker can't read `manifest.json` at runtime. */\n    readonly clientEntry: string;\n    /** The app's aggregate stylesheet URLs (`buildClient`'s `BuildManifest.css`) - baked as\n     * `export const styles` so the server entry can hand them to `createWebApp` (→ `<link rel=\"stylesheet\">`\n     * in `<head>`). Without this the built SSR page ships no CSS link and renders unstyled. */\n    readonly styles?: readonly string[] | undefined;\n    /** Per-route stylesheet URLs (`buildClient`'s `BuildManifest.routeStyles`) - baked as\n     * `export const routeStyles` so a page links only the CSS its route chain uses. */\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>> | undefined;\n    /** How framework-owned stylesheet links should activate before the generated client mounts. */\n    readonly cssLoading?: CssLoadingMode;\n    /** Emit **lazy** per-route loaders (`() => import(\"./routes/x\")`, a static specifier) instead of\n     * eager `import * as`, so a bundler with code-splitting emits one chunk per route - loaded on the\n     * first request to it, not all at boot (smaller cold-start parse). Default `false` (eager). Both\n     * modes are fs-free with statically-analyzable specifiers; only the *when* differs. */\n    readonly lazy?: boolean;\n}"
   },
   {
     "name": "generateServiceWorker",
@@ -7241,7 +7546,7 @@
     "name": "GraphqlHttpOptions",
     "kind": "interface",
     "package": "@nifrajs/graphql",
-    "signature": "export interface GraphqlHttpOptions<Context = unknown, Env = unknown> {\n    /** The executable schema (types + resolvers), e.g. from `graphql`'s `buildSchema` or a schema builder. */\n    readonly schema: GraphQLSchema;\n    /** Build the resolver `contextValue` from the request (and nifra context when mounted). */\n    readonly context?: GraphqlContextBuilder<Context, Env>;\n    /** The nifra route context, when the caller has one (supplied by `mountGraphql`). */\n    readonly nifra?: NifraContextLike<Env>;\n    /** Maximum request body size in bytes. Default 1 MB. Rejected bodies answer 413. */\n    readonly maxBodyBytes?: number;\n    /** Prototype-pollution policy for the parsed JSON body. Default `\"reject\"`. */\n    readonly protoPoisoning?: ProtoPoisoning;\n    /** Optional root value passed to the executor. */\n    readonly rootValue?: unknown;\n    /**\n     * Origin allowlist for the CORS `access-control-allow-origin` header. Omit to reflect any origin\n     * (`*`) - correct for a public API; set it to lock the browser callers down.\n     */\n    readonly allowedOrigins?: readonly string[];\n    /**\n     * Per-request authorization, run after the body parses and before execution. Return `false` to answer\n     * `401` with a GraphQL error envelope and skip execution entirely.\n     */\n    readonly authorize?: (request: Request) => boolean | Promise<boolean>;\n    /** Emit the legacy always-200 `application/json` response shape instead of `application/graphql-response+json`. */\n    readonly legacyJsonResponse?: boolean;\n}"
+    "signature": "export interface GraphqlHttpOptions<Context = unknown, Env = unknown> {\n    /** The executable schema (types + resolvers), e.g. from `graphql`'s `buildSchema` or a schema builder. */\n    readonly schema: GraphQLSchema;\n    /** Build the resolver `contextValue` from the request (and nifra context when mounted). */\n    readonly context?: GraphqlContextBuilder<Context, Env>;\n    /** The nifra route context, when the caller has one (supplied by `mountGraphql`). */\n    readonly nifra?: NifraContextLike<Env>;\n    /** Maximum request body size in bytes. Default 1 MB. Rejected bodies answer 413. */\n    readonly maxBodyBytes?: number;\n    /** Maximum UTF-8 query size. Default 64 KiB, applied to POST and GET. */\n    readonly maxQueryBytes?: number;\n    /** Maximum UTF-8 serialized variables size. Default 256 KiB. */\n    readonly maxVariablesBytes?: number;\n    /** Maximum expanded field depth. Default 20. */\n    readonly maxDepth?: number;\n    /** Maximum aliases in one document. Default 100. */\n    readonly maxAliases?: number;\n    /** Maximum simple field complexity in one document. Default 1,000. */\n    readonly maxComplexity?: number;\n    /** Maximum operation definitions in one document. Default 10. */\n    readonly maxOperations?: number;\n    /** Maximum asynchronous resolver execution time. Default 10 seconds. */\n    readonly executionTimeoutMs?: number;\n    /** Prototype-pollution policy for the parsed JSON body. Default `\"reject\"`. */\n    readonly protoPoisoning?: ProtoPoisoning;\n    /** Optional root value passed to the executor. */\n    readonly rootValue?: unknown;\n    /**\n     * Origin allowlist for the CORS `access-control-allow-origin` header. Omit to reflect any origin\n     * (`*`) - correct for a public API; set it to lock the browser callers down.\n     */\n    readonly allowedOrigins?: readonly string[];\n    /**\n     * Per-request authorization, run after the body parses and before execution. Return `false` to answer\n     * `401` with a GraphQL error envelope and skip execution entirely.\n     */\n    readonly authorize?: (request: Request) => boolean | Promise<boolean>;\n    /** Emit the legacy always-200 `application/json` response shape instead of `application/graphql-response+json`. */\n    readonly legacyJsonResponse?: boolean;\n    /** Format request/execution errors. The default masks resolver messages and preserves request errors. */\n    readonly formatError?: (error: GraphQLError, phase: \"request\" | \"execution\") => unknown;\n}"
   },
   {
     "name": "GraphqlPubSub",
@@ -7261,7 +7566,7 @@
     "name": "GraphqlWsOptions",
     "kind": "interface",
     "package": "@nifrajs/graphql",
-    "signature": "export interface GraphqlWsOptions<Context extends Record<string, unknown> = Record<string, unknown>> {\n    /** The executable schema. */\n    readonly schema: GraphQLSchema;\n    /** Build the resolver `contextValue` from the upgrade request. Shared with the HTTP transport. */\n    readonly context?: GraphqlContextBuilder<Context>;\n    /**\n     * Called once per connection with the client's `connection_init` payload; return `false` (or throw)\n     * to reject the connection. The seam for authenticating a socket from an init token.\n     */\n    readonly onConnect?: (payload: ConnectionInitMessage[\"payload\"], request: Request) => boolean | Promise<boolean>;\n    /** Additional raw `graphql-ws` server options merged last (advanced escape hatch). */\n    readonly serverOptions?: Partial<ServerOptions>;\n}"
+    "signature": "export interface GraphqlWsOptions<Context extends Record<string, unknown> = Record<string, unknown>> {\n    /** The executable schema. */\n    readonly schema: GraphQLSchema;\n    /** Build the resolver `contextValue` from the upgrade request. Shared with the HTTP transport. */\n    readonly context?: GraphqlContextBuilder<Context>;\n    /**\n     * Called once per connection with the client's `connection_init` payload; return `false` (or throw)\n     * to reject the connection. The seam for authenticating a socket from an init token.\n     */\n    readonly onConnect?: (payload: ConnectionInitMessage[\"payload\"], request: Request) => boolean | Promise<boolean>;\n    /** Additional raw `graphql-ws` server options merged last (advanced escape hatch). */\n    readonly serverOptions?: Partial<ServerOptions>;\n    /** Same query/complexity limits as the HTTP transport. */\n    readonly maxQueryBytes?: number;\n    readonly maxVariablesBytes?: number;\n    readonly maxDepth?: number;\n    readonly maxAliases?: number;\n    readonly maxComplexity?: number;\n    readonly maxOperations?: number;\n    /** Maximum concurrent subscription operation ids per connection. Default 20. */\n    readonly maxSubscriptions?: number;\n    /** Maximum time for initial execute/subscribe setup. Default 10 seconds. */\n    readonly executionTimeoutMs?: number;\n}"
   },
   {
     "name": "GuardOptions",
@@ -7380,6 +7685,20 @@
     "signature": "export interface HandoffView {\n    readonly requestId: string;\n    readonly runId: string;\n    readonly nodeId: string;\n    readonly capability: string;\n    readonly vector: number;\n    readonly expiresAt: number;\n    readonly state: HandoffLifecycleState;\n    /** Opaque origin role. */\n    readonly from: string;\n    /** Opaque owner role once assigned. */\n    readonly to?: string;\n}",
     "doc": "/** Content-free projection of one handoff boundary for a list/inspect view. */"
   },
+  {
+    "name": "hasDuplicateCookie",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function hasDuplicateCookie(header: string | null | undefined, targetName: string): boolean;",
+    "doc": "/** True when a raw Cookie header contains the same exact cookie name more than once. */"
+  },
+  {
+    "name": "hasDuplicateCookie",
+    "kind": "function",
+    "package": "nifra",
+    "signature": "export declare function hasDuplicateCookie(header: string | null | undefined, targetName: string): boolean;",
+    "doc": "/** True when a raw Cookie header contains the same exact cookie name more than once. */"
+  },
   {
     "name": "hash8",
     "kind": "function",
@@ -7473,6 +7792,13 @@
     "signature": "export interface HtmlImageAttrs {\n    readonly src: string;\n    readonly width: number;\n    readonly height: number;\n    readonly alt: string;\n    readonly loading: \"lazy\" | \"eager\";\n    readonly decoding: \"async\";\n    readonly srcset?: string;\n    readonly sizes?: string;\n    readonly fetchpriority?: \"high\";\n}",
     "doc": "/** Plain lowercase HTML `<img>` attributes (`srcset`/`fetchpriority`, not React's camelCase). */"
   },
+  {
+    "name": "HtmlSanitizer",
+    "kind": "type",
+    "package": "@nifrajs/web",
+    "signature": "export type HtmlSanitizer = (value: string) => string;",
+    "doc": "/** The only contract a project-specific, allowlist-based HTML sanitizer must satisfy. */"
+  },
   {
     "name": "HtmlValue",
     "kind": "type",
@@ -7484,14 +7810,14 @@
     "name": "HttpAgentTransport",
     "kind": "class",
     "package": "@nifrajs/agent-app",
-    "signature": "export declare class HttpAgentTransport implements AgentTransport {\n    private readonly url;\n    private readonly authorize;\n    private readonly fetchImpl;\n    constructor(options: HttpAgentTransportOptions);\n    private headers;\n    command<T = unknown>(request: AgentTransportRequest): Promise<CommandOutcome<T>>;\n    stream(request: AgentTransportRequest): AsyncIterable<AgentEvent>;\n}",
+    "signature": "export declare class HttpAgentTransport implements AgentTransport {\n    private readonly url;\n    private readonly authorize;\n    private readonly fetchImpl;\n    private readonly maxResponseBytes;\n    constructor(options: HttpAgentTransportOptions);\n    private headers;\n    command<T = unknown>(request: AgentTransportRequest): Promise<CommandOutcome<T>>;\n    stream(request: AgentTransportRequest): AsyncIterable<AgentEvent>;\n}",
     "doc": "/** Web `fetch` + SSE transport. Browser- and Bun-compatible; depends on no Node or framework code. */"
   },
   {
     "name": "HttpAgentTransportOptions",
     "kind": "interface",
     "package": "@nifrajs/agent-app",
-    "signature": "export interface HttpAgentTransportOptions {\n    /** RPC origin, e.g. `http://127.0.0.1:8787`. The `/rpc` path is appended. */\n    readonly endpoint: string;\n    /** Per-request bearer-token source. Never stored; only the header value is used and discarded. */\n    readonly authorize?: AuthProvider;\n    /** Injectable fetch for tests and non-DOM hosts. Defaults to the ambient `fetch`. */\n    readonly fetch?: typeof fetch;\n}"
+    "signature": "export interface HttpAgentTransportOptions {\n    /** RPC origin, e.g. `http://127.0.0.1:8787`. The `/rpc` path is appended. */\n    readonly endpoint: string;\n    /** Per-request bearer-token source. Never stored; only the header value is used and discarded. */\n    readonly authorize?: AuthProvider;\n    /** Injectable fetch for tests and non-DOM hosts. Defaults to the ambient `fetch`. */\n    readonly fetch?: typeof fetch;\n    /** Maximum response bytes retained by command and SSE reads. Defaults to 8 MiB. */\n    readonly maxResponseBytes?: number;\n}"
   },
   {
     "name": "httpToolAdapter",
@@ -7670,7 +7996,7 @@
     "name": "IdempotencyClaim",
     "kind": "type",
     "package": "@nifrajs/middleware",
-    "signature": "export type IdempotencyClaim = {\n    readonly state: \"new\";\n} | {\n    readonly state: \"in_flight\";\n} | {\n    readonly state: \"replay\";\n    readonly record: IdempotencyRecord;\n};"
+    "signature": "export type IdempotencyClaim = {\n    readonly state: \"new\";\n    readonly reservation: string;\n} | {\n    readonly state: \"in_flight\";\n} | {\n    readonly state: \"replay\";\n    readonly record: IdempotencyRecord;\n};"
   },
   {
     "name": "IdempotencyClass",
@@ -7754,7 +8080,7 @@
     "name": "IdempotencyStore",
     "kind": "interface",
     "package": "@nifrajs/middleware",
-    "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}",
+    "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 only when `reservation` still owns the lock (kept for `ttlMs`). */\n    complete(key: string, reservation: string, record: IdempotencyRecord, ttlMs: number): Promise<boolean>;\n    /** Release only the lock owned by `reservation` (handler errored / response not cacheable). */\n    release(key: string, reservation: string): Promise<boolean>;\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 */"
   },
   {
@@ -7943,6 +8269,37 @@
     "signature": "export declare function implement<const C extends ContractShape, H extends HandlersFor<C, Ctx>, R extends Registry = EmptyRegistry, Ctx = NonNullable<unknown>, HookOutput = never>(contract: C, handlers: H, app?: Server<R, Ctx, HookOutput>): Server<R & RegistryFromImpl<C, H, Ctx, HookOutput>, Ctx, HookOutput>;",
     "doc": "/**\n * Bind handlers to a contract, producing a real {@link Server} you can `.listen()`\n * or `.fetch()`. Each op is registered through the same path as the inline\n * builder, so the result is identical to writing the routes inline - handlers\n * lift over **unchanged** (\"graduation\"), and body/query schemas validate at the\n * request boundary exactly as in inline mode.\n *\n * Pass a pre-configured `app` to give the contract's routes a middleware chain. A route captures the\n * server's `derive`/`decorate`/assurance chain **at registration**, so anything applied to the\n * returned server afterwards reaches the contract's routes not at all - the app must already carry it:\n *\n * ```ts\n * const app = implement(contract, handlers, server().use(auth).derive(sessionOf))\n * ```\n *\n * That is also the seam that lets `nifra assure` prove rather than merely classify a contract-first\n * app: the plugin that installs the enforcement is what declares the evidence\n * ({@link withRouteAssurance}), and only a plugin installed *before* registration is captured. Handlers\n * then see the app's `Ctx`, and the returned server keeps any routes the app already had.\n */"
   },
+  {
+    "name": "ImportedApiInventory",
+    "kind": "interface",
+    "package": "@nifrajs/schema",
+    "signature": "export interface ImportedApiInventory {\n    readonly title: string;\n    readonly version: string;\n    readonly routes: readonly ImportedRoute[];\n    readonly warnings: readonly string[];\n}"
+  },
+  {
+    "name": "ImportedRoute",
+    "kind": "interface",
+    "package": "@nifrajs/schema",
+    "signature": "export interface ImportedRoute {\n    /** Lowercase HTTP method as it appears in the document. */\n    readonly method: string;\n    /** Nifra-templated path (`/users/:id`). */\n    readonly path: string;\n    readonly operationId?: string;\n    /** Template parameter names in path order. */\n    readonly pathParams: readonly string[];\n    readonly query: readonly ImportedRouteQuery[];\n    readonly hasBody: boolean;\n    readonly requestBodyRequired: boolean;\n    /** Response status keys (`\"200\"`, `\"404\"`, `\"default\"`). */\n    readonly responseStatuses: readonly string[];\n    /** Per-route degradations (wildcard rewrites). */\n    readonly notes: readonly string[];\n}"
+  },
+  {
+    "name": "ImportedRouteQuery",
+    "kind": "interface",
+    "package": "@nifrajs/schema",
+    "signature": "export interface ImportedRouteQuery {\n    readonly name: string;\n    readonly required: boolean;\n}"
+  },
+  {
+    "name": "importOpenAPI",
+    "kind": "function",
+    "package": "@nifrajs/schema",
+    "signature": "export declare function importOpenAPI(document: unknown, options?: ImportOpenAPIOptions): ImportedApiInventory;",
+    "doc": "/** Parse an OpenAPI 3.0/3.1 document into a canonical route inventory. Throws on invalid input. */"
+  },
+  {
+    "name": "ImportOpenAPIOptions",
+    "kind": "interface",
+    "package": "@nifrajs/schema",
+    "signature": "export interface ImportOpenAPIOptions {\n    /** Maximum entries under `paths`. Default 5000. */\n    readonly maxPaths?: number;\n    /** Maximum operations on one path item. Default 8. */\n    readonly maxOperationsPerPath?: number;\n    /** Maximum merged parameters per operation. Default 100. */\n    readonly maxParameters?: number;\n}"
+  },
   {
     "name": "IncidentCapsule",
     "kind": "interface",
@@ -8202,7 +8559,8 @@
     "name": "isAgentEvent",
     "kind": "function",
     "package": "@nifrajs/agent-protocol",
-    "signature": "export declare function isAgentEvent(value: unknown): value is AgentEvent;"
+    "signature": "export declare function isAgentEvent(value: unknown): value is AgentEvent;",
+    "doc": "/** Validate the complete discriminated event union before a projection or UI consumer sees it. */"
   },
   {
     "name": "isAllowedFontUrl",
@@ -8239,6 +8597,20 @@
     "signature": "export declare function isDraftEnabled(request: Request, secret: string): Promise<boolean>;",
     "doc": "/**\n * Whether `request` carries a **valid** signed draft cookie (constant-time verify via `unsignValue`).\n * `createWebApp` uses it to set `ctx.draft`; `withISR` uses it to bypass the cache for editors. A\n * missing, forged, or tampered cookie returns `false`.\n */"
   },
+  {
+    "name": "isJsonRpcRequest",
+    "kind": "function",
+    "package": "@nifrajs/mcp",
+    "signature": "export declare function isJsonRpcRequest(value: unknown): value is JsonRpcRequest;",
+    "doc": "/** Validate a JSON-RPC request/notification before any transport or method-specific access. */"
+  },
+  {
+    "name": "isJsonRpcResponse",
+    "kind": "function",
+    "package": "@nifrajs/mcp",
+    "signature": "export declare function isJsonRpcResponse(value: unknown): value is JsonRpcResponse;",
+    "doc": "/** Validate a JSON-RPC response received by a transport-side client hook. Responses are not accepted\n * by {@link handleRpc}; this guard exists for the stdio roots/list answer, which is the one server-\n * initiated request response the CLI consumes itself. */"
+  },
   {
     "name": "island",
     "kind": "function",
@@ -8427,6 +8799,13 @@
     "signature": "export interface ISRPlatform {\n    readonly waitUntil?: (promise: Promise<unknown>) => void;\n}",
     "doc": "/** Minimal platform shape `withISR` needs - just `waitUntil` (edge runtimes extend the response\n * lifetime so background regeneration finishes). Off-edge it's absent and regen runs fire-and-forget. */"
   },
+  {
+    "name": "isSafeReviewDiff",
+    "kind": "function",
+    "package": "@nifrajs/coding-agent",
+    "signature": "export declare function isSafeReviewDiff(value: unknown): value is string;",
+    "doc": "/** Validate the only repository selector exposed by the host review RPC. */"
+  },
   {
     "name": "isSameOriginPath",
     "kind": "function",
@@ -9193,6 +9572,13 @@
     "signature": "export declare const MAX_MEDIA_QUERY_LENGTH = 256;",
     "doc": "/** The maximum media-query length accepted from an HTML data attribute. */"
   },
+  {
+    "name": "MAX_TRANSPORT_BYTES",
+    "kind": "const",
+    "package": "@nifrajs/agent-protocol",
+    "signature": "export declare const MAX_TRANSPORT_BYTES: number;",
+    "doc": "/**\n * Protocol-neutral byte limits for HTTP adapters.\n *\n * MCP's HTTP server and the Agent App browser transport have different wire protocols, but both need\n * the same fail-closed rules when reading an untrusted stream. Keeping this small policy here avoids\n * coupling either adapter to the other while making the limit and cancellation semantics identical.\n */"
+  },
   {
     "name": "maxClassification",
     "kind": "function",
@@ -9258,7 +9644,7 @@
     "name": "McpAppBridge",
     "kind": "interface",
     "package": "@nifrajs/mcp",
-    "signature": "export interface McpAppBridge {\n    /** Latest `structuredContent` the host pushed (or `null` before the first result). */\n    data: unknown;\n    /** Register a callback for `structuredContent` - fired immediately if data already arrived, then on\n     * every later `ui/notifications/tool-result`. The common case: `mcpApp.onData(render)`. */\n    onData(cb: (data: unknown) => void): void;\n    /** Register a callback for the raw tool-call arguments (`ui/notifications/tool-input`). */\n    onInput(cb: (args: unknown) => void): void;\n    /** Latest theme the host pushed (`{ mode, tokens }`), or `null` before the first push. */\n    theme: unknown;\n    /** Register a callback for host theme pushes. The bridge ALSO auto-applies the tokens to the document\n     * root (shadcn semantic vars + `color-scheme`/`data-theme`), so most widgets need no theme code. */\n    onTheme(cb: (theme: unknown) => void): void;\n    /** Invoke a tool back through the host; resolves with the tools/call result. */\n    callTool(name: string, args?: Record<string, unknown>): Promise<unknown>;\n}",
+    "signature": "export interface McpAppBridge {\n    /** Latest `structuredContent` the host pushed (or `null` before the first result). */\n    data: unknown;\n    /** Register a callback for `structuredContent` - fired immediately if data already arrived, then on\n     * every later `ui/notifications/tool-result`. The common case: `mcpApp.onData(render)`. */\n    onData(cb: (data: unknown) => void): void;\n    /** Register a callback for the raw tool-call arguments (`ui/notifications/tool-input`). */\n    onInput(cb: (args: unknown) => void): void;\n    /** Latest theme the host pushed (`{ mode, tokens }`), or `null` before the first push. */\n    theme: unknown;\n    /** Register a callback for host theme pushes. The bridge ALSO auto-applies the tokens to the document\n     * root (shadcn semantic vars + `color-scheme`/`data-theme`), so most widgets need no theme code. */\n    onTheme(cb: (theme: unknown) => void): void;\n    /** Invoke a tool back through the host; resolves with the tools/call result. */\n    callTool(name: string, args?: Record<string, unknown>): Promise<unknown>;\n    /** Reject pending calls when the embedding host tears down the widget. */\n    disconnect(reason?: string): void;\n}",
     "doc": "/** The author-facing global injected into a widget. Kept minimal and stable. */"
   },
   {
@@ -9298,13 +9684,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    /**\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}"
+    "signature": "export interface McpHttpOptions {\n    /** Maximum JSON-RPC request body size in bytes. Default 1 MB. */\n    readonly maxBodyBytes?: number;\n    /** Maximum serialized JSON-RPC response or SSE frame size. Default 1 MB. */\n    readonly maxResponseBytes?: 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    /** Explicitly expose a secret-free, unauthenticated server to browser clients from any origin. */\n    readonly allowAnyOrigin?: boolean;\n    /** Origin allowlist for the DNS-rebinding guard. When set, only exact origins are accepted. */\n    readonly allowedOrigins?: readonly string[];\n    /**\n     * Shared request registry for one authenticated MCP session. Pass the same state to the\n     * request that starts a tool call and its `notifications/cancelled` request. Do not share one\n     * state across unrelated callers unless the surrounding authorization boundary makes their\n     * request-id namespace exclusive.\n     */\n    readonly state?: McpProtocolState;\n    /**\n     * Resolve a session-scoped request registry after authorization. This is the preferred seam for\n     * multi-user HTTP hosts: bind the returned state to the authenticated caller/session and return\n     * `undefined` for stateless requests. A resolver failure fails closed with a generic denial.\n     */\n    readonly resolveState?: (request: Request, message: JsonRpcRequest) => McpProtocolState | undefined | Promise<McpProtocolState | undefined>;\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    /**\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}"
+    "signature": "export interface McpHttpOptions {\n    /** Maximum JSON-RPC request body size in bytes. Default 1 MB. */\n    readonly maxBodyBytes?: number;\n    /** Maximum serialized JSON-RPC response or SSE frame size. Default 1 MB. */\n    readonly maxResponseBytes?: 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    /** Explicitly expose a secret-free, unauthenticated server to browser clients from any origin. */\n    readonly allowAnyOrigin?: boolean;\n    /** Origin allowlist for the DNS-rebinding guard. When set, only exact origins are accepted. */\n    readonly allowedOrigins?: readonly string[];\n    /**\n     * Shared request registry for one authenticated MCP session. Pass the same state to the\n     * request that starts a tool call and its `notifications/cancelled` request. Do not share one\n     * state across unrelated callers unless the surrounding authorization boundary makes their\n     * request-id namespace exclusive.\n     */\n    readonly state?: McpProtocolState;\n    /**\n     * Resolve a session-scoped request registry after authorization. This is the preferred seam for\n     * multi-user HTTP hosts: bind the returned state to the authenticated caller/session and return\n     * `undefined` for stateless requests. A resolver failure fails closed with a generic denial.\n     */\n    readonly resolveState?: (request: Request, message: JsonRpcRequest) => McpProtocolState | undefined | Promise<McpProtocolState | undefined>;\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",
@@ -9375,7 +9761,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, 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    /**\n     * Release server-owned resources, when the implementation has any (for example a database worker).\n     * Calling it more than once is safe. The base MCP server has nothing to release and omits this hook.\n     */\n    readonly close?: () => Promise<void>;\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\" | \"state\" | \"resolveState\">): 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    /**\n     * Release server-owned resources, when the implementation has any (for example a database worker).\n     * Calling it more than once is safe. The base MCP server has nothing to release and omits this hook.\n     */\n    readonly close?: () => Promise<void>;\n}"
   },
   {
     "name": "McpServerConfig",
@@ -9608,7 +9994,7 @@
     "name": "MemoryIdempotencyStore",
     "kind": "class",
     "package": "@nifrajs/middleware",
-    "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}",
+    "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, reservation: string, record: IdempotencyRecord, ttlMs: number): Promise<boolean>;\n    release(key: string, reservation: string): Promise<boolean>;\n}",
     "doc": "/** In-process store. Refuses to run in production unless explicitly allowed (per-instance ⇒ no cross-instance dedupe). */"
   },
   {
@@ -10057,7 +10443,7 @@
     "name": "MountA2AOptions",
     "kind": "interface",
     "package": "@nifrajs/a2a",
-    "signature": "export interface MountA2AOptions<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1> {\n    readonly agent: AgentDefinition<InputSchema, OutputSchema>;\n    readonly card: A2ACardInfo;\n    /** JSON-RPC endpoint path. Default `/a2a`. */\n    readonly path?: string;\n    /** Agent card path. Default `/.well-known/agent-card.json`. */\n    readonly cardPath?: string;\n    /** Bounded run length passed to the runner. */\n    readonly maxTurns?: number;\n    /** Maximum request body size in bytes. Default 1_000_000. */\n    readonly maxBodyBytes?: number;\n    /** Prototype-poisoning policy for the framing lane. Default `\"reject\"`. */\n    readonly protoPoisoning?: ProtoPoisoning;\n    /**\n     * Build the ports for one request - the model, durable state store, approval transport,\n     * capabilities, and budgets. Receives the route context so the caller can scope every port to the\n     * request subject.\n     */\n    readonly ports: (c: A2ARouteContext) => AgentPorts | Promise<AgentPorts>;\n}"
+    "signature": "export interface MountA2AOptions<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1> {\n    readonly agent: AgentDefinition<InputSchema, OutputSchema>;\n    readonly card: A2ACardInfo;\n    /** JSON-RPC endpoint path. Default `/a2a`. */\n    readonly path?: string;\n    /** Agent card path. Default `/.well-known/agent-card.json`. */\n    readonly cardPath?: string;\n    /** Bounded run length passed to the runner. */\n    readonly maxTurns?: number;\n    /** Maximum request body size in bytes. Default 1_000_000. */\n    readonly maxBodyBytes?: number;\n    /** Prototype-poisoning policy for the framing lane. Default `\"reject\"`. */\n    readonly protoPoisoning?: ProtoPoisoning;\n    /** Maximum total UTF-8 bytes emitted by one response. Default 4 MiB. */\n    readonly maxOutputBytes?: number;\n    /**\n     * Build the ports for one request - the model, durable state store, approval transport,\n     * capabilities, and budgets. Receives the route context so the caller can scope every port to the\n     * request subject.\n     */\n    readonly ports: (c: A2ARouteContext) => AgentPorts | Promise<AgentPorts>;\n}"
   },
   {
     "name": "mountAgent",
@@ -10083,7 +10469,7 @@
     "name": "MountAgUIOptions",
     "kind": "interface",
     "package": "@nifrajs/ag-ui",
-    "signature": "export interface MountAgUIOptions<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1> {\n    readonly agent: AgentDefinition<InputSchema, OutputSchema>;\n    /** Endpoint path. Default `/agui`. */\n    readonly path?: string;\n    /** Bounded run length passed to the runner. */\n    readonly maxTurns?: number;\n    /** Maximum request body size in bytes. Default 1_000_000. */\n    readonly maxBodyBytes?: number;\n    /** Prototype-poisoning policy for the framing lane. Default `\"reject\"`. */\n    readonly protoPoisoning?: ProtoPoisoning;\n    /**\n     * Build the ports for one request - the model, durable state store, approval transport,\n     * capabilities, and budgets. Receives the route context so the caller can scope every port to\n     * the request subject, and the run context carrying the turn id and the shared UI state channel.\n     */\n    readonly ports: (c: AgUIRouteContext, run: AgUIRunContext) => AgentPorts | Promise<AgentPorts>;\n    /**\n     * Evidence log making the SSE stream resumable via `Last-Event-ID`. The in-memory reference\n     * (`createMemoryAgentEvidenceLog`) is single-process; a durable log is an adapter concern.\n     */\n    readonly evidenceLog?: AgentEvidenceLog;\n    /**\n     * Emit a `MESSAGES_SNAPSHOT` (the request's `messages` plus the assistant output message)\n     * before `RUN_FINISHED` on a successful completion. Default `false`: the snapshot echoes\n     * client-sent message payloads, and terminal events are persisted to the evidence log when one\n     * is configured - leave it off unless the client relies on an authoritative snapshot.\n     */\n    readonly emitMessagesSnapshot?: boolean;\n}"
+    "signature": "export interface MountAgUIOptions<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1> {\n    readonly agent: AgentDefinition<InputSchema, OutputSchema>;\n    /** Endpoint path. Default `/agui`. */\n    readonly path?: string;\n    /** Bounded run length passed to the runner. */\n    readonly maxTurns?: number;\n    /** Maximum request body size in bytes. Default 1_000_000. */\n    readonly maxBodyBytes?: number;\n    /** Prototype-poisoning policy for the framing lane. Default `\"reject\"`. */\n    readonly protoPoisoning?: ProtoPoisoning;\n    /** Maximum total UTF-8 bytes emitted by one SSE response. Default 4 MiB. */\n    readonly maxOutputBytes?: number;\n    /**\n     * Build the ports for one request - the model, durable state store, approval transport,\n     * capabilities, and budgets. Receives the route context so the caller can scope every port to\n     * the request subject, and the run context carrying the turn id and the shared UI state channel.\n     */\n    readonly ports: (c: AgUIRouteContext, run: AgUIRunContext) => AgentPorts | Promise<AgentPorts>;\n    /**\n     * Evidence log making the SSE stream resumable via `Last-Event-ID`. The in-memory reference\n     * (`createMemoryAgentEvidenceLog`) is single-process; a durable log is an adapter concern.\n     */\n    readonly evidenceLog?: AgentEvidenceLog;\n    /**\n     * Emit a `MESSAGES_SNAPSHOT` (the request's `messages` plus the assistant output message)\n     * before `RUN_FINISHED` on a successful completion. Default `false`: the snapshot echoes\n     * client-sent message payloads, and terminal events are persisted to the evidence log when one\n     * is configured - leave it off unless the client relies on an authoritative snapshot.\n     */\n    readonly emitMessagesSnapshot?: boolean;\n}"
   },
   {
     "name": "mountGraphql",
@@ -10528,7 +10914,7 @@
     "name": "NifraBackend",
     "kind": "class",
     "package": "@nifrajs/coding-agent",
-    "signature": "export declare class NifraBackend implements AgentBackend {\n    readonly info: AgentBackendInfo;\n    private readonly options;\n    private readonly sessions;\n    private readonly pendingApprovals;\n    constructor(options: NifraBackendOptions);\n    createSession(input: CreateSessionInput): Promise<AgentSessionSnapshot>;\n    send(input: SendMessageInput): AsyncIterable<AgentEvent>;\n    cancel(sessionId: string, reason?: string): Promise<void>;\n    snapshot(sessionId: string): Promise<AgentSessionSnapshot>;\n    reload(sessionId: string): Promise<ReloadResult>;\n    resolveApproval(sessionId: string, approvalId: string, approved: boolean, reason?: string): Promise<boolean | undefined>;\n    close(sessionId: string): Promise<void>;\n    private run;\n    private consumeModel;\n    private finish;\n    private requestApproval;\n    private settleApproval;\n    private emit;\n    private update;\n    private requireSession;\n    private now;\n}",
+    "signature": "export declare class NifraBackend implements AgentBackend {\n    readonly info: AgentBackendInfo;\n    private readonly options;\n    private readonly sessions;\n    private readonly pendingApprovals;\n    constructor(options: NifraBackendOptions);\n    createSession(input: CreateSessionInput): Promise<AgentSessionSnapshot>;\n    send(input: SendMessageInput): AsyncIterable<AgentEvent>;\n    cancel(sessionId: string, reason?: string): Promise<void>;\n    snapshot(sessionId: string): Promise<AgentSessionSnapshot>;\n    reload(sessionId: string): Promise<ReloadResult>;\n    resolveApproval(sessionId: string, approvalId: string, approved: boolean, reason?: string): Promise<boolean | undefined>;\n    close(sessionId: string): Promise<void>;\n    private run;\n    private consumeModel;\n    private finish;\n    private requestApproval;\n    private settleApproval;\n    private cancelTurn;\n    private clearTurnSignal;\n    private clearTurn;\n    private isCurrentTurn;\n    private assertCurrentTurn;\n    private emit;\n    private update;\n    private requireSession;\n    private now;\n}",
     "doc": "/**\n * Small provider port for a future Nifra-native backend.\n *\n * It deliberately knows only messages, tools, and the protocol. Provider SDKs, credentials, UI,\n * and framework packages stay outside this module. A model may return one response or stream\n * deltas followed by a final response.\n */"
   },
   {
@@ -10785,6 +11171,13 @@
     "package": "@nifrajs/node",
     "signature": "export interface NodeServer {\n    /** The bound port (resolved when `port: 0` is requested). */\n    readonly port: number;\n    /**\n     * Stop accepting connections, let in-flight requests drain (up to `drainMs`), then\n     * force-close stragglers + idle keep-alives. Mirrors nifra's Bun `stop()`.\n     */\n    stop(options?: {\n        drainMs?: number;\n    }): Promise<void>;\n}"
   },
+  {
+    "name": "NonceResolver",
+    "kind": "type",
+    "package": "@nifrajs/web",
+    "signature": "export type NonceResolver<Env = unknown> = (ctx: {\n    readonly request: Request;\n    readonly env: Env;\n}) => string | undefined | Promise<string | undefined>;",
+    "doc": "/** Resolve the CSP nonce for one document request. Return `undefined` to omit nonce attributes. */"
+  },
   {
     "name": "noopArtifactPort",
     "kind": "function",
@@ -10792,6 +11185,13 @@
     "signature": "export declare function noopArtifactPort(): ArtifactPort;",
     "doc": "/**\n * Hashes the payload for a content-free {@link ArtifactRef}, then discards the bytes. The default\n * port: public code sees only the digest, size, and coordinates - never the payload.\n */"
   },
+  {
+    "name": "normalizeCssLoading",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function normalizeCssLoading(value: unknown): CssLoadingMode;",
+    "doc": "/** Runtime validation for JavaScript callers, generated manifests, and hand-authored integrations. */"
+  },
   {
     "name": "normalizeEffectMetadata",
     "kind": "function",
@@ -10928,6 +11328,13 @@
     "package": "@nifrajs/schema",
     "signature": "export interface OpenAPIDocument {\n    readonly openapi: \"3.1.0\";\n    readonly info: OpenAPIInfo;\n    readonly paths: Record<string, Record<string, OpenAPIOperation>>;\n    readonly servers?: readonly OpenAPIServer[];\n    readonly tags?: readonly OpenAPITag[];\n    readonly security?: readonly SecurityRequirement[];\n    readonly components?: OpenAPIComponents;\n}"
   },
+  {
+    "name": "OpenAPIImportError",
+    "kind": "class",
+    "package": "@nifrajs/schema",
+    "signature": "export declare class OpenAPIImportError extends Error {\n    constructor(message: string);\n}",
+    "doc": "/**\n * OpenAPI 3.x inventory import - the structural half of an export/import roundtrip.\n *\n * `toOpenAPI` renders a Nifra app (or contract) as an OpenAPI 3.1 document. This module reads such\n * a document back into a canonical route inventory: method, Nifra-templated path (`{id}` back to\n * `:id`), required query names, body presence, and response statuses. `diffOpenApiInventory` then\n * compares two inventories, so `export -> import -> diff` proves the cycle survives in CI.\n *\n * Deliberate boundaries, all fail-closed or explicitly documented:\n *\n * - Offline and ref-opaque. `$ref`s are never resolved and nothing is fetched. A `$ref` parameter\n *   cannot yield a name without resolution, so it throws with the location; `$ref` bodies and\n *   response schemas only assert presence, which needs no resolution.\n * - No schema reconstruction. JSON Schema is not turned back into `t` builders here - that is a\n *   separate codegen step needing consumer evidence. The inventory proves the route table survived;\n *   field-level types ride along in the source document, not in this comparison.\n * - No auth interpretation. `security`, `securitySchemes`, and `servers` are never read. Importing\n *   an API must not silently adopt its auth model.\n * - Templated paths degrade conservatively. `/files/*path` exports as `/files/{path}`, indistinguishable\n *   from a single-segment `:path`. Import yields `:path` and records a note for every OpenAPI template;\n *   a greedy remainder needs a manual `*path` rewrite.\n * - Nifra parameter names follow `/^[A-Za-z_][A-Za-z0-9_]*$/`; `__proto__`, `constructor`, and\n *   `prototype` are rejected. Mixed templates are converted only when their boundaries are representable.\n * - Bounded. Path/operation/parameter counts are capped (`ImportOpenAPIOptions`); a document over\n *   the caps throws rather than allocating.\n */"
+  },
   {
     "name": "OpenApiInfo",
     "kind": "interface",
@@ -10941,6 +11348,12 @@
     "signature": "export interface OpenAPIInfo {\n    readonly title: string;\n    readonly version: string;\n    readonly description?: string;\n}",
     "doc": "/**\n * OpenAPI 3.1 generation. We model a practical slice of the spec - enough to feed Swagger UI / codegen\n * and to validate structurally: paths, parameters, request bodies, responses (incl. non-200 and\n * non-JSON), tags, security, servers, and `$ref` reuse via `components.schemas`.\n *\n * Schemas carry full detail only for `t`/TypeBox inputs (they expose a JSON Schema); a BYO Standard\n * Schema validates at runtime but exposes no JSON Schema, so its route is emitted without body/response\n * detail. A **contract** is richest - its operations carry `response`, `tags`, `security`, additional\n * `responses`, etc.; an **app** emits request shapes + a generic `200` (an inline handler has no\n * response *schema* to serialize), enrichable via `options.operations`.\n */"
   },
+  {
+    "name": "OpenApiInventoryDrift",
+    "kind": "interface",
+    "package": "@nifrajs/schema",
+    "signature": "export interface OpenApiInventoryDrift {\n    /** `METHOD /path`, or `inventory` for route-set level drift. */\n    readonly route: string;\n    readonly message: string;\n}"
+  },
   {
     "name": "OpenApiOptions",
     "kind": "interface",
@@ -11235,14 +11648,14 @@
     "kind": "function",
     "package": "@nifrajs/core",
     "signature": "export declare function parseCookies(header: string | null | undefined): Record<string, string>;",
-    "doc": "/** Parse a request `Cookie` header into a name→value map (values URL-decoded). Unparseable pairs are\n * skipped rather than throwing - a junk `Cookie` header shouldn't fail the request.\n *\n * Hand-rolled index walk instead of `split(\";\")` + `trim()` chains: those allocated an array + up\n * to three substrings per pair and showed up at ~6% of a realistic (auth + cookie) request. Same\n * semantics, two slices per pair, no intermediate array. */"
+    "doc": "/** Parse a request `Cookie` header into a name→value map (values URL-decoded). Unparseable pairs are\n * skipped rather than throwing - a junk `Cookie` header shouldn't fail the request.\n *\n * Hand-rolled index walk instead of `split(\";\")` + `trim()` chains: those allocated an array + up\n * to three substrings per pair and showed up at ~6% of a realistic (auth + cookie) request. Same\n * semantics, two slices per pair, no intermediate array. Duplicate names use the first value\n * deterministically; security-sensitive callers can use {@link hasDuplicateCookie} and fail closed. */"
   },
   {
     "name": "parseCookies",
     "kind": "function",
     "package": "nifra",
     "signature": "export declare function parseCookies(header: string | null | undefined): Record<string, string>;",
-    "doc": "/** Parse a request `Cookie` header into a name→value map (values URL-decoded). Unparseable pairs are\n * skipped rather than throwing - a junk `Cookie` header shouldn't fail the request.\n *\n * Hand-rolled index walk instead of `split(\";\")` + `trim()` chains: those allocated an array + up\n * to three substrings per pair and showed up at ~6% of a realistic (auth + cookie) request. Same\n * semantics, two slices per pair, no intermediate array. */"
+    "doc": "/** Parse a request `Cookie` header into a name→value map (values URL-decoded). Unparseable pairs are\n * skipped rather than throwing - a junk `Cookie` header shouldn't fail the request.\n *\n * Hand-rolled index walk instead of `split(\";\")` + `trim()` chains: those allocated an array + up\n * to three substrings per pair and showed up at ~6% of a realistic (auth + cookie) request. Same\n * semantics, two slices per pair, no intermediate array. Duplicate names use the first value\n * deterministically; security-sensitive callers can use {@link hasDuplicateCookie} and fail closed. */"
   },
   {
     "name": "parseCron",
@@ -11309,7 +11722,7 @@
     "name": "parseEventStream",
     "kind": "function",
     "package": "@nifrajs/agent-app",
-    "signature": "export declare function parseEventStream(body: ReadableStream<Uint8Array>, method: string): AsyncIterable<AgentEvent>;",
+    "signature": "export declare function parseEventStream(body: ReadableStream<Uint8Array>, method: string, maxFrameBytes?: number): AsyncIterable<AgentEvent>;",
     "doc": "/** Parse an SSE body into protocol events, skipping any frame whose data is not a valid event. */"
   },
   {
@@ -11347,6 +11760,13 @@
     "signature": "export declare function parseManifestClientEntry(source: string): string | undefined;",
     "doc": "/** The baked `clientEntry` URL in a committed server-manifest, or `undefined` if absent. Pure. */"
   },
+  {
+    "name": "parseManifestCssLoading",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function parseManifestCssLoading(source: string): CssLoadingMode | undefined;",
+    "doc": "/** The baked framework stylesheet activation mode, or `undefined` for an older manifest. Pure. */"
+  },
   {
     "name": "parseManifestRouteFiles",
     "kind": "function",
@@ -11402,6 +11822,13 @@
     "package": "@nifrajs/core",
     "signature": "export declare function parseReplayFile(value: unknown): ReplayFile;"
   },
+  {
+    "name": "parseReviewReport",
+    "kind": "function",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare function parseReviewReport(input: unknown): Promise<ReviewReport>;",
+    "doc": "/** Parse a JSON string or unknown value into a bounded, deeply frozen review report. */"
+  },
   {
     "name": "parseRubricVerdict",
     "kind": "function",
@@ -11503,6 +11930,13 @@
     "signature": "export declare function parseTraceparent(header: string | null | undefined): ParsedTraceparent | null;",
     "doc": "/**\n * Parse a `traceparent` header, or `null` if it's absent/malformed/version-unknown - per the spec,\n * a bad header means \"start a fresh trace\", never an error. Only version `00` is accepted.\n */"
   },
+  {
+    "name": "parseTransportContentLength",
+    "kind": "function",
+    "package": "@nifrajs/agent-protocol",
+    "signature": "export declare function parseTransportContentLength(value: string | null): number | undefined;",
+    "doc": "/** Parse a decimal Content-Length without allowing malformed or unsafe values to pass as a size. */"
+  },
   {
     "name": "pathnameOf",
     "kind": "function",
@@ -11532,27 +11966,27 @@
     "name": "PiBackend",
     "kind": "class",
     "package": "@nifrajs/coding-agent",
-    "signature": "export declare class PiBackend implements AgentBackend {\n    readonly info: AgentBackendInfo;\n    private readonly options;\n    private readonly sessions;\n    constructor(options?: PiBackendOptions);\n    createSession(input: CreateSessionInput): Promise<AgentSessionSnapshot>;\n    send(input: SendMessageInput): AsyncIterable<AgentEvent>;\n    cancel(sessionId: string, reason?: string): Promise<void>;\n    snapshot(sessionId: string): Promise<AgentSessionSnapshot>;\n    reload(sessionId: string): Promise<ReloadResult>;\n    resolveApproval(sessionId: string, approvalId: string, approved: boolean): Promise<boolean | undefined>;\n    close(sessionId: string): Promise<void>;\n    private requireSession;\n    private spawnProcess;\n    private attachProcess;\n    private readStdout;\n    private readStderr;\n    private consumeText;\n    private consumeRecord;\n    private emit;\n    private updateSnapshot;\n    private failActive;\n    private finishTurn;\n}",
+    "signature": "export declare class PiBackend implements AgentBackend {\n    readonly info: AgentBackendInfo;\n    private readonly options;\n    private readonly maxRecordBytes;\n    private readonly maxMessageChars;\n    private readonly sessions;\n    constructor(options?: PiBackendOptions);\n    createSession(input: CreateSessionInput): Promise<AgentSessionSnapshot>;\n    send(input: SendMessageInput): AsyncIterable<AgentEvent>;\n    cancel(sessionId: string, reason?: string): Promise<void>;\n    snapshot(sessionId: string): Promise<AgentSessionSnapshot>;\n    reload(sessionId: string): Promise<ReloadResult>;\n    resolveApproval(sessionId: string, approvalId: string, approved: boolean): Promise<boolean | undefined>;\n    close(sessionId: string): Promise<void>;\n    private requireSession;\n    private spawnProcess;\n    private attachProcess;\n    private readStdout;\n    private readStderr;\n    private consumeText;\n    private consumeRecord;\n    private emit;\n    private updateSnapshot;\n    private failActive;\n    private finishTurn;\n    private cancelTurn;\n    private clearTurnSignal;\n    private clearTurn;\n}",
     "doc": "/**\n * Spawn Pi in its documented JSONL RPC mode and translate its events into the Nifra protocol.\n *\n * This adapter intentionally talks to the public Pi process protocol instead of importing Pi into\n * any Nifra framework package. A future SDK adapter can implement the same AgentBackend contract.\n */"
   },
   {
     "name": "PiBackend",
     "kind": "class",
     "package": "@nifrajs/pi",
-    "signature": "export declare class PiBackend implements AgentBackend {\n    readonly info: AgentBackendInfo;\n    private readonly options;\n    private readonly sessions;\n    constructor(options?: PiBackendOptions);\n    createSession(input: CreateSessionInput): Promise<AgentSessionSnapshot>;\n    send(input: SendMessageInput): AsyncIterable<AgentEvent>;\n    cancel(sessionId: string, reason?: string): Promise<void>;\n    snapshot(sessionId: string): Promise<AgentSessionSnapshot>;\n    reload(sessionId: string): Promise<ReloadResult>;\n    resolveApproval(sessionId: string, approvalId: string, approved: boolean): Promise<boolean | undefined>;\n    close(sessionId: string): Promise<void>;\n    private requireSession;\n    private spawnProcess;\n    private attachProcess;\n    private readStdout;\n    private readStderr;\n    private consumeText;\n    private consumeRecord;\n    private emit;\n    private updateSnapshot;\n    private failActive;\n    private finishTurn;\n}",
+    "signature": "export declare class PiBackend implements AgentBackend {\n    readonly info: AgentBackendInfo;\n    private readonly options;\n    private readonly maxRecordBytes;\n    private readonly maxMessageChars;\n    private readonly sessions;\n    constructor(options?: PiBackendOptions);\n    createSession(input: CreateSessionInput): Promise<AgentSessionSnapshot>;\n    send(input: SendMessageInput): AsyncIterable<AgentEvent>;\n    cancel(sessionId: string, reason?: string): Promise<void>;\n    snapshot(sessionId: string): Promise<AgentSessionSnapshot>;\n    reload(sessionId: string): Promise<ReloadResult>;\n    resolveApproval(sessionId: string, approvalId: string, approved: boolean): Promise<boolean | undefined>;\n    close(sessionId: string): Promise<void>;\n    private requireSession;\n    private spawnProcess;\n    private attachProcess;\n    private readStdout;\n    private readStderr;\n    private consumeText;\n    private consumeRecord;\n    private emit;\n    private updateSnapshot;\n    private failActive;\n    private finishTurn;\n    private cancelTurn;\n    private clearTurnSignal;\n    private clearTurn;\n}",
     "doc": "/**\n * Spawn Pi in its documented JSONL RPC mode and translate its events into the Nifra protocol.\n *\n * This adapter intentionally talks to the public Pi process protocol instead of importing Pi into\n * any Nifra framework package. A future SDK adapter can implement the same AgentBackend contract.\n */"
   },
   {
     "name": "PiBackendOptions",
     "kind": "interface",
     "package": "@nifrajs/coding-agent",
-    "signature": "export interface PiBackendOptions {\n    /** Defaults to `pi`, resolved through PATH. */\n    readonly command?: string;\n    /** Extra arguments appended after `--mode rpc`. */\n    readonly args?: readonly string[];\n    readonly env?: Readonly<Record<string, string | undefined>>;\n    readonly sessionDir?: string;\n    readonly noSession?: boolean;\n    /** Override the generated Pi flags for a test double or a compatible RPC executable. */\n    readonly rpcArgs?: readonly string[];\n    /**\n     * Reload transport. Pi's documented RPC protocol uses a slash command bridged by a tiny\n     * extension; compatible RPC implementations may opt into their legacy top-level command.\n     */\n    readonly reloadCommand?: \"restart\" | \"prompt\" | \"rpc\";\n    /** Load the tiny public-API reload bridge. Defaults to true for generated Pi processes. */\n    readonly enableReloadBridge?: boolean;\n    readonly maxEventQueueSize?: number;\n    /** Optional project instructions passed through Pi's documented append-system-prompt flag. */\n    readonly appendSystemPrompt?: string;\n    /** Opt-in loading of the separately packaged Nifra verification tools extension. */\n    readonly enableNifraTools?: boolean;\n}"
+    "signature": "export interface PiBackendOptions {\n    /** Defaults to `pi`, resolved through PATH. */\n    readonly command?: string;\n    /** Extra arguments appended after `--mode rpc`. */\n    readonly args?: readonly string[];\n    readonly env?: Readonly<Record<string, string | undefined>>;\n    readonly sessionDir?: string;\n    readonly noSession?: boolean;\n    /** Override the generated Pi flags for a test double or a compatible RPC executable. */\n    readonly rpcArgs?: readonly string[];\n    /**\n     * Reload transport. Pi's documented RPC protocol uses a slash command bridged by a tiny\n     * extension; compatible RPC implementations may opt into their legacy top-level command.\n     */\n    readonly reloadCommand?: \"restart\" | \"prompt\" | \"rpc\";\n    /** Load the tiny public-API reload bridge. Defaults to true for generated Pi processes. */\n    readonly enableReloadBridge?: boolean;\n    readonly maxEventQueueSize?: number;\n    /** Maximum UTF-8 bytes accepted for one Pi JSONL record. Defaults to 1 MiB. */\n    readonly maxRecordBytes?: number;\n    /** Maximum prompt characters accepted by the adapter. Defaults to 64 KiB. */\n    readonly maxMessageChars?: number;\n    /** Optional project instructions passed through Pi's documented append-system-prompt flag. */\n    readonly appendSystemPrompt?: string;\n    /** Opt-in loading of the separately packaged Nifra verification tools extension. */\n    readonly enableNifraTools?: boolean;\n}"
   },
   {
     "name": "PiBackendOptions",
     "kind": "interface",
     "package": "@nifrajs/pi",
-    "signature": "export interface PiBackendOptions {\n    /** Defaults to `pi`, resolved through PATH. */\n    readonly command?: string;\n    /** Extra arguments appended after `--mode rpc`. */\n    readonly args?: readonly string[];\n    readonly env?: Readonly<Record<string, string | undefined>>;\n    readonly sessionDir?: string;\n    readonly noSession?: boolean;\n    /** Override the generated Pi flags for a test double or a compatible RPC executable. */\n    readonly rpcArgs?: readonly string[];\n    /**\n     * Reload transport. Pi's documented RPC protocol uses a slash command bridged by a tiny\n     * extension; compatible RPC implementations may opt into their legacy top-level command.\n     */\n    readonly reloadCommand?: \"restart\" | \"prompt\" | \"rpc\";\n    /** Load the tiny public-API reload bridge. Defaults to true for generated Pi processes. */\n    readonly enableReloadBridge?: boolean;\n    readonly maxEventQueueSize?: number;\n    /** Optional project instructions passed through Pi's documented append-system-prompt flag. */\n    readonly appendSystemPrompt?: string;\n    /** Opt-in loading of the separately packaged Nifra verification tools extension. */\n    readonly enableNifraTools?: boolean;\n}"
+    "signature": "export interface PiBackendOptions {\n    /** Defaults to `pi`, resolved through PATH. */\n    readonly command?: string;\n    /** Extra arguments appended after `--mode rpc`. */\n    readonly args?: readonly string[];\n    readonly env?: Readonly<Record<string, string | undefined>>;\n    readonly sessionDir?: string;\n    readonly noSession?: boolean;\n    /** Override the generated Pi flags for a test double or a compatible RPC executable. */\n    readonly rpcArgs?: readonly string[];\n    /**\n     * Reload transport. Pi's documented RPC protocol uses a slash command bridged by a tiny\n     * extension; compatible RPC implementations may opt into their legacy top-level command.\n     */\n    readonly reloadCommand?: \"restart\" | \"prompt\" | \"rpc\";\n    /** Load the tiny public-API reload bridge. Defaults to true for generated Pi processes. */\n    readonly enableReloadBridge?: boolean;\n    readonly maxEventQueueSize?: number;\n    /** Maximum UTF-8 bytes accepted for one Pi JSONL record. Defaults to 1 MiB. */\n    readonly maxRecordBytes?: number;\n    /** Maximum prompt characters accepted by the adapter. Defaults to 64 KiB. */\n    readonly maxMessageChars?: number;\n    /** Optional project instructions passed through Pi's documented append-system-prompt flag. */\n    readonly appendSystemPrompt?: string;\n    /** Opt-in loading of the separately packaged Nifra verification tools extension. */\n    readonly enableNifraTools?: boolean;\n}"
   },
   {
     "name": "pickLanguage",
@@ -11813,24 +12247,111 @@
     "signature": "export declare const preactDedupePlugin: (from: string) => BunPlugin;"
   },
   {
-    "name": "PrerenderApp",
+    "name": "PredictedExecutionResult",
     "kind": "interface",
-    "package": "@nifrajs/web",
-    "signature": "export interface PrerenderApp {\n    fetch(req: Request): Response | Promise<Response>;\n}",
-    "doc": "/** Minimal app surface the driver needs - just a fetch handler (a built `createWebApp`). */"
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface PredictedExecutionResult<Output, State> {\n    readonly outcome: \"committed\" | \"rolled-back\" | \"conflicted\" | \"expired\" | \"stale\" | \"invalid\" | \"executed\";\n    readonly predictionId?: string;\n    readonly prediction?: AgentSurfacePrediction;\n    readonly tool?: ToolCallResult<Output>;\n    readonly snapshot: PredictionStoreSnapshot<State>;\n}"
   },
   {
-    "name": "PrerenderAppLike",
-    "kind": "interface",
-    "package": "@nifrajs/web",
-    "signature": "export interface PrerenderAppLike {\n    fetch(req: Request): Response | Promise<Response>;\n}",
-    "doc": "/** Minimal app surface `buildTarget`'s static path needs - a fetch handler (a built `createWebApp`). */"
+    "name": "PREDICTION_LAB_SEED",
+    "kind": "const",
+    "package": "@nifrajs/testing",
+    "signature": "export declare const PREDICTION_LAB_SEED = 1347568964;"
   },
   {
-    "name": "PrerenderEntry",
-    "kind": "interface",
-    "package": "@nifrajs/web",
-    "signature": "export interface PrerenderEntry {\n    /** The route pattern that was prerendered (e.g. `/`, `/about`). */\n    readonly path: string;\n    /** The written file, relative to `outDir` (e.g. `index.html`, `about/index.html`). */\n    readonly file: string;\n    /** Byte length of the written HTML. */\n    readonly bytes: number;\n    /** The loader-data file written alongside (`<path>/_data.json`) so a client soft-nav INTO this\n     * route skips the worker. Absent when the data-mode response is NDJSON (a deferred loader). */\n    readonly dataFile?: string;\n}"
+    "name": "predictionLabCaseIds",
+    "kind": "const",
+    "package": "@nifrajs/testing",
+    "signature": "export declare const predictionLabCaseIds: readonly string[];",
+    "doc": "/** Stable case IDs in run order. */"
+  },
+  {
+    "name": "PredictionLabContext",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface PredictionLabContext {\n    readonly seed: number;\n    readonly caseId: string;\n    readonly target: PredictionLabTarget;\n    readonly mutation?: string;\n}"
+  },
+  {
+    "name": "PredictionLabOptions",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface PredictionLabOptions {\n    /** Replayable seed. Prediction IDs and clocks derive from it deterministically. */\n    readonly seed?: number;\n    /** Replay only these stable case IDs. */\n    readonly only?: string | readonly string[];\n}"
+  },
+  {
+    "name": "PredictionLabReplay",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface PredictionLabReplay {\n    readonly seed: number;\n    readonly caseId: string;\n}"
+  },
+  {
+    "name": "PredictionLabReport",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface PredictionLabReport {\n    readonly ok: boolean;\n    readonly seed: number;\n    readonly results: readonly PredictionLabResult[];\n    readonly failures: readonly PredictionLabResult[];\n    readonly counts: {\n        readonly passed: number;\n        readonly failed: number;\n    };\n}"
+  },
+  {
+    "name": "PredictionLabResult",
+    "kind": "interface",
+    "package": "@nifrajs/testing",
+    "signature": "export interface PredictionLabResult {\n    readonly id: string;\n    readonly target: PredictionLabTarget;\n    readonly mutation?: string;\n    readonly ok: boolean;\n    readonly message: string;\n    readonly replay: PredictionLabReplay;\n}"
+  },
+  {
+    "name": "PredictionLabTarget",
+    "kind": "type",
+    "package": "@nifrajs/testing",
+    "signature": "export type PredictionLabTarget = \"prediction\" | \"projection\";",
+    "doc": "/**\n * Seeded hostile corpus for predictions and projections - the prediction-side sibling of\n * `adversarial.ts`.\n *\n * `adversarial.ts` proves HTTP body/query/response contracts with validator-proven hostile\n * mutations. This module proves the same shaped guarantees one layer up: the `@nifrajs/webmcp`\n * prediction store (stale versions, expiry, prototype-grafting patches, non-atomic patches,\n * commit conflicts, reconcile/tool rollback) and the WebMCP-plus-MCP projection of one\n * capability (the same witness accepted or rejected identically on both surfaces).\n *\n * Every case has a stable ID, every run carries its replay seed, and every clock is injected -\n * nothing reads `Date.now` or `crypto.randomUUID` implicitly. `only` replays a subset by ID.\n *\n * Deliberately out of scope: A2A and AG-UI projections. Neither package exposes a same-contract\n * projection from a tool/capability (`a2a` has `agentCard`/`mountA2A` at the protocol level; there\n * is no `capability -> a2a/ag-ui` seam), so a parity case here would invent the seam it claims to\n * test. Proposing such a seam needs consumer evidence first (N7), not a lab that assumes it.\n */"
+  },
+  {
+    "name": "PredictionPatchOperation",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "signature": "export type PredictionPatchOperation = {\n    readonly op: \"add\" | \"replace\";\n    readonly path: string;\n    readonly value: unknown;\n} | {\n    readonly op: \"remove\";\n    readonly path: string;\n};",
+    "doc": "/** The safe RFC 6902 subset accepted for speculative UI updates. */"
+  },
+  {
+    "name": "PredictionStore",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface PredictionStore<State> {\n    readonly snapshot: () => PredictionStoreSnapshot<State>;\n    readonly predict: (predictionId: string, prediction: AgentSurfacePrediction, now?: number) => PredictionStoreResult<State>;\n    readonly commit: (predictionId: string, authoritative: AgentSurfaceAuthoritativeState<State>, now?: number) => PredictionStoreResult<State>;\n    readonly rollback: (predictionId: string) => PredictionStoreResult<State>;\n    readonly expire: (now?: number) => readonly string[];\n    readonly subscribe: (listener: (event: PredictionStoreEvent<State>) => void) => () => void;\n}"
+  },
+  {
+    "name": "PredictionStoreEvent",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "signature": "export type PredictionStoreEvent<State> = {\n    readonly type: \"predicted\";\n    readonly predictionId: string;\n    readonly snapshot: PredictionStoreSnapshot<State>;\n} | {\n    readonly type: \"committed\";\n    readonly predictionId: string;\n    readonly snapshot: PredictionStoreSnapshot<State>;\n} | {\n    readonly type: \"rolled-back\";\n    readonly predictionId: string;\n    readonly snapshot: PredictionStoreSnapshot<State>;\n} | {\n    readonly type: \"conflicted\";\n    readonly predictionId: string;\n    readonly snapshot: PredictionStoreSnapshot<State>;\n} | {\n    readonly type: \"expired\";\n    readonly predictionId: string;\n    readonly snapshot: PredictionStoreSnapshot<State>;\n};"
+  },
+  {
+    "name": "PredictionStoreResult",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "signature": "export type PredictionStoreResult<State> = {\n    readonly outcome: \"predicted\" | \"committed\" | \"rolled-back\" | \"conflicted\" | \"expired\" | \"stale\" | \"invalid\" | \"missing\";\n    readonly predictionId: string;\n    readonly snapshot: PredictionStoreSnapshot<State>;\n};"
+  },
+  {
+    "name": "PredictionStoreSnapshot",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface PredictionStoreSnapshot<State> extends AgentSurfaceSnapshot<State> {\n    readonly authoritativeVersion: string;\n    readonly activePredictionIds: readonly string[];\n}"
+  },
+  {
+    "name": "PrerenderApp",
+    "kind": "interface",
+    "package": "@nifrajs/web",
+    "signature": "export interface PrerenderApp {\n    fetch(req: Request): Response | Promise<Response>;\n}",
+    "doc": "/** Minimal app surface the driver needs - just a fetch handler (a built `createWebApp`). */"
+  },
+  {
+    "name": "PrerenderAppLike",
+    "kind": "interface",
+    "package": "@nifrajs/web",
+    "signature": "export interface PrerenderAppLike {\n    fetch(req: Request): Response | Promise<Response>;\n}",
+    "doc": "/** Minimal app surface `buildTarget`'s static path needs - a fetch handler (a built `createWebApp`). */"
+  },
+  {
+    "name": "PrerenderEntry",
+    "kind": "interface",
+    "package": "@nifrajs/web",
+    "signature": "export interface PrerenderEntry {\n    /** The route pattern that was prerendered (e.g. `/`, `/about`). */\n    readonly path: string;\n    /** The written file, relative to `outDir` (e.g. `index.html`, `about/index.html`). */\n    readonly file: string;\n    /** Byte length of the written HTML. */\n    readonly bytes: number;\n    /** The loader-data file written alongside (`<path>/_data.json`) so a client soft-nav INTO this\n     * route skips the worker. Absent when the data-mode response is NDJSON (a deferred loader). */\n    readonly dataFile?: string;\n}"
   },
   {
     "name": "PrerenderOptions",
@@ -11966,7 +12487,7 @@
     "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}"
+    "signature": "export interface ProjectEvidenceOptions {\n    readonly assurance?: AssuranceReport;\n    readonly capabilities?: CapabilityAssuranceReport;\n    /**\n     * An existing reflection pass. Supplying it lets several offline projections share one pass\n     * without asking the runtime source for `.routes()` again. Validators are consumed only while\n     * building the token-only snapshot and never cross this seam.\n     */\n    readonly routes?: readonly ReflectedRoute[];\n    /** Optional static source locations keyed by `${METHOD}\\n${path}`. */\n    readonly sourceLocations?: ReadonlyMap<string, readonly ProjectEvidenceSourceLocation[]>;\n}"
   },
   {
     "name": "ProjectEvidenceRoute",
@@ -12003,7 +12524,7 @@
     "name": "ProjectFacts",
     "kind": "interface",
     "package": "@nifrajs/cli",
-    "signature": "export interface ProjectFacts {\n    readonly source: SourceIndex;\n    readonly routes: readonly StaticRouteFinding[];\n    readonly importGraph: readonly TransitiveServerImportFinding[];\n    readonly packages: ProjectPackageFacts;\n    readonly pipeline?: PipelineReport;\n    readonly policies: ProjectPolicyFacts;\n    readonly sourceFindings: ProjectSourceFindings;\n    readonly legacyDiagnostics: readonly CheckDiagnostic[];\n}"
+    "signature": "export interface ProjectFacts {\n    readonly source: SourceIndex;\n    readonly routes: readonly StaticRouteFinding[];\n    readonly importGraph: readonly TransitiveServerImportFinding[];\n    readonly packages: ProjectPackageFacts;\n    readonly pipeline?: PipelineReport;\n    readonly policies: ProjectPolicyFacts;\n    readonly check: ProjectCheckFacts;\n    readonly sourceFindings: ProjectSourceFindings;\n}"
   },
   {
     "name": "ProjectWorkGraphResult",
@@ -12293,6 +12814,13 @@
     "package": "@nifrajs/jobs",
     "signature": "export interface Queue {\n    /** Register a typed job. Throws now (not at run time) on a duplicate name. */\n    define<Payload>(name: string, definition: JobDefinition<Payload>): JobHandle<Payload>;\n    /** Enqueue by name (the {@link JobHandle} is the typed alternative). */\n    enqueue(name: string, payload: unknown, options?: EnqueueOptions): Promise<string>;\n    /** Run ONE poll round: lease up to `concurrency` due jobs, run them, await them. Returns the count run.\n     * Re-entrant-safe (a concurrent call returns the in-flight round). Used by `start()` and by Workers. */\n    process(): Promise<number>;\n    /** Process repeatedly until no job is due (one-shot batch drain). */\n    drain(): Promise<number>;\n    /** Start the background worker (Bun/Node/Deno). */\n    start(options?: WorkerOptions): Worker;\n    /** Current store counts. */\n    counts(): JobCounts | Promise<JobCounts>;\n    /** The underlying store (for dead-letter inspection, custom drivers). */\n    readonly store: JobStore;\n}"
   },
+  {
+    "name": "QueueHealth",
+    "kind": "interface",
+    "package": "@nifrajs/jobs",
+    "signature": "export interface QueueHealth {\n    readonly pending: number;\n    readonly active: number;\n    readonly dead: number;\n}",
+    "doc": "/** Queue health counters. A straight passthrough of `JobStore.counts()` - counters are safe. */"
+  },
   {
     "name": "QueueOptions",
     "kind": "interface",
@@ -12446,6 +12974,13 @@
     "package": "@nifrajs/coding-agent",
     "signature": "export declare function readBoundedText(stream: ReadableStream<Uint8Array> | null | undefined | number, maxBytes: number): Promise<BoundedText>;"
   },
+  {
+    "name": "readBoundedTransportBytes",
+    "kind": "function",
+    "package": "@nifrajs/agent-protocol",
+    "signature": "export declare function readBoundedTransportBytes(body: ReadableStream<Uint8Array>, maxBytes: number): Promise<BoundedTransportRead>;",
+    "doc": "/** Read a Web stream under one byte cap, canceling the source as soon as the cap is exceeded. */"
+  },
   {
     "name": "readCausalityHeaders",
     "kind": "function",
@@ -12523,6 +13058,12 @@
     "package": "@nifrajs/core",
     "signature": "export interface ReconciliationLeaseStore {\n    readonly durability?: \"memory\" | \"durable\";\n    acquire(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly now: number;\n        readonly leaseMs: number;\n    }): ReconciliationLease | undefined | Promise<ReconciliationLease | undefined>;\n    renew(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly token: string;\n        readonly now: number;\n        readonly leaseMs: number;\n    }): boolean | Promise<boolean>;\n    checkpoint(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly token: string;\n        readonly cursor?: string;\n    }): boolean | Promise<boolean>;\n    release(input: {\n        readonly name: string;\n        readonly owner: string;\n        readonly token: string;\n    }): boolean | Promise<boolean>;\n}"
   },
+  {
+    "name": "ReconciliationMode",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "signature": "export type ReconciliationMode = \"accept-server-state\" | \"reload\" | \"manual\";"
+  },
   {
     "name": "ReconciliationPage",
     "kind": "interface",
@@ -12680,6 +13221,13 @@
     "package": "@nifrajs/core",
     "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": "reflectedRoutesFromEvidence",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function reflectedRoutesFromEvidence(evidence: ProjectEvidenceSnapshot): readonly ReflectedRoute[];",
+    "doc": "/**\n * Adapt the canonical token-only snapshot to the runtime-reflection shape used by projections.\n * The returned schemas deliberately have no `standard` validator: this adapter is for offline\n * contract views, not request validation or mock generation.\n */"
+  },
   {
     "name": "ReflectedSchemaField",
     "kind": "interface",
@@ -12728,6 +13276,13 @@
     "signature": "export declare function registerSingleCopy(options?: SingleCopyOptions): SingleCopyPlan;",
     "doc": "/**\n * Install the plugin into the Bun RUNTIME. Import `@nifrajs/core/single-copy/register` from a\n * `bunfig.toml` preload rather than calling this from application code: a resolver installed from\n * inside a module cannot affect the imports that module already resolved.\n */"
   },
+  {
+    "name": "registerWebMcpTools",
+    "kind": "function",
+    "package": "@nifrajs/webmcp",
+    "signature": "export declare function registerWebMcpTools(capabilities: readonly AgentCapabilityReference[], target?: WebMcpTarget | undefined, options?: WebMcpExecutionOptions): Promise<WebMcpRegistrationReport>;",
+    "doc": "/** Register an explicit allowlist of capabilities, safely degrading on ordinary browsers. */"
+  },
   {
     "name": "Registry",
     "kind": "type",
@@ -12880,7 +13435,7 @@
     "name": "RenderPageOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface RenderPageOptions {\n    readonly adapter: RenderAdapter;\n    /** The layout chain to render - outermost layout → page (opaque; the adapter renders it). */\n    readonly chain: readonly unknown[];\n    /** The loader output for this request. */\n    readonly data: unknown;\n    /** An action's data return (POST only) - surfaced to the page as `actionData` + serialized\n     * for the client so post-POST hydration matches. Omit on GETs. */\n    readonly actionData?: unknown;\n    /**\n     * URL of the built client entry (loaded as a module script).\n     *\n     * Optional ONLY on a `hydrate: false` page, where there is no client takeover to feed and this value\n     * reaches no output at all. The union below is what enforces that: omitting it on a hydrating page\n     * stays a compile error rather than rendering `src=\"\"`.\n     */\n    readonly clientEntry?: string;\n    /** Chunk URLs for the **matched** route (its layout chain + own chunk) to `modulepreload` in the\n     * shell - so the route code downloads in parallel with the entry instead of after it\n     * (`buildClient`'s per-route map). Empty/omitted ⇒ only the entry is preloaded (unchanged). */\n    readonly preload?: readonly string[];\n    /** Stylesheet URLs for the **matched** route (its layout chain + own CSS, from `buildClient`'s\n     * `BuildManifest.css`) - injected as `<link rel=\"stylesheet\">` in `<head>` so styles arrive with the\n     * first paint (no FOUC). Rendered even on non-hydrated pages. Empty/omitted ⇒ none (unchanged). */\n    readonly styles?: readonly string[];\n    /** SSG: the prerendered-path set, serialized to `window.__NIFRA_PRERENDERED__` so the client fetches\n     * a static `_data.json` on soft-nav into a prerendered route. Empty/omitted ⇒ not injected. */\n    readonly prerenderedPaths?: readonly string[];\n    /** ISR: route freshness in seconds, emitted as the `x-nifra-isr-revalidate` header for a `withISR`\n     * wrapper to read. Omit ⇒ no header (the wrapper's default TTL applies). */\n    readonly revalidate?: number;\n    /** ISR invalidation tags emitted as a bounded `x-nifra-isr-tags` header. */\n    readonly revalidateTags?: readonly string[];\n    /** Matched route id; written to `window.__NIFRA_ROUTE__` so the client hydrates this chain. */\n    readonly routeId?: string;\n    /** The matched route's decoded path params - surfaced to the page as `params` (via {@link RenderProps})\n     * so an adapter's `useParams` is SSR-correct. Omit ⇒ `{}` (a route with no dynamic segments, or an\n     * error/404 render). */\n    readonly params?: Readonly<Record<string, string>>;\n    /** The request's `pathname + search` - surfaced as `path` (via {@link RenderProps}) so an adapter's\n     * `useLocation`/`useSearchParams` render the right URL server-side and hydrate without drift. Omit ⇒\n     * `\"\"`. */\n    readonly path?: string;\n    /** The route's validated search (`searchOf(mod.searchSchema, url.search)`, the same value handed to\n     * the loader as `ctx.search`), surfaced as `search` (via {@link RenderProps}) so an adapter's\n     * `useSearch` is SSR-correct. Omit ⇒ `{}` (a render with no search context). */\n    readonly search?: Record<string, unknown>;\n    /** Per-layout loader data, forwarded to the adapter as `RenderProps.layoutData`. Aligned with the\n     * chain's layout prefix; omitted when no layout in the chain has a loader. */\n    readonly layoutData?: readonly unknown[];\n    /** Dynamic-boundary states, forwarded to the adapter and serialized for hydration when present. */\n    readonly boundaries?: BoundaryStates;\n    /** HTTP status for the response (default 200; e.g. 404 for a not-found page). */\n    readonly status?: number;\n    /** Extra response headers - e.g. the `cache-control` a terminal status page wants. `content-type`\n     * is ignored (the document is always HTML) and the ISR freshness header is applied after these,\n     * so neither can be overridden from here. */\n    readonly headers?: HeadersLike;\n    /** Document title (fallback when `head.title` is unset). */\n    readonly title?: string;\n    /** Resolved route head - `title` overrides `title` above; `meta`/`link` render as managed\n     * (`data-nifra`) tags the client updates on navigation.\n     *\n     * **Head contract (the layout chain contributes).** `createWebApp` resolves this via\n     * {@link mergeHeads}: a route's head is its **layout chain's** `meta`/`head` exports merged with the\n     * page's. A `_layout.tsx` may `export const meta` (or `export function meta(args)`) - its tags land\n     * on every page below it (the home for `hreflang`, `preconnect`, a section-default `<title>`). The\n     * merge is **nearest-wins for scalars** (the page's `title` overrides an inner layout's, which\n     * overrides an outer one; an undefined page title keeps the layout's) and **concatenated for the\n     * `meta`/`link` arrays** (outermost layout first, page last). `<meta>`/`<link>` attributes pass a\n     * shared tag-specific allowlist (including inert `data-*` metadata) and values are escaped. */\n    readonly head?: Meta;\n    /** Id of the container wrapping the app markup (default `\"root\"`). A non-default id also gets\n     * {@link ROOT_ATTRIBUTE}, which is how the generated client entry finds the container to hydrate -\n     * the entry is built once and cannot know what a given render chose. */\n    readonly rootId?: string;\n    /** When `false`, emit a complete but **non-hydrated** document - no client entry script, data\n     * globals, or modulepreloads. Used for server-rendered `_error` pages: a terminal state that needs no\n     * client takeover, and it sidesteps an SSR/hydrate mismatch (the server rendered the boundary, not\n     * the page the client manifest maps this route id to). Default `true`. */\n    readonly hydrate?: boolean;\n    /** Island client bundles (`@nifrajs/web/islands`) to load as `<script type=\"module\">` in the document\n     * tail - emitted **regardless of `hydrate`**, so a static (`hydrate: false`) page can still mount\n     * no-framework islands. URLs are attribute-escaped. Empty/omitted ⇒ none (unchanged output). */\n    readonly islandScripts?: readonly string[];\n    /** CSP nonce applied to every framework-owned executable script in this document. */\n    readonly nonce?: string;\n    /**\n     * Advanced: a per-route slot the renderer fills with the request-invariant document pieces (shell\n     * prefix/suffix, tail statics) on the first render and reuses afterwards, skipping their re-assembly.\n     *\n     * Only pass a cache when every shell-shaping input is IDENTICAL across the requests sharing it:\n     * same `head` content (a static meta chain - never a `meta(data)` function), `title`, `styles`,\n     * `preload`, `islandScripts`, `clientEntry`, `rootId`, `hydrate`, and `prerenderedPaths`. Per-request\n     * values (`data`, `params`, `search`, `actionData`, `layoutData`, deferred state) are always assembled\n     * fresh and safe. A per-request `nonce` disables the cache automatically. `createWebApp` wires this\n     * per route, gated on the route + layout metas being static.\n     */\n    readonly assemblyCache?: RenderAssemblyCache;\n}"
+    "signature": "export interface RenderPageOptions {\n    readonly adapter: RenderAdapter;\n    /** The layout chain to render - outermost layout → page (opaque; the adapter renders it). */\n    readonly chain: readonly unknown[];\n    /** The loader output for this request. */\n    readonly data: unknown;\n    /** An action's data return (POST only) - surfaced to the page as `actionData` + serialized\n     * for the client so post-POST hydration matches. Omit on GETs. */\n    readonly actionData?: unknown;\n    /**\n     * URL of the built client entry (loaded as a module script).\n     *\n     * Optional ONLY on a `hydrate: false` page, where there is no client takeover to feed and this value\n     * reaches no output at all. The union below is what enforces that: omitting it on a hydrating page\n     * stays a compile error rather than rendering `src=\"\"`.\n     */\n    readonly clientEntry?: string;\n    /** Chunk URLs for the **matched** route (its layout chain + own chunk) to `modulepreload` in the\n     * shell - so the route code downloads in parallel with the entry instead of after it\n     * (`buildClient`'s per-route map). Empty/omitted ⇒ only the entry is preloaded (unchanged). */\n    readonly preload?: readonly string[];\n    /** Stylesheet URLs for the **matched** route (its layout chain + own CSS, from `buildClient`'s\n     * `BuildManifest.css`) - injected as `<link rel=\"stylesheet\">` in `<head>` so styles arrive with the\n     * first paint (no FOUC). Rendered even on non-hydrated pages. Empty/omitted ⇒ none (unchanged). */\n    readonly styles?: readonly string[];\n    /**\n     * Activation policy for these framework-owned stylesheet links (default `\"blocking\"`). In\n     * `\"deferred\"` mode, hydrating pages fetch with `media=\"print\"` and the generated client promotes\n     * them to `media=\"all\"` after load/error/timeout. Non-hydrated pages remain blocking so JS-off pages\n     * and terminal documents are styled.\n     */\n    readonly cssLoading?: CssLoadingMode;\n    /** SSG: the prerendered-path set, serialized to `window.__NIFRA_PRERENDERED__` so the client fetches\n     * a static `_data.json` on soft-nav into a prerendered route. Empty/omitted ⇒ not injected. */\n    readonly prerenderedPaths?: readonly string[];\n    /** ISR: route freshness in seconds, emitted as the `x-nifra-isr-revalidate` header for a `withISR`\n     * wrapper to read. Omit ⇒ no header (the wrapper's default TTL applies). */\n    readonly revalidate?: number;\n    /** ISR invalidation tags emitted as a bounded `x-nifra-isr-tags` header. */\n    readonly revalidateTags?: readonly string[];\n    /** Matched route id; written to `window.__NIFRA_ROUTE__` so the client hydrates this chain. */\n    readonly routeId?: string;\n    /** The matched route's decoded path params - surfaced to the page as `params` (via {@link RenderProps})\n     * so an adapter's `useParams` is SSR-correct. Omit ⇒ `{}` (a route with no dynamic segments, or an\n     * error/404 render). */\n    readonly params?: Readonly<Record<string, string>>;\n    /** The request's `pathname + search` - surfaced as `path` (via {@link RenderProps}) so an adapter's\n     * `useLocation`/`useSearchParams` render the right URL server-side and hydrate without drift. Omit ⇒\n     * `\"\"`. */\n    readonly path?: string;\n    /** The route's validated search (`searchOf(mod.searchSchema, url.search)`, the same value handed to\n     * the loader as `ctx.search`), surfaced as `search` (via {@link RenderProps}) so an adapter's\n     * `useSearch` is SSR-correct. Omit ⇒ `{}` (a render with no search context). */\n    readonly search?: Record<string, unknown>;\n    /** Per-layout loader data, forwarded to the adapter as `RenderProps.layoutData`. Aligned with the\n     * chain's layout prefix; omitted when no layout in the chain has a loader. */\n    readonly layoutData?: readonly unknown[];\n    /** Dynamic-boundary states, forwarded to the adapter and serialized for hydration when present. */\n    readonly boundaries?: BoundaryStates;\n    /** HTTP status for the response (default 200; e.g. 404 for a not-found page). */\n    readonly status?: number;\n    /** Extra response headers - e.g. the `cache-control` a terminal status page wants. `content-type`\n     * is ignored (the document is always HTML) and the ISR freshness header is applied after these,\n     * so neither can be overridden from here. */\n    readonly headers?: HeadersLike;\n    /** Document title (fallback when `head.title` is unset). */\n    readonly title?: string;\n    /** Resolved route head - `title` overrides `title` above; `meta`/`link` render as managed\n     * (`data-nifra`) tags the client updates on navigation.\n     *\n     * **Head contract (the layout chain contributes).** `createWebApp` resolves this via\n     * {@link mergeHeads}: a route's head is its **layout chain's** `meta`/`head` exports merged with the\n     * page's. A `_layout.tsx` may `export const meta` (or `export function meta(args)`) - its tags land\n     * on every page below it (the home for `hreflang`, `preconnect`, a section-default `<title>`). The\n     * merge is **nearest-wins for scalars** (the page's `title` overrides an inner layout's, which\n     * overrides an outer one; an undefined page title keeps the layout's) and **concatenated for the\n     * `meta`/`link` arrays** (outermost layout first, page last). `<meta>`/`<link>` attributes pass a\n     * shared tag-specific allowlist (including inert `data-*` metadata) and values are escaped. */\n    readonly head?: Meta;\n    /** Id of the container wrapping the app markup (default `\"root\"`). A non-default id also gets\n     * {@link ROOT_ATTRIBUTE}, which is how the generated client entry finds the container to hydrate -\n     * the entry is built once and cannot know what a given render chose. */\n    readonly rootId?: string;\n    /** When `false`, emit a complete but **non-hydrated** document - no client entry script, data\n     * globals, or modulepreloads. Used for server-rendered `_error` pages: a terminal state that needs no\n     * client takeover, and it sidesteps an SSR/hydrate mismatch (the server rendered the boundary, not\n     * the page the client manifest maps this route id to). Default `true`. */\n    readonly hydrate?: boolean;\n    /** Island client bundles (`@nifrajs/web/islands`) to load as `<script type=\"module\">` in the document\n     * tail - emitted **regardless of `hydrate`**, so a static (`hydrate: false`) page can still mount\n     * no-framework islands. URLs are attribute-escaped. Empty/omitted ⇒ none (unchanged output). */\n    readonly islandScripts?: readonly string[];\n    /** CSP nonce applied to every framework-owned executable script in this document. Nonce-bearing\n     * documents are marked `private, no-store` so a request-specific nonce is never replayed. */\n    readonly nonce?: string;\n    /**\n     * Advanced: a per-route slot the renderer fills with the request-invariant document pieces (shell\n     * prefix/suffix, tail statics) on the first render and reuses afterwards, skipping their re-assembly.\n     *\n     * Only pass a cache when every shell-shaping input is IDENTICAL across the requests sharing it:\n     * same `head` content (a static meta chain - never a `meta(data)` function), `title`, `styles`,\n     * `cssLoading`, `preload`, `islandScripts`, `clientEntry`, `rootId`, `hydrate`, and `prerenderedPaths`.\n     * Per-request\n     * values (`data`, `params`, `search`, `actionData`, `layoutData`, deferred state) are always assembled\n     * fresh and safe. A per-request `nonce` disables the cache automatically. `createWebApp` wires this\n     * per route, gated on the route + layout metas being static.\n     */\n    readonly assemblyCache?: RenderAssemblyCache;\n}"
   },
   {
     "name": "renderPageResult",
@@ -12943,7 +13498,7 @@
     "name": "ReplayBackend",
     "kind": "class",
     "package": "@nifrajs/coding-agent",
-    "signature": "export declare class ReplayBackend implements AgentBackend {\n    readonly info: AgentBackendInfo;\n    private readonly events;\n    private readonly delayMs;\n    private readonly sessions;\n    constructor(options: ReplayBackendOptions);\n    createSession(input: CreateSessionInput): Promise<AgentSessionSnapshot>;\n    send(input: SendMessageInput): AsyncIterable<AgentEvent>;\n    cancel(sessionId: string, reason?: string): Promise<void>;\n    snapshot(sessionId: string): Promise<AgentSessionSnapshot>;\n    reload(sessionId: string): Promise<ReloadResult>;\n    close(sessionId: string): Promise<void>;\n    private replay;\n    private push;\n    private requireSession;\n}",
+    "signature": "export declare class ReplayBackend implements AgentBackend {\n    readonly info: AgentBackendInfo;\n    /** Serialized immutable source records; parsing per replay prevents caller/consumer mutation leaks. */\n    private readonly events;\n    private readonly delayMs;\n    private readonly sessions;\n    constructor(options: ReplayBackendOptions);\n    createSession(input: CreateSessionInput): Promise<AgentSessionSnapshot>;\n    send(input: SendMessageInput): AsyncIterable<AgentEvent>;\n    cancel(sessionId: string, reason?: string): Promise<void>;\n    snapshot(sessionId: string): Promise<AgentSessionSnapshot>;\n    reload(sessionId: string): Promise<ReloadResult>;\n    close(sessionId: string): Promise<void>;\n    private replay;\n    private cancelTurn;\n    private isCurrentTurn;\n    private clearTurn;\n    private push;\n    private requireSession;\n}",
     "doc": "/** Deterministic protocol backend for demos, CI, and UI regression tests. */"
   },
   {
@@ -13607,6 +14162,243 @@
     "signature": "export interface RevalidateResult<T> {\n    readonly __nifraRevalidate: readonly string[];\n    readonly data: T;\n}",
     "doc": "/** The wrapper `revalidate()` returns: the action's `data` plus the paths it changed. A plain tagged\n * shape (not a class) so `@nifrajs/client`'s `ActionData` can unwrap it structurally without importing\n * from `@nifrajs/web`. `createWebApp` strips the wrapper - the client receives `data` as the body and\n * the paths via the `X-Nifra-Revalidate` header. */"
   },
+  {
+    "name": "REVIEW_MAX_ARRAY_ITEMS",
+    "kind": "const",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare const REVIEW_MAX_ARRAY_ITEMS = 1024;"
+  },
+  {
+    "name": "REVIEW_MAX_BYTES",
+    "kind": "const",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare const REVIEW_MAX_BYTES: number;"
+  },
+  {
+    "name": "REVIEW_MAX_CODE_BYTES",
+    "kind": "const",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare const REVIEW_MAX_CODE_BYTES = 64;"
+  },
+  {
+    "name": "REVIEW_MAX_DEPTH",
+    "kind": "const",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare const REVIEW_MAX_DEPTH = 8;"
+  },
+  {
+    "name": "REVIEW_MAX_ID_BYTES",
+    "kind": "const",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare const REVIEW_MAX_ID_BYTES = 128;"
+  },
+  {
+    "name": "REVIEW_MAX_OBJECT_KEYS",
+    "kind": "const",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare const REVIEW_MAX_OBJECT_KEYS = 32;"
+  },
+  {
+    "name": "REVIEW_MAX_PATH_BYTES",
+    "kind": "const",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare const REVIEW_MAX_PATH_BYTES = 512;"
+  },
+  {
+    "name": "REVIEW_MAX_REF_BYTES",
+    "kind": "const",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare const REVIEW_MAX_REF_BYTES = 256;"
+  },
+  {
+    "name": "REVIEW_REPORT_VERSION",
+    "kind": "const",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare const REVIEW_REPORT_VERSION: 1;",
+    "doc": "/** Stable version of the content-free review report contract. */"
+  },
+  {
+    "name": "ReviewCategory",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewCategory = \"correctness\" | \"security\" | \"boundary\" | \"assurance\" | \"capability\" | \"contract\" | \"dependency\" | \"hydration\" | \"coverage\" | \"configuration\" | \"operational\";"
+  },
+  {
+    "name": "ReviewCheckId",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewCheckId = \"typecheck\" | \"typed-client\" | \"server-boundary\" | \"route-boundary\" | \"pipeline\" | \"security\" | \"route-assurance\" | \"capability-provenance\" | \"manifest\" | \"dependency\" | \"contract-witness\" | \"coverage\" | \"hydration\" | \"configuration\";"
+  },
+  {
+    "name": "ReviewCheckResult",
+    "kind": "interface",
+    "package": "@nifrajs/agent-review",
+    "signature": "export interface ReviewCheckResult {\n    readonly id: ReviewCheckId;\n    readonly required: boolean;\n    readonly status: ReviewCheckStatus;\n    /** Display-only timing bucket. It is deliberately excluded from report digests. */\n    readonly duration: ReviewDurationBucket;\n    readonly counts: ReviewCounts;\n    readonly findingIds: readonly string[];\n    readonly evidence: readonly ReviewEvidenceRef[];\n    readonly reasonCode?: ReviewReasonCode;\n}"
+  },
+  {
+    "name": "ReviewCheckStatus",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewCheckStatus = \"pass\" | \"fail\" | \"skipped\" | \"unavailable\" | \"error\";"
+  },
+  {
+    "name": "ReviewCounts",
+    "kind": "interface",
+    "package": "@nifrajs/agent-review",
+    "signature": "export interface ReviewCounts {\n    readonly findings: number;\n    readonly errors: number;\n    readonly warnings: number;\n    readonly info: number;\n    readonly outOfScope: number;\n}"
+  },
+  {
+    "name": "ReviewDurationBucket",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewDurationBucket = \"none\" | \"fast\" | \"standard\" | \"slow\" | \"timeout\";"
+  },
+  {
+    "name": "ReviewEvidenceRef",
+    "kind": "interface",
+    "package": "@nifrajs/agent-review",
+    "signature": "export interface ReviewEvidenceRef {\n    readonly source: ReviewEvidenceSource;\n    readonly token: string;\n    readonly digest: string;\n    readonly path?: string;\n}"
+  },
+  {
+    "name": "ReviewEvidenceSource",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewEvidenceSource = \"check\" | \"assurance\" | \"capability\" | \"manifest\" | \"contract\" | \"coverage\" | \"git-scope\" | \"collector\";"
+  },
+  {
+    "name": "ReviewExecutionErrorCode",
+    "kind": "type",
+    "package": "@nifrajs/coding-agent",
+    "signature": "export type ReviewExecutionErrorCode = \"timeout\" | \"output-truncated\" | \"invalid-report\" | \"spawn-failed\";"
+  },
+  {
+    "name": "ReviewExecutionResult",
+    "kind": "interface",
+    "package": "@nifrajs/coding-agent",
+    "signature": "export interface ReviewExecutionResult {\n    readonly name: \"review\";\n    readonly ok: boolean;\n    readonly status: number | null;\n    /** A parsed, content-free ReviewReport. Raw stdout/stderr is intentionally never returned. */\n    readonly report?: unknown;\n    readonly errorCode?: ReviewExecutionErrorCode;\n}"
+  },
+  {
+    "name": "ReviewFinding",
+    "kind": "interface",
+    "package": "@nifrajs/agent-review",
+    "signature": "export interface ReviewFinding {\n    readonly id: string;\n    readonly check: ReviewCheckId;\n    readonly code: string;\n    readonly severity: ReviewSeverity;\n    readonly category: ReviewCategory;\n    readonly location?: ReviewLocation;\n    readonly evidence: readonly ReviewEvidenceRef[];\n    readonly fix?: ReviewFixRef;\n}"
+  },
+  {
+    "name": "ReviewFixRecipeId",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewFixRecipeId = \"manifest.sync\" | \"workspace-dist.rebuild\";"
+  },
+  {
+    "name": "ReviewFixRef",
+    "kind": "interface",
+    "package": "@nifrajs/agent-review",
+    "signature": "export interface ReviewFixRef {\n    readonly recipe: ReviewFixRecipeId;\n}"
+  },
+  {
+    "name": "ReviewFixResult",
+    "kind": "interface",
+    "package": "@nifrajs/agent-review",
+    "signature": "export interface ReviewFixResult {\n    readonly recipe: ReviewFixRecipeId;\n    readonly status: ReviewFixStatus;\n    readonly changedPaths?: readonly string[];\n    readonly reasonCode?: ReviewReasonCode;\n}"
+  },
+  {
+    "name": "ReviewFixStatus",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewFixStatus = \"planned\" | \"changed\" | \"no-op\" | \"failed\";"
+  },
+  {
+    "name": "ReviewLocation",
+    "kind": "interface",
+    "package": "@nifrajs/agent-review",
+    "signature": "export interface ReviewLocation {\n    readonly path: string;\n    readonly line?: number;\n    readonly column?: number;\n}"
+  },
+  {
+    "name": "ReviewOptions",
+    "kind": "interface",
+    "package": "@nifrajs/coding-agent",
+    "signature": "export interface ReviewOptions {\n    readonly cwd: string;\n    readonly command?: string;\n    readonly commandArgs?: readonly string[];\n    readonly strict?: boolean;\n    readonly diff?: string;\n    readonly timeoutMs?: number;\n    readonly maxOutputBytes?: number;\n    readonly env?: Readonly<Record<string, string | undefined>>;\n}"
+  },
+  {
+    "name": "ReviewParserError",
+    "kind": "class",
+    "package": "@nifrajs/agent-review",
+    "signature": "export declare class ReviewParserError extends Error {\n    readonly code: ReviewParserErrorCode;\n    readonly path?: string;\n    constructor(code: ReviewParserErrorCode, path?: string);\n}",
+    "doc": "/** Error raised for every malformed, unsafe, or payload-bearing report. */"
+  },
+  {
+    "name": "ReviewParserErrorCode",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewParserErrorCode = \"invalid-root\" | \"unknown-key\" | \"forbidden-content\" | \"invalid-type\" | \"invalid-enum\" | \"invalid-id\" | \"invalid-reference\" | \"invalid-path\" | \"invalid-digest\" | \"duplicate-id\" | \"missing-required\" | \"oversized\" | \"derived-field-mismatch\" | \"non-canonical\";"
+  },
+  {
+    "name": "ReviewReasonCode",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewReasonCode = \"not-configured\" | \"config-missing\" | \"config-invalid\" | \"collector-error\" | \"collector-unavailable\" | \"diagnostics-truncated\" | \"missing-typescript\" | \"invalid-target\" | \"invalid-git-ref\" | \"invalid-git-scope\" | \"filtered-out-of-scope\" | \"fix-failed\" | \"fix-no-op\" | \"unsupported\";"
+  },
+  {
+    "name": "ReviewReport",
+    "kind": "interface",
+    "package": "@nifrajs/agent-review",
+    "signature": "export interface ReviewReport {\n    readonly version: typeof REVIEW_REPORT_VERSION;\n    readonly strict: boolean;\n    readonly scope: ReviewScope;\n    readonly checks: readonly ReviewCheckResult[];\n    readonly findings: readonly ReviewFinding[];\n    readonly fixes?: readonly ReviewFixResult[];\n    readonly blocking: number;\n    readonly ok: boolean;\n    readonly status: ReviewStatus;\n    /** Lowercase SHA-256 of the canonical report without this field or display-only durations. */\n    readonly digest: string;\n}"
+  },
+  {
+    "name": "ReviewReportDraft",
+    "kind": "interface",
+    "package": "@nifrajs/agent-review",
+    "signature": "export interface ReviewReportDraft {\n    readonly strict: boolean;\n    readonly scope: ReviewScope;\n    readonly checks: readonly ReviewCheckResult[];\n    readonly findings: readonly ReviewFinding[];\n    readonly fixes?: readonly ReviewFixResult[];\n}",
+    "doc": "/** Sanitized structural inputs accepted by the deterministic composer. */"
+  },
+  {
+    "name": "ReviewScope",
+    "kind": "interface",
+    "package": "@nifrajs/agent-review",
+    "signature": "export interface ReviewScope {\n    readonly kind: \"project\" | \"diff\";\n    readonly state: \"valid\" | \"invalid\";\n    readonly gitRef?: string;\n    readonly changedPaths: readonly string[];\n    /** SHA-256 of the canonical changed-path list. */\n    readonly pathDigest: string;\n    readonly outOfScopeCount: number;\n    readonly reasonCode?: ReviewReasonCode;\n}"
+  },
+  {
+    "name": "ReviewSeverity",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewSeverity = \"error\" | \"warning\" | \"info\";"
+  },
+  {
+    "name": "ReviewStatus",
+    "kind": "type",
+    "package": "@nifrajs/agent-review",
+    "signature": "export type ReviewStatus = \"pass\" | \"fail\" | \"inconclusive\";"
+  },
+  {
+    "name": "ReviewView",
+    "kind": "interface",
+    "package": "@nifrajs/agent-app",
+    "signature": "export interface ReviewView {\n    readonly version: 1;\n    readonly status: ReviewViewStatus;\n    readonly ok: boolean;\n    readonly strict: boolean;\n    readonly blocking: number;\n    readonly digest?: string;\n    readonly processStatus?: number | null;\n    readonly reasonCode?: \"invalid-report\" | \"unavailable\" | \"process-failed\";\n    readonly scope?: {\n        readonly kind: \"project\" | \"diff\";\n        readonly state: \"valid\" | \"invalid\";\n        readonly pathDigest: string;\n        readonly changedPathCount: number;\n        readonly outOfScopeCount: number;\n    };\n    readonly checks: readonly ReviewViewCheck[];\n    readonly findings: readonly ReviewViewFinding[];\n    readonly fixes: readonly {\n        readonly recipe: string;\n        readonly status: \"planned\" | \"changed\" | \"no-op\" | \"failed\";\n    }[];\n}"
+  },
+  {
+    "name": "ReviewViewCheck",
+    "kind": "interface",
+    "package": "@nifrajs/agent-app",
+    "signature": "export interface ReviewViewCheck {\n    readonly id: string;\n    readonly required: boolean;\n    readonly status: \"pass\" | \"fail\" | \"skipped\" | \"unavailable\" | \"error\";\n    readonly findings: number;\n    readonly errors: number;\n    readonly warnings: number;\n    readonly info: number;\n    readonly outOfScope: number;\n    readonly reasonCode?: string;\n}"
+  },
+  {
+    "name": "ReviewViewEvidence",
+    "kind": "interface",
+    "package": "@nifrajs/agent-app",
+    "signature": "export interface ReviewViewEvidence {\n    readonly source: string;\n    readonly token: string;\n    readonly digest: string;\n    readonly path?: string;\n}"
+  },
+  {
+    "name": "ReviewViewFinding",
+    "kind": "interface",
+    "package": "@nifrajs/agent-app",
+    "signature": "export interface ReviewViewFinding {\n    readonly id: string;\n    readonly check: string;\n    readonly code: string;\n    readonly severity: \"error\" | \"warning\" | \"info\";\n    readonly category: string;\n    readonly location?: {\n        readonly path: string;\n        readonly line?: number;\n    };\n    readonly evidence: readonly ReviewViewEvidence[];\n    readonly fix?: {\n        readonly recipe: string;\n    };\n}"
+  },
+  {
+    "name": "ReviewViewStatus",
+    "kind": "type",
+    "package": "@nifrajs/agent-app",
+    "signature": "export type ReviewViewStatus = \"pass\" | \"fail\" | \"inconclusive\" | \"unavailable\";"
+  },
   {
     "name": "rewriteSsrImports",
     "kind": "function",
@@ -13697,7 +14489,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\" | \"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}"
+    "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\" | \"params\" | \"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",
@@ -13944,7 +14736,7 @@
     "name": "RouteSnapshotSchema",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "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}"
+    "signature": "export interface RouteSnapshotSchema {\n    readonly headers?: SchemaSnapshot;\n    readonly body?: SchemaSnapshot;\n    readonly query?: SchemaSnapshot;\n    readonly params?: SchemaSnapshot;\n    readonly response?: SchemaSnapshot;\n    readonly sse?: SchemaSnapshot;\n    readonly errors?: Readonly<Record<string, SchemaSnapshot>>;\n}"
   },
   {
     "name": "rpcError",
@@ -14052,6 +14844,13 @@
     "package": "@nifrajs/agent",
     "signature": "export interface RunAgentOptions {\n    readonly state: AgentTurnState;\n    readonly maxTurns?: number;\n    readonly goal?: (output: unknown) => boolean;\n}"
   },
+  {
+    "name": "runAgentSurfaceConformance",
+    "kind": "function",
+    "package": "@nifrajs/webmcp",
+    "signature": "export declare function runAgentSurfaceConformance(capabilities: readonly AgentCapabilityReference[], options?: AgentSurfaceConformanceOptions): Promise<AgentSurfaceConformanceResult>;",
+    "doc": "/** Run deterministic host-independent checks over the WebMCP projection and optional calls. */"
+  },
   {
     "name": "runApp",
     "kind": "function",
@@ -14282,6 +15081,13 @@
     "signature": "export declare function runNifraContext(options: NifraContextOptions): Promise<NifraContextResult>;",
     "doc": "/** Project discovery kept outside the framework runtime; it is only spawned when an agent asks for it. */"
   },
+  {
+    "name": "runNifraReview",
+    "kind": "function",
+    "package": "@nifrajs/coding-agent",
+    "signature": "export declare function runNifraReview(options: ReviewOptions): Promise<ReviewExecutionResult>;",
+    "doc": "/** Run `nifra review --json` with the same bounded process discipline as the existing gates. */"
+  },
   {
     "name": "runNifraVerification",
     "kind": "function",
@@ -14378,6 +15184,12 @@
     "signature": "export interface RunPlanRef {\n    readonly id: string;\n    /** SHA-256 hex of the canonical plan. Content-free. */\n    readonly digest: string;\n    readonly nodeCount: number;\n}",
     "doc": "/** A content-free pointer to the plan a run is executing. */"
   },
+  {
+    "name": "runPredictionLab",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function runPredictionLab(options?: PredictionLabOptions): Promise<PredictionLabReport>;"
+  },
   {
     "name": "RunQueryOptions",
     "kind": "interface",
@@ -14676,6 +15488,64 @@
     "package": "@nifrajs/core",
     "signature": "export interface SagaStore {\n    readonly durability?: \"memory\" | \"durable\";\n    create(record: SagaRecord): boolean | Promise<boolean>;\n    get(sagaId: string): SagaRecord | undefined | Promise<SagaRecord | undefined>;\n    /** Atomic version compare-and-set; this is the saga engine's crash/concurrency boundary. */\n    compareAndSet(input: {\n        readonly sagaId: string;\n        readonly version: number;\n        readonly record: SagaRecord;\n    }): boolean | Promise<boolean>;\n    /** Bounded operational scan. Transition-only stores do not need to implement reconciliation. */\n    scan?(input: ReconciliationScanOptions<SagaState>): ReconciliationScanPage<SagaRecord> | Promise<ReconciliationScanPage<SagaRecord>>;\n    /** @deprecated Compatibility fallback; production reconciliation should implement `scan`. */\n    list?(): readonly SagaRecord[] | Promise<readonly SagaRecord[]>;\n}"
   },
+  {
+    "name": "sanitizedHtml",
+    "kind": "const",
+    "package": "@nifrajs/web",
+    "signature": "export declare const sanitizedHtml: typeof sanitizeHtml;",
+    "doc": "/** Explicit sanitized-content vocabulary for callers and security audits. */"
+  },
+  {
+    "name": "SanitizedHtml",
+    "kind": "type",
+    "package": "@nifrajs/web",
+    "signature": "export type SanitizedHtml = TrustedHtml & {\n    readonly [SANITIZED_HTML_BRAND]: \"sanitized-html\";\n};",
+    "doc": "/** HTML returned by an explicit, caller-supplied sanitizer. It is also trusted by the adapters. */"
+  },
+  {
+    "name": "sanitizeHtml",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function sanitizeHtml(value: string, sanitizer: HtmlSanitizer): SanitizedHtml;",
+    "doc": "/**\n * Run untrusted markup through an explicit sanitizer before it reaches a raw-HTML adapter.\n *\n * Nifra deliberately does not bundle a sanitizer: applications choose the maintained allowlist\n * appropriate to their runtime and content policy. Requiring the sanitizer as an argument prevents\n * `sanitizedHtml(value)` from silently becoming an alias for the unsafe trust operation.\n */"
+  },
+  {
+    "name": "SarifLocation",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface SarifLocation {\n    readonly physicalLocation: {\n        readonly artifactLocation: {\n            readonly uri: string;\n            readonly uriBaseId?: string;\n        };\n        readonly region?: {\n            readonly startLine: number;\n        };\n    };\n}"
+  },
+  {
+    "name": "SarifLog",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface SarifLog {\n    readonly $schema: \"https://json.schemastore.org/sarif-2.1.0.json\";\n    readonly version: \"2.1.0\";\n    readonly runs: readonly SarifRun[];\n}",
+    "doc": "/** The subset of SARIF 2.1.0 emitted by {@link toSarifLog}. */"
+  },
+  {
+    "name": "SarifProjectionOptions",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface SarifProjectionOptions {\n    /** Name shown by external review tools in the SARIF run metadata. Defaults to `nifra`. */\n    readonly toolName?: string;\n    /** Optional CLI/framework version shown by external review tools. */\n    readonly toolVersion?: string;\n    /** Base URI identifier for relative diagnostic file paths. */\n    readonly uriBaseId?: string;\n}"
+  },
+  {
+    "name": "SarifResult",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface SarifResult {\n    readonly ruleId: string;\n    readonly level: \"error\" | \"warning\" | \"note\";\n    readonly message: {\n        readonly text: string;\n    };\n    readonly locations?: readonly SarifLocation[];\n    readonly properties?: Readonly<Record<string, string | readonly string[]>>;\n}"
+  },
+  {
+    "name": "SarifRule",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface SarifRule {\n    readonly id: string;\n    readonly shortDescription: {\n        readonly text: string;\n    };\n}"
+  },
+  {
+    "name": "SarifRun",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface SarifRun {\n    readonly tool: {\n        readonly driver: {\n            readonly name: string;\n            readonly version?: string;\n            readonly rules: readonly SarifRule[];\n        };\n    };\n    readonly results: readonly SarifResult[];\n}"
+  },
   {
     "name": "SassCompiler",
     "kind": "interface",
@@ -15050,14 +15920,14 @@
     "name": "Server",
     "kind": "class",
     "package": "@nifrajs/core",
-    "signature": "export declare class Server<R extends Registry = EmptyRegistry, Ctx = EmptyContext, HookOutput = never> {\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    /** True once any `app.ws()` route sets `validateSend: true` - the one case where a broadcast frame\n     * is validated (and possibly dropped) per socket, so `app.publish` must stay on the JS registry loop\n     * rather than delegate to Bun's native `server.publish`. */\n    private wsHasValidatedSend;\n    /** Bun's native topic broadcast, bound by `listen()` in native-pubsub mode; `app.publish` uses it\n     * instead of the JS registry. `undefined` off Bun, before `listen()`, or with a validated-send route. */\n    private nativePublish;\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    /**\n     * Add a per-request, computed context extension. Order-scoped: it is snapshotted into every route\n     * declared *after* this call, and reaches none declared before. One added after the last route\n     * (e.g. on the app returned by a route-registering factory) covers nothing - see\n     * {@link ServerOptions.unusedScopedHooks}.\n     *\n     * Returning a `status(...)` (or a `Response`) instead of an extension ends the request there - the\n     * guard shape, and the cheap one: it renders as plain data on the same lane a handler's return\n     * takes, where `throw new Response(...)` pays ~40% of the rejection lane to build the object. That\n     * branch is control flow, so it does not widen the derived context type.\n     */\n    derive<H extends (context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx & ContextExtensionOf<ReturnType<H>>, HookOutput | StatusResponseOf<Awaited<ReturnType<H>>>>;\n    /**\n     * Add a static context value. Order-scoped: captured by every route declared *after* this call, and\n     * by none before; one added after the last route reaches nothing\n     * (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    decorate<const K extends string, V>(key: K, value: V): Server<R, Ctx & Record<K, V>, HookOutput>;\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    /**\n     * Run after validation, before the handler; a non-`undefined` return short-circuits. Order-scoped:\n     * it is snapshotted into every route declared *after* this call and covers none declared before, so\n     * one added after the last route reaches nothing (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    beforeHandle<H extends (context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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     * Order-scoped: captured by every route declared *after* this call, none before; one added after the\n     * last route reaches nothing (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    around<H extends (context: Context & Ctx, next: () => MaybePromise<unknown>) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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: captured by routes declared\n     * *after* this call, none before; one added after the last route reaches nothing (see\n     * {@link ServerOptions.unusedScopedHooks}). */\n    afterHandle<H extends (result: unknown, context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\n    /** Handle a thrown error; a non-`undefined` return becomes the response (else the default 500).\n     * Order-scoped: captured by routes declared *after* this call, none before; one added after the last\n     * route reaches nothing (see {@link ServerOptions.unusedScopedHooks}). */\n    onError<H extends (error: unknown, context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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    private responseObserverMethods;\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    /** Enable the opt-in portable response observer methods. */\n    use(plugin: ResponseObserverPlugin): this & ResponseObserverMethods;\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, HookOutput>;\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<AddedHookOutput = never>(plugin: IdentityPlugin<AddedHookOutput>): Server<R, Ctx, HookOutput | AddedHookOutput>;\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     * If the plugin's return type is unpinned - `Server<any, any>`, as a hand-rolled `(app) => app` or a\n     * `NifraPlugin<AnyServer, AnyServer>` infers (e.g. an auth plugin whose own types collapsed) - this\n     * returns the non-callable {@link PluginTypeCollapsed} instead of silently widening the whole typed\n     * client to `any`. `.get()`/`.post()` then fail right here rather than surfacing as `any` hundreds of\n     * lines away. Fix at the plugin: build it with {@link defineIdentityPlugin}/{@link defineContextPlugin},\n     * or pin its input server type. This mirrors the guard {@link definePlugin} already applies.\n     */\n    use<Out extends AnyServer>(plugin: (app: this) => Out): [ServerTypeUnpinned<Out>] extends [true] ? PluginTypeCollapsed : 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 bundle applied after\n     * the last route reaches nothing - {@link ServerOptions.unusedScopedHooks} logs that at seal. A named\n     * bundle already applied is skipped (idempotent).\n     */\n    use<M extends Middleware>(mw: M): Server<R, Ctx, HookOutput | MiddlewareOutputOf<M>>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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, HookOutput>;\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, HookOutput>;\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, HookOutput> : Server<AddRoute<R, \"WS\", Path, WsRouteInfoFor<Path, Schema, Send>>, Ctx, HookOutput>;\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 response observer plugin. */\n    [INSTALL_RESPONSE_OBSERVER](runtime: ResponseObserverRuntime): ResponseObserverMethods;\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, HookOutput2>(other: Server<R2, Ctx2, HookOutput2>): Server<R & R2, Ctx, HookOutput>;\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     * Select a mounted handler's native Node lane without materializing a Web Request. This is an\n     * adapter seam, not a second lifecycle: any app-wide behavior that the ordinary mount path would\n     * run makes the capability ineligible and the caller falls back to `resolveNodeSource`. Typed\n     * routes keep precedence exactly as `routeAndRun` does, including the existing mount behavior for\n     * a path whose registered route rejects this method.\n     */\n    [RESOLVE_NODE_MOUNT](source: RequestSource): NativeMountSelection | undefined;\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 compiled route program, 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 same error boundary as the compiled route program (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 the compiled route program'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    /**\n     * Compile a route's `derive + before` lifecycle to a single closure: the per-request walk through\n     * `runSync` → `runHooksSync` is a stack of 3 frames and 2 `Object.assign`s for what is by far the\n     * most common middleware shape (auth/trace/id derivation, an auth/policy `beforeHandle`). Folding\n     * the same steps into one closure hits the same monomorphic inline-cache site as `buildFusedWeb`,\n     * and `Object.assign(ctx, deriveResult)` becomes one extra property write on the context's already\n     * hot hidden class. Behavior is byte-identical to the compiled route program: the same thrown-value\n     * contract (`Response` is control flow, anything else logs + 500), the same `c.set` semantics, the\n     * same `fusedRespond` for the rendered body. The `LifecycleExecutionLane` guarantee\n     * (`schema.params === undefined && schema.headers === undefined && derives === 1 &&\n     * beforeHandle === 1 && afterHandle === 0 && onError === 0 && !hasResponseContract &&\n     * !hasDecorations`) is enforced by `selectRouteLanes`; this lane is selected ONLY when all of those\n     * hold. A `query` schema (the route declares `{ query }` alongside the hooks) is validated FIRST,\n     * mirroring the compiled route program's stage order; the fused builder runs validate → derive →\n     * before → handler in one frame.\n     */\n    private buildFusedDeriveBefore;\n    /**\n     * Same shape as `buildFusedDeriveBefore`, plus one `afterHandle` step. The closure runs (validate) →\n     * derive → before → handler → after in one frame, the shape the realistic middleware route lands on\n     * when it also wants a response transform (e.g. attaching a request id to a successful payload's\n     * headers). `LifecycleExecutionLane` and `selectRouteLanes` guarantee `afterHandle === 1`, the\n     * throw contract is the same as the generic program, and the `after` step is the final transform +\n     * respond the generic program already does.\n     */\n    private buildFusedDeriveBeforeAfter;\n    /**\n     * Body + lifecycle hooks fused: parse → validate → derive → before → handler → (after) in one\n     * closure, the same win `buildFusedBodyRunner` gives for the no-hooks body shape. The shape is\n     * `lifecycleHookLane` PLUS a body schema with no other validation conflicts; the lane is selected\n     * ONLY when `schema.body !== undefined && schema.query/params/headers === undefined &&\n     * schema.onValidationError === undefined && !defaultOnValidationError && !hasIdempotency &&\n     * !hasLedger && derives === 1 && beforeHandle === 1 && afterHandle <= 1 && onError === 0 &&\n     * !hasResponseContract && !hasDecorations && around === 0`. The same single `querySchema === undefined`\n     * trick used in the no-body lane lets the build path stay simple: a query + body route falls back\n     * to the generic program (this is rare in practice - validated query + validated body is usually a\n     * \"search results\" route with a middleware chain on top, and the generic lane is fine there).\n     */\n    private buildFusedBodyDeriveBeforeAfter;\n    private bareError;\n    /**\n     * Keep the ordinary thrown-error response independent from the caught value. Deliberate Response\n     * control flow is handled by `renderBareError`; every other throw gets this fixed public envelope.\n     */\n    private internalErrorResponse;\n    private runWithAround;\n    /** Execute the registration-compiled general stage program. */\n    private runProgram;\n    /** Bind a compiled validation stage to its stable schema and the existing recovery contract. */\n    private validateProgramStage;\n    /** Preserve the existing bounded body reader and its fail-closed framing/prototype checks. */\n    private readProgramBody;\n    /** Keep thrown Response/status and redacted 500 semantics in one existing error boundary. */\n    private handleProgramError;\n    /** Finish a successful program result through response-contract enforcement and finalization. */\n    private finishProgramResult;\n    private runAround;\n    private runBodyOnly;\n    /** Validate + run the handler for the bodyOnly path - shared by the inline fast path and the\n     * streaming fallback. A method (not per-request closures) so the hot path allocates nothing\n     * beyond the one `.then` continuation. */\n    private finishBodyOnly;\n    private executeHandler;\n    private handleValidationErrorRecovery;\n    private applyBodyValidation;\n    private runQueryOnly;\n    /** Validate-result → set `ctx.query` → run handler. A method (not a per-request closure), the\n     * query analogue of {@link applyBodyValidation}. */\n    private applyQueryValidation;\n    /**\n     * Thread the response through each global `onResponse` hook. Stays SYNCHRONOUS until a hook\n     * actually returns a Promise - an `async` version forced a promise + microtask on EVERY response\n     * of any app with an onResponse hook (cors/securityHeaders/etag/timing all use onResponse), the\n     * same ~13%/req tax the onRequest walk was de-async'd to avoid. The first async hook hands the\n     * rest to {@link continueOnResponse}.\n     */\n    private applyOnResponse;\n    private applyOnResponseAndFinalize;\n    private completeResponseFinalization;\n    private failResponseFinalization;\n    /** Notify terminal observers in order while isolating both sync and async failures. */\n    private notifyResponseFinalized;\n    /** Async tail of {@link applyOnResponse}: runs the remaining hooks once one has gone async. */\n    private continueOnResponse;\n    /**\n     * Bound the response time. On timeout we abort `ctx.signal` (so cancellation-aware\n     * handlers can bail) and return 503; the in-flight work keeps running but its\n     * result is discarded - JS can't forcibly cancel a promise.\n     */\n    private withTimeout;\n    private finishLifecycleContract;\n    private finishContractOutcome;\n    /** Synchronous by design, and `MaybePromise` rather than `Promise` for the same reason: control flow\n     * out of a lifecycle stage must not cost a promise. An `async` method allocates one and defers the\n     * result a microtask even when every branch it takes returns immediately, which is the common case\n     * here - a thrown `status(...)`/`Response`, or a route with no `onError` hook at all. Only the hook\n     * loop, which may await, drops into {@link runErrorHooks}. */\n    private handleLifecycleError;\n    /** The `onError` chain, split off {@link handleLifecycleError} so its `await` costs only the routes\n     * that registered a hook. A hook may return a custom response; otherwise the default 500 stands. */\n    private runErrorHooks;\n    /** Log an unhandled request error to the (redacting) logger - shared by the compiled route program 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    /** 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}",
+    "signature": "export declare class Server<R extends Registry = EmptyRegistry, Ctx = EmptyContext, HookOutput = never> {\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    /** True once any `app.ws()` route sets `validateSend: true` - the one case where a broadcast frame\n     * is validated (and possibly dropped) per socket, so `app.publish` must stay on the JS registry loop\n     * rather than delegate to Bun's native `server.publish`. */\n    private wsHasValidatedSend;\n    /** Bun's native topic broadcast, bound by `listen()` in native-pubsub mode; `app.publish` uses it\n     * instead of the JS registry. `undefined` off Bun, before `listen()`, or with a validated-send route. */\n    private nativePublish;\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    private readonly wsUpgradeTimeoutMs;\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    /**\n     * Add a per-request, computed context extension. Order-scoped: it is snapshotted into every route\n     * declared *after* this call, and reaches none declared before. One added after the last route\n     * (e.g. on the app returned by a route-registering factory) covers nothing - see\n     * {@link ServerOptions.unusedScopedHooks}.\n     *\n     * Returning a `status(...)` (or a `Response`) instead of an extension ends the request there - the\n     * guard shape, and the cheap one: it renders as plain data on the same lane a handler's return\n     * takes, where `throw new Response(...)` pays ~40% of the rejection lane to build the object. That\n     * branch is control flow, so it does not widen the derived context type.\n     */\n    derive<H extends (context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx & ContextExtensionOf<ReturnType<H>>, HookOutput | StatusResponseOf<Awaited<ReturnType<H>>>>;\n    /**\n     * Add a static context value. Order-scoped: captured by every route declared *after* this call, and\n     * by none before; one added after the last route reaches nothing\n     * (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    decorate<const K extends string, V>(key: K, value: V): Server<R, Ctx & Record<K, V>, HookOutput>;\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    /**\n     * Run after validation, before the handler; a non-`undefined` return short-circuits. Order-scoped:\n     * it is snapshotted into every route declared *after* this call and covers none declared before, so\n     * one added after the last route reaches nothing (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    beforeHandle<H extends (context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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     * Order-scoped: captured by every route declared *after* this call, none before; one added after the\n     * last route reaches nothing (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    around<H extends (context: Context & Ctx, next: () => MaybePromise<unknown>) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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: captured by routes declared\n     * *after* this call, none before; one added after the last route reaches nothing (see\n     * {@link ServerOptions.unusedScopedHooks}). */\n    afterHandle<H extends (result: unknown, context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\n    /** Handle a thrown error; a non-`undefined` return becomes the response (else the default 500).\n     * Order-scoped: captured by routes declared *after* this call, none before; one added after the last\n     * route reaches nothing (see {@link ServerOptions.unusedScopedHooks}). */\n    onError<H extends (error: unknown, context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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    private responseObserverMethods;\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    /** Enable the opt-in portable response observer methods. */\n    use(plugin: ResponseObserverPlugin): this & ResponseObserverMethods;\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, HookOutput>;\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<AddedHookOutput = never>(plugin: IdentityPlugin<AddedHookOutput>): Server<R, Ctx, HookOutput | AddedHookOutput>;\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     * If the plugin's return type is unpinned - `Server<any, any>`, as a hand-rolled `(app) => app` or a\n     * `NifraPlugin<AnyServer, AnyServer>` infers (e.g. an auth plugin whose own types collapsed) - this\n     * returns the non-callable {@link PluginTypeCollapsed} instead of silently widening the whole typed\n     * client to `any`. `.get()`/`.post()` then fail right here rather than surfacing as `any` hundreds of\n     * lines away. Fix at the plugin: build it with {@link defineIdentityPlugin}/{@link defineContextPlugin},\n     * or pin its input server type. This mirrors the guard {@link definePlugin} already applies.\n     */\n    use<Out extends AnyServer>(plugin: (app: this) => Out): [ServerTypeUnpinned<Out>] extends [true] ? PluginTypeCollapsed : 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 bundle applied after\n     * the last route reaches nothing - {@link ServerOptions.unusedScopedHooks} logs that at seal. A named\n     * bundle already applied is skipped (idempotent).\n     */\n    use<M extends Middleware>(mw: M): Server<R, Ctx, HookOutput | MiddlewareOutputOf<M>>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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, HookOutput>;\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, HookOutput>;\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, HookOutput> : Server<AddRoute<R, \"WS\", Path, WsRouteInfoFor<Path, Schema, Send>>, Ctx, HookOutput>;\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 response observer plugin. */\n    [INSTALL_RESPONSE_OBSERVER](runtime: ResponseObserverRuntime): ResponseObserverMethods;\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, HookOutput2>(other: Server<R2, Ctx2, HookOutput2>): Server<R & R2, Ctx, HookOutput>;\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     * Select a mounted handler's native Node lane without materializing a Web Request. This is an\n     * adapter seam, not a second lifecycle: any app-wide behavior that the ordinary mount path would\n     * run makes the capability ineligible and the caller falls back to `resolveNodeSource`. Typed\n     * routes keep precedence exactly as `routeAndRun` does, including the existing mount behavior for\n     * a path whose registered route rejects this method.\n     */\n    [RESOLVE_NODE_MOUNT](source: RequestSource): NativeMountSelection | undefined;\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    private runWebSocketRequestHooks;\n    private continueWebSocketRequestHooks;\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 compiled route program, 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 same error boundary as the compiled route program (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 the compiled route program'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    /**\n     * Compile a route's `derive + before` lifecycle to a single closure: the per-request walk through\n     * `runSync` → `runHooksSync` is a stack of 3 frames and 2 `Object.assign`s for what is by far the\n     * most common middleware shape (auth/trace/id derivation, an auth/policy `beforeHandle`). Folding\n     * the same steps into one closure hits the same monomorphic inline-cache site as `buildFusedWeb`,\n     * and `Object.assign(ctx, deriveResult)` becomes one extra property write on the context's already\n     * hot hidden class. Behavior is byte-identical to the compiled route program: the same thrown-value\n     * contract (`Response` is control flow, anything else logs + 500), the same `c.set` semantics, the\n     * same `fusedRespond` for the rendered body. The `LifecycleExecutionLane` guarantee\n     * (`schema.params === undefined && schema.headers === undefined && derives === 1 &&\n     * beforeHandle === 1 && afterHandle === 0 && onError === 0 && !hasResponseContract &&\n     * !hasDecorations`) is enforced by `selectRouteLanes`; this lane is selected ONLY when all of those\n     * hold. A `query` schema (the route declares `{ query }` alongside the hooks) is validated FIRST,\n     * mirroring the compiled route program's stage order; the fused builder runs validate → derive →\n     * before → handler in one frame.\n     */\n    private buildFusedDeriveBefore;\n    /**\n     * Same shape as `buildFusedDeriveBefore`, plus one `afterHandle` step. The closure runs (validate) →\n     * derive → before → handler → after in one frame, the shape the realistic middleware route lands on\n     * when it also wants a response transform (e.g. attaching a request id to a successful payload's\n     * headers). `LifecycleExecutionLane` and `selectRouteLanes` guarantee `afterHandle === 1`, the\n     * throw contract is the same as the generic program, and the `after` step is the final transform +\n     * respond the generic program already does.\n     */\n    private buildFusedDeriveBeforeAfter;\n    /**\n     * Body + lifecycle hooks fused: parse → validate → derive → before → handler → (after) in one\n     * closure, the same win `buildFusedBodyRunner` gives for the no-hooks body shape. The shape is\n     * `lifecycleHookLane` PLUS a body schema with no other validation conflicts; the lane is selected\n     * ONLY when `schema.body !== undefined && schema.query/params/headers === undefined &&\n     * schema.onValidationError === undefined && !defaultOnValidationError && !hasIdempotency &&\n     * !hasLedger && derives === 1 && beforeHandle === 1 && afterHandle <= 1 && onError === 0 &&\n     * !hasResponseContract && !hasDecorations && around === 0`. The same single `querySchema === undefined`\n     * trick used in the no-body lane lets the build path stay simple: a query + body route falls back\n     * to the generic program (this is rare in practice - validated query + validated body is usually a\n     * \"search results\" route with a middleware chain on top, and the generic lane is fine there).\n     */\n    private buildFusedBodyDeriveBeforeAfter;\n    private bareError;\n    /**\n     * Keep the ordinary thrown-error response independent from the caught value. Deliberate Response\n     * control flow is handled by `renderBareError`; every other throw gets this fixed public envelope.\n     */\n    private internalErrorResponse;\n    private runWithAround;\n    /** Execute the registration-compiled general stage program. */\n    private runProgram;\n    /** Bind a compiled validation stage to its stable schema and the existing recovery contract. */\n    private validateProgramStage;\n    /** Preserve the existing bounded body reader and its fail-closed framing/prototype checks. */\n    private readProgramBody;\n    /** Keep thrown Response/status and redacted 500 semantics in one existing error boundary. */\n    private handleProgramError;\n    /** Finish a successful program result through response-contract enforcement and finalization. */\n    private finishProgramResult;\n    private runAround;\n    private runBodyOnly;\n    /** Validate + run the handler for the bodyOnly path - shared by the inline fast path and the\n     * streaming fallback. A method (not per-request closures) so the hot path allocates nothing\n     * beyond the one `.then` continuation. */\n    private finishBodyOnly;\n    private executeHandler;\n    private handleValidationErrorRecovery;\n    private applyBodyValidation;\n    private runQueryOnly;\n    /** Validate-result → set `ctx.query` → run handler. A method (not a per-request closure), the\n     * query analogue of {@link applyBodyValidation}. */\n    private applyQueryValidation;\n    /**\n     * Thread the response through each global `onResponse` hook. Stays SYNCHRONOUS until a hook\n     * actually returns a Promise - an `async` version forced a promise + microtask on EVERY response\n     * of any app with an onResponse hook (cors/securityHeaders/etag/timing all use onResponse), the\n     * same ~13%/req tax the onRequest walk was de-async'd to avoid. The first async hook hands the\n     * rest to {@link continueOnResponse}.\n     */\n    private applyOnResponse;\n    private applyOnResponseAndFinalize;\n    private completeResponseFinalization;\n    private failResponseFinalization;\n    /** Notify terminal observers in order while isolating both sync and async failures. */\n    private notifyResponseFinalized;\n    /** Async tail of {@link applyOnResponse}: runs the remaining hooks once one has gone async. */\n    private continueOnResponse;\n    /**\n     * Bound the response time. On timeout we abort `ctx.signal` (so cancellation-aware\n     * handlers can bail) and return 503; the in-flight work keeps running but its\n     * result is discarded - JS can't forcibly cancel a promise.\n     */\n    private withTimeout;\n    private finishLifecycleContract;\n    private finishContractOutcome;\n    /** Synchronous by design, and `MaybePromise` rather than `Promise` for the same reason: control flow\n     * out of a lifecycle stage must not cost a promise. An `async` method allocates one and defers the\n     * result a microtask even when every branch it takes returns immediately, which is the common case\n     * here - a thrown `status(...)`/`Response`, or a route with no `onError` hook at all. Only the hook\n     * loop, which may await, drops into {@link runErrorHooks}. */\n    private handleLifecycleError;\n    /** The `onError` chain, split off {@link handleLifecycleError} so its `await` costs only the routes\n     * that registered a hook. A hook may return a custom response; otherwise the default 500 stands. */\n    private runErrorHooks;\n    /** Log an unhandled request error to the (redacting) logger - shared by the compiled route program 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    /** 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, HookOutput = never> {\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    /** True once any `app.ws()` route sets `validateSend: true` - the one case where a broadcast frame\n     * is validated (and possibly dropped) per socket, so `app.publish` must stay on the JS registry loop\n     * rather than delegate to Bun's native `server.publish`. */\n    private wsHasValidatedSend;\n    /** Bun's native topic broadcast, bound by `listen()` in native-pubsub mode; `app.publish` uses it\n     * instead of the JS registry. `undefined` off Bun, before `listen()`, or with a validated-send route. */\n    private nativePublish;\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    /**\n     * Add a per-request, computed context extension. Order-scoped: it is snapshotted into every route\n     * declared *after* this call, and reaches none declared before. One added after the last route\n     * (e.g. on the app returned by a route-registering factory) covers nothing - see\n     * {@link ServerOptions.unusedScopedHooks}.\n     *\n     * Returning a `status(...)` (or a `Response`) instead of an extension ends the request there - the\n     * guard shape, and the cheap one: it renders as plain data on the same lane a handler's return\n     * takes, where `throw new Response(...)` pays ~40% of the rejection lane to build the object. That\n     * branch is control flow, so it does not widen the derived context type.\n     */\n    derive<H extends (context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx & ContextExtensionOf<ReturnType<H>>, HookOutput | StatusResponseOf<Awaited<ReturnType<H>>>>;\n    /**\n     * Add a static context value. Order-scoped: captured by every route declared *after* this call, and\n     * by none before; one added after the last route reaches nothing\n     * (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    decorate<const K extends string, V>(key: K, value: V): Server<R, Ctx & Record<K, V>, HookOutput>;\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    /**\n     * Run after validation, before the handler; a non-`undefined` return short-circuits. Order-scoped:\n     * it is snapshotted into every route declared *after* this call and covers none declared before, so\n     * one added after the last route reaches nothing (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    beforeHandle<H extends (context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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     * Order-scoped: captured by every route declared *after* this call, none before; one added after the\n     * last route reaches nothing (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    around<H extends (context: Context & Ctx, next: () => MaybePromise<unknown>) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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: captured by routes declared\n     * *after* this call, none before; one added after the last route reaches nothing (see\n     * {@link ServerOptions.unusedScopedHooks}). */\n    afterHandle<H extends (result: unknown, context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\n    /** Handle a thrown error; a non-`undefined` return becomes the response (else the default 500).\n     * Order-scoped: captured by routes declared *after* this call, none before; one added after the last\n     * route reaches nothing (see {@link ServerOptions.unusedScopedHooks}). */\n    onError<H extends (error: unknown, context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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    private responseObserverMethods;\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    /** Enable the opt-in portable response observer methods. */\n    use(plugin: ResponseObserverPlugin): this & ResponseObserverMethods;\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, HookOutput>;\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<AddedHookOutput = never>(plugin: IdentityPlugin<AddedHookOutput>): Server<R, Ctx, HookOutput | AddedHookOutput>;\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     * If the plugin's return type is unpinned - `Server<any, any>`, as a hand-rolled `(app) => app` or a\n     * `NifraPlugin<AnyServer, AnyServer>` infers (e.g. an auth plugin whose own types collapsed) - this\n     * returns the non-callable {@link PluginTypeCollapsed} instead of silently widening the whole typed\n     * client to `any`. `.get()`/`.post()` then fail right here rather than surfacing as `any` hundreds of\n     * lines away. Fix at the plugin: build it with {@link defineIdentityPlugin}/{@link defineContextPlugin},\n     * or pin its input server type. This mirrors the guard {@link definePlugin} already applies.\n     */\n    use<Out extends AnyServer>(plugin: (app: this) => Out): [ServerTypeUnpinned<Out>] extends [true] ? PluginTypeCollapsed : 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 bundle applied after\n     * the last route reaches nothing - {@link ServerOptions.unusedScopedHooks} logs that at seal. A named\n     * bundle already applied is skipped (idempotent).\n     */\n    use<M extends Middleware>(mw: M): Server<R, Ctx, HookOutput | MiddlewareOutputOf<M>>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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, HookOutput>;\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, HookOutput>;\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, HookOutput> : Server<AddRoute<R, \"WS\", Path, WsRouteInfoFor<Path, Schema, Send>>, Ctx, HookOutput>;\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 response observer plugin. */\n    [INSTALL_RESPONSE_OBSERVER](runtime: ResponseObserverRuntime): ResponseObserverMethods;\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, HookOutput2>(other: Server<R2, Ctx2, HookOutput2>): Server<R & R2, Ctx, HookOutput>;\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     * Select a mounted handler's native Node lane without materializing a Web Request. This is an\n     * adapter seam, not a second lifecycle: any app-wide behavior that the ordinary mount path would\n     * run makes the capability ineligible and the caller falls back to `resolveNodeSource`. Typed\n     * routes keep precedence exactly as `routeAndRun` does, including the existing mount behavior for\n     * a path whose registered route rejects this method.\n     */\n    [RESOLVE_NODE_MOUNT](source: RequestSource): NativeMountSelection | undefined;\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 compiled route program, 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 same error boundary as the compiled route program (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 the compiled route program'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    /**\n     * Compile a route's `derive + before` lifecycle to a single closure: the per-request walk through\n     * `runSync` → `runHooksSync` is a stack of 3 frames and 2 `Object.assign`s for what is by far the\n     * most common middleware shape (auth/trace/id derivation, an auth/policy `beforeHandle`). Folding\n     * the same steps into one closure hits the same monomorphic inline-cache site as `buildFusedWeb`,\n     * and `Object.assign(ctx, deriveResult)` becomes one extra property write on the context's already\n     * hot hidden class. Behavior is byte-identical to the compiled route program: the same thrown-value\n     * contract (`Response` is control flow, anything else logs + 500), the same `c.set` semantics, the\n     * same `fusedRespond` for the rendered body. The `LifecycleExecutionLane` guarantee\n     * (`schema.params === undefined && schema.headers === undefined && derives === 1 &&\n     * beforeHandle === 1 && afterHandle === 0 && onError === 0 && !hasResponseContract &&\n     * !hasDecorations`) is enforced by `selectRouteLanes`; this lane is selected ONLY when all of those\n     * hold. A `query` schema (the route declares `{ query }` alongside the hooks) is validated FIRST,\n     * mirroring the compiled route program's stage order; the fused builder runs validate → derive →\n     * before → handler in one frame.\n     */\n    private buildFusedDeriveBefore;\n    /**\n     * Same shape as `buildFusedDeriveBefore`, plus one `afterHandle` step. The closure runs (validate) →\n     * derive → before → handler → after in one frame, the shape the realistic middleware route lands on\n     * when it also wants a response transform (e.g. attaching a request id to a successful payload's\n     * headers). `LifecycleExecutionLane` and `selectRouteLanes` guarantee `afterHandle === 1`, the\n     * throw contract is the same as the generic program, and the `after` step is the final transform +\n     * respond the generic program already does.\n     */\n    private buildFusedDeriveBeforeAfter;\n    /**\n     * Body + lifecycle hooks fused: parse → validate → derive → before → handler → (after) in one\n     * closure, the same win `buildFusedBodyRunner` gives for the no-hooks body shape. The shape is\n     * `lifecycleHookLane` PLUS a body schema with no other validation conflicts; the lane is selected\n     * ONLY when `schema.body !== undefined && schema.query/params/headers === undefined &&\n     * schema.onValidationError === undefined && !defaultOnValidationError && !hasIdempotency &&\n     * !hasLedger && derives === 1 && beforeHandle === 1 && afterHandle <= 1 && onError === 0 &&\n     * !hasResponseContract && !hasDecorations && around === 0`. The same single `querySchema === undefined`\n     * trick used in the no-body lane lets the build path stay simple: a query + body route falls back\n     * to the generic program (this is rare in practice - validated query + validated body is usually a\n     * \"search results\" route with a middleware chain on top, and the generic lane is fine there).\n     */\n    private buildFusedBodyDeriveBeforeAfter;\n    private bareError;\n    /**\n     * Keep the ordinary thrown-error response independent from the caught value. Deliberate Response\n     * control flow is handled by `renderBareError`; every other throw gets this fixed public envelope.\n     */\n    private internalErrorResponse;\n    private runWithAround;\n    /** Execute the registration-compiled general stage program. */\n    private runProgram;\n    /** Bind a compiled validation stage to its stable schema and the existing recovery contract. */\n    private validateProgramStage;\n    /** Preserve the existing bounded body reader and its fail-closed framing/prototype checks. */\n    private readProgramBody;\n    /** Keep thrown Response/status and redacted 500 semantics in one existing error boundary. */\n    private handleProgramError;\n    /** Finish a successful program result through response-contract enforcement and finalization. */\n    private finishProgramResult;\n    private runAround;\n    private runBodyOnly;\n    /** Validate + run the handler for the bodyOnly path - shared by the inline fast path and the\n     * streaming fallback. A method (not per-request closures) so the hot path allocates nothing\n     * beyond the one `.then` continuation. */\n    private finishBodyOnly;\n    private executeHandler;\n    private handleValidationErrorRecovery;\n    private applyBodyValidation;\n    private runQueryOnly;\n    /** Validate-result → set `ctx.query` → run handler. A method (not a per-request closure), the\n     * query analogue of {@link applyBodyValidation}. */\n    private applyQueryValidation;\n    /**\n     * Thread the response through each global `onResponse` hook. Stays SYNCHRONOUS until a hook\n     * actually returns a Promise - an `async` version forced a promise + microtask on EVERY response\n     * of any app with an onResponse hook (cors/securityHeaders/etag/timing all use onResponse), the\n     * same ~13%/req tax the onRequest walk was de-async'd to avoid. The first async hook hands the\n     * rest to {@link continueOnResponse}.\n     */\n    private applyOnResponse;\n    private applyOnResponseAndFinalize;\n    private completeResponseFinalization;\n    private failResponseFinalization;\n    /** Notify terminal observers in order while isolating both sync and async failures. */\n    private notifyResponseFinalized;\n    /** Async tail of {@link applyOnResponse}: runs the remaining hooks once one has gone async. */\n    private continueOnResponse;\n    /**\n     * Bound the response time. On timeout we abort `ctx.signal` (so cancellation-aware\n     * handlers can bail) and return 503; the in-flight work keeps running but its\n     * result is discarded - JS can't forcibly cancel a promise.\n     */\n    private withTimeout;\n    private finishLifecycleContract;\n    private finishContractOutcome;\n    /** Synchronous by design, and `MaybePromise` rather than `Promise` for the same reason: control flow\n     * out of a lifecycle stage must not cost a promise. An `async` method allocates one and defers the\n     * result a microtask even when every branch it takes returns immediately, which is the common case\n     * here - a thrown `status(...)`/`Response`, or a route with no `onError` hook at all. Only the hook\n     * loop, which may await, drops into {@link runErrorHooks}. */\n    private handleLifecycleError;\n    /** The `onError` chain, split off {@link handleLifecycleError} so its `await` costs only the routes\n     * that registered a hook. A hook may return a custom response; otherwise the default 500 stands. */\n    private runErrorHooks;\n    /** Log an unhandled request error to the (redacting) logger - shared by the compiled route program 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    /** 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}",
+    "signature": "export declare class Server<R extends Registry = EmptyRegistry, Ctx = EmptyContext, HookOutput = never> {\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    /** True once any `app.ws()` route sets `validateSend: true` - the one case where a broadcast frame\n     * is validated (and possibly dropped) per socket, so `app.publish` must stay on the JS registry loop\n     * rather than delegate to Bun's native `server.publish`. */\n    private wsHasValidatedSend;\n    /** Bun's native topic broadcast, bound by `listen()` in native-pubsub mode; `app.publish` uses it\n     * instead of the JS registry. `undefined` off Bun, before `listen()`, or with a validated-send route. */\n    private nativePublish;\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    private readonly wsUpgradeTimeoutMs;\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    /**\n     * Add a per-request, computed context extension. Order-scoped: it is snapshotted into every route\n     * declared *after* this call, and reaches none declared before. One added after the last route\n     * (e.g. on the app returned by a route-registering factory) covers nothing - see\n     * {@link ServerOptions.unusedScopedHooks}.\n     *\n     * Returning a `status(...)` (or a `Response`) instead of an extension ends the request there - the\n     * guard shape, and the cheap one: it renders as plain data on the same lane a handler's return\n     * takes, where `throw new Response(...)` pays ~40% of the rejection lane to build the object. That\n     * branch is control flow, so it does not widen the derived context type.\n     */\n    derive<H extends (context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx & ContextExtensionOf<ReturnType<H>>, HookOutput | StatusResponseOf<Awaited<ReturnType<H>>>>;\n    /**\n     * Add a static context value. Order-scoped: captured by every route declared *after* this call, and\n     * by none before; one added after the last route reaches nothing\n     * (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    decorate<const K extends string, V>(key: K, value: V): Server<R, Ctx & Record<K, V>, HookOutput>;\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    /**\n     * Run after validation, before the handler; a non-`undefined` return short-circuits. Order-scoped:\n     * it is snapshotted into every route declared *after* this call and covers none declared before, so\n     * one added after the last route reaches nothing (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    beforeHandle<H extends (context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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     * Order-scoped: captured by every route declared *after* this call, none before; one added after the\n     * last route reaches nothing (see {@link ServerOptions.unusedScopedHooks}).\n     */\n    around<H extends (context: Context & Ctx, next: () => MaybePromise<unknown>) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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: captured by routes declared\n     * *after* this call, none before; one added after the last route reaches nothing (see\n     * {@link ServerOptions.unusedScopedHooks}). */\n    afterHandle<H extends (result: unknown, context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\n    /** Handle a thrown error; a non-`undefined` return becomes the response (else the default 500).\n     * Order-scoped: captured by routes declared *after* this call, none before; one added after the last\n     * route reaches nothing (see {@link ServerOptions.unusedScopedHooks}). */\n    onError<H extends (error: unknown, context: Context & Ctx) => MaybePromise<unknown>>(fn: H): Server<R, Ctx, HookOutput | HookOutputOf<ReturnType<H>>>;\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    private responseObserverMethods;\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    /** Enable the opt-in portable response observer methods. */\n    use(plugin: ResponseObserverPlugin): this & ResponseObserverMethods;\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, HookOutput>;\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<AddedHookOutput = never>(plugin: IdentityPlugin<AddedHookOutput>): Server<R, Ctx, HookOutput | AddedHookOutput>;\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     * If the plugin's return type is unpinned - `Server<any, any>`, as a hand-rolled `(app) => app` or a\n     * `NifraPlugin<AnyServer, AnyServer>` infers (e.g. an auth plugin whose own types collapsed) - this\n     * returns the non-callable {@link PluginTypeCollapsed} instead of silently widening the whole typed\n     * client to `any`. `.get()`/`.post()` then fail right here rather than surfacing as `any` hundreds of\n     * lines away. Fix at the plugin: build it with {@link defineIdentityPlugin}/{@link defineContextPlugin},\n     * or pin its input server type. This mirrors the guard {@link definePlugin} already applies.\n     */\n    use<Out extends AnyServer>(plugin: (app: this) => Out): [ServerTypeUnpinned<Out>] extends [true] ? PluginTypeCollapsed : 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 bundle applied after\n     * the last route reaches nothing - {@link ServerOptions.unusedScopedHooks} logs that at seal. A named\n     * bundle already applied is skipped (idempotent).\n     */\n    use<M extends Middleware>(mw: M): Server<R, Ctx, HookOutput | MiddlewareOutputOf<M>>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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>, HookOutput>>, Ctx, HookOutput>;\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, HookOutput>;\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, HookOutput>;\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, HookOutput> : Server<AddRoute<R, \"WS\", Path, WsRouteInfoFor<Path, Schema, Send>>, Ctx, HookOutput>;\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 response observer plugin. */\n    [INSTALL_RESPONSE_OBSERVER](runtime: ResponseObserverRuntime): ResponseObserverMethods;\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, HookOutput2>(other: Server<R2, Ctx2, HookOutput2>): Server<R & R2, Ctx, HookOutput>;\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     * Select a mounted handler's native Node lane without materializing a Web Request. This is an\n     * adapter seam, not a second lifecycle: any app-wide behavior that the ordinary mount path would\n     * run makes the capability ineligible and the caller falls back to `resolveNodeSource`. Typed\n     * routes keep precedence exactly as `routeAndRun` does, including the existing mount behavior for\n     * a path whose registered route rejects this method.\n     */\n    [RESOLVE_NODE_MOUNT](source: RequestSource): NativeMountSelection | undefined;\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    private runWebSocketRequestHooks;\n    private continueWebSocketRequestHooks;\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 compiled route program, 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 same error boundary as the compiled route program (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 the compiled route program'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    /**\n     * Compile a route's `derive + before` lifecycle to a single closure: the per-request walk through\n     * `runSync` → `runHooksSync` is a stack of 3 frames and 2 `Object.assign`s for what is by far the\n     * most common middleware shape (auth/trace/id derivation, an auth/policy `beforeHandle`). Folding\n     * the same steps into one closure hits the same monomorphic inline-cache site as `buildFusedWeb`,\n     * and `Object.assign(ctx, deriveResult)` becomes one extra property write on the context's already\n     * hot hidden class. Behavior is byte-identical to the compiled route program: the same thrown-value\n     * contract (`Response` is control flow, anything else logs + 500), the same `c.set` semantics, the\n     * same `fusedRespond` for the rendered body. The `LifecycleExecutionLane` guarantee\n     * (`schema.params === undefined && schema.headers === undefined && derives === 1 &&\n     * beforeHandle === 1 && afterHandle === 0 && onError === 0 && !hasResponseContract &&\n     * !hasDecorations`) is enforced by `selectRouteLanes`; this lane is selected ONLY when all of those\n     * hold. A `query` schema (the route declares `{ query }` alongside the hooks) is validated FIRST,\n     * mirroring the compiled route program's stage order; the fused builder runs validate → derive →\n     * before → handler in one frame.\n     */\n    private buildFusedDeriveBefore;\n    /**\n     * Same shape as `buildFusedDeriveBefore`, plus one `afterHandle` step. The closure runs (validate) →\n     * derive → before → handler → after in one frame, the shape the realistic middleware route lands on\n     * when it also wants a response transform (e.g. attaching a request id to a successful payload's\n     * headers). `LifecycleExecutionLane` and `selectRouteLanes` guarantee `afterHandle === 1`, the\n     * throw contract is the same as the generic program, and the `after` step is the final transform +\n     * respond the generic program already does.\n     */\n    private buildFusedDeriveBeforeAfter;\n    /**\n     * Body + lifecycle hooks fused: parse → validate → derive → before → handler → (after) in one\n     * closure, the same win `buildFusedBodyRunner` gives for the no-hooks body shape. The shape is\n     * `lifecycleHookLane` PLUS a body schema with no other validation conflicts; the lane is selected\n     * ONLY when `schema.body !== undefined && schema.query/params/headers === undefined &&\n     * schema.onValidationError === undefined && !defaultOnValidationError && !hasIdempotency &&\n     * !hasLedger && derives === 1 && beforeHandle === 1 && afterHandle <= 1 && onError === 0 &&\n     * !hasResponseContract && !hasDecorations && around === 0`. The same single `querySchema === undefined`\n     * trick used in the no-body lane lets the build path stay simple: a query + body route falls back\n     * to the generic program (this is rare in practice - validated query + validated body is usually a\n     * \"search results\" route with a middleware chain on top, and the generic lane is fine there).\n     */\n    private buildFusedBodyDeriveBeforeAfter;\n    private bareError;\n    /**\n     * Keep the ordinary thrown-error response independent from the caught value. Deliberate Response\n     * control flow is handled by `renderBareError`; every other throw gets this fixed public envelope.\n     */\n    private internalErrorResponse;\n    private runWithAround;\n    /** Execute the registration-compiled general stage program. */\n    private runProgram;\n    /** Bind a compiled validation stage to its stable schema and the existing recovery contract. */\n    private validateProgramStage;\n    /** Preserve the existing bounded body reader and its fail-closed framing/prototype checks. */\n    private readProgramBody;\n    /** Keep thrown Response/status and redacted 500 semantics in one existing error boundary. */\n    private handleProgramError;\n    /** Finish a successful program result through response-contract enforcement and finalization. */\n    private finishProgramResult;\n    private runAround;\n    private runBodyOnly;\n    /** Validate + run the handler for the bodyOnly path - shared by the inline fast path and the\n     * streaming fallback. A method (not per-request closures) so the hot path allocates nothing\n     * beyond the one `.then` continuation. */\n    private finishBodyOnly;\n    private executeHandler;\n    private handleValidationErrorRecovery;\n    private applyBodyValidation;\n    private runQueryOnly;\n    /** Validate-result → set `ctx.query` → run handler. A method (not a per-request closure), the\n     * query analogue of {@link applyBodyValidation}. */\n    private applyQueryValidation;\n    /**\n     * Thread the response through each global `onResponse` hook. Stays SYNCHRONOUS until a hook\n     * actually returns a Promise - an `async` version forced a promise + microtask on EVERY response\n     * of any app with an onResponse hook (cors/securityHeaders/etag/timing all use onResponse), the\n     * same ~13%/req tax the onRequest walk was de-async'd to avoid. The first async hook hands the\n     * rest to {@link continueOnResponse}.\n     */\n    private applyOnResponse;\n    private applyOnResponseAndFinalize;\n    private completeResponseFinalization;\n    private failResponseFinalization;\n    /** Notify terminal observers in order while isolating both sync and async failures. */\n    private notifyResponseFinalized;\n    /** Async tail of {@link applyOnResponse}: runs the remaining hooks once one has gone async. */\n    private continueOnResponse;\n    /**\n     * Bound the response time. On timeout we abort `ctx.signal` (so cancellation-aware\n     * handlers can bail) and return 503; the in-flight work keeps running but its\n     * result is discarded - JS can't forcibly cancel a promise.\n     */\n    private withTimeout;\n    private finishLifecycleContract;\n    private finishContractOutcome;\n    /** Synchronous by design, and `MaybePromise` rather than `Promise` for the same reason: control flow\n     * out of a lifecycle stage must not cost a promise. An `async` method allocates one and defers the\n     * result a microtask even when every branch it takes returns immediately, which is the common case\n     * here - a thrown `status(...)`/`Response`, or a route with no `onError` hook at all. Only the hook\n     * loop, which may await, drops into {@link runErrorHooks}. */\n    private handleLifecycleError;\n    /** The `onError` chain, split off {@link handleLifecycleError} so its `await` costs only the routes\n     * that registered a hook. A hook may return a custom response; otherwise the default 500 stands. */\n    private runErrorHooks;\n    /** Log an unhandled request error to the (redacting) logger - shared by the compiled route program 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    /** 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 */"
   },
   {
@@ -15265,13 +16135,13 @@
     "name": "ServerOptions",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "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    /**\n     * What to do when an order-scoped hook (`derive`/`beforeHandle`/`around`/`aroundCapability`/\n     * `afterHandle`/`onError`/`decorate`) covers no route because it was added after the last route was\n     * registered. `register()` snapshots the current chain into each route as it is declared, so a hook\n     * appended after every route reaches nothing and is silently dead. `\"warn\"` (default) logs once at\n     * seal (first `listen()`/`fetch`/`resolveNode`); `\"error\"` throws a `FrameworkError`\n     * (`UNUSED_SCOPED_HOOKS`); `\"off\"` skips the bookkeeping entirely, including the one-frame stack\n     * capture. App-global hooks (`onRequest`/`onResponse`/...) are unaffected in every mode.\n     *\n     * This is a development-time diagnostic: the whole audit is guarded by `process.env.NODE_ENV !==\n     * \"production\"`, so any bundler that defines `NODE_ENV` (vite/esbuild/webpack/next, `bun build\n     * --production`) dead-code-eliminates it, leaving zero bytes and zero per-request cost in the shipped\n     * bundle. It fires in development, test, and CI - where you catch the mistake - not in production.\n     */\n    readonly unusedScopedHooks?: \"warn\" | \"error\" | \"off\";\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    /** WebSocket upgrade admission/guard timeout (ms). Default 10_000; set to 0 only for a deliberate unbounded guard. */\n    readonly wsUpgradeTimeoutMs?: 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    /**\n     * What to do when an order-scoped hook (`derive`/`beforeHandle`/`around`/`aroundCapability`/\n     * `afterHandle`/`onError`/`decorate`) covers no route because it was added after the last route was\n     * registered. `register()` snapshots the current chain into each route as it is declared, so a hook\n     * appended after every route reaches nothing and is silently dead. `\"warn\"` (default) logs once at\n     * seal (first `listen()`/`fetch`/`resolveNode`); `\"error\"` throws a `FrameworkError`\n     * (`UNUSED_SCOPED_HOOKS`); `\"off\"` skips the bookkeeping entirely, including the one-frame stack\n     * capture. App-global hooks (`onRequest`/`onResponse`/...) are unaffected in every mode.\n     *\n     * This is a development-time diagnostic: the whole audit is guarded by `process.env.NODE_ENV !==\n     * \"production\"`, so any bundler that defines `NODE_ENV` (vite/esbuild/webpack/next, `bun build\n     * --production`) dead-code-eliminates it, leaving zero bytes and zero per-request cost in the shipped\n     * bundle. It fires in development, test, and CI - where you catch the mistake - not in production.\n     */\n    readonly unusedScopedHooks?: \"warn\" | \"error\" | \"off\";\n}"
   },
   {
     "name": "ServerOptions",
     "kind": "interface",
     "package": "nifra",
-    "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    /**\n     * What to do when an order-scoped hook (`derive`/`beforeHandle`/`around`/`aroundCapability`/\n     * `afterHandle`/`onError`/`decorate`) covers no route because it was added after the last route was\n     * registered. `register()` snapshots the current chain into each route as it is declared, so a hook\n     * appended after every route reaches nothing and is silently dead. `\"warn\"` (default) logs once at\n     * seal (first `listen()`/`fetch`/`resolveNode`); `\"error\"` throws a `FrameworkError`\n     * (`UNUSED_SCOPED_HOOKS`); `\"off\"` skips the bookkeeping entirely, including the one-frame stack\n     * capture. App-global hooks (`onRequest`/`onResponse`/...) are unaffected in every mode.\n     *\n     * This is a development-time diagnostic: the whole audit is guarded by `process.env.NODE_ENV !==\n     * \"production\"`, so any bundler that defines `NODE_ENV` (vite/esbuild/webpack/next, `bun build\n     * --production`) dead-code-eliminates it, leaving zero bytes and zero per-request cost in the shipped\n     * bundle. It fires in development, test, and CI - where you catch the mistake - not in production.\n     */\n    readonly unusedScopedHooks?: \"warn\" | \"error\" | \"off\";\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    /** WebSocket upgrade admission/guard timeout (ms). Default 10_000; set to 0 only for a deliberate unbounded guard. */\n    readonly wsUpgradeTimeoutMs?: 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    /**\n     * What to do when an order-scoped hook (`derive`/`beforeHandle`/`around`/`aroundCapability`/\n     * `afterHandle`/`onError`/`decorate`) covers no route because it was added after the last route was\n     * registered. `register()` snapshots the current chain into each route as it is declared, so a hook\n     * appended after every route reaches nothing and is silently dead. `\"warn\"` (default) logs once at\n     * seal (first `listen()`/`fetch`/`resolveNode`); `\"error\"` throws a `FrameworkError`\n     * (`UNUSED_SCOPED_HOOKS`); `\"off\"` skips the bookkeeping entirely, including the one-frame stack\n     * capture. App-global hooks (`onRequest`/`onResponse`/...) are unaffected in every mode.\n     *\n     * This is a development-time diagnostic: the whole audit is guarded by `process.env.NODE_ENV !==\n     * \"production\"`, so any bundler that defines `NODE_ENV` (vite/esbuild/webpack/next, `bun build\n     * --production`) dead-code-eliminates it, leaving zero bytes and zero per-request cost in the shipped\n     * bundle. It fires in development, test, and CI - where you catch the mistake - not in production.\n     */\n    readonly unusedScopedHooks?: \"warn\" | \"error\" | \"off\";\n}"
   },
   {
     "name": "ServeStaticOptions",
@@ -15318,7 +16188,7 @@
     "name": "SessionContext",
     "kind": "interface",
     "package": "@nifrajs/auth",
-    "signature": "export interface SessionContext {\n    readonly cookies: Readonly<Record<string, string>>;\n    readonly set: {\n        cookie(name: string, value: string, options?: CookieOptions): void;\n        deleteCookie(name: string, options?: {\n            readonly path?: string;\n            readonly domain?: string;\n        }): void;\n    };\n}",
+    "signature": "export interface SessionContext {\n    readonly cookies: Readonly<Record<string, string>>;\n    /** Optional raw request, used to reject ambiguous duplicate session cookies. */\n    readonly request?: Request;\n    readonly set: {\n        cookie(name: string, value: string, options?: CookieOptions): void;\n        deleteCookie(name: string, options?: {\n            readonly path?: string;\n            readonly domain?: string;\n        }): void;\n    };\n}",
     "doc": "/** The cookie + response surface the manager needs - a structural subset of nifra's `Context`, so any\n * `c` satisfies it and it's testable with a stub. */"
   },
   {
@@ -15409,7 +16279,7 @@
     "name": "SessionStore",
     "kind": "interface",
     "package": "@nifrajs/coding-agent",
-    "signature": "export interface SessionStore {\n    append(sessionId: string, type: string, payload?: unknown, options?: {\n        readonly pinned?: boolean;\n    }): Promise<SessionLogEntry>;\n    read(sessionId: string): Promise<readonly SessionLogEntry[]>;\n    checkpoint(sessionId: string, payload: unknown): Promise<void>;\n    fork(sessionId: string, targetSessionId?: string): Promise<string>;\n}"
+    "signature": "export interface SessionStore {\n    append(sessionId: string, type: string, payload?: unknown, options?: {\n        readonly pinned?: boolean;\n    }): Promise<SessionLogEntry>;\n    /** Read at most `limit` retained entries from the tail of the session log. */\n    read(sessionId: string, limit?: number): Promise<readonly SessionLogEntry[]>;\n    checkpoint(sessionId: string, payload: unknown): Promise<void>;\n    fork(sessionId: string, targetSessionId?: string): Promise<string>;\n}"
   },
   {
     "name": "SessionUserOf",
@@ -15787,6 +16657,13 @@
     "signature": "export declare function snapshotRoutes(source: unknown): readonly RouteSnapshot[];",
     "doc": "/**\n * Snapshot an app's routes (anything `reflectRoutes` accepts) as plain JSON. Validators are\n * dropped; only introspectable JSON Schema metadata is kept, so the result round-trips through\n * `JSON.stringify` unchanged.\n */"
   },
+  {
+    "name": "snapshotRoutesFromEvidence",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function snapshotRoutesFromEvidence(evidence: ProjectEvidenceSnapshot): readonly RouteSnapshot[];",
+    "doc": "/** Snapshot routes from an existing canonical project-evidence pass. */"
+  },
   {
     "name": "solidAdapter",
     "kind": "const",
@@ -16795,6 +17672,13 @@
     "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": "toDeadLetterView",
+    "kind": "function",
+    "package": "@nifrajs/jobs",
+    "signature": "export declare function toDeadLetterView(records: readonly DeadLetterRecord[]): readonly DeadLetterView[];",
+    "doc": "/** Project dead-letter records to content-free views. Throws on malformed input, never partial. */"
+  },
   {
     "name": "toEvalComparisonView",
     "kind": "function",
@@ -16922,6 +17806,12 @@
     "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": "ToolApproval",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "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",
@@ -16946,12 +17836,24 @@
     "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": "ToolCallOptions",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "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": "ToolCallResult",
+    "kind": "type",
+    "package": "@nifrajs/webmcp",
+    "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",
@@ -16983,12 +17885,24 @@
     "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": "ToolContract",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "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": "ToolContractOptions",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "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": "ToolDeltaView",
     "kind": "interface",
@@ -17007,12 +17921,24 @@
     "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": "ToolError",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "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": "ToolEvidence",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "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",
@@ -17092,11 +18018,18 @@
     "signature": "export declare function toOpenAPI(input: ContractShape | Server, options?: ToOpenAPIOptions): OpenAPIDocument;",
     "doc": "/** Generate an OpenAPI 3.1 document from a contract or a running app. See the module doc for the detail model. */"
   },
+  {
+    "name": "toOpenAPIFromEvidence",
+    "kind": "function",
+    "package": "@nifrajs/schema",
+    "signature": "export declare function toOpenAPIFromEvidence(evidence: ProjectEvidenceSnapshot, options?: Omit<ToOpenAPIOptions, \"evidence\">): OpenAPIDocument;",
+    "doc": "/** Generate OpenAPI from an existing canonical project-evidence snapshot without loading a server. */"
+  },
   {
     "name": "ToOpenAPIOptions",
     "kind": "interface",
     "package": "@nifrajs/schema",
-    "signature": "export interface ToOpenAPIOptions {\n    readonly title?: string;\n    readonly version?: string;\n    readonly description?: string;\n    /** Server URLs the API is served from (OpenAPI `servers`). */\n    readonly servers?: readonly OpenAPIServer[];\n    /** Tag definitions (OpenAPI top-level `tags`) - names referenced by an operation's `tags`. */\n    readonly tags?: readonly OpenAPITag[];\n    /** Reusable security schemes → `components.securitySchemes` (e.g. `{ bearer: { type: \"http\", scheme: \"bearer\" } }`). */\n    readonly securitySchemes?: Readonly<Record<string, Record<string, unknown>>>;\n    /** Document-wide security requirement; a per-operation `security` (incl. `[]` for public) overrides it. */\n    readonly security?: readonly SecurityRequirement[];\n    /**\n     * Per-operation overrides, shallow-merged over the generated operation. Keyed by `operationId`\n     * (contract op name) or `\"METHOD /path\"` (e.g. `\"GET /users/:id\"`). The escape hatch for detail that\n     * can't be introspected - richer response bodies, examples, app-route tags/security.\n     */\n    readonly operations?: Readonly<Record<string, Record<string, unknown>>>;\n    /**\n     * Optional build-time response schemas inferred from TypeScript declarations. Keys are\n     * `METHOD /path` (for example `GET /users/:id`), and explicit route/contract schemas always win.\n     * This is inert OpenAPI metadata: it never enables runtime response validation.\n     */\n    readonly inferredResponses?: Readonly<Record<string, Readonly<Record<string, {\n        readonly description?: string;\n        readonly schema?: JsonSchema;\n        readonly contentType?: string;\n    }>>>>;\n}"
+    "signature": "export interface ToOpenAPIOptions {\n    readonly title?: string;\n    readonly version?: string;\n    readonly description?: string;\n    /** Server URLs the API is served from (OpenAPI `servers`). */\n    readonly servers?: readonly OpenAPIServer[];\n    /** Tag definitions (OpenAPI top-level `tags`) - names referenced by an operation's `tags`. */\n    readonly tags?: readonly OpenAPITag[];\n    /** Reusable security schemes → `components.securitySchemes` (e.g. `{ bearer: { type: \"http\", scheme: \"bearer\" } }`). */\n    readonly securitySchemes?: Readonly<Record<string, Record<string, unknown>>>;\n    /** Document-wide security requirement; a per-operation `security` (incl. `[]` for public) overrides it. */\n    readonly security?: readonly SecurityRequirement[];\n    /**\n     * Reuse a canonical token-only route-evidence pass. This is useful for build artifacts and CLI\n     * projections that already evaluated the project; it never supplies runtime validators.\n     */\n    readonly evidence?: ProjectEvidenceSnapshot;\n    /**\n     * Per-operation overrides, shallow-merged over the generated operation. Keyed by `operationId`\n     * (contract op name) or `\"METHOD /path\"` (e.g. `\"GET /users/:id\"`). The escape hatch for detail that\n     * can't be introspected - richer response bodies, examples, app-route tags/security.\n     */\n    readonly operations?: Readonly<Record<string, Record<string, unknown>>>;\n    /**\n     * Optional build-time response schemas inferred from TypeScript declarations. Keys are\n     * `METHOD /path` (for example `GET /users/:id`), and explicit route/contract schemas always win.\n     * This is inert OpenAPI metadata: it never enables runtime response validation.\n     */\n    readonly inferredResponses?: Readonly<Record<string, Readonly<Record<string, {\n        readonly description?: string;\n        readonly schema?: JsonSchema;\n        readonly contentType?: string;\n    }>>>>;\n}"
   },
   {
     "name": "TopicRegistry",
@@ -17105,6 +18038,12 @@
     "signature": "export declare class TopicRegistry {\n    private readonly topics;\n    private readonly memberships;\n    subscribe(topic: string, ws: NifraWebSocket): void;\n    unsubscribe(topic: string, ws: NifraWebSocket): void;\n    /** Drop every subscription for a connection - called on close so a registry never leaks dead sockets. */\n    unsubscribeAll(ws: NifraWebSocket): void;\n    /** Send `data` to every connection subscribed to `topic`. Per-socket send errors are isolated. */\n    publish(topic: string, data: string | ArrayBufferView | ArrayBuffer): void;\n}",
     "doc": "/**\n * In-process pub/sub for `ws.subscribe(topic)` + `app.publish(topic, data)`. **Single-instance only** -\n * topics live in this process's memory, so a multi-instance deploy (multiple servers behind a load\n * balancer) needs an external fan-out (Redis pub/sub, a Cloudflare Durable Object, NATS, …) bridged to\n * `app.publish`. The same registry instance is shared by an app's connections and its `publish`.\n */"
   },
+  {
+    "name": "toPredictionLabContext",
+    "kind": "function",
+    "package": "@nifrajs/testing",
+    "signature": "export declare function toPredictionLabContext(seed: number, labCase: {\n    readonly id: string;\n    readonly target: PredictionLabTarget;\n    readonly mutation?: string;\n}): PredictionLabContext;"
+  },
   {
     "name": "topUserFrame",
     "kind": "function",
@@ -17112,6 +18051,13 @@
     "signature": "export declare function topUserFrame(frames: readonly DiagnosticFrame[], root: string | undefined): DiagnosticFrame | undefined;",
     "doc": "/** The first frame that points at the user's own source - what the codeframe should show. */"
   },
+  {
+    "name": "toQueueHealth",
+    "kind": "function",
+    "package": "@nifrajs/jobs",
+    "signature": "export declare function toQueueHealth(counts: {\n    readonly pending: number;\n    readonly active: number;\n    readonly dead: number;\n}): QueueHealth;",
+    "doc": "/** Project store counts to a health snapshot. Non-negative integers only; anything else throws. */"
+  },
   {
     "name": "toRegistryCapabilityView",
     "kind": "function",
@@ -17125,6 +18071,13 @@
     "package": "@nifrajs/core",
     "signature": "export declare function toResponse(result: HandlerResult, set: CtxSet, tagResponseBody?: ResponseBodyTagOption, statics?: StaticResponseHeaders): Response;"
   },
+  {
+    "name": "toReviewView",
+    "kind": "function",
+    "package": "@nifrajs/agent-app",
+    "signature": "export declare function toReviewView(value: unknown): ReviewView | undefined;",
+    "doc": "/** Project a review report or host RPC result into a bounded, content-free browser view. */"
+  },
   {
     "name": "toRunStudioView",
     "kind": "function",
@@ -17138,6 +18091,13 @@
     "package": "@nifrajs/agent-app",
     "signature": "export declare function toRunView(snapshot: RunSnapshot): RunView;"
   },
+  {
+    "name": "toSarifLog",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function toSarifLog(diagnostics: readonly Diagnostic[], options?: SarifProjectionOptions): SarifLog;",
+    "doc": "/**\n * Project stable Nifra diagnostics into SARIF for code-host and external review surfaces.\n *\n * This is deliberately a pure projection: it does not run checks, read files, or reinterpret policy.\n * Relative file names remain relative so callers can choose the review tool's checkout base through\n * {@link SarifProjectionOptions.uriBaseId}.\n */"
+  },
   {
     "name": "toSessionView",
     "kind": "function",
@@ -17158,6 +18118,13 @@
     "signature": "export declare function toVercelHandler<Env = unknown>(app: FetchApp<Env>): VercelHandler;",
     "doc": "/** Adapt a Web-standard app to a Vercel Edge Function default export. */"
   },
+  {
+    "name": "toWebMcpTool",
+    "kind": "function",
+    "package": "@nifrajs/webmcp",
+    "signature": "export declare function toWebMcpTool<Input, Output, State>(capability: AgentCapability<Input, Output, State>, options?: WebMcpExecutionOptions): WebMcpToolDefinition;",
+    "doc": "/** Adapt one canonical capability to the proposed WebMCP tool shape. */"
+  },
   {
     "name": "traceAgentRun",
     "kind": "function",
@@ -17253,6 +18220,12 @@
     "signature": "export declare function transformCssModule(source: string, filePath: string): CssModuleResult;",
     "doc": "/**\n * Pure core (no I/O): scope a CSS-module source. Same `(source, filePath)` in → byte-identical out, so\n * the `\"dom\"` and `\"ssr\"` plugin forms produce the same class map. Exposed for direct testing.\n */"
   },
+  {
+    "name": "TransportByteLimitOptions",
+    "kind": "interface",
+    "package": "@nifrajs/agent-protocol",
+    "signature": "export interface TransportByteLimitOptions {\n    readonly minimum?: number;\n    readonly maximum?: number;\n    readonly label?: string;\n}"
+  },
   {
     "name": "TransportCodec",
     "kind": "interface",
@@ -17311,6 +18284,19 @@
     "signature": "export declare function trimTrailingSlash(options?: TrailingSlashOptions): import(\"@nifrajs/core\").IdentityPlugin<never>;",
     "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 */"
   },
+  {
+    "name": "TrustedHtml",
+    "kind": "type",
+    "package": "@nifrajs/web",
+    "signature": "export type TrustedHtml = string & {\n    readonly [TRUSTED_HTML_BRAND]: \"trusted-html\";\n};"
+  },
+  {
+    "name": "trustHtml",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function trustHtml(value: string): TrustedHtml;",
+    "doc": "/** Mark already-sanitized or application-owned HTML for an intentional raw-HTML adapter sink. */"
+  },
   {
     "name": "tryGetContext",
     "kind": "function",
@@ -18148,14 +19134,14 @@
     "name": "VERSION",
     "kind": "const",
     "package": "@nifrajs/core",
-    "signature": "export declare const VERSION: \"3.3.0\";",
+    "signature": "export declare const VERSION: \"3.5.0\";",
     "doc": "/**\n * Current package version. A hardcoded literal on purpose - core runs on the edge (no fs), so it can't\n * read its own package.json at runtime. `scripts/version.ts` rewrites it on every release bump and\n * `check:publish` asserts it equals `@nifrajs/core`'s package version.\n */"
   },
   {
     "name": "VERSION",
     "kind": "const",
     "package": "nifra",
-    "signature": "export declare const VERSION: \"3.3.0\";",
+    "signature": "export declare const VERSION: \"3.5.0\";",
     "doc": "/**\n * Current package version. A hardcoded literal on purpose - core runs on the edge (no fs), so it can't\n * read its own package.json at runtime. `scripts/version.ts` rewrites it on every release bump and\n * `check:publish` asserts it equals `@nifrajs/core`'s package version.\n */"
   },
   {
@@ -18233,6 +19219,20 @@
     "signature": "export declare function vueSvgComponentBunPlugin(generate: \"dom\" | \"ssr\"): BunPlugin;",
     "doc": "/** The Vue SVG-component plugin. `generate` selects Vue's client/SSR render, matching `vueBunPlugin`. */"
   },
+  {
+    "name": "waitForStyles",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function waitForStyles(options?: WaitForStylesOptions): Promise<void>;",
+    "doc": "/**\n * Wait for the framework-owned deferred stylesheet links in the initial document, then promote them to\n * `media=\"all\"`. It is safe to call more than once: repeated calls for one document share the same\n * per-link waits, and duplicate framework links are removed before waiting. Blocking links are not\n * touched.\n *\n * This function lives in the browser-only `@nifrajs/web/client` entry. It is nevertheless defensive\n * when imported in a non-DOM environment so an accidental import cannot crash a server process.\n */"
+  },
+  {
+    "name": "WaitForStylesOptions",
+    "kind": "interface",
+    "package": "@nifrajs/web",
+    "signature": "export interface WaitForStylesOptions {\n    /**\n     * Maximum time to wait for one framework-owned deferred stylesheet before hydrating anyway.\n     * Defaults to 4000 ms and is capped at 30000 ms so a bad value cannot leave the app inert forever.\n     */\n    readonly timeoutMs?: number;\n}",
+    "doc": "/** Options for {@link waitForStyles}. */"
+  },
   {
     "name": "wasmImageBackend",
     "kind": "function",
@@ -18266,6 +19266,48 @@
     "signature": "export type WebhookResult = {\n    readonly ok: true;\n    readonly payload: string;\n} | {\n    readonly ok: false;\n    readonly reason: WebhookFailureReason;\n};",
     "doc": "/** Verified ⇒ the raw `payload` text (parse it with your schema). Rejected ⇒ a stable `reason`. */"
   },
+  {
+    "name": "WebMcpExecutionOptions",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface WebMcpExecutionOptions extends Omit<ToolCallOptions, \"signal\" | \"capabilities\"> {\n    /** Extra capability tokens may be supplied by an embedding host; the tool's own token is always added. */\n    readonly capabilities?: readonly string[];\n    /** A page-local authorization check. Server authorization remains mandatory for remote writes. */\n    readonly authorize?: (input: unknown) => boolean | PromiseLike<boolean>;\n    /** Return the Nifra receipt envelope (default) or only the typed output on success. */\n    readonly resultMode?: \"receipt\" | \"output\";\n    /** Maximum JSON-encoded output bytes retained in the default receipt. */\n    readonly maxReceiptBytes?: number;\n}"
+  },
+  {
+    "name": "WebMcpModelContext",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface WebMcpModelContext {\n    readonly registerTool: (tool: WebMcpToolDefinition) => void | PromiseLike<void>;\n    readonly unregisterTool?: (name: string) => void | PromiseLike<void>;\n}"
+  },
+  {
+    "name": "WebMcpReceipt",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface WebMcpReceipt<Output = unknown> {\n    readonly ok: boolean;\n    readonly outcome: \"committed\" | \"dry-run\" | \"failed\" | \"denied\";\n    readonly dryRun: boolean;\n    readonly output?: Output;\n    readonly outputTruncated?: true;\n    readonly error?: {\n        readonly code: ToolError[\"code\"];\n        readonly stage: ToolError[\"stage\"];\n    };\n    readonly evidence: readonly ToolEvidence[];\n}"
+  },
+  {
+    "name": "WebMcpRegistrationFailure",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface WebMcpRegistrationFailure {\n    readonly name: string;\n    readonly error: string;\n}"
+  },
+  {
+    "name": "WebMcpRegistrationReport",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface WebMcpRegistrationReport {\n    readonly supported: boolean;\n    readonly registered: readonly string[];\n    readonly failed: readonly WebMcpRegistrationFailure[];\n    readonly cleanup: () => Promise<void>;\n}"
+  },
+  {
+    "name": "WebMcpTarget",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface WebMcpTarget {\n    readonly modelContext?: WebMcpModelContext;\n}"
+  },
+  {
+    "name": "WebMcpToolDefinition",
+    "kind": "interface",
+    "package": "@nifrajs/webmcp",
+    "signature": "export interface WebMcpToolDefinition {\n    readonly name: string;\n    readonly description: string;\n    readonly inputSchema: Record<string, unknown>;\n    readonly annotations: AgentCapability<unknown, unknown>[\"tool\"][\"annotations\"];\n    readonly execute: (input: unknown) => unknown | PromiseLike<unknown>;\n}"
+  },
   {
     "name": "websocket",
     "kind": "function",
@@ -18454,7 +19496,7 @@
     "name": "WorkflowRunner",
     "kind": "class",
     "package": "@nifrajs/coding-agent",
-    "signature": "export declare class WorkflowRunner {\n    private readonly options;\n    private readonly values;\n    private readonly completed;\n    private steps;\n    constructor(options?: WorkflowRunnerOptions);\n    run(step: WorkflowStep): Promise<WorkflowResult>;\n    private context;\n    private execute;\n    private single;\n    private parallel;\n    private emit;\n}",
+    "signature": "export declare class WorkflowRunner {\n    private readonly options;\n    private readonly signal;\n    private readonly values;\n    private readonly completed;\n    private steps;\n    constructor(options?: WorkflowRunnerOptions);\n    run(step: WorkflowStep): Promise<WorkflowResult>;\n    private context;\n    private execute;\n    private single;\n    private parallel;\n    private emit;\n}",
     "doc": "/** Bounded orchestration primitives. The kernel knows no provider, UI, or framework package. */"
   },
   {
@@ -18485,7 +19527,7 @@
     "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}"
+    "signature": "export interface WorkGraphBuildInput {\n    readonly source: unknown;\n    /** Reuse a canonical route-evidence pass when the caller already has one. */\n    readonly evidence?: ProjectEvidenceSnapshot;\n    readonly files?: readonly WorkGraphSourceFile[];\n    readonly freshness?: BuildFreshness;\n}"
   },
   {
     "name": "WorkGraphEdge",
@@ -18503,8 +19545,7 @@
     "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 */"
+    "signature": "export type WorkGraphNodeKind = \"route\" | \"schema\" | \"capability\" | \"assurance\" | \"test\" | \"file\" | \"manifest\";"
   },
   {
     "name": "WorkGraphSourceFile",