@nifrajs/middleware 2.2.0 → 2.4.0

package/README.md

@@ -1,7 +1,7 @@
 # @nifrajs/middleware
 
-Composable, dependency-light middleware for [nifra](../../README.md) — CORS, security headers, body
-limits, auth, CSRF, JWT/JWKS, IP restriction, response caching, timing, and ops helpers — applied with
+Composable, dependency-light middleware for [nifra](../../README.md) - CORS, security headers, body
+limits, auth, CSRF, JWT/JWKS, IP restriction, response caching, timing, and ops helpers - applied with
 `app.use()`.
 
 ```sh
@@ -33,41 +33,41 @@ const app = server()
   .get("/", () => ({ ok: true }))
 ```
 
-- **`bodyLimit({ maxBytes })`** — fail-closed `Content-Length` gate before routing. Lengthless
+- **`bodyLimit({ maxBytes })`** - fail-closed `Content-Length` gate before routing. Lengthless
   bodies are rejected with `411` by default; use route-level `c.boundedBody()` / schema validation
   for intentionally streamed endpoints.
-- **`basicAuth(options)`** — Basic Auth plugin with constant-time static credential comparison or
+- **`basicAuth(options)`** - Basic Auth plugin with constant-time static credential comparison or
   a custom verifier.
-- **`bearer(options)` / `apiKey(options)`** — token auth plugins with typed principals.
-- **`csrf({ secret })`** — signed double-submit CSRF protection plus Origin/Referer checking.
-- **`jwt(options)` + `verifyJwt()` / `tryVerifyJwt()` + `jwk()` / `jwks()`** — JWT auth
+- **`bearer(options)` / `apiKey(options)`** - token auth plugins with typed principals.
+- **`csrf({ secret })`** - signed double-submit CSRF protection plus Origin/Referer checking.
+- **`jwt(options)` + `verifyJwt()` / `tryVerifyJwt()` + `jwk()` / `jwks()`** - JWT auth
   with explicit algorithm allowlists, required expiration by default, issuer/audience checks,
   direct JWK, HTTPS JWKS, and an additive no-throw Result helper for manual verification.
-- **`ipRestriction(options)`** — allow/deny IPv4/IPv6 exact and CIDR matches. Fails closed unless
+- **`ipRestriction(options)`** - allow/deny IPv4/IPv6 exact and CIDR matches. Fails closed unless
   you provide `clientIp`, trusted proxy extraction, or a trusted single-IP header.
-- **`cors(options)`** — preflight handling + headers on *every* response (errors and
+- **`cors(options)`** - preflight handling + headers on *every* response (errors and
   404s included). Origin as `"*"` / exact / list / predicate. **Throws** if
   `credentials: true` is paired with `origin: "*"` (the browser rejects it).
-- **`securityHeaders(options)`** — `X-Content-Type-Options`, `X-Frame-Options`,
+- **`securityHeaders(options)`** - `X-Content-Type-Options`, `X-Frame-Options`,
   `Referrer-Policy` by default; opt-in HSTS and CSP.
-- **`rateLimit(options)`** — `429` + `Retry-After` + `RateLimit-*` headers, with a
+- **`rateLimit(options)`** - `429` + `Retry-After` + `RateLimit-*` headers, with a
   pluggable `RateLimitStore`. Configure a trusted `key`, trusted single-IP `header`, or
   `trustedProxies`; a missing key source fails closed instead of silently sharing one
   bucket. The bundled `MemoryStore` **refuses to run in production** (a per-instance
-  limiter is unsafe across instances) — provide a shared store (Redis, etc.) there.
-- **`cache({ store, ttlMs })` / `responseCache(...)`** — full response cache with a pluggable
+  limiter is unsafe across instances) - provide a shared store (Redis, etc.) there.
+- **`cache({ store, ttlMs })` / `responseCache(...)`** - full response cache with a pluggable
   store, `Vary`-aware keys, `Age`, byte caps, and `Cache-Control` / `Set-Cookie` safety defaults.
   `MemoryResponseCache` is dev/single-instance only unless explicitly allowed in production.
-- **`timing()`** — `Server-Timing` plus typed `c.timing.metric/mark/measure` controls.
-- **`prettyJson()`** — capped, JSON-only pretty printing for debugging and developer-facing APIs.
-- **`methodOverride()`** — header/query method tunneling for clients that can only send `POST`.
+- **`timing()`** - `Server-Timing` plus typed `c.timing.metric/mark/measure` controls.
+- **`prettyJson()`** - capped, JSON-only pretty printing for debugging and developer-facing APIs.
+- **`methodOverride()`** - header/query method tunneling for clients that can only send `POST`.
   Header override is on by default; query override is opt-in.
-- **`trimTrailingSlash()` / `appendTrailingSlash()`** — redirect or rewrite URL canonicalization.
-- **`poweredBy()`** — opt-in product/framework header; Nifra emits no powered-by header by default.
-- **`language()` / `pickLanguage()`** — `Accept-Language` negotiation with typed `c.language`.
-- **`combine()` / `namedCombine()`** — reusable runtime bundles for middleware/plugins.
+- **`trimTrailingSlash()` / `appendTrailingSlash()`** - redirect or rewrite URL canonicalization.
+- **`poweredBy()`** - opt-in product/framework header; Nifra emits no powered-by header by default.
+- **`language()` / `pickLanguage()`** - `Accept-Language` negotiation with typed `c.language`.
+- **`combine()` / `namedCombine()`** - reusable runtime bundles for middleware/plugins.
 - **`requestId()` / `logger()` / `etag()` / `compression()` / `cacheControl()` /
-  `idempotency()` / `healthcheck()` / `openapi()`** — additional operational middleware for APIs.
+  `idempotency()` / `healthcheck()` / `openapi()`** - additional operational middleware for APIs.
 
 Request timeouts are configured at the core server boundary so they can abort `c.signal` and race the
 whole lifecycle:
@@ -80,7 +80,7 @@ const app = server({ requestTimeoutMs: 5_000 })
 
 ## For AI agents
 
-Start with [`LLM.md`](./LLM.md) — this package's contract card (the exports you call + its footguns),
+Start with [`LLM.md`](./LLM.md) - this package's contract card (the exports you call + its footguns),
 one cheap read instead of the whole corpus. For the wider framework: the repo's
 [`AGENTS.md`](../../AGENTS.md) is the copy-paste quick reference, and
 [`llms-full.txt`](../../llms-full.txt) is the full machine-readable corpus. Run `nifra check` as the

package/dist/_utils.d.ts

@@ -16,12 +16,12 @@ export declare function hmacSha256(input: string, secret: string | Uint8Array):
 export declare function verifyHmacSha256(input: string, signature: string, secret: string | Uint8Array): Promise<boolean>;
 /**
  * Apply header mutations to a response, in place when possible. Framework-built responses
- * (`new Response`, `Response.json`) have mutable headers across every runtime — so the common path
+ * (`new Response`, `Response.json`) have mutable headers across every runtime - so the common path
  * mutates `res` directly and returns it, allocating nothing. Only an *immutable*-headers response
- * (`Response.redirect()`/`Response.error()`, or a proxied `fetch()` response on Node/Deno/workerd —
+ * (`Response.redirect()`/`Response.error()`, or a proxied `fetch()` response on Node/Deno/workerd -
  * never on Bun) makes `.set`/`.append` throw; that path clones into a fresh `Headers` + `Response`,
  * exactly the old always-clone behavior. `apply` runs once either way (immutability is all-or-nothing
- * — the first mutation throws before any partial change), so a mutation chain is safe to pass.
+ * - the first mutation throws before any partial change), so a mutation chain is safe to pass.
  */
 export declare function withHeaders(res: Response, apply: (headers: Headers) => void): Response;
 //# sourceMappingURL=_utils.d.ts.map

package/dist/_utils.js

@@ -120,12 +120,12 @@ export async function verifyHmacSha256(input, signature, secret) {
 }
 /**
  * Apply header mutations to a response, in place when possible. Framework-built responses
- * (`new Response`, `Response.json`) have mutable headers across every runtime — so the common path
+ * (`new Response`, `Response.json`) have mutable headers across every runtime - so the common path
  * mutates `res` directly and returns it, allocating nothing. Only an *immutable*-headers response
- * (`Response.redirect()`/`Response.error()`, or a proxied `fetch()` response on Node/Deno/workerd —
+ * (`Response.redirect()`/`Response.error()`, or a proxied `fetch()` response on Node/Deno/workerd -
  * never on Bun) makes `.set`/`.append` throw; that path clones into a fresh `Headers` + `Response`,
  * exactly the old always-clone behavior. `apply` runs once either way (immutability is all-or-nothing
- * — the first mutation throws before any partial change), so a mutation chain is safe to pass.
+ * - the first mutation throws before any partial change), so a mutation chain is safe to pass.
  */
 export function withHeaders(res, apply) {
     try {

package/dist/admission.d.ts

@@ -2,7 +2,7 @@ import type { AdmissionController } from "@nifrajs/core/server";
 /**
  * Adaptive capacity admission. Rate limiting bounds request *frequency* and `@nifrajs/core/budget` bounds
  * request *duration*; neither stops a healthy instance from accepting more *concurrent* work than it
- * can finish. This gate admits on live capacity evidence — in-flight count + event-loop lag — briefly
+ * can finish. This gate admits on live capacity evidence - in-flight count + event-loop lag - briefly
  * queues at the edge, and sheds the rest with `429` + `Retry-After`, so p99 stays bounded under load
  * instead of collapsing.
  *
@@ -10,7 +10,7 @@ import type { AdmissionController } from "@nifrajs/core/server";
  * hook layers tenant priority and reserved capacity on top without leaking
  * those concerns into the OSS core.
  *
- * Wire it as the server's `admission` option (NOT an `onRequest` hook — a hook disables the native
+ * Wire it as the server's `admission` option (NOT an `onRequest` hook - a hook disables the native
  * route table). Off by default: when unset, the request path is untouched.
  */
 export type ShedReason = "inflight" | "loop-lag" | "queue-timeout" | "policy" | "cancelled";

package/dist/admission.js

@@ -1,5 +1,5 @@
 const OVERLOADED_BODY = JSON.stringify({ ok: false, error: "overloaded" });
-/** Shared no-op sampler — the fallback when an explicitly supplied monitor has no histogram. */
+/** Shared no-op sampler - the fallback when an explicitly supplied monitor has no histogram. */
 const NO_LAG = () => 0;
 /**
  * Event-loop-lag sampler. By default it measures timer drift using only Web/JS runtime primitives, so
@@ -159,7 +159,7 @@ export function createAdmissionController(options) {
                 return inFlight < maxInFlight + reserved ? occupy() : shedResponse("policy");
             }
         }
-        // Loop-lag shed: the box is behind on the event loop — reject regardless of slot count.
+        // Loop-lag shed: the box is behind on the event loop - reject regardless of slot count.
         if (lag > maxLagMs)
             return shedResponse("loop-lag");
         // FAST PATH (O(1)): a slot is free and lag is fine. No timer, no queue, no extra await.

package/dist/cache-control.d.ts

@@ -8,7 +8,7 @@ export interface CacheControlOptions {
 }
 /**
  * Set a `Cache-Control` header on matching responses. `value` is either a fixed directive string or a
- * function of the request (return `undefined` to leave a response untouched — e.g. cache by path).
+ * function of the request (return `undefined` to leave a response untouched - e.g. cache by path).
  * Defaults to `GET`/`HEAD` + 2xx, and never clobbers a `Cache-Control` the handler set itself.
  *
  * ```ts

package/dist/cache-control.js

@@ -1,7 +1,7 @@
 import { definePlugin } from "@nifrajs/core/server";
 /**
  * Set a `Cache-Control` header on matching responses. `value` is either a fixed directive string or a
- * function of the request (return `undefined` to leave a response untouched — e.g. cache by path).
+ * function of the request (return `undefined` to leave a response untouched - e.g. cache by path).
  * Defaults to `GET`/`HEAD` + 2xx, and never clobbers a `Cache-Control` the handler set itself.
  *
  * ```ts

package/dist/cache.js

@@ -189,7 +189,7 @@ export function cache(options) {
                 return withStatusHeader(res, cacheStatusHeader, "BYPASS");
             }
             // Shared-cache safety (RFC 9111 §3.5): never store a response to an authenticated request
-            // (Authorization or Cookie) unless it's explicitly public — otherwise a personalized 200 leaks
+            // (Authorization or Cookie) unless it's explicitly public - otherwise a personalized 200 leaks
             // across users. Opt in with `cacheAuthenticated: true` for a route that's the same for everyone.
             if (!cacheAuthenticated &&
                 (req.headers.has("authorization") || req.headers.has("cookie")) &&

package/dist/compression.d.ts

@@ -14,7 +14,7 @@ export interface CompressionOptions {
  *
  * The body is **peeked** up to `threshold` bytes to enforce the size floor: a response that ends below
  * the threshold is sent uncompressed (gzip's ~20-byte overhead would enlarge it), and only larger
- * bodies are compressed — the buffered prefix is replayed and the remainder streamed. (Runtimes rarely
+ * bodies are compressed - the buffered prefix is replayed and the remainder streamed. (Runtimes rarely
  * set `Content-Length` on a constructed `Response`, so the header alone can't gate this.)
  *
  * Skips: clients that don't accept gzip, already-encoded responses, bodyless responses (204/304/HEAD),

package/dist/compression.js

@@ -30,7 +30,7 @@ const gzipHeaders = (source) => {
  *
  * The body is **peeked** up to `threshold` bytes to enforce the size floor: a response that ends below
  * the threshold is sent uncompressed (gzip's ~20-byte overhead would enlarge it), and only larger
- * bodies are compressed — the buffered prefix is replayed and the remainder streamed. (Runtimes rarely
+ * bodies are compressed - the buffered prefix is replayed and the remainder streamed. (Runtimes rarely
  * set `Content-Length` on a constructed `Response`, so the header alone can't gate this.)
  *
  * Skips: clients that don't accept gzip, already-encoded responses, bodyless responses (204/304/HEAD),
@@ -47,7 +47,7 @@ export function compression(options = {}) {
     return definePlugin("compression", (app) => app.onResponse(async (res, req) => {
         const body = res.body;
         if (body === null)
-            return res; // 204/304/HEAD — nothing to compress
+            return res; // 204/304/HEAD - nothing to compress
         if (!(req.headers.get("accept-encoding") ?? "").toLowerCase().includes("gzip"))
             return res;
         if (res.headers.has("content-encoding"))
@@ -68,7 +68,7 @@ export function compression(options = {}) {
         while (total < threshold) {
             const { done, value } = await reader.read();
             if (done) {
-                // Body ended below the threshold — too small to be worth gzipping. Emit as-is.
+                // Body ended below the threshold - too small to be worth gzipping. Emit as-is.
                 return new Response(concat(buffered, total), {
                     status: res.status,
                     statusText: res.statusText,
@@ -78,7 +78,7 @@ export function compression(options = {}) {
             buffered.push(value);
             total += value.byteLength;
         }
-        // Over the threshold: replay the buffered prefix, then stream the rest — all through gzip.
+        // Over the threshold: replay the buffered prefix, then stream the rest - all through gzip.
         // (No explicit generic: it lets the chunk type infer from the non-shared reader so the stream
         // matches `CompressionStream`'s `Uint8Array` typing.)
         const source = new ReadableStream({

package/dist/cors.d.ts

@@ -18,7 +18,7 @@ export interface CorsOptions {
  * short-circuits to `204` via `onRequest`; the origin/credentials headers are added in
  * `onResponse`, so they also land on errors, 404s, and the preflight itself.
  *
- * Throws at construction if `credentials: true` is paired with `origin: "*"` — the
+ * Throws at construction if `credentials: true` is paired with `origin: "*"` - the
  * browser rejects that combination, so we fail loud instead of shipping dead CORS.
  */
 export declare function cors(options?: CorsOptions): Middleware;

package/dist/cors.js

@@ -25,14 +25,14 @@ function resolveAllowOrigin(option, requestOrigin) {
  * short-circuits to `204` via `onRequest`; the origin/credentials headers are added in
  * `onResponse`, so they also land on errors, 404s, and the preflight itself.
  *
- * Throws at construction if `credentials: true` is paired with `origin: "*"` — the
+ * Throws at construction if `credentials: true` is paired with `origin: "*"` - the
  * browser rejects that combination, so we fail loud instead of shipping dead CORS.
  */
 export function cors(options = {}) {
     const origin = options.origin ?? "*";
     const credentials = options.credentials ?? false;
     if (credentials && origin === "*") {
-        throw new Error('cors: `credentials: true` cannot be combined with `origin: "*"` — list explicit origin(s).');
+        throw new Error('cors: `credentials: true` cannot be combined with `origin: "*"` - list explicit origin(s).');
     }
     const methods = (options.methods ?? DEFAULT_METHODS).join(", ");
     const allowedHeaders = options.allowedHeaders?.join(", ");

package/dist/durable-command.d.ts

@@ -0,0 +1,34 @@
+import { type CapabilityExecutionJournal } from "@nifrajs/core/capabilities";
+import { type NifraPlugin } from "@nifrajs/core/server";
+export interface DurableCommandOptions {
+    /** Where effect transitions are recorded. `createDurableEffectJournal` from
+     * `@nifrajs/core/durable-execution` is the one this is built for; any implementation of the seam
+     * works, and a memory-backed one is a test double, not a durable command. */
+    readonly journal: CapabilityExecutionJournal;
+}
+/**
+ * Journal every capability effect on the routes below it, and declare the evidence that says so.
+ *
+ * A capability defined `idempotency: "durable"` requires `nifra.durable-command` evidence, and until
+ * this adapter existed nothing in the framework produced it. The only way to satisfy the tier was to
+ * write `assurance: ["nifra.durable-command"]` on the route - an assertion with nothing behind it,
+ * wrong in both directions: a route that genuinely journals its effects but omits the string fails
+ * `nifra check`, and a route that journals nothing but includes it passes.
+ *
+ * The evidence is a by-product here rather than a claim. Installing the adapter puts the journal on
+ * the request, so `executeCapability` records intent before an effect runs and exactly one terminal
+ * outcome after - which is what the tier is asking about. A call that passes its own `journal` still
+ * uses that one.
+ *
+ *     const commands = durableCommand({ journal: createDurableEffectJournal({ store }) })
+ *     const app = server().use(commands).post("/charge", { capabilities: ["billing.charge"] }, …)
+ *
+ * `beforeHandle` is order-scoped, like the auth plugins: routes registered before `.use(...)` are not
+ * covered, and the `subsequent` scope on the evidence says the same thing to `nifra check`.
+ *
+ * Note what this does NOT claim. Response replay (`schema.idempotency`) is a different guarantee and
+ * deliberately never proves this one: replaying a stored response after a crash mid-effect does not
+ * make the effect exactly-once, and the journal is what survives the crash.
+ */
+export declare function durableCommand(options: DurableCommandOptions): NifraPlugin;
+//# sourceMappingURL=durable-command.d.ts.map

package/dist/durable-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-command.d.ts","sourceRoot":"","sources":["../src/durable-command.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAErE,MAAM,WAAW,qBAAqB;IACpC;;iFAE6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,0BAA0B,CAAA;CAC7C;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,WAAW,CAuB1E"}

package/dist/durable-command.js

@@ -0,0 +1,50 @@
+import { NIFRA_ASSURANCE, withRouteAssurance } from "@nifrajs/core/assurance";
+import { attachCapabilityJournal, } from "@nifrajs/core/capabilities";
+import { definePlugin } from "@nifrajs/core/server";
+/**
+ * Journal every capability effect on the routes below it, and declare the evidence that says so.
+ *
+ * A capability defined `idempotency: "durable"` requires `nifra.durable-command` evidence, and until
+ * this adapter existed nothing in the framework produced it. The only way to satisfy the tier was to
+ * write `assurance: ["nifra.durable-command"]` on the route - an assertion with nothing behind it,
+ * wrong in both directions: a route that genuinely journals its effects but omits the string fails
+ * `nifra check`, and a route that journals nothing but includes it passes.
+ *
+ * The evidence is a by-product here rather than a claim. Installing the adapter puts the journal on
+ * the request, so `executeCapability` records intent before an effect runs and exactly one terminal
+ * outcome after - which is what the tier is asking about. A call that passes its own `journal` still
+ * uses that one.
+ *
+ *     const commands = durableCommand({ journal: createDurableEffectJournal({ store }) })
+ *     const app = server().use(commands).post("/charge", { capabilities: ["billing.charge"] }, …)
+ *
+ * `beforeHandle` is order-scoped, like the auth plugins: routes registered before `.use(...)` are not
+ * covered, and the `subsequent` scope on the evidence says the same thing to `nifra check`.
+ *
+ * Note what this does NOT claim. Response replay (`schema.idempotency`) is a different guarantee and
+ * deliberately never proves this one: replaying a stored response after a crash mid-effect does not
+ * make the effect exactly-once, and the journal is what survives the crash.
+ */
+export function durableCommand(options) {
+    const journal = options.journal;
+    if (journal === null || typeof journal !== "object") {
+        throw new TypeError("durableCommand: journal must be a CapabilityExecutionJournal");
+    }
+    for (const method of ["intent", "executing", "committed", "failed"]) {
+        if (typeof journal[method] !== "function") {
+            // Fail at wiring time. A journal missing a transition would otherwise surface as a mid-effect
+            // TypeError on the first write in production, with the evidence already declared.
+            throw new TypeError(`durableCommand: journal.${method} must be a function`);
+        }
+    }
+    const plugin = definePlugin("nifra:durable-command", (app) => app.beforeHandle((c) => {
+        attachCapabilityJournal(c, journal);
+        return undefined;
+    }));
+    return withRouteAssurance(plugin, {
+        id: NIFRA_ASSURANCE.DURABLE_COMMAND,
+        source: "durable-command",
+        scope: "subsequent",
+    });
+}
+//# sourceMappingURL=durable-command.js.map

package/dist/durable-command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-command.js","sourceRoot":"","sources":["../src/durable-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC7E,OAAO,EACL,uBAAuB,GAExB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,YAAY,EAAoB,MAAM,sBAAsB,CAAA;AASrE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,cAAc,CAAC,OAA8B;IAC3D,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAA;IAC/B,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QACpD,MAAM,IAAI,SAAS,CAAC,8DAA8D,CAAC,CAAA;IACrF,CAAC;IACD,KAAK,MAAM,MAAM,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,CAAU,EAAE,CAAC;QAC7E,IAAI,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,UAAU,EAAE,CAAC;YAC1C,8FAA8F;YAC9F,kFAAkF;YAClF,MAAM,IAAI,SAAS,CAAC,2BAA2B,MAAM,qBAAqB,CAAC,CAAA;QAC7E,CAAC;IACH,CAAC;IACD,MAAM,MAAM,GAAG,YAAY,CAAC,uBAAuB,EAAE,CAAC,GAAG,EAAE,EAAE,CAC3D,GAAG,CAAC,YAAY,CAAC,CAAC,CAAS,EAAE,EAAE;QAC7B,uBAAuB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAA;QACnC,OAAO,SAAS,CAAA;IAClB,CAAC,CAAC,CACH,CAAA;IACD,OAAO,kBAAkB,CAAC,MAAM,EAAE;QAChC,EAAE,EAAE,eAAe,CAAC,eAAe;QACnC,MAAM,EAAE,iBAAiB;QACzB,KAAK,EAAE,YAAY;KACpB,CAAC,CAAA;AACJ,CAAC"}

package/dist/etag.d.ts

@@ -1,12 +1,12 @@
 export interface ETagOptions {
-    /** Emit a weak validator (`W/"…"`). Default `true` — it's a content hash, not a byte-for-byte promise. */
+    /** Emit a weak validator (`W/"…"`). Default `true` - it's a content hash, not a byte-for-byte promise. */
     readonly weak?: boolean;
     /** Maximum response bytes to hash. Default `1_000_000`; larger responses pass through unchanged. */
     readonly maxBytes?: number;
 }
 /**
  * A {@link definePlugin} plugin that adds a content-hash `ETag` to `GET` `200` responses and returns
- * **`304 Not Modified`** when the client's `If-None-Match` matches — saving bandwidth on unchanged
+ * **`304 Not Modified`** when the client's `If-None-Match` matches - saving bandwidth on unchanged
  * responses. It reads and rebuilds small bodies only; larger responses pass through unchanged.
  * Idempotent.
  */

package/dist/etag.js

@@ -1,5 +1,5 @@
 import { definePlugin } from "@nifrajs/core/server";
-/** 32-bit FNV-1a over bytes → hex. A fast, dependency-free content fingerprint for ETags — not crypto. */
+/** 32-bit FNV-1a over bytes → hex. A fast, dependency-free content fingerprint for ETags - not crypto. */
 function fnv1a(bytes) {
     let h = 0x811c9dc5;
     for (let i = 0; i < bytes.length; i++) {
@@ -10,7 +10,7 @@ function fnv1a(bytes) {
 }
 /**
  * A {@link definePlugin} plugin that adds a content-hash `ETag` to `GET` `200` responses and returns
- * **`304 Not Modified`** when the client's `If-None-Match` matches — saving bandwidth on unchanged
+ * **`304 Not Modified`** when the client's `If-None-Match` matches - saving bandwidth on unchanged
  * responses. It reads and rebuilds small bodies only; larger responses pass through unchanged.
  * Idempotent.
  */
@@ -33,7 +33,7 @@ export function etag(options = {}) {
         const headers = new Headers(res.headers);
         headers.set("ETag", tag);
         if (matchesIfNoneMatch(req.headers.get("if-none-match"), tag)) {
-            // A 304 carries no body — drop the body-describing headers so strict intermediaries don't see a
+            // A 304 carries no body - drop the body-describing headers so strict intermediaries don't see a
             // null body with a non-zero Content-Length.
             headers.delete("content-length");
             headers.delete("content-type");

package/dist/healthcheck.d.ts

@@ -1,8 +1,8 @@
 type MaybePromise<T> = T | Promise<T>;
 export interface HealthcheckOptions {
-    /** Liveness path — always `200` while the process is up. Default `"/health"`. */
+    /** Liveness path - always `200` while the process is up. Default `"/health"`. */
     readonly path?: string;
-    /** Readiness path — runs `checks`; `200` if all pass, `503` otherwise. Default `"/ready"`. */
+    /** Readiness path - runs `checks`; `200` if all pass, `503` otherwise. Default `"/ready"`. */
     readyPath?: string;
     /** Readiness checks (DB ping, cache reachable, …). Each returns a boolean or throws; a throw counts
      * as failing. `/ready` reports each by name and is `200` only when all pass. */

package/dist/healthcheck.js

@@ -22,7 +22,7 @@ export function healthcheck(options = {}) {
         app.register("GET", readyPath, undefined, async () => {
             const results = {};
             let ready = true;
-            // Run checks concurrently; a throw (or false) marks that check — and the whole probe — not ready.
+            // Run checks concurrently; a throw (or false) marks that check - and the whole probe - not ready.
             await Promise.all(checkNames.map(async (name) => {
                 try {
                     results[name] = (await checks[name]?.()) === true;

package/dist/idempotency.d.ts

@@ -1,18 +1,18 @@
 import { type Middleware } from "@nifrajs/core/server";
 /**
- * Idempotency keys for unsafe requests — a client retrying a `POST` (dropped connection, impatient
+ * Idempotency keys for unsafe requests - a client retrying a `POST` (dropped connection, impatient
  * tap) with the same `Idempotency-Key` gets the **first** response replayed instead of the side effect
  * running twice (double-charge, double-publish). Runs in `onRequest` (before the handler), so a replay
  * or an in-flight collision short-circuits before any mutation.
  *
- * Pair it with a DB uniqueness constraint — this stops the *retry*, the constraint is the source of
+ * Pair it with a DB uniqueness constraint - this stops the *retry*, the constraint is the source of
  * truth for genuinely-concurrent distinct requests. Production MUST use a shared {@link IdempotencyStore}
  * (Redis, etc.) so the guarantee holds across instances; {@link MemoryIdempotencyStore} is dev-only.
  */
 /** A captured response, replayed verbatim on a retry. Body is base64 (binary-safe + JSON-serializable). */
 export interface IdempotencyRecord {
     readonly status: number;
-    /** Response headers, **excluding `Set-Cookie`** (cookies are session-specific — see {@link idempotency}). */
+    /** Response headers, **excluding `Set-Cookie`** (cookies are session-specific - see {@link idempotency}). */
     readonly headers: ReadonlyArray<readonly [string, string]>;
     /** Response body, base64-encoded. */
     readonly body: string;
@@ -43,7 +43,7 @@ export interface IdempotencyStore {
     release(key: string): Promise<void>;
 }
 export interface MemoryIdempotencyStoreOptions {
-    /** Allow the in-memory store in production. Off by default — a per-instance store can't dedupe across instances. */
+    /** Allow the in-memory store in production. Off by default - a per-instance store can't dedupe across instances. */
     readonly allowInProduction?: boolean;
 }
 /** In-process store. Refuses to run in production unless explicitly allowed (per-instance ⇒ no cross-instance dedupe). */

package/dist/idempotency.js

@@ -146,7 +146,7 @@ function replay(record) {
 /**
  * Idempotency-key middleware. Apply with `app.use(idempotency({ store }))`.
  *
- * **`Set-Cookie` is intentionally not cached or replayed** — a cookie set on the first request is
+ * **`Set-Cookie` is intentionally not cached or replayed** - a cookie set on the first request is
  * session-specific, so replaying it to a different caller (key collision or abuse) would leak/fixate a
  * session. Cache the body + status + the rest of the headers; let auth cookies re-issue per request.
  *
@@ -180,7 +180,7 @@ export function idempotency(options) {
                 return undefined;
             const key = keyOf(req, header);
             if (key === null || key === "")
-                return undefined; // opt-in per request — no key ⇒ no dedupe
+                return undefined; // opt-in per request - no key ⇒ no dedupe
             const claim = await store.begin(key, lockTtlMs);
             if (claim.state === "replay")
                 return replay(claim.record);
@@ -215,7 +215,7 @@ export function idempotency(options) {
                 throw err;
             }
             if (!("bytes" in captured)) {
-                await store.release(key); // too large to store — return it, but don't cache
+                await store.release(key); // too large to store - return it, but don't cache
                 return captured.response;
             }
             const bytes = captured.bytes;

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 /**
- * `@nifrajs/middleware` — composable, dependency-free middleware + plugins applied via `app.use()`.
+ * `@nifrajs/middleware` - composable, dependency-free middleware + plugins applied via `app.use()`.
  * The hardening set (`cors`, `rateLimit`, `securityHeaders`) returns a `@nifrajs/core` `Middleware`
  * (a hook bundle, context-agnostic). The seeded plugins (`requestId`, `logger`, `etag`, `bearer`,
- * `apiKey`) use the `definePlugin` convention — named (idempotent dedupe), and `requestId` threads
+ * `apiKey`) use the `definePlugin` convention - named (idempotent dedupe), and `requestId` threads
  * `c.requestId` into the handler context.
  */
 export { type AdmissionControllerHandle, type AdmissionEvidence, type AdmissionOptions, type AdmissionPolicy, type AdmissionSnapshot, createAdmissionController, createEventLoopLagSampler, type LoopDelayHistogram, type LoopDelayMonitor, type ShedReason, } from "./admission.js";
@@ -14,6 +14,7 @@ export { type Composable, combine, namedCombine } from "./combine.js";
 export { type CompressionOptions, compression } from "./compression.js";
 export { type CorsOptions, cors } from "./cors.js";
 export { type CsrfOptions, createCsrfToken, csrf, verifyCsrfToken, } from "./csrf.js";
+export { type DurableCommandOptions, durableCommand } from "./durable-command.js";
 export { type ETagOptions, etag } from "./etag.js";
 export { type HealthcheckOptions, healthcheck } from "./healthcheck.js";
 export { type IdempotencyClaim, type IdempotencyOptions, type IdempotencyRecord, type IdempotencyStore, idempotency, MemoryIdempotencyStore, type MemoryIdempotencyStoreOptions, } from "./idempotency.js";

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -1,8 +1,8 @@
 /**
- * `@nifrajs/middleware` — composable, dependency-free middleware + plugins applied via `app.use()`.
+ * `@nifrajs/middleware` - composable, dependency-free middleware + plugins applied via `app.use()`.
  * The hardening set (`cors`, `rateLimit`, `securityHeaders`) returns a `@nifrajs/core` `Middleware`
  * (a hook bundle, context-agnostic). The seeded plugins (`requestId`, `logger`, `etag`, `bearer`,
- * `apiKey`) use the `definePlugin` convention — named (idempotent dedupe), and `requestId` threads
+ * `apiKey`) use the `definePlugin` convention - named (idempotent dedupe), and `requestId` threads
  * `c.requestId` into the handler context.
  */
 export { createAdmissionController, createEventLoopLagSampler, } from "./admission.js";
@@ -14,6 +14,7 @@ export { combine, namedCombine } from "./combine.js";
 export { compression } from "./compression.js";
 export { cors } from "./cors.js";
 export { createCsrfToken, csrf, verifyCsrfToken, } from "./csrf.js";
+export { durableCommand } from "./durable-command.js";
 export { etag } from "./etag.js";
 export { healthcheck } from "./healthcheck.js";
 export { idempotency, MemoryIdempotencyStore, } from "./idempotency.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAML,yBAAyB,EACzB,yBAAyB,GAI1B,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAIL,SAAS,GACV,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAyB,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,EAGL,KAAK,EACL,mBAAmB,EAGnB,aAAa,GACd,MAAM,YAAY,CAAA;AACnB,OAAO,EAA4B,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAC3E,OAAO,EAAmB,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACrE,OAAO,EAA2B,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACvE,OAAO,EAAoB,IAAI,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,EAEL,eAAe,EACf,IAAI,EACJ,eAAe,GAChB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAoB,IAAI,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,EAA2B,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACvE,OAAO,EAKL,WAAW,EACX,sBAAsB,GAEvB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAA6C,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAC9F,OAAO,EAUL,GAAG,EACH,IAAI,EACJ,GAAG,EACH,YAAY,EAIZ,SAAS,GACV,MAAM,UAAU,CAAA;AACjB,OAAO,EAGL,QAAQ,EACR,YAAY,GACb,MAAM,eAAe,CAAA;AACtB,OAAO,EAAsB,MAAM,EAAyB,MAAM,aAAa,CAAA;AAC/E,OAAO,EAA8B,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACjF,OAAO,EACL,oBAAoB,EAMpB,OAAO,GAGR,MAAM,cAAc,CAAA;AACrB,OAAO,EAAyB,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,EAA0B,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,EACL,WAAW,EAKX,SAAS,GACV,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAyB,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,EAA+B,eAAe,EAAE,MAAM,uBAAuB,CAAA;AACpF,OAAO,EAA8D,MAAM,EAAE,MAAM,aAAa,CAAA;AAChG,OAAO,EAIL,MAAM,EAEN,MAAM,GACP,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,mBAAmB,EAEnB,iBAAiB,GAClB,MAAM,qBAAqB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAML,yBAAyB,EACzB,yBAAyB,GAI1B,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAIL,SAAS,GACV,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAyB,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,EAGL,KAAK,EACL,mBAAmB,EAGnB,aAAa,GACd,MAAM,YAAY,CAAA;AACnB,OAAO,EAA4B,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAC3E,OAAO,EAAmB,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACrE,OAAO,EAA2B,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACvE,OAAO,EAAoB,IAAI,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,EAEL,eAAe,EACf,IAAI,EACJ,eAAe,GAChB,MAAM,WAAW,CAAA;AAClB,OAAO,EAA8B,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACjF,OAAO,EAAoB,IAAI,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,EAA2B,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACvE,OAAO,EAKL,WAAW,EACX,sBAAsB,GAEvB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAA6C,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAC9F,OAAO,EAUL,GAAG,EACH,IAAI,EACJ,GAAG,EACH,YAAY,EAIZ,SAAS,GACV,MAAM,UAAU,CAAA;AACjB,OAAO,EAGL,QAAQ,EACR,YAAY,GACb,MAAM,eAAe,CAAA;AACtB,OAAO,EAAsB,MAAM,EAAyB,MAAM,aAAa,CAAA;AAC/E,OAAO,EAA8B,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACjF,OAAO,EACL,oBAAoB,EAMpB,OAAO,GAGR,MAAM,cAAc,CAAA;AACrB,OAAO,EAAyB,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,EAA0B,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,EACL,WAAW,EAKX,SAAS,GACV,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAyB,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,EAA+B,eAAe,EAAE,MAAM,uBAAuB,CAAA;AACpF,OAAO,EAA8D,MAAM,EAAE,MAAM,aAAa,CAAA;AAChG,OAAO,EAIL,MAAM,EAEN,MAAM,GACP,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,mBAAmB,EAEnB,iBAAiB,GAClB,MAAM,qBAAqB,CAAA"}

package/dist/logger.d.ts

@@ -11,8 +11,8 @@ export interface LoggerOptions {
     readonly log?: (fields: RequestLogFields) => void;
 }
 /**
- * A {@link definePlugin} plugin that logs one structured line per request — method, path, status,
- * and duration — via `onRequest`/`onResponse` (so it covers 404s and errors too). The start time is
+ * A {@link definePlugin} plugin that logs one structured line per request - method, path, status,
+ * and duration - via `onRequest`/`onResponse` (so it covers 404s and errors too). The start time is
  * paired to the request through a `WeakMap` (no per-request allocation leak). Idempotent.
  */
 export declare function logger(options?: LoggerOptions): import("@nifrajs/core/server").NifraPlugin<import("@nifrajs/core/server").AnyServer, import("@nifrajs/core/server").AnyServer>;

package/dist/logger.js

@@ -1,7 +1,7 @@
 import { definePlugin } from "@nifrajs/core/server";
 /**
- * A {@link definePlugin} plugin that logs one structured line per request — method, path, status,
- * and duration — via `onRequest`/`onResponse` (so it covers 404s and errors too). The start time is
+ * A {@link definePlugin} plugin that logs one structured line per request - method, path, status,
+ * and duration - via `onRequest`/`onResponse` (so it covers 404s and errors too). The start time is
  * paired to the request through a `WeakMap` (no per-request allocation leak). Idempotent.
  */
 export function logger(options = {}) {

package/dist/openapi.d.ts

@@ -1,4 +1,4 @@
-/** A registered route as seen by {@link buildOpenApiDocument} — structurally a `@nifrajs/core`
+/** A registered route as seen by {@link buildOpenApiDocument} - structurally a `@nifrajs/core`
  * `RouteDescriptor` (so `app.routes()` is passed straight through). */
 export interface RouteLike {
     readonly method: string;
@@ -49,7 +49,7 @@ export interface OpenApiOptions {
         readonly method: string;
         readonly path: string;
     }) => boolean;
-    /** Per-operation overrides keyed by `"GET /users/:id"`, shallow-merged over the generated skeleton —
+    /** Per-operation overrides keyed by `"GET /users/:id"`, shallow-merged over the generated skeleton -
      * the escape hatch for rich request/response schemas, tags, and per-op security (Standard Schema
      * can't be introspected). */
     readonly operations?: Readonly<Record<string, Record<string, unknown>>>;
@@ -66,10 +66,10 @@ export interface OpenApiOptions {
  */
 export declare function buildOpenApiDocument(routes: readonly RouteLike[], options?: OpenApiOptions): Record<string, unknown>;
 /**
- * Serve an OpenAPI 3.1 document (a structural subset — see {@link buildOpenApiDocument}) at
+ * Serve an OpenAPI 3.1 document (a structural subset - see {@link buildOpenApiDocument}) at
  * `options.path` (default `/openapi.json`), generated from the app's registered routes. Generation is
  * **lazy + memoized**: it reads `app.routes()` on the first request, by which point every route is
- * registered — so the plugin's own position in the chain doesn't matter.
+ * registered - so the plugin's own position in the chain doesn't matter.
  *
  * Pass `ui: true` (or `ui: { path, title, cdn }`) to also serve a Scalar API-reference page (default
  * `/reference`) that renders the spec. The page loads Scalar from a CDN; pin/self-host via `ui.cdn`,