@nifrajs/core 3.1.0 → 3.3.0

package/dist/server/server.js

@@ -1,11 +1,13 @@
 import { admitDeadline, createRequestBudget, createUnboundedRequestBudget, NIFRA_DEADLINE_HEADER, } from "../budget.js";
 import { FrameworkError, RouteConfigError } from "../errors.js";
-import { CAPABILITY_GUARD, createCapabilityGuard, DEFAULT_CAPABILITY_INTERCEPTOR_TIMEOUT_MS, normalizeRouteCapabilities, } from "../internal/capability-runtime.js";
-import { assuranceDeclarationsOf, assuranceEvidenceFor, NIFRA_ASSURANCE_IDS, validEvidenceId, } from "../internal/route-assurance.js";
+import { DEFAULT_CAPABILITY_INTERCEPTOR_TIMEOUT_MS, } from "../internal/capability-runtime.js";
+import { assuranceDeclarationsOf, assuranceEvidenceFor, } from "../internal/route-assurance.js";
 import { RouteCatalog } from "../internal/route-catalog.js";
+import { compileRouteOptions } from "../internal/route-compiler.js";
 import { compileRouteExecutionPlan, } from "../internal/route-execution.js";
+import { compileRouteProgram, executeRouteProgram } from "../internal/route-program.js";
 import { isSameOriginRequest } from "../internal/same-origin.js";
-import { compileRoutePattern, decodeRouteParams } from "../router/pattern.js";
+import { decodeRouteParams } from "../router/pattern.js";
 import { EMPTY_PARAMS, Router } from "../router/router.js";
 import { emitRequestErrorLog, renderBareError } from "./bare-error-lane.js";
 import { assertByteLimit, markTransportCap, markTrustedBodyFraming, UNLIMITED_BODY_BYTES, } from "./body.js";
@@ -14,11 +16,12 @@ import { hasLowercaseHeaderKeysMark, headerKeysAllLowercase, markLowercaseHeader
 import { headerObjectOf } from "./headers.js";
 import { jsonError, pathnameOf, plainError, urlPartsOf } from "./http.js";
 import { withStaticNodeHeaders } from "./node-outcome.js";
-import { isUrlEncodedForm, queryObjectOf, readBoundedForm, searchOf, } from "./query.js";
-import { RequestContext, readBodyFramed, readBoundedJsonSource } from "./request-context.js";
+import { queryObjectOf, searchOf } from "./query.js";
+import { RequestContext, readBodyFramed } from "./request-context.js";
 import { applyStaticResponseHeaders, buildStaticResponseHeaders, fusedRespond, fusedRespondNoSet, toResponse, } from "./respond.js";
-import { CONTEXT_SEARCH, CONTEXT_SET, EMPTY_RESPONSE_CONTROLS, getNeverAbortSignal, getUnboundedRequestBudget, headerOf, isResponseResult, requestOf, status, } from "./runtime-core.js";
+import { CONTEXT_SEARCH, CONTEXT_SET, EMPTY_RESPONSE_CONTROLS, getNeverAbortSignal, getUnboundedRequestBudget, headerOf, isResponseResult, requestOf, } from "./runtime-core.js";
 import { normalizeStaticResponseHeaders } from "./static-headers.js";
+import { plainValidationError } from "./validation.js";
 import { INSTALL_EFFECT_LEDGER, INSTALL_IDEMPOTENCY, INSTALL_MCP, INSTALL_NODE_DIRECT, INSTALL_RESPONSE_CONTRACT, INSTALL_RESPONSE_OBSERVER, INSTALL_SSE, INSTALL_WS, NODE_NATIVE_MOUNT, RESOLVE_NODE_MOUNT, } from "./install.js";
 import { jsonLogger } from "./logger.js";
 const functionToString = Function.prototype.toString;
@@ -74,22 +77,13 @@ const STOP_HOOK_TIMEOUT_MS = 5_000;
  * owner, shared with the server-function mount in `@nifrajs/web` - the two used to answer differently
  * for the same request, so a browser that could open a socket was told its POST was cross-origin. */
 const wsSameOrigin = isSameOriginRequest;
-function validationIssues(issues) {
-    const serialized = issues.map((issue) => {
-        const path = issue.path?.map((seg) => String(typeof seg === "object" ? seg.key : seg));
-        return path !== undefined ? { message: issue.message, path } : { message: issue.message };
-    });
-    return { ok: false, error: "validation", issues: serialized };
-}
-/** The 422 as plain data - the shape every lane's response wrapper takes, so a rejected body costs
- * what an accepted one costs: on Node it is written straight to the socket with a `content-length`
- * instead of being built as a `Response` and drained back out. */
-export function plainValidationError(issues) {
-    return status(422, validationIssues(issues));
-}
 // `jsonError`, `urlPartsOf`, `pathnameOf` moved to `./http.ts` (a dependency-free leaf shared with the
 // opt-in request lanes); re-exported so existing importers keep resolving from here.
 export { pathnameOf, urlPartsOf } from "./http.js";
+/** The 422 as plain data - the shape every lane's response wrapper takes, so a rejected body costs
+ * what an accepted one costs: on Node it is written straight to the socket with a `content-length`
+ * instead of being built as a `Response` and drained back out. */
+export { plainValidationError } from "./validation.js";
 // Query-string + urlencoded-form parsing now lives in `./query.ts`; re-exported so existing
 // importers keep resolving `searchOf`/`queryObjectOf`/`QueryValue` from here.
 export { queryObjectOf, searchOf };
@@ -128,20 +122,6 @@ function stripMountPrefix(request, prefix) {
 function responseSet(ctx) {
     return ctx[CONTEXT_SET]() ?? EMPTY_RESPONSE_CONTROLS;
 }
-/**
- * A `derive` that answered with a response rather than a context extension - `status(...)`, or a bare
- * `Response`. The request ends there, on the same lane a `beforeHandle`'s early return takes.
- *
- * `derive` is the one stage that could not exit early: `beforeHandle` says "done" by returning a
- * value, but a derive's return value IS the extension, so the only way out was `throw`ing a
- * `Response` - which measured as the single most expensive way to answer (the `Response` object
- * costs ~40% of the rejection lane; see `PlainRender`). Neither shape had a meaning here before:
- * `Object.assign(ctx, response)` copies nothing (a `Response`'s properties live on its prototype),
- * so a derive that returned one silently fell through to the handler it meant to prevent.
- */
-function isDeriveEarlyExit(extension) {
-    return isResponseResult(extension) || extension instanceof Response;
-}
 function isContextlessNoArgArrow(handler) {
     if (handler.length !== 0)
         return false;
@@ -255,6 +235,13 @@ export class Server {
      * Created by the first `app.ws()` via the `@nifrajs/core/ws` runtime - `undefined` until then, so a
      * no-WebSocket app never constructs (or bundles) it. */
     topics;
+    /** True once any `app.ws()` route sets `validateSend: true` - the one case where a broadcast frame
+     * is validated (and possibly dropped) per socket, so `app.publish` must stay on the JS registry loop
+     * rather than delegate to Bun's native `server.publish`. */
+    wsHasValidatedSend = false;
+    /** Bun's native topic broadcast, bound by `listen()` in native-pubsub mode; `app.publish` uses it
+     * instead of the JS registry. `undefined` off Bun, before `listen()`, or with a validated-send route. */
+    nativePublish;
     maxBodyBytes;
     protoPoisoning;
     /** `trustBodyFraming`: mark every `app.fetch` request as runtime-framed (see ServerOptions). */
@@ -861,6 +848,10 @@ export class Server {
         if (handler.validateSend === true && handler.sendSchema === undefined) {
             throw new RouteConfigError("INVALID_WS_SEND_VALIDATION", `route WS ${path}: validateSend requires sendSchema`);
         }
+        // A validated-send route makes broadcast bytes route-dependent (drop-on-invalid per socket), so the
+        // whole app forgoes native pub/sub and keeps the JS registry loop that runs each send through the sender.
+        if (handler.validateSend === true)
+            this.wsHasValidatedSend = true;
         this.topics ??= runtime.createTopics();
         // A `messageSchema` wraps `message` with validation once, here - every adapter then dispatches
         // already-validated, typed messages (Bun/Deno/Node/Workers) with no per-adapter code.
@@ -876,6 +867,12 @@ export class Server {
      * an external fan-out (Redis, a Durable Object) to this. A no-op when nobody is subscribed.
      */
     publish(topic, data) {
+        // Native-pubsub mode (Bun, no validated-send route): one native broadcast to every subscriber, no
+        // per-connection JS loop. Bound only after `listen()`; before that (or off Bun) the registry runs.
+        if (this.nativePublish !== undefined) {
+            this.nativePublish(topic, data);
+            return;
+        }
         // No `app.ws()` yet ⇒ no registry and necessarily no subscribers - a publish is a no-op anyway.
         this.topics?.publish(topic, data);
     }
@@ -912,205 +909,88 @@ export class Server {
         this.catalog.addBatch(staged);
     }
     prepareRoute(method, path, schema, handler) {
-        const pattern = compileRoutePattern(path);
-        // Resolved here, once: `undefined` past this point means the route declared `"unlimited"`, NOT
-        // "nothing declared". Readers fall back to UNLIMITED_BODY_BYTES accordingly.
-        let bodyLimit = this.maxBodyBytes;
-        const invalidBodyLimit = (message) => {
-            throw new RouteConfigError("INVALID_BODY_LIMIT", `route ${method} ${path}: ${message}`);
-        };
-        if (schema?.bodyLimitReason !== undefined && schema.bodyLimit !== "unlimited") {
-            invalidBodyLimit('bodyLimitReason is only valid with bodyLimit: "unlimited"');
-        }
-        if (schema?.bodyLimit === "unlimited") {
-            if (typeof schema.bodyLimitReason !== "string" ||
-                schema.bodyLimitReason.trim().length === 0) {
-                invalidBodyLimit('bodyLimit: "unlimited" requires a non-empty bodyLimitReason');
-            }
-            if (schema.body !== undefined) {
-                invalidBodyLimit('bodyLimit: "unlimited" cannot be used with a body schema; use a finite cap');
-            }
-            if (schema.idempotency !== undefined) {
-                invalidBodyLimit('bodyLimit: "unlimited" cannot be used with idempotency');
-            }
-            bodyLimit = undefined;
-        }
-        else if (schema?.bodyLimit !== undefined) {
-            try {
-                assertByteLimit(schema.bodyLimit, "route bodyLimit");
-            }
-            catch {
-                invalidBodyLimit('bodyLimit must be a non-negative safe integer or "unlimited"');
-            }
-            bodyLimit = schema.bodyLimit;
-        }
-        const capabilities = normalizeRouteCapabilities(schema?.capabilities);
-        const handlerAssurance = assuranceDeclarationsOf(handler);
-        const invalidHandlerScope = handlerAssurance.find((declaration) => declaration.scope !== "plugin");
-        if (invalidHandlerScope !== undefined) {
-            throw new RouteConfigError("INVALID_ASSURANCE", `route handler assurance must use plugin scope (received ${invalidHandlerScope.scope})`);
-        }
-        const authenticated = assuranceEvidenceFor([...this.activeAssurance, ...handlerAssurance, ...this.globalAssurance], method, path).some((evidence) => evidence.id === NIFRA_ASSURANCE_IDS.AUTHENTICATED);
-        const routeDecorations = { ...this.decorations };
-        if (capabilities.length > 0) {
-            routeDecorations[CAPABILITY_GUARD] = createCapabilityGuard(capabilities, method, path, this.onCapabilityUse, this.idempotencyRuntime?.trackEffect, Object.freeze([...this.capabilityInterceptors]), Object.freeze([...this.capabilityObservers]));
-        }
-        const hasDecorations = Reflect.ownKeys(routeDecorations).length > 0;
-        // An idempotency route runs a dedupe lane that must buffer the body and capture the response, so it
-        // never takes the fused/native fast path - force it onto the portable matched lane (which routes
-        // through `fetchMatched`, where the dedupe wrapper lives). Fail closed: a route may not declare
-        // idempotency unless the idempotency runtime is installed, so the safety gate can never be silently
-        // dropped by a missing plugin.
-        if (schema?.idempotency !== undefined && this.idempotencyRuntime === undefined) {
-            throw new RouteConfigError("INVALID_IDEMPOTENCY", "route declares idempotency but the idempotency plugin is not installed; add .use(idempotency())");
-        }
-        const idempotent = this.idempotencyRuntime?.resolve(schema, authenticated, this.maxBodyBytes);
-        // A ledgered route (capabilities declared + `.use(effectLedger())`) needs a per-request
-        // context to carry the ledger and a settle step to seal + sink it, so it too leaves the
-        // fused/contextless fast path. Resolved per route, at registration - like the capability guard.
-        const ledgered = this.effectLedgerRuntime?.resolve(capabilities, method, path);
-        // A checked response schema needs the handler's VALUE before it becomes bytes, and the fused and
-        // native lanes exist precisely to skip that step. So a contracted route leaves them - the same
-        // structural trade an idempotent route makes above. The check itself is not the cost: a compiled
-        // validator measures ~100ns/response, within benchmark noise on any route these lanes already
-        // exclude (middleware, derives, lifecycle hooks).
-        const runtime = this.responseContractRuntime;
-        const contracted = runtime !== undefined && schema?.response !== undefined
-            ? { runtime, schema: schema.response }
-            : undefined;
-        const bare = schema?.params === undefined &&
-            schema?.headers === undefined &&
-            schema?.body === undefined &&
-            schema?.query === undefined &&
-            idempotent === undefined &&
-            ledgered === undefined &&
-            contracted === undefined &&
-            this.derives.length === 0 &&
-            this.beforeHandleHooks.length === 0 &&
-            this.afterHandleHooks.length === 0 &&
-            this.onErrorHooks.length === 0;
-        // A route whose ONLY lifecycle step is a query schema can fuse too: the parse + validate +
-        // handler + respond collapse into one closure with no lifecycle promise on the sync path. The
-        // guards mirror the `query` lane below PLUS everything the fused dispatch skips: around hooks,
-        // the idempotency/ledger wrappers, and validation-error recovery (schema or server default) -
-        // the fused invalid path is exactly `validationError(issues)`, so any recovery semantics keep
-        // the generic lane.
-        const fusedQuery = !bare &&
-            contracted === undefined &&
-            schema?.query !== undefined &&
-            schema.body === undefined &&
-            schema.params === undefined &&
-            schema.headers === undefined &&
-            schema.onValidationError === undefined &&
-            this.defaultOnValidationError === undefined &&
-            idempotent === undefined &&
-            ledgered === undefined &&
-            this.derives.length === 0 &&
-            this.beforeHandleHooks.length === 0 &&
-            this.afterHandleHooks.length === 0 &&
-            this.onErrorHooks.length === 0 &&
-            this.aroundHooks.length === 0;
-        const bodyOnly = contracted === undefined &&
-            schema?.body !== undefined &&
-            schema.query === undefined &&
-            schema.params === undefined &&
-            schema.headers === undefined &&
-            this.derives.length === 0 &&
-            this.beforeHandleHooks.length === 0 &&
-            this.afterHandleHooks.length === 0 &&
-            this.onErrorHooks.length === 0;
-        const fusedBody = !bare &&
-            bodyOnly &&
-            schema.onValidationError === undefined &&
-            this.defaultOnValidationError === undefined &&
-            idempotent === undefined &&
-            ledgered === undefined &&
-            this.aroundHooks.length === 0;
-        // Body-only routes still need an async body read, but eligible routes can compile the validation +
-        // handler continuation once. The runner keeps the bounded parser and all error semantics while
-        // avoiding the generic entry/schema/lifecycle dispatch on Bun, Deno, and Node-direct.
+        const compiled = compileRouteOptions({
+            maxBodyBytes: this.maxBodyBytes,
+            activeAssurance: this.activeAssurance,
+            globalAssurance: this.globalAssurance,
+            decorations: this.decorations,
+            onCapabilityUse: this.onCapabilityUse,
+            capabilityInterceptors: this.capabilityInterceptors,
+            capabilityObservers: this.capabilityObservers,
+            effectLedgerRuntime: this.effectLedgerRuntime,
+            idempotencyRuntime: this.idempotencyRuntime,
+            responseContractRuntime: this.responseContractRuntime,
+            derives: this.derives,
+            beforeHandleHooks: this.beforeHandleHooks,
+            afterHandleHooks: this.afterHandleHooks,
+            onErrorHooks: this.onErrorHooks,
+            aroundHooks: this.aroundHooks,
+            defaultOnValidationError: this.defaultOnValidationError,
+        }, method, path, schema, handler);
+        const { pattern, bodyLimit, capabilities, routeDecorations, hasDecorations, idempotent, ledgered, responseContract, lanes, routeAssurance, } = compiled;
+        const { bare, fusedQuery, fusedBody } = lanes;
         const fusedBodyRunner = fusedBody
-            ? this.buildFusedBodyRunner(handler, schema.body, hasDecorations ? routeDecorations : undefined, bodyLimit ?? UNLIMITED_BODY_BYTES)
+            ? this.buildFusedBodyRunner(handler, schema?.body, hasDecorations ? routeDecorations : undefined, bodyLimit ?? UNLIMITED_BODY_BYTES)
             : undefined;
+        // Fused lifecycle lanes: derive + before (with or without an after), and body + the same shape.
+        // The lane selectors in `selectRouteLanes` are exhaustive about the lifecycleHookLane /
+        // body-derive-before-after eligibility, so we only need to check the lane and the hook counts.
+        const lifecycleHookLane = lanes.lifecycleHookLane;
+        const isFusedLifecycle = lifecycleHookLane !== undefined && this.derives.length === 1;
+        const isFusedBodyLifecycle = lanes.fusedLane === "body-derive-before" || lanes.fusedLane === "body-derive-before-after";
         const fusedWeb = bare && this.aroundHooks.length === 0
             ? this.buildFusedWeb(handler, hasDecorations ? routeDecorations : undefined, isContextlessNoArgArrow(handler), bodyLimit ?? UNLIMITED_BODY_BYTES)
             : fusedQuery
-                ? this.buildFusedQueryWeb(handler, hasDecorations ? routeDecorations : undefined, schema.query, bodyLimit ?? UNLIMITED_BODY_BYTES)
+                ? this.buildFusedQueryWeb(handler, hasDecorations ? routeDecorations : undefined, schema?.query, bodyLimit ?? UNLIMITED_BODY_BYTES)
                 : fusedBody
                     ? this.buildFusedBodyWeb(fusedBodyRunner)
-                    : undefined;
-        const contextless = bare && this.aroundHooks.length === 0 && isContextlessNoArgArrow(handler);
-        // The body and query lanes finalize the handler's result themselves, so a contracted route takes
-        // the general lifecycle lane instead - one place owns the check rather than three.
-        const lane = bare
-            ? "bare"
-            : bodyOnly
-                ? "body"
-                : contracted === undefined &&
-                    schema?.body === undefined &&
-                    schema?.query !== undefined &&
-                    schema.params === undefined &&
-                    schema.headers === undefined &&
-                    this.derives.length === 0 &&
-                    this.beforeHandleHooks.length === 0 &&
-                    this.afterHandleHooks.length === 0 &&
-                    this.onErrorHooks.length === 0
-                    ? "query"
-                    : "lifecycle";
-        // Lifecycle routes with no params schema are the common middleware shape: a derive/before hook
-        // plus an optional query or body schema. Select their complete validation stage at registration
-        // so the request path never re-checks params/body presence. Parameter-schema routes retain the
-        // generic lifecycle runner until their more involved recovery matrix is selected explicitly.
-        const lifecycleLane = lane !== "lifecycle" || schema?.params !== undefined || schema?.headers !== undefined
-            ? undefined
-            : schema?.body !== undefined
-                ? schema.query !== undefined
-                    ? "body-query"
-                    : "body"
-                : schema?.query !== undefined
-                    ? "query"
-                    : "hooks";
-        // The realistic middleware shape is commonly exactly one synchronous-or-async derive followed
-        // by one before hook. Keep the generic runner for every route that can observe decorations,
-        // after hooks, error hooks, or response contracts; this lane only removes the two per-request
-        // hook-loop dispatches and preserves the same async continuations and error handling.
-        const lifecycleHookLane = lane === "lifecycle" &&
-            contracted === undefined &&
-            !hasDecorations &&
-            this.derives.length === 1 &&
-            this.beforeHandleHooks.length === 1 &&
-            this.afterHandleHooks.length === 0 &&
-            this.onErrorHooks.length === 0
-            ? "derive-before"
-            : undefined;
+                    : isFusedBodyLifecycle
+                        ? this.buildFusedBodyDeriveBeforeAfter(handler, this.derives[0], this.beforeHandleHooks[0], this.afterHandleHooks[0], schema?.body, bodyLimit ?? UNLIMITED_BODY_BYTES)
+                        : isFusedLifecycle && lifecycleHookLane === "derive-before"
+                            ? this.buildFusedDeriveBefore(handler, this.derives[0], this.beforeHandleHooks[0], schema?.query, bodyLimit ?? UNLIMITED_BODY_BYTES)
+                            : isFusedLifecycle && lifecycleHookLane === "derive-before-after"
+                                ? this.buildFusedDeriveBeforeAfter(handler, this.derives[0], this.beforeHandleHooks[0], this.afterHandleHooks[0], schema?.query, bodyLimit ?? UNLIMITED_BODY_BYTES)
+                                : undefined;
+        const program = compileRouteProgram({
+            schema,
+            handler: handler,
+            derives: this.derives,
+            beforeHandle: this.beforeHandleHooks,
+            afterHandle: this.afterHandleHooks,
+            onError: this.onErrorHooks,
+            decorations: routeDecorations,
+            hasDecorations,
+            bodySchema: schema?.body,
+            bodyLimit,
+            responseContract,
+        });
+        const contextless = lanes.bare && this.aroundHooks.length === 0 && isContextlessNoArgArrow(handler);
         const execution = compileRouteExecutionPlan({
-            lane,
+            lane: lanes.lane,
             contextless,
             hasAround: this.aroundHooks.length > 0,
             hasLedger: ledgered !== undefined,
-            lifecycleLane,
             fusedWeb,
             fusedBody: fusedBodyRunner,
-            fusedLane: fusedWeb === undefined ? undefined : fusedQuery ? "query" : fusedBody ? "body" : "bare",
+            fusedLane: lanes.fusedLane,
         });
         const registeredEntry = {
-            // (context: never) => unknown -> InternalHandler: the framework invokes it
-            // with the concrete RawContext the typed handler expects, so this is sound.
             handler: handler,
             schema,
             bodyLimit,
             idempotent,
             ledgered,
-            responseContract: contracted,
+            responseContract,
             derives: [...this.derives],
             decorations: routeDecorations,
             hasDecorations,
             beforeHandle: [...this.beforeHandleHooks],
             afterHandle: [...this.afterHandleHooks],
             onError: [...this.onErrorHooks],
-            lifecycleHookLane,
+            lifecycleHookLane: lanes.lifecycleHookLane,
             around: [...this.aroundHooks],
             execution,
+            program,
         };
         const descriptor = {
             method,
@@ -1119,64 +999,13 @@ export class Server {
             ...(capabilities.length > 0 ? { capabilities } : {}),
             ...(schema?.family === true ? { family: true } : {}),
         };
-        const routeAssurance = [...this.activeAssurance, ...handlerAssurance];
-        if (contracted?.runtime.mode === "enforce" && schema?.response !== undefined) {
-            routeAssurance.push(Object.freeze({
-                id: NIFRA_ASSURANCE_IDS.RESPONSE_CONTRACT,
-                source: "response-contract",
-                scope: "plugin",
-            }));
-        }
-        // Inline `schema.assurance`: the route DECLARES its enforcement evidence adjacent to the handler, so an
-        // in-handler-guarded route satisfies a policy `require:` clause without a `withRouteAssurance` middleware
-        // rewrite. Each id becomes route-scoped `declared` evidence (invalid ids fail closed at registration).
-        for (const id of schema?.assurance ?? []) {
-            if (!validEvidenceId(id)) {
-                throw new Error(`route assurance: invalid evidence id ${JSON.stringify(id)} on ${method} ${path} (use lowercase dot/dash segments)`);
-            }
-            const declared = { id, source: "declared", scope: "plugin" };
-            Object.defineProperty(declared, "provenance", {
-                value: "declared",
-                enumerable: false,
-                configurable: false,
-                writable: false,
-            });
-            routeAssurance.push(Object.freeze(declared));
-        }
-        // Two ways a route proves its body is bounded, both enforced by the core at read time:
-        // `schema.body` (the validated read is bounded) and an explicit finite `schema.bodyLimit` (the
-        // transport cap shadows every reader, including a raw `c.req.body` stream that a Content-Length
-        // middleware cannot bound).
-        // `bodyLimit: "unlimited"` is rejected above for schema and idempotency routes. The remaining
-        // exemption is schema-less streaming/upload work, so it publishes NOTHING: there is no finite
-        // framework byte ceiling for assurance to attest and the application protocol owns that bound.
-        // The server-wide `maxBodyBytes` default is not evidence either. It applies to every route
-        // whether or not anyone thought about it, so publishing it would make the id pass everywhere and
-        // prove nothing; this evidence marks a bound the route chose.
-        const unlimitedBody = schema?.bodyLimit === "unlimited";
-        if (!unlimitedBody && (schema?.body !== undefined || typeof schema?.bodyLimit === "number")) {
-            routeAssurance.push(Object.freeze({
-                id: NIFRA_ASSURANCE_IDS.BODY_BOUNDED,
-                source: "route-schema",
-                scope: "plugin",
-            }));
-        }
-        // Declaring `schema.idempotency` is evidence for request replay only. It deliberately never proves
-        // durable command execution; that stronger evidence belongs to a command/outbox adapter.
-        if (schema?.idempotency !== undefined) {
-            routeAssurance.push(Object.freeze({
-                id: NIFRA_ASSURANCE_IDS.IDEMPOTENCY_KEY,
-                source: "route-schema",
-                scope: "plugin",
-            }));
-        }
         return {
             method,
             path,
             pattern,
             entry: registeredEntry,
             descriptor,
-            assurance: Object.freeze(routeAssurance),
+            assurance: routeAssurance,
         };
     }
     /** The idempotency lane's bridge back into the normal matched lanes, resolved to a concrete Response
@@ -1341,14 +1170,37 @@ export class Server {
             return route;
         // Rebuild with the SAME builder that produced the closure - rebinding a query-fused route as
         // bare would silently drop its validation.
-        const fusedBody = entry.execution.fusedLane === "body"
+        const lane = entry.execution.fusedLane;
+        // Type-erase the lane so each `===` branch sees the full union, not the narrowed remainder.
+        const laneName = lane;
+        // Body+lifecycle routes have a fused Web renderer, but no body-only Node renderer: the latter
+        // would bypass derive/before/after because the Node-direct dispatcher prefers `fusedBody` over
+        // the generic execution plan. Only the original body-only lane may populate this slot.
+        const fusedBody = laneName === "body"
             ? this.buildFusedBodyRunner(entry.handler, entry.schema?.body, entry.hasDecorations ? entry.decorations : undefined, entry.bodyLimit ?? UNLIMITED_BODY_BYTES)
             : undefined;
-        const fusedWeb = entry.execution.fusedLane === "body"
+        const derive = entry.derives[0];
+        const before = entry.beforeHandle[0];
+        const after = entry.afterHandle[0];
+        const fusedWeb = laneName === "body"
             ? this.buildFusedBodyWeb(fusedBody)
-            : entry.execution.fusedLane === "query"
+            : laneName === "query"
                 ? this.buildFusedQueryWeb(entry.handler, entry.hasDecorations ? entry.decorations : undefined, entry.schema?.query, entry.bodyLimit ?? UNLIMITED_BODY_BYTES)
-                : this.buildFusedWeb(entry.handler, entry.hasDecorations ? entry.decorations : undefined, isContextlessNoArgArrow(entry.handler), entry.bodyLimit ?? UNLIMITED_BODY_BYTES);
+                : laneName === "body-derive-before" && derive !== undefined && before !== undefined
+                    ? this.buildFusedBodyDeriveBeforeAfter(entry.handler, derive, before, undefined, entry.schema?.body, entry.bodyLimit ?? UNLIMITED_BODY_BYTES)
+                    : laneName === "body-derive-before-after" &&
+                        derive !== undefined &&
+                        before !== undefined &&
+                        after !== undefined
+                        ? this.buildFusedBodyDeriveBeforeAfter(entry.handler, derive, before, after, entry.schema?.body, entry.bodyLimit ?? UNLIMITED_BODY_BYTES)
+                        : laneName === "derive-before" && derive !== undefined && before !== undefined
+                            ? this.buildFusedDeriveBefore(entry.handler, derive, before, entry.schema?.query, entry.bodyLimit ?? UNLIMITED_BODY_BYTES)
+                            : laneName === "derive-before-after" &&
+                                derive !== undefined &&
+                                before !== undefined &&
+                                after !== undefined
+                                ? this.buildFusedDeriveBeforeAfter(entry.handler, derive, before, after, entry.schema?.query, entry.bodyLimit ?? UNLIMITED_BODY_BYTES)
+                                : this.buildFusedWeb(entry.handler, entry.hasDecorations ? entry.decorations : undefined, isContextlessNoArgArrow(entry.handler), entry.bodyLimit ?? UNLIMITED_BODY_BYTES);
         return {
             ...route,
             entry: {
@@ -1987,7 +1839,7 @@ export class Server {
     /**
      * Route → build context → run. Synchronous through to the handler for a **bare** route
      * (selected by its compiled plan), so a sync handler produces its result with zero promise allocations;
-     * routes with validation/hooks keep the full async {@link runLifecycle}, unchanged.
+     * routes with validation/hooks keep the full compiled route program, unchanged.
      */
     routeAndRun(source, platform, finalize, wrapResponse, onTimeout, webFast) {
         // Routing only needs the pathname. Scan the URL once but keep the two slices in locals instead
@@ -2152,7 +2004,6 @@ export class Server {
     /** The narrowest bare route: a syntactic `() => ...` handler cannot observe the context argument, so
      * successful requests can skip allocating `RequestContext`. Errors still allocate one for logging. */
     // @ts-expect-error TS6133 -- invoked structurally by compiled plans (internal/route-execution.ts)
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: invoked structurally by compiled plans (internal/route-execution.ts)
     runContextlessBare(entry, source, params, search, signal, budget, platform, finalize, wrapResponse) {
         let result;
         try {
@@ -2175,18 +2026,17 @@ export class Server {
             return wrapResponse(err);
         const ctx = new RequestContext(source, params, search, signal, budget, platform, this.maxBodyBytes, this.protoPoisoning);
         this.logRequestError(err, ctx);
-        return wrapResponse(plainError(500, "internal_error"));
+        return this.internalErrorResponse(wrapResponse);
     }
     /**
      * The synchronous fast path selected by a route's execution plan: apply static decorations, call the
      * handler, render the result - **no `await`** unless the handler itself returns a promise. It mirrors
-     * the bare slice of {@link runLifecycle} (which a bare route would otherwise no-op through) and shares
+     * the same error boundary as the compiled route program (which a bare route would otherwise no-op through) and shares
      * {@link logRequestError}; a bare route has no `onError` hooks, so error handling is fully synchronous
      * (a thrown `Response` is control flow; anything else is a logged flat 500). This is where nifra skips
      * the per-request async-frame tax - the same win codegen routers get, but without `eval`.
      */
     // @ts-expect-error TS6133 -- invoked structurally by compiled plans (internal/route-execution.ts)
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: invoked structurally by compiled plans (internal/route-execution.ts)
     runBare(entry, ctx, finalize, wrapResponse) {
         let result;
         try {
@@ -2203,7 +2053,7 @@ export class Server {
         }
         return finalize(result, responseSet(ctx));
     }
-    /** Bare-route error rendering - identical to {@link runLifecycle}'s catch minus the (absent) onError
+    /** Bare-route error rendering - identical to the compiled route program's catch minus the (absent) onError
      * loop: a thrown `Response` is returned as deliberate control flow; anything else is logged + 500. */
     /**
      * Build a route's fused Web renderer. Composition happens once at
@@ -2383,14 +2233,338 @@ export class Server {
             return runHandler(ctx, validation.value);
         };
     }
+    /**
+     * Compile a route's `derive + before` lifecycle to a single closure: the per-request walk through
+     * `runSync` → `runHooksSync` is a stack of 3 frames and 2 `Object.assign`s for what is by far the
+     * most common middleware shape (auth/trace/id derivation, an auth/policy `beforeHandle`). Folding
+     * the same steps into one closure hits the same monomorphic inline-cache site as `buildFusedWeb`,
+     * and `Object.assign(ctx, deriveResult)` becomes one extra property write on the context's already
+     * hot hidden class. Behavior is byte-identical to the compiled route program: the same thrown-value
+     * contract (`Response` is control flow, anything else logs + 500), the same `c.set` semantics, the
+     * same `fusedRespond` for the rendered body. The `LifecycleExecutionLane` guarantee
+     * (`schema.params === undefined && schema.headers === undefined && derives === 1 &&
+     * beforeHandle === 1 && afterHandle === 0 && onError === 0 && !hasResponseContract &&
+     * !hasDecorations`) is enforced by `selectRouteLanes`; this lane is selected ONLY when all of those
+     * hold. A `query` schema (the route declares `{ query }` alongside the hooks) is validated FIRST,
+     * mirroring the compiled route program's stage order; the fused builder runs validate → derive →
+     * before → handler in one frame.
+     */
+    buildFusedDeriveBefore(handler, derive, before, querySchema, maxBodyBytes) {
+        const logError = (err, ctx) => this.bareError(err, ctx, (result, set) => this.wrapWebResponse(toResponse(result, set)), this.wrapWebResponse);
+        return (source, params, search, signal, budget, platform, nativeContext) => {
+            const ctx = nativeContext
+                ? RequestContext.native(source, params, search, maxBodyBytes, platform, this.protoPoisoning)
+                : new RequestContext(source, params, search, signal, budget, platform, maxBodyBytes, this.protoPoisoning);
+            const runHandler = () => {
+                let result;
+                try {
+                    result = handler(ctx);
+                }
+                catch (err) {
+                    return logError(err, ctx);
+                }
+                if (result instanceof Promise) {
+                    return result.then((value) => fusedRespond(value, ctx, this.responseBodyTag, this.staticResponseHeaders, this.onResponseHooks.length === 0), (err) => logError(err, ctx));
+                }
+                return fusedRespond(result, ctx, this.responseBodyTag, this.staticResponseHeaders, this.onResponseHooks.length === 0);
+            };
+            const runBefore = () => {
+                let early;
+                try {
+                    early = before(ctx);
+                }
+                catch (err) {
+                    return logError(err, ctx);
+                }
+                if (early instanceof Promise) {
+                    return early.then((settled) => {
+                        if (settled === undefined)
+                            return runHandler();
+                        return fusedRespond(settled, ctx, this.responseBodyTag, this.staticResponseHeaders);
+                    }, (err) => logError(err, ctx));
+                }
+                if (early === undefined)
+                    return runHandler();
+                return fusedRespond(early, ctx, this.responseBodyTag, this.staticResponseHeaders);
+            };
+            const runDerive = () => {
+                let derived;
+                try {
+                    derived = derive(ctx);
+                }
+                catch (err) {
+                    return logError(err, ctx);
+                }
+                if (derived instanceof Promise) {
+                    return derived.then((settled) => {
+                        if (isResponseResult(settled) || settled instanceof Response) {
+                            return fusedRespond(settled, ctx, this.responseBodyTag, this.staticResponseHeaders);
+                        }
+                        Object.assign(ctx, settled);
+                        return runBefore();
+                    }, (err) => logError(err, ctx));
+                }
+                if (isResponseResult(derived) || derived instanceof Response) {
+                    return fusedRespond(derived, ctx, this.responseBodyTag, this.staticResponseHeaders);
+                }
+                Object.assign(ctx, derived);
+                return runBefore();
+            };
+            if (querySchema === undefined)
+                return runDerive();
+            let validation;
+            try {
+                validation = querySchema["~standard"].validate(queryObjectOf(ctx[CONTEXT_SEARCH]));
+            }
+            catch (err) {
+                return logError(err, ctx);
+            }
+            if (validation instanceof Promise) {
+                return validation.then((settled) => {
+                    if (settled.issues !== undefined)
+                        return this.wrapWebResponse(plainValidationError(settled.issues));
+                    ctx.query = settled.value;
+                    return runDerive();
+                }, (err) => logError(err, ctx));
+            }
+            if (validation.issues !== undefined)
+                return this.wrapWebResponse(plainValidationError(validation.issues));
+            ctx.query = validation.value;
+            return runDerive();
+        };
+    }
+    /**
+     * Same shape as `buildFusedDeriveBefore`, plus one `afterHandle` step. The closure runs (validate) →
+     * derive → before → handler → after in one frame, the shape the realistic middleware route lands on
+     * when it also wants a response transform (e.g. attaching a request id to a successful payload's
+     * headers). `LifecycleExecutionLane` and `selectRouteLanes` guarantee `afterHandle === 1`, the
+     * throw contract is the same as the generic program, and the `after` step is the final transform +
+     * respond the generic program already does.
+     */
+    buildFusedDeriveBeforeAfter(handler, derive, before, after, querySchema, maxBodyBytes) {
+        const logError = (err, ctx) => this.bareError(err, ctx, (result, set) => this.wrapWebResponse(toResponse(result, set)), this.wrapWebResponse);
+        return (source, params, search, signal, budget, platform, nativeContext) => {
+            const ctx = nativeContext
+                ? RequestContext.native(source, params, search, maxBodyBytes, platform, this.protoPoisoning)
+                : new RequestContext(source, params, search, signal, budget, platform, maxBodyBytes, this.protoPoisoning);
+            const runAfter = (result) => {
+                let transformed;
+                try {
+                    transformed = after(result, ctx);
+                }
+                catch (err) {
+                    return logError(err, ctx);
+                }
+                if (transformed instanceof Promise) {
+                    return transformed.then((value) => fusedRespond(value, ctx, this.responseBodyTag, this.staticResponseHeaders, this.onResponseHooks.length === 0), (err) => logError(err, ctx));
+                }
+                return fusedRespond(transformed, ctx, this.responseBodyTag, this.staticResponseHeaders, this.onResponseHooks.length === 0);
+            };
+            const runHandler = () => {
+                let result;
+                try {
+                    result = handler(ctx);
+                }
+                catch (err) {
+                    return logError(err, ctx);
+                }
+                if (result instanceof Promise) {
+                    return result.then((value) => runAfter(value), (err) => logError(err, ctx));
+                }
+                return runAfter(result);
+            };
+            const runBefore = () => {
+                let early;
+                try {
+                    early = before(ctx);
+                }
+                catch (err) {
+                    return logError(err, ctx);
+                }
+                if (early instanceof Promise) {
+                    return early.then((settled) => {
+                        if (settled === undefined)
+                            return runHandler();
+                        return fusedRespond(settled, ctx, this.responseBodyTag, this.staticResponseHeaders);
+                    }, (err) => logError(err, ctx));
+                }
+                if (early === undefined)
+                    return runHandler();
+                return fusedRespond(early, ctx, this.responseBodyTag, this.staticResponseHeaders);
+            };
+            const runDerive = () => {
+                let derived;
+                try {
+                    derived = derive(ctx);
+                }
+                catch (err) {
+                    return logError(err, ctx);
+                }
+                if (derived instanceof Promise) {
+                    return derived.then((settled) => {
+                        if (isResponseResult(settled) || settled instanceof Response) {
+                            return fusedRespond(settled, ctx, this.responseBodyTag, this.staticResponseHeaders);
+                        }
+                        Object.assign(ctx, settled);
+                        return runBefore();
+                    }, (err) => logError(err, ctx));
+                }
+                if (isResponseResult(derived) || derived instanceof Response) {
+                    return fusedRespond(derived, ctx, this.responseBodyTag, this.staticResponseHeaders);
+                }
+                Object.assign(ctx, derived);
+                return runBefore();
+            };
+            if (querySchema === undefined)
+                return runDerive();
+            let validation;
+            try {
+                validation = querySchema["~standard"].validate(queryObjectOf(ctx[CONTEXT_SEARCH]));
+            }
+            catch (err) {
+                return logError(err, ctx);
+            }
+            if (validation instanceof Promise) {
+                return validation.then((settled) => {
+                    if (settled.issues !== undefined)
+                        return this.wrapWebResponse(plainValidationError(settled.issues));
+                    ctx.query = settled.value;
+                    return runDerive();
+                }, (err) => logError(err, ctx));
+            }
+            if (validation.issues !== undefined)
+                return this.wrapWebResponse(plainValidationError(validation.issues));
+            ctx.query = validation.value;
+            return runDerive();
+        };
+    }
+    /**
+     * Body + lifecycle hooks fused: parse → validate → derive → before → handler → (after) in one
+     * closure, the same win `buildFusedBodyRunner` gives for the no-hooks body shape. The shape is
+     * `lifecycleHookLane` PLUS a body schema with no other validation conflicts; the lane is selected
+     * ONLY when `schema.body !== undefined && schema.query/params/headers === undefined &&
+     * schema.onValidationError === undefined && !defaultOnValidationError && !hasIdempotency &&
+     * !hasLedger && derives === 1 && beforeHandle === 1 && afterHandle <= 1 && onError === 0 &&
+     * !hasResponseContract && !hasDecorations && around === 0`. The same single `querySchema === undefined`
+     * trick used in the no-body lane lets the build path stay simple: a query + body route falls back
+     * to the generic program (this is rare in practice - validated query + validated body is usually a
+     * "search results" route with a middleware chain on top, and the generic lane is fine there).
+     */
+    buildFusedBodyDeriveBeforeAfter(handler, derive, before, after, bodySchema, maxBodyBytes) {
+        const logError = (err, ctx) => this.bareError(err, ctx, (result, set) => this.wrapWebResponse(toResponse(result, set)), this.wrapWebResponse);
+        return (source, params, search, signal, budget, platform, nativeContext) => {
+            const ctx = nativeContext
+                ? RequestContext.native(source, params, search, maxBodyBytes, platform, this.protoPoisoning)
+                : new RequestContext(source, params, search, signal, budget, platform, maxBodyBytes, this.protoPoisoning);
+            const runHandlerValidated = () => {
+                const runAfter = (result) => {
+                    if (after === undefined) {
+                        return fusedRespond(result, ctx, this.responseBodyTag, this.staticResponseHeaders, this.onResponseHooks.length === 0);
+                    }
+                    let transformed;
+                    try {
+                        transformed = after(result, ctx);
+                    }
+                    catch (err) {
+                        return logError(err, ctx);
+                    }
+                    if (transformed instanceof Promise) {
+                        return transformed.then((value) => fusedRespond(value, ctx, this.responseBodyTag, this.staticResponseHeaders, this.onResponseHooks.length === 0), (err) => logError(err, ctx));
+                    }
+                    return fusedRespond(transformed, ctx, this.responseBodyTag, this.staticResponseHeaders, this.onResponseHooks.length === 0);
+                };
+                const runHandler = () => {
+                    let result;
+                    try {
+                        result = handler(ctx);
+                    }
+                    catch (err) {
+                        return logError(err, ctx);
+                    }
+                    if (result instanceof Promise) {
+                        return result.then((value) => runAfter(value), (err) => logError(err, ctx));
+                    }
+                    return runAfter(result);
+                };
+                const runBefore = () => {
+                    let early;
+                    try {
+                        early = before(ctx);
+                    }
+                    catch (err) {
+                        return logError(err, ctx);
+                    }
+                    if (early instanceof Promise) {
+                        return early.then((settled) => {
+                            if (settled === undefined)
+                                return runHandler();
+                            return fusedRespond(settled, ctx, this.responseBodyTag, this.staticResponseHeaders);
+                        }, (err) => logError(err, ctx));
+                    }
+                    if (early === undefined)
+                        return runHandler();
+                    return fusedRespond(early, ctx, this.responseBodyTag, this.staticResponseHeaders);
+                };
+                let derived;
+                try {
+                    derived = derive(ctx);
+                }
+                catch (err) {
+                    return logError(err, ctx);
+                }
+                if (derived instanceof Promise) {
+                    return derived.then((settled) => {
+                        if (isResponseResult(settled) || settled instanceof Response) {
+                            return fusedRespond(settled, ctx, this.responseBodyTag, this.staticResponseHeaders);
+                        }
+                        Object.assign(ctx, settled);
+                        return runBefore();
+                    }, (err) => logError(err, ctx));
+                }
+                if (isResponseResult(derived) || derived instanceof Response) {
+                    return fusedRespond(derived, ctx, this.responseBodyTag, this.staticResponseHeaders);
+                }
+                Object.assign(ctx, derived);
+                return runBefore();
+            };
+            const onParsed = (parsed) => {
+                let validation;
+                try {
+                    validation = bodySchema["~standard"].validate(parsed);
+                }
+                catch (err) {
+                    return logError(err, ctx);
+                }
+                if (validation instanceof Promise) {
+                    return validation.then((settled) => {
+                        if (settled.issues !== undefined)
+                            return this.wrapWebResponse(plainValidationError(settled.issues));
+                        ctx.body = settled.value;
+                        return runHandlerValidated();
+                    }, (err) => logError(err, ctx));
+                }
+                if (validation.issues !== undefined)
+                    return this.wrapWebResponse(plainValidationError(validation.issues));
+                ctx.body = validation.value;
+                return runHandlerValidated();
+            };
+            return readBodyFramed(source, maxBodyBytes, this.protoPoisoning, onParsed, (response) => this.wrapWebResponse(response), (err) => Promise.resolve(logError(err, ctx)));
+        };
+    }
     bareError(err, ctx, finalize, wrapResponse) {
         // The thrown-value contract lives in `bare-error-lane.ts`, one source of truth for both this
         // lane and the fused body runner. `responseSet` and the logger are injected because they reach
         // into class state; the closure is allocated only on the throw path, never on the hot lane.
-        return renderBareError(err, ctx, finalize, wrapResponse, responseSet, (e, c) => this.logRequestError(e, c));
+        return renderBareError(err, ctx, finalize, wrapResponse, responseSet, (e, c) => this.logRequestError(e, c), () => this.internalErrorResponse(wrapResponse));
+    }
+    /**
+     * Keep the ordinary thrown-error response independent from the caught value. Deliberate Response
+     * control flow is handled by `renderBareError`; every other throw gets this fixed public envelope.
+     */
+    internalErrorResponse(wrapResponse) {
+        return wrapResponse(plainError(500, "internal_error"));
     }
     // @ts-expect-error TS6133 -- invoked structurally by compiled plans (internal/route-execution.ts)
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: invoked structurally by compiled plans (internal/route-execution.ts)
     runWithAround(entry, ctx, run, finalize, wrapResponse) {
         let outcome;
         try {
@@ -2403,6 +2577,45 @@ export class Server {
             ? outcome.catch((err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse))
             : outcome;
     }
+    /** Execute the registration-compiled general stage program. */
+    // @ts-expect-error TS6133 -- invoked structurally by compiled plans (internal/route-execution.ts)
+    runProgram(entry, source, ctx, finalize, wrapResponse) {
+        return executeRouteProgram(this, entry, entry.program, source, ctx, finalize, wrapResponse);
+    }
+    /** Bind a compiled validation stage to its stable schema and the existing recovery contract. */
+    // @ts-expect-error TS6133 -- invoked structurally by the general route program
+    validateProgramStage(entry, stage, source, ctx) {
+        const input = stage.kind === "headers"
+            ? headerObjectOf(source.headers)
+            : stage.kind === "params"
+                ? ctx.params
+                : stage.kind === "query"
+                    ? queryObjectOf(ctx[CONTEXT_SEARCH])
+                    : undefined;
+        if (stage.kind === "body")
+            return this.readProgramBody(entry, source, ctx);
+        const validation = stage.schema["~standard"].validate(input);
+        return validation instanceof Promise
+            ? validation.then((result) => this.applyLifecycleValidation(entry, result, ctx, stage.kind))
+            : this.applyLifecycleValidation(entry, validation, ctx, stage.kind);
+    }
+    /** Preserve the existing bounded body reader and its fail-closed framing/prototype checks. */
+    readProgramBody(entry, source, ctx) {
+        const bodySchema = entry.program.bodySchema;
+        if (bodySchema === undefined)
+            return Promise.resolve(plainError(415, "unsupported_media_type"));
+        return this.readAndValidateBody(source, entry, ctx, bodySchema, entry.program.bodyLimit);
+    }
+    /** Keep thrown Response/status and redacted 500 semantics in one existing error boundary. */
+    // @ts-expect-error TS6133 -- invoked structurally by the general route program
+    handleProgramError(entry, error, ctx, finalize, wrapResponse) {
+        return this.handleLifecycleError(entry, error, ctx, finalize, wrapResponse);
+    }
+    /** Finish a successful program result through response-contract enforcement and finalization. */
+    // @ts-expect-error TS6133 -- invoked structurally by the general route program
+    finishProgramResult(entry, ctx, result, finalize, wrapResponse) {
+        return this.finishLifecycleContract(entry, ctx, finalize, wrapResponse, result);
+    }
     runAround(hooks, ctx, run) {
         const dispatch = (index) => {
             if (index >= hooks.length)
@@ -2419,7 +2632,6 @@ export class Server {
         return dispatch(0);
     }
     // @ts-expect-error TS6133 -- invoked structurally by compiled plans (internal/route-execution.ts)
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: invoked structurally by compiled plans (internal/route-execution.ts)
     runBodyOnly(entry, source, ctx, finalize, wrapResponse) {
         return readBodyFramed(source, entry.bodyLimit ?? UNLIMITED_BODY_BYTES, this.protoPoisoning, (parsed) => this.finishBodyOnly(entry, parsed, ctx, finalize, wrapResponse), wrapResponse, (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
     }
@@ -2520,7 +2732,6 @@ export class Server {
         return this.executeHandler(entry, ctx, finalize);
     }
     // @ts-expect-error TS6133 -- invoked structurally by compiled plans (internal/route-execution.ts)
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: invoked structurally by compiled plans (internal/route-execution.ts)
     runQueryOnly(entry, ctx, finalize, wrapResponse) {
         try {
             // Call the validator directly for the raw StandardResult (read `.issues`/`.value`) - skip
@@ -2665,343 +2876,6 @@ export class Server {
                 clearTimeout(timer);
         }
     }
-    /**
-     * The post-match lifecycle: validate → derive → beforeHandle → handler → afterHandle, with onError.
-     * Generic over the render: a success value goes through `finalize(result, set)` (a Web `Response`, or
-     * node-direct primitives); an early/error `Response` (validation, thrown, 500) through `wrapResponse`.
-     */
-    /** Synchronous until a validator, lifecycle hook, handler, or contract check actually returns a Promise. */
-    // @ts-expect-error TS6133 -- invoked structurally by compiled plans (internal/route-execution.ts)
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: invoked structurally by compiled plans (internal/route-execution.ts)
-    runLifecycle(entry, source, ctx, finalize, wrapResponse) {
-        try {
-            const headersSchema = entry.schema?.headers;
-            if (headersSchema !== undefined) {
-                const validation = headersSchema["~standard"].validate(headerObjectOf(source.headers));
-                if (validation instanceof Promise) {
-                    return validation.then((result) => this.runLifecycleAfterHeadersResult(entry, source, ctx, finalize, wrapResponse, result), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-                }
-                return this.runLifecycleAfterHeadersResult(entry, source, ctx, finalize, wrapResponse, validation);
-            }
-            const paramsSchema = entry.schema?.params;
-            if (paramsSchema !== undefined) {
-                const validation = paramsSchema["~standard"].validate(ctx.params);
-                if (validation instanceof Promise) {
-                    return validation.then((result) => this.runLifecycleAfterParamsResult(entry, source, ctx, finalize, wrapResponse, result), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-                }
-                return this.runLifecycleAfterParamsResult(entry, source, ctx, finalize, wrapResponse, validation);
-            }
-            // Registration already knows whether this route has body/params/query validation. Most real
-            // read routes have no body or params schema, so skip the generic stage ladder and go straight to
-            // query validation + lifecycle hooks. The fallback below remains the complete path for routes
-            // with body/params combinations and validation recovery.
-            if (entry.schema?.body === undefined) {
-                return this.runQueryAndLifecycle(entry, ctx, finalize, wrapResponse);
-            }
-            return this.runLifecycleAfterParams(entry, source, ctx, finalize, wrapResponse, undefined);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    runLifecycleAfterHeadersResult(entry, source, ctx, finalize, wrapResponse, result) {
-        try {
-            const headersError = this.applyLifecycleValidation(entry, result, ctx, "headers");
-            if (headersError instanceof Promise) {
-                return headersError.then((error) => error === undefined
-                    ? this.runLifecycleAfterHeaders(entry, source, ctx, finalize, wrapResponse)
-                    : wrapResponse(error), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-            }
-            return headersError === undefined
-                ? this.runLifecycleAfterHeaders(entry, source, ctx, finalize, wrapResponse)
-                : wrapResponse(headersError);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    runLifecycleAfterHeaders(entry, source, ctx, finalize, wrapResponse) {
-        const paramsSchema = entry.schema?.params;
-        if (paramsSchema === undefined) {
-            if (entry.schema?.body === undefined)
-                return this.runQueryAndLifecycle(entry, ctx, finalize, wrapResponse);
-            return this.runLifecycleAfterParams(entry, source, ctx, finalize, wrapResponse, undefined);
-        }
-        const validation = paramsSchema["~standard"].validate(ctx.params);
-        if (validation instanceof Promise) {
-            return validation.then((result) => this.runLifecycleAfterParamsResult(entry, source, ctx, finalize, wrapResponse, result), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-        }
-        return this.runLifecycleAfterParamsResult(entry, source, ctx, finalize, wrapResponse, validation);
-    }
-    /** Registration-specialized query lifecycle: query validation (including recovery) → hooks. */
-    runLifecycleQuery(entry, ctx, finalize, wrapResponse) {
-        try {
-            // The execution plan only selects this runner when the route has a query schema. Keeping the
-            // non-null access here removes the per-request schema-presence branch from realistic GETs.
-            const validation = entry.schema.query["~standard"].validate(queryObjectOf(ctx[CONTEXT_SEARCH]));
-            if (validation instanceof Promise) {
-                return validation.then((result) => {
-                    try {
-                        return this.runQueryAndLifecycleResult(entry, ctx, finalize, wrapResponse, result);
-                    }
-                    catch (err) {
-                        return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-                    }
-                }, (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-            }
-            return this.runQueryAndLifecycleResult(entry, ctx, finalize, wrapResponse, validation);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    /** Registration-specialized body lifecycle: bounded body validation (including recovery) → hooks. */
-    // @ts-expect-error TS6133 -- invoked structurally by compiled plans (internal/route-execution.ts)
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: invoked structurally by compiled plans (internal/route-execution.ts)
-    runLifecycleBody(entry, source, ctx, finalize, wrapResponse) {
-        return this.readAndValidateBody(source, entry, ctx).then((bodyError) => bodyError === undefined
-            ? this.runLifecycleHooks(entry, ctx, finalize, wrapResponse)
-            : wrapResponse(bodyError), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-    }
-    /** Registration-specialized body + query lifecycle: bounded body validation → query validation → hooks. */
-    // @ts-expect-error TS6133 -- invoked structurally by compiled plans (internal/route-execution.ts)
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: invoked structurally by compiled plans (internal/route-execution.ts)
-    runLifecycleBodyQuery(entry, source, ctx, finalize, wrapResponse) {
-        return this.readAndValidateBody(source, entry, ctx).then((bodyError) => bodyError === undefined
-            ? this.runLifecycleQuery(entry, ctx, finalize, wrapResponse)
-            : wrapResponse(bodyError), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-    }
-    /** Registration-specialized no-body lifecycle: query validation (if present) → derives/hooks. */
-    runQueryAndLifecycle(entry, ctx, finalize, wrapResponse) {
-        const querySchema = entry.schema?.query;
-        return querySchema === undefined
-            ? this.runLifecycleHooks(entry, ctx, finalize, wrapResponse)
-            : this.runLifecycleQuery(entry, ctx, finalize, wrapResponse);
-    }
-    runQueryAndLifecycleResult(entry, ctx, finalize, wrapResponse, result) {
-        const queryError = this.applyLifecycleValidation(entry, result, ctx, "query");
-        if (queryError instanceof Promise) {
-            return queryError.then((error) => error === undefined
-                ? this.runLifecycleHooks(entry, ctx, finalize, wrapResponse)
-                : wrapResponse(error), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-        }
-        if (queryError !== undefined)
-            return wrapResponse(queryError);
-        return this.runLifecycleHooks(entry, ctx, finalize, wrapResponse);
-    }
-    runLifecycleAfterParamsResult(entry, source, ctx, finalize, wrapResponse, result) {
-        try {
-            return this.runLifecycleAfterParams(entry, source, ctx, finalize, wrapResponse, this.applyLifecycleValidation(entry, result, ctx, "params"));
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    runLifecycleAfterParams(entry, source, ctx, finalize, wrapResponse, paramsError) {
-        if (paramsError instanceof Promise) {
-            return paramsError.then((error) => this.runLifecycleAfterParamsSettled(entry, source, ctx, finalize, wrapResponse, error), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-        }
-        return this.runLifecycleAfterParamsSettled(entry, source, ctx, finalize, wrapResponse, paramsError);
-    }
-    runLifecycleAfterParamsSettled(entry, source, ctx, finalize, wrapResponse, paramsError) {
-        if (paramsError !== undefined)
-            return wrapResponse(paramsError);
-        if (entry.schema?.body !== undefined) {
-            return this.readAndValidateBody(source, entry, ctx).then((bodyError) => this.runLifecycleAfterBody(entry, ctx, finalize, wrapResponse, bodyError), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-        }
-        return this.runLifecycleAfterBody(entry, ctx, finalize, wrapResponse, undefined);
-    }
-    runLifecycleAfterBody(entry, ctx, finalize, wrapResponse, bodyError) {
-        if (bodyError !== undefined)
-            return wrapResponse(bodyError);
-        const querySchema = entry.schema?.query;
-        if (querySchema === undefined)
-            return this.runLifecycleHooks(entry, ctx, finalize, wrapResponse);
-        const validation = querySchema["~standard"].validate(queryObjectOf(ctx[CONTEXT_SEARCH]));
-        if (validation instanceof Promise) {
-            return validation.then((result) => this.runLifecycleAfterQueryResult(entry, ctx, finalize, wrapResponse, result), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-        }
-        return this.runLifecycleAfterQueryResult(entry, ctx, finalize, wrapResponse, validation);
-    }
-    runLifecycleAfterQueryResult(entry, ctx, finalize, wrapResponse, result) {
-        try {
-            const queryError = this.applyLifecycleValidation(entry, result, ctx, "query");
-            if (queryError instanceof Promise) {
-                return queryError.then((error) => this.runLifecycleAfterQuery(entry, ctx, finalize, wrapResponse, error), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-            }
-            return this.runLifecycleAfterQuery(entry, ctx, finalize, wrapResponse, queryError);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    runLifecycleAfterQuery(entry, ctx, finalize, wrapResponse, queryError) {
-        if (queryError !== undefined)
-            return wrapResponse(queryError);
-        return this.runLifecycleHooks(entry, ctx, finalize, wrapResponse);
-    }
-    runLifecycleHooks(entry, ctx, finalize, wrapResponse) {
-        if (entry.lifecycleHookLane === "derive-before") {
-            return this.runLifecycleDeriveBefore(entry, ctx, finalize, wrapResponse);
-        }
-        try {
-            if (entry.hasDecorations)
-                Object.assign(ctx, entry.decorations);
-            for (let i = 0; i < entry.derives.length; i++) {
-                const extension = entry.derives[i](ctx);
-                if (extension instanceof Promise) {
-                    return this.continueLifecycleAfterDerive(entry, ctx, finalize, wrapResponse, i, extension);
-                }
-                if (isDeriveEarlyExit(extension))
-                    return finalize(extension, responseSet(ctx));
-                Object.assign(ctx, extension);
-            }
-            for (let i = 0; i < entry.beforeHandle.length; i++) {
-                const outcome = entry.beforeHandle[i](ctx);
-                if (outcome instanceof Promise) {
-                    return this.continueLifecycleAfterBefore(entry, ctx, finalize, wrapResponse, i, outcome);
-                }
-                if (outcome !== undefined)
-                    return finalize(outcome, responseSet(ctx));
-            }
-            const result = entry.handler(ctx);
-            if (result instanceof Promise) {
-                return result.then((value) => this.finishLifecycleResult(entry, ctx, finalize, wrapResponse, value), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-            }
-            return this.finishLifecycleResult(entry, ctx, finalize, wrapResponse, result);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    /** Registration-specialized derive → before → handler lifecycle. */
-    runLifecycleDeriveBefore(entry, ctx, finalize, wrapResponse) {
-        try {
-            const extension = entry.derives[0](ctx);
-            if (extension instanceof Promise) {
-                return this.continueLifecycleAfterDerive(entry, ctx, finalize, wrapResponse, 0, extension);
-            }
-            if (isDeriveEarlyExit(extension))
-                return finalize(extension, responseSet(ctx));
-            Object.assign(ctx, extension);
-            const outcome = entry.beforeHandle[0](ctx);
-            if (outcome instanceof Promise) {
-                return this.continueLifecycleAfterBefore(entry, ctx, finalize, wrapResponse, 0, outcome);
-            }
-            if (outcome !== undefined)
-                return this.finishSimpleLifecycleResult(entry, ctx, finalize, wrapResponse, outcome);
-            const result = entry.handler(ctx);
-            if (result instanceof Promise) {
-                return result.then((value) => this.finishSimpleLifecycleResult(entry, ctx, finalize, wrapResponse, value), (err) => this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse));
-            }
-            return this.finishSimpleLifecycleResult(entry, ctx, finalize, wrapResponse, result);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    /** Finalize the specialized lane without rechecking its registration-proven invariants. */
-    finishSimpleLifecycleResult(entry, ctx, finalize, wrapResponse, result) {
-        try {
-            return finalize(result, responseSet(ctx));
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    async continueLifecycleAfterDerive(entry, ctx, finalize, wrapResponse, firstIndex, first) {
-        try {
-            const settled = await first;
-            if (isDeriveEarlyExit(settled))
-                return finalize(settled, responseSet(ctx));
-            Object.assign(ctx, settled);
-            for (let i = firstIndex + 1; i < entry.derives.length; i++) {
-                const raw = entry.derives[i](ctx);
-                const extension = raw instanceof Promise ? await raw : raw;
-                if (isDeriveEarlyExit(extension))
-                    return finalize(extension, responseSet(ctx));
-                Object.assign(ctx, extension);
-            }
-            return await this.runLifecycleHooksAsync(entry, ctx, finalize, wrapResponse);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    async runLifecycleHooksAsync(entry, ctx, finalize, wrapResponse) {
-        try {
-            // Indexed, not `for...of`. An array iterator declared inside an async function stays live
-            // across the `await` below, so neither engine can sink it - unlike the sync lanes above,
-            // where V8 elides it. Measured cost of the iterator form: 43ns per hook on Bun, ~9ns on
-            // Node, on a chain whose hooks return synchronously (the common shape).
-            for (let i = 0; i < entry.beforeHandle.length; i++) {
-                const outcome = entry.beforeHandle[i](ctx);
-                const early = outcome instanceof Promise ? await outcome : outcome;
-                if (early !== undefined)
-                    return finalize(early, responseSet(ctx));
-            }
-            return await this.runLifecycleHandlerAsync(entry, ctx, finalize, wrapResponse);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    async continueLifecycleAfterBefore(entry, ctx, finalize, wrapResponse, firstIndex, first) {
-        try {
-            const firstOutcome = await first;
-            if (firstOutcome !== undefined)
-                return finalize(firstOutcome, responseSet(ctx));
-            for (let i = firstIndex + 1; i < entry.beforeHandle.length; i++) {
-                const outcome = entry.beforeHandle[i](ctx);
-                const early = outcome instanceof Promise ? await outcome : outcome;
-                if (early !== undefined)
-                    return finalize(early, responseSet(ctx));
-            }
-            return await this.runLifecycleHandlerAsync(entry, ctx, finalize, wrapResponse);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    async runLifecycleHandlerAsync(entry, ctx, finalize, wrapResponse) {
-        try {
-            const output = entry.handler(ctx);
-            const result = output instanceof Promise ? await output : output;
-            return await this.finishLifecycleResult(entry, ctx, finalize, wrapResponse, result);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    finishLifecycleResult(entry, ctx, finalize, wrapResponse, initial) {
-        try {
-            let result = initial;
-            for (let i = 0; i < entry.afterHandle.length; i++) {
-                const transformed = entry.afterHandle[i](result, ctx);
-                if (transformed instanceof Promise) {
-                    return this.continueLifecycleAfterHandle(entry, ctx, finalize, wrapResponse, i, transformed);
-                }
-                result = transformed;
-            }
-            return this.finishLifecycleContract(entry, ctx, finalize, wrapResponse, result);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
-    async continueLifecycleAfterHandle(entry, ctx, finalize, wrapResponse, firstIndex, first) {
-        try {
-            let result = await first;
-            for (let i = firstIndex + 1; i < entry.afterHandle.length; i++) {
-                const transformed = entry.afterHandle[i](result, ctx);
-                result = transformed instanceof Promise ? await transformed : transformed;
-            }
-            return await this.finishLifecycleContract(entry, ctx, finalize, wrapResponse, result);
-        }
-        catch (err) {
-            return this.handleLifecycleError(entry, err, ctx, finalize, wrapResponse);
-        }
-    }
     finishLifecycleContract(entry, ctx, finalize, wrapResponse, result) {
         try {
             const contract = entry.responseContract;
@@ -3073,34 +2947,23 @@ export class Server {
         this.logRequestError(err, ctx);
         return wrapResponse(plainError(500, "internal_error"));
     }
-    /** Log an unhandled request error to the (redacting) logger - shared by {@link runLifecycle} and the
+    /** Log an unhandled request error to the (redacting) logger - shared by the compiled route program and the
      * bare fast path ({@link bareError}) so both record the same fields. Never throws; never leaks. */
     logRequestError(err, ctx) {
         emitRequestErrorLog(this.logger, this.errorLogDetail, err, ctx);
     }
-    async readAndValidateBody(req, entry, ctx) {
-        const contentType = headerOf(req, "content-type") ?? "";
-        let parsed;
-        if (contentType === "application/json" || contentType.includes("application/json")) {
-            const json = await this.readBoundedJson(req, entry.bodyLimit ?? UNLIMITED_BODY_BYTES);
-            if (isResponseResult(json))
-                return json;
-            parsed = json;
-        }
-        else if (isUrlEncodedForm(contentType)) {
-            const form = await readBoundedForm(req, entry.bodyLimit ?? UNLIMITED_BODY_BYTES);
-            if (isResponseResult(form))
-                return form;
-            parsed = form;
-        }
-        else {
-            // multipart/form-data (file uploads) stays 415 on the schema path by design - files don't
-            // fit a value schema; use a schema-less route + @nifrajs/uploads helpers for those.
-            return plainError(415, "unsupported_media_type");
-        }
-        const validation = entry.schema.body["~standard"].validate(parsed);
-        const result = validation instanceof Promise ? await validation : validation;
-        return this.applyLifecycleValidation(entry, result, ctx, "body");
+    readAndValidateBody(req, entry, ctx, bodySchema = entry.schema?.body, bodyLimit = entry.bodyLimit) {
+        // Keep the generic lifecycle body stage on the same framed parser/continuation as the body-only
+        // lane. This avoids an async wrapper that first awaits parsing and then starts validation in a
+        // second continuation, while retaining the exact bounded-read, content-type, and poisoning
+        // contracts shared by every body route.
+        const validate = (parsed) => {
+            const validation = bodySchema["~standard"].validate(parsed);
+            return validation instanceof Promise
+                ? validation.then((result) => this.applyLifecycleValidation(entry, result, ctx, "body"))
+                : this.applyLifecycleValidation(entry, validation, ctx, "body");
+        };
+        return readBodyFramed(req, bodyLimit ?? UNLIMITED_BODY_BYTES, this.protoPoisoning, validate, (response) => response, (error) => Promise.reject(error));
     }
     /** Apply validation and its recovery hook on the generic lifecycle lane. Recovery is completed
      * before derives/beforeHandle run, matching the body-only and query-only execution lanes. */
@@ -3154,13 +3017,6 @@ export class Server {
         assign(retried.value);
         return undefined;
     }
-    readBoundedJson(req, maxBodyBytes = this.maxBodyBytes, onResult, onError) {
-        // Not `async`: this is a pass-through, and wrapping the lane's own promise in a coroutine
-        // frame costs an extra microtask hop on every JSON body.
-        return onResult === undefined
-            ? readBoundedJsonSource(req, maxBodyBytes, this.protoPoisoning)
-            : readBoundedJsonSource(req, maxBodyBytes, this.protoPoisoning, onResult, onError);
-    }
     /** Adapt one route's compiled execution plan to Bun's already-matched request shape. Route
      * semantics remain in the plan; this closure only supplies native params and deadline fallback. */
     compileBunNativeHandler(entry, paramNames, fused, signal, budget) {
@@ -3324,9 +3180,12 @@ export class Server {
         // matched route's handler, set by `server.upgrade`.
         // With WS routes, the dispatcher comes from the installed `.use(websocket())` runtime - non-null
         // because wsRouteCount > 0 means ws() ran, and ws() requires the runtime at registration.
+        // Native pub/sub when the app has WS routes and none validate outbound frames: `ws.subscribe` and
+        // `app.publish` go through Bun's own (uWebSockets) broadcast instead of the JS registry loop.
+        const nativePubsub = this.wsRouteCount > 0 && !this.wsHasValidatedSend;
         const wsHandlers = this.wsRouteCount === 0
             ? undefined
-            : this.wsRuntime.bunHandlers(this.topics);
+            : this.wsRuntime.bunHandlers(this.topics, nativePubsub);
         const reusePort = options?.reusePort === true;
         // Spread rather than pass `hostname: undefined` - Bun treats an explicit undefined as a value
         // on some option paths, and omitting is what selects its 0.0.0.0 default.
@@ -3362,6 +3221,14 @@ export class Server {
                 },
             }));
         this.bunServer = running;
+        // Bind `app.publish` to Bun's native broadcast now that the server handle exists. Guarded on the
+        // method's presence so a runtime whose handle lacks it simply keeps the registry path.
+        if (nativePubsub && typeof running.publish === "function") {
+            const native = running.publish.bind(running);
+            this.nativePublish = (topic, data) => {
+                native(topic, data);
+            };
+        }
         this.sealed = true;
         if (this.gracefulSignals)
             this.installSignalHandlers();