@nifrajs/core 2.1.0 → 2.3.0

package/dist/seo.js

@@ -1,5 +1,5 @@
 /**
- * `sitemap.xml` + `robots.txt` builders — pure, edge-safe string generators (no I/O, no runtime deps).
+ * `sitemap.xml` + `robots.txt` builders - pure, edge-safe string generators (no I/O, no runtime deps).
  * Wire them to a route on any runtime:
  *
  *   app.get("/sitemap.xml", () =>
@@ -19,7 +19,7 @@ const XML_ESCAPES = {
     '"': """,
     "'": "'",
 };
-/** Escape the five XML metacharacters — `<loc>` and `<lastmod>` carry app- or DB-derived strings. */
+/** Escape the five XML metacharacters - `<loc>` and `<lastmod>` carry app- or DB-derived strings. */
 function escapeXml(value) {
     return value.replace(/[&<>"']/g, (char) => XML_ESCAPES[char]);
 }
@@ -37,7 +37,7 @@ const SITEMAP_MAX_URLS = 50_000;
 /** Build a `<urlset>` sitemap XML document from `entries`. Throws on out-of-spec input (dev-time data). */
 export function sitemap(entries, options = {}) {
     if (entries.length > SITEMAP_MAX_URLS) {
-        throw new RangeError(`sitemap: ${entries.length} entries exceeds the ${SITEMAP_MAX_URLS}-URL per-file limit — split into a sitemap index`);
+        throw new RangeError(`sitemap: ${entries.length} entries exceeds the ${SITEMAP_MAX_URLS}-URL per-file limit - split into a sitemap index`);
     }
     const base = options.hostname?.replace(/\/+$/, "");
     const urls = entries.map((entry) => {
@@ -66,7 +66,7 @@ function resolveLoc(url, base) {
     if (/^https?:\/\//i.test(url))
         return url; // already absolute
     if (base === undefined)
-        return url; // relative — caller's choice (sitemaps prefer absolute)
+        return url; // relative - caller's choice (sitemaps prefer absolute)
     return `${base}${url.startsWith("/") ? "" : "/"}${url}`;
 }
 /** robots.txt is line-oriented, so a newline in any value could inject a forged directive. Flatten it. */

package/dist/server/body.d.ts

@@ -1,5 +1,5 @@
 /**
- * Bounded request-body reading — the single source of truth for nifra's body-size cap. A lying or
+ * Bounded request-body reading - the single source of truth for nifra's body-size cap. A lying or
  * absent `Content-Length` can't force us to buffer an oversized payload: a declared length over the
  * cap is rejected *before* buffering, and a chunked / length-less body is aborted mid-stream once the
  * running byte count exceeds the cap. Shared by the server's schema path, `c.boundedBody`, and
@@ -13,7 +13,7 @@ interface BodySource {
 export declare function parseContentLength(value: string): number | undefined;
 /** The shared streaming byte-cap loop: read until done, or cancel + 413 once over `maxBytes`.
  * A single-chunk body (the common case for small chunked payloads) returns the runtime's own
- * chunk directly — no chunk array, no copy-merge. */
+ * chunk directly - no chunk array, no copy-merge. */
 export declare function drainCapped(body: ReadableStream<Uint8Array>, maxBytes: number): Promise<{
     ok: true;
     bytes: Uint8Array;

package/dist/server/body.js

@@ -1,5 +1,5 @@
 /**
- * Bounded request-body reading — the single source of truth for nifra's body-size cap. A lying or
+ * Bounded request-body reading - the single source of truth for nifra's body-size cap. A lying or
  * absent `Content-Length` can't force us to buffer an oversized payload: a declared length over the
  * cap is rejected *before* buffering, and a chunked / length-less body is aborted mid-stream once the
  * running byte count exceeds the cap. Shared by the server's schema path, `c.boundedBody`, and
@@ -21,7 +21,7 @@ export function parseContentLength(value) {
 }
 /** The shared streaming byte-cap loop: read until done, or cancel + 413 once over `maxBytes`.
  * A single-chunk body (the common case for small chunked payloads) returns the runtime's own
- * chunk directly — no chunk array, no copy-merge. */
+ * chunk directly - no chunk array, no copy-merge. */
 export async function drainCapped(body, maxBytes) {
     const reader = body.getReader();
     let first;

package/dist/server/context.d.ts

@@ -54,12 +54,12 @@ export interface RouteSchema {
      * Dedupe retries of this (mutating) route on an `Idempotency-Key` header. The first request runs and
      * its response is stored; a retry with the same key replays that response without re-running the
      * handler, and a key reused with a different body is rejected (409). A missing key on an
-     * idempotency-required route fails closed (400). Off the hot path — routes without it are unchanged.
+     * idempotency-required route fails closed (400). Off the hot path - routes without it are unchanged.
      */
     readonly idempotency?: IdempotencyConfig;
     /**
      * Highest data-sensitivity this route's response body carries (`public` | `pii` | `secret`). A
-     * declarative, compile-time + introspection fact — never validated at runtime. Reflected for tooling,
+     * declarative, compile-time + introspection fact - never validated at runtime. Reflected for tooling,
      * recorded in the capability lockfile (so a route that starts returning PII is a reviewable change),
      * and read by downstream policy (e.g. a partner-API surface refusing to expose `pii`/`secret`).
      */
@@ -96,20 +96,20 @@ export interface RouteSchema {
     readonly query?: StandardSchemaV1;
     /** Optional **response contract**. When declared: the handler's return is type-checked against it
      * (the implementation can't drift from the contract), the typed client sees THIS as the response type
-     * (the contract — not the handler's incidental return), and it's emitted into OpenAPI/JSON-Schema so
+     * (the contract - not the handler's incidental return), and it's emitted into OpenAPI/JSON-Schema so
      * tooling and coding agents can read the exact shape. It is **not** validated at runtime (zero
-     * hot-path cost) — purely a compile-time + introspection contract. */
+     * hot-path cost) - purely a compile-time + introspection contract. */
     readonly response?: StandardSchemaV1;
     /**
      * Optional **error-response contract**: a map of HTTP status code → the Standard Schema of that error's
      * body. Declares a route's failure modes so they flow into OpenAPI (as non-2xx `responses`), the
-     * `/llms.txt` context, and other introspection — the whole contract, not just the happy path, is legible
+     * `/llms.txt` context, and other introspection - the whole contract, not just the happy path, is legible
      * to tooling and coding agents. Like `response`, it is **not** validated at runtime (zero hot-path cost);
      * it's a compile-time + introspection contract. Example: `{ 404: NotFound, 409: Conflict }`. */
     readonly errors?: Readonly<Record<number, StandardSchemaV1>>;
     /**
      * Optional **SSE event contract**: the Standard Schema of each event's `data` payload on a
-     * streaming route (declared via `app.sse()`). Marks the route as a typed event stream — the
+     * streaming route (declared via `app.sse()`). Marks the route as a typed event stream - the
      * typed client grows a `.subscribe()` for it, and the schema flows into reflection. Like
      * `response`, it is **not** validated at runtime (zero hot-path cost); the server-side
      * `stream.send()` is compile-time-checked against it instead.
@@ -121,7 +121,7 @@ export interface RouteSchema {
      *   - a **`Response`** → returned as-is, short-circuiting the route (custom error envelope, redirect, …).
      *   - **any other value** → treated as a repaired payload and **re-validated once** against the same
      *     schema. If it now passes, the handler runs with it; if it still fails, the original `422` stands.
-     *     Re-validation means a bad return can't bypass the schema — the trust boundary holds.
+     *     Re-validation means a bad return can't bypass the schema - the trust boundary holds.
      *   - **`undefined`** → give up; the original validation `422` is returned unchanged.
      * A route hook **overrides** the app-wide default set via `server({ onValidationError })`; return
      * `undefined` to fall through to the plain `422` even when an app default exists. Typical uses: a custom
@@ -147,8 +147,8 @@ export interface ResponseControls {
     status?: number;
     readonly headers: Record<string, string>;
     /**
-     * Queue a `Set-Cookie` on the response. Defaults are **secure-by-default** —
-     * `HttpOnly; Secure; SameSite=Lax; Path=/` — overridable per call (pass `{ secure: false }` for
+     * Queue a `Set-Cookie` on the response. Defaults are **secure-by-default** -
+     * `HttpOnly; Secure; SameSite=Lax; Path=/` - overridable per call (pass `{ secure: false }` for
      * local http dev). Multiple calls set multiple cookies (they're merged via a `Headers` object, so
      * they don't collapse the way the plain `headers` Record would). Sign the value with `signValue`
      * for tamper-evidence (what `@nifrajs/auth` sessions do).
@@ -165,7 +165,7 @@ export interface ResponseControls {
  */
 export interface Platform<Env = unknown> {
     /** Platform bindings (KV/D1/secrets on Workers). Typed as `Env` when the app declares them via
-     * `server<Env>()`; otherwise `unknown` — validate before use. */
+     * `server<Env>()`; otherwise `unknown` - validate before use. */
     readonly env?: Env;
     /** Extend the response's lifetime for background work (Workers `ctx.waitUntil`). */
     readonly waitUntil?: (promise: Promise<unknown>) => void;
@@ -182,7 +182,7 @@ export interface Platform<Env = unknown> {
 export interface Context<Path extends string = string, S extends RouteSchema = RouteSchema> {
     readonly req: Request;
     /**
-     * Alias of {@link req} — the same `Request`. Page loaders/actions receive their request as `request`;
+     * Alias of {@link req} - the same `Request`. Page loaders/actions receive their request as `request`;
      * this alias lets route handlers and loaders share one name, so `c.request` and `ctx.req` both work
      * everywhere (no more `c.req` vs `ctx.request` mismatch).
      */
@@ -191,12 +191,12 @@ export interface Context<Path extends string = string, S extends RouteSchema = R
     readonly query: QueryOf<S>;
     readonly body: BodyOf<S>;
     /** The request's cookies, parsed from the `Cookie` header (values URL-decoded). Parsed lazily on
-     * first access + cached. Signed cookies arrive as `value.signature` — verify with `unsignValue`. */
+     * first access + cached. Signed cookies arrive as `value.signature` - verify with `unsignValue`. */
     readonly cookies: Readonly<Record<string, string>>;
     readonly set: ResponseControls;
     /**
      * Aborts when the server's `requestTimeoutMs` elapses (and never, when no timeout
-     * is configured). Pass it to cancellation-aware work — DB drivers, `fetch` — so a
+     * is configured). Pass it to cancellation-aware work - DB drivers, `fetch` - so a
      * timed-out request stops doing work instead of running on after the 503.
      */
     readonly signal: AbortSignal;
@@ -206,14 +206,14 @@ export interface Context<Path extends string = string, S extends RouteSchema = R
      */
     readonly budget: RequestBudget;
     /**
-     * Platform bindings from `app.fetch(request, { env })` — Workers `env` (KV/D1/secrets), etc.
+     * Platform bindings from `app.fetch(request, { env })` - Workers `env` (KV/D1/secrets), etc.
      * `undefined` off-edge (Bun/Node/Deno). Declare the shape with `server<Env>()` to read it typed
      * (`c.env: Env`); otherwise `unknown`. Validate at the trust boundary before use either way.
      */
     readonly env: unknown;
     /**
      * The caller's IP. By default the raw socket peer the serving adapter observed (`listen()`,
-     * `@nifrajs/node`, `@nifrajs/deno`) — the one address a client cannot forge — or `undefined` when the
+     * `@nifrajs/node`, `@nifrajs/deno`) - the one address a client cannot forge - or `undefined` when the
      * runtime exposes no socket (Workers) and no trust is declared. Behind a proxy/CDN, set the
      * `clientIp` server option (`{ trustedHops }` or `{ header }`) to derive the real caller from the
      * forwarding chain as far as you trust it; unset, no forwarded header is ever believed. Safe to key
@@ -228,8 +228,8 @@ export interface Context<Path extends string = string, S extends RouteSchema = R
     readonly waitUntil: (promise: Promise<unknown>) => void;
     /**
      * Read the raw request body as bytes, **capped** at `maxBytes` (default: the server's
-     * `maxBodyBytes`). For routes with **no body schema** — raw bodies, file uploads,
-     * BYO-validation — where the automatic schema cap doesn't apply. An over-cap body (by
+     * `maxBodyBytes`). For routes with **no body schema** - raw bodies, file uploads,
+     * BYO-validation - where the automatic schema cap doesn't apply. An over-cap body (by
      * `Content-Length` or while streaming) throws a flat `413`; a malformed `Content-Length`
      * throws `400`. Consumes the body stream (call once). Pass a larger `maxBytes` for an
      * upload route, a smaller one to tighten a specific endpoint.
@@ -243,7 +243,7 @@ export interface Context<Path extends string = string, S extends RouteSchema = R
     readonly boundedJson: <T = unknown>(maxBytes?: number) => Promise<T>;
     /**
      * Build a JSON `Response`. Pass a status number or a full `ResponseInit` as the second arg. `return` it
-     * from a handler, or `throw` it from `derive`/`beforeHandle` to short-circuit — both work:
+     * from a handler, or `throw` it from `derive`/`beforeHandle` to short-circuit - both work:
      * `throw c.json({ error: "unauthorized" }, 401)`. A terser alternative to
      * `new Response(JSON.stringify(...), { status, headers: { "content-type": "application/json" } })`.
      */

package/dist/server/contract.d.ts

@@ -15,7 +15,7 @@ export interface ResponseDef {
 /**
  * One operation in a contract. Input schemas are any Standard Schema; `response` is optional.
  *
- * The fields below `response` are **optional OpenAPI metadata** — they don't affect runtime
+ * The fields below `response` are **optional OpenAPI metadata** - they don't affect runtime
  * validation or the inferred handler types, they enrich the document `toOpenAPI` emits. A contract is
  * the natural home for them: it's the versionable description of the API, decoupled from the impl.
  */
@@ -80,7 +80,7 @@ type OpErrors<O extends OperationDef> = O extends {
  * RouteInfo as a *decoupled consumer* sees it from the contract alone: the
  * `output` is the declared `response` schema's type, or `unknown` when none is
  * declared (the consumer can't know the response without the server). Path/method
- * levels are mutable and fields are `readonly` — matching the inline registry, so
+ * levels are mutable and fields are `readonly` - matching the inline registry, so
  * the two are mutually assignable.
  */
 type RouteInfoForOp<O extends OperationDef> = {
@@ -112,7 +112,7 @@ type SchemaForOp<O extends OperationDef> = (O extends {
     params: P;
 } : Record<never, never>);
 /**
- * The handler context for an op — identical to the inline `Context<Path, S>`, so a
+ * The handler context for an op - identical to the inline `Context<Path, S>`, so a
  * handler written for an inline route type-checks unchanged under `implement`
  * (the graduation guarantee).
  */
@@ -120,9 +120,9 @@ export type ContextForOp<O extends OperationDef> = Context<O["path"], SchemaForO
 type MaybePromise<T> = T | Promise<T>;
 /**
  * What a handler may return for an op. When the op declares a `response`, the return is constrained to
- * that contract shape (or a raw `Response`) — so an `implement`ed backend can't drift from the response
+ * that contract shape (or a raw `Response`) - so an `implement`ed backend can't drift from the response
  * the contract's client was built against. With no `response` it's unconstrained (`unknown`), identical
- * to before. Purely type-level — erased at compile time, zero runtime cost — and mirrors the inline
+ * to before. Purely type-level - erased at compile time, zero runtime cost - and mirrors the inline
  * route's `ResponseOf` constraint, so a handler graduates inline↔contract unchanged.
  */
 type HandlerReturnForOp<O extends OperationDef> = O extends {
@@ -148,7 +148,7 @@ export declare function defineContract<const C extends ContractShape>(contract:
 type AnyFn = (...args: never[]) => unknown;
 /**
  * The registry produced by `implement`: input from the contract op; `output` is the declared `response`
- * contract when present (it wins — exactly as in the inline path), else the bound HANDLER's return — so
+ * contract when present (it wins - exactly as in the inline path), else the bound HANDLER's return - so
  * the implemented server stays route-for-route identical to the equivalent inline server (the
  * mode-conformance guarantee), and a contract-typed client and a `typeof app`-typed client agree.
  */
@@ -169,7 +169,7 @@ export type RegistryFromImpl<C extends ContractShape, H extends HandlersFor<C, C
 /**
  * Bind handlers to a contract, producing a real {@link Server} you can `.listen()`
  * or `.fetch()`. Each op is registered through the same path as the inline
- * builder, so the result is identical to writing the routes inline — handlers
+ * builder, so the result is identical to writing the routes inline - handlers
  * lift over **unchanged** ("graduation"), and body/query schemas validate at the
  * request boundary exactly as in inline mode.
  *

package/dist/server/contract.js

@@ -33,7 +33,7 @@ export function defineContract(contract) {
 /**
  * Bind handlers to a contract, producing a real {@link Server} you can `.listen()`
  * or `.fetch()`. Each op is registered through the same path as the inline
- * builder, so the result is identical to writing the routes inline — handlers
+ * builder, so the result is identical to writing the routes inline - handlers
  * lift over **unchanged** ("graduation"), and body/query schemas validate at the
  * request boundary exactly as in inline mode.
  *
@@ -54,9 +54,9 @@ export function implement(contract, handlers, app) {
     const target = (app ?? new Server());
     const routes = Object.entries(contract).map(([name, op]) => {
         // body/query are validated at the request boundary; `response` is a type + introspection contract
-        // ONLY — never validated at runtime and never read on the request hot path (the lifecycle reads
+        // ONLY - never validated at runtime and never read on the request hot path (the lifecycle reads
         // schema.body/query by name; the `bare`/bodyOnly/queryOnly fast-path gates ignore `response`). Built
-        // once here at bind time, not per request — it just carries a reference to the op's existing schema.
+        // once here at bind time, not per request - it just carries a reference to the op's existing schema.
         // A response-less op still yields `undefined`, byte-identical to before.
         const schema = op.params !== undefined ||
             op.body !== undefined ||

package/dist/server/cookies.d.ts

@@ -1,5 +1,5 @@
 /**
- * Cookie primitives — parse a request `Cookie` header, serialize a `Set-Cookie`, and sign/verify a
+ * Cookie primitives - parse a request `Cookie` header, serialize a `Set-Cookie`, and sign/verify a
  * value with HMAC-SHA256 via **WebCrypto** (`crypto.subtle`), so they're portable across Bun, Node,
  * Deno, and workerd with no `node:crypto` dependency. Pure + runtime-agnostic: `c.cookies` (read) and
  * `c.set.cookie` (write) build on these, and `@nifrajs/auth` builds sessions on top.
@@ -17,16 +17,16 @@ export interface CookieOptions {
     readonly partitioned?: boolean;
 }
 /** Parse a request `Cookie` header into a name→value map (values URL-decoded). Unparseable pairs are
- * skipped rather than throwing — a junk `Cookie` header shouldn't fail the request.
+ * skipped rather than throwing - a junk `Cookie` header shouldn't fail the request.
  *
  * Hand-rolled index walk instead of `split(";")` + `trim()` chains: those allocated an array + up
  * to three substrings per pair and showed up at ~6% of a realistic (auth + cookie) request. Same
  * semantics, two slices per pair, no intermediate array. */
 export declare function parseCookies(header: string | null | undefined): Record<string, string>;
 /**
- * Serialize a `Set-Cookie` header value. Pure — applies **no** security defaults (the caller, e.g.
+ * Serialize a `Set-Cookie` header value. Pure - applies **no** security defaults (the caller, e.g.
  * `c.set.cookie`, layers `HttpOnly`/`Secure`/`SameSite` on). Throws on an invalid cookie name, a
- * header-injecting `Path`/`Domain`, a non-integer `maxAge`, or an oversized result — a serialization
+ * header-injecting `Path`/`Domain`, a non-integer `maxAge`, or an oversized result - a serialization
  * bug should fail loudly, not silently emit a cookie the browser drops.
  */
 export declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;

package/dist/server/cookies.js

@@ -1,5 +1,5 @@
 /**
- * Cookie primitives — parse a request `Cookie` header, serialize a `Set-Cookie`, and sign/verify a
+ * Cookie primitives - parse a request `Cookie` header, serialize a `Set-Cookie`, and sign/verify a
  * value with HMAC-SHA256 via **WebCrypto** (`crypto.subtle`), so they're portable across Bun, Node,
  * Deno, and workerd with no `node:crypto` dependency. Pure + runtime-agnostic: `c.cookies` (read) and
  * `c.set.cookie` (write) build on these, and `@nifrajs/auth` builds sessions on top.
@@ -7,8 +7,8 @@
 import { requireSecretBytes } from "../internal/secret.js";
 // RFC 6265 cookie-name token: visible ASCII minus separators/whitespace/controls.
 const COOKIE_NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
-const MAX_COOKIE_BYTES = 4096; // browsers cap a cookie near 4 KB — reject oversized before the wire
-/** True if `v` contains a character illegal in a cookie attribute (control char or `;` separator) —
+const MAX_COOKIE_BYTES = 4096; // browsers cap a cookie near 4 KB - reject oversized before the wire
+/** True if `v` contains a character illegal in a cookie attribute (control char or `;` separator) -
  * the header-injection guard for dev-supplied `Path`/`Domain`. */
 const hasIllegalChar = (v) => {
     for (let i = 0; i < v.length; i++) {
@@ -19,7 +19,7 @@ const hasIllegalChar = (v) => {
     return false;
 };
 const safeDecode = (v) => {
-    // No `%` ⇒ nothing to decode — skip the call AND its try frame (profiled: cookie values are
+    // No `%` ⇒ nothing to decode - skip the call AND its try frame (profiled: cookie values are
     // overwhelmingly plain; this was ~3% of a realistic request).
     if (!v.includes("%"))
         return v;
@@ -31,7 +31,7 @@ const safeDecode = (v) => {
     }
 };
 /** Parse a request `Cookie` header into a name→value map (values URL-decoded). Unparseable pairs are
- * skipped rather than throwing — a junk `Cookie` header shouldn't fail the request.
+ * skipped rather than throwing - a junk `Cookie` header shouldn't fail the request.
  *
  * Hand-rolled index walk instead of `split(";")` + `trim()` chains: those allocated an array + up
  * to three substrings per pair and showed up at ~6% of a realistic (auth + cookie) request. Same
@@ -86,9 +86,9 @@ export function parseCookies(header) {
     return out;
 }
 /**
- * Serialize a `Set-Cookie` header value. Pure — applies **no** security defaults (the caller, e.g.
+ * Serialize a `Set-Cookie` header value. Pure - applies **no** security defaults (the caller, e.g.
  * `c.set.cookie`, layers `HttpOnly`/`Secure`/`SameSite` on). Throws on an invalid cookie name, a
- * header-injecting `Path`/`Domain`, a non-integer `maxAge`, or an oversized result — a serialization
+ * header-injecting `Path`/`Domain`, a non-integer `maxAge`, or an oversized result - a serialization
  * bug should fail loudly, not silently emit a cookie the browser drops.
  */
 export function serializeCookie(name, value, options = {}) {
@@ -152,7 +152,7 @@ const fromBase64Url = (s) => {
         return bytes;
     }
     catch {
-        return null; // not valid base64 — treat as a bad signature
+        return null; // not valid base64 - treat as a bad signature
     }
 };
 /** Append an HMAC-SHA256 signature to a value → `value.signature` (base64url). For signed cookies. */

package/dist/server/edge.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The edge adapter: a nifra app presented as a Cloudflare-Workers-shaped `ExportedHandler`.
+ *
+ * ## Why this is not in the server kernel
+ *
+ * `toFetchHandler` never touches the `Server` class. It takes a STRUCTURAL app - anything with `fetch`, and
+ * optionally `resolveWebSocketUpgrade` - which is what lets it wrap an app it has no access to the
+ * internals of, and what makes it a separate concern from the kernel rather than a method on it. It sat
+ * in `server.ts` for no reason other than that both were written the same week.
+ *
+ * The types here are all structural too (`ExecutionContext`, `ScheduledController`,
+ * `DurableObjectNamespaceLike`), so `@nifrajs/core` declares the Workers surface it needs instead of
+ * depending on `@cloudflare/workers-types`. The real Workers types satisfy them.
+ *
+ * The `MaybePromise` import is type-only and erased, so there is no runtime cycle back into the kernel.
+ */
+import type { Platform } from "./context.js";
+import type { MaybePromise } from "./server.js";
+import type { WebSocketUpgradeOutcome } from "./websocket.js";
+/** A Cloudflare Workers-style execution context (the `fetch` 3rd arg). Structural - only
+ * `waitUntil` is used; declared here so `@nifrajs/core` needs no Workers type dependency. */
+export interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+}
+/** A Cloudflare Workers-style scheduled (cron) controller. Structural - no Workers type dependency. */
+export interface ScheduledController {
+    /** Epoch ms the run was scheduled for. */
+    readonly scheduledTime: number;
+    /** The matching cron expression from `wrangler.toml` `[triggers]`. */
+    readonly cron: string;
+    /** Tell the platform not to retry this run on failure. */
+    noRetry(): void;
+}
+/** A nifra cron handler: the platform controller + the same typed `env`/`waitUntil` nifra threads into
+ * request handlers. Schedule background work with `waitUntil` so it outlives the trigger. */
+export type ScheduledHandler<Env = unknown> = (controller: ScheduledController, context: {
+    readonly env: Env;
+    waitUntil(promise: Promise<unknown>): void;
+}) => MaybePromise<void>;
+/** Structural view of a Cloudflare Durable Object namespace binding - keeps `@cloudflare/workers-types`
+ * out of `@nifrajs/core`. The real `DurableObjectNamespace` satisfies it. */
+export interface DurableObjectNamespaceLike {
+    idFromName(name: string): unknown;
+    get(id: unknown): {
+        fetch(request: Request): Promise<Response>;
+    };
+}
+/**
+ * Adapt a nifra app to an edge "ExportedHandler" - use it as a Cloudflare Workers (or any
+ * `fetch(request, env, ctx)` runtime) default export. It threads `env` + `ctx.waitUntil` into the
+ * nifra Context, so handlers read `c.env` and schedule background work via `c.waitUntil`:
+ *
+ *   export default toFetchHandler(app)
+ *
+ * Pass `{ scheduled }` to also export a Workers cron handler (for a `[triggers]` schedule) - it
+ * receives the platform controller plus the same typed `env`/`waitUntil`:
+ *
+ *   export default toFetchHandler(app, {
+ *     scheduled: (controller, { env, waitUntil }) =>
+ *       waitUntil(env.KV.put("last-run", String(controller.scheduledTime))),
+ *   })
+ *
+ * No Workers-only deps - `app.fetch` stays a portable Web-standard handler; this is the thin
+ * shim from the platform's 3-arg `fetch`/`scheduled` to it.
+ */
+export declare function toFetchHandler<Env = unknown>(app: {
+    fetch(request: Request, platform?: Platform<Env>): MaybePromise<Response>;
+    resolveWebSocketUpgrade?(request: Request, platform?: Platform<Env>): MaybePromise<WebSocketUpgradeOutcome>;
+}, options?: {
+    scheduled?: ScheduledHandler<Env>;
+    /**
+     * Route WebSocket upgrades to a Durable Object that holds the connections and runs the app's
+     * pub/sub - enabling cross-connection broadcast (`app.publish`) on Cloudflare Workers, where a
+     * stateless isolate can't. Pass the DO namespace binding from `env`; pair with `@nifrajs/workers`'
+     * `createWebSocketHub(app)` (the DO class) + a `wrangler.toml` binding. Without this, WS upgrades use
+     * a per-connection `WebSocketPair` (no broadcast).
+     */
+    webSocketHub?: (env: Env) => DurableObjectNamespaceLike;
+}): {
+    fetch(request: Request, env: Env, ctx: ExecutionContext): MaybePromise<Response>;
+    scheduled?(controller: ScheduledController, env: Env, ctx: ExecutionContext): MaybePromise<void>;
+};
+//# sourceMappingURL=edge.d.ts.map

package/dist/server/edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.d.ts","sourceRoot":"","sources":["../../src/server/edge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAqB,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAEhF;6FAC6F;AAC7F,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;CAC3C;AAED,uGAAuG;AACvG,MAAM,WAAW,mBAAmB;IAClC,0CAA0C;IAC1C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,0DAA0D;IAC1D,OAAO,IAAI,IAAI,CAAA;CAChB;AAED;6FAC6F;AAC7F,MAAM,MAAM,gBAAgB,CAAC,GAAG,GAAG,OAAO,IAAI,CAC5C,UAAU,EAAE,mBAAmB,EAC/B,OAAO,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAAC,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;CAAE,KACvE,YAAY,CAAC,IAAI,CAAC,CAAA;AAQvB;6EAC6E;AAC7E,MAAM,WAAW,0BAA0B;IACzC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;IACjC,GAAG,CAAC,EAAE,EAAE,OAAO,GAAG;QAAE,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;KAAE,CAAA;CACjE;AAKD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,GAAG,GAAG,OAAO,EAC1C,GAAG,EAAE;IACH,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;IACzE,uBAAuB,CAAC,CACtB,OAAO,EAAE,OAAO,EAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,GACvB,YAAY,CAAC,uBAAuB,CAAC,CAAA;CACzC,EACD,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAA;IACjC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,0BAA0B,CAAA;CACxD,GACA;IACD,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,gBAAgB,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;IAChF,SAAS,CAAC,CAAC,UAAU,EAAE,mBAAmB,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,gBAAgB,GAAG,YAAY,CAAC,IAAI,CAAC,CAAA;CACjG,CAkDA"}

package/dist/server/edge.js

@@ -0,0 +1,71 @@
+/** The single hub Durable Object id nifra routes WS upgrades to (one hub per app - see `@nifrajs/workers`). */
+const NIFRA_WS_HUB_ID = "nifra-ws-hub";
+/**
+ * Adapt a nifra app to an edge "ExportedHandler" - use it as a Cloudflare Workers (or any
+ * `fetch(request, env, ctx)` runtime) default export. It threads `env` + `ctx.waitUntil` into the
+ * nifra Context, so handlers read `c.env` and schedule background work via `c.waitUntil`:
+ *
+ *   export default toFetchHandler(app)
+ *
+ * Pass `{ scheduled }` to also export a Workers cron handler (for a `[triggers]` schedule) - it
+ * receives the platform controller plus the same typed `env`/`waitUntil`:
+ *
+ *   export default toFetchHandler(app, {
+ *     scheduled: (controller, { env, waitUntil }) =>
+ *       waitUntil(env.KV.put("last-run", String(controller.scheduledTime))),
+ *   })
+ *
+ * No Workers-only deps - `app.fetch` stays a portable Web-standard handler; this is the thin
+ * shim from the platform's 3-arg `fetch`/`scheduled` to it.
+ */
+export function toFetchHandler(app, options) {
+    const scheduled = options?.scheduled;
+    const webSocketHub = options?.webSocketHub;
+    const resolveWs = app.resolveWebSocketUpgrade?.bind(app);
+    return {
+        fetch: (request, env, ctx) => {
+            const platform = { env, waitUntil: (promise) => ctx.waitUntil(promise) };
+            // WebSocket broadcast on Workers: route upgrades to the hub Durable Object (it holds the
+            // connections + runs the app's pub/sub, so `app.publish` reaches every client). The hub itself
+            // resolves the route and rejects non-WS paths. See `@nifrajs/workers`' `createWebSocketHub`.
+            if (webSocketHub !== undefined &&
+                request.headers.get("upgrade")?.toLowerCase() === "websocket") {
+                const ns = webSocketHub(env);
+                return ns.get(ns.idFromName(NIFRA_WS_HUB_ID)).fetch(request);
+            }
+            // Workers WebSockets: a WS upgrade for a registered route becomes a `WebSocketPair` + a 101.
+            // Feature-detected, so non-Workers edge runtimes (which lack `WebSocketPair` - e.g. Deno Deploy
+            // uses `@nifrajs/deno`'s `Deno.upgradeWebSocket`) simply fall through to the normal `fetch`.
+            const Pair = globalThis.WebSocketPair;
+            if (resolveWs !== undefined && Pair !== undefined) {
+                const accept = (outcome) => {
+                    if (outcome.kind === "pass")
+                        return app.fetch(request, platform);
+                    if (outcome.kind === "reject")
+                        return outcome.response;
+                    const pair = new Pair();
+                    const server = pair[1];
+                    server.accept();
+                    // The outcome carries the installed runtime's `attach`, so `toFetchHandler` (a standalone
+                    // function, no access to the app's private runtime) wires the socket without a static WS import.
+                    outcome.attach(server, outcome.handler, outcome.data, {
+                        openNow: true,
+                        pubsub: outcome.pubsub,
+                    });
+                    // `webSocket` is a Workers-only `ResponseInit` field (absent from the standard type), and a
+                    // 101 status is only valid on the Workers runtime - both gated by the `Pair` feature check.
+                    return new Response(null, { status: 101, webSocket: pair[0] });
+                };
+                const out = resolveWs(request, platform);
+                return out instanceof Promise ? out.then(accept) : accept(out);
+            }
+            return app.fetch(request, platform);
+        },
+        ...(scheduled !== undefined
+            ? {
+                scheduled: (controller, env, ctx) => scheduled(controller, { env, waitUntil: (promise) => ctx.waitUntil(promise) }),
+            }
+            : {}),
+    };
+}
+//# sourceMappingURL=edge.js.map

package/dist/server/edge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.js","sourceRoot":"","sources":["../../src/server/edge.ts"],"names":[],"mappings":"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"}

package/dist/server/install.d.ts

@@ -18,4 +18,6 @@ export declare const INSTALL_SSE: unique symbol;
 export declare const INSTALL_NODE_DIRECT: unique symbol;
 /** @internal Install the WebSocket runtime on a server (called by the `websocket()` plugin). */
 export declare const INSTALL_WS: unique symbol;
+/** @internal Install the response-contract runtime on a server (called by the `responseContract()` plugin). */
+export declare const INSTALL_RESPONSE_CONTRACT: unique symbol;
 //# sourceMappingURL=install.d.ts.map

package/dist/server/install.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/server/install.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,oGAAoG;AACpG,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAAwD,CAAA;AAEjG,uGAAuG;AACvG,eAAO,MAAM,qBAAqB,EAAE,OAAO,MAE1C,CAAA;AAED,oFAAoF;AACpF,eAAO,MAAM,WAAW,EAAE,OAAO,MAAgD,CAAA;AAEjF,8FAA8F;AAC9F,eAAO,MAAM,WAAW,EAAE,OAAO,MAAgD,CAAA;AAEjF,oGAAoG;AACpG,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAAwD,CAAA;AAEjG,gGAAgG;AAChG,eAAO,MAAM,UAAU,EAAE,OAAO,MAA+C,CAAA"}
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/server/install.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,oGAAoG;AACpG,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAAwD,CAAA;AAEjG,uGAAuG;AACvG,eAAO,MAAM,qBAAqB,EAAE,OAAO,MAE1C,CAAA;AAED,oFAAoF;AACpF,eAAO,MAAM,WAAW,EAAE,OAAO,MAAgD,CAAA;AAEjF,8FAA8F;AAC9F,eAAO,MAAM,WAAW,EAAE,OAAO,MAAgD,CAAA;AAEjF,oGAAoG;AACpG,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAAwD,CAAA;AAEjG,gGAAgG;AAChG,eAAO,MAAM,UAAU,EAAE,OAAO,MAA+C,CAAA;AAE/E,+GAA+G;AAC/G,eAAO,MAAM,yBAAyB,EAAE,OAAO,MAE9C,CAAA"}

package/dist/server/install.js

@@ -18,4 +18,6 @@ export const INSTALL_SSE = Symbol.for("@nifrajs/core/install-sse");
 export const INSTALL_NODE_DIRECT = Symbol.for("@nifrajs/core/install-node-direct");
 /** @internal Install the WebSocket runtime on a server (called by the `websocket()` plugin). */
 export const INSTALL_WS = Symbol.for("@nifrajs/core/install-ws");
+/** @internal Install the response-contract runtime on a server (called by the `responseContract()` plugin). */
+export const INSTALL_RESPONSE_CONTRACT = Symbol.for("@nifrajs/core/install-response-contract");
 //# sourceMappingURL=install.js.map

package/dist/server/install.js.map

@@ -1 +1 @@
-{"version":3,"file":"install.js","sourceRoot":"","sources":["../../src/server/install.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,oGAAoG;AACpG,MAAM,CAAC,MAAM,mBAAmB,GAAkB,MAAM,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAA;AAEjG,uGAAuG;AACvG,MAAM,CAAC,MAAM,qBAAqB,GAAkB,MAAM,CAAC,GAAG,CAC5D,qCAAqC,CACtC,CAAA;AAED,oFAAoF;AACpF,MAAM,CAAC,MAAM,WAAW,GAAkB,MAAM,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAA;AAEjF,8FAA8F;AAC9F,MAAM,CAAC,MAAM,WAAW,GAAkB,MAAM,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAA;AAEjF,oGAAoG;AACpG,MAAM,CAAC,MAAM,mBAAmB,GAAkB,MAAM,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAA;AAEjG,gGAAgG;AAChG,MAAM,CAAC,MAAM,UAAU,GAAkB,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAA"}
+{"version":3,"file":"install.js","sourceRoot":"","sources":["../../src/server/install.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,oGAAoG;AACpG,MAAM,CAAC,MAAM,mBAAmB,GAAkB,MAAM,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAA;AAEjG,uGAAuG;AACvG,MAAM,CAAC,MAAM,qBAAqB,GAAkB,MAAM,CAAC,GAAG,CAC5D,qCAAqC,CACtC,CAAA;AAED,oFAAoF;AACpF,MAAM,CAAC,MAAM,WAAW,GAAkB,MAAM,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAA;AAEjF,8FAA8F;AAC9F,MAAM,CAAC,MAAM,WAAW,GAAkB,MAAM,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAA;AAEjF,oGAAoG;AACpG,MAAM,CAAC,MAAM,mBAAmB,GAAkB,MAAM,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAA;AAEjG,gGAAgG;AAChG,MAAM,CAAC,MAAM,UAAU,GAAkB,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAA;AAE/E,+GAA+G;AAC/G,MAAM,CAAC,MAAM,yBAAyB,GAAkB,MAAM,CAAC,GAAG,CAChE,yCAAyC,CAC1C,CAAA"}

package/dist/server/logger.d.ts

@@ -12,12 +12,12 @@ export interface Logger {
 }
 /**
  * Tunes redaction. Key-name redaction always runs; the rest is **opt-in**:
- * - `keyParts` — extra case-insensitive key fragments, added to the built-in denylist.
- * - `valuePatterns` — regexes matched against string **values** *and* the log message; each match is
+ * - `keyParts` - extra case-insensitive key fragments, added to the built-in denylist.
+ * - `valuePatterns` - regexes matched against string **values** *and* the log message; each match is
  *   replaced with the placeholder. This is the value-scanning hook for secrets that land in a value or
- *   message (e.g. `err.message`), which key-name redaction can't catch. Off unless provided — the
+ *   message (e.g. `err.message`), which key-name redaction can't catch. Off unless provided - the
  *   default path does no value scanning, so it stays allocation-light. See {@link commonSecretPatterns}.
- * - `placeholder` — the replacement string (default `[REDACTED]`).
+ * - `placeholder` - the replacement string (default `[REDACTED]`).
  */
 export interface RedactOptions {
     readonly keyParts?: readonly string[];
@@ -25,7 +25,7 @@ export interface RedactOptions {
     readonly placeholder?: string;
 }
 /**
- * A conservative, high-signal set of patterns for {@link RedactOptions.valuePatterns} — opt in by
+ * A conservative, high-signal set of patterns for {@link RedactOptions.valuePatterns} - opt in by
  * passing it (or a subset) to `jsonLogger`/`redactLogFields`. Covers bearer tokens, JWTs, emails, and a
  * few well-known key formats (Stripe, GitHub, AWS access-key ids). Chosen to minimize false positives;
  * add your own (e.g. internal id formats) as needed. Every pattern is global so all matches are scrubbed.
@@ -39,11 +39,11 @@ export declare const commonSecretPatterns: ReadonlyArray<RegExp>;
 export declare function redactLogFields(fields: LogFields, options?: RedactOptions): LogFields;
 /**
  * The default logger: one redacted JSON object per line. `write` is injectable for tests or
- * alternative sinks (defaults to stderr). `options` tunes redaction — pass `valuePatterns` (e.g.
+ * alternative sinks (defaults to stderr). `options` tunes redaction - pass `valuePatterns` (e.g.
  * {@link commonSecretPatterns}) to also scrub secrets embedded in values + the message. Framework keys
  * (`level`, `message`, `time`) always win over user fields of the same name.
  */
 export declare function jsonLogger(write?: (line: string) => void, options?: RedactOptions): Logger;
-/** Discards everything — for tests, or when log output is handled elsewhere. */
+/** Discards everything - for tests, or when log output is handled elsewhere. */
 export declare const silentLogger: Logger;
 //# sourceMappingURL=logger.d.ts.map