@nifrajs/cli 1.13.0 → 2.0.0

package/docs/types.json

@@ -63,7 +63,7 @@
     "kind": "interface",
     "package": "@nifrajs/core",
     "signature": "export interface AdmissionController {\n    admit(req: Request): AdmissionDecision | Promise<AdmissionDecision>;\n}",
-    "doc": "/**\n * A capacity-admission gate. Decides, per request, whether the instance has capacity to run it now —\n * bounding *concurrency*, which rate limits (frequency) and deadlines (duration) do not. Provide an\n * implementation (see `@nifrajs/middleware`'s `createAdmissionController`) as {@link ServerOptions.admission}.\n *\n * Enabling it trades the fused native-route lane for native matching + this gate (the gate cannot be a\n * per-request `onRequest` hook without disabling native routes entirely); when unset, the request path\n * is untouched.\n */"
+    "doc": "/**\n * A capacity-admission gate. Decides, per request, whether the instance has capacity to run it now -\n * bounding *concurrency*, which rate limits (frequency) and deadlines (duration) do not. Provide an\n * implementation (see `@nifrajs/middleware`'s `createAdmissionController`) as {@link ServerOptions.admission}.\n *\n * Enabling it trades the fused native-route lane for native matching + this gate (the gate cannot be a\n * per-request `onRequest` hook without disabling native routes entirely); when unset, the request path\n * is untouched.\n */"
   },
   {
     "name": "AdmissionControllerHandle",
@@ -168,20 +168,6 @@
     "package": "create-nifra",
     "signature": "export interface AgentsMdOptions {\n    readonly template: TemplateName;\n    readonly framework: Framework;\n    readonly name: string;\n    /** Drizzle preset, when scaffolded with `--db` — adds a Database section. */\n    readonly db?: DbChoice;\n    /** Auth preset, when scaffolded with `--auth` — adds an Authentication section. */\n    readonly auth?: AuthChoice;\n}"
   },
-  {
-    "name": "AgentSpan",
-    "kind": "type",
-    "package": "@nifrajs/agent-telemetry",
-    "signature": "export type AgentSpan = NifraSpan;",
-    "doc": "/** A tool-call span. Kept as an alias for package-specific naming without duplicating OTel types. */"
-  },
-  {
-    "name": "AgentSpanExporter",
-    "kind": "type",
-    "package": "@nifrajs/agent-telemetry",
-    "signature": "export type AgentSpanExporter = SpanExporter;",
-    "doc": "/** Exporter seam shared with `@nifrajs/otel`. */"
-  },
   {
     "name": "agentTelemetry",
     "kind": "function",
@@ -193,7 +179,7 @@
     "name": "AgentTelemetryOptions",
     "kind": "interface",
     "package": "@nifrajs/agent-telemetry",
-    "signature": "export interface AgentTelemetryOptions {\n    /** Exporter that receives completed tool-call spans. */\n    readonly exporter: AgentSpanExporter;\n    /** Path prefix for nifra tool routes (default `\"/_nifra/tool/\"`). */\n    readonly toolPathPrefix?: string | undefined;\n    /** Path for the MCP endpoint (default `\"/mcp\"`). */\n    readonly mcpPath?: string | undefined;\n}"
+    "signature": "export interface AgentTelemetryOptions {\n    /** Exporter that receives completed tool-call spans. */\n    readonly exporter: ObservationAdapter;\n    /** Path prefix for nifra tool routes (default `\"/_nifra/tool/\"`). */\n    readonly toolPathPrefix?: string | undefined;\n    /** Path for the MCP endpoint (default `\"/mcp\"`). */\n    readonly mcpPath?: string | undefined;\n}"
   },
   {
     "name": "aggregateSizeReport",
@@ -262,11 +248,17 @@
     "signature": "export declare function apiRoutesSection(routes: readonly ReflectedRoute[]): string;",
     "doc": "/** Markdown section listing the backend's API routes with their request + response field shapes. */"
   },
+  {
+    "name": "appendCookiesToResponse",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function appendCookiesToResponse(response: Response, set: CtxSet): Response;"
+  },
   {
     "name": "appendTrailingSlash",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function appendTrailingSlash(options?: TrailingSlashOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function appendTrailingSlash(options?: TrailingSlashOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "doc": "/**\n * Append a trailing slash to non-root paths. By default it skips file-looking paths such as\n * `/app.css`, which keeps static assets and extensionful API routes stable.\n */"
   },
   {
@@ -408,13 +400,13 @@
     "name": "AssuranceFindingCode",
     "kind": "type",
     "package": "@nifrajs/core",
-    "signature": "export type AssuranceFindingCode = \"no-routes\" | \"unclassified-route\" | \"missing-evidence\" | \"forbidden-evidence\";"
+    "signature": "export type AssuranceFindingCode = \"no-routes\" | \"unclassified-route\" | \"missing-evidence\" | \"forbidden-evidence\" | \"classified-no-evidence\";"
   },
   {
     "name": "AssurancePolicy",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface AssurancePolicy {\n    /** First matching rule owns a route. Put exceptions before broad defaults. */\n    readonly rules: readonly AssuranceRule[];\n    /** Default `error`: an unclassified route fails closed. */\n    readonly unmatched?: \"error\" | \"ignore\";\n    /** Default false: reject an empty reflected source so a wrong import cannot pass CI silently. */\n    readonly allowEmpty?: boolean;\n}"
+    "signature": "export interface AssurancePolicy {\n    /** First matching rule owns a route. Put exceptions before broad defaults. */\n    readonly rules: readonly AssuranceRule[];\n    /** Default `error`: an unclassified route fails closed. */\n    readonly unmatched?: \"error\" | \"ignore\";\n    /** Default false: reject an empty reflected source so a wrong import cannot pass CI silently. */\n    readonly allowEmpty?: boolean;\n    /**\n     * Default false. When true, a route matched by a **pure-classification** rule (no `require`, no `forbid`)\n     * that carries NO enforcement evidence is reported (`classified-no-evidence`). This surfaces the gap the\n     * feedback flagged: a classification-only policy silently degrades \"proof\" to a \"label\". Opt-in, because\n     * a genuinely public route legitimately carries no evidence; enable it once your guards emit evidence\n     * (inline `schema.assurance` or a `withRouteAssurance` middleware) to keep classification honest.\n     */\n    readonly flagClassifiedWithoutEvidence?: boolean;\n}"
   },
   {
     "name": "AssuranceReport",
@@ -491,6 +483,20 @@
     "package": "create-nifra",
     "signature": "export type AuthChoice = (typeof AUTH_CHOICES)[number];"
   },
+  {
+    "name": "authed",
+    "kind": "function",
+    "package": "@nifrajs/better-auth",
+    "signature": "export declare function authed<A extends BetterAuthLike, const RequireTenant extends boolean = false>(auth: A, options?: AuthedOptions<SessionUserOf<A>> & {\n    readonly requireTenant?: RequireTenant;\n}): <S extends AnyServer>(app: S) => WithPrincipal<S, PrincipalFor<SessionUserOf<A>, RequireTenant>>;",
+    "doc": "/**\n * A nifra plugin that derives a fail-closed {@link Principal} onto every downstream handler as\n * `c.principal`. After `server().use(authed(auth))`, `c.principal.user` / `c.principal.userId` are typed\n * and **non-null** - a handler CANNOT run without an authenticated caller, so the guard can't be\n * forgotten. Works in both modes:\n *\n * ```ts\n * // inline\n * const app = server().use(authed(auth)).get(\"/me\", (c) => ({ id: c.principal.userId }))\n * // contract-first (the pre-applied derive threads `principal` into the contract's handlers)\n * const api = implement(contract, handlers, server().use(authed(auth, { requireTenant: true })))\n * ```\n *\n * With `{ requireTenant: true }`, `c.principal.tenantId` is typed `string` (a missing tenant is a `403`).\n *\n * DESIGN NOTE: this is an **unnamed** plugin by necessity. A named plugin (for idempotent dedupe) carries\n * a `& { pluginName }` intersection that defeats the generic inference of `use`'s context-threading\n * overload and collapses the server - and its typed client - to `any` (see `@nifrajs/core` plugin docs).\n * Threading a NON-NULL principal is the whole point, so `authed` stays unnamed and generic. Applying it\n * twice simply derives twice (the second resolve overwrites with the same value); scope it once per app.\n */"
+  },
+  {
+    "name": "AuthedOptions",
+    "kind": "interface",
+    "package": "@nifrajs/better-auth",
+    "signature": "export interface AuthedOptions<User> {\n    /** Require a resolvable tenant. When set and no tenant resolves, fail closed with `403`. */\n    readonly requireTenant?: boolean;\n    /** Browser redirect target (`302`) for a missing session, instead of the default `401` JSON. Same-origin. */\n    readonly redirectTo?: string;\n    /** Resolve the tenant id from the user. Default: `user.tenantId ?? user.orgId` (string-valued only). */\n    readonly tenantOf?: (user: User) => string | undefined;\n}",
+    "doc": "/**\n * Options for {@link requirePrincipal} / {@link authed}.\n */"
+  },
   {
     "name": "AuthPlugin",
     "kind": "type",
@@ -646,7 +652,7 @@
     "name": "betterAuth",
     "kind": "function",
     "package": "@nifrajs/better-auth",
-    "signature": "export declare function betterAuth(auth: BetterAuthLike, options?: BetterAuthOptions): import(\"@nifrajs/core\").IdentityPlugin;",
+    "signature": "export declare function betterAuth(auth: BetterAuthLike, options?: BetterAuthOptions): import(\"@nifrajs/core/server\").IdentityPlugin;",
     "doc": "/**\n * Mount a better-auth instance into a nifra app: registers its handler at `${basePath}/*`\n * (default `/api/auth/*`) for `GET` + `POST`, so every better-auth endpoint — sign-in/up/out, OAuth\n * callbacks, session, 2FA, magic links, … — is served by your nifra server.\n *\n * ```ts\n * import { betterAuth, requireSession } from \"@nifrajs/better-auth\"\n * import { auth } from \"./auth\"           // your configured better-auth instance\n *\n * const app = server().use(betterAuth(auth))            // wires /api/auth/*\n *   .get(\"/me\", async (c) => (await requireSession(auth, c.req)).user)\n * ```\n *\n * Idempotent (named `\"better-auth\"` — applying twice mounts once). Read the session with\n * {@link getSession} / {@link requireSession}, which infer your better-auth types.\n */"
   },
   {
@@ -875,7 +881,7 @@
     "name": "cacheControl",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function cacheControl(value: string | ((request: Request) => string | undefined), options?: CacheControlOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function cacheControl(value: string | ((request: Request) => string | undefined), options?: CacheControlOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "doc": "/**\n * Set a `Cache-Control` header on matching responses. `value` is either a fixed directive string or a\n * function of the request (return `undefined` to leave a response untouched — e.g. cache by path).\n * Defaults to `GET`/`HEAD` + 2xx, and never clobbers a `Cache-Control` the handler set itself.\n *\n * ```ts\n * app.use(cacheControl(\"public, max-age=3600, stale-while-revalidate=60\"))\n * // or per-path:\n * app.use(cacheControl((req) =>\n *   new URL(req.url).pathname.startsWith(\"/assets/\") ? \"public, max-age=31536000, immutable\" : undefined,\n * ))\n * ```\n */"
   },
   {
@@ -1369,14 +1375,14 @@
     "name": "CheckDiagnostic",
     "kind": "interface",
     "package": "@nifrajs/cli",
-    "signature": "export interface CheckDiagnostic {\n    readonly rule: \"typecheck\" | \"typed-client\" | \"untyped-client\" | \"server-only-import\" | \"response-route\" | \"undeclared-dependency\" | \"duplicate-install\" | \"server-manifest-drift\" | \"manifest-drift\" | \"capability-assurance\" | \"capability-config\";\n    /** `error` fails the gate (a real contract break); `warning` is advisory — surfaced to the agent but\n     * does NOT fail `nifra check`, for patterns that are sometimes intentional (a route returning a raw\n     * `Response`, which silently drops the typed client to `data: never` but is valid for files/redirects). */\n    readonly severity: \"error\" | \"warning\";\n    readonly file?: string;\n    readonly line?: number;\n    readonly message: string;\n    /** The canonical, rule-level fix — clean of the per-occurrence snippet, so an agent can apply it\n     * directly. Set for the lint rules (they have one correct fix); omitted for `typecheck` (the fix is\n     * specific to each type error). */\n    readonly fix?: string;\n    /** A richer, agent-oriented fix hint. Diffs are only emitted when the edit is mechanical and local;\n     * ambiguous cases give concrete steps instead of pretending the checker can safely rewrite code. */\n    readonly suggestion?: CheckSuggestion;\n    /**\n     * The import chain that pulls server-only code into the browser bundle, as display labels\n     * `[routeFile, …as-written specifiers…, sink]`. Set only on `server-only-import`.\n     *\n     * #4.4: this is now the FULL **transitive** chain — a bounded import-resolution walk (`Bun.resolveSync`\n     * from each file's dir, BFS the local module graph) follows `route → ../data → ../db → node:crypto`,\n     * matching the build leak-guard's depth (`detectNodeBuiltinsInClient` in `@nifrajs/web/build`). A\n     * length-2 chain (`[routeFile, specifier]`) means the route imports the sink directly. When a hop can't\n     * be resolved precisely (a bare pkg, a tsconfig path alias), the walk degrades to the honest direct\n     * edge rather than fabricating a deeper path — never a lie.\n     */\n    readonly chain?: readonly string[];\n}",
+    "signature": "export interface CheckDiagnostic {\n    readonly rule: \"typecheck\" | \"typed-client\" | \"untyped-client\" | \"server-only-import\" | \"response-route\" | \"undeclared-dependency\" | \"duplicate-install\" | \"server-manifest-drift\" | \"manifest-drift\" | \"capability-assurance\" | \"capability-config\" | \"check-config\";\n    /** `error` fails the gate (a real contract break); `warning` is advisory — surfaced to the agent but\n     * does NOT fail `nifra check`, for patterns that are sometimes intentional (a route returning a raw\n     * `Response`, which silently drops the typed client to `data: never` but is valid for files/redirects). */\n    readonly severity: \"error\" | \"warning\";\n    readonly file?: string;\n    readonly line?: number;\n    readonly message: string;\n    /** The canonical, rule-level fix — clean of the per-occurrence snippet, so an agent can apply it\n     * directly. Set for the lint rules (they have one correct fix); omitted for `typecheck` (the fix is\n     * specific to each type error). */\n    readonly fix?: string;\n    /** A richer, agent-oriented fix hint. Diffs are only emitted when the edit is mechanical and local;\n     * ambiguous cases give concrete steps instead of pretending the checker can safely rewrite code. */\n    readonly suggestion?: CheckSuggestion;\n    /**\n     * The import chain that pulls server-only code into the browser bundle, as display labels\n     * `[routeFile, …as-written specifiers…, sink]`. Set only on `server-only-import`.\n     *\n     * #4.4: this is now the FULL **transitive** chain — a bounded import-resolution walk (`Bun.resolveSync`\n     * from each file's dir, BFS the local module graph) follows `route → ../data → ../db → node:crypto`,\n     * matching the build leak-guard's depth (`detectNodeBuiltinsInClient` in `@nifrajs/web/build`). A\n     * length-2 chain (`[routeFile, specifier]`) means the route imports the sink directly. When a hop can't\n     * be resolved precisely (a bare pkg, a tsconfig path alias), the walk degrades to the honest direct\n     * edge rather than fabricating a deeper path — never a lie.\n     */\n    readonly chain?: readonly string[];\n}",
     "doc": "/** A single machine-readable check failure — the unit an agent (or CI) acts on. */"
   },
   {
     "name": "CheckResult",
     "kind": "interface",
     "package": "@nifrajs/cli",
-    "signature": "export interface CheckResult {\n    readonly ok: boolean;\n    readonly typecheck: \"pass\" | \"fail\" | \"skipped\";\n    readonly diagnostics: readonly CheckDiagnostic[];\n    /** Set only when the caller passed `maxDiagnostics` and there were more — `diagnostics` then holds the\n     * first `shown` of `total`. It caps the serialized size so the `nifra_check` MCP tool can't emit a\n     * message large enough to break the stdio transport; fix the shown diagnostics and re-run for the rest. */\n    readonly truncated?: {\n        readonly shown: number;\n        readonly total: number;\n    };\n}",
+    "signature": "export interface CheckResult {\n    readonly ok: boolean;\n    readonly typecheck: \"pass\" | \"fail\" | \"skipped\";\n    readonly diagnostics: readonly CheckDiagnostic[];\n    /** Intentional non-typed mount prefixes declared in `nifra.check.json` (e.g. `/auth` for a mounted\n     * better-auth). Echoed here so `--json` / the MCP tool / the report can show what the typed-client scan\n     * deliberately skipped - a suppressed prefix stays auditable instead of silently hiding real drift. */\n    readonly externalMounts?: readonly string[];\n    /** Set only when the caller passed `maxDiagnostics` and there were more — `diagnostics` then holds the\n     * first `shown` of `total`. It caps the serialized size so the `nifra_check` MCP tool can't emit a\n     * message large enough to break the stdio transport; fix the shown diagnostics and re-run for the rest. */\n    readonly truncated?: {\n        readonly shown: number;\n        readonly total: number;\n    };\n}",
     "doc": "/** The structured result of a full check — what `--json` prints and the `nifra_check` MCP tool returns. */"
   },
   {
@@ -1439,11 +1445,25 @@
     "signature": "export declare function clientCall(method: string, path: string, schema: unknown): string;",
     "doc": "/**\n * The typed-client call form for a route — the exact `client<typeof app>` proxy chain an agent should\n * write, derived from the same convention `@nifrajs/client` implements (so it never has to read the\n * client tests to learn it): a static segment is a property (`.users`), a path param/wildcard is a call\n * that appends the value (`({ id })`), the root path is `.index`, and the HTTP verb is the terminal call.\n * Body verbs (POST/PUT/PATCH) take the body first then call-options; other verbs take call-options first —\n * so the `{ query }` argument lands in the right slot for each.\n */"
   },
+  {
+    "name": "ClientIpTrust",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type ClientIpTrust = {\n    readonly trustedHops: number;\n} | {\n    readonly header: string;\n};",
+    "doc": "/**\n * How much of the forwarding chain to trust when deriving `c.clientIp`. Omit for the safe default\n * (socket peer only, no header believed).\n *\n * - `{ trustedHops: n }` - trust `n` reverse-proxy hops in front of the app. The caller is taken from\n *   `X-Forwarded-For` counted from the right past the `n` trusted hops (the socket peer is hop 0). Use\n *   this when the app sits behind `n` proxies **you operate**. Fewer entries than trusted hops means\n *   the header is too short to trust, so `c.clientIp` is `undefined` (fail closed).\n * - `{ header: name }` - trust a single named header's first value (e.g. a CDN that overwrites it at\n *   the edge). Only declare this when the app is reachable **exclusively** through that edge; a\n *   directly-reachable app lets any client forge the header.\n */"
+  },
   {
     "name": "ClientOptions",
     "kind": "interface",
     "package": "@nifrajs/client",
-    "signature": "export interface ClientOptions {\n    /** Headers sent on every request (a per-call `headers` option is merged on top). */\n    readonly headers?: Record<string, string>;\n    /** Override the `fetch` implementation (tests, an in-process bridge, a custom agent, etc.). */\n    readonly fetch?: FetchFn;\n}"
+    "signature": "export interface ClientOptions {\n    /** Headers sent on every request (a per-call `headers` option is merged on top). */\n    readonly headers?: Record<string, string>;\n    /** Override the `fetch` implementation (tests, an in-process bridge, a custom agent, etc.). */\n    readonly fetch?: FetchFn;\n    /**\n     * Runs before each request (including each retry). Return a header map to MERGE onto the outgoing\n     * request — the place to inject a fresh auth token. `await`ed, so async token refresh works.\n     */\n    readonly onRequest?: (request: {\n        readonly url: string;\n        readonly method: string;\n        readonly headers: Record<string, string>;\n        readonly body: unknown;\n    }) => MaybePromise<Record<string, string> | undefined>;\n    /** Runs after a response arrives (once per call, on the final response). Observe-only. */\n    readonly onResponse?: (response: {\n        readonly url: string;\n        readonly method: string;\n        readonly response: Response;\n    }) => MaybePromise<void>;\n    /** Abort a call that takes longer than this many ms. Surfaces as `{ ok: false, status: 0 }` with a\n     * `timeout` error, never a throw. Combined with a per-call `signal`. */\n    readonly timeoutMs?: number;\n    /** Enable safe automatic retries. See {@link ClientRetryOptions}. */\n    readonly retry?: ClientRetryOptions;\n}"
+  },
+  {
+    "name": "ClientRetryOptions",
+    "kind": "interface",
+    "package": "@nifrajs/client",
+    "signature": "export interface ClientRetryOptions {\n    /** Max RETRIES after the first attempt. Default 2. */\n    readonly attempts?: number;\n    /** Response statuses to retry. Default `[502, 503, 504]`. 4xx/429 are never added by default. */\n    readonly on?: readonly number[];\n    /** Methods eligible for retry. Default the idempotent set `GET/HEAD/OPTIONS/PUT/DELETE`. */\n    readonly methods?: readonly string[];\n    /** Delay (ms) before retry `n` (1-based). Default exponential backoff with jitter, capped at 3s. */\n    readonly backoff?: (attempt: number) => number;\n}",
+    "doc": "/** Safe retry policy. Off unless `retry` is set; retries ONLY idempotent methods and transient 5xx —\n * never a 4xx/429 and never a non-idempotent method, so a retry can't double a side effect. */"
   },
   {
     "name": "ClientRouter",
@@ -1491,6 +1511,13 @@
     "package": "@nifrajs/web",
     "signature": "export interface CloudflarePagesRoutesOptions {\n    /** Prerendered request paths (e.g. `prerenderRoutes(...).prerendered.map(p => p.path)`, or the\n     * build's `prerendered.json`). Each is excluded from the worker — plus its static `_data.json`. */\n    readonly prerendered: readonly string[];\n    /** Extra globs to keep OFF the worker (CDN-served). Default `[\"/assets/*\"]` (the hashed bundle). */\n    readonly staticGlobs?: readonly string[];\n}"
   },
+  {
+    "name": "codePositionMask",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function codePositionMask(src: string): string;",
+    "doc": "/** Blank comments and every quoted/template literal while preserving offsets. Unlike\n * {@link stripComments}, this is a code-position mask: scanners use it to find a call expression in\n * executable code, then inspect the original source for the call's literal argument. That prevents\n * documentation strings such as `const example = 'client(\"/\")'` from becoming diagnostics. */"
+  },
   {
     "name": "collectAssuranceReport",
     "kind": "function",
@@ -1626,7 +1653,7 @@
     "kind": "function",
     "package": "@nifrajs/web-react",
     "signature": "export declare function compose(chain: readonly unknown[], props: RenderProps): ReactNode;",
-    "doc": "/**\n * Fold a layout chain (outermost layout → page) into a single React tree: the page\n * (innermost) receives `props` (the loader data); each layout wraps the child via its\n * `children`. Shared by the server adapter (renderToString) and the client (hydrateRoot).\n *\n * The whole tree is wrapped in a {@link RouterContext} provider carrying the matched `params` + the\n * current `path` (both threaded through `RenderProps` identically on SSR and client), so the routing\n * hooks (`useParams`/`useLocation`/`useSearchParams`) read the same value on both sides — no hydration\n * mismatch. A render with no routing fields (a non-router adapter usage) provides the empty default.\n */"
+    "doc": "/**\n * Fold a layout chain (outermost layout → page) into a single React tree: the page\n * (innermost) receives `props` (the loader data); each layout wraps the child via its\n * `children`. Shared by the server adapter (renderToString) and the client (hydrateRoot).\n *\n * The whole tree is wrapped in a {@link RouterContext} provider carrying the matched `params`, the\n * current `path`, and the client `pending` flag (all threaded through `RenderProps` identically on SSR\n * and client), so the routing hooks (`useParams`/`useLocation`/`useNavigation`) read the same value on\n * both sides - no hydration mismatch (`pending` is `false` on SSR and on the initial client render).\n * A render with no routing fields (a non-router adapter usage) provides the empty default.\n */"
   },
   {
     "name": "compose",
@@ -1653,7 +1680,7 @@
     "name": "compression",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function compression(options?: CompressionOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function compression(options?: CompressionOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "doc": "/**\n * Transparently **gzip** responses when the client sends `Accept-Encoding: gzip` and the body is a\n * compressible type larger than `threshold`. Uses the Web-standard `CompressionStream` (streaming, no\n * full-body buffering), so it runs on every nifra runtime including the edge. gzip is the one encoding\n * `CompressionStream` guarantees everywhere; brotli isn't part of the standard, so it's not offered.\n *\n * The body is **peeked** up to `threshold` bytes to enforce the size floor: a response that ends below\n * the threshold is sent uncompressed (gzip's ~20-byte overhead would enlarge it), and only larger\n * bodies are compressed — the buffered prefix is replayed and the remainder streamed. (Runtimes rarely\n * set `Content-Length` on a constructed `Response`, so the header alone can't gate this.)\n *\n * Skips: clients that don't accept gzip, already-encoded responses, bodyless responses (204/304/HEAD),\n * `Range` responses (206 / `Content-Range`), `Cache-Control: no-transform`, and non-compressible types.\n * Adds `Vary: Accept-Encoding`.\n *\n * ```ts\n * app.use(compression())\n * ```\n */"
   },
   {
@@ -1694,14 +1721,14 @@
     "name": "consoleAgentExporter",
     "kind": "function",
     "package": "@nifrajs/agent-telemetry",
-    "signature": "export declare function consoleAgentExporter(log?: (line: string) => void): AgentSpanExporter;",
+    "signature": "export declare function consoleAgentExporter(log?: (line: string) => void): ObservationAdapter;",
     "doc": "/**\n * Pretty-prints agent tool call traces to the terminal.\n *\n * Output format:\n * ```\n * [agent] tool:get_weather 12ms ok (input: 45B, output: 128B)\n * ```\n */"
   },
   {
     "name": "consoleSpanExporter",
     "kind": "function",
     "package": "@nifrajs/otel",
-    "signature": "export declare function consoleSpanExporter(log?: (line: string) => void): SpanExporter;",
+    "signature": "export declare function consoleSpanExporter(log?: (line: string) => void): ObservationAdapter;",
     "doc": "/** A no-frills exporter that logs each completed span as one structured line. Useful in dev or as a\n * starting point before wiring a real backend. */"
   },
   {
@@ -1767,9 +1794,21 @@
     "name": "Context",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface Context<Path extends string = string, S extends RouteSchema = RouteSchema> {\n    readonly req: Request;\n    /**\n     * Alias of {@link req} — the same `Request`. Page loaders/actions receive their request as `request`;\n     * this alias lets route handlers and loaders share one name, so `c.request` and `ctx.req` both work\n     * everywhere (no more `c.req` vs `ctx.request` mismatch).\n     */\n    readonly request: Request;\n    readonly params: Params<Path>;\n    readonly query: QueryOf<S>;\n    readonly body: BodyOf<S>;\n    /** The request's cookies, parsed from the `Cookie` header (values URL-decoded). Parsed lazily on\n     * first access + cached. Signed cookies arrive as `value.signature` — verify with `unsignValue`. */\n    readonly cookies: Readonly<Record<string, string>>;\n    readonly set: ResponseControls;\n    /**\n     * Aborts when the server's `requestTimeoutMs` elapses (and never, when no timeout\n     * is configured). Pass it to cancellation-aware work — DB drivers, `fetch` — so a\n     * timed-out request stops doing work instead of running on after the 503.\n     */\n    readonly signal: AbortSignal;\n    /**\n     * Absolute request deadline plus monotonic remaining time. It shares {@link signal}; the server\n     * clamps an inbound deadline to local policy when `acceptInboundDeadlines` is enabled.\n     */\n    readonly budget: RequestBudget;\n    /**\n     * Platform bindings from `app.fetch(request, { env })` — Workers `env` (KV/D1/secrets), etc.\n     * `undefined` off-edge (Bun/Node/Deno). Declare the shape with `server<Env>()` to read it typed\n     * (`c.env: Env`); otherwise `unknown`. Validate at the trust boundary before use either way.\n     */\n    readonly env: unknown;\n    /**\n     * Schedule background work. On edge runtimes it extends the response lifetime (Workers\n     * `ctx.waitUntil`); off-edge it runs the promise fire-and-forget (a rejection is swallowed,\n     * never an unhandled rejection).\n     */\n    readonly waitUntil: (promise: Promise<unknown>) => void;\n    /**\n     * Read the raw request body as bytes, **capped** at `maxBytes` (default: the server's\n     * `maxBodyBytes`). For routes with **no body schema** — raw bodies, file uploads,\n     * BYO-validation — where the automatic schema cap doesn't apply. An over-cap body (by\n     * `Content-Length` or while streaming) throws a flat `413`; a malformed `Content-Length`\n     * throws `400`. Consumes the body stream (call once). Pass a larger `maxBytes` for an\n     * upload route, a smaller one to tighten a specific endpoint.\n     */\n    readonly boundedBody: (maxBytes?: number) => Promise<Uint8Array>;\n    /**\n     * `boundedBody` + `JSON.parse` (UTF-8). Same cap + `413`/`400` semantics; additionally\n     * throws a flat `400` on invalid JSON. Use for a schema-less JSON endpoint that still\n     * wants the body bounded.\n     */\n    readonly boundedJson: <T = unknown>(maxBytes?: number) => Promise<T>;\n    /**\n     * Build a JSON `Response`. Pass a status number or a full `ResponseInit` as the second arg. `return` it\n     * from a handler, or `throw` it from `derive`/`beforeHandle` to short-circuit — both work:\n     * `throw c.json({ error: \"unauthorized\" }, 401)`. A terser alternative to\n     * `new Response(JSON.stringify(...), { status, headers: { \"content-type\": \"application/json\" } })`.\n     */\n    readonly json: (body: unknown, init?: ResponseInit | number) => Response;\n    /** Build a `text/plain; charset=utf-8` `Response`. Like {@link json}, pass a status or `ResponseInit`. */\n    readonly text: (body: string, init?: ResponseInit | number) => Response;\n}",
+    "signature": "export interface Context<Path extends string = string, S extends RouteSchema = RouteSchema> {\n    readonly req: Request;\n    /**\n     * Alias of {@link req} — the same `Request`. Page loaders/actions receive their request as `request`;\n     * this alias lets route handlers and loaders share one name, so `c.request` and `ctx.req` both work\n     * everywhere (no more `c.req` vs `ctx.request` mismatch).\n     */\n    readonly request: Request;\n    readonly params: ParamsOf<S, Path>;\n    readonly query: QueryOf<S>;\n    readonly body: BodyOf<S>;\n    /** The request's cookies, parsed from the `Cookie` header (values URL-decoded). Parsed lazily on\n     * first access + cached. Signed cookies arrive as `value.signature` — verify with `unsignValue`. */\n    readonly cookies: Readonly<Record<string, string>>;\n    readonly set: ResponseControls;\n    /**\n     * Aborts when the server's `requestTimeoutMs` elapses (and never, when no timeout\n     * is configured). Pass it to cancellation-aware work — DB drivers, `fetch` — so a\n     * timed-out request stops doing work instead of running on after the 503.\n     */\n    readonly signal: AbortSignal;\n    /**\n     * Absolute request deadline plus monotonic remaining time. It shares {@link signal}; the server\n     * clamps an inbound deadline to local policy when `acceptInboundDeadlines` is enabled.\n     */\n    readonly budget: RequestBudget;\n    /**\n     * Platform bindings from `app.fetch(request, { env })` — Workers `env` (KV/D1/secrets), etc.\n     * `undefined` off-edge (Bun/Node/Deno). Declare the shape with `server<Env>()` to read it typed\n     * (`c.env: Env`); otherwise `unknown`. Validate at the trust boundary before use either way.\n     */\n    readonly env: unknown;\n    /**\n     * The caller's IP. By default the raw socket peer the serving adapter observed (`listen()`,\n     * `@nifrajs/node`, `@nifrajs/deno`) — the one address a client cannot forge — or `undefined` when the\n     * runtime exposes no socket (Workers) and no trust is declared. Behind a proxy/CDN, set the\n     * `clientIp` server option (`{ trustedHops }` or `{ header }`) to derive the real caller from the\n     * forwarding chain as far as you trust it; unset, no forwarded header is ever believed. Safe to key\n     * rate limits and audit logs on.\n     */\n    readonly clientIp: string | undefined;\n    /**\n     * Schedule background work. On edge runtimes it extends the response lifetime (Workers\n     * `ctx.waitUntil`); off-edge it runs the promise fire-and-forget (a rejection is swallowed,\n     * never an unhandled rejection).\n     */\n    readonly waitUntil: (promise: Promise<unknown>) => void;\n    /**\n     * Read the raw request body as bytes, **capped** at `maxBytes` (default: the server's\n     * `maxBodyBytes`). For routes with **no body schema** — raw bodies, file uploads,\n     * BYO-validation — where the automatic schema cap doesn't apply. An over-cap body (by\n     * `Content-Length` or while streaming) throws a flat `413`; a malformed `Content-Length`\n     * throws `400`. Consumes the body stream (call once). Pass a larger `maxBytes` for an\n     * upload route, a smaller one to tighten a specific endpoint.\n     */\n    readonly boundedBody: (maxBytes?: number) => Promise<Uint8Array>;\n    /**\n     * `boundedBody` + `JSON.parse` (UTF-8). Same cap + `413`/`400` semantics; additionally\n     * throws a flat `400` on invalid JSON. Use for a schema-less JSON endpoint that still\n     * wants the body bounded.\n     */\n    readonly boundedJson: <T = unknown>(maxBytes?: number) => Promise<T>;\n    /**\n     * Build a JSON `Response`. Pass a status number or a full `ResponseInit` as the second arg. `return` it\n     * from a handler, or `throw` it from `derive`/`beforeHandle` to short-circuit — both work:\n     * `throw c.json({ error: \"unauthorized\" }, 401)`. A terser alternative to\n     * `new Response(JSON.stringify(...), { status, headers: { \"content-type\": \"application/json\" } })`.\n     */\n    readonly json: (body: unknown, init?: ResponseInit | number) => Response;\n    /** Build a `text/plain; charset=utf-8` `Response`. Like {@link json}, pass a status or `ResponseInit`. */\n    readonly text: (body: string, init?: ResponseInit | number) => Response;\n}",
     "doc": "/**\n * Handler context. `params` are inferred from the path; `body` and `query` are\n * the validated outputs of their schemas when declared (else `undefined` /\n * raw `URLSearchParams`).\n */"
   },
+  {
+    "name": "CONTEXT_SEARCH",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const CONTEXT_SEARCH: unique symbol;"
+  },
+  {
+    "name": "CONTEXT_SET",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const CONTEXT_SET: unique symbol;"
+  },
   {
     "name": "ContextFilter",
     "kind": "interface",
@@ -1909,6 +1948,13 @@
     "package": "@nifrajs/cli",
     "signature": "export declare function countBodyHits(lowerBody: string, group: SearchTermGroup, maxHits: number): number;"
   },
+  {
+    "name": "Counter",
+    "kind": "class",
+    "package": "@nifrajs/otel",
+    "signature": "export declare class Counter {\n    readonly name: string;\n    readonly help: string;\n    private readonly series;\n    constructor(name: string, help: string);\n    inc(labels?: Labels, by?: number): void;\n    render(): string;\n}",
+    "doc": "/** A monotonically increasing counter (requests, errors). */"
+  },
   {
     "name": "createAdmissionController",
     "kind": "function",
@@ -1963,6 +2009,13 @@
     "signature": "export declare function createDevServer(options: DevServerOptions): Promise<DevServer>;",
     "doc": "/** Start the dev server: build → serve → watch → rebuild + reload on change. */"
   },
+  {
+    "name": "createEffectLedgerRuntime",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createEffectLedgerRuntime(options: EffectLedgerOptions): EffectLedgerRuntime;",
+    "doc": "/**\n * Build an effect-ledger runtime from the app-wide options. `sink` receives the sealed, token-only\n * ledger when a capability-declaring route settles with recorded entries; `maxEntries` bounds a single\n * request's ledger; `chain` opts into the per-entry hash chain.\n */"
+  },
   {
     "name": "createEventLoopLagSampler",
     "kind": "function",
@@ -1998,6 +2051,13 @@
     "signature": "export declare function createFormatter(locale: string, messages: Messages): Formatter;",
     "doc": "/**\n * Build (or reuse) a {@link Formatter} bound to a locale + its message catalog. Cheap to call per\n * request/render — instances are cached per `(messages, locale)`, and parsed ASTs + `Intl.*` are\n * memoized inside each. The catalog is the app's (import a JSON file); this only negotiates (see\n * `negotiateLocale`) and formats.\n */"
   },
+  {
+    "name": "createIdempotencyRuntime",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function createIdempotencyRuntime(options?: IdempotencyPluginOptions): IdempotencyRuntime;",
+    "doc": "/**\n * Build an idempotency runtime. `store` is the app-wide default backing routes that declare\n * `schema.idempotency` without their own `store`; when omitted, a shared in-process\n * {@link MemoryIdempotencyStore} is created lazily on first idempotent route.\n */"
+  },
   {
     "name": "createImageHandler",
     "kind": "function",
@@ -2051,6 +2111,13 @@
     "signature": "export declare function createMemoryLedgerSink(options?: MemoryLedgerSinkOptions): MemoryLedgerSink;",
     "doc": "/** Bounded in-memory sink for tests and local development. Token-only, like every sink. */"
   },
+  {
+    "name": "createMetricsRegistry",
+    "kind": "function",
+    "package": "@nifrajs/otel",
+    "signature": "export declare function createMetricsRegistry(): MetricsRegistry;",
+    "doc": "/** Create a standalone registry to register custom app metrics on, shared into `metrics({ registry })`. */"
+  },
   {
     "name": "createMockServer",
     "kind": "function",
@@ -2132,13 +2199,6 @@
     "signature": "export declare function createScheduler(options?: SchedulerOptions): Scheduler;",
     "doc": "/** Create an in-process cron scheduler. */"
   },
-  {
-    "name": "createSeededRandom",
-    "kind": "function",
-    "package": "@nifrajs/core",
-    "signature": "export declare function createSeededRandom(seed: number): () => number;",
-    "doc": "/** Deterministic PRNG (mulberry32). Ambient randomness would make failures unreproducible. */"
-  },
   {
     "name": "createSessions",
     "kind": "function",
@@ -2177,7 +2237,7 @@
     "name": "CreateWebAppOptions",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface CreateWebAppOptions {\n    readonly adapter: RenderAdapter;\n    readonly manifest: Manifest;\n    /** URL of the built client entry (module script) injected into every page. */\n    readonly clientEntry: string;\n    /** Default document title for all pages. */\n    readonly title?: string;\n    /** Injected into each loader's `ctx.api` — typically an `inProcessClient(app)` (typed\n     * per-route via `@nifrajs/client`'s `createRoutes`). Opaque to the core.\n     *\n     * **Auto-mount.** Every `inProcessClient(backend)` exposes the symbol-keyed platform-aware backend\n     * mount interface from `@nifrajs/core/mount`; `createWebApp` also serves that backend over HTTP at\n     * {@link apiPrefix} (default `/api`): a request whose pathname starts with the prefix is dispatched\n     * before page routing with the same `env`/`waitUntil` platform context, and the backend's `Response`\n     * is returned untouched. Legacy custom `.fetch(url, init)` bridges remain mountable but cannot\n     * receive platform context. 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` has neither the symbol mount nor a legacy callable `.fetch`. */\n    readonly apiPrefix?: string;\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. from `enumeratePrerenderedPaths` or the build's\n     * `prerendered.json`). Injected as `window.__NIFRA_PRERENDERED__` on every page so a client soft-nav\n     * into a prerendered route fetches its static `_data.json` instead of hitting the worker. */\n    readonly prerenderedPaths?: readonly string[];\n    /** SSG: per dynamic route pattern, its `getStaticPaths` `fallback` (from `enumerateStaticRoutes` or\n     * the build's `prerendered.json`). A route mapped to `\"404\"` rejects any path NOT in\n     * `prerenderedPaths` with the 404 page — the unlisted path simply doesn't exist. `\"ssr\"` (the\n     * default for unmapped routes) renders unlisted paths on-demand. */\n    readonly staticFallbacks?: Readonly<Record<string, \"ssr\" | \"404\">>;\n    /** Observe every loader/action failure — for error-reporting plugins (Sentry-style). Called for\n     * real throws (not control-flow `Response`s like `redirect`), **before** the nearest `_error`\n     * boundary renders / a soft-nav 500 / a rethrow — so it sees errors that the boundary would\n     * otherwise hide. Observation only; its own throws are swallowed so a faulty reporter can't break\n     * rendering. (`beforeLoader` is intentionally omitted — the core HTTP hooks already cover\n     * pre-request work.) */\n    readonly onLoaderError?: (error: unknown, ctx: {\n        readonly request: Request;\n        readonly params: Readonly<Record<string, string>>;\n        readonly route: string;\n    }) => void;\n}"
+    "signature": "export interface CreateWebAppOptions {\n    readonly adapter: RenderAdapter;\n    readonly manifest: Manifest;\n    /** URL of the built client entry (module script) injected into every page. */\n    readonly clientEntry: string;\n    /** Default document title for all pages. */\n    readonly title?: string;\n    /** Injected into each loader's `ctx.api` — typically an `inProcessClient(app)` (typed\n     * per-route via `@nifrajs/client`'s `createRoutes`). Opaque to the core.\n     *\n     * **Auto-mount.** Every `inProcessClient(backend)` exposes the symbol-keyed platform-aware backend\n     * mount interface from `@nifrajs/core/mount`; `createWebApp` also serves that backend over HTTP at\n     * {@link apiPrefix} (default `/api`): a request whose pathname starts with the prefix is dispatched\n     * before page routing with the same `env`/`waitUntil` platform context, and the backend's `Response`\n     * is returned untouched. The mount runs in `nifra dev` too. Pass `apiPrefix: \"\"` to disable it. */\n    readonly api?: unknown;\n    /** HTTP path prefix the {@link api} backend is auto-mounted at (default `\"/api\"`). A request whose\n     * pathname is exactly the prefix or starts with `prefix + \"/\"` is dispatched to the backend before\n     * page routing; the backend therefore defines its routes at the **full** path (`server().post(\"/api/\n     * sync\", …)`), matching the in-process `inProcessClient` call sites. Set to `\"\"` to disable the\n     * auto-mount entirely (the app serves pages only and `api` stays a loader-only `ctx.api`). Mounting\n     * is also a no-op when `api` does not expose the symbol mount. */\n    readonly apiPrefix?: string;\n    /** Secret for **draft / preview mode** (see `enableDraft`). When set, a request carrying a valid\n     * signed `__nifra_draft` cookie gets `ctx.draft === true` in loaders/actions (else always `false`).\n     * Pair with `withISR({ draftSecret })` so editors bypass the cache. Omit to disable draft mode. */\n    readonly draftSecret?: string;\n    /** Per-route chunk URLs (`buildClient`'s `BuildManifest.routes`) — `routeId → [layout chunks…, own\n     * chunk]`. When present, each page `modulepreload`s its matched route's chunks alongside the entry,\n     * so the route code downloads in parallel (no entry→route-chunk waterfall). Omit ⇒ entry-only. */\n    readonly routePreload?: Readonly<Record<string, readonly string[]>>;\n    /** The app's bundled stylesheet URLs (`buildClient`'s `BuildManifest.css`) — the aggregate, injected\n     * as `<link rel=\"stylesheet\">` in a page's `<head>`. Used as the fallback for any route absent from\n     * {@link routeStyles}. Omit ⇒ no links (dev, where Vite injects CSS, or a CSS-free app). */\n    readonly styles?: readonly string[];\n    /** Per-route stylesheet URLs (`buildClient`'s `BuildManifest.routeStyles`) — `routeId → [chain CSS]`.\n     * When a matched route has an entry here, only those (its layout chain + own CSS) are linked instead\n     * of the aggregate `styles`, so a page ships only the CSS it uses. An empty array ⇒ no `<link>` (the\n     * page imports no CSS). Routes absent here fall back to `styles`. Omit ⇒ always use `styles`. */\n    readonly routeStyles?: Readonly<Record<string, readonly string[]>>;\n    /** SSG: the prerendered-path set (e.g. `enumerateStaticRoutes(routes).paths` or the build's\n     * `prerendered.json`). Injected as `window.__NIFRA_PRERENDERED__` on every page so a client soft-nav\n     * into a prerendered route fetches its static `_data.json` instead of hitting the worker. */\n    readonly prerenderedPaths?: readonly string[];\n    /** SSG: per dynamic route pattern, its `getStaticPaths` `fallback` (from `enumerateStaticRoutes` or\n     * the build's `prerendered.json`). A route mapped to `\"404\"` rejects any path NOT in\n     * `prerenderedPaths` with the 404 page — the unlisted path simply doesn't exist. `\"ssr\"` (the\n     * default for unmapped routes) renders unlisted paths on-demand. */\n    readonly staticFallbacks?: Readonly<Record<string, \"ssr\" | \"404\">>;\n    /** Observe every loader/action failure — for error-reporting plugins (Sentry-style). Called for\n     * real throws (not control-flow `Response`s like `redirect`), **before** the nearest `_error`\n     * boundary renders / a soft-nav 500 / a rethrow — so it sees errors that the boundary would\n     * otherwise hide. Observation only; its own throws are swallowed so a faulty reporter can't break\n     * rendering. (`beforeLoader` is intentionally omitted — the core HTTP hooks already cover\n     * pre-request work.) */\n    readonly onLoaderError?: (error: unknown, ctx: {\n        readonly request: Request;\n        readonly params: Readonly<Record<string, string>>;\n        readonly route: string;\n    }) => void;\n}"
   },
   {
     "name": "CronError",
@@ -2239,6 +2299,13 @@
     "signature": "export declare function cssModulesBunPlugin(generate: \"dom\" | \"ssr\"): BunPlugin;",
     "doc": "/**\n * The CSS Modules Bun plugin. `\"dom\"` → the `.module.css` import becomes the class map AND emits the\n * scoped stylesheet as a virtual `?nifra-css-module` module that `Bun.build`'s CSS bundler folds into\n * the app stylesheet. `\"ssr\"` → the class map only (no CSS; the scoped names match the client build).\n * Tolerates a trailing `?query` on the path (dev servers append one to bust Bun's import cache).\n */"
   },
+  {
+    "name": "CtxSet",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type CtxSet = ResponseControls & {\n    _headers?: Record<string, string>;\n    /** Accumulated `Set-Cookie` values — a list, since a `Record` would collapse multiple cookies. */\n    _cookies?: string[];\n};",
+    "doc": "/** `ctx.set` carrying the lazy backings (`_headers`, `_cookies`) so `toResponse` can skip allocating\n * anything when no handler touched `c.set.*`. Server-internal. */"
+  },
   {
     "name": "CURSOR_MCP_JSON_PATH",
     "kind": "const",
@@ -2510,19 +2577,19 @@
     "kind": "function",
     "package": "@nifrajs/core",
     "signature": "export declare function defineIdentityPlugin(name: string, apply: <S extends AnyServer>(app: S) => S): IdentityPlugin;",
-    "doc": "/**\n * Define a type-**identity** plugin: it registers routes/hooks as a side effect but returns the app with\n * its `Registry` + `Context` UNCHANGED. Use this (not {@link definePlugin}) for any plugin that doesn't\n * add context types — e.g. one mounting an auth handler. It threads the caller's *concrete* server type\n * through `use`, so routes declared after `app.use(plugin)` keep their types.\n *\n * Why a dedicated helper: `definePlugin((app) => app)` infers `app: Server<any, any>`, so `use` returns\n * `Server<any, any>` and the whole typed client collapses to `any`. The explicit generic return type here\n * (which a plain `Object.assign` can't preserve) is what keeps `use` returning the precise server type.\n *\n * ```ts\n * export const audit = defineIdentityPlugin(\"audit\", (app) => app.onResponse(logResponse))\n * const api = server().get(\"/a\", h).use(audit).get(\"/b\", h) // /a AND /b stay typed\n * ```\n */"
+    "doc": "/**\n * Define a type-**identity** plugin: it registers routes/hooks as a side effect but returns the app with\n * its `Registry` + `Context` UNCHANGED. Use this (not {@link definePlugin}) for any plugin that doesn't\n * add context types - e.g. one mounting an auth handler. It threads the caller's *concrete* server type\n * through `use`, so routes declared after `app.use(plugin)` keep their types.\n *\n * Why a dedicated helper: `definePlugin((app) => app)` infers `app: Server<any, any>`, so `use` returns\n * `Server<any, any>` and the whole typed client collapses to `any`. The explicit generic return type here\n * (which a plain `Object.assign` can't preserve) is what keeps `use` returning the precise server type.\n *\n * ```ts\n * export const audit = defineIdentityPlugin(\"audit\", (app) => app.onResponse(logResponse))\n * const api = server().get(\"/a\", h).use(audit).get(\"/b\", h) // /a AND /b stay typed\n * ```\n */"
   },
   {
     "name": "defineMcpTool",
     "kind": "function",
     "package": "@nifrajs/mcp",
-    "signature": "export declare function defineMcpTool(opts: DefineMcpToolOptions): McpTool;"
+    "signature": "export declare function defineMcpTool<S extends StandardSchemaV1 = UntypedArgs>(opts: DefineMcpToolOptions<S>): McpTool;"
   },
   {
     "name": "DefineMcpToolOptions",
     "kind": "interface",
     "package": "@nifrajs/mcp",
-    "signature": "export interface DefineMcpToolOptions {\n    readonly name: string;\n    readonly description: string;\n    /** JSON Schema for the arguments. Defaults to an empty object schema. */\n    readonly inputSchema?: Record<string, unknown>;\n    /** Link a widget so the tool's result renders as interactive UI in MCP Apps hosts (iframe). */\n    readonly widget?: McpWidget;\n    /** Render-intent for generative hosts that build their own themed UI from `structuredContent`. Lands\n     * in `_meta.ui.intent`. Independent of `widget` — a tool can offer both (widget for MCP Apps hosts,\n     * intent for generative builders). */\n    readonly intent?: McpUiIntent;\n    readonly handler: (args: Record<string, unknown>, context: McpToolContext) => McpToolHandlerResult | Promise<McpToolHandlerResult>;\n}"
+    "signature": "export interface DefineMcpToolOptions<S extends StandardSchemaV1 = UntypedArgs> {\n    readonly name: string;\n    readonly description: string;\n    /**\n     * A Standard Schema for the arguments (nifra's `t`, zod, valibot, arktype, …). It validates every\n     * call before the handler runs - invalid arguments return an in-band `isError` result naming each\n     * issue, so the calling agent can correct and retry - and it types the handler's `args`. Schemas\n     * that carry a JSON Schema (nifra's `t` does) also become the advertised `inputSchema` for free.\n     */\n    readonly input?: S;\n    /**\n     * JSON Schema for the wire descriptor (`tools/list`). Defaults to `input`'s own JSON Schema when\n     * it exposes one, else an empty object schema. Pass explicitly when `input` comes from a vendor\n     * whose schemas carry no JSON Schema, so the agent still sees real parameter docs.\n     */\n    readonly inputSchema?: Record<string, unknown>;\n    /** Link a widget so the tool's result renders as interactive UI in MCP Apps hosts (iframe). */\n    readonly widget?: McpWidget;\n    /** Render-intent for generative hosts that build their own themed UI from `structuredContent`. Lands\n     * in `_meta.ui.intent`. Independent of `widget` — a tool can offer both (widget for MCP Apps hosts,\n     * intent for generative builders). */\n    readonly intent?: McpUiIntent;\n    readonly handler: (args: InferOutput<S>, context: McpToolContext) => McpToolHandlerResult | Promise<McpToolHandlerResult>;\n}"
   },
   {
     "name": "defineMcpWidget",
@@ -2541,14 +2608,14 @@
     "kind": "function",
     "package": "@nifrajs/core",
     "signature": "export declare function definePlugin<In extends AnyServer, Out extends AnyServer>(name: string, apply: (app: In) => Out): NifraPlugin<In, Out>;",
-    "doc": "/**\n * Name + ergonomics for a plugin that **adds typed context** (`derive`/`decorate`). `app.use(myPlugin)`\n * applies it once; a second `use` of the same name is skipped (idempotent), so plugins can depend on each\n * other without double-registering hooks.\n *\n * ```ts\n * export const requestId = definePlugin(\"requestId\", (app) => app.derive(() => ({ requestId: uuid() })))\n * app.use(requestId)   // downstream handlers see c.requestId\n * ```\n *\n * FOOTGUN: only use this for a plugin that adds context. For a plugin that **mounts routes/hooks but adds\n * NO context** (an auth router, an audit logger), use {@link defineRouterPlugin} ({@link defineIdentityPlugin}).\n * `definePlugin((app) => app.get(...))` infers `app: Server<any, any>`, so `.use()` returns `Server<any, any>`\n * and your whole typed client silently collapses to `any` — no type error, no runtime error.\n */"
+    "doc": "/**\n * Name + ergonomics for a plugin that **adds typed context** (`derive`/`decorate`). `app.use(myPlugin)`\n * applies it once; a second `use` of the same name is skipped (idempotent), so plugins can depend on each\n * other without double-registering hooks.\n *\n * ```ts\n * export const requestId = definePlugin(\"requestId\", (app) => app.derive(() => ({ requestId: uuid() })))\n * app.use(requestId)   // downstream handlers see c.requestId\n * ```\n *\n * FOOTGUN: only use this for a plugin that adds context. For a plugin that **mounts routes/hooks but adds\n * NO context** (an auth router, an audit logger), use {@link defineRouterPlugin} ({@link defineIdentityPlugin}).\n * `definePlugin((app) => app.get(...))` infers `app: Server<any, any>`, so `.use()` returns `Server<any, any>`\n * and your whole typed client silently collapses to `any` - no type error, no runtime error.\n */"
   },
   {
     "name": "defineRouterPlugin",
     "kind": "const",
     "package": "@nifrajs/core",
     "signature": "export declare const defineRouterPlugin: typeof defineIdentityPlugin;",
-    "doc": "/**\n * Alias of {@link defineIdentityPlugin} with a name that says what it's FOR: a plugin that **mounts\n * routes/hooks but adds no context type** (an auth router, an audit logger). Use this — not\n * {@link definePlugin} — for any such plugin, or the typed client silently collapses to `any`. The\n * \"identity\" in {@link defineIdentityPlugin} refers to the type-identity it preserves; `defineRouterPlugin`\n * is the same thing under a clearer name.\n *\n * Mount routes as a **side effect**, then return the app unchanged (registering via `.get`/`.post` would\n * change the type away from the identity `S`; the mounted routes run but aren't in the caller's typed\n * registry — that's the trade that keeps everything else typed):\n *\n * ```ts\n * export const scim = defineRouterPlugin(\"scim\", (app) => {\n *   app.get(\"/scim/v2/Users\", listUsers) // side effect: mounted at runtime\n *   return app                           // return S unchanged → routes added after .use(scim) stay typed\n * })\n * const api = server().get(\"/a\", h).use(scim).get(\"/b\", h) // /a AND /b stay typed\n * ```\n */"
+    "doc": "/**\n * Alias of {@link defineIdentityPlugin} with a name that says what it's FOR: a plugin that **mounts\n * routes/hooks but adds no context type** (an auth router, an audit logger). Use this - not\n * {@link definePlugin} - for any such plugin, or the typed client silently collapses to `any`. The\n * \"identity\" in {@link defineIdentityPlugin} refers to the type-identity it preserves; `defineRouterPlugin`\n * is the same thing under a clearer name.\n *\n * Mount routes as a **side effect**, then return the app unchanged (registering via `.get`/`.post` would\n * change the type away from the identity `S`; the mounted routes run but aren't in the caller's typed\n * registry - that's the trade that keeps everything else typed):\n *\n * ```ts\n * export const scim = defineRouterPlugin(\"scim\", (app) => {\n *   app.get(\"/scim/v2/Users\", listUsers) // side effect: mounted at runtime\n *   return app                           // return S unchanged → routes added after .use(scim) stay typed\n * })\n * const api = server().get(\"/a\", h).use(scim).get(\"/b\", h) // /a AND /b stay typed\n * ```\n */"
   },
   {
     "name": "DehydratedState",
@@ -2557,6 +2624,19 @@
     "signature": "export interface DehydratedState {\n    readonly queries: ReadonlyArray<{\n        readonly key: unknown;\n        readonly data: unknown;\n        readonly updatedAt: number;\n    }>;\n}",
     "doc": "/** A serializable snapshot of the cache's successful queries — the SSR→client bridge payload. */"
   },
+  {
+    "name": "DependencyMove",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface DependencyMove {\n    readonly from: string;\n    readonly to: string;\n    readonly toVersion: string;\n}",
+    "doc": "/** Move a removed package dependency to its replacement, preserving the consumer's range style. */"
+  },
+  {
+    "name": "DependencyMoveChange",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface DependencyMoveChange {\n    readonly file: string;\n    readonly field: string;\n    readonly from: string;\n    readonly to: string;\n    readonly fromVersion: string;\n    readonly toVersion: string;\n    readonly action: \"renamed\" | \"removed\";\n}"
+  },
   {
     "name": "describeProject",
     "kind": "function",
@@ -2629,7 +2709,7 @@
     "name": "devtools",
     "kind": "function",
     "package": "@nifrajs/devtools",
-    "signature": "export declare function devtools(options?: DevToolsOptions | undefined): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function devtools(options?: DevToolsOptions | undefined): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "doc": "/**\n * DevTools plugin. Its observation adapter projects the single request span into a\n * `DevToolsEvent`; its middleware only owns the secured SSE transport.\n * When configuring `tracing()` yourself, register it before this plugin so DevTools attaches to\n * that request owner.\n */"
   },
   {
@@ -2833,6 +2913,13 @@
     "signature": "export interface EffectEntryInput {\n    /** Capability token (`db.write`, `payments.charge`). Must be a valid capability id. */\n    readonly capability: string;\n    /** Default `\"intent\"`. Record `committed`/`failed`/`compensated` only after the outcome is known. */\n    readonly phase?: EffectPhase;\n    /** Adapter/resource token (`repo:orders`, `provider:payments`). A token — never a value or a row. */\n    readonly target?: string;\n    /** Dimensionless counters; see {@link EffectCost}. At most {@link MAX_COST_AXES} axes. */\n    readonly cost?: EffectCost;\n    /** Optional keyed-HMAC digest of the effect payload (see {@link computeEffectDigest}); hex, 64 chars. */\n    readonly digest?: string;\n    /** Outcome error as a bounded token code — never a message, never a stack. */\n    readonly error?: {\n        readonly code: string;\n    };\n}",
     "doc": "/** Caller-supplied fields for one entry. Everything else (`seq`, `at`) is assigned by the ledger. */"
   },
+  {
+    "name": "effectLedger",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function effectLedger(options: EffectLedgerOptions): IdentityPlugin;",
+    "doc": "/**\n * Enable the per-request effect ledger. Each route that declares `schema.capabilities` gets a bounded,\n * token-only ledger; `useCapability(c, id, …)` appends one entry per effect, and the sink receives the\n * sealed ledger when the response settles (only when it recorded entries). Token-only by construction -\n * capability ids, phases, counters, digests; never payloads, values, or the concrete URL (the route\n * pattern is recorded). Without this plugin, capability-declaring routes simply carry no ledger.\n */"
+  },
   {
     "name": "effectLedgerOf",
     "kind": "function",
@@ -2854,6 +2941,13 @@
     "signature": "export declare class EffectLedgerOverflowError extends Error {\n    readonly maxEntries: number;\n    constructor(maxEntries: number);\n}",
     "doc": "/** Thrown by `append` when the per-request entry bound is exceeded. Fails the request closed. */"
   },
+  {
+    "name": "EffectLedgerRuntime",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface EffectLedgerRuntime {\n    /** Resolve a capability-declaring route into its ledger wiring, or `undefined` when it declares none. */\n    resolve(capabilities: readonly string[], method: string, path: string): ResolvedEffectLedger | undefined;\n    /** Create the per-request ledger for a ledgered route. */\n    create(resolved: ResolvedEffectLedger): RequestLedger;\n    /** Attach a ledger to the request context so `useCapability` can append to it. */\n    attach(context: object, ledger: RequestLedger): void;\n    /** Seal the ledger and deliver it to the sink (empty ledgers are not delivered). */\n    settle<T>(ledger: RequestLedger, resolved: ResolvedEffectLedger, value: T, onSinkError: (fields: {\n        method: string;\n        path: string;\n        name: string;\n    }) => void): Promise<T>;\n}",
+    "doc": "/** The injected effect-ledger implementation the kernel calls through when the plugin is installed. */"
+  },
   {
     "name": "EffectLedgerSealedError",
     "kind": "class",
@@ -2874,6 +2968,12 @@
     "package": "@nifrajs/core",
     "signature": "export declare const EMPTY_PARAMS: Record<string, string>;"
   },
+  {
+    "name": "EMPTY_RESPONSE_CONTROLS",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const EMPTY_RESPONSE_CONTROLS: CtxSet;"
+  },
   {
     "name": "EmptyRegistry",
     "kind": "type",
@@ -2920,13 +3020,6 @@
     "signature": "export declare function ensureDefaultFormats(): void;",
     "doc": "/**\n * Install the standard string formats into TypeBox's global `FormatRegistry`, once.\n *\n * This is driven from the validate path (see `./adapter.ts`) rather than run as a bare\n * top-level import side effect *on purpose*: a production bundler (`Bun.build`, esbuild)\n * tree-shakes a module that is only imported for its effect, and Bun.build does **not**\n * honor the `sideEffects` package.json field — so the old top-level registration loop was\n * dropped from prod server bundles, making every `t.string({ format })` reject with\n * \"Unknown format\" while unbundled `nifra dev` worked. Calling this from code the validator\n * actually reaches keeps the registration in the bundle.\n *\n * Idempotent and cheap to call on every validate (a single boolean check after the first\n * run). The `Has` guard means a format a consumer registered first via {@link registerFormat}\n * is left untouched.\n */"
   },
-  {
-    "name": "enumeratePrerenderedPaths",
-    "kind": "function",
-    "package": "@nifrajs/web",
-    "signature": "export declare function enumeratePrerenderedPaths(routes: readonly RouteEntry[]): Promise<string[]>;",
-    "doc": "/** The prerendered-path subset of {@link enumerateStaticRoutes} — kept for callers that only need the\n * paths (e.g. injecting `window.__NIFRA_PRERENDERED__`). */"
-  },
   {
     "name": "enumerateStaticRoutes",
     "kind": "function",
@@ -3004,11 +3097,18 @@
     "signature": "export declare function errorBoundary(fallback: unknown): unknown;",
     "doc": "/**\n * Build an error-boundary chain element bound to `fallback` (a route's `_error` component). nifra's\n * client codegen inserts it before the page in the matched chain; a render error in the subtree is\n * captured (`onErrorCaptured`) and renders `fallback` with `{ data: { name, message } }` instead of\n * crashing. DOM-transparent (renders the default slot directly), so it never disturbs hydration.\n */"
   },
+  {
+    "name": "ErrorStatus",
+    "kind": "type",
+    "package": "@nifrajs/client",
+    "signature": "export type ErrorStatus = 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;",
+    "doc": "/**\n * The failure statuses a call can carry (the IANA registry's 3xx/4xx/5xx set). Finite on purpose:\n * the undeclared-status fallback arm of {@link Result} is `Exclude<ErrorStatus, declared>` - with a\n * bare `number` there instead, `status === 404` could not narrow `data` to the declared 404 body,\n * because 404 would still inhabit the fallback arm.\n */"
+  },
   {
     "name": "etag",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function etag(options?: ETagOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function etag(options?: ETagOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "doc": "/**\n * A {@link definePlugin} plugin that adds a content-hash `ETag` to `GET` `200` responses and returns\n * **`304 Not Modified`** when the client's `If-None-Match` matches — saving bandwidth on unchanged\n * responses. It reads and rebuilds small bodies only; larger responses pass through unchanged.\n * Idempotent.\n */"
   },
   {
@@ -3179,6 +3279,13 @@
     "package": "@nifrajs/testing",
     "signature": "export interface FailureScenarioReport {\n    readonly name: string;\n    readonly ok: boolean;\n    readonly replay: FailureReplay;\n    readonly evidence: readonly FailureEvidence[];\n    /** Sanitized failure identity. Messages and stacks are deliberately excluded. */\n    readonly error?: {\n        readonly name: string;\n        readonly kind?: FailureInjectedError[\"kind\"];\n    };\n}"
   },
+  {
+    "name": "fallbackWaitUntil",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const fallbackWaitUntil: (promise: Promise<unknown>) => void;",
+    "doc": "/** Off-edge `waitUntil`: run the background work fire-and-forget, never leaking an unhandled\n * rejection. Edge runtimes pass their own (Workers `ctx.waitUntil`) via the platform arg. */"
+  },
   {
     "name": "FEATURE_IDS",
     "kind": "const",
@@ -3248,13 +3355,6 @@
     "signature": "export type FetcherStore = Readable<FetcherState> & {\n    /** Load a route path's loader data into this fetcher (concurrent; doesn't touch the active view). */\n    readonly load: (path: string) => Promise<void>;\n    /** Submit an action into this fetcher (concurrent); honors `X-Nifra-Revalidate`. */\n    readonly submit: (action: string, body: NonNullable<RequestInit[\"body\"]>) => Promise<void>;\n};",
     "doc": "/** A fetcher store: a `Readable<FetcherState>` (read via `$`) plus imperative `load`/`submit`. */"
   },
-  {
-    "name": "FetchFinding",
-    "kind": "type",
-    "package": "@nifrajs/cli",
-    "signature": "export type FetchFinding = SourceFinding;",
-    "doc": "/** @deprecated kept for back-compat with existing tests; prefer {@link SourceFinding}. */"
-  },
   {
     "name": "FetchFn",
     "kind": "type",
@@ -3266,7 +3366,7 @@
     "name": "FetchHandler",
     "kind": "interface",
     "package": "@nifrajs/node",
-    "signature": "export interface FetchHandler {\n    fetch(request: Request): 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): WsUpgradeOutcome | Promise<WsUpgradeOutcome>;\n}",
     "doc": "/** Anything exposing a Web `fetch` handler — a nifra `app`, for instance. */"
   },
   {
@@ -3322,7 +3422,7 @@
     "kind": "function",
     "package": "@nifrajs/web",
     "signature": "export declare function fillRoutePattern(pattern: string, params: Record<string, string>): {\n    path: string;\n    missing: string[];\n};",
-    "doc": "/**\n * Substitute a route pattern's `:param` segments with concrete values: `/users/:id` + `{id:\"7\"}` →\n * `/users/7`. Returns the filled path plus any params that had no value (a `getStaticPaths` bug) so\n * the caller can skip rather than emit a path with a literal `:name`. Shared by the SSG driver and\n * {@link enumeratePrerenderedPaths}.\n */"
+    "doc": "/**\n * Substitute a route pattern's `:param` segments with concrete values: `/users/:id` + `{id:\"7\"}` →\n * `/users/7`. Returns the filled path plus any params that had no value (a `getStaticPaths` bug) so\n * the caller can skip rather than emit a path with a literal `:name`. Shared by the SSG driver and\n * {@link enumerateStaticRoutes}.\n */"
   },
   {
     "name": "fixedBackoff",
@@ -3335,7 +3435,7 @@
     "name": "Flags",
     "kind": "interface",
     "package": "@nifrajs/cli",
-    "signature": "export interface Flags {\n    readonly port: number;\n    readonly out: string;\n    readonly poll: boolean;\n    /** `nifra build --target <t>`: emit a full deploy dir for a target (bun/node/deno/cf-pages/vercel/\n     * static) instead of just the client bundle. Undefined ⇒ the legacy client-only build. */\n    readonly target?: string;\n    /** `nifra build --report`: print a per-chunk size + gzip table after the build. */\n    readonly report: boolean;\n}"
+    "signature": "export interface Flags {\n    readonly port: number;\n    readonly out: string;\n    readonly poll: boolean;\n    /** `nifra build --target <t>`: emit a full deploy dir for this target. Defaults to `bun`. */\n    readonly target: string;\n    /** `nifra build --report`: print a per-chunk size + gzip table after the build. */\n    readonly report: boolean;\n}"
   },
   {
     "name": "FontAsset",
@@ -3409,6 +3509,13 @@
     "signature": "export declare function formatDiff(diff: RoutesDiff): string;",
     "doc": "/** Render a diff for terminals: breaking first, then info, then compatible. */"
   },
+  {
+    "name": "formatIssues",
+    "kind": "function",
+    "package": "@nifrajs/mcp",
+    "signature": "export declare function formatIssues(issues: ReadonlyArray<StandardIssue>): string;",
+    "doc": "/** Render issues as one agent-readable line per problem: `location: message`. */"
+  },
   {
     "name": "formatManifestDiff",
     "kind": "function",
@@ -3495,6 +3602,27 @@
     "signature": "export declare function fromTypeBox<T extends TSchema>(schema: T, options?: {\n    readonly coerce?: boolean;\n}): NifraSchema<T>;",
     "doc": "/**\n * Wrap a TypeBox schema as a `NifraSchema`.\n *\n * **Validation is fast where it can be, and works everywhere.** The first `validate`\n * builds a compiled `TypeCompiler` validator (codegen via `new Function`) and memoizes\n * it — composing schemas (`t.object({ a: t.string() })`) never compiles the inner\n * pieces; only a schema actually used to validate a request pays the one-time codegen\n * cost. On Bun and Node this is the only path and it is untouched.\n *\n * Edge runtimes (Cloudflare Workers, Vercel Edge, Deno Deploy) **forbid dynamic code\n * generation**, so that first compile throws there. We catch it once per schema and\n * fall back to TypeBox's eval-free `Value` checker — same semantics (and same global\n * `FormatRegistry`, so `t.string({ format })` behaves identically), no `new Function`.\n * The branch is decided once and memoized, so the hot path is a single check either way.\n *\n * Exposed (not just used internally by `t`) so a TypeBox schema authored directly can\n * be adapted without leaving the Standard Schema world.\n *\n * `options.coerce` runs TypeBox's `Value.Convert` (string→number/integer/boolean, per the schema)\n * BEFORE validating. Query values always arrive as strings (`?limit=20` → `\"20\"`), so a query schema\n * with a numeric field can't validate without this — it's how `t.pageQuery` yields a real `number`.\n * Leave it OFF (the default) for body/JSON schemas: a JSON number is already a number, and coercing\n * would silently accept `\"20\"` where the contract said `20`.\n */"
   },
+  {
+    "name": "fusedRespond",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function fusedRespond(result: unknown, ctx: RawContext): Response;",
+    "doc": "/** Fused-lane respond with a context: read `c.set` once; untouched (the common case) -> the fast\n * JSON respond; touched -> the generic `toResponse` with those controls (statuses, headers, cookies). */"
+  },
+  {
+    "name": "fusedRespondNoSet",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function fusedRespondNoSet(result: unknown): Response;",
+    "doc": "/** Fused-lane respond when `c.set` is untouched. Bun 1.3's native `Response.json` now beats the\n * older hand-inlined stringify + Response construction on this lane while preserving the exact\n * body/content-type contract; keep the generic fallback for non-JSON values. */"
+  },
+  {
+    "name": "Gauge",
+    "kind": "class",
+    "package": "@nifrajs/otel",
+    "signature": "export declare class Gauge {\n    readonly name: string;\n    readonly help: string;\n    private readonly series;\n    constructor(name: string, help: string);\n    private at;\n    inc(labels?: Labels, by?: number): void;\n    dec(labels?: Labels, by?: number): void;\n    set(labels: Labels, value: number): void;\n    render(): string;\n}",
+    "doc": "/** A value that can go up and down (in-flight requests, queue depth). */"
+  },
   {
     "name": "generateClientEntry",
     "kind": "function",
@@ -3582,6 +3710,12 @@
     "signature": "export declare function getContext<C extends Context = Context>(): C;",
     "doc": "/** Return the current request context, or throw when no context-storage wrapper is active. */"
   },
+  {
+    "name": "getNeverAbortSignal",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const getNeverAbortSignal: () => AbortSignal;"
+  },
   {
     "name": "getRecipe",
     "kind": "function",
@@ -3603,10 +3737,10 @@
     "doc": "/** A dynamic route's build-time param enumeration (the SSG equivalent of \"which pages exist\"). */"
   },
   {
-    "name": "getWsRuntime",
-    "kind": "function",
+    "name": "getUnboundedRequestBudget",
+    "kind": "const",
     "package": "@nifrajs/core",
-    "signature": "export declare function getWsRuntime(): WsRuntime | undefined;"
+    "signature": "export declare const getUnboundedRequestBudget: () => RequestBudget;"
   },
   {
     "name": "githubDeployWorkflow",
@@ -3657,6 +3791,13 @@
     "signature": "export declare function handleRpc(message: JsonRpcRequest, tools: readonly McpTool[], serverInfo: {\n    name: string;\n    version: string;\n}, features?: McpServerFeatures, options?: McpProtocolOptions): Promise<JsonRpcResponse | null>;",
     "doc": "/**\n * Dispatch one JSON-RPC message against the given tools. Returns the response, or `null` for a\n * notification (no reply). Tool errors are reported in-band (`isError`) so the agent can react to them.\n */"
   },
+  {
+    "name": "HandlerResult",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type HandlerResult = Response | unknown;",
+    "doc": "/** A handler returns a `Response` (used as-is) or any value (serialized to JSON). */"
+  },
   {
     "name": "HandlersFor",
     "kind": "type",
@@ -3678,11 +3819,17 @@
     "signature": "export declare function hashQueryKey(key: unknown): string;",
     "doc": "/**\n * Hash a query key to a stable cache string. Object keys are sorted (so `{a,b}` ≡ `{b,a}`); arrays\n * keep order. Keys must be serializable — a function/symbol in the key throws (it can't be a stable\n * identity). Mirrors TanStack Query's structural hashing.\n */"
   },
+  {
+    "name": "headerOf",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function headerOf(source: RequestSource, name: string): string | null;"
+  },
   {
     "name": "healthcheck",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function healthcheck(options?: HealthcheckOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function healthcheck(options?: HealthcheckOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "doc": "/**\n * Register **liveness** (`/health`) and **readiness** (`/ready`) endpoints. Liveness is a flat `200`\n * (the process is serving). Readiness runs each `check` and returns `200 { status: \"ok\", checks }`\n * when all pass, or `503 { status: \"error\", checks }` when any fail (a thrown check counts as failed).\n * Both are `Cache-Control: no-store`.\n *\n * Apply it **before** auth guards so the endpoints stay public (`beforeHandle` is order-scoped):\n *\n * ```ts\n * app.use(healthcheck({ checks: { db: () => db.ping() } })).use(bearer({ verify }))\n * ```\n */"
   },
   {
@@ -3691,6 +3838,13 @@
     "package": "@nifrajs/middleware",
     "signature": "export interface HealthcheckOptions {\n    /** Liveness path — always `200` while the process is up. Default `\"/health\"`. */\n    readonly path?: string;\n    /** Readiness path — runs `checks`; `200` if all pass, `503` otherwise. Default `\"/ready\"`. */\n    readyPath?: string;\n    /** Readiness checks (DB ping, cache reachable, …). Each returns a boolean or throws; a throw counts\n     * as failing. `/ready` reports each by name and is `200` only when all pass. */\n    readonly checks?: Readonly<Record<string, () => MaybePromise<boolean>>>;\n}"
   },
+  {
+    "name": "Histogram",
+    "kind": "class",
+    "package": "@nifrajs/otel",
+    "signature": "export declare class Histogram {\n    readonly name: string;\n    readonly help: string;\n    private readonly series;\n    private readonly buckets;\n    constructor(name: string, help: string, buckets: readonly number[]);\n    observe(value: number, labels?: Labels): void;\n    render(): string;\n}",
+    "doc": "/** Latency-style distribution over fixed buckets (seconds). Renders Prometheus cumulative buckets. */"
+  },
   {
     "name": "hmacSha256",
     "kind": "function",
@@ -3827,6 +3981,12 @@
     "signature": "export interface I18nProviderProps {\n  /** The active locale (e.g. `\"en\"`, `\"fr-CA\"`). */\n  locale: string\n  /** The ICU message catalog for `locale`. */\n  messages: Messages\n  /** The subtree that reads the formatter via `useT()`. */\n  children?: Snippet\n}",
     "doc": "/** Hand-written types for `I18nProvider.svelte` (consumers resolve these via the `./i18n` re-export). */"
   },
+  {
+    "name": "idempotency",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function idempotency(options?: IdempotencyPluginOptions): IdentityPlugin;"
+  },
   {
     "name": "idempotency",
     "kind": "function",
@@ -3878,12 +4038,26 @@
     "signature": "export interface IdempotencyEntryKey {\n    readonly namespace: string;\n    readonly key: string;\n}",
     "doc": "/** Namespaces isolate the same client key across tenants/subjects without putting identity in a header. */"
   },
+  {
+    "name": "IdempotencyHost",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface IdempotencyHost {\n    readonly maxBodyBytes: number;\n    runLanes(buffered: Request, platform: Platform | undefined, entry: unknown, params: Record<string, string>, search: string | undefined): Promise<Response>;\n}",
+    "doc": "/**\n * What the dedupe lane needs from the server to run a fresh key: the app-wide body cap and a way to\n * run the buffered request through the route's normal lanes to a concrete `Response`.\n */"
+  },
   {
     "name": "IdempotencyOptions",
     "kind": "interface",
     "package": "@nifrajs/middleware",
     "signature": "export interface IdempotencyOptions {\n    /** Where claims + cached responses live. `MemoryIdempotencyStore` for dev; a shared store in production. */\n    readonly store: IdempotencyStore;\n    /** Header carrying the key. Default `\"idempotency-key\"`. */\n    readonly header?: string;\n    /** Methods the guard applies to. Default `[\"POST\", \"PUT\", \"PATCH\", \"DELETE\"]` (unsafe methods). */\n    readonly methods?: readonly string[];\n    /** How long a completed response is replayable, in ms. Default 24h. */\n    readonly ttlMs?: number;\n    /** How long the in-flight lock survives a crashed handler, in ms. Default 60s. */\n    readonly lockTtlMs?: number;\n    /** Max response bytes to cache. A larger response is returned but **not** stored. Default 1 MiB. */\n    readonly maxBytes?: number;\n    /** Whether a response should be cached for replay. Default: status `< 500` (don't replay transient 5xx). */\n    readonly shouldCache?: (response: Response) => boolean;\n    /**\n     * Derive the store key from the request. Default: the `header` value **scoped by method + path**, so the\n     * same key on a different endpoint can't collide. Return a **principal-scoped** key (e.g.\n     * `` `${userId}:${req.headers.get(\"idempotency-key\")}` ``) so one user can't replay another's stored\n     * response on a shared key. Return `null`/`\"\"` to skip dedupe for this request.\n     */\n    readonly key?: (req: Request, header: string) => string | null;\n}"
   },
+  {
+    "name": "IdempotencyPluginOptions",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface IdempotencyPluginOptions {\n    readonly store?: IdempotencyStore | undefined;\n}",
+    "doc": "/**\n * Enable request idempotency. Routes that declare `schema.idempotency` get the dedupe lane: a repeat\n * `Idempotency-Key` replays the stored response instead of re-running the handler. Without this plugin,\n * declaring `schema.idempotency` is a registration error (the safety gate can never be silently\n * dropped). `store` is the app-wide default backing routes that do not pin their own; omit it for a\n * shared in-process store (development/tests only - inject a durable store in production).\n */"
+  },
   {
     "name": "IdempotencyRecord",
     "kind": "interface",
@@ -3897,6 +4071,13 @@
     "package": "@nifrajs/core",
     "signature": "export declare class IdempotencyResponseTooLargeError extends Error {\n    readonly maxBytes: number;\n    constructor(maxBytes: number);\n}"
   },
+  {
+    "name": "IdempotencyRuntime",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface IdempotencyRuntime {\n    /** Resolve a route's declared idempotency into a pinned store + defaults, or `undefined` when off. */\n    resolve(schema: RouteSchema | undefined, authenticated: boolean, maxBodyBytes: number): ResolvedIdempotency | undefined;\n    /** The dedupe lane: read the key, fingerprint the request, consult the store, run/replay/reject. */\n    run<T>(config: ResolvedIdempotency, req: Request, platform: Platform | undefined, entry: unknown, params: Record<string, string>, search: string | undefined, wrapResponse: (response: Response) => T, host: IdempotencyHost): Promise<T>;\n}",
+    "doc": "/** The injected idempotency implementation the kernel calls through when the plugin is installed. */"
+  },
   {
     "name": "IdempotencyScope",
     "kind": "type",
@@ -4127,6 +4308,13 @@
     "signature": "export type InferOutput<S extends StandardSchemaV1> = NonNullable<S[\"~standard\"][\"types\"]>[\"output\"];",
     "doc": "/** Extract a Standard Schema's validated output type. */"
   },
+  {
+    "name": "InferOutput",
+    "kind": "type",
+    "package": "@nifrajs/mcp",
+    "signature": "export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema[\"~standard\"][\"types\"]>[\"output\"];",
+    "doc": "/** The validated (post-transform) type of a Standard Schema. */"
+  },
   {
     "name": "InfiniteData",
     "kind": "interface",
@@ -4178,8 +4366,8 @@
     "name": "inProcessClient",
     "kind": "function",
     "package": "@nifrajs/client",
-    "signature": "export declare function inProcessClient<App extends {\n    fetch(request: Request): Response | Promise<Response>;\n}>(app: App, options?: Omit<ClientOptions, \"fetch\">): InProcessClient<App>;",
-    "doc": "/**\n * A {@link client} whose `fetch` calls a nifra app's own `fetch` in-process — no network, full\n * lifecycle (validation, middleware, contracts). For SSR loaders. Typed from `App` exactly like\n * the network client. The `(url, init) → Request` bridge is required because the client calls\n * `fetch(url, init)` while `app.fetch` takes a `Request`.\n *\n * The returned proxy also implements the explicit symbol-keyed {@link BackendMount} interface, so\n * `createWebApp({ api: inProcessClient(backend) })` can auto-mount the backend while forwarding the\n * outer runtime's `env` and `waitUntil`. The released `.fetch(url, init)` bridge remains available as\n * a compatibility surface for custom integrations, but the platform-aware mount never relies on it.\n */"
+    "signature": "export declare function inProcessClient<App extends {\n    fetch(request: Request): Response | Promise<Response>;\n}>(app: App, options?: InProcessClientOptions): InProcessClient<App>;",
+    "doc": "/**\n * A {@link client} whose `fetch` calls a nifra app's own `fetch` in-process — no network, full\n * lifecycle (validation, middleware, contracts). For SSR loaders. Typed from `App` exactly like\n * the network client. The `(url, init) → Request` bridge is required because the client calls\n * `fetch(url, init)` while `app.fetch` takes a `Request`.\n *\n * The returned proxy also implements the explicit symbol-keyed {@link BackendMount} interface, so\n * `createWebApp({ api: inProcessClient(backend) })` can auto-mount the backend while forwarding the\n * outer runtime's `env` and `waitUntil`.\n */"
   },
   {
     "name": "InProcessClient",
@@ -4188,6 +4376,54 @@
     "signature": "export type InProcessClient<App> = Treaty<App> & BackendMount;",
     "doc": "/** Typed route client plus the explicit platform-aware backend mount capability. */"
   },
+  {
+    "name": "InProcessClientOptions",
+    "kind": "interface",
+    "package": "@nifrajs/client",
+    "signature": "export interface InProcessClientOptions extends Omit<ClientOptions, \"fetch\"> {\n    /**\n     * Assert every JSON response against the route's declared contract — `schema.response` for 2xx,\n     * `schema.errors[status]` for declared failures — and THROW on mismatch, so a handler whose real\n     * output drifts from its schema fails the test instead of passing silently. Statuses with no\n     * declared schema, non-JSON bodies, and 204/205/HEAD pass through unchecked. Test-focused: the\n     * check parses a clone of each JSON body, a cost that belongs in tests, not production hot paths.\n     */\n    readonly validateResponses?: boolean;\n}"
+  },
+  {
+    "name": "INSTALL_EFFECT_LEDGER",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const INSTALL_EFFECT_LEDGER: unique symbol;",
+    "doc": "/** @internal Install the effect-ledger runtime on a server (called by the `effectLedger()` plugin). */"
+  },
+  {
+    "name": "INSTALL_IDEMPOTENCY",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const INSTALL_IDEMPOTENCY: unique symbol;",
+    "doc": "/** @internal Install the idempotency runtime on a server (called by the `idempotency()` plugin). */"
+  },
+  {
+    "name": "INSTALL_MCP",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const INSTALL_MCP: unique symbol;",
+    "doc": "/** @internal Install the MCP runtime on a server (called by the `mcp()` plugin). */"
+  },
+  {
+    "name": "INSTALL_NODE_DIRECT",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const INSTALL_NODE_DIRECT: unique symbol;",
+    "doc": "/** @internal Install the Node-direct renderer on a server (called by the `nodeDirect()` plugin). */"
+  },
+  {
+    "name": "INSTALL_SSE",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const INSTALL_SSE: unique symbol;",
+    "doc": "/** @internal Install the SSE streaming runtime on a server (called by the `sse()` plugin). */"
+  },
+  {
+    "name": "INSTALL_WS",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const INSTALL_WS: unique symbol;",
+    "doc": "/** @internal Install the WebSocket runtime on a server (called by the `websocket()` plugin). */"
+  },
   {
     "name": "installForms",
     "kind": "function",
@@ -4211,26 +4447,8 @@
     "name": "InvariantExecutor",
     "kind": "type",
     "package": "@nifrajs/core",
-    "signature": "export type InvariantExecutor = (request: Request) => Response | Promise<Response>;"
-  },
-  {
-    "name": "InvariantFinding",
-    "kind": "interface",
-    "package": "@nifrajs/core",
-    "signature": "export interface InvariantFinding {\n    readonly code: InvariantFindingCode;\n    readonly method: string;\n    readonly path: string;\n    /** The case's deterministic seed — rerun with it to reproduce the exact request. */\n    readonly seed?: number;\n    readonly message: string;\n}"
-  },
-  {
-    "name": "InvariantFindingCode",
-    "kind": "type",
-    "package": "@nifrajs/core",
-    "signature": "export type InvariantFindingCode = \"classification-understated\" | \"server-error-on-valid-input\" | \"response-schema-violation\" | \"validation-bypass\" | \"server-error-on-invalid-input\";",
-    "doc": "/**\n * Contract-generated invariant tests: the declared contract *is* the test suite.\n *\n * `runContractInvariants(app)` reads each route's reflected contract (schemas, classification) and\n * verifies, with deterministic seeded fuzzing, the properties the contract already promises:\n *\n *  1. **Classification consistency** (static) — a route whose response fields are tagged more\n *     sensitive than its declared route-level classification is understating what it emits.\n *  2. **Valid input never crashes** (dynamic) — schema-generated valid requests must not produce 5xx.\n *  3. **Response conformance** (dynamic) — a 2xx response body must validate against the declared\n *     response schema; an undeclared response shape is exactly where sensitive data leaks.\n *  4. **Validation fails closed** (dynamic) — schema-violating bodies must be rejected (4xx), never\n *     accepted (2xx) and never crash (5xx).\n *\n * Everything is deterministic: a seeded PRNG (no ambient randomness, no wall clock), so a failing\n * case reproduces from its seed. Routes whose inputs cannot be generated from their JSON Schema are\n * reported in `skipped` — never silently dropped.\n */"
-  },
-  {
-    "name": "InvariantReport",
-    "kind": "interface",
-    "package": "@nifrajs/core",
-    "signature": "export interface InvariantReport {\n    readonly ok: boolean;\n    /** Routes exercised dynamically. */\n    readonly tested: readonly {\n        readonly method: string;\n        readonly path: string;\n    }[];\n    /** Routes that could not be exercised, with the reason — reported, never silently dropped. */\n    readonly skipped: readonly SkippedRoute[];\n    readonly findings: readonly InvariantFinding[];\n}"
+    "signature": "export type InvariantExecutor = (request: Request) => Response | Promise<Response>;",
+    "doc": "/** Isolated request executor used by adversarial contract verification. */"
   },
   {
     "name": "IpMatcher",
@@ -4381,6 +4599,12 @@
     "signature": "export interface ISRApp {\n    fetch(req: Request, platform?: ISRPlatform): Response | Promise<Response>;\n}",
     "doc": "/** The app `withISR` wraps — anything with a `fetch(req, platform?)` (a `createWebApp` result). */"
   },
+  {
+    "name": "isResponseResult",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function isResponseResult(value: unknown): value is ResponseResult;"
+  },
   {
     "name": "ISROptions",
     "kind": "interface",
@@ -4401,6 +4625,13 @@
     "signature": "export declare const issue: (message: string) => {\n    readonly issues: ReadonlyArray<StandardIssue>;\n};",
     "doc": "/** A single issue. Messages NEVER include the variable's value — it may be a secret. */"
   },
+  {
+    "name": "isUrlEncodedForm",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function isUrlEncodedForm(contentType: string): boolean;",
+    "doc": "/** `application/x-www-form-urlencoded`, with or without a charset suffix. */"
+  },
   {
     "name": "JobContext",
     "kind": "interface",
@@ -4469,6 +4700,13 @@
     "signature": "export declare function joinCausality(parents: readonly CausalityContext[], nodeKind: CausalityKind, id: string, options?: ContinueCausalityOptions): CausalityStep;",
     "doc": "/** Join several immediate parents. Cross-execution joins fail closed. */"
   },
+  {
+    "name": "jsonError",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function jsonError(status: number, error: string, headers?: Record<string, string>): Response;",
+    "doc": "/** A uniform JSON error envelope: `{ ok: false, error }` at the given status. */"
+  },
   {
     "name": "jsonError",
     "kind": "function",
@@ -4521,6 +4759,13 @@
     "signature": "export type JsonSchema = boolean | Readonly<Record<string, unknown>>;",
     "doc": "/** JSON Schema permits either a schema object or the boolean schemas `true` and `false`. */"
   },
+  {
+    "name": "jsonSchemaOf",
+    "kind": "function",
+    "package": "@nifrajs/mcp",
+    "signature": "export declare function jsonSchemaOf(schema: StandardSchemaV1): Record<string, unknown> | undefined;",
+    "doc": "/**\n * The wire JSON Schema of a Standard Schema, when it carries one. nifra's `t` schemas ARE\n * JSON Schema (exposed as `.jsonSchema`), so tools authored with `t` advertise a full\n * `inputSchema` for free. Schemas from other vendors return `undefined` - pass an explicit\n * `inputSchema` alongside `input` for those.\n */"
+  },
   {
     "name": "jwk",
     "kind": "function",
@@ -4631,7 +4876,7 @@
     "name": "language",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function language<const L extends readonly string[]>(options: LanguageOptions<L>): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").Server<any, any>>;",
+    "signature": "export declare function language<const L extends readonly string[]>(options: LanguageOptions<L>): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").Server<any, any>>;",
     "doc": "/**\n * Derives `c.language` from `Accept-Language` and emits `Content-Language` by default.\n */"
   },
   {
@@ -4839,7 +5084,7 @@
     "name": "logger",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function logger(options?: LoggerOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function logger(options?: LoggerOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "doc": "/**\n * A {@link definePlugin} plugin that logs one structured line per request — method, path, status,\n * and duration — via `onRequest`/`onResponse` (so it covers 404s and errors too). The start time is\n * paired to the request through a `WeakMap` (no per-request allocation leak). Idempotent.\n */"
   },
   {
@@ -4937,12 +5182,25 @@
     "signature": "export declare function maxClassification(values: Iterable<DataClassification>): DataClassification;",
     "doc": "/** The most sensitive classification among the inputs; `\"public\"` when none are given. */"
   },
+  {
+    "name": "MaybePromise",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type MaybePromise<T> = T | Promise<T>;"
+  },
   {
     "name": "MaybePromise",
     "kind": "type",
     "package": "@nifrajs/middleware",
     "signature": "export type MaybePromise<T> = T | Promise<T>;"
   },
+  {
+    "name": "mcp",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function mcp(): IdentityPlugin;",
+    "doc": "/**\n * Enable MCP declarations on a server: `.use(mcp())` turns on `.tool()`, `.resource()`, and\n * `.prompt()`. Applying it twice is a no-op (named plugin dedupe).\n */"
+  },
   {
     "name": "MCP_CLI_VERSION",
     "kind": "const",
@@ -5035,7 +5293,7 @@
     "kind": "interface",
     "package": "@nifrajs/core",
     "signature": "export interface McpPromptDescriptor {\n    readonly name: string;\n    readonly description: string;\n    readonly arguments?: readonly PromptArgument[];\n    readonly handler: (args: Record<string, string>) => MaybePromise<readonly PromptMessage[]>;\n}",
-    "doc": "/** An app-declared MCP prompt — a reusable prompt template an agent can fetch through `nifra mcp`. */"
+    "doc": "/** An app-declared MCP prompt - a reusable prompt template an agent can fetch through `nifra mcp`. */"
   },
   {
     "name": "McpPromptMessage",
@@ -5066,7 +5324,13 @@
     "kind": "interface",
     "package": "@nifrajs/core",
     "signature": "export interface McpResourceDescriptor {\n    readonly uri: string;\n    readonly name: string;\n    readonly description?: string;\n    readonly mimeType?: string;\n    readonly read: () => MaybePromise<string | {\n        readonly text: string;\n        readonly mimeType?: string;\n    }>;\n}",
-    "doc": "/** An app-declared MCP resource — read-only data an agent can fetch through `nifra mcp`. */"
+    "doc": "/** An app-declared MCP resource - read-only data an agent can fetch through `nifra mcp`. */"
+  },
+  {
+    "name": "McpRuntime",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface McpRuntime {\n    tool(name: string, config: McpToolConfig, handler: (input: unknown, context: Context) => unknown): McpToolPlan;\n    resource(uri: string, config: {\n        readonly name: string;\n        readonly description?: string;\n        readonly mimeType?: string;\n    }, read: McpResourceDescriptor[\"read\"]): McpResourceDescriptor;\n    prompt(name: string, config: {\n        readonly description: string;\n        readonly arguments?: readonly PromptArgument[];\n    }, handler: McpPromptDescriptor[\"handler\"]): McpPromptDescriptor;\n}"
   },
   {
     "name": "McpServer",
@@ -5100,6 +5364,12 @@
     "signature": "export interface McpToolAnnotations {\n    readonly title?: string;\n    readonly readOnlyHint?: boolean;\n    readonly destructiveHint?: boolean;\n    readonly idempotentHint?: boolean;\n    readonly openWorldHint?: boolean;\n}",
     "doc": "/** MCP tool safety hints (`readOnlyHint`/`destructiveHint`/…) surfaced in `tools/list`, per the MCP spec. */"
   },
+  {
+    "name": "McpToolConfig",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface McpToolConfig {\n    readonly description: string;\n    readonly input: StandardSchemaV1;\n    readonly output?: StandardSchemaV1;\n    readonly annotations?: ToolAnnotations;\n}"
+  },
   {
     "name": "McpToolContext",
     "kind": "interface",
@@ -5113,6 +5383,12 @@
     "signature": "export type McpToolHandlerResult = string | {\n    /** Model-facing text (becomes a single text content block when `content` is omitted). */\n    readonly text?: string;\n    /** Explicit content blocks (overrides `text`). */\n    readonly content?: readonly McpContentBlock[];\n    /** Structured data for the linked widget — NOT added to the model's context. */\n    readonly structuredContent?: Record<string, unknown>;\n    readonly _meta?: Record<string, unknown>;\n    readonly isError?: boolean;\n};",
     "doc": "/** The ergonomic result an MCP-tool handler may return (coerced to the protocol's {@link McpToolResult}). */"
   },
+  {
+    "name": "McpToolPlan",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface McpToolPlan {\n    readonly path: string;\n    readonly schema: RouteSchema;\n    readonly run: (context: Context) => unknown;\n    readonly descriptor: NonNullable<RouteDescriptor[\"tool\"]>;\n}"
+  },
   {
     "name": "McpToolResult",
     "kind": "interface",
@@ -5279,7 +5555,7 @@
     "name": "MetaArgs",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface MetaArgs<Data = unknown> {\n    readonly data: Data;\n    readonly params: Record<string, string>;\n    /**\n     * The site origin — scheme + host (+ port), e.g. `\"https://news.example.com\"`, **with no trailing\n     * slash**. The single piece of server/env knowledge `meta()` otherwise can't see: it runs in BOTH\n     * SSR and client navigation, so it has no `request`/`process.env`. The framework resolves it from the\n     * request URL during SSR and from `location.origin` on client nav — and they match, so an absolute\n     * `og:url`/`canonical`/`og:image` built from it never drifts between the server-rendered `<head>` and\n     * a soft-nav. Use it for absolute URLs (`origin + \"/posts/\" + slug`) instead of threading `siteUrl`\n     * through loader data. Empty string (`\"\"`) when the origin is unknown (e.g. a hand-built test render\n     * with no request URL) — back-compat-safe: a `meta()` that ignores `origin` is unchanged.\n     */\n    readonly origin: string;\n}",
+    "signature": "export interface MetaArgs<Data = unknown> {\n    readonly data: Data;\n    readonly params: Record<string, string>;\n    /**\n     * The site origin — scheme + host (+ port), e.g. `\"https://news.example.com\"`, **with no trailing\n     * slash**. The single piece of server/env knowledge `meta()` otherwise can't see: it runs in BOTH\n     * SSR and client navigation, so it has no `request`/`process.env`. The framework resolves it from the\n     * request URL during SSR and from `location.origin` on client nav — and they match, so an absolute\n     * `og:url`/`canonical`/`og:image` built from it never drifts between the server-rendered `<head>` and\n     * a soft-nav. Use it for absolute URLs (`origin + \"/posts/\" + slug`) instead of threading `siteUrl`\n     * through loader data. Empty string (`\"\"`) when the origin is unknown (e.g. a hand-built test render\n     * with no request URL). A `meta()` that ignores `origin` is unchanged.\n     */\n    readonly origin: string;\n}",
     "doc": "/**\n * Args for a route's `meta` function: the loader's `data` + the route `params` + the request `origin`.\n * `meta()` runs in BOTH SSR and client navigation, so it has **no `request`/`process.env`/server access** —\n * `origin` is the only server-resolved fact it gets (so you needn't thread `siteUrl` through loader data\n * for absolute `og:url`/`canonical`/`og:image` URLs). See {@link origin}.\n */"
   },
   {
@@ -5299,14 +5575,14 @@
     "name": "methodOverride",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function methodOverride(options?: MethodOverrideOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function methodOverride(options?: MethodOverrideOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "doc": "/**\n * HTTP method override for clients that can only send `POST`. The middleware rewrites the request\n * before routing, so handlers, validation, and response hooks all see the overridden method.\n *\n * Header override is enabled by default; query override is opt-in. Form-body override is deliberately\n * not implemented because reading the body before routing would consume or buffer it for every write.\n */"
   },
   {
     "name": "MethodOverrideOptions",
     "kind": "interface",
     "package": "@nifrajs/middleware",
-    "signature": "export interface MethodOverrideOptions {\n    /**\n     * Header carrying the desired method. Default `\"x-http-method-override\"`.\n     * Set `false` to disable header-based override.\n     */\n    readonly header?: string | false;\n    /**\n     * Query parameter carrying the desired method. Disabled by default because query-tunneled writes are\n     * easier to trigger accidentally from links/forms. Use only with CSRF protection on browser routes.\n     */\n    readonly query?: string | false;\n    /** Original request methods allowed to tunnel. Default `[\"POST\"]`. */\n    readonly methods?: readonly string[];\n    /** Target methods accepted from the override source. Default `[\"PUT\", \"PATCH\", \"DELETE\"]`. */\n    readonly allowed?: readonly Method[];\n    /** Invalid override values reject with `400` by default. Use `\"ignore\"` for legacy clients. */\n    readonly onInvalid?: \"reject\" | \"ignore\";\n}"
+    "signature": "export interface MethodOverrideOptions {\n    /**\n     * Header carrying the desired method. Default `\"x-http-method-override\"`.\n     * Set `false` to disable header-based override.\n     */\n    readonly header?: string | false;\n    /**\n     * Query parameter carrying the desired method. Disabled by default because query-tunneled writes are\n     * easier to trigger accidentally from links/forms. Use only with CSRF protection on browser routes.\n     */\n    readonly query?: string | false;\n    /** Original request methods allowed to tunnel. Default `[\"POST\"]`. */\n    readonly methods?: readonly string[];\n    /** Target methods accepted from the override source. Default `[\"PUT\", \"PATCH\", \"DELETE\"]`. */\n    readonly allowed?: readonly Method[];\n}"
   },
   {
     "name": "METHODS",
@@ -5315,12 +5591,32 @@
     "signature": "export declare const METHODS: readonly [\"GET\", \"POST\", \"PUT\", \"PATCH\", \"DELETE\", \"HEAD\", \"OPTIONS\"];",
     "doc": "/** HTTP methods the router accepts. */"
   },
+  {
+    "name": "metrics",
+    "kind": "function",
+    "package": "@nifrajs/otel",
+    "signature": "export declare function metrics(options?: MetricsOptions): NifraPlugin;",
+    "doc": "/**\n * Enable RED metrics + a `/metrics` Prometheus endpoint. Records `nifra_http_requests_total`,\n * `nifra_http_request_duration_seconds`, and `nifra_http_requests_in_flight`, labeled by method,\n * matched route template, and status. Apply once (named-plugin dedupe).\n */"
+  },
+  {
+    "name": "MetricsOptions",
+    "kind": "interface",
+    "package": "@nifrajs/otel",
+    "signature": "export interface MetricsOptions {\n    /** Where to expose the Prometheus text. Default `/metrics`. This route is excluded from the metrics. */\n    readonly path?: string;\n    /** Reuse a registry (so custom app metrics render alongside the RED series). Default: a fresh one. */\n    readonly registry?: MetricsRegistry;\n    /** Histogram buckets in SECONDS for request duration. Default OpenTelemetry latency buckets. */\n    readonly buckets?: readonly number[];\n}"
+  },
+  {
+    "name": "MetricsRegistry",
+    "kind": "class",
+    "package": "@nifrajs/otel",
+    "signature": "export declare class MetricsRegistry {\n    private readonly counters;\n    private readonly gauges;\n    private readonly histograms;\n    counter(name: string, help?: string): Counter;\n    gauge(name: string, help?: string): Gauge;\n    histogram(name: string, buckets: readonly number[], help?: string): Histogram;\n    /** The Prometheus text exposition of every registered series. */\n    render(): string;\n}",
+    "doc": "/** A collection of metrics that renders one Prometheus exposition document. */"
+  },
   {
     "name": "Middleware",
     "kind": "interface",
     "package": "@nifrajs/core",
     "signature": "export interface Middleware {\n    readonly name?: string;\n    readonly onRequest?: (req: Request, platform?: Platform) => MaybePromise<OnRequestResult>;\n    readonly around?: <T>(context: Context, next: () => MaybePromise<T>) => MaybePromise<T>;\n    readonly beforeHandle?: (context: Context) => MaybePromise<unknown>;\n    readonly afterHandle?: (result: unknown, context: Context) => MaybePromise<unknown>;\n    readonly onResponse?: (response: Response, req: Request) => MaybePromise<Response>;\n    readonly onResponseFinalized?: (outcome: ResponseFinalization, req: Request) => MaybePromise<void>;\n    readonly onError?: (error: unknown, context: Context) => MaybePromise<unknown>;\n}",
-    "doc": "/**\n * A bundle of lifecycle hooks applied together via {@link Server.use} — the unit\n * `@nifrajs/middleware` ships (cors, security headers, rate-limit). Every hook is\n * optional and wired to its lifecycle point. Middleware is context-agnostic (sees\n * the base `Context`); `use` does no context-type merging — the full type-merging\n * plugin system is deferred, and `.use` is reserved as its future entry point.\n */"
+    "doc": "/**\n * A bundle of lifecycle hooks applied together via {@link Server.use} - the unit\n * `@nifrajs/middleware` ships (cors, security headers, rate-limit). Every hook is\n * optional and wired to its lifecycle point. Middleware is context-agnostic (sees\n * the base `Context`); `use` does no context-type merging - the full type-merging\n * plugin system is deferred, and `.use` is reserved as its future entry point.\n */"
   },
   {
     "name": "MIN_DIGEST_KEY_BYTES",
@@ -5432,6 +5728,13 @@
     "signature": "export interface MovableStorageAdapter extends StorageAdapter {\n    copy(sourceKey: string, destinationKey: string): Promise<void>;\n    move(sourceKey: string, destinationKey: string): Promise<void>;\n}",
     "doc": "/** Optional server-side copy/move capability. */"
   },
+  {
+    "name": "moveDependenciesText",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function moveDependenciesText(text: string, moves: readonly {\n    from: string;\n    to: string;\n    toVersion: string;\n}[]): {\n    text: string;\n    changes: Array<Omit<DependencyMoveChange, \"file\">>;\n};",
+    "doc": "/** Move removed package dependencies without reserializing or reordering package.json. */"
+  },
   {
     "name": "MutationCallbacks",
     "kind": "interface",
@@ -5495,6 +5798,13 @@
     "signature": "export interface NavigateProps {\n    readonly to: string;\n    readonly replace?: boolean;\n}",
     "doc": "/** {@link Navigate} props: the destination `to` and whether to `replace` the history entry. */"
   },
+  {
+    "name": "Navigation",
+    "kind": "interface",
+    "package": "@nifrajs/web-react",
+    "signature": "export interface Navigation {\n    /** True while a client navigation (or revalidation) is in flight. The current route stays mounted\n     * until the new one is ready, so this drives a loading indicator, not a route swap. */\n    readonly pending: boolean;\n    /** `\"loading\"` while a navigation is in flight, else `\"idle\"`. */\n    readonly state: \"idle\" | \"loading\";\n    /** The `pathname + search` being navigated TO while `pending`; `undefined` when idle or during a\n     * same-route revalidation. Mirrors Remix's `useNavigation().location`. */\n    readonly location: string | undefined;\n}",
+    "doc": "/** The current navigation state, mirroring the Remix `useNavigation()` shape for familiarity. */"
+  },
   {
     "name": "NavLink",
     "kind": "const",
@@ -5513,7 +5823,7 @@
     "name": "NavLinkRenderProps",
     "kind": "interface",
     "package": "@nifrajs/web-react",
-    "signature": "export interface NavLinkRenderProps {\n    /** True when the current location matches this link's `to` (prefix match, or exact when `end`). */\n    readonly isActive: boolean;\n    /** Reserved for a future pending-navigation signal; currently always `false`. */\n    readonly isPending: boolean;\n}",
+    "signature": "export interface NavLinkRenderProps {\n    /** True when the current location matches this link's `to` (prefix match, or exact when `end`). */\n    readonly isActive: boolean;\n    /** True while a client navigation to THIS link's target is in flight (matched like `isActive`).\n     * `false` on SSR and when idle. Use it to show a per-link spinner during the transition. */\n    readonly isPending: boolean;\n}",
     "doc": "/** The state a {@link NavLink}'s function-form `className`/`style`/`children` receive. */"
   },
   {
@@ -5637,7 +5947,7 @@
     "kind": "type",
     "package": "@nifrajs/core",
     "signature": "export type NifraPlugin<In extends AnyServer = AnyServer, Out extends AnyServer = In> = ((app: In) => Out) & {\n    readonly pluginName?: string;\n};",
-    "doc": "/**\n * A nifra **plugin**: a function that augments an app — calling `use`/`derive`/`decorate` and/or\n * registering routes — and returns it. Because `derive`/`decorate` are type-threaded, an **inline**\n * `app.use((a) => a.derive(...).decorate(...))` carries the added context to handlers defined after\n * it (the `use` overload is generic over the concrete `this`). Wrap with {@link definePlugin} to\n * attach a name for idempotent dedupe (applying the same named plugin twice — e.g. transitively — is\n * a no-op).\n */"
+    "doc": "/**\n * A nifra **plugin**: a function that augments an app - calling `use`/`derive`/`decorate` and/or\n * registering routes - and returns it. Because `derive`/`decorate` are type-threaded, an **inline**\n * `app.use((a) => a.derive(...).decorate(...))` carries the added context to handlers defined after\n * it (the `use` overload is generic over the concrete `this`). Wrap with {@link definePlugin} to\n * attach a name for idempotent dedupe (applying the same named plugin twice - e.g. transitively - is\n * a no-op).\n */"
   },
   {
     "name": "NifraSchema",
@@ -5668,7 +5978,14 @@
     "doc": "/** The portable socket handed to WS lifecycle callbacks. Each adapter wraps its native socket. */"
   },
   {
-    "name": "noBackoff",
+    "name": "NO_SOCKET",
+    "kind": "const",
+    "package": "@nifrajs/client",
+    "signature": "export declare const NO_SOCKET: unique symbol;",
+    "doc": "/** Internal handshake between `inProcessClient` and the proxy: in-process apps have no socket. */"
+  },
+  {
+    "name": "noBackoff",
     "kind": "const",
     "package": "@nifrajs/jobs",
     "signature": "export declare const noBackoff: Backoff;",
@@ -5681,12 +5998,31 @@
     "signature": "export interface NodeBuiltinFinding {\n    readonly builtin: string;\n    readonly chunk: string;\n    /** The shortest import path from a user entry to the builtin, as a list of display labels:\n     * `[entryFile, ...as-written specifiers along the way, builtin]`, e.g.\n     * `[\"routes/article/[slug].tsx\", \"../data.ts\", \"../db/client.ts\", \"postgres\", \"node:tls\"]`. The\n     * entry is its graph key (the route file); each hop is the import's *as-written* specifier; the tail\n     * is the builtin. Empty only if the builtin module isn't reachable from any traced input (it always\n     * is when flagged). */\n    readonly chain: readonly string[];\n}",
     "doc": "/** One `node:`-builtin-in-the-client finding: the offending builtin, the emitted chunk it landed in,\n * and the shortest USER-module import chain that pulled it there (entry → … → builtin). */"
   },
+  {
+    "name": "nodeDirect",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function nodeDirect(): IdentityPlugin;",
+    "doc": "/** Enable `app.resolveNode()` for direct callers. Applying it twice is a no-op (named plugin dedupe). */"
+  },
+  {
+    "name": "nodeOutcomeFromResponse",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function nodeOutcomeFromResponse(response: Response): NodeServeOutcome;"
+  },
+  {
+    "name": "NodeOutcomeRuntime",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface NodeOutcomeRuntime {\n    toOutcome(result: unknown, set: CtxSet): NodeServeOutcome;\n    fromResponse(response: Response): NodeServeOutcome;\n    timeout(): NodeServeOutcome;\n}"
+  },
   {
     "name": "NodeServeOutcome",
     "kind": "type",
     "package": "@nifrajs/core",
     "signature": "export type NodeServeOutcome = {\n    readonly kind: \"response\";\n    readonly response: Response;\n} | {\n    readonly kind: \"json\";\n    readonly status: number;\n    /** `c.set.headers` backing, or `undefined` when the handler never set a header. */\n    readonly headers: Readonly<Record<string, string>> | undefined;\n    /** Queued `Set-Cookie` lines, or `undefined`; the adapter emits one header line each. */\n    readonly cookies: readonly string[] | undefined;\n    /** The JSON body already stringified, or `null` for an empty (204) response. */\n    readonly body: string | null;\n} | {\n    readonly kind: \"body\";\n    readonly status: number;\n    readonly headers: Readonly<Record<string, string | readonly string[]>> | undefined;\n    readonly body: string | Uint8Array;\n};",
-    "doc": "/**\n * What {@link Server.resolveNode} returns: either a plain-data render the `@nifrajs/node` adapter writes\n * to the socket directly (`kind: \"json\"` — status + headers + cookies + a pre-stringified body, **no**\n * undici `Response` built or drained), a marked buffered response body (`kind: \"body\"` — e.g.\n * @nifrajs/web's non-deferred SSR HTML), or a `Response` (`kind: \"response\"`) for everything else\n * (redirects, 404/405/errors, unmarked or streaming bodies). Internal to the nifra↔node bridge.\n */"
+    "doc": "/**\n * What {@link Server.resolveNode} returns: either a plain-data render the `@nifrajs/node` adapter writes\n * to the socket directly (`kind: \"json\"` - status + headers + cookies + a pre-stringified body, **no**\n * undici `Response` built or drained), a marked buffered response body (`kind: \"body\"` - e.g.\n * @nifrajs/web's non-deferred SSR HTML), or a `Response` (`kind: \"response\"`) for everything else\n * (redirects, 404/405/errors, unmarked or streaming bodies). Internal to the nifra<->node bridge.\n */"
   },
   {
     "name": "NodeServer",
@@ -5768,7 +6104,7 @@
     "name": "openapi",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function openapi(options?: OpenApiOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function openapi(options?: OpenApiOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "doc": "/**\n * Serve an OpenAPI 3.1 document (a structural subset — see {@link buildOpenApiDocument}) at\n * `options.path` (default `/openapi.json`), generated from the app's registered routes. Generation is\n * **lazy + memoized**: it reads `app.routes()` on the first request, by which point every route is\n * registered — so the plugin's own position in the chain doesn't matter.\n *\n * Pass `ui: true` (or `ui: { path, title, cdn }`) to also serve a Scalar API-reference page (default\n * `/reference`) that renders the spec. The page loads Scalar from a CDN; pin/self-host via `ui.cdn`,\n * and remember to allow that origin if you ship a `script-src` Content-Security-Policy.\n *\n * ```ts\n * app.use(openapi({ info: { title: \"My API\", version: \"1.0.0\" }, ui: true }))\n * ```\n */"
   },
   {
@@ -5847,11 +6183,17 @@
     "signature": "export interface OpenGraphInput {\n    readonly title?: string;\n    readonly description?: string;\n    /** Absolute URL of the share image (`og:image`). */\n    readonly image?: string;\n    /** Canonical URL of the page (`og:url`). */\n    readonly url?: string;\n    /** Object type (`og:type`) — `\"website\"`, `\"article\"`, … Default `\"website\"`. */\n    readonly type?: string;\n}",
     "doc": "/** Inputs for {@link openGraph} — the common Open Graph properties. All optional; only the provided\n * ones become tags. `type` defaults to `\"website\"`. */"
   },
+  {
+    "name": "openWebSocket",
+    "kind": "function",
+    "package": "@nifrajs/client",
+    "signature": "export declare function openWebSocket(base: string, path: string, callOptions: WsRuntimeOptions | undefined, noSocket: boolean): WsHandle<unknown, unknown>;"
+  },
   {
     "name": "OperationDef",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface OperationDef {\n    readonly method: Method;\n    readonly path: string;\n    readonly body?: StandardSchemaV1;\n    readonly query?: StandardSchemaV1;\n    readonly response?: StandardSchemaV1;\n    /** Declared effect tokens, carried into route reflection and capability assurance. */\n    readonly capabilities?: readonly string[];\n    /** Dedupe retries of this operation on an `Idempotency-Key` header (see {@link RouteSchema.idempotency}). */\n    readonly idempotency?: IdempotencyConfig;\n    /** Highest data-sensitivity the response carries (see {@link RouteSchema.classification}). */\n    readonly classification?: DataClassification;\n    /** Short summary (OpenAPI `summary`). */\n    readonly summary?: string;\n    /** Longer description (OpenAPI `description`, CommonMark). */\n    readonly description?: string;\n    /** Grouping tags (OpenAPI `tags`). */\n    readonly tags?: readonly string[];\n    /** Mark the operation deprecated. */\n    readonly deprecated?: boolean;\n    /** Security requirements (names ref `securitySchemes`); `[]` = explicitly public. Omit ⇒ inherit the document default. */\n    readonly security?: ReadonlyArray<Readonly<Record<string, readonly string[]>>>;\n    /** Request body content type. Default `application/json`. */\n    readonly requestContentType?: string;\n    /** Content type of the success (`200`) response. Default `application/json`. */\n    readonly responseContentType?: string;\n    /** Additional responses by status code, e.g. `{ \"404\": { description: \"Not found\" } }`. */\n    readonly responses?: Readonly<Record<string, ResponseDef>>;\n}",
+    "signature": "export interface OperationDef {\n    readonly method: Method;\n    readonly path: string;\n    /** Optional path-params schema (validated + coercible at the boundary; see {@link RouteSchema.params}). */\n    readonly params?: StandardSchemaV1;\n    readonly body?: StandardSchemaV1;\n    readonly query?: StandardSchemaV1;\n    readonly response?: StandardSchemaV1;\n    /** Declared effect tokens, carried into route reflection and capability assurance. */\n    readonly capabilities?: readonly string[];\n    /** Dedupe retries of this operation on an `Idempotency-Key` header (see {@link RouteSchema.idempotency}). */\n    readonly idempotency?: IdempotencyConfig;\n    /** Highest data-sensitivity the response carries (see {@link RouteSchema.classification}). */\n    readonly classification?: DataClassification;\n    /** Inline route-assurance evidence this operation carries (see {@link RouteSchema.assurance}). */\n    readonly assurance?: readonly string[];\n    /** Mark this operation a dynamic route family (see {@link RouteSchema.family}). */\n    readonly family?: boolean;\n    /** Short summary (OpenAPI `summary`). */\n    readonly summary?: string;\n    /** Longer description (OpenAPI `description`, CommonMark). */\n    readonly description?: string;\n    /** Grouping tags (OpenAPI `tags`). */\n    readonly tags?: readonly string[];\n    /** Mark the operation deprecated. */\n    readonly deprecated?: boolean;\n    /** Security requirements (names ref `securitySchemes`); `[]` = explicitly public. Omit ⇒ inherit the document default. */\n    readonly security?: ReadonlyArray<Readonly<Record<string, readonly string[]>>>;\n    /** Request body content type. Default `application/json`. */\n    readonly requestContentType?: string;\n    /** Content type of the success (`200`) response. Default `application/json`. */\n    readonly responseContentType?: string;\n    /** Additional responses by status code, e.g. `{ \"404\": { description: \"Not found\" } }`. */\n    readonly responses?: Readonly<Record<string, ResponseDef>>;\n}",
     "doc": "/**\n * One operation in a contract. Input schemas are any Standard Schema; `response` is optional.\n *\n * The fields below `response` are **optional OpenAPI metadata** — they don't affect runtime\n * validation or the inferred handler types, they enrich the document `toOpenAPI` emits. A contract is\n * the natural home for them: it's the versionable description of the API, decoupled from the impl.\n */"
   },
   {
@@ -5861,6 +6203,24 @@
     "signature": "export type Orm = \"drizzle\" | \"prisma\" | \"kysely\";",
     "doc": "/** ORM family of a preset — drives the auth adapter, the AGENTS DB rules, and the `c.db` query idiom. */"
   },
+  {
+    "name": "otlpExporter",
+    "kind": "function",
+    "package": "@nifrajs/otel",
+    "signature": "export declare function otlpExporter(options: OtlpExporterOptions): OtlpExporter;"
+  },
+  {
+    "name": "OtlpExporter",
+    "kind": "interface",
+    "package": "@nifrajs/otel",
+    "signature": "export interface OtlpExporter extends ObservationAdapter {\n    /** Send everything queued now. Await it in a graceful shutdown so no span is lost. */\n    flush(): Promise<void>;\n    /** Stop the periodic timer and flush a final time. Call on server stop. */\n    shutdown(): Promise<void>;\n}"
+  },
+  {
+    "name": "OtlpExporterOptions",
+    "kind": "interface",
+    "package": "@nifrajs/otel",
+    "signature": "export interface OtlpExporterOptions {\n    /** The collector's traces endpoint, e.g. `http://localhost:4318/v1/traces`. */\n    readonly url: string;\n    /** Extra headers on every export (auth tokens, tenant ids). */\n    readonly headers?: Record<string, string>;\n    /** `service.name` resource attribute. Default `\"nifra\"`. */\n    readonly serviceName?: string;\n    /** Batching knobs. */\n    readonly batch?: {\n        /** Flush once this many spans are queued. Must be a positive safe integer. Default 512. */\n        readonly maxBatch?: number;\n        /** Hard cap on the queue; oldest spans are dropped past it. Positive safe integer; default 2048. */\n        readonly maxQueue?: number;\n        /** Periodic flush interval (ms). Must be a positive safe integer. Default 5000. */\n        readonly flushIntervalMs?: number;\n    };\n    /** Called when an export POST fails or spans are dropped. Fail-open: never throws into a request. */\n    readonly onError?: (error: unknown) => void;\n    /** Override `fetch` (tests, a proxy agent). Defaults to the global. */\n    readonly fetch?: (input: string, init: RequestInit) => Promise<{\n        ok: boolean;\n        status: number;\n    }>;\n}"
+  },
   {
     "name": "OutputFormat",
     "kind": "type",
@@ -6024,6 +6384,20 @@
     "signature": "export declare function parseManifestRouteFiles(source: string, routesPrefix?: string): string[];",
     "doc": "/**\n * Extract the route-relative file list the committed server-manifest imports, normalized to the same\n * `routes/`-relative keys `discoverRoutes` produces (e.g. `docs/index.tsx`). `routesPrefix` is the\n * specifier prefix the manifest used for the routes dir (default `./routes/`, what `buildServer`'s\n * default `resolve` emits). Only import specifiers under that prefix are route files; the\n * `@nifrajs/web` import (and any other bare specifier) is ignored. Pure — operates on source text.\n */"
   },
+  {
+    "name": "parseManifestRouteStyles",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function parseManifestRouteStyles(source: string): Record<string, string[]>;",
+    "doc": "/** The baked per-route `routeStyles` map in a committed server-manifest (empty if absent/unparseable). Pure. */"
+  },
+  {
+    "name": "parseManifestStyles",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function parseManifestStyles(source: string): string[];",
+    "doc": "/** The baked top-level `styles` array in a committed server-manifest (empty if absent/unparseable). Pure. */"
+  },
   {
     "name": "parseNdjsonData",
     "kind": "function",
@@ -6110,7 +6484,7 @@
     "name": "Platform",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface Platform<Env = unknown> {\n    /** Platform bindings (KV/D1/secrets on Workers). Typed as `Env` when the app declares them via\n     * `server<Env>()`; otherwise `unknown` — validate before use. */\n    readonly env?: Env;\n    /** Extend the response's lifetime for background work (Workers `ctx.waitUntil`). */\n    readonly waitUntil?: (promise: Promise<unknown>) => void;\n}",
+    "signature": "export interface Platform<Env = unknown> {\n    /** Platform bindings (KV/D1/secrets on Workers). Typed as `Env` when the app declares them via\n     * `server<Env>()`; otherwise `unknown` — validate before use. */\n    readonly env?: Env;\n    /** Extend the response's lifetime for background work (Workers `ctx.waitUntil`). */\n    readonly waitUntil?: (promise: Promise<unknown>) => void;\n    /** The raw socket peer address the serving adapter observed, if any (`listen()`, `@nifrajs/node`,\n     * `@nifrajs/deno` set it). The server applies the app's `clientIp` trust declaration to this before\n     * exposing {@link Context.clientIp}; read `c.clientIp`, not this. */\n    readonly clientIp?: string | undefined;\n}",
     "doc": "/**\n * Runtime platform inputs, passed as `app.fetch(request, platform)`. Edge adapters (e.g.\n * Cloudflare Workers) supply `env` (bindings) + `waitUntil`; Bun/Node/Deno omit them. Optional +\n * runtime-neutral, so `app.fetch` stays a Web-standard handler.\n */"
   },
   {
@@ -6161,6 +6535,33 @@
     "package": "@nifrajs/cli",
     "signature": "export interface PortResult {\n    readonly resolved: ResolvedTarget | undefined;\n    readonly detected: readonly DetectedFeature[];\n    readonly json: PortJson;\n}"
   },
+  {
+    "name": "postcssBunPlugin",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function postcssBunPlugin(generate: \"dom\" | \"ssr\", options?: PostcssPluginOptions): BunPlugin;",
+    "doc": "/**\n * The PostCSS Bun plugin. `\"dom\"` → bundles the processed CSS (and, for `*.module.*`, exports the\n * scoped class map); `\"ssr\"` → the class map only for `*.module.*`, an empty module for plain CSS.\n * Tolerates a trailing `?query` (dev servers append one to bust Bun's import cache).\n */"
+  },
+  {
+    "name": "PostcssConfigLoader",
+    "kind": "type",
+    "package": "@nifrajs/web",
+    "signature": "export type PostcssConfigLoader = (ctx?: Record<string, unknown>, path?: string) => Promise<{\n    readonly plugins?: readonly unknown[];\n    readonly options?: Record<string, unknown>;\n}>;",
+    "doc": "/** The subset of `postcss-load-config` this plugin uses when no explicit `plugins` are given. */"
+  },
+  {
+    "name": "PostcssPluginOptions",
+    "kind": "interface",
+    "package": "@nifrajs/web",
+    "signature": "export interface PostcssPluginOptions {\n    /** Inject the `postcss` function (default: the optional peer, loaded lazily). Pass a stub in tests. */\n    readonly postcss?: PostcssProcessor;\n    /** PostCSS plugins to run. When omitted, the project's `postcss.config.js` is loaded instead. */\n    readonly plugins?: readonly unknown[];\n    /** Directory (or file) to load `postcss.config.js` from, when `plugins` is omitted. Default: cwd. */\n    readonly config?: string;\n    /** Inject the config loader (default: the `postcss-load-config` optional peer). */\n    readonly loadConfig?: PostcssConfigLoader;\n}"
+  },
+  {
+    "name": "PostcssProcessor",
+    "kind": "type",
+    "package": "@nifrajs/web",
+    "signature": "export type PostcssProcessor = (plugins?: readonly unknown[]) => {\n    process(css: string, options: {\n        readonly from?: string;\n        readonly to?: string;\n    }): PromiseLike<{\n        readonly css: string;\n    }>;\n};",
+    "doc": "/** The subset of the `postcss` API this plugin uses (structural, so no hard dependency on its types). */"
+  },
   {
     "name": "poweredBy",
     "kind": "function",
@@ -6293,7 +6694,7 @@
     "name": "prettyJson",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function prettyJson(options?: PrettyJsonOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function prettyJson(options?: PrettyJsonOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "doc": "/**\n * Pretty-print JSON responses for debugging and developer-facing APIs. It only touches JSON content,\n * skips encoded responses, caps inspection size, and leaves invalid JSON untouched.\n */"
   },
   {
@@ -6302,6 +6703,20 @@
     "package": "@nifrajs/middleware",
     "signature": "export interface PrettyJsonOptions {\n    /** JSON indentation spaces. Default `2`. */\n    readonly spaces?: number;\n    /** Maximum response bytes to inspect. Default `1_000_000`; larger responses pass through. */\n    readonly maxBytes?: number;\n    /** Append a final newline. Default `true`. */\n    readonly newline?: boolean;\n    /** Optional query toggle. When set, pretty printing runs only when the parameter is present. */\n    readonly query?: string | false;\n    /** Only pretty-print matching requests. Default `true`. */\n    readonly enabled?: boolean | ((request: Request) => boolean);\n}"
   },
+  {
+    "name": "Principal",
+    "kind": "interface",
+    "package": "@nifrajs/better-auth",
+    "signature": "export interface Principal<User> {\n    /** The full better-auth user record, typed from the concrete auth instance. */\n    readonly user: User;\n    /** The user's id (`user.id`). */\n    readonly userId: string;\n    /** The session's id (`session.id`). */\n    readonly sessionId: string;\n    /** The resolved tenant/org id, if any. Non-optional `string` under `{ requireTenant: true }`. */\n    readonly tenantId?: string;\n}",
+    "doc": "/**\n * The authenticated caller of a request, mapped from a better-auth session. Built by\n * {@link requirePrincipal} / {@link authed} and threaded onto the handler context as `c.principal`.\n *\n * `tenantId` is optional here (`string | undefined`); with `{ requireTenant: true }` it is narrowed to a\n * non-optional `string` (see {@link authed}), so a tenant-scoped handler never has to null-check it.\n * nifra owns the session -> principal wiring ONLY; binding the principal to a DB/RLS scope stays in\n * userland (nifra is storage-agnostic and adds no DB code).\n */"
+  },
+  {
+    "name": "PrincipalFor",
+    "kind": "type",
+    "package": "@nifrajs/better-auth",
+    "signature": "export type PrincipalFor<User, RequireTenant extends boolean> = RequireTenant extends true ? Principal<User> & {\n    readonly tenantId: string;\n} : Principal<User>;",
+    "doc": "/**\n * The principal type for a given `requireTenant` flag: `tenantId` narrows to a required `string` when\n * `requireTenant` is `true`, otherwise stays optional (`string | undefined`). The flag is captured as a\n * literal `const` type parameter at the call sites so `{ requireTenant: true }` selects the narrowed branch.\n */"
+  },
   {
     "name": "projectFeatures",
     "kind": "function",
@@ -6488,7 +6903,7 @@
     "kind": "type",
     "package": "@nifrajs/core",
     "signature": "export type QueryValue = string | string[];",
-    "doc": "/** A query value: a single occurrence is a string; a repeated key promotes to a string[] so an\n * array query schema (`t.array(t.string())`) can validate `?tag=a&tag=b` — last-wins silently\n * dropped values before (audit 2026-06). Single-occurrence keys stay plain strings, so existing\n * `t.string()` schemas are untouched; a repeated key against a string schema now FAILS validation\n * (an explicit 400 beats silently picking one). */"
+    "doc": "/** A query value: a single occurrence is a string; a repeated key promotes to a string[] so an\n * array query schema (`t.array(t.string())`) can validate `?tag=a&tag=b` - last-wins silently\n * dropped values before (audit 2026-06). Single-occurrence keys stay plain strings, so existing\n * `t.string()` schemas are untouched; a repeated key against a string schema now FAILS validation\n * (an explicit 400 beats silently picking one). */"
   },
   {
     "name": "Queue",
@@ -6568,6 +6983,13 @@
     "signature": "export declare function raw(trusted: string): RawHtml;",
     "doc": "/**\n * Mark a string as trusted, pre-escaped markup — it is emitted verbatim. The deliberate escape\n * hatch (CMS-sanitized HTML, pre-rendered markdown): every call site is greppable, exactly like\n * React's dangerouslySetInnerHTML, without the JSX.\n */"
   },
+  {
+    "name": "RawContext",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface RawContext {\n    readonly req: Request;\n    readonly request: Request;\n    readonly json: (body: unknown, init?: ResponseInit | number) => Response;\n    readonly text: (body: string, init?: ResponseInit | number) => Response;\n    params: Record<string, string>;\n    query: unknown;\n    readonly cookies: Readonly<Record<string, string>>;\n    body: unknown;\n    readonly set: ResponseControls;\n    readonly [CONTEXT_SET]: () => CtxSet | undefined;\n    readonly [CONTEXT_SEARCH]: string;\n    readonly signal: AbortSignal;\n    readonly budget: RequestBudget;\n    readonly env: unknown;\n    readonly clientIp: string | undefined;\n    readonly waitUntil: (promise: Promise<unknown>) => void;\n    readonly boundedBody: (maxBytes?: number) => Promise<Uint8Array>;\n    readonly boundedJson: <T = unknown>(maxBytes?: number) => Promise<T>;\n}",
+    "doc": "/** Internal, path-erased runtime context. The typed `Context<Path, S>` is a structural view of this. */"
+  },
   {
     "name": "RawHtml",
     "kind": "class",
@@ -6622,6 +7044,20 @@
     "signature": "export declare function readBoundedBytes(req: BodySource, maxBytes: number): Promise<{\n    ok: true;\n    bytes: Uint8Array;\n} | {\n    ok: false;\n    status: 400 | 413;\n}>;",
     "doc": "/**\n * Read a request body as **bytes**, capped at `maxBytes`. Rejects a `Content-Length` over the cap\n * before buffering (`413`) and a malformed `Content-Length` (`400`); a chunked / length-less body\n * falls through to the streaming byte-cap guard. Fast path: a non-chunked request with a\n * `Content-Length` within the cap is read via native `arrayBuffer()` (framing-bounded by the runtime's\n * HTTP server), skipping the manual stream loop.\n */"
   },
+  {
+    "name": "readBoundedForm",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function readBoundedForm(req: RequestSource, maxBytes: number): Promise<Record<string, QueryValue> | Response>;",
+    "doc": "/**\n * Read an HTML-form body (urlencoded) into the plain object a body schema validates - same byte\n * cap as the JSON path (a lying/absent Content-Length can't force an oversized buffer), same\n * repeated-key -> `string[]` promotion as query parsing, same `__proto__` guard.\n */"
+  },
+  {
+    "name": "readBoundedJsonSource",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function readBoundedJsonSource(req: RequestSource, maxBytes: number): Promise<unknown | Response>;",
+    "doc": "/**\n * Read a JSON body with the same byte cap used by schema validation and `c.boundedJson`.\n * Non-chunked, framed requests with an in-cap `Content-Length` use the runtime-native `req.json()`;\n * chunked or length-less requests fall back to the streaming byte-cap guard.\n */"
+  },
   {
     "name": "readCausalityHeaders",
     "kind": "function",
@@ -6681,8 +7117,8 @@
     "name": "redirect",
     "kind": "function",
     "package": "@nifrajs/web",
-    "signature": "export declare function redirect(location: string, statusOrOptions?: number | RedirectOptions): Response;",
-    "doc": "/**\n * Build a redirect `Response` — return it from a route `action` for the Post/Redirect/Get\n * pattern (POST mutates, 303 sends the browser to a fresh GET, so a reload doesn't re-submit).\n * Defaults to 303 (See Other); pass `307`/`308` (or `{ status }`) to preserve the method.\n *\n * **Secure by default:** `location` must be a same-origin path (begins with `/`, not `//`). An\n * off-origin/absolute destination throws unless you pass `{ external: true }` — this closes the\n * open-redirect footgun of `return redirect(formData.get(\"next\"))` on the no-JS (native-form) path,\n * which returns the action's `Response` verbatim.\n *\n * @param statusOrOptions a status number (back-compat) or `{ status?, external? }`.\n */"
+    "signature": "export declare function redirect(location: string, options?: RedirectOptions): Response;",
+    "doc": "/**\n * Build a redirect `Response` — return it from a route `action` for the Post/Redirect/Get\n * pattern (POST mutates, 303 sends the browser to a fresh GET, so a reload doesn't re-submit).\n * Defaults to 303 (See Other); pass `{ status: 307 }` or `{ status: 308 }` to preserve the method.\n *\n * **Secure by default:** `location` must be a same-origin path (begins with `/`, not `//`). An\n * off-origin/absolute destination throws unless you pass `{ external: true }` — this closes the\n * open-redirect footgun of `return redirect(formData.get(\"next\"))` on the no-JS (native-form) path,\n * which returns the action's `Response` verbatim.\n *\n * @param options redirect status and whether an off-origin destination is intentional.\n */"
   },
   {
     "name": "REDIRECT_HEADER",
@@ -6709,13 +7145,13 @@
     "name": "ReflectedRoute",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface ReflectedRoute {\n    readonly method: string;\n    readonly path: string;\n    readonly schema?: ReflectedRouteSchema;\n    readonly assurance?: readonly AssuranceEvidence[];\n    readonly capabilities?: readonly string[];\n    /** Field-level response classification plus the highest sensitivity present. */\n    readonly classification?: ResponseClassification;\n    readonly tool?: {\n        readonly name: string;\n        readonly description: string;\n        readonly annotations?: ToolAnnotations;\n    };\n}"
+    "signature": "export interface ReflectedRoute {\n    readonly method: string;\n    readonly path: string;\n    readonly schema?: ReflectedRouteSchema;\n    readonly assurance?: readonly AssuranceEvidence[];\n    readonly capabilities?: readonly string[];\n    /** Set when the route is a declared dynamic route family (a runtime-resolved template like\n     * `/api/:slug/:resource`) - so the assurance gate treats it as one classified family, not a single route. */\n    readonly family?: boolean;\n    /** Field-level response classification plus the highest sensitivity present. */\n    readonly classification?: ResponseClassification;\n    readonly tool?: {\n        readonly name: string;\n        readonly description: string;\n        readonly annotations?: ToolAnnotations;\n    };\n}"
   },
   {
     "name": "ReflectedRouteSchema",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface ReflectedRouteSchema {\n    readonly body?: SchemaReflection;\n    readonly query?: SchemaReflection;\n    readonly response?: SchemaReflection;\n    readonly errors?: Readonly<Record<string, SchemaReflection>>;\n    /** The SSE event-payload schema of a typed streaming route (`app.sse()`). */\n    readonly sse?: SchemaReflection;\n}"
+    "signature": "export interface ReflectedRouteSchema {\n    readonly body?: SchemaReflection;\n    readonly query?: SchemaReflection;\n    /** Path-params schema — constraints (uuid format, integer min/max) declared via `params: t.object(…)`. */\n    readonly params?: SchemaReflection;\n    readonly response?: SchemaReflection;\n    readonly errors?: Readonly<Record<string, SchemaReflection>>;\n    /** The SSE event-payload schema of a typed streaming route (`app.sse()`). */\n    readonly sse?: SchemaReflection;\n}"
   },
   {
     "name": "ReflectedSchemaField",
@@ -6871,7 +7307,7 @@
     "name": "RenderProps",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface RenderProps {\n    readonly data: unknown;\n    readonly actionData?: unknown;\n    /** True while a client navigation or submit is in flight (client-only; absent/false on SSR). */\n    readonly pending?: boolean;\n    /** The in-flight client submit, for optimistic UI (client-only; absent on SSR + when idle). */\n    readonly submission?: Submission;\n    /** The matched route's decoded path params (`/users/:id` → `{ id: \"7\" }`). Threaded identically on\n     * SSR (from the request match) and on client navigation (from router state) so an adapter's\n     * `useParams` reads the same value on both, with no hydration mismatch. Absent ⇒ no params (`{}`). */\n    readonly params?: Readonly<Record<string, string>>;\n    /** The current URL's `pathname + search` (no hash — the hash never reaches the server). Threaded on\n     * SSR and client alike so an adapter's `useLocation`/`useSearchParams` hydrate consistently. Absent\n     * on adapters/callers that don't supply it (treated as `\"\"`). */\n    readonly path?: string;\n}",
+    "signature": "export interface RenderProps {\n    readonly data: unknown;\n    readonly actionData?: unknown;\n    /** True while a client navigation or submit is in flight (client-only; absent/false on SSR). */\n    readonly pending?: boolean;\n    /** The path a client navigation is transitioning TO while `pending` (client-only; absent on SSR and\n     * when idle). Lets an adapter tell a `NavLink` whether its own target is the one loading. */\n    readonly pendingPath?: string;\n    /** The in-flight client submit, for optimistic UI (client-only; absent on SSR + when idle). */\n    readonly submission?: Submission;\n    /** The matched route's decoded path params (`/users/:id` → `{ id: \"7\" }`). Threaded identically on\n     * SSR (from the request match) and on client navigation (from router state) so an adapter's\n     * `useParams` reads the same value on both, with no hydration mismatch. Absent ⇒ no params (`{}`). */\n    readonly params?: Readonly<Record<string, string>>;\n    /** The current URL's `pathname + search` (no hash — the hash never reaches the server). Threaded on\n     * SSR and client alike so an adapter's `useLocation`/`useSearchParams` hydrate consistently. Absent\n     * on adapters/callers that don't supply it (treated as `\"\"`). */\n    readonly path?: string;\n}",
     "doc": "/** The data handed to a route component. Opaque to the core. `actionData` is the return of a\n * route `action` after a POST (absent on plain GETs). `pending` + `submission` are client-only\n * (absent on SSR): they drive **optimistic UI** — render from `submission.formData` while `pending`. */"
   },
   {
@@ -6936,11 +7372,17 @@
     "signature": "export interface RequestBudget {\n    /** Absolute Unix epoch deadline for wire propagation. */\n    readonly deadline: number;\n    /** The request cancellation signal. Nifra drives this when its effective deadline elapses. */\n    readonly signal: AbortSignal;\n    /** Non-negative milliseconds remaining, measured with the monotonic clock. */\n    remaining(): number;\n    /** A view that finishes `reserveMs` before this budget, preserving time for response cleanup. */\n    child(reserveMs: number): RequestBudget;\n}",
     "doc": "/** A time budget shared by one request and every downstream hop it initiates. */"
   },
+  {
+    "name": "RequestContext",
+    "kind": "class",
+    "package": "@nifrajs/core",
+    "signature": "export declare class RequestContext implements RawContext {\n    params: Record<string, string>;\n    body: unknown;\n    private searchValue;\n    private signalValue;\n    private budgetValue;\n    private platformValue;\n    private setValue;\n    private queryValue;\n    private queryReady;\n    private cookiesValue;\n    private readonly source;\n    private readonly maxBodyBytes;\n    constructor(source: RequestSource, params: Record<string, string>, maxBodyBytes: number);\n    constructor(source: RequestSource, params: Record<string, string>, search: string | undefined, signal: AbortSignal, budget: RequestBudget, platform: Platform | undefined, maxBodyBytes: number);\n    static native(source: RequestSource, params: Record<string, string>, maxBodyBytes: number): RequestContext;\n    [CONTEXT_SET](): CtxSet | undefined;\n    get [CONTEXT_SEARCH](): string;\n    get set(): CtxSet;\n    get signal(): AbortSignal;\n    get budget(): RequestBudget;\n    get env(): unknown;\n    get clientIp(): string | undefined;\n    get waitUntil(): (promise: Promise<unknown>) => void;\n    get req(): Request;\n    get request(): Request;\n    json(body: unknown, init?: ResponseInit | number): Response;\n    text(body: string, init?: ResponseInit | number): Response;\n    get query(): unknown;\n    set query(v: unknown);\n    get cookies(): Readonly<Record<string, string>>;\n    boundedBody(maxBytes?: number): Promise<Uint8Array>;\n    boundedJson<T = unknown>(maxBytes?: number): Promise<T>;\n}"
+  },
   {
     "name": "requestId",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function requestId(options?: RequestIdOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").Server<any, any>>;",
+    "signature": "export declare function requestId(options?: RequestIdOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").Server<any, any>>;",
     "doc": "/**\n * A {@link definePlugin} plugin that gives every request a stable id: it reuses an inbound\n * `x-request-id` (or generates one), exposes it on the handler context as **`c.requestId`** (typed,\n * threaded by `derive`), and echoes it on the response header. Idempotent — applying it twice is a\n * no-op.\n *\n * ```ts\n * app.use(requestId())          // c.requestId available downstream; X-Request-Id on responses\n * ```\n */"
   },
   {
@@ -6963,6 +7405,13 @@
     "signature": "export interface RequestLogFields {\n    readonly method: string;\n    readonly path: string;\n    readonly status: number;\n    /** Wall-clock duration in ms (0 if the start couldn't be paired). */\n    readonly ms: number;\n}",
     "doc": "/** Structured fields logged per request. */"
   },
+  {
+    "name": "requestOf",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function requestOf(source: RequestSource): Request;",
+    "doc": "/** The concrete `Request` for a source - itself when a real `Request` was passed (the Web path), or the\n * lazily-built one (the Node adapter). A real `Request` IS a `RequestSource`, so no wrapper is allocated\n * on the Web hot path. */"
+  },
   {
     "name": "RequestProtocol",
     "kind": "type",
@@ -6996,6 +7445,13 @@
     "signature": "export declare function requirePeer<T>(specifier: string, hint: {\n    readonly feature: string;\n    readonly install: string;\n}): Promise<T>;",
     "doc": "/**\n * Load an optional peer compiler at build time, throwing a consistent, actionable install-hint error if\n * it's absent — the `@vue/compiler-sfc` peer pattern, centralized. Build-time only, so the dynamic\n * `import` (which keeps the peer out of the package's hard dependencies) is correct here.\n */"
   },
+  {
+    "name": "requirePrincipal",
+    "kind": "function",
+    "package": "@nifrajs/better-auth",
+    "signature": "export declare function requirePrincipal<A extends BetterAuthLike, const RequireTenant extends boolean = false>(auth: A, request: Request, options?: AuthedOptions<SessionUserOf<A>> & {\n    readonly requireTenant?: RequireTenant;\n}): Promise<PrincipalFor<SessionUserOf<A>, RequireTenant>>;",
+    "doc": "/**\n * Resolve the better-auth session and map it to a {@link Principal}, or **throw a `Response`** so the\n * handler never runs unauthenticated:\n *\n * - No/invalid session -> `302` to `options.redirectTo` when set, else `401` JSON (`requireSession`).\n * - `requireTenant: true` and no tenant resolves -> `403` JSON (`{ ok: false, error: \"forbidden\" }`).\n *\n * nifra returns a thrown `Response` as-is (short-circuit), so this is the fail-closed guard used inline\n * or by {@link authed}. `tenantId` is a non-optional `string` in the return type when `requireTenant`.\n *\n * ```ts\n * const principal = await requirePrincipal(auth, c.req, { requireTenant: true })\n * // principal.userId / principal.tenantId are typed `string`, no null-check\n * ```\n */"
+  },
   {
     "name": "requireSecretBytes",
     "kind": "function",
@@ -7043,6 +7499,27 @@
     "package": "@nifrajs/image",
     "signature": "export interface ResizeOutput {\n    readonly bytes: Uint8Array;\n    readonly contentType: string;\n    readonly format: OutputFormat;\n}"
   },
+  {
+    "name": "resolveClientIp",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function resolveClientIp(peer: string | undefined, req: Request, trust: ClientIpTrust | undefined): string | undefined;",
+    "doc": "/**\n * Resolve the caller IP from the raw socket `peer` (adapter-observed), the request's forwarding\n * headers, and the app's `trust` declaration. Pure and synchronous.\n */"
+  },
+  {
+    "name": "ResolvedEffectLedger",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ResolvedEffectLedger {\n    readonly sink: EffectLedgerOptions[\"sink\"];\n    readonly maxEntries: number;\n    readonly chain: boolean;\n    /** The registered route pattern - what the sealed ledger names (never the concrete URL). */\n    readonly method: string;\n    readonly path: string;\n    /** The route's declared capability tokens, surfaced on the sealed ledger. */\n    readonly declared: readonly string[];\n}",
+    "doc": "/** Registration-resolved effect-ledger wiring for one capability-declaring route. */"
+  },
+  {
+    "name": "ResolvedIdempotency",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ResolvedIdempotency {\n    readonly store: IdempotencyStore;\n    readonly ttlMs: number;\n    readonly headerName: string;\n    readonly namespace: NonNullable<RouteSchema[\"idempotency\"]>[\"namespace\"];\n    readonly maxResponseBytes: number;\n}",
+    "doc": "/** Registration-resolved idempotency for a route: the config with its store + defaults pinned. */"
+  },
   {
     "name": "ResolvedImage",
     "kind": "interface",
@@ -7111,6 +7588,12 @@
     "signature": "export declare function respondMcpHttp(request: Request, tools: McpTool[], serverInfo: {\n    name: string;\n    version: string;\n}, options?: McpHttpOptions): Promise<Response>;",
     "doc": "/**\n * Handle one MCP request over HTTP against the given `tools`/`features`. POST a JSON-RPC body → JSON-RPC\n * response; GET → a plain-text health page; OPTIONS → CORS preflight. Never throws — a bad body becomes a\n * JSON-RPC parse error. The dispatch is the shared, transport-agnostic {@link handleRpc}.\n */"
   },
+  {
+    "name": "RESPONSE_RESULT",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const RESPONSE_RESULT: unique symbol;"
+  },
   {
     "name": "responseCache",
     "kind": "const",
@@ -7130,6 +7613,13 @@
     "signature": "export interface ResponseClassification {\n    readonly fields: Readonly<Record<string, DataClassification>>;\n    readonly max: DataClassification;\n}",
     "doc": "/** Field paths use JSON Pointer segments; array items use a `*` segment. */"
   },
+  {
+    "name": "ResponseContractViolation",
+    "kind": "class",
+    "package": "@nifrajs/client",
+    "signature": "export declare class ResponseContractViolation extends Error {\n    constructor(message: string);\n}",
+    "doc": "/**\n * A response body that broke its route's declared contract. Thrown THROUGH the \"never throws\"\n * client on purpose: this is a test assertion about the server's honesty, not a call outcome the\n * caller should branch on - swallowing it into a `Result` would let the drift pass the test.\n */"
+  },
   {
     "name": "ResponseControls",
     "kind": "interface",
@@ -7158,12 +7648,25 @@
     "signature": "export declare function responseFromStored(stored: StoredResponse, options?: {\n    readonly maxBytes?: number;\n}): Response;",
     "doc": "/** Rebuild a live response from storage, stamping the replay marker header. */"
   },
+  {
+    "name": "ResponseResult",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface ResponseResult {\n    readonly [RESPONSE_RESULT]: true;\n    toResponse(): Response;\n    toNodeBody?(): {\n        readonly status: number;\n        readonly headers: Readonly<Record<string, string | readonly string[]>> | undefined;\n        readonly body: string | Uint8Array;\n    };\n}"
+  },
   {
     "name": "Result",
     "kind": "type",
     "package": "@nifrajs/client",
-    "signature": "export type Result<Data, ErrData = unknown> = {\n    readonly ok: true;\n    readonly status: number;\n    readonly data: Data;\n    readonly error: null;\n} | {\n    readonly ok: false;\n    readonly status: number;\n    readonly data: ErrData;\n    readonly error: ApiError;\n};",
-    "doc": "/**\n * The outcome of a client call. The client never throws — inspect `ok` to branch.\n * `data` is the parsed response body, **typed by `ok`**: on success it's the route's\n * response type; on failure it's the parsed error body, typed from the route's\n * `errors` contract (`unknown` when the route declares none, `null` on a transport\n * error with no response body). `error` is always the server's normalized\n * `{ error, issues? }` summary on failure (or a transport error), `null` on success.\n */"
+    "signature": "export type Result<Data, Errors = unknown> = {\n    readonly ok: true;\n    readonly status: number;\n    readonly data: Data;\n    readonly error: null;\n} | ([Errors] extends [Record<number, unknown>] ? DeclaredFailures<Errors> | {\n    readonly ok: false;\n    readonly status: Exclude<ErrorStatus, Extract<keyof Errors, number>> | 0;\n    readonly data: unknown;\n    readonly error: ApiError;\n} : {\n    readonly ok: false;\n    readonly status: number;\n    readonly data: Errors;\n    readonly error: ApiError;\n});",
+    "doc": "/**\n * The outcome of a client call. The client never throws - inspect `ok` to branch.\n *\n * On success, `data` is the route's response type. On failure the union is DISCRIMINATED BY\n * `status` when the route declares an `errors` record: `status === 404` narrows `data` to the\n * declared 404 body; every undeclared status (plus `0` for a transport error with no response)\n * falls into a fallback arm whose `data` is `unknown`. A route with no `errors` contract keeps a\n * single failure arm with `data: Errors` (`unknown`). `error` is always the server's normalized\n * `{ error, issues? }` summary on failure, `null` on success.\n */"
+  },
+  {
+    "name": "resyncServerManifestSource",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function resyncServerManifestSource(source: string, manifest: Parameters<typeof generateServerManifest>[0], routesPrefix: string): string;",
+    "doc": "/**\n * Re-emit a committed server-manifest from a freshly-discovered route tree, PRESERVING its baked\n * client-asset references (`clientEntry` / `styles` / `routeStyles`) and its eager-vs-lazy shape. This is\n * what makes `nifra sync-manifest` a route-table refresh (renamed / added / removed routes) that does NOT\n * need a full build. It deliberately does NOT rebuild the client bundle: a brand-new HYDRATING route still\n * needs a full build so its client chunk exists - this only re-syncs the server manifest's route table.\n * Pure: `source` + the discovered `manifest` in, new source out.\n */"
   },
   {
     "name": "RetryPolicy",
@@ -7282,8 +7785,8 @@
     "name": "RouteDescriptor",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface RouteDescriptor {\n    readonly method: Method;\n    readonly path: string;\n    readonly schema: RouteSchema | undefined;\n    /** Effective enforcement evidence, populated only during reflection/introspection. */\n    readonly assurance?: readonly AssuranceEvidence[];\n    /** Normalized declared effect tokens, populated only when the route declares any. */\n    readonly capabilities?: readonly string[];\n    readonly tool?: {\n        readonly name: string;\n        readonly description: string;\n        readonly annotations?: ToolAnnotations;\n    };\n}",
-    "doc": "/**\n * A registered route's public descriptor — method, path, and input schemas. The\n * router trie discards the original patterns, so this flat list is what lets tools\n * (e.g. `toOpenAPI`) enumerate routes after registration.\n */"
+    "signature": "export interface RouteDescriptor {\n    readonly method: Method;\n    readonly path: string;\n    readonly schema: RouteSchema | undefined;\n    /** Effective enforcement evidence, populated only during reflection/introspection. */\n    readonly assurance?: readonly AssuranceEvidence[];\n    /** Normalized declared effect tokens, populated only when the route declares any. */\n    readonly capabilities?: readonly string[];\n    /** Set when the route is a declared dynamic route family (`schema.family`). */\n    readonly family?: boolean;\n    readonly tool?: {\n        readonly name: string;\n        readonly description: string;\n        readonly annotations?: ToolAnnotations;\n    };\n}",
+    "doc": "/**\n * A registered route's public descriptor - method, path, and input schemas. The\n * router trie discards the original patterns, so this flat list is what lets tools\n * (e.g. `toOpenAPI`) enumerate routes after registration.\n */"
   },
   {
     "name": "RouteEntry",
@@ -7303,7 +7806,7 @@
     "name": "RouteInfo",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface RouteInfo {\n    readonly params: object;\n    readonly query: unknown;\n    readonly body: unknown;\n    readonly output: unknown;\n    /** Union of the route's declared error-response body types (from `schema.errors`); `unknown` when the\n     * route declares none. Surfaced by the typed client as the failure `errorData`. */\n    readonly errors?: unknown;\n    /** The SSE event payload type (from `schema.sse`, declared via `app.sse()`); `never` for ordinary\n     * routes. The typed client keys `.subscribe()` availability and its event type off this. */\n    readonly sse?: unknown;\n}",
+    "signature": "export interface RouteInfo {\n    readonly params: object;\n    readonly query: unknown;\n    readonly body: unknown;\n    readonly output: unknown;\n    /** The route's declared error bodies as a status-keyed record (from `schema.errors`, e.g.\n     * `{ 404: NotFound }`); `unknown` when the route declares none. The typed client turns this into\n     * a status-discriminated failure union. */\n    readonly errors?: unknown;\n    /** The SSE event payload type (from `schema.sse`, declared via `app.sse()`); `never` for ordinary\n     * routes. The typed client keys `.subscribe()` availability and its event type off this. */\n    readonly sse?: unknown;\n    /** The WebSocket message contract (from `app.ws()`'s `messageSchema`/`sendSchema`): `in` is what the\n     * client may send, `out` what the server pushes. Present only on WS entries (method key `\"WS\"`);\n     * the typed client keys `.ws()` availability and its frame types off this. */\n    readonly ws?: unknown;\n}",
     "doc": "/**\n * One route's input/output shape as the **client** will consume it. `query`/`body`\n * are `never` when the route declares no schema for them, so the client can detect\n * \"this route takes no body\" via `[body] extends [never]`. `output` is the\n * handler's raw return type (the client applies `Jsonify` when reading it).\n */"
   },
   {
@@ -7313,6 +7816,13 @@
     "signature": "export type RouteInfoFor<Path extends string, S extends RouteSchema, Output> = {\n    readonly params: Params<Path>;\n    readonly query: RegistryQuery<S>;\n    readonly body: RegistryBody<S>;\n    readonly output: RegistryOutput<S, Output>;\n    readonly errors: RegistryErrors<S>;\n    readonly sse: RegistrySse<S>;\n};",
     "doc": "/** Build a {@link RouteInfo} from a route's path, schema, and handler output type. */"
   },
+  {
+    "name": "RouteIntrospectable",
+    "kind": "interface",
+    "package": "@nifrajs/client",
+    "signature": "export interface RouteIntrospectable {\n    routes(): ReadonlyArray<RouteDescriptorLike>;\n}",
+    "doc": "/** What `validateResponses` needs from the app beyond `fetch`: the route table. */"
+  },
   {
     "name": "RouteJson",
     "kind": "interface",
@@ -7406,7 +7916,7 @@
     "name": "RouterContextValue",
     "kind": "interface",
     "package": "@nifrajs/web-react",
-    "signature": "export interface RouterContextValue {\n    /** The matched route's decoded path params (`/users/:id` → `{ id: \"7\" }`). */\n    readonly params: Readonly<Record<string, string>>;\n    /** The current URL's `pathname + search` (no hash — the router never carries one). */\n    readonly path: string;\n}",
+    "signature": "export interface RouterContextValue {\n    /** The matched route's decoded path params (`/users/:id` → `{ id: \"7\" }`). */\n    readonly params: Readonly<Record<string, string>>;\n    /** The current URL's `pathname + search` (no hash — the router never carries one). */\n    readonly path: string;\n    /** True while a client navigation (or revalidation) is in flight — the current route stays mounted\n     * until the new one is ready. Always `false` on SSR (loaders block before render). Drives loading UI\n     * via {@link useNavigation}. */\n    readonly pending: boolean;\n    /** The `pathname + search` a navigation is transitioning TO while `pending` (`undefined` when idle or\n     * during a same-route revalidation). Powers {@link NavLink}'s per-link `isPending`. */\n    readonly pendingPath?: string | undefined;\n}",
     "doc": "/** The current route the routing hooks read. Provided by `compose` on SSR + client mount alike. */"
   },
   {
@@ -7420,14 +7930,14 @@
     "name": "RouterState",
     "kind": "interface",
     "package": "@nifrajs/web",
-    "signature": "export interface RouterState {\n    readonly routeId: string;\n    readonly params: Record<string, string>;\n    /** The current URL path (used to revalidate the active loader after an action). */\n    readonly path: string;\n    readonly data: unknown;\n    /** An action's data return after a client-side submit (cleared on navigation). */\n    readonly actionData?: unknown;\n    /** True while a navigation or submit is in flight (drives loading UI). */\n    readonly pending: boolean;\n    /** The in-flight submit (set during a `submit`, cleared when it settles) — for optimistic UI. */\n    readonly submission?: Submission;\n}",
+    "signature": "export interface RouterState {\n    readonly routeId: string;\n    readonly params: Record<string, string>;\n    /** The current URL path (used to revalidate the active loader after an action). */\n    readonly path: string;\n    readonly data: unknown;\n    /** An action's data return after a client-side submit (cleared on navigation). */\n    readonly actionData?: unknown;\n    /** True while a navigation or submit is in flight (drives loading UI). */\n    readonly pending: boolean;\n    /** The path a navigation is transitioning TO while `pending` (cleared when it settles). Lets a\n     * `NavLink` know whether its own `to` is the one loading; `undefined` when idle. */\n    readonly pendingPath?: string | undefined;\n    /** The in-flight submit (set during a `submit`, cleared when it settles) — for optimistic UI. */\n    readonly submission?: Submission;\n}",
     "doc": "/** The router's observable state. A new object is published on every transition. */"
   },
   {
     "name": "RouteSchema",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface RouteSchema {\n    /** Declared effect tokens. Reflected for assurance; never read by validation or serialization. */\n    readonly capabilities?: readonly string[];\n    /**\n     * Dedupe retries of this (mutating) route on an `Idempotency-Key` header. The first request runs and\n     * its response is stored; a retry with the same key replays that response without re-running the\n     * handler, and a key reused with a different body is rejected (409). A missing key on an\n     * idempotency-required route fails closed (400). Off the hot path — routes without it are unchanged.\n     */\n    readonly idempotency?: IdempotencyConfig;\n    /**\n     * Highest data-sensitivity this route's response body carries (`public` | `pii` | `secret`). A\n     * declarative, compile-time + introspection fact — never validated at runtime. Reflected for tooling,\n     * recorded in the capability lockfile (so a route that starts returning PII is a reviewable change),\n     * and read by downstream policy (e.g. a partner-API surface refusing to expose `pii`/`secret`).\n     */\n    readonly classification?: DataClassification;\n    readonly body?: StandardSchemaV1;\n    readonly query?: StandardSchemaV1;\n    /** Optional **response contract**. When declared: the handler's return is type-checked against it\n     * (the implementation can't drift from the contract), the typed client sees THIS as the response type\n     * (the contract — not the handler's incidental return), and it's emitted into OpenAPI/JSON-Schema so\n     * tooling and coding agents can read the exact shape. It is **not** validated at runtime (zero\n     * hot-path cost) — purely a compile-time + introspection contract. */\n    readonly response?: StandardSchemaV1;\n    /**\n     * Optional **error-response contract**: a map of HTTP status code → the Standard Schema of that error's\n     * body. Declares a route's failure modes so they flow into OpenAPI (as non-2xx `responses`), the\n     * `/llms.txt` context, and other introspection — the whole contract, not just the happy path, is legible\n     * to tooling and coding agents. Like `response`, it is **not** validated at runtime (zero hot-path cost);\n     * it's a compile-time + introspection contract. Example: `{ 404: NotFound, 409: Conflict }`. */\n    readonly errors?: Readonly<Record<number, StandardSchemaV1>>;\n    /**\n     * Optional **SSE event contract**: the Standard Schema of each event's `data` payload on a\n     * streaming route (declared via `app.sse()`). Marks the route as a typed event stream — the\n     * typed client grows a `.subscribe()` for it, and the schema flows into reflection. Like\n     * `response`, it is **not** validated at runtime (zero hot-path cost); the server-side\n     * `stream.send()` is compile-time-checked against it instead.\n     */\n    readonly sse?: StandardSchemaV1;\n    /**\n     * Hook fired when the request fails `body`/`query` validation, before the handler runs. `kind` says\n     * which input failed (`\"body\"` | `\"query\"`). Its return value selects one of three outcomes (may be async):\n     *   - a **`Response`** → returned as-is, short-circuiting the route (custom error envelope, redirect, …).\n     *   - **any other value** → treated as a repaired payload and **re-validated once** against the same\n     *     schema. If it now passes, the handler runs with it; if it still fails, the original `422` stands.\n     *     Re-validation means a bad return can't bypass the schema — the trust boundary holds.\n     *   - **`undefined`** → give up; the original validation `422` is returned unchanged.\n     * A route hook **overrides** the app-wide default set via `server({ onValidationError })`; return\n     * `undefined` to fall through to the plain `422` even when an app default exists. Typical uses: a custom\n     * error envelope, coercing the input, or prompting an LLM to repair the payload (re-validated, so it can't\n     * bypass the schema).\n     */\n    readonly onValidationError?: (issues: ReadonlyArray<StandardIssue>, ctx: Context, kind: \"body\" | \"query\") => Response | unknown | Promise<Response | unknown>;\n}",
+    "signature": "export interface RouteSchema {\n    /** Declared effect tokens. Reflected for assurance; never read by validation or serialization. */\n    readonly capabilities?: readonly string[];\n    /**\n     * Dedupe retries of this (mutating) route on an `Idempotency-Key` header. The first request runs and\n     * its response is stored; a retry with the same key replays that response without re-running the\n     * handler, and a key reused with a different body is rejected (409). A missing key on an\n     * idempotency-required route fails closed (400). Off the hot path — routes without it are unchanged.\n     */\n    readonly idempotency?: IdempotencyConfig;\n    /**\n     * Highest data-sensitivity this route's response body carries (`public` | `pii` | `secret`). A\n     * declarative, compile-time + introspection fact — never validated at runtime. Reflected for tooling,\n     * recorded in the capability lockfile (so a route that starts returning PII is a reviewable change),\n     * and read by downstream policy (e.g. a partner-API surface refusing to expose `pii`/`secret`).\n     */\n    readonly classification?: DataClassification;\n    /**\n     * Inline **route-assurance evidence**: the enforcement posture this route carries, declared adjacent to\n     * the handler (e.g. `[NIFRA_ASSURANCE.AUTHENTICATED]`). Each id becomes route-scoped `declared` evidence\n     * in reflection, so a `nifra.assurance.ts` policy `require:` clause is satisfiable WITHOUT rewriting an\n     * in-handler guard into a `withRouteAssurance`-marked middleware. Ids are lowercase dot/dash segments\n     * (invalid ids throw at registration). Reflected for the assurance gate; never read on the hot path.\n     *\n     * This is an author ASSERTION (recorded as `source: \"declared\"`), not runtime proof - like every\n     * assurance marker it is trusted by the static gate, which matches on the evidence id, not its source.\n     * Declare an id only on a route whose guard actually enforces it; a false declaration silently satisfies\n     * the policy. (`source` is retained in reflection, so a stricter policy or reviewer can still tell\n     * declared evidence from enforcement-module evidence.)\n     */\n    readonly assurance?: readonly string[];\n    /**\n     * Mark this route a **dynamic route family**: a template (`/api/:slug/:resource`) whose concrete\n     * resources are resolved at runtime (auto-CRUD over tenant-defined tables, a catch-all dispatcher).\n     * Purely declarative - it does not change dispatch. It surfaces in reflection so the assurance gate and\n     * tooling treat the one templated route as a deliberate family whose evidence covers every runtime-\n     * resolved resource, instead of reading it as a single forgotten route.\n     */\n    readonly family?: boolean;\n    /** Optional **path-params schema**. Path params arrive as strings (`/users/:id` -> `c.params.id`);\n     * declaring a schema validates them at the boundary (a malformed `:id` is a `422` before the handler,\n     * like `body`/`query`) and can coerce them (use `t.query({ id: t.integer() })` for a numeric param).\n     * The schema must cover every path param; with the strict default an undeclared path param is rejected.\n     * When omitted, `c.params` stays the path-inferred `Record<name, string>`. */\n    readonly params?: StandardSchemaV1;\n    readonly body?: StandardSchemaV1;\n    readonly query?: StandardSchemaV1;\n    /** Optional **response contract**. When declared: the handler's return is type-checked against it\n     * (the implementation can't drift from the contract), the typed client sees THIS as the response type\n     * (the contract — not the handler's incidental return), and it's emitted into OpenAPI/JSON-Schema so\n     * tooling and coding agents can read the exact shape. It is **not** validated at runtime (zero\n     * hot-path cost) — purely a compile-time + introspection contract. */\n    readonly response?: StandardSchemaV1;\n    /**\n     * Optional **error-response contract**: a map of HTTP status code → the Standard Schema of that error's\n     * body. Declares a route's failure modes so they flow into OpenAPI (as non-2xx `responses`), the\n     * `/llms.txt` context, and other introspection — the whole contract, not just the happy path, is legible\n     * to tooling and coding agents. Like `response`, it is **not** validated at runtime (zero hot-path cost);\n     * it's a compile-time + introspection contract. Example: `{ 404: NotFound, 409: Conflict }`. */\n    readonly errors?: Readonly<Record<number, StandardSchemaV1>>;\n    /**\n     * Optional **SSE event contract**: the Standard Schema of each event's `data` payload on a\n     * streaming route (declared via `app.sse()`). Marks the route as a typed event stream — the\n     * typed client grows a `.subscribe()` for it, and the schema flows into reflection. Like\n     * `response`, it is **not** validated at runtime (zero hot-path cost); the server-side\n     * `stream.send()` is compile-time-checked against it instead.\n     */\n    readonly sse?: StandardSchemaV1;\n    /**\n     * Hook fired when the request fails `body`/`query` validation, before the handler runs. `kind` says\n     * which input failed (`\"body\"` | `\"query\"`). Its return value selects one of three outcomes (may be async):\n     *   - a **`Response`** → returned as-is, short-circuiting the route (custom error envelope, redirect, …).\n     *   - **any other value** → treated as a repaired payload and **re-validated once** against the same\n     *     schema. If it now passes, the handler runs with it; if it still fails, the original `422` stands.\n     *     Re-validation means a bad return can't bypass the schema — the trust boundary holds.\n     *   - **`undefined`** → give up; the original validation `422` is returned unchanged.\n     * A route hook **overrides** the app-wide default set via `server({ onValidationError })`; return\n     * `undefined` to fall through to the plain `422` even when an app default exists. Typical uses: a custom\n     * error envelope, coercing the input, or prompting an LLM to repair the payload (re-validated, so it can't\n     * bypass the schema).\n     */\n    readonly onValidationError?: (issues: ReadonlyArray<StandardIssue>, ctx: Context, kind: \"body\" | \"query\" | \"params\") => Response | unknown | Promise<Response | unknown>;\n}",
     "doc": "/** Per-route input schemas. Each is any Standard Schema (zod/valibot/arktype/…). */"
   },
   {
@@ -7543,13 +8053,6 @@
     "signature": "export declare function runCheck(cwd: string, opts?: {\n    readonly json?: boolean;\n    readonly lintsOnly?: boolean;\n}): Promise<boolean>;",
     "doc": "/** Run the full check; print a report (`--json` for machine output) and return whether it passed. */"
   },
-  {
-    "name": "runContractInvariants",
-    "kind": "function",
-    "package": "@nifrajs/core",
-    "signature": "export declare function runContractInvariants(app: ReflectableApp, options?: RunInvariantsOptions): Promise<InvariantReport>;",
-    "doc": "/**\n * @deprecated Use `runAdversarialContract` from `@nifrajs/testing`. The testing package is the\n * authoritative deep contract laboratory and powers CLI L4; this export remains for compatibility.\n */"
-  },
   {
     "name": "runDiff",
     "kind": "function",
@@ -7578,12 +8081,6 @@
     "signature": "export declare function runInitAgents(cwd: string, opts?: {\n    readonly json?: boolean;\n    readonly force?: boolean;\n}): Promise<boolean>;",
     "doc": "/**\n * CLI entry: run the retrofit at `cwd` and print the result. Returns `true` (the command always succeeds\n * unless a write throws — which propagates as a non-zero exit via the dispatcher's catch). `--json`\n * emits the structured result for agents/CI.\n */"
   },
-  {
-    "name": "RunInvariantsOptions",
-    "kind": "interface",
-    "package": "@nifrajs/core",
-    "signature": "export interface RunInvariantsOptions {\n    /** Deterministic seed for the fuzzer. Default 1. */\n    readonly seed?: number;\n    /** Valid-input cases per route. Default 8. */\n    readonly casesPerRoute?: number;\n    /** Invalid-input (mutated) cases per route with a body schema. Default 4. */\n    readonly invalidCasesPerRoute?: number;\n    /**\n     * Explicit isolated executor for dynamic cases. It must point at a disposable test app, sandbox,\n     * or transaction that is rolled back. The runner never calls `source.fetch()` implicitly: doing so\n     * could charge cards, send mail, or mutate production state merely by running a verification tool.\n     */\n    readonly executor?: InvariantExecutor;\n}"
-  },
   {
     "name": "runLevels",
     "kind": "function",
@@ -7617,7 +8114,7 @@
     "kind": "interface",
     "package": "@nifrajs/core",
     "signature": "export interface RunningServer {\n    readonly port: number;\n    readonly hostname: string;\n    readonly pendingRequests: number;\n    stop(closeActiveConnections?: boolean): void;\n}",
-    "doc": "/**\n * The handle `listen()` returns — the slice of Bun's server nifra holds and exposes.\n * Declared explicitly (rather than `ReturnType<typeof Bun.serve>`) so the public type\n * surface doesn't leak the ambient `Bun` global into consumers' `.d.ts` resolution.\n */"
+    "doc": "/**\n * The handle `listen()` returns - the slice of Bun's server nifra holds and exposes.\n * Declared explicitly (rather than `ReturnType<typeof Bun.serve>`) so the public type\n * surface doesn't leak the ambient `Bun` global into consumers' `.d.ts` resolution.\n */"
   },
   {
     "name": "RunOptions",
@@ -7671,6 +8168,13 @@
     "signature": "export declare function runSnapshot(cwd: string, options: {\n    out?: string;\n}): Promise<void>;",
     "doc": "/** `nifra snapshot`: write the current contract as the CI baseline. */"
   },
+  {
+    "name": "runSyncManifest",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function runSyncManifest(cwd: string): Promise<boolean>;",
+    "doc": "/** CLI entry: sync every generated manifest, print a per-file summary + the client-rebuild caveat. */"
+  },
   {
     "name": "runtimeAdapterCertificationProfile",
     "kind": "function",
@@ -7765,8 +8269,8 @@
     "name": "scanFetchText",
     "kind": "function",
     "package": "@nifrajs/cli",
-    "signature": "export declare function scanFetchText(file: string, content: string): SourceFinding[];",
-    "doc": "/** Scan one file's text for hand-rolled own-API `fetch()` calls. Pure + line-accurate. */"
+    "signature": "export declare function scanFetchText(file: string, content: string, externalMounts?: readonly string[]): SourceFinding[];",
+    "doc": "/** Scan one file's text for hand-rolled own-API `fetch()` calls. Pure + line-accurate. `externalMounts`\n * are intentional non-typed mount prefixes (from `nifra.check.json`, e.g. a mounted better-auth owning\n * `/auth/**`) - a relative fetch into one is deliberate, not drift, so it's skipped. A fetch with an\n * inline literal `x-nifra-data` header is Nifra's page-loader transport, not a backend API call, and is\n * skipped too. */"
   },
   {
     "name": "scanFileForFeatures",
@@ -7780,7 +8284,7 @@
     "kind": "function",
     "package": "@nifrajs/cli",
     "signature": "export declare function scanProject(cwd: string): Promise<SourceFinding[]>;",
-    "doc": "/** Collect own-API `fetch()` findings across the project (kept for back-compat + reuse). */"
+    "doc": "/** Collect own-API `fetch()` findings across the project. */"
   },
   {
     "name": "scanResponseRoutes",
@@ -8035,8 +8539,7 @@
     "name": "serve",
     "kind": "function",
     "package": "@nifrajs/node",
-    "signature": "export declare function serve(app: FetchHandler, options: ServeOptions): Promise<NodeServer>;",
-    "doc": "/**\n * Serve a Web-`fetch` app on a Node `http` server. Resolves once bound — Node binds\n * the port asynchronously, so awaiting gives you the real port (matters for `port: 0`).\n */"
+    "signature": "export declare function serve(app: FetchHandler, options: ServeOptions): Promise<NodeServer>;"
   },
   {
     "name": "serveDatabaseAsMcp",
@@ -8068,7 +8571,7 @@
     "name": "Server",
     "kind": "class",
     "package": "@nifrajs/core",
-    "signature": "export declare class Server<R extends Registry = EmptyRegistry, Ctx = EmptyContext> {\n    private readonly catalog;\n    /** WebSocket routes, matched separately at upgrade time (a GET + `Upgrade: websocket`). */\n    private readonly wsRouter;\n    private wsRouteCount;\n    /** In-process pub/sub backing `ws.subscribe(topic)` + `app.publish(topic, data)` (single-instance).\n     * Created by the first `app.ws()` via the `@nifrajs/core/ws` runtime — `undefined` until then, so a\n     * no-WebSocket app never constructs (or bundles) it. */\n    private topics;\n    private readonly maxBodyBytes;\n    private readonly wsMaxPayloadBytes;\n    private readonly requestTimeoutMs;\n    private readonly acceptInboundDeadlines;\n    private readonly maxInboundDeadlineMs;\n    private readonly deadlineAdmissionOptions;\n    private readonly gracefulSignals;\n    /** Capacity-admission gate; `undefined` = off (the request path pays nothing). */\n    private readonly capacityGate;\n    private readonly onCapabilityUse;\n    /** Effect-ledger defaults pinned at construction; per-route `ledgered` copies add route identity. */\n    private readonly effectLedger;\n    /** App-wide idempotency store (explicit option, else a lazily-created in-process default). */\n    private readonly configuredIdempotencyStore;\n    private lazyIdempotencyStore;\n    private readonly logger;\n    /** App-wide validation-error fallback; a route's own `schema.onValidationError` takes precedence. */\n    private readonly defaultOnValidationError?;\n    private bunServer;\n    private sealed;\n    private readonly derives;\n    private readonly decorations;\n    private readonly beforeHandleHooks;\n    private readonly afterHandleHooks;\n    private readonly onErrorHooks;\n    private readonly aroundHooks;\n    private readonly onRequestHooks;\n    private readonly onResponseHooks;\n    private readonly onResponseFinalizedHooks;\n    private readonly responseRequests;\n    /** Names of plugins/middleware already applied via `use` — for idempotent dedupe. */\n    private readonly appliedPlugins;\n    /** Order-scoped evidence captured by routes registered after an assured plugin. */\n    private readonly activeAssurance;\n    /** App-wide evidence from global hooks; applies retroactively to every route. */\n    private readonly globalAssurance;\n    /** App-declared MCP resources / prompts (via {@link resource} / {@link prompt}), read by `nifra mcp`. */\n    private readonly mcpResourceList;\n    private readonly mcpPromptList;\n    constructor(options?: ServerOptions);\n    private assertConfigurable;\n    /** Add a per-request, computed context extension for subsequent routes. */\n    derive<D extends object>(fn: (context: Context & Ctx) => MaybePromise<D>): Server<R, Ctx & D>;\n    /** Add a static context value for subsequent routes. */\n    decorate<const K extends string, V>(key: K, value: V): Server<R, Ctx & Record<K, V>>;\n    /**\n     * Run before routing on the raw request. Return a `Response` to short-circuit, or a replacement\n     * `Request` to continue routing with a rewritten method/URL/headers. Global.\n     */\n    onRequest(fn: (req: Request, platform?: Platform<EnvOf<Ctx>>) => MaybePromise<OnRequestResult>): this;\n    /** Run after validation, before the handler; a non-`undefined` return short-circuits. Order-scoped. */\n    beforeHandle(fn: (context: Context & Ctx) => MaybePromise<unknown>): this;\n    /**\n     * Wrap the matched route lifecycle for subsequent routes. This is intentionally generic over the\n     * route output, so wrappers like async context storage do not force Node's direct JSON path through\n     * a Web `Response`. The first registered wrapper is outermost.\n     */\n    around(fn: <T>(context: Context & Ctx, next: () => MaybePromise<T>) => MaybePromise<T>): this;\n    /** Transform the handler's result before it is serialized. Order-scoped. */\n    afterHandle(fn: (result: unknown, context: Context & Ctx) => MaybePromise<unknown>): this;\n    /** Handle a thrown error; a non-`undefined` return becomes the response (else the default 500). Order-scoped. */\n    onError(fn: (error: unknown, context: Context & Ctx) => MaybePromise<unknown>): this;\n    /** Transform every outgoing response — success, error, 404, 405, short-circuit. Global. */\n    onResponse(fn: (response: Response, req: Request) => MaybePromise<Response>): this;\n    /** Observe the terminal response after all transformations. Observers are ordered and fail-open. */\n    onResponseFinalized(fn: (outcome: ResponseFinalization, req: Request) => MaybePromise<void>): this;\n    /**\n     * Apply a type-**identity** plugin ({@link IdentityPlugin}, from {@link defineIdentityPlugin}) — it\n     * registers routes/hooks but doesn't change the types, so this returns `this` with the route registry\n     * and context fully intact. This overload exists specifically so a *named* identity plugin (e.g.\n     * `@nifrajs/better-auth`) threads the registry: its `& { pluginName }` intersection would otherwise\n     * defeat the generic inference of the transforming overload below and collapse the result to `any`.\n     */\n    use(plugin: IdentityPlugin): this;\n    /**\n     * Apply a **plugin function** — `(app) => app`, typically built with {@link definePlugin}. It's\n     * called with `this` and its result is returned, so an inline plugin's `derive`/`decorate` thread\n     * the added context to handlers defined after `use` (the overload is generic over the concrete\n     * `this`). A named plugin already applied is skipped (idempotent dedupe).\n     */\n    use<Out extends AnyServer>(plugin: (app: this) => Out): Out;\n    /**\n     * Apply a {@link Middleware} bundle — wire each hook it provides to its lifecycle point. Returns\n     * `this` (no context-type merging); call it before the routes its `beforeHandle`/`afterHandle`\n     * should cover (those are order-scoped; `onRequest`/`onResponse` are global). A named bundle already\n     * applied is skipped (idempotent).\n     */\n    use(mw: Middleware): this;\n    get<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    get<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    /**\n     * Register a **typed SSE route** — a GET endpoint streaming `text/event-stream` whose event\n     * payloads are contracted by `schema.sse`. The handler receives the validated context plus a\n     * {@link TypedSSEStream}: `stream.send(event)` is compile-time-checked against the schema and\n     * JSON-serialized into the SSE `data:` field. The typed client sees the marker and grows a\n     * `.subscribe(onEvent)` for the route with the same payload type — end-to-end typed streaming.\n     *\n     *   const app = server().sse(\"/feed\", { sse: t.object({ id: t.integer(), title: t.string() }) },\n     *     async (c, stream) => {\n     *       stream.send({ id: 1, title: \"hello\" })          // typed\n     *       await waitForDisconnect(stream.signal)\n     *     },\n     *     { keepAlive: 15_000 })\n     *\n     *   // client: const off = api.feed.subscribe((post) => console.log(post.title))\n     *\n     * `init` passes through to the underlying {@link sse} helper (`keepAlive`, extra headers). The\n     * connection closes when the handler resolves, `stream.close()` runs, or the client disconnects\n     * (`stream.signal`). Query/body schemas validate exactly as on any other route.\n     */\n    sse<Path extends string, S extends RouteSchema & {\n        sse: StandardSchemaV1;\n    }>(path: Path, schema: S, run: (context: Context<Path, S> & Ctx, stream: TypedSSEStream<InferOutput<S[\"sse\"]>>) => void | Promise<void>, init?: SSEInit): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, S, Response>>, Ctx>;\n    post<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"POST\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    post<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"POST\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    put<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"PUT\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    put<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"PUT\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    patch<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"PATCH\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    patch<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"PATCH\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    delete<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"DELETE\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    delete<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"DELETE\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    tool<Name extends string, S extends {\n        description: string;\n        input: StandardSchemaV1;\n        output?: StandardSchemaV1;\n        annotations?: ToolAnnotations;\n    }, H extends (input: InferOutput<S[\"input\"]>, ctx: Context & Ctx) => MaybePromise<S[\"output\"] extends StandardSchemaV1 ? InferOutput<S[\"output\"]> : unknown>>(name: Name, config: S, handler: H): Server<AddRoute<R, \"POST\", `/_nifra/tool/${Name}`, RouteInfoFor<`/_nifra/tool/${Name}`, S[\"output\"] extends StandardSchemaV1 ? {\n        body: S[\"input\"];\n        response: S[\"output\"];\n    } : {\n        body: S[\"input\"];\n    }, OutputOf<H>>>, Ctx>;\n    /**\n     * Declare an MCP **resource** — read-only data an agent can fetch through `nifra mcp` (app config, a\n     * generated document, …). `read` runs in the app process, so capture whatever app state it needs in the\n     * closure. `uri` is the MCP resource identifier (e.g. `\"myapp://config\"`). The sibling of {@link tool}\n     * for the resource half of MCP.\n     */\n    resource(uri: string, config: {\n        readonly name: string;\n        readonly description?: string;\n        readonly mimeType?: string;\n    }, read: McpResourceDescriptor[\"read\"]): Server<R, Ctx>;\n    /**\n     * Declare an MCP **prompt** — a reusable prompt template an agent can fetch through `nifra mcp`.\n     * `handler` receives the caller's arguments and returns the rendered messages.\n     */\n    prompt(name: string, config: {\n        readonly description: string;\n        readonly arguments?: readonly PromptArgument[];\n    }, handler: McpPromptDescriptor[\"handler\"]): Server<R, Ctx>;\n    /** The MCP resources declared via {@link resource} — enumerated by `nifra mcp`. */\n    mcpResources(): readonly McpResourceDescriptor[];\n    /** The MCP prompts declared via {@link prompt} — enumerated by `nifra mcp`. */\n    mcpPrompts(): readonly McpPromptDescriptor[];\n    /**\n     * Register a **WebSocket** route. The connection upgrades on a `GET` to `path` carrying\n     * `Upgrade: websocket`; the optional `handler.upgrade(c)` runs in the request context first and may\n     * reject (return a `Response`) or seed per-connection `ws.data`. WebSockets are served by the\n     * adapter (`listen()`, `@nifrajs/node`, `@nifrajs/deno`, `toFetchHandler`) — not by bare `app.fetch`, which\n     * has no socket (a WS path through `app.fetch` is a normal HTTP response).\n     *\n     *   app.ws(\"/chat\", { open: (ws) => ws.send(\"hi\"), message: (ws, data) => ws.send(data) })\n     */\n    ws<Data = unknown, Schema extends StandardSchemaV1 | undefined = undefined>(path: string, handler: WebSocketHandler<Data, EnvOf<Ctx>, Schema>): this;\n    /**\n     * Broadcast `data` to every WebSocket connection subscribed to `topic` (via `ws.subscribe(topic)`).\n     * In-process and **single-instance** (see {@link TopicRegistry}) — a multi-instance deploy must bridge\n     * an external fan-out (Redis, a Durable Object) to this. A no-op when nobody is subscribed.\n     */\n    publish(topic: string, data: string | ArrayBufferView | ArrayBuffer): void;\n    private route;\n    /**\n     * Low-level route registration shared by the inline builder and `implement()`.\n     * Captures the server's current `derive`/`decorate` chain into the route — this\n     * is the \"compiled\", order-scoped per-route chain.\n     */\n    register(method: Method, path: string, schema: RouteSchema | undefined, handler: (context: never) => unknown): void;\n    /** Register a contract/group route batch atomically. Every route captures the same current chain it\n     * would capture through {@link register}; no route becomes visible unless the full batch validates. */\n    registerBatch(routes: readonly {\n        readonly method: Method;\n        readonly path: string;\n        readonly schema: RouteSchema | undefined;\n        readonly handler: (context: never) => unknown;\n    }[]): void;\n    private prepareRoute;\n    /** Collapse route-invariant lifecycle decisions into one runner at registration. The request path\n     * performs no eligibility ladder: it supplies request state to this already-selected plan. */\n    private compileExecutionPlan;\n    /** Resolve a route's declared idempotency into a pinned store + defaults, or `undefined` when off. */\n    private resolveIdempotency;\n    /** The app-wide idempotency store: the configured one, else a lazily-created shared in-process store. */\n    private defaultIdempotencyStore;\n    /**\n     * Merge another server's routes into this one — the composition escape hatch for large apps.\n     *\n     * WHY: the fluent chain accumulates one type-alias level per route, and TypeScript resolves\n     * that stack in one recursion — a single chain hits TS2589 at ~95 routes. Groups keep every\n     * chain short: build each domain (`listings`, `agents`, …) as its own `server()` (its registry\n     * resolves independently), then `app.merge(listings).merge(agents)` — each merge adds ONE level\n     * regardless of group size. 300+ routes stay fully typed (see many-routes.test-d.ts). The\n     * other escape hatch is contract-first `implement()`, whose registry is a single object type.\n     *\n     * Semantics: merged routes keep the chains captured where they were DEFINED — the group's\n     * `derive`/`decorate`/`beforeHandle`/`afterHandle`/`onError`/`around` apply to its routes\n     * exactly as they did standalone, so a group wires its own plugins. The group's request-level\n     * hooks (`onRequest`/`onResponse`/`onResponseFinalized`) are appended to this server's. This\n     * server's route-scoped chains do NOT retroactively wrap merged routes (order-scoped, like\n     * routes registered before a `derive`). Fail closed: a path+method collision throws\n     * `RouteConfigError` at merge time, and a group with WebSocket routes is refused (register\n     * those on the parent).\n     */\n    merge<R2 extends Registry, Ctx2>(other: Server<R2, Ctx2>): Server<R & R2, Ctx>;\n    /** A fused renderer closes over runtime services to keep its seven-argument JSC fast path. Merging\n     * rebinds that closure once to the executing server; generic plans already receive the runtime. */\n    private bindFusedRuntime;\n    /**\n     * Enumerate the registered routes (method, path, input schemas), in registration\n     * order. Powers `toOpenAPI` and other introspection; the router trie itself no\n     * longer holds the original patterns.\n     */\n    routes(): ReadonlyArray<RouteDescriptor>;\n    /**\n     * Resolve a `Request` to a `Response` — the whole lifecycle, testable without a port. The\n     * optional `platform` carries edge inputs (`env`, `waitUntil`); edge adapters pass it, and\n     * Bun/Node/Deno omit it (then `c.env` is `undefined` and `c.waitUntil` runs fire-and-forget).\n     */\n    fetch(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<Response>;\n    private fetchSource;\n    private fetchSourceInner;\n    /** Web response path when Bun already matched the route. The lifecycle and response hooks remain\n     * exactly the same as {@link fetchSource}; only portable URL scanning + trie lookup are skipped. */\n    private fetchMatched;\n    private fetchMatchedInner;\n    /**\n     * Run `produce` under the capacity gate: admit → run → release exactly once when the response is\n     * produced (or the run throws). Only reached when {@link capacityGate} is set, so the off path pays\n     * nothing. The slot is held for the duration of handler execution, not the streaming of the body —\n     * capacity here bounds concurrent *work*, matching how in-flight is counted.\n     */\n    private admitGated;\n    private runAdmitted;\n    /**\n     * Like {@link fetch}, but renders a plain-data result **without** building a Web `Response` — the\n     * `@nifrajs/node` adapter serializes the returned primitives straight to the socket, skipping the undici\n     * `Response` build + body drain (the bulk of the Node bridge cost, measured ≈4µs/req). A handler that\n     * returns a `Response`, an error/short-circuit, or any registered `onResponse` hook falls back to the\n     * full Web path (`{ kind: \"response\" }`), so behavior is identical — only the common JSON-data case is\n     * faster. Same lifecycle as {@link fetch} (body cap, validation, hooks all run); only the final\n     * render differs.\n     */\n    resolveNode(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<NodeServeOutcome>;\n    resolveNodeSource(source: RequestSource, platform?: Platform<EnvOf<Ctx>>): MaybePromise<NodeServeOutcome>;\n    /**\n     * Resolve a WebSocket upgrade — the seam every serving adapter uses. Returns `pass` (not a WS\n     * upgrade for a registered route → handle as normal HTTP), `reject` (a WS route matched but\n     * `upgrade()` rejected, or the path was malformed → return `response`), or `upgrade` (perform the\n     * runtime upgrade, then dispatch the native socket's events to `handler`, seeding `ws.data` with\n     * `data`). Runs the route's `upgrade(c)` guard in a real request context. Synchronous unless\n     * `upgrade()` is async; a throw rejects with a flat 500 (no detail leaked).\n     */\n    resolveWebSocketUpgrade(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<WebSocketUpgradeOutcome>;\n    /** Bun `fetch` when WS routes exist: try a WS upgrade first, else run the normal HTTP lifecycle.\n     * `undefined` ⇒ Bun owns the upgraded socket; a `Response` ⇒ a normal reply or a rejected upgrade.\n     * (The socket dispatch itself lives in `ws-bun.ts`, loaded via `@nifrajs/core/ws`.) */\n    private bunFetchWithWebSocket;\n    /**\n     * The shared lifecycle, generic over how the final value is rendered: `finalize` turns a handler's\n     * result + `set` into the output `T` (`toResponse` → a Web `Response`; `toNodeOutcome` → node-direct\n     * primitives), `wrapResponse` lifts an early/error `Response` into that same `T`, and `onTimeout`\n     * produces the 503. The Web `fetch` and `resolveNode` are thin callers over this one routing +\n     * context + lifecycle implementation — no duplication across the trust boundary.\n     */\n    private dispatch;\n    /**\n     * onRequest short-circuit path. Synchronous as long as every hook returns synchronously (the\n     * common case — e.g. CORS returning `undefined` for a non-preflight request): an `async` version\n     * here put EVERY request of any app with one onRequest hook onto the promise machinery, profiled\n     * at ~13% of a realistic request. The first hook that returns a Promise hands the REMAINING\n     * hooks to the async continuation; behavior is identical.\n     */\n    private runWithOnRequest;\n    /** Async tail of {@link runWithOnRequest}: applies the first awaited hook's outcome, then runs\n     * the remaining hooks (awaiting freely — we're already async here). */\n    private continueOnRequest;\n    private takeResponseRequest;\n    /**\n     * Route → build context → run. Synchronous through to the handler for a **bare** route\n     * (selected by its compiled plan), so a sync handler produces its result with zero promise allocations;\n     * routes with validation/hooks keep the full async {@link runLifecycle}, unchanged.\n     */\n    private routeAndRun;\n    /** Run a route that has already been matched by the runtime or Nifra's portable router. */\n    private runMatched;\n    /**\n     * Idempotency dedupe lane. Reads the `Idempotency-Key`, fingerprints the request, and consults the\n     * store: a fresh key runs the handler (via {@link runMatchedLanes} with the body buffered) and stores\n     * the response; a repeat key replays it without re-running; a key reused with a different body or an\n     * in-flight duplicate is rejected. Every branch materializes a `Response`, then adapts to `T` via the\n     * caller's `wrapResponse`, so it works on the Web fetch path and the Node-native outcome path alike.\n     */\n    private runIdempotent;\n    /** Supply request-specific deadline state to the route's precompiled execution plan. */\n    private runMatchedLanes;\n    /**\n     * Seal a ledgered request and deliver the sealed ledger to the sink. An empty ledger (declared\n     * capabilities, none exercised) is not delivered — there is nothing to audit. This post-effect\n     * ledger is observational: transactional/durable audit belongs in\n     * the owned effect transaction, so a sink outage must not turn a successful effect into a retryable\n     * 500 that can duplicate it.\n     */\n    private settleEffectLedger;\n    /** The narrowest bare route: a syntactic `() => ...` handler cannot observe the context argument, so\n     * successful requests can skip allocating `RequestContext`. Errors still allocate one for logging. */\n    private runContextlessBare;\n    private contextlessBareError;\n    /**\n     * The synchronous fast path selected by a route's execution plan: apply static decorations, call the\n     * handler, render the result — **no `await`** unless the handler itself returns a promise. It mirrors\n     * the bare slice of {@link runLifecycle} (which a bare route would otherwise no-op through) and shares\n     * {@link logRequestError}; a bare route has no `onError` hooks, so error handling is fully synchronous\n     * (a thrown `Response` is control flow; anything else is a logged flat 500). This is where nifra skips\n     * the per-request async-frame tax — the same win codegen routers get, but without `eval`.\n     */\n    private runBare;\n    /** Bare-route error rendering — identical to {@link runLifecycle}'s catch minus the (absent) onError\n     * loop: a thrown `Response` is returned as deliberate control flow; anything else is logged + 500. */\n    /**\n     * Build a route's fused Web renderer. Composition happens once at\n     * registration; the returned closure is what every request to the route runs. Behavior is\n     * byte-identical to the generic `runBare`/`runContextlessBare` + `toResponse` pair — same\n     * decoration order, same error routing (thrown `Response` = control flow; anything else logs and\n     * 500s), same respond semantics (the lifecycle parity suite pins it).\n     */\n    private buildFusedWeb;\n    private bareError;\n    private runWithAround;\n    private runAround;\n    private runBodyOnly;\n    /** Validate + run the handler for the bodyOnly path — shared by the inline fast path and the\n     * streaming fallback. A method (not per-request closures) so the hot path allocates nothing\n     * beyond the one `.then` continuation. */\n    private finishBodyOnly;\n    private executeHandler;\n    private handleValidationErrorRecovery;\n    private applyBodyValidation;\n    private runQueryOnly;\n    /** Validate-result → set `ctx.query` → run handler. A method (not a per-request closure), the\n     * query analogue of {@link applyBodyValidation}. */\n    private applyQueryValidation;\n    /**\n     * Thread the response through each global `onResponse` hook. Stays SYNCHRONOUS until a hook\n     * actually returns a Promise — an `async` version forced a promise + microtask on EVERY response\n     * of any app with an onResponse hook (cors/securityHeaders/etag/timing all use onResponse), the\n     * same ~13%/req tax the onRequest walk was de-async'd to avoid. The first async hook hands the\n     * rest to {@link continueOnResponse}.\n     */\n    private applyOnResponse;\n    private applyOnResponseAndFinalize;\n    private completeResponseFinalization;\n    private failResponseFinalization;\n    /** Notify terminal observers in order while isolating both sync and async failures. */\n    private notifyResponseFinalized;\n    /** Async tail of {@link applyOnResponse}: runs the remaining hooks once one has gone async. */\n    private continueOnResponse;\n    /**\n     * Bound the response time. On timeout we abort `ctx.signal` (so cancellation-aware\n     * handlers can bail) and return 503; the in-flight work keeps running but its\n     * result is discarded — JS can't forcibly cancel a promise.\n     */\n    private withTimeout;\n    /**\n     * The post-match lifecycle: validate → derive → beforeHandle → handler → afterHandle, with onError.\n     * Generic over the render: a success value goes through `finalize(result, set)` (a Web `Response`, or\n     * node-direct primitives); an early/error `Response` (validation, thrown, 500) through `wrapResponse`.\n     */\n    private runLifecycle;\n    private handleLifecycleError;\n    /** Log an unhandled request error to the (redacting) logger — shared by {@link runLifecycle} and the\n     * bare fast path ({@link bareError}) so both record the same fields. Never throws; never leaks. */\n    private logRequestError;\n    private readAndValidateBody;\n    /** Apply validation and its recovery hook on the generic lifecycle lane. Recovery is completed\n     * before derives/beforeHandle run, matching the body-only and query-only execution lanes. */\n    private applyLifecycleValidation;\n    /**\n     * Read the body as text, capped at `maxBodyBytes`. Rejects (`null`) on a\n     * `Content-Length` over the cap *before* buffering, and aborts mid-stream once the\n     * running byte count exceeds it — so a lying or absent length can't force us to\n     * buffer an oversized payload.\n     *\n     * Fast path: when a non-chunked request carries a `Content-Length` within the cap,\n     * a native `req.json()` is already bounded — under HTTP/1.1 + HTTP/2 framing the\n     * runtime delivers at most `Content-Length` bytes — so we skip the manual stream\n     * loop and a separate text decode. It trusts the wire\n     * *framing*, not the header value: nifra only ever receives framed Requests from the\n     * runtime's HTTP server, never a hand-built one with a mismatched length. Chunked or\n     * length-less bodies fall through to the streaming byte-cap guard below.\n     */\n    private readBoundedJson;\n    /** Adapt one route's compiled execution plan to Bun's already-matched request shape. Route\n     * semantics remain in the plan; this closure only supplies native params and deadline fallback. */\n    private compileBunNativeHandler;\n    /** Compile portable route registrations into Bun's native route table. Apps with request-rewrite\n     * hooks or WebSockets retain the single portable dispatcher because those features must run before\n     * route selection/upgrade. Named wildcards also stay on the fallback until Bun exposes their raw\n     * capture semantics; static and `:param` routes take the native lane. */\n    private buildBunNativeRoutes;\n    /**\n     * Start a `Bun.serve` instance bound to `port` (use `0` for an ephemeral port).\n     *\n     * `reusePort` sets `SO_REUSEPORT` so **multiple processes can bind the same port** and the kernel\n     * load-balances connections across them — the standard way to use every core (Bun is\n     * single-threaded per process). Spawn one process per core, each calling\n     * `app.listen(PORT, { reusePort: true })`; see `examples/cluster.ts`. Every process must opt in,\n     * and all of them must be the same app. Linux balances ~evenly; macOS accepts the flag but may\n     * favor one socket (fine for dev, measure on Linux for production numbers).\n     *\n     * `hostname` is the bind address, defaulting to Bun's `0.0.0.0` (every interface). Pass\n     * `\"127.0.0.1\"` to bind loopback only - an admin surface, a sidecar, or anything that must not be\n     * reachable off the box. Omitting it when you meant to restrict is a real exposure, so it is a\n     * first-class option rather than something a caller has to drop down to `Bun.serve` for.\n     */\n    listen(port: number, options?: {\n        readonly reusePort?: boolean;\n        readonly hostname?: string;\n    }): RunningServer;\n    /**\n     * Gracefully stop: wait for in-flight requests to finish (up to `drainMs`), then\n     * issue a single terminal stop — graceful if everything drained, forced if\n     * stragglers remain. Safe to call when not listening.\n     *\n     * The Bun semantics: poll `pendingRequests` (awaiting\n     * `stop()`'s promise drops in-flight requests), and decide graceful-vs-forced in\n     * ONE call (Bun can't escalate an already-graceful `stop()` to a forced close).\n     * New connections may be accepted during the drain window; in a real deploy the\n     * load balancer has already stopped routing here, and `drainMs` bounds it.\n     */\n    stop({ drainMs }?: {\n        drainMs?: number;\n    }): Promise<void>;\n    private installSignalHandlers;\n}",
+    "signature": "export declare class Server<R extends Registry = EmptyRegistry, Ctx = EmptyContext> {\n    private readonly catalog;\n    /** WebSocket routes, matched separately at upgrade time (a GET + `Upgrade: websocket`). */\n    private readonly wsRouter;\n    private wsRouteCount;\n    /** In-process pub/sub backing `ws.subscribe(topic)` + `app.publish(topic, data)` (single-instance).\n     * Created by the first `app.ws()` via the `@nifrajs/core/ws` runtime — `undefined` until then, so a\n     * no-WebSocket app never constructs (or bundles) it. */\n    private topics;\n    private readonly maxBodyBytes;\n    private readonly wsMaxPayloadBytes;\n    private readonly requestTimeoutMs;\n    /** Opt-in caller-IP trust declaration; `undefined` = socket peer only, no forwarded header believed. */\n    private readonly clientIpTrust;\n    private readonly acceptInboundDeadlines;\n    private readonly maxInboundDeadlineMs;\n    private readonly deadlineAdmissionOptions;\n    private readonly gracefulSignals;\n    /** Capacity-admission gate; `undefined` = off (the request path pays nothing). */\n    private readonly capacityGate;\n    private readonly onCapabilityUse;\n    /** The installed effect-ledger runtime (owns the sink + per-route resolution + settle), or\n     * `undefined` when the effect-ledger plugin is not installed. */\n    private effectLedgerRuntime;\n    /** The installed idempotency runtime (owns the app-wide default store + the dedupe lane), or\n     * `undefined` when the idempotency plugin is not installed. */\n    private idempotencyRuntime;\n    /** Installed opt-in runtime for `.tool()`/`.resource()`/`.prompt()`; `undefined` until `.use(mcp())`. */\n    private mcpRuntime;\n    /** Installed Node-direct renderer for direct `resolveNode()` callers; `undefined` until `.use(nodeDirect())`. */\n    private nodeOutcomeRuntime;\n    /** Installed streaming runtime for `.sse()` routes; `undefined` until `.use(streaming())`. */\n    private sseRuntime;\n    /** Installed WebSocket runtime for `.ws()` routes; `undefined` until `.use(websocket())`. */\n    private wsRuntime;\n    private readonly logger;\n    /** App-wide validation-error fallback; a route's own `schema.onValidationError` takes precedence. */\n    private readonly defaultOnValidationError?;\n    private bunServer;\n    private sealed;\n    private readonly derives;\n    private readonly decorations;\n    private readonly beforeHandleHooks;\n    private readonly afterHandleHooks;\n    private readonly onErrorHooks;\n    private readonly aroundHooks;\n    private readonly onRequestHooks;\n    private readonly onResponseHooks;\n    private readonly onResponseFinalizedHooks;\n    private readonly responseRequests;\n    /** Names of plugins/middleware already applied via `use` — for idempotent dedupe. */\n    private readonly appliedPlugins;\n    /** Order-scoped evidence captured by routes registered after an assured plugin. */\n    private readonly activeAssurance;\n    /** App-wide evidence from global hooks; applies retroactively to every route. */\n    private readonly globalAssurance;\n    /** App-declared MCP resources / prompts (via {@link resource} / {@link prompt}), read by `nifra mcp`. */\n    private readonly mcpResourceList;\n    private readonly mcpPromptList;\n    constructor(options?: ServerOptions);\n    private assertConfigurable;\n    /** Add a per-request, computed context extension for subsequent routes. */\n    derive<D extends object>(fn: (context: Context & Ctx) => MaybePromise<D>): Server<R, Ctx & D>;\n    /** Add a static context value for subsequent routes. */\n    decorate<const K extends string, V>(key: K, value: V): Server<R, Ctx & Record<K, V>>;\n    /**\n     * Run before routing on the raw request. Return a `Response` to short-circuit, or a replacement\n     * `Request` to continue routing with a rewritten method/URL/headers. Global.\n     */\n    onRequest(fn: (req: Request, platform?: Platform<EnvOf<Ctx>>) => MaybePromise<OnRequestResult>): this;\n    /** Run after validation, before the handler; a non-`undefined` return short-circuits. Order-scoped. */\n    beforeHandle(fn: (context: Context & Ctx) => MaybePromise<unknown>): this;\n    /**\n     * Wrap the matched route lifecycle for subsequent routes. This is intentionally generic over the\n     * route output, so wrappers like async context storage do not force Node's direct JSON path through\n     * a Web `Response`. The first registered wrapper is outermost.\n     */\n    around(fn: <T>(context: Context & Ctx, next: () => MaybePromise<T>) => MaybePromise<T>): this;\n    /** Transform the handler's result before it is serialized. Order-scoped. */\n    afterHandle(fn: (result: unknown, context: Context & Ctx) => MaybePromise<unknown>): this;\n    /** Handle a thrown error; a non-`undefined` return becomes the response (else the default 500). Order-scoped. */\n    onError(fn: (error: unknown, context: Context & Ctx) => MaybePromise<unknown>): this;\n    /** Transform every outgoing response — success, error, 404, 405, short-circuit. Global. */\n    onResponse(fn: (response: Response, req: Request) => MaybePromise<Response>): this;\n    /** Observe the terminal response after all transformations. Observers are ordered and fail-open. */\n    onResponseFinalized(fn: (outcome: ResponseFinalization, req: Request) => MaybePromise<void>): this;\n    /**\n     * Apply a type-**identity** plugin ({@link IdentityPlugin}, from {@link defineIdentityPlugin}) — it\n     * registers routes/hooks but doesn't change the types, so this returns `this` with the route registry\n     * and context fully intact. This overload exists specifically so a *named* identity plugin (e.g.\n     * `@nifrajs/better-auth`) threads the registry: its `& { pluginName }` intersection would otherwise\n     * defeat the generic inference of the transforming overload below and collapse the result to `any`.\n     */\n    use(plugin: IdentityPlugin): this;\n    /**\n     * Apply a **plugin function** — `(app) => app`, typically built with {@link definePlugin}. It's\n     * called with `this` and its result is returned, so an inline plugin's `derive`/`decorate` thread\n     * the added context to handlers defined after `use` (the overload is generic over the concrete\n     * `this`). A named plugin already applied is skipped (idempotent dedupe).\n     */\n    use<Out extends AnyServer>(plugin: (app: this) => Out): Out;\n    /**\n     * Apply a {@link Middleware} bundle — wire each hook it provides to its lifecycle point. Returns\n     * `this` (no context-type merging); call it before the routes its `beforeHandle`/`afterHandle`\n     * should cover (those are order-scoped; `onRequest`/`onResponse` are global). A named bundle already\n     * applied is skipped (idempotent).\n     */\n    use(mw: Middleware): this;\n    get<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    get<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    /**\n     * Register a **typed SSE route** — a GET endpoint streaming `text/event-stream` whose event\n     * payloads are contracted by `schema.sse`. The handler receives the validated context plus a\n     * {@link TypedSSEStream}: `stream.send(event)` is compile-time-checked against the schema and\n     * JSON-serialized into the SSE `data:` field. The typed client sees the marker and grows a\n     * `.subscribe(onEvent)` for the route with the same payload type — end-to-end typed streaming.\n     *\n     *   import { streaming } from \"@nifrajs/core/sse\"   // .use(streaming()) enables .sse()\n     *   const app = server().use(streaming()).sse(\"/feed\", { sse: t.object({ id: t.integer(), title: t.string() }) },\n     *     async (c, stream) => {\n     *       stream.send({ id: 1, title: \"hello\" })          // typed\n     *       await waitForDisconnect(stream.signal)\n     *     },\n     *     { keepAlive: 15_000 })\n     *\n     *   // client: const off = api.feed.subscribe((post) => console.log(post.title))\n     *\n     * `init` passes through to the underlying {@link sse} helper (`keepAlive`, extra headers). The\n     * connection closes when the handler resolves, `stream.close()` runs, or the client disconnects\n     * (`stream.signal`). Query/body schemas validate exactly as on any other route.\n     */\n    sse<Path extends string, S extends RouteSchema & {\n        sse: StandardSchemaV1;\n    }>(path: Path, schema: S, run: (context: Context<Path, S> & Ctx, stream: TypedSSEStream<InferOutput<S[\"sse\"]>>) => void | Promise<void>, init?: SSEInit): Server<AddRoute<R, \"GET\", Path, RouteInfoFor<Path, S, Response>>, Ctx>;\n    post<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"POST\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    post<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"POST\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    put<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"PUT\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    put<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"PUT\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    patch<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"PATCH\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    patch<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"PATCH\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    delete<Path extends string, S extends RouteSchema, H extends Handler<Path, S, Ctx>>(path: Path, schema: S, handler: H): Server<AddRoute<R, \"DELETE\", Path, RouteInfoFor<Path, S, OutputOf<H>>>, Ctx>;\n    delete<Path extends string, H extends Handler<Path, RouteSchema, Ctx>>(path: Path, handler: H): Server<AddRoute<R, \"DELETE\", Path, RouteInfoFor<Path, Record<never, never>, OutputOf<H>>>, Ctx>;\n    /**\n     * Declare an **MCP tool** an agent can call (via `nifra mcp`, or a mounted MCP endpoint): a typed\n     * `POST /_nifra/tool/<name>` route whose `input`/`output` schemas contract the call and surface in\n     * `tools/list`. Requires `.use(mcp())` - without it, `.tool()` is a registration error, so an\n     * ordinary HTTP app never bundles the MCP wiring. Siblings: {@link resource}, {@link prompt}.\n     *\n     *   import { mcp } from \"@nifrajs/core/mcp\"\n     *   const app = server().use(mcp()).tool(\n     *     \"search\",\n     *     { description: \"Search posts\", input: t.object({ q: t.string() }) },\n     *     ({ q }) => findPosts(q),\n     *   )\n     */\n    tool<Name extends string, S extends {\n        description: string;\n        input: StandardSchemaV1;\n        output?: StandardSchemaV1;\n        annotations?: ToolAnnotations;\n    }, H extends (input: InferOutput<S[\"input\"]>, ctx: Context & Ctx) => MaybePromise<S[\"output\"] extends StandardSchemaV1 ? InferOutput<S[\"output\"]> : unknown>>(name: Name, config: S, handler: H): Server<AddRoute<R, \"POST\", `/_nifra/tool/${Name}`, RouteInfoFor<`/_nifra/tool/${Name}`, S[\"output\"] extends StandardSchemaV1 ? {\n        body: S[\"input\"];\n        response: S[\"output\"];\n    } : {\n        body: S[\"input\"];\n    }, OutputOf<H>>>, Ctx>;\n    /**\n     * Declare an MCP **resource** — read-only data an agent can fetch through `nifra mcp` (app config, a\n     * generated document, …). `read` runs in the app process, so capture whatever app state it needs in the\n     * closure. `uri` is the MCP resource identifier (e.g. `\"myapp://config\"`). The sibling of {@link tool}\n     * for the resource half of MCP.\n     */\n    resource(uri: string, config: {\n        readonly name: string;\n        readonly description?: string;\n        readonly mimeType?: string;\n    }, read: McpResourceDescriptor[\"read\"]): Server<R, Ctx>;\n    /**\n     * Declare an MCP **prompt** — a reusable prompt template an agent can fetch through `nifra mcp`.\n     * `handler` receives the caller's arguments and returns the rendered messages.\n     */\n    prompt(name: string, config: {\n        readonly description: string;\n        readonly arguments?: readonly PromptArgument[];\n    }, handler: McpPromptDescriptor[\"handler\"]): Server<R, Ctx>;\n    /** The MCP resources declared via {@link resource} — enumerated by `nifra mcp`. */\n    mcpResources(): readonly McpResourceDescriptor[];\n    /** The MCP prompts declared via {@link prompt} — enumerated by `nifra mcp`. */\n    mcpPrompts(): readonly McpPromptDescriptor[];\n    /**\n     * Register a **WebSocket** route. The connection upgrades on a `GET` to `path` carrying\n     * `Upgrade: websocket`; the optional `handler.upgrade(c)` runs in the request context first and may\n     * reject (return a `Response`) or seed per-connection `ws.data`. WebSockets are served by the\n     * adapter (`listen()`, `@nifrajs/node`, `@nifrajs/deno`, `toFetchHandler`) — not by bare `app.fetch`, which\n     * has no socket (a WS path through `app.fetch` is a normal HTTP response).\n     *\n     * The route also enters the type-level registry (under the pseudo-method `\"WS\"`), so the typed\n     * client grows a `.ws()` handle for it: `messageSchema` types what the client may `send`,\n     * `sendSchema` types the frames it receives. Passing explicit type arguments (`ws<MyData>(…)`)\n     * defeats path-literal inference and skips the registry entry - the route still serves, it is just\n     * invisible to `client<App>`; prefer typing `data` via `upgrade()`'s return.\n     *\n     *   app.ws(\"/chat\", { open: (ws) => ws.send(\"hi\"), message: (ws, data) => ws.send(data) })\n     */\n    ws<Data = unknown, Schema extends StandardSchemaV1 | undefined = undefined, Send extends StandardSchemaV1 | undefined = undefined, Path extends string = string>(path: Path, handler: WebSocketHandler<Data, EnvOf<Ctx>, Schema, Send>): string extends Path ? Server<R, Ctx> : Server<AddRoute<R, \"WS\", Path, WsRouteInfoFor<Path, Schema, Send>>, Ctx>;\n    /**\n     * Broadcast `data` to every WebSocket connection subscribed to `topic` (via `ws.subscribe(topic)`).\n     * In-process and **single-instance** (see {@link TopicRegistry}) — a multi-instance deploy must bridge\n     * an external fan-out (Redis, a Durable Object) to this. A no-op when nobody is subscribed.\n     */\n    publish(topic: string, data: string | ArrayBufferView | ArrayBuffer): void;\n    private route;\n    /**\n     * Low-level route registration shared by the inline builder and `implement()`.\n     * Captures the server's current `derive`/`decorate` chain into the route — this\n     * is the \"compiled\", order-scoped per-route chain.\n     */\n    register(method: Method, path: string, schema: RouteSchema | undefined, handler: (context: never) => unknown): void;\n    /** Register a contract/group route batch atomically. Every route captures the same current chain it\n     * would capture through {@link register}; no route becomes visible unless the full batch validates. */\n    registerBatch(routes: readonly {\n        readonly method: Method;\n        readonly path: string;\n        readonly schema: RouteSchema | undefined;\n        readonly handler: (context: never) => unknown;\n    }[]): void;\n    private prepareRoute;\n    /** Collapse route-invariant lifecycle decisions into one runner at registration. The request path\n     * performs no eligibility ladder: it supplies request state to this already-selected plan. */\n    private compileExecutionPlan;\n    /** The idempotency lane's bridge back into the normal matched lanes, resolved to a concrete Response\n     * (the lane buffers the body, then replays it through the route's real validation + handler). */\n    private idempotencyRunLanes;\n    /** @internal Symbol-keyed install seam for the `idempotency()` plugin. Off the public typed surface. */\n    [INSTALL_IDEMPOTENCY](runtime: IdempotencyRuntime): void;\n    /** @internal Symbol-keyed install seam for the `mcp()` plugin. Off the public typed surface. */\n    [INSTALL_MCP](runtime: McpRuntime): void;\n    /** @internal Symbol-keyed install seam for the `nodeDirect()` plugin. Off the public typed surface. */\n    [INSTALL_NODE_DIRECT](runtime: NodeOutcomeRuntime): void;\n    /** @internal Symbol-keyed install seam for the `streaming()` plugin. Off the public typed surface. */\n    [INSTALL_SSE](runtime: SseRuntime): void;\n    /** @internal Symbol-keyed install seam for the `websocket()` plugin. Off the public typed surface. */\n    [INSTALL_WS](runtime: WsRuntime): void;\n    /**\n     * Merge another server's routes into this one — the composition escape hatch for large apps.\n     *\n     * WHY: the fluent chain accumulates one type-alias level per route, and TypeScript resolves\n     * that stack in one recursion — a single chain hits TS2589 at ~95 routes. Groups keep every\n     * chain short: build each domain (`listings`, `agents`, …) as its own `server()` (its registry\n     * resolves independently), then `app.merge(listings).merge(agents)` — each merge adds ONE level\n     * regardless of group size. 300+ routes stay fully typed (see many-routes.test-d.ts). The\n     * other escape hatch is contract-first `implement()`, whose registry is a single object type.\n     *\n     * Semantics: merged routes keep the chains captured where they were DEFINED — the group's\n     * `derive`/`decorate`/`beforeHandle`/`afterHandle`/`onError`/`around` apply to its routes\n     * exactly as they did standalone, so a group wires its own plugins. The group's request-level\n     * hooks (`onRequest`/`onResponse`/`onResponseFinalized`) are appended to this server's. This\n     * server's route-scoped chains do NOT retroactively wrap merged routes (order-scoped, like\n     * routes registered before a `derive`). Fail closed: a path+method collision throws\n     * `RouteConfigError` at merge time, and a group with WebSocket routes is refused (register\n     * those on the parent).\n     */\n    merge<R2 extends Registry, Ctx2>(other: Server<R2, Ctx2>): Server<R & R2, Ctx>;\n    /** A fused renderer closes over runtime services to keep its seven-argument JSC fast path. Merging\n     * rebinds that closure once to the executing server; generic plans already receive the runtime. */\n    private bindFusedRuntime;\n    /**\n     * Enumerate the registered routes (method, path, input schemas), in registration\n     * order. Powers `toOpenAPI` and other introspection; the router trie itself no\n     * longer holds the original patterns.\n     */\n    routes(): ReadonlyArray<RouteDescriptor>;\n    /**\n     * Resolve a `Request` to a `Response` — the whole lifecycle, testable without a port. The\n     * optional `platform` carries edge inputs (`env`, `waitUntil`); edge adapters pass it, and\n     * Bun/Node/Deno omit it (then `c.env` is `undefined` and `c.waitUntil` runs fire-and-forget).\n     */\n    fetch(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<Response>;\n    private fetchSource;\n    private fetchSourceInner;\n    /** Web response path when Bun already matched the route. The lifecycle and response hooks remain\n     * exactly the same as {@link fetchSource}; only portable URL scanning + trie lookup are skipped. */\n    private fetchMatched;\n    private fetchMatchedInner;\n    /**\n     * Run `produce` under the capacity gate: admit → run → release exactly once when the response is\n     * produced (or the run throws). Only reached when {@link capacityGate} is set, so the off path pays\n     * nothing. The slot is held for the duration of handler execution, not the streaming of the body —\n     * capacity here bounds concurrent *work*, matching how in-flight is counted.\n     */\n    private admitGated;\n    private runAdmitted;\n    /**\n     * Like {@link fetch}, but renders a plain-data result **without** building a Web `Response` — the\n     * `@nifrajs/node` adapter serializes the returned primitives straight to the socket, skipping the undici\n     * `Response` build + body drain (the bulk of the Node bridge cost, measured ≈4µs/req). A handler that\n     * returns a `Response`, an error/short-circuit, or any registered `onResponse` hook falls back to the\n     * full Web path (`{ kind: \"response\" }`), so behavior is identical — only the common JSON-data case is\n     * faster. Same lifecycle as {@link fetch} (body cap, validation, hooks all run); only the final\n     * render differs.\n     */\n    resolveNode(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<NodeServeOutcome>;\n    resolveNodeSource(source: RequestSource, platform?: Platform<EnvOf<Ctx>>, suppliedRuntime?: NodeOutcomeRuntime): MaybePromise<NodeServeOutcome>;\n    /**\n     * Resolve a WebSocket upgrade — the seam every serving adapter uses. Returns `pass` (not a WS\n     * upgrade for a registered route → handle as normal HTTP), `reject` (a WS route matched but\n     * `upgrade()` rejected, or the path was malformed → return `response`), or `upgrade` (perform the\n     * runtime upgrade, then dispatch the native socket's events to `handler`, seeding `ws.data` with\n     * `data`). Runs the route's `upgrade(c)` guard in a real request context. Synchronous unless\n     * `upgrade()` is async; a throw rejects with a flat 500 (no detail leaked).\n     */\n    resolveWebSocketUpgrade(req: Request, platform?: Platform<EnvOf<Ctx>>): MaybePromise<WebSocketUpgradeOutcome>;\n    /** Bun `fetch` when WS routes exist: try a WS upgrade first, else run the normal HTTP lifecycle.\n     * `undefined` ⇒ Bun owns the upgraded socket; a `Response` ⇒ a normal reply or a rejected upgrade.\n     * (The socket dispatch itself lives in `ws-bun.ts`, loaded via `@nifrajs/core/ws`.) */\n    private bunFetchWithWebSocket;\n    /**\n     * The shared lifecycle, generic over how the final value is rendered: `finalize` turns a handler's\n     * result + `set` into the output `T` (`toResponse` → a Web `Response`; `toNodeOutcome` → node-direct\n     * primitives), `wrapResponse` lifts an early/error `Response` into that same `T`, and `onTimeout`\n     * produces the 503. The Web `fetch` and `resolveNode` are thin callers over this one routing +\n     * context + lifecycle implementation — no duplication across the trust boundary.\n     */\n    /** Apply the `clientIp` trust declaration to the adapter's raw socket peer, returning a platform\n     * whose `clientIp` is the derived caller. Only called when a trust declaration is configured. */\n    private deriveClientIp;\n    private dispatch;\n    /**\n     * onRequest short-circuit path. Synchronous as long as every hook returns synchronously (the\n     * common case — e.g. CORS returning `undefined` for a non-preflight request): an `async` version\n     * here put EVERY request of any app with one onRequest hook onto the promise machinery, profiled\n     * at ~13% of a realistic request. The first hook that returns a Promise hands the REMAINING\n     * hooks to the async continuation; behavior is identical.\n     */\n    private runWithOnRequest;\n    /** Async tail of {@link runWithOnRequest}: applies the first awaited hook's outcome, then runs\n     * the remaining hooks (awaiting freely — we're already async here). */\n    private continueOnRequest;\n    private takeResponseRequest;\n    /**\n     * Route → build context → run. Synchronous through to the handler for a **bare** route\n     * (selected by its compiled plan), so a sync handler produces its result with zero promise allocations;\n     * routes with validation/hooks keep the full async {@link runLifecycle}, unchanged.\n     */\n    private routeAndRun;\n    /** Run a route that has already been matched by the runtime or Nifra's portable router. */\n    private runMatched;\n    /** Supply request-specific deadline state to the route's precompiled execution plan. */\n    private runMatchedLanes;\n    /** @internal Symbol-keyed install seam for the `effectLedger()` plugin. Off the public typed surface. */\n    [INSTALL_EFFECT_LEDGER](runtime: EffectLedgerRuntime): void;\n    /** The narrowest bare route: a syntactic `() => ...` handler cannot observe the context argument, so\n     * successful requests can skip allocating `RequestContext`. Errors still allocate one for logging. */\n    private runContextlessBare;\n    private contextlessBareError;\n    /**\n     * The synchronous fast path selected by a route's execution plan: apply static decorations, call the\n     * handler, render the result — **no `await`** unless the handler itself returns a promise. It mirrors\n     * the bare slice of {@link runLifecycle} (which a bare route would otherwise no-op through) and shares\n     * {@link logRequestError}; a bare route has no `onError` hooks, so error handling is fully synchronous\n     * (a thrown `Response` is control flow; anything else is a logged flat 500). This is where nifra skips\n     * the per-request async-frame tax — the same win codegen routers get, but without `eval`.\n     */\n    private runBare;\n    /** Bare-route error rendering — identical to {@link runLifecycle}'s catch minus the (absent) onError\n     * loop: a thrown `Response` is returned as deliberate control flow; anything else is logged + 500. */\n    /**\n     * Build a route's fused Web renderer. Composition happens once at\n     * registration; the returned closure is what every request to the route runs. Behavior is\n     * byte-identical to the generic `runBare`/`runContextlessBare` + `toResponse` pair — same\n     * decoration order, same error routing (thrown `Response` = control flow; anything else logs and\n     * 500s), same respond semantics (the lifecycle parity suite pins it).\n     */\n    private buildFusedWeb;\n    private bareError;\n    private runWithAround;\n    private runAround;\n    private runBodyOnly;\n    /** Validate + run the handler for the bodyOnly path — shared by the inline fast path and the\n     * streaming fallback. A method (not per-request closures) so the hot path allocates nothing\n     * beyond the one `.then` continuation. */\n    private finishBodyOnly;\n    private executeHandler;\n    private handleValidationErrorRecovery;\n    private applyBodyValidation;\n    private runQueryOnly;\n    /** Validate-result → set `ctx.query` → run handler. A method (not a per-request closure), the\n     * query analogue of {@link applyBodyValidation}. */\n    private applyQueryValidation;\n    /**\n     * Thread the response through each global `onResponse` hook. Stays SYNCHRONOUS until a hook\n     * actually returns a Promise — an `async` version forced a promise + microtask on EVERY response\n     * of any app with an onResponse hook (cors/securityHeaders/etag/timing all use onResponse), the\n     * same ~13%/req tax the onRequest walk was de-async'd to avoid. The first async hook hands the\n     * rest to {@link continueOnResponse}.\n     */\n    private applyOnResponse;\n    private applyOnResponseAndFinalize;\n    private completeResponseFinalization;\n    private failResponseFinalization;\n    /** Notify terminal observers in order while isolating both sync and async failures. */\n    private notifyResponseFinalized;\n    /** Async tail of {@link applyOnResponse}: runs the remaining hooks once one has gone async. */\n    private continueOnResponse;\n    /**\n     * Bound the response time. On timeout we abort `ctx.signal` (so cancellation-aware\n     * handlers can bail) and return 503; the in-flight work keeps running but its\n     * result is discarded — JS can't forcibly cancel a promise.\n     */\n    private withTimeout;\n    /**\n     * The post-match lifecycle: validate → derive → beforeHandle → handler → afterHandle, with onError.\n     * Generic over the render: a success value goes through `finalize(result, set)` (a Web `Response`, or\n     * node-direct primitives); an early/error `Response` (validation, thrown, 500) through `wrapResponse`.\n     */\n    private runLifecycle;\n    private handleLifecycleError;\n    /** Log an unhandled request error to the (redacting) logger — shared by {@link runLifecycle} and the\n     * bare fast path ({@link bareError}) so both record the same fields. Never throws; never leaks. */\n    private logRequestError;\n    private readAndValidateBody;\n    /** Apply validation and its recovery hook on the generic lifecycle lane. Recovery is completed\n     * before derives/beforeHandle run, matching the body-only and query-only execution lanes. */\n    private applyLifecycleValidation;\n    /**\n     * Read the body as text, capped at `maxBodyBytes`. Rejects (`null`) on a\n     * `Content-Length` over the cap *before* buffering, and aborts mid-stream once the\n     * running byte count exceeds it — so a lying or absent length can't force us to\n     * buffer an oversized payload.\n     *\n     * Fast path: when a non-chunked request carries a `Content-Length` within the cap,\n     * a native `req.json()` is already bounded — under HTTP/1.1 + HTTP/2 framing the\n     * runtime delivers at most `Content-Length` bytes — so we skip the manual stream\n     * loop and a separate text decode. It trusts the wire\n     * *framing*, not the header value: nifra only ever receives framed Requests from the\n     * runtime's HTTP server, never a hand-built one with a mismatched length. Chunked or\n     * length-less bodies fall through to the streaming byte-cap guard below.\n     */\n    private readBoundedJson;\n    /** Adapt one route's compiled execution plan to Bun's already-matched request shape. Route\n     * semantics remain in the plan; this closure only supplies native params and deadline fallback. */\n    private compileBunNativeHandler;\n    /** Compile portable route registrations into Bun's native route table. Apps with request-rewrite\n     * hooks or WebSockets retain the single portable dispatcher because those features must run before\n     * route selection/upgrade. Named wildcards also stay on the fallback until Bun exposes their raw\n     * capture semantics; static and `:param` routes take the native lane. */\n    private buildBunNativeRoutes;\n    /**\n     * Start a `Bun.serve` instance bound to `port` (use `0` for an ephemeral port).\n     *\n     * `reusePort` sets `SO_REUSEPORT` so **multiple processes can bind the same port** and the kernel\n     * load-balances connections across them — the standard way to use every core (Bun is\n     * single-threaded per process). Spawn one process per core, each calling\n     * `app.listen(PORT, { reusePort: true })`; see `examples/cluster.ts`. Every process must opt in,\n     * and all of them must be the same app. Linux balances ~evenly; macOS accepts the flag but may\n     * favor one socket (fine for dev, measure on Linux for production numbers).\n     *\n     * `hostname` is the bind address, defaulting to Bun's `0.0.0.0` (every interface). Pass\n     * `\"127.0.0.1\"` to bind loopback only - an admin surface, a sidecar, or anything that must not be\n     * reachable off the box. Omitting it when you meant to restrict is a real exposure, so it is a\n     * first-class option rather than something a caller has to drop down to `Bun.serve` for.\n     */\n    listen(port: number, options?: {\n        readonly reusePort?: boolean;\n        readonly hostname?: string;\n    }): RunningServer;\n    /**\n     * Gracefully stop: wait for in-flight requests to finish (up to `drainMs`), then\n     * issue a single terminal stop — graceful if everything drained, forced if\n     * stragglers remain. Safe to call when not listening.\n     *\n     * The Bun semantics: poll `pendingRequests` (awaiting\n     * `stop()`'s promise drops in-flight requests), and decide graceful-vs-forced in\n     * ONE call (Bun can't escalate an already-graceful `stop()` to a forced close).\n     * New connections may be accepted during the drain window; in a real deploy the\n     * load balancer has already stopped routing here, and `drainMs` bounds it.\n     */\n    stop({ drainMs }?: {\n        drainMs?: number;\n    }): Promise<void>;\n    private installSignalHandlers;\n}",
     "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 */"
   },
   {
@@ -8116,7 +8619,7 @@
     "name": "ServerOptions",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface ServerOptions {\n    /**\n     * Max request body size (bytes), enforced **only when a route declares a body schema** — the cap\n     * lives in the schema-validated read path. Default 1_000_000.\n     *\n     * A route WITHOUT a body schema (raw body, file upload, BYO-validation) that reads `c.req` directly\n     * is not auto-bounded — use **`c.boundedBody(maxBytes?)`** / **`c.boundedJson(maxBytes?)`**, which\n     * apply this same cap (override per route by passing `maxBytes` — larger for an upload endpoint,\n     * smaller to tighten one).\n     */\n    readonly maxBodyBytes?: number;\n    /** Max inbound WebSocket message size (bytes) when `listen()`ing on Bun — frames over this are rejected\n     * by the runtime before reaching your handler (so a huge frame can't be JSON-parsed into memory).\n     * Default: `maxBodyBytes` (1 MB). */\n    readonly wsMaxPayloadBytes?: number;\n    /** Per-request timeout (ms): a slower request gets a 503 and `ctx.signal` aborts. 0 disables (default). */\n    readonly requestTimeoutMs?: number;\n    /**\n     * 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    /**\n     * Enable the per-request effect ledger. Each route that declares `schema.capabilities` gets a\n     * bounded, token-only ledger; `useCapability(c, id, …)` appends one entry per effect, and the sink\n     * receives the sealed ledger when the response settles (only when it recorded entries). Token-only\n     * by construction — capability ids, phases, counters, digests; never payloads, values, or the\n     * concrete URL (the route *pattern* is recorded). Enabling it moves capability-declaring routes off\n     * the fused fast path (they need a per-request context + a settle step); all other routes are\n     * unaffected, and when unset the request path pays nothing.\n     */\n    readonly effectLedger?: EffectLedgerOptions;\n    /**\n     * Default store backing routes that declare `schema.idempotency` without their own `store`. Defaults\n     * to a shared in-process {@link MemoryIdempotencyStore} (created lazily on first idempotent route).\n     * Inject a durable store here to make request-scoped dedupe survive restarts app-wide.\n     */\n    readonly idempotencyStore?: IdempotencyStore;\n    /** Structured logger for framework events (redacts secrets). Default: JSON to stderr. */\n    readonly logger?: Logger;\n    /**\n     * App-wide fallback fired when a route **without its own `onValidationError`** fails body/query\n     * validation. Same contract as the per-route hook (`(issues, ctx, kind) => Response | repaired-value |\n     * undefined`): a route's own hook takes precedence, and a route can fall through to the plain `422` by\n     * returning `undefined`. Use it for one app-wide error envelope (like tRPC's `errorFormatter` /\n     * Fastify's `setErrorHandler`) instead of repeating a formatter per route.\n     */\n    readonly onValidationError?: RouteSchema[\"onValidationError\"];\n}"
+    "signature": "export interface ServerOptions {\n    /**\n     * Max request body size (bytes), enforced **only when a route declares a body schema** - the cap\n     * lives in the schema-validated read path. Default 1_000_000.\n     *\n     * A route WITHOUT a body schema (raw body, file upload, BYO-validation) that reads `c.req` directly\n     * is not auto-bounded - use **`c.boundedBody(maxBytes?)`** / **`c.boundedJson(maxBytes?)`**, which\n     * apply this same cap (override per route by passing `maxBytes` - larger for an upload endpoint,\n     * smaller to tighten one).\n     */\n    readonly maxBodyBytes?: number;\n    /** Max inbound WebSocket message size (bytes) when `listen()`ing on Bun - frames over this are rejected\n     * by the runtime before reaching your handler (so a huge frame can't be JSON-parsed into memory).\n     * Default: `maxBodyBytes` (1 MB). */\n    readonly wsMaxPayloadBytes?: number;\n    /** Per-request timeout (ms): a slower request gets a 503 and `ctx.signal` aborts. 0 disables (default). */\n    readonly requestTimeoutMs?: number;\n    /**\n     * How to derive `c.clientIp` behind a reverse proxy or CDN. Omit (default) to trust only the raw\n     * socket peer and never believe a forwarded header. Set `{ trustedHops: n }` when the app sits\n     * behind `n` proxies you operate (the caller is read from `X-Forwarded-For` past those hops), or\n     * `{ header: name }` to trust one edge-set header's first value. Declaring trust the app can't\n     * actually enforce lets clients forge their IP, so leave it unset unless a proxy really fronts you.\n     */\n    readonly clientIp?: ClientIpTrust;\n    /**\n     * Admit the public `x-nifra-deadline` header and let it shorten local work. Disabled by default:\n     * services that participate in trusted cross-service deadline propagation opt in explicitly,\n     * while ordinary/public HTTP routes pay no header-admission tax and ignore hostile client values.\n     */\n    readonly acceptInboundDeadlines?: boolean;\n    /**\n     * Maximum time accepted from an inbound `x-nifra-deadline`, in milliseconds. An incoming absolute\n     * deadline may shorten this cap (and `requestTimeoutMs`, when configured), never extend it.\n     * Default 30_000; applies only when `acceptInboundDeadlines` is enabled and the header is present.\n     */\n    readonly maxInboundDeadlineMs?: number;\n    /** When `listen()`ing, install SIGTERM/SIGINT handlers that gracefully `stop()`. Default false. */\n    readonly gracefulSignals?: boolean;\n    /**\n     * Capacity-admission gate (see {@link AdmissionController}). Bounds concurrent in-flight work so a\n     * healthy instance sheds load (`429` + `Retry-After`) instead of accepting more than it can finish.\n     * Off by default. Enabling it disables the fused native-route fast path (requests route through the\n     * shared matched lane where the gate runs); when unset, the request path pays nothing.\n     */\n    readonly admission?: AdmissionController;\n    /**\n     * Optional token-only observation hook called by `useCapability(c, id)`. It receives no request,\n     * parameters, body, tenant, or values. Routes without capability declarations keep the old hot path.\n     */\n    readonly onCapabilityUse?: (event: CapabilityUseEvent) => void;\n    /** Structured logger for framework events (redacts secrets). Default: JSON to stderr. */\n    readonly logger?: Logger;\n    /**\n     * App-wide fallback fired when a route **without its own `onValidationError`** fails body/query\n     * validation. Same contract as the per-route hook (`(issues, ctx, kind) => Response | repaired-value |\n     * undefined`): a route's own hook takes precedence, and a route can fall through to the plain `422` by\n     * returning `undefined`. Use it for one app-wide error envelope (like tRPC's `errorFormatter` /\n     * Fastify's `setErrorHandler`) instead of repeating a formatter per route.\n     */\n    readonly onValidationError?: RouteSchema[\"onValidationError\"];\n}"
   },
   {
     "name": "ServeStaticOptions",
@@ -8179,6 +8682,13 @@
     "signature": "export interface SessionStore {\n    /** The record for `id`, or `undefined` on a miss. */\n    get(id: string): Promise<SessionRecord | undefined>;\n    /** Store (or overwrite) the record for `id`. */\n    set(id: string, record: SessionRecord): Promise<void>;\n    /** Drop `id` (logout / regeneration). A no-op if absent. */\n    delete(id: string): Promise<void>;\n}",
     "doc": "/**\n * Pluggable session backend (store mode). Async so a network store (KV/Redis) fits the same shape.\n * **Production needs a shared/durable store** so sessions hold across instances — {@link MemorySessionStore}\n * prod-guards against the per-instance footgun.\n */"
   },
+  {
+    "name": "SessionUserOf",
+    "kind": "type",
+    "package": "@nifrajs/better-auth",
+    "signature": "export type SessionUserOf<A extends BetterAuthLike> = SessionOf<A> extends {\n    user: infer U;\n} ? U : unknown;",
+    "doc": "/**\n * The non-null user type of a concrete better-auth instance `A` (`SessionOf<A>[\"user\"]`). Collapses to\n * `unknown` only for the erased structural `BetterAuthLike`; a real instance recovers the concrete user.\n */"
+  },
   {
     "name": "setBrowserNavigate",
     "kind": "function",
@@ -8234,13 +8744,6 @@
     "signature": "export type SetSearchParams = (next: SearchParamsInit | ((prev: URLSearchParams) => SearchParamsInit), options?: NavigateOptions) => void;",
     "doc": "/** Set the query string. Accepts a `URLSearchParams`, a record, a raw string, or an updater of the\n * current params; navigates to the same pathname with the new query (push, or replace via options). */"
   },
-  {
-    "name": "setWsRuntime",
-    "kind": "function",
-    "package": "@nifrajs/core",
-    "signature": "export declare function setWsRuntime(impl: WsRuntime): void;",
-    "doc": "/** Called by `@nifrajs/core/ws` on import. Last registration wins (idempotent in practice — there is\n * one implementation; double-import is a no-op re-set of the same functions). */"
-  },
   {
     "name": "sha256",
     "kind": "function",
@@ -8273,7 +8776,7 @@
     "kind": "type",
     "package": "@nifrajs/middleware",
     "signature": "export type ShedReason = \"inflight\" | \"loop-lag\" | \"queue-timeout\" | \"policy\" | \"cancelled\";",
-    "doc": "/**\n * Adaptive capacity admission. Rate limiting bounds request *frequency* and `@nifrajs/budget` bounds\n * request *duration*; neither stops a healthy instance from accepting more *concurrent* work than it\n * can finish. This gate admits on live capacity evidence — in-flight count + event-loop lag — briefly\n * queues at the edge, and sheds the rest with `429` + `Retry-After`, so p99 stays bounded under load\n * instead of collapsing.\n *\n * Public mechanics (in-flight + loop lag) know nothing about tenants. An application-supplied {@link AdmissionPolicy}\n * hook layers tenant priority and reserved capacity on top without leaking\n * those concerns into the OSS core.\n *\n * Wire it as the server's `admission` option (NOT an `onRequest` hook — a hook disables the native\n * route table). Off by default: when unset, the request path is untouched.\n */"
+    "doc": "/**\n * Adaptive capacity admission. Rate limiting bounds request *frequency* and `@nifrajs/core/budget` bounds\n * request *duration*; neither stops a healthy instance from accepting more *concurrent* work than it\n * can finish. This gate admits on live capacity evidence — in-flight count + event-loop lag — briefly\n * queues at the edge, and sheds the rest with `429` + `Retry-After`, so p99 stays bounded under load\n * instead of collapsing.\n *\n * Public mechanics (in-flight + loop lag) know nothing about tenants. An application-supplied {@link AdmissionPolicy}\n * hook layers tenant priority and reserved capacity on top without leaking\n * those concerns into the OSS core.\n *\n * Wire it as the server's `admission` option (NOT an `onRequest` hook — a hook disables the native\n * route table). Off by default: when unset, the request path is untouched.\n */"
   },
   {
     "name": "signal",
@@ -8390,12 +8893,6 @@
     "signature": "export interface SizeReport {\n    /** Per-chunk sizes, sorted biggest gzip first (the regression you want to see at the top). */\n    readonly chunks: readonly ChunkSize[];\n    /** Sum of every chunk's raw bytes. */\n    readonly totalBytes: number;\n    /** Sum of every chunk's gzip bytes. */\n    readonly totalGzip: number;\n}",
     "doc": "/** A whole build's size report — every chunk (largest first) + the totals. */"
   },
-  {
-    "name": "SkippedRoute",
-    "kind": "interface",
-    "package": "@nifrajs/core",
-    "signature": "export interface SkippedRoute {\n    readonly method: string;\n    readonly path: string;\n    readonly reason: string;\n}"
-  },
   {
     "name": "snapshotCapabilities",
     "kind": "function",
@@ -8438,6 +8935,13 @@
     "signature": "export declare function solidMdxBunPlugin(generate: \"dom\" | \"ssr\"): BunPlugin;",
     "doc": "/** Build a `Bun.build` plugin that loads `.mdx` files as Solid components. `generate`: `\"ssr\"` for the\n * server build, `\"dom\"` for the client (matches `solidBunPlugin`). */"
   },
+  {
+    "name": "solidSvgComponentBunPlugin",
+    "kind": "function",
+    "package": "@nifrajs/web-solid",
+    "signature": "export declare function solidSvgComponentBunPlugin(generate: \"dom\" | \"ssr\"): BunPlugin;",
+    "doc": "/** The Solid SVG-component plugin. `generate` selects the Solid `\"dom\"`/`\"ssr\"` output, matching\n * `solidBunPlugin`. A plain `import \"./icon.svg\"` (asset URL) is untouched - only `?component` matches. */"
+  },
   {
     "name": "SourceFinding",
     "kind": "interface",
@@ -8445,13 +8949,6 @@
     "signature": "export interface SourceFinding {\n    readonly file: string;\n    readonly line: number;\n    readonly snippet: string;\n}",
     "doc": "/**\n * `nifra check` — the agent's (and CI's) definition of done. It makes the guarantees that keep a nifra\n * app drift-proof actually *fire*, instead of relying on the agent to remember them:\n *\n *   1. **typecheck** (`tsc --noEmit`) — the frontend↔backend contract is compiler-enforced. The typed\n *      client derives request + response types from the routes, so a shape mismatch is a type error.\n *   2. **typed-client lint** — flags hand-rolled `fetch()` to this app's *own* API (a relative URL),\n *      which bypasses `client<typeof app>` so the compiler can't see the drift.\n *   3. **server-only-import lint** — flags a top-level import of server-only code (a DB driver, `node:`/\n *      `bun:` builtins, the `./db` module) into a `routes/` page module. Those modules are bundled for\n *      the browser too, so the import ships server code to the client and breaks the build — the #1\n *      full-stack footgun. Reach server resources via `c.db` / `ctx.api`, never a top-level import.\n *\n * `collectCheckResult` returns a structured, machine-readable result (consumed by `--json` and the\n * `nifra_check` MCP tool, so an agent acts on diagnostics instead of scraping prose). Exits non-zero if\n * anything fails. Pure scanners (`scanFetchText`, `scanServerOnlyImports`) are unit-tested.\n */"
   },
-  {
-    "name": "SpanExporter",
-    "kind": "type",
-    "package": "@nifrajs/otel",
-    "signature": "export type SpanExporter = ObservationAdapter;",
-    "doc": "/** Backwards-compatible name for an observation sink. */"
-  },
   {
     "name": "SpanStatus",
     "kind": "type",
@@ -8499,6 +8996,12 @@
     "signature": "export interface SSEMessage {\n    readonly data?: string;\n    readonly event?: string;\n    readonly id?: string;\n    /** Client reconnection delay hint, ms (coerced to an integer). */\n    readonly retry?: number;\n    /** A `: comment` line (e.g. a keep-alive ping). */\n    readonly comment?: string;\n}",
     "doc": "/** One SSE frame. Every field is optional; `data` may be multi-line (emitted as multiple `data:` lines). */"
   },
+  {
+    "name": "SseRuntime",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface SseRuntime {\n    response<Event>(context: SSEContext, run: (stream: TypedSSEStream<Event>) => void | Promise<void>, init?: SSEInit): Response;\n}"
+  },
   {
     "name": "SSEStream",
     "kind": "interface",
@@ -8525,6 +9028,12 @@
     "signature": "export interface StandardIssue {\n    readonly message: string;\n}",
     "doc": "/**\n * Minimal Standard Schema surface (the public https://standardschema.dev v1 spec), inlined so\n * `@nifrajs/env` stays dependency-free and accepts validators from `t` (@nifrajs/schema), zod, valibot,\n * or its own coercing `env.*` helpers interchangeably.\n */"
   },
+  {
+    "name": "StandardIssue",
+    "kind": "interface",
+    "package": "@nifrajs/mcp",
+    "signature": "export interface StandardIssue {\n    readonly message: string;\n    readonly path?: ReadonlyArray<PropertyKey | {\n        readonly key: PropertyKey;\n    }> | undefined;\n}"
+  },
   {
     "name": "StandardPathSegment",
     "kind": "interface",
@@ -8550,6 +9059,12 @@
     "signature": "export type StandardResult<Output> = {\n    readonly value: Output;\n    readonly issues?: undefined;\n} | {\n    readonly issues: ReadonlyArray<{\n        readonly message: string;\n    }>;\n};",
     "doc": "/** The validate-result half of the Standard Schema spec. */"
   },
+  {
+    "name": "StandardResult",
+    "kind": "type",
+    "package": "@nifrajs/mcp",
+    "signature": "export type StandardResult<Output> = {\n    readonly value: Output;\n    readonly issues?: undefined;\n} | {\n    readonly issues: ReadonlyArray<StandardIssue>;\n};"
+  },
   {
     "name": "StandardSchemaProps",
     "kind": "interface",
@@ -8576,6 +9091,13 @@
     "signature": "export interface StandardSchemaV1<Output = unknown> {\n    readonly \"~standard\": {\n        readonly version: 1;\n        readonly vendor: string;\n        readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;\n        readonly types?: {\n            readonly input: unknown;\n            readonly output: Output;\n        };\n    };\n}",
     "doc": "/** A minimal structural view of a Standard Schema validator (v1). `t.object(...)` satisfies it. */"
   },
+  {
+    "name": "StandardSchemaV1",
+    "kind": "interface",
+    "package": "@nifrajs/mcp",
+    "signature": "export interface StandardSchemaV1<Input = unknown, Output = Input> {\n    readonly \"~standard\": {\n        readonly version: 1;\n        readonly vendor: string;\n        readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;\n        readonly types?: {\n            readonly input: Input;\n            readonly output: Output;\n        } | undefined;\n    };\n}",
+    "doc": "/**\n * The Standard Schema v1 interface (https://standardschema.dev), vendored as types + a tiny\n * runtime so any compliant validator - nifra's `t`, zod, valibot, arktype, … - can type and\n * validate tool arguments without coupling this package to a validator. The spec is MIT-licensed\n * and explicitly designed to be copied; this package stays dependency-free.\n */"
+  },
   {
     "name": "StandardSuccess",
     "kind": "interface",
@@ -8745,6 +9267,13 @@
     "signature": "export interface StoredResponse {\n    readonly status: number;\n    readonly headers: readonly (readonly [string, string])[];\n    /** Base64-encoded response body; `\"\"` when the response had no body. */\n    readonly body: string;\n}",
     "doc": "/** A serialized response held by a store. `body` is base64 so binary payloads round-trip intact. */"
   },
+  {
+    "name": "streaming",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function streaming(): IdentityPlugin;",
+    "doc": "/**\n * Enable `.sse()` streaming routes: `.use(streaming())` installs the SSE runtime. Without it, an\n * `.sse()` route is a registration error, so the ReadableStream framing stays out of non-SSE bundles.\n * The `sse()` / `typedSSEStream()` helpers ship from this same subpath for use inside handlers.\n */"
+  },
   {
     "name": "string",
     "kind": "function",
@@ -8832,11 +9361,93 @@
     "signature": "export declare function svelteMdxBunPlugin(generate: \"dom\" | \"ssr\"): BunPlugin;",
     "doc": "/** Build a `Bun.build` plugin that loads `.mdx` files as Svelte components via mdsvex. `generate`:\n * `\"ssr\"` for the server build, `\"dom\"` for the client (matches `svelteBunPlugin`). */"
   },
+  {
+    "name": "svelteSvgComponentBunPlugin",
+    "kind": "function",
+    "package": "@nifrajs/web-svelte",
+    "signature": "export declare function svelteSvgComponentBunPlugin(generate: \"dom\" | \"ssr\"): BunPlugin;",
+    "doc": "/** The Svelte SVG-component plugin. `generate` selects Svelte's `\"client\"`/`\"server\"` output, matching\n * `svelteBunPlugin`. */"
+  },
+  {
+    "name": "SVG_COMPONENT_FILTER",
+    "kind": "const",
+    "package": "@nifrajs/web",
+    "signature": "export declare const SVG_COMPONENT_FILTER: RegExp;",
+    "doc": "/** The Bun `onLoad` filter every adapter's SVG-component plugin matches: `*.svg?component`. */"
+  },
+  {
+    "name": "svgComponentBunPlugin",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function svgComponentBunPlugin(_generate: \"dom\" | \"ssr\", options?: SvgPluginOptions): BunPlugin;",
+    "doc": "/**\n * The SVG-as-component Bun plugin (React/Preact). `generate` is accepted for parity with the other\n * plugin pairs; the emitted component is the same on `\"dom\"` and `\"ssr\"`.\n */"
+  },
+  {
+    "name": "svgComponentSource",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function svgComponentSource(xml: string, options?: SvgToJsxOptions): string;",
+    "doc": "/** Emit the component module source for a `?component` SVG import. Identical on dom + ssr (isomorphic). */"
+  },
+  {
+    "name": "SvgOptimizer",
+    "kind": "interface",
+    "package": "@nifrajs/web",
+    "signature": "export interface SvgOptimizer {\n    optimize(input: string, options?: Record<string, unknown>): {\n        readonly data: string;\n    };\n}",
+    "doc": "/** The subset of the `svgo` API this plugin uses (structural, so no hard dependency on its types). */"
+  },
+  {
+    "name": "SvgPluginOptions",
+    "kind": "interface",
+    "package": "@nifrajs/web",
+    "signature": "export interface SvgPluginOptions {\n    /** Optimize each SVG first. `true` loads the `svgo` peer; pass an optimizer to inject one (or a stub). */\n    readonly svgo?: boolean | SvgOptimizer;\n}"
+  },
+  {
+    "name": "svgToJsx",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function svgToJsx(xml: string, options?: SvgToJsxOptions): string;",
+    "doc": "/** Convert an SVG XML string into a JSX-safe `<svg>…</svg>` element with `{...props}` spread on the root. */"
+  },
+  {
+    "name": "SvgToJsxOptions",
+    "kind": "interface",
+    "package": "@nifrajs/web",
+    "signature": "export interface SvgToJsxOptions {\n    /** The JSX prop name for `class`. `\"className\"` for React/Preact; `\"class\"` for Solid. */\n    readonly classProp?: string;\n}"
+  },
+  {
+    "name": "svgToSvelte",
+    "kind": "function",
+    "package": "@nifrajs/web-svelte",
+    "signature": "export declare function svgToSvelte(xml: string): string;",
+    "doc": "/** Wrap raw SVG XML in a Svelte 5 component: strip XML noise, spread props onto the root `<svg>`. */"
+  },
+  {
+    "name": "svgToVueSfc",
+    "kind": "function",
+    "package": "@nifrajs/web-vue",
+    "signature": "export declare function svgToVueSfc(xml: string): string;",
+    "doc": "/** Wrap raw SVG XML in a template-only Vue SFC (single root → Vue inherits attrs onto the `<svg>`). */"
+  },
+  {
+    "name": "SyncManifestResult",
+    "kind": "interface",
+    "package": "@nifrajs/cli",
+    "signature": "export interface SyncManifestResult {\n    /** The committed server-manifest file (relative to cwd). */\n    readonly file: string;\n    /** True when the file's route table changed and it was rewritten. */\n    readonly changed: boolean;\n    /** Route files now imported that weren't before (added). */\n    readonly added: readonly string[];\n    /** Route files no longer imported (removed/renamed away). */\n    readonly removed: readonly string[];\n    /** Set when the sync was REFUSED because discovery found zero routes for a manifest that had some\n     * (`routes/` likely emptied by mistake) - the manifest was left untouched rather than wiped. */\n    readonly refusedEmpty?: boolean;\n}",
+    "doc": "/**\n * `nifra sync-manifest` - regenerate a committed web `server-manifest.ts` from the current `routes/` tree\n * WITHOUT a full build. The manifest is a generated file that bakes the route table (+ client-asset hashes)\n * for a disk-less edge worker; after adding/renaming/removing a route it drifts, and `nifra check` flags it.\n * Regenerating it used to require the whole `build` (server + worker + migrate bundles). This re-scans\n * `routes/` and rewrites just the manifest's route table, preserving the baked client-asset references.\n *\n * It does NOT rebuild the client bundle: a brand-new HYDRATING route still needs a full build so its client\n * chunk exists. This clears route-table drift for the common case (a loader edit, an SSR-only route, a\n * rename) in milliseconds, and prints that caveat for the case it can't cover.\n */"
+  },
+  {
+    "name": "syncServerManifests",
+    "kind": "function",
+    "package": "@nifrajs/cli",
+    "signature": "export declare function syncServerManifests(cwd: string): Promise<SyncManifestResult[]>;",
+    "doc": "/**\n * Discover every generated `server-manifest.ts` under `cwd` and re-sync its route table from the live\n * `routes/` tree, preserving baked client assets. Returns one result per generated manifest. Never throws\n * on a per-manifest miss (an unreadable/absent routes dir is skipped).\n */"
+  },
   {
     "name": "t",
     "kind": "const",
     "package": "@nifrajs/schema",
-    "signature": "export declare const t: {\n    readonly string: (options?: StringOptions) => NifraSchema<import(\"@sinclair/typebox\").TString>;\n    readonly number: (options?: NumberOptions) => NifraSchema<import(\"@sinclair/typebox\").TNumber>;\n    readonly integer: (options?: IntegerOptions) => NifraSchema<import(\"@sinclair/typebox\").TInteger>;\n    readonly boolean: () => NifraSchema<import(\"@sinclair/typebox\").TBoolean>;\n    readonly null: () => NifraSchema<import(\"@sinclair/typebox\").TNull>;\n    readonly literal: <const L extends TLiteralValue>(value: L) => NifraSchema<import(\"@sinclair/typebox\").TLiteral<L>>;\n    readonly object: <P extends Props>(props: P, options?: ObjectOptions) => NifraSchema<import(\"@sinclair/typebox\").TObject<{ [K in keyof P]: P[K][\"jsonSchema\"]; }>>;\n    /** Like `t.object` but ACCEPTS (and passes through) unknown fields — the explicit opt-out of the\n     * strict default. Prefer `t.object` unless you genuinely need an open object. */\n    readonly looseObject: <P extends Props>(props: P, options?: ObjectOptions) => NifraSchema<import(\"@sinclair/typebox\").TObject<{ [K in keyof P]: P[K][\"jsonSchema\"]; }>>;\n    readonly array: <T extends TSchema>(item: NifraSchema<T>, options?: ArrayOptions) => NifraSchema<import(\"@sinclair/typebox\").TArray<T>>;\n    /** Marks a property optional inside `t.object`; standalone it is `T | undefined`. */\n    readonly optional: <T extends TSchema>(schema: NifraSchema<T>) => NifraSchema<T extends import(\"@sinclair/typebox\").TOptional<infer S extends TSchema> ? import(\"@sinclair/typebox\").TOptional<S> : import(\"@sinclair/typebox\").Ensure<import(\"@sinclair/typebox\").TOptional<T>>>;\n    readonly union: <const S extends readonly NifraSchema[]>(schemas: S) => NifraSchema<TUnion<{ -readonly [K in keyof S]: S[K][\"jsonSchema\"]; }>>;\n    readonly record: <T extends TSchema>(value: NifraSchema<T>, options?: ObjectOptions) => NifraSchema<import(\"@sinclair/typebox\").TRecord<import(\"@sinclair/typebox\").TString, T>>;\n    /** A cursor-pagination response envelope: `{ items: T[]; nextCursor: string | null }` (`null` = last page). */\n    readonly paginated: <T extends TSchema>(item: NifraSchema<T>, options?: ObjectOptions) => NifraSchema<import(\"@sinclair/typebox\").TObject<{\n        items: import(\"@sinclair/typebox\").TArray<T>;\n        nextCursor: TUnion<[import(\"@sinclair/typebox\").TString, import(\"@sinclair/typebox\").TNull]>;\n    }>>;\n    /** A request query schema for cursor pagination: `{ cursor?: string; limit?: number }`. `maxLimit`\n     * caps `limit` — a larger value fails validation (a 422), so a client can't request an unbounded page.\n     * `coerce` is on because query values arrive as strings (`?limit=20` → `\"20\"`); it's what makes `limit`\n     * a real `number` in the handler (`c.query.limit`), not a string. */\n    readonly pageQuery: (options?: {\n        maxLimit?: number;\n    }) => NifraSchema<import(\"@sinclair/typebox\").TObject<{\n        cursor: import(\"@sinclair/typebox\").TOptional<import(\"@sinclair/typebox\").TString>;\n        limit: import(\"@sinclair/typebox\").TOptional<import(\"@sinclair/typebox\").TInteger>;\n    }>>;\n};",
+    "signature": "export declare const t: {\n    readonly string: (options?: StringOptions) => NifraSchema<import(\"@sinclair/typebox\").TString>;\n    readonly number: (options?: NumberOptions) => NifraSchema<import(\"@sinclair/typebox\").TNumber>;\n    readonly integer: (options?: IntegerOptions) => NifraSchema<import(\"@sinclair/typebox\").TInteger>;\n    readonly boolean: () => NifraSchema<import(\"@sinclair/typebox\").TBoolean>;\n    readonly null: () => NifraSchema<import(\"@sinclair/typebox\").TNull>;\n    readonly literal: <const L extends TLiteralValue>(value: L) => NifraSchema<import(\"@sinclair/typebox\").TLiteral<L>>;\n    readonly object: <P extends Props>(props: P, options?: ObjectOptions) => NifraSchema<import(\"@sinclair/typebox\").TObject<{ [K in keyof P]: P[K][\"jsonSchema\"]; }>>;\n    /** Like `t.object` but ACCEPTS (and passes through) unknown fields — the explicit opt-out of the\n     * strict default. Prefer `t.object` unless you genuinely need an open object. */\n    readonly looseObject: <P extends Props>(props: P, options?: ObjectOptions) => NifraSchema<import(\"@sinclair/typebox\").TObject<{ [K in keyof P]: P[K][\"jsonSchema\"]; }>>;\n    readonly array: <T extends TSchema>(item: NifraSchema<T>, options?: ArrayOptions) => NifraSchema<import(\"@sinclair/typebox\").TArray<T>>;\n    /** Marks a property optional inside `t.object`; standalone it is `T | undefined`. */\n    readonly optional: <T extends TSchema>(schema: NifraSchema<T>) => NifraSchema<T extends import(\"@sinclair/typebox\").TOptional<infer S extends TSchema> ? import(\"@sinclair/typebox\").TOptional<S> : import(\"@sinclair/typebox\").Ensure<import(\"@sinclair/typebox\").TOptional<T>>>;\n    readonly union: <const S extends readonly NifraSchema[]>(schemas: S) => NifraSchema<TUnion<{ -readonly [K in keyof S]: S[K][\"jsonSchema\"]; }>>;\n    readonly record: <T extends TSchema>(value: NifraSchema<T>, options?: ObjectOptions) => NifraSchema<import(\"@sinclair/typebox\").TRecord<import(\"@sinclair/typebox\").TString, T>>;\n    /** A cursor-pagination response envelope: `{ items: T[]; nextCursor: string | null }` (`null` = last page). */\n    readonly paginated: <T extends TSchema>(item: NifraSchema<T>, options?: ObjectOptions) => NifraSchema<import(\"@sinclair/typebox\").TObject<{\n        items: import(\"@sinclair/typebox\").TArray<T>;\n        nextCursor: TUnion<[import(\"@sinclair/typebox\").TString, import(\"@sinclair/typebox\").TNull]>;\n    }>>;\n    /** A request query schema for cursor pagination: `{ cursor?: string; limit?: number }`. `maxLimit`\n     * caps `limit` — a larger value fails validation (a 422), so a client can't request an unbounded page.\n     * `coerce` is on because query values arrive as strings (`?limit=20` → `\"20\"`); it's what makes `limit`\n     * a real `number` in the handler (`c.query.limit`), not a string. */\n    readonly pageQuery: (options?: {\n        maxLimit?: number;\n    }) => NifraSchema<import(\"@sinclair/typebox\").TObject<{\n        cursor: import(\"@sinclair/typebox\").TOptional<import(\"@sinclair/typebox\").TString>;\n        limit: import(\"@sinclair/typebox\").TOptional<import(\"@sinclair/typebox\").TInteger>;\n    }>>;\n    /** A request-query schema with string->scalar COERCION on. Query values always arrive as strings\n     * (`?limit=20` -> `\"20\"`), so a plain `t.object({ limit: t.integer() })` in a `query` slot fails to\n     * validate; use `t.query` and `t.integer()`/`t.number()`/`t.boolean()` fields become real numbers/\n     * booleans in `c.query`. **Open by default** (unknown query fields pass through — `additionalProperties:\n     * true`): query params are read by name, not spread into a DB write, so unknown params (UTM tracking,\n     * `fbclid`, etc.) passing through is safe, and rejecting them is a production-only footgun (ad/social\n     * traffic appends params your schema never declares, causing 422s that never appear in dev/CI). Pass\n     * `{ additionalProperties: false }` to enforce a strict allowlist. This is the query-slot constructor;\n     * `t.object` stays the constructor for body slots (no coercion, a JSON body is already typed). */\n    readonly query: <P extends Props>(props: P, options?: ObjectOptions) => NifraSchema<import(\"@sinclair/typebox\").TObject<{ [K in keyof P]: P[K][\"jsonSchema\"]; }>>;\n};",
     "doc": "/**\n * The built-in schema builder. Each constructor returns a `NifraSchema` — a\n * Standard Schema whose validated output type flows into `c.body`/`c.query`, and\n * whose `jsonSchema` powers `toOpenAPI`. Options (min/max, length, pattern, …)\n * pass straight through to TypeBox and so become JSON Schema constraints.\n *\n * Composite constructors are generic over the *inner* TypeBox schema `T extends\n * TSchema` (not over `NifraSchema`): reading `.jsonSchema` off a value typed only as\n * `NifraSchema` would erase to the `TSchema` constraint and collapse the output type\n * to `unknown`. Capturing `T` keeps `Static<T>` precise (`string[]`, not\n * `unknown[]`).\n */"
   },
   {
@@ -8909,6 +9520,12 @@
     "package": "@nifrajs/cli",
     "signature": "export interface TestToolResult {\n    readonly ok: boolean;\n    readonly command: readonly string[];\n    readonly durationMs: number;\n    readonly exitCode: number | null;\n    readonly timedOut: boolean;\n    readonly cancelled?: boolean;\n    readonly summary: TestSummary;\n    readonly stdout: string;\n    readonly stderr: string;\n    readonly error?: string;\n}"
   },
+  {
+    "name": "TEXT_DECODER",
+    "kind": "const",
+    "package": "@nifrajs/core",
+    "signature": "export declare const TEXT_DECODER: TextDecoder;"
+  },
   {
     "name": "Thenable",
     "kind": "type",
@@ -8920,7 +9537,7 @@
     "name": "timing",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function timing(options?: TimingOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").Server<any, any>>;",
+    "signature": "export declare function timing(options?: TimingOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").Server<any, any>>;",
     "doc": "/**\n * Adds a `Server-Timing` response header and typed `c.timing` controls for custom metrics.\n * Put request-rewriting middleware (for example `methodOverride`) before `timing()` so timing is\n * attached to the final routed request.\n */"
   },
   {
@@ -8985,12 +9602,19 @@
     "package": "@nifrajs/cli",
     "signature": "export declare function tokenSetHas(tokens: ReadonlySet<string>, group: SearchTermGroup): boolean;"
   },
+  {
+    "name": "toNodeOutcome",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function toNodeOutcome(result: HandlerResult, set: CtxSet): NodeServeOutcome;",
+    "doc": "/**\n * `finalize` for the node-direct path - mirror of `toResponse` that skips the `Response` build:\n * a plain value becomes pre-stringified JSON primitives (the adapter `JSON.stringify`s once, here, not\n * via `Response.json` + a body drain); a handler-returned `Response` is wrapped as-is, with queued\n * cookies appended exactly as `toResponse` does (so the set-cookie-then-`redirect()` pattern still\n * works on Node).\n */"
+  },
   {
     "name": "ToolAnnotations",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface ToolAnnotations {\n    /** Human-readable display title for the tool, distinct from the machine `name`. */\n    readonly title?: string;\n    /** The tool does not modify its environment (a pure read). */\n    readonly readOnlyHint?: boolean;\n    /** The tool may perform destructive updates — only meaningful when `readOnlyHint` is not `true`. */\n    readonly destructiveHint?: boolean;\n    /** Repeated calls with the same arguments have no additional effect beyond the first. */\n    readonly idempotentHint?: boolean;\n    /** The tool interacts with external entities (an \"open world\" beyond this server). */\n    readonly openWorldHint?: boolean;\n}",
-    "doc": "/**\n * MCP tool safety hints, surfaced in `tools/list`, that tell an agent how risky a `.tool()` call is — so it\n * can decide whether to auto-invoke or confirm first. All optional; an omitted hint means \"unknown\". Mirrors\n * the MCP spec's tool `annotations`.\n */"
+    "signature": "export interface ToolAnnotations {\n    /** Human-readable display title for the tool, distinct from the machine `name`. */\n    readonly title?: string;\n    /** The tool does not modify its environment (a pure read). */\n    readonly readOnlyHint?: boolean;\n    /** The tool may perform destructive updates - only meaningful when `readOnlyHint` is not `true`. */\n    readonly destructiveHint?: boolean;\n    /** Repeated calls with the same arguments have no additional effect beyond the first. */\n    readonly idempotentHint?: boolean;\n    /** The tool interacts with external entities (an \"open world\" beyond this server). */\n    readonly openWorldHint?: boolean;\n}",
+    "doc": "/**\n * MCP tool safety hints, surfaced in `tools/list`, that tell an agent how risky a `.tool()` call is - so it\n * can decide whether to auto-invoke or confirm first. All optional; an omitted hint means \"unknown\". Mirrors\n * the MCP spec's tool `annotations`.\n */"
   },
   {
     "name": "toOpenAPI",
@@ -9012,6 +9636,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": "toResponse",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function toResponse(result: HandlerResult, set: CtxSet): Response;"
+  },
   {
     "name": "TraceContext",
     "kind": "type",
@@ -9030,14 +9660,14 @@
     "name": "tracing",
     "kind": "function",
     "package": "@nifrajs/otel",
-    "signature": "export declare function tracing(options?: TracingOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").Server<any, any>>;",
+    "signature": "export declare function tracing(options?: TracingOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").Server<any, any>>;",
     "doc": "/**\n * Distributed-tracing plugin. Each request continues the inbound trace (or starts one), opens a\n * server span, and ends it on response with the status + HTTP attributes. Idempotent.\n *\n * ```ts\n * app.use(tracing({ exporter: myOtelExporter, serviceName: \"orders-api\" }))\n * // in a handler: fetch(url, { headers: traceHeaders(c.trace) })  // continue the trace downstream\n * ```\n */"
   },
   {
     "name": "TracingOptions",
     "kind": "interface",
     "package": "@nifrajs/otel",
-    "signature": "export interface TracingOptions {\n    /** Where spans are sent. Default: {@link consoleSpanExporter}. */\n    readonly exporter?: SpanExporter;\n    /** Additional observation adapters (DevTools, a private redacting backend, metrics, …). */\n    readonly adapters?: readonly ObservationAdapter[];\n    /** Sets the `service.name` attribute on every span. */\n    readonly serviceName?: string;\n    /**\n     * Set the outbound `traceparent` on the RESPONSE too (handy for browser/client correlation).\n     * Default false — most setups only propagate downstream, not back to the caller.\n     */\n    readonly responseHeader?: boolean;\n    /**\n     * Optional durable graph recorder. When configured, the request root is appended before the\n     * handler runs and recorder failure fails closed. Without one, `c.causality` is still propagated.\n     */\n    readonly causality?: {\n        readonly recorder?: CausalityRecorder;\n        /** Injectable epoch clock for deterministic tests. */\n        readonly now?: () => number;\n        /**\n         * Explicit trust gate for service-to-service causality headers. Internet clients are untrusted\n         * by default; a false result or thrown/rejected check starts a fresh execution graph.\n         */\n        readonly acceptInbound?: (request: Request, context: CausalityContext) => boolean | Promise<boolean>;\n    };\n}"
+    "signature": "export interface TracingOptions {\n    /** Where spans are sent. Default: {@link consoleSpanExporter}. */\n    readonly exporter?: ObservationAdapter;\n    /** Additional observation adapters (DevTools, a private redacting backend, metrics, …). */\n    readonly adapters?: readonly ObservationAdapter[];\n    /** Sets the `service.name` attribute on every span. */\n    readonly serviceName?: string;\n    /**\n     * Set the outbound `traceparent` on the RESPONSE too (handy for browser/client correlation).\n     * Default false — most setups only propagate downstream, not back to the caller.\n     */\n    readonly responseHeader?: boolean;\n    /**\n     * Optional durable graph recorder. When configured, the request root is appended before the\n     * handler runs and recorder failure fails closed. Without one, `c.causality` is still propagated.\n     */\n    readonly causality?: {\n        readonly recorder?: CausalityRecorder;\n        /** Injectable epoch clock for deterministic tests. */\n        readonly now?: () => number;\n        /**\n         * Explicit trust gate for service-to-service causality headers. Internet clients are untrusted\n         * by default; a false result or thrown/rejected check starts a fresh execution graph.\n         */\n        readonly acceptInbound?: (request: Request, context: CausalityContext) => boolean | Promise<boolean>;\n    };\n}"
   },
   {
     "name": "TrailingSlashOptions",
@@ -9077,7 +9707,7 @@
     "name": "trimTrailingSlash",
     "kind": "function",
     "package": "@nifrajs/middleware",
-    "signature": "export declare function trimTrailingSlash(options?: TrailingSlashOptions): import(\"@nifrajs/core\").NifraPlugin<import(\"@nifrajs/core\").AnyServer, import(\"@nifrajs/core\").AnyServer>;",
+    "signature": "export declare function trimTrailingSlash(options?: TrailingSlashOptions): import(\"@nifrajs/core/server\").NifraPlugin<import(\"@nifrajs/core/server\").AnyServer, import(\"@nifrajs/core/server\").AnyServer>;",
     "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 */"
   },
   {
@@ -9140,7 +9770,7 @@
     "kind": "function",
     "package": "@nifrajs/mcp",
     "signature": "export declare function uiResourceMeta(uri: string): Record<string, unknown>;",
-    "doc": "/** The MCP Apps `_meta.ui.resourceUri` link, emitted nested (current spec) AND flat (the deprecated\n * `ui/resourceUri`, still read by some hosts) so a tool renders across the transition. */"
+    "doc": "/** The MCP Apps `_meta.ui.resourceUri` link. */"
   },
   {
     "name": "UNBOUNDED_DEADLINE",
@@ -9173,13 +9803,13 @@
     "name": "UpgradePlan",
     "kind": "interface",
     "package": "@nifrajs/cli",
-    "signature": "export interface UpgradePlan {\n    readonly version: string;\n    readonly pins: readonly PinChange[];\n    readonly importMoves: readonly ImportChange[];\n    readonly notes: readonly string[];\n}"
+    "signature": "export interface UpgradePlan {\n    readonly version: string;\n    readonly pins: readonly PinChange[];\n    readonly dependencyMoves: readonly DependencyMoveChange[];\n    readonly importMoves: readonly ImportChange[];\n    readonly notes: readonly string[];\n}"
   },
   {
     "name": "UpgradeRecipe",
     "kind": "interface",
     "package": "@nifrajs/cli",
-    "signature": "export interface UpgradeRecipe {\n    readonly version: string;\n    readonly pins: readonly PinRule[];\n    readonly importMoves: readonly ImportMove[];\n    /** Human notes printed after the plan — e.g. structural changes the runner deliberately can't do. */\n    readonly notes?: readonly string[];\n}"
+    "signature": "export interface UpgradeRecipe {\n    readonly version: string;\n    readonly pins: readonly PinRule[];\n    readonly dependencyMoves?: readonly DependencyMove[];\n    readonly importMoves: readonly ImportMove[];\n    /** Human notes printed after the plan — e.g. structural changes the runner deliberately can't do. */\n    readonly notes?: readonly string[];\n}"
   },
   {
     "name": "UploadResult",
@@ -9195,6 +9825,12 @@
     "signature": "export declare function url(opts?: Base<string> & Optional): StandardSchemaV1<string | undefined>;",
     "doc": "/** A valid absolute URL (parses with the WHATWG `URL`). Returns the normalized href string. */"
   },
+  {
+    "name": "UrlParts",
+    "kind": "interface",
+    "package": "@nifrajs/core",
+    "signature": "export interface UrlParts {\n    readonly pathname: string;\n    readonly search: string;\n}"
+  },
   {
     "name": "urlPartsOf",
     "kind": "function",
@@ -9334,6 +9970,13 @@
     "signature": "export declare function useNavigate(): NavigateFunction;",
     "doc": "/** Get the {@link NavigateFunction}. Stable across renders; resolves the browser navigate at call time\n * (so it works as soon as `installHistory` has run, and no-ops before then / on the server). */"
   },
+  {
+    "name": "useNavigation",
+    "kind": "function",
+    "package": "@nifrajs/web-react",
+    "signature": "export declare function useNavigation(): Navigation;",
+    "doc": "/**\n * Observe client navigation to drive loading UI (a top-bar spinner, dimmed content, a skeleton). nifra\n * navigates imperatively - it fetches the next route's chunk + loader data while the current route stays\n * on screen, then swaps - so `pending` is the signal for \"a transition is in flight,\" not a Suspense\n * boundary. Always `{ pending: false, state: \"idle\" }` on the server (loaders block before render), so\n * it is hydration-safe.\n *\n * ```tsx\n * const { pending } = useNavigation()\n * return <div className={pending ? \"opacity-60\" : \"\"}>{pending && <TopBarSpinner />}<Outlet /></div>\n * ```\n */"
+  },
   {
     "name": "useParams",
     "kind": "function",
@@ -9341,6 +9984,13 @@
     "signature": "export declare function useParams<T extends Record<string, string | undefined> = Record<string, string>>(): Readonly<T>;",
     "doc": "/**\n * The matched route's decoded path params — `/users/:id` on `/users/7` → `{ id: \"7\" }`. SSR-correct:\n * `compose` provides the same value server-side (from the request match) and client-side (from router\n * state), so a param rendered into markup doesn't flash on hydration.\n */"
   },
+  {
+    "name": "usePending",
+    "kind": "function",
+    "package": "@nifrajs/web-react",
+    "signature": "export declare function usePending(): boolean;",
+    "doc": "/** Convenience boolean form of {@link useNavigation}: `true` while a client navigation is in flight. */"
+  },
   {
     "name": "useQuery",
     "kind": "function",
@@ -9665,8 +10315,8 @@
     "name": "VERSION",
     "kind": "const",
     "package": "@nifrajs/core",
-    "signature": "export declare const VERSION: \"1.13.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, so the literal can't go stale\n * (it shipped at \"0.0.0\" through 1.0.0 before those guards existed). Kept narrow (`as const`) so\n * consumers can pin it at the type level — see `test/version.test-d.ts`.\n */"
+    "signature": "export declare const VERSION: \"2.0.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": "ViteDevServer",
@@ -9694,6 +10344,13 @@
     "signature": "export declare function vueBunPlugin(generate: \"dom\" | \"ssr\"): BunPlugin;",
     "doc": "/**\n * The `.vue` compiler Bun plugin. `\"dom\"` → client-hydratable output; `\"ssr\"` → server render. On the\n * `\"dom\"` build, a SFC's `<style>` CSS is emitted as a virtual `?vue-css` module that `Bun.build`'s CSS\n * bundler folds into the app stylesheet (served as a `<link>`). The `\"ssr\"` build emits no CSS — the\n * scope attributes are already in the markup and the stylesheet ships from the client build. With\n * `nifra dev`, `@vitejs/plugin-vue` handles the styles instead.\n */"
   },
+  {
+    "name": "vueSvgComponentBunPlugin",
+    "kind": "function",
+    "package": "@nifrajs/web-vue",
+    "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": "walkServerOnlyChain",
     "kind": "function",
@@ -9747,6 +10404,13 @@
     "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": "websocket",
+    "kind": "function",
+    "package": "@nifrajs/core",
+    "signature": "export declare function websocket(): IdentityPlugin;",
+    "doc": "/**\n * Enable WebSocket routes on a server: `.use(websocket())` turns on `app.ws()`. Applying it twice is\n * a no-op (named plugin dedupe).\n */"
+  },
   {
     "name": "WebSocketContext",
     "kind": "interface",
@@ -9765,14 +10429,14 @@
     "name": "WebSocketHandler",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface WebSocketHandler<Data = unknown, Env = unknown, Schema extends StandardSchemaV1 | undefined = undefined> {\n    /**\n     * Cross-site WebSocket hijacking (CSWSH) guard — checked BEFORE `upgrade()`. A browser does not\n     * apply CORS to WebSocket handshakes and DOES send the page's cookies, so without an Origin check\n     * any site can open an authenticated socket to your app. Set this to lock the route to known\n     * origins: a string allow-list (exact `Origin` header match) or a predicate. A request whose\n     * `Origin` doesn't match (or is absent, for the allow-list form) is rejected with `403` before any\n     * per-connection work.\n     *\n     * **When omitted, the default is same-origin:** a cross-origin BROWSER handshake (an `Origin` header\n     * whose host differs from the request's) is rejected with `403`. Non-browser clients (no `Origin`) and\n     * same-origin browsers pass. Set this to allow specific cross-origin clients, or `() => true` for a\n     * genuinely public socket. Non-browser clients can spoof `Origin`, so this is a browser-CSWSH defense,\n     * not authentication — pair it with auth in `upgrade()`.\n     */\n    allowedOrigins?: ReadonlyArray<string> | ((origin: string | null) => boolean);\n    /**\n     * Runs in the HTTP request context **before** the upgrade (and after {@link allowedOrigins}) — the\n     * place to authenticate or rate-limit. Return the initial per-connection `data` (→ `ws.data`), or a\n     * `Response` to **reject** the upgrade (the client never connects). Omit to accept with\n     * `data: undefined`. A thrown error rejects with a flat 500.\n     */\n    upgrade?(c: WebSocketContext<Env>): MaybePromise<Data | Response>;\n    /**\n     * Contract-first messages: a Standard Schema (`t`, zod, valibot, …) validating each **inbound** frame.\n     * Text frames are parsed as JSON first. When set, `message` receives the validated, typed value; a\n     * non-JSON or schema-invalid frame is routed to `onInvalidMessage` (or dropped if that's omitted).\n     */\n    messageSchema?: Schema;\n    open?(ws: NifraWebSocket<Data>): MaybePromise<void>;\n    message?(ws: NifraWebSocket<Data>, data: WsMessageInput<Schema>): MaybePromise<void>;\n    /** Inbound frame that failed JSON parse or `messageSchema` validation (only fires when a schema is\n     * set). `raw` is the original frame; `issues` are the Standard Schema issues (one synthetic issue for\n     * a JSON parse failure). Omit to silently drop invalid frames. */\n    onInvalidMessage?(ws: NifraWebSocket<Data>, issues: ReadonlyArray<StandardIssue>, raw: WebSocketData): MaybePromise<void>;\n    close?(ws: NifraWebSocket<Data>, code: number, reason: string): MaybePromise<void>;\n    error?(ws: NifraWebSocket<Data>, error: unknown): MaybePromise<void>;\n}",
+    "signature": "export interface WebSocketHandler<Data = unknown, Env = unknown, Schema extends StandardSchemaV1 | undefined = undefined, Send extends StandardSchemaV1 | undefined = undefined> {\n    /**\n     * Cross-site WebSocket hijacking (CSWSH) guard — checked BEFORE `upgrade()`. A browser does not\n     * apply CORS to WebSocket handshakes and DOES send the page's cookies, so without an Origin check\n     * any site can open an authenticated socket to your app. Set this to lock the route to known\n     * origins: a string allow-list (exact `Origin` header match) or a predicate. A request whose\n     * `Origin` doesn't match (or is absent, for the allow-list form) is rejected with `403` before any\n     * per-connection work.\n     *\n     * **When omitted, the default is same-origin:** a cross-origin BROWSER handshake (an `Origin` header\n     * whose host differs from the request's) is rejected with `403`. Non-browser clients (no `Origin`) and\n     * same-origin browsers pass. Set this to allow specific cross-origin clients, or `() => true` for a\n     * genuinely public socket. Non-browser clients can spoof `Origin`, so this is a browser-CSWSH defense,\n     * not authentication — pair it with auth in `upgrade()`.\n     */\n    allowedOrigins?: ReadonlyArray<string> | ((origin: string | null) => boolean);\n    /**\n     * Runs in the HTTP request context **before** the upgrade (and after {@link allowedOrigins}) — the\n     * place to authenticate or rate-limit. Return the initial per-connection `data` (→ `ws.data`), or a\n     * `Response` to **reject** the upgrade (the client never connects). Omit to accept with\n     * `data: undefined`. A thrown error rejects with a flat 500.\n     */\n    upgrade?(c: WebSocketContext<Env>): MaybePromise<Data | Response>;\n    /**\n     * Contract-first messages: a Standard Schema (`t`, zod, valibot, …) validating each **inbound** frame.\n     * Text frames are parsed as JSON first. When set, `message` receives the validated, typed value; a\n     * non-JSON or schema-invalid frame is routed to `onInvalidMessage` (or dropped if that's omitted).\n     */\n    messageSchema?: Schema;\n    /**\n     * The **outbound** frame contract (server → client), a Standard Schema. Purely type-level: it types\n     * the frames the typed client's `.ws()` handle receives, and documents what this route pushes. The\n     * server does NOT runtime-validate its own sends - the inbound `messageSchema` guards the trust\n     * boundary; outbound honesty is the handler author's code, checked by tests.\n     */\n    sendSchema?: Send;\n    open?(ws: NifraWebSocket<Data>): MaybePromise<void>;\n    message?(ws: NifraWebSocket<Data>, data: WsMessageInput<Schema>): MaybePromise<void>;\n    /** Inbound frame that failed JSON parse or `messageSchema` validation (only fires when a schema is\n     * set). `raw` is the original frame; `issues` are the Standard Schema issues (one synthetic issue for\n     * a JSON parse failure). Omit to silently drop invalid frames. */\n    onInvalidMessage?(ws: NifraWebSocket<Data>, issues: ReadonlyArray<StandardIssue>, raw: WebSocketData): MaybePromise<void>;\n    close?(ws: NifraWebSocket<Data>, code: number, reason: string): MaybePromise<void>;\n    error?(ws: NifraWebSocket<Data>, error: unknown): MaybePromise<void>;\n}",
     "doc": "/** A WebSocket route's lifecycle. All callbacks optional; only `message` is needed for an echo. */"
   },
   {
     "name": "WebSocketUpgradeOutcome",
     "kind": "type",
     "package": "@nifrajs/core",
-    "signature": "export type WebSocketUpgradeOutcome = {\n    readonly kind: \"pass\";\n} | {\n    readonly kind: \"reject\";\n    readonly response: Response;\n} | {\n    readonly kind: \"upgrade\";\n    readonly handler: WebSocketHandler;\n    readonly data: unknown;\n    /** The app's pub/sub registry — the adapter wires `ws.subscribe` + close-cleanup to it. */\n    readonly pubsub: TopicRegistry;\n};",
+    "signature": "export type WebSocketUpgradeOutcome = {\n    readonly kind: \"pass\";\n} | {\n    readonly kind: \"reject\";\n    readonly response: Response;\n} | {\n    readonly kind: \"upgrade\";\n    readonly handler: WebSocketHandler;\n    readonly data: unknown;\n    /** The app's pub/sub registry — the adapter wires `ws.subscribe` + close-cleanup to it. */\n    readonly pubsub: TopicRegistry;\n    /** The installed runtime's {@link attachWebSocket}, carried on the outcome so an adapter can wire\n     * a standard socket without a static import of the WS implementation (which would defeat the\n     * `.use(websocket())` tree-shaking). `@nifrajs/workers` may import `attachWebSocket` directly instead. */\n    readonly attach: WsAttach;\n};",
     "doc": "/**\n * The outcome of `app.resolveWebSocketUpgrade(req)` — for serving adapters:\n * - `pass` — not a WS upgrade for a registered WS route; handle as a normal HTTP request.\n * - `reject` — a WS route matched but `upgrade()` rejected (or the path was malformed); return `response`.\n * - `upgrade` — perform the runtime upgrade, then dispatch the native socket's events to `handler`,\n *   seeding `ws.data` with `data`.\n */"
   },
   {
@@ -9809,6 +10473,20 @@
     "signature": "export declare function withISR(app: ISRApp, options: ISROptions): (req: Request, platform?: ISRPlatform) => Promise<Response>;",
     "doc": "/**\n * Wrap a nifra app with **Incremental Static Regeneration**: a cacheable page is served from\n * {@link CacheStore} when fresh, served **stale while a fresh copy regenerates in the background**\n * (`platform.waitUntil` on edge), or rendered + stored on a miss. Framework-agnostic (it caches the\n * rendered bytes). Returns a `fetch(req, platform?)` handler — hand it to `Bun.serve`/the Workers\n * `export default`, etc. Regeneration is single-flight per key (no stampede on a hot stale page).\n *\n * Each route's freshness comes from the `revalidate` header the app sets (per-route\n * `export const revalidate`), falling back to `options.revalidate`. Only full-document `text/html`\n * GET 200s are cached; everything else (assets, data-mode GETs, redirects, errors) passes through.\n */"
   },
+  {
+    "name": "WithPrincipal",
+    "kind": "type",
+    "package": "@nifrajs/better-auth",
+    "signature": "export type WithPrincipal<S extends AnyServer, P> = S extends Server<infer R, infer C> ? Server<R, C & {\n    principal: P;\n}> : never;",
+    "doc": "/** Add `{ principal: P }` to a server's context while preserving its route registry `R` (no collapse to\n * `any`). This is the type that makes `.use(authed(auth))` thread a NON-NULL `c.principal`. */"
+  },
+  {
+    "name": "withResponseValidation",
+    "kind": "function",
+    "package": "@nifrajs/client",
+    "signature": "export declare function withResponseValidation(app: unknown, bridge: FetchFn): FetchFn;",
+    "doc": "/**\n * Wrap the in-process bridge so every response is checked against its route's declared contract.\n * Throws at wrap time when the app cannot enumerate routes - a misconfiguration, not a soft skip.\n */"
+  },
   {
     "name": "withRouteAssurance",
     "kind": "function",
@@ -9862,11 +10540,38 @@
     "signature": "export declare function writeScaffoldRoute(cwd: string, urlPath: string, framework: Framework): Promise<ScaffoldWriteResult>;",
     "doc": "/** Write a scaffolded route stub when the framework has a verified ready-to-write body. The write is\n * intentionally conservative: it refuses non-JSX stubs (where we only return contract guidance) and\n * uses `wx`, so an agent cannot overwrite user work by accident. */"
   },
+  {
+    "name": "WsAttach",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type WsAttach = (socket: StandardWebSocket, handler: WebSocketHandler, data: unknown, options: {\n    openNow: boolean;\n    pubsub: TopicRegistry;\n}) => NifraWebSocket;",
+    "doc": "/** The socket-wiring signature the upgrade outcome carries (the installed runtime's `attach`). */"
+  },
+  {
+    "name": "WsCallOptions",
+    "kind": "interface",
+    "package": "@nifrajs/client",
+    "signature": "export interface WsCallOptions {\n    query?: Record<string, string | number | boolean>;\n    /** WebSocket subprotocols. A browser handshake cannot carry custom headers - authenticate via\n     * `upgrade()` reading cookies/query/subprotocol, not an Authorization header. */\n    protocols?: string | string[];\n    /** Abort to close the socket (same effect as calling `close()`). */\n    signal?: AbortSignal;\n    /** Socket-level failures (connection refused, abnormal close). */\n    onError?: (error: unknown) => void;\n}"
+  },
+  {
+    "name": "WsHandle",
+    "kind": "interface",
+    "package": "@nifrajs/client",
+    "signature": "export interface WsHandle<In, Out> {\n    /** Send one typed frame (JSON-encoded). Queued until the socket opens, so it never throws. */\n    send(message: In): void;\n    /** Async-iterate incoming typed frames. Ends when the socket closes (or `signal` aborts). */\n    messages(options?: {\n        signal?: AbortSignal;\n    }): AsyncIterableIterator<Out>;\n    /** Callback form of {@link messages}; returns an unsubscribe. */\n    onMessage(callback: (message: Out) => void): () => void;\n    /** Resolves when the socket is open (rejects on a connect failure). */\n    readonly opened: Promise<void>;\n    close(code?: number, reason?: string): void;\n    /** The underlying socket, for anything off the typed contract (binary frames, bufferedAmount…). */\n    readonly raw: WebSocket;\n}",
+    "doc": "/**\n * A live typed WebSocket connection to an `app.ws()` route. `send` accepts the route's\n * `messageSchema` input type (validated server-side at the trust boundary); received frames are\n * typed from its `sendSchema` and JSON-parsed. Binary frames are not part of the typed contract\n * and are ignored by `messages()`/`onMessage` - use `raw` for them.\n */"
+  },
+  {
+    "name": "WsRouteInfoFor",
+    "kind": "type",
+    "package": "@nifrajs/core",
+    "signature": "export type WsRouteInfoFor<Path extends string, In extends StandardSchemaV1 | undefined, Out extends StandardSchemaV1 | undefined> = {\n    readonly params: Params<Path>;\n    readonly query: never;\n    readonly body: never;\n    readonly output: never;\n    readonly errors: unknown;\n    readonly sse: never;\n    readonly ws: {\n        readonly in: In extends StandardSchemaV1 ? InferInput<In> : unknown;\n        readonly out: Out extends StandardSchemaV1 ? InferOutput<Out> : unknown;\n    };\n};",
+    "doc": "/**\n * The registry entry for a WebSocket route (stored under the pseudo-method key `\"WS\"`, so WS routes\n * ride the same path → method map as HTTP routes - no extra Server generic). `in` is the client →\n * server frame type: the `messageSchema`'s INPUT side, since that is what goes on the wire before\n * validation transforms it. `out` is the server → client frame type from `sendSchema` (a type-level\n * contract; the server's own sends are not runtime-validated). Either is `unknown` when undeclared.\n */"
+  },
   {
     "name": "WsRuntime",
     "kind": "interface",
     "package": "@nifrajs/core",
-    "signature": "export interface WsRuntime {\n    /** `wrapWebSocketMessageValidation` — applied once at `app.ws()` registration. */\n    wrapHandler(handler: WebSocketHandler): WebSocketHandler;\n    /** One in-process pub/sub registry per app (backs `ws.subscribe` + `app.publish`). */\n    createTopics(): TopicRegistry;\n    /** The Bun `websocket` config for `listen()` when the app has WS routes. */\n    bunHandlers(topics: TopicRegistry): BunWsHandlers;\n    /** `attachWebSocket` — wires a standard server socket (Workers `WebSocketPair`) to a handler. */\n    attach(socket: StandardWebSocket, handler: WebSocketHandler, data: unknown, options: {\n        openNow: boolean;\n        pubsub: TopicRegistry;\n    }): NifraWebSocket;\n}",
+    "signature": "export interface WsRuntime {\n    /** `wrapWebSocketMessageValidation` - applied once at `app.ws()` registration. */\n    wrapHandler(handler: WebSocketHandler): WebSocketHandler;\n    /** One in-process pub/sub registry per app (backs `ws.subscribe` + `app.publish`). */\n    createTopics(): TopicRegistry;\n    /** The Bun `websocket` config for `listen()` when the app has WS routes. */\n    bunHandlers(topics: TopicRegistry): BunWsHandlers;\n    /** `attachWebSocket` - wires a standard server socket (Workers `WebSocketPair`) to a handler. */\n    attach(socket: StandardWebSocket, handler: WebSocketHandler, data: unknown, options: {\n        openNow: boolean;\n        pubsub: TopicRegistry;\n    }): NifraWebSocket;\n}",
     "doc": "/** What `@nifrajs/core/ws` registers: everything `server.ts` and `toFetchHandler` need at runtime. */"
   }
 ]