@nifrajs/core 1.13.0 → 2.1.0

package/src/wire.ts

@@ -0,0 +1,474 @@
+/**
+ * Rich-type wire codec: round-trips values that plain JSON silently drops or corrupts, across any
+ * JSON transport (RPC bodies, loader payloads, WebSocket frames).
+ *
+ * `JSON.stringify` turns `undefined` into a missing key, `Date` into a lossy string, `NaN`/`Infinity`
+ * into `null`, loses `-0`, and throws on `BigInt` - and it has no notion of `Map`, `Set`, `RegExp`,
+ * `URL`, `ArrayBuffer`, or typed arrays. It also flattens a shared reference into two copies and throws
+ * on a cycle. A typed client that infers `Date` from the server type then receives a `string` at runtime
+ * is exactly the drift this framework exists to remove. `encode` maps a value to a JSON-safe structure
+ * that `decode` reconstructs exactly - including cycles and preserved reference identity; `stringify` /
+ * `parse` are the drop-in `JSON.*` equivalents.
+ *
+ * The wire form is `{ r, n }`: `r` is the root (an inline value or a `ref`), `n` is a flat table of
+ * container/rich nodes addressed by index. Because every object is interned in `n` and referenced by
+ * index, a shared object is encoded once (and decodes to a single shared instance), and a cycle is a
+ * back-reference rather than infinite recursion. Functions and symbols are rejected, never silently
+ * dropped. Decoding validates every tag and index, so a malformed payload throws {@link WireDecodeError}
+ * rather than producing a corrupt value.
+ *
+ * Not covered by design (matches `JSON`): class identity (a class instance decodes to a plain object
+ * carrying its own enumerable properties), non-enumerable and symbol keys, and getters (read once).
+ */
+
+/** Discriminator key on a tagged wire node. Never collides with user data: user objects live under a
+ * node's `v` field, so their own keys - including one literally named `$w` - are never re-interpreted. */
+const TAG = "$w"
+
+/** The JSON-safe encoded form produced by {@link encode} and consumed by {@link decode}. */
+export interface Wire {
+  /** The root value: an inline primitive/scalar, or a `{ [TAG]: "ref", i }` into {@link Wire.n}. */
+  readonly r: unknown
+  /** Interned container and rich-type nodes, addressed by index from `ref`s. */
+  readonly n: readonly unknown[]
+}
+
+/** Resource limits applied while reconstructing transport-controlled wire data. */
+export interface WireDecodeLimits {
+  /** Maximum number of interned nodes. Default 10,000. */
+  readonly maxNodes?: number
+  /** Maximum nesting depth across containers and references. Default 256. */
+  readonly maxDepth?: number
+  /** Maximum total object/array/map/set entries visited. Default 100,000. */
+  readonly maxCollectionEntries?: number
+  /** Maximum UTF-8 string plus decoded binary bytes materialized. Default 16 MiB. */
+  readonly maxDecodedBytes?: number
+}
+
+export const DEFAULT_WIRE_DECODE_LIMITS: Readonly<Required<WireDecodeLimits>> = Object.freeze({
+  maxNodes: 10_000,
+  maxDepth: 256,
+  maxCollectionEntries: 100_000,
+  maxDecodedBytes: 16 * 1024 * 1024,
+})
+
+/** Thrown by {@link encode} for a value it will not encode (a function or a symbol). */
+export class WireEncodeError extends TypeError {
+  constructor(message: string) {
+    super(message)
+    this.name = "WireEncodeError"
+  }
+}
+
+/** Thrown by {@link decode} for a wire value carrying an unknown tag, a bad index, or malformed shape. */
+export class WireDecodeError extends TypeError {
+  constructor(message: string) {
+    super(message)
+    this.name = "WireDecodeError"
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+}
+
+function decodeLimit(value: number | undefined, fallback: number, label: string): number {
+  const limit = value ?? fallback
+  if (!Number.isSafeInteger(limit) || limit < 0) {
+    throw new RangeError(`wire decode ${label} must be a non-negative safe integer`)
+  }
+  return limit
+}
+
+function utf8ByteLength(value: string, stopAfter = Number.MAX_SAFE_INTEGER): number {
+  let bytes = 0
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index)
+    if (code < 0x80) bytes++
+    else if (code < 0x800) bytes += 2
+    else if (code >= 0xd800 && code <= 0xdbff && index + 1 < value.length) {
+      const next = value.charCodeAt(index + 1)
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        bytes += 4
+        index++
+      } else bytes += 3
+    } else bytes += 3
+    if (bytes > stopAfter) return bytes
+  }
+  return bytes
+}
+
+/** The typed-array kinds the codec round-trips, by constructor name. */
+const TYPED_ARRAYS = {
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array,
+} as const
+type TypedArrayName = keyof typeof TYPED_ARRAYS
+type TypedArray = InstanceType<(typeof TYPED_ARRAYS)[TypedArrayName]>
+
+function defineEnumerableOwn(target: object, key: string, value: unknown): void {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true,
+  })
+}
+
+// ─── encode ─────────────────────────────────────────────────────────────────
+
+/** Encode any supported value into a JSON-safe {@link Wire} form. */
+export function encode(value: unknown): Wire {
+  const nodes: unknown[] = []
+  const interned = new Map<object, number>()
+
+  /** Encode a value to its inline wire form, interning objects into `nodes` and returning a `ref`. */
+  const inline = (v: unknown): unknown => {
+    if (v === undefined) return { [TAG]: "undef" }
+    if (v === null) return null
+
+    switch (typeof v) {
+      case "string":
+      case "boolean":
+        return v
+      case "number":
+        if (Object.is(v, -0)) return { [TAG]: "num", v: "-0" }
+        if (Number.isNaN(v)) return { [TAG]: "num", v: "NaN" }
+        if (v === Infinity) return { [TAG]: "num", v: "Infinity" }
+        if (v === -Infinity) return { [TAG]: "num", v: "-Infinity" }
+        return v // a finite, signed-zero-free number is already JSON-safe
+      case "bigint":
+        return { [TAG]: "bigint", v: v.toString() }
+      case "function":
+      case "symbol":
+        throw new WireEncodeError(`cannot encode a ${typeof v}`)
+    }
+
+    const obj = v as object
+    const existing = interned.get(obj)
+    if (existing !== undefined) return { [TAG]: "ref", i: existing }
+
+    // Reserve this object's index BEFORE encoding its body, so a self- or mutual-reference inside the
+    // body resolves to a `ref` here instead of recursing forever.
+    const index = nodes.length
+    interned.set(obj, index)
+    nodes.push(0) // placeholder, overwritten below
+    nodes[index] = body(v, inline)
+    return { [TAG]: "ref", i: index }
+  }
+
+  return { r: inline(value), n: nodes }
+}
+
+/** Encode the interned body of one object into its tagged node. */
+function body(v: unknown, inline: (x: unknown) => unknown): unknown {
+  if (v instanceof Date) {
+    const time = v.getTime()
+    return { [TAG]: "date", v: Number.isNaN(time) ? null : v.toISOString() }
+  }
+  if (v instanceof RegExp) return { [TAG]: "regexp", v: [v.source, v.flags] }
+  if (v instanceof URL) return { [TAG]: "url", v: v.href }
+  if (v instanceof ArrayBuffer) return { [TAG]: "buf", v: bytesToBase64(new Uint8Array(v)) }
+  if (v instanceof DataView) {
+    return { [TAG]: "dv", v: bytesToBase64(new Uint8Array(v.buffer, v.byteOffset, v.byteLength)) }
+  }
+  if (ArrayBuffer.isView(v)) {
+    const view = v as TypedArray
+    const kind = view.constructor.name
+    if (!(kind in TYPED_ARRAYS)) throw new WireEncodeError(`cannot encode typed array ${kind}`)
+    return {
+      [TAG]: "ta",
+      k: kind,
+      v: bytesToBase64(new Uint8Array(view.buffer, view.byteOffset, view.byteLength)),
+    }
+  }
+  if (v instanceof Map) {
+    return { [TAG]: "map", v: Array.from(v, ([k, val]) => [inline(k), inline(val)]) }
+  }
+  if (v instanceof Set) return { [TAG]: "set", v: Array.from(v, (item) => inline(item)) }
+  if (Array.isArray(v)) return { [TAG]: "arr", v: v.map((item) => inline(item)) }
+
+  const record = v as Record<string, unknown>
+  const out: Record<string, unknown> = {}
+  for (const key of Object.keys(record)) defineEnumerableOwn(out, key, inline(record[key]))
+  return { [TAG]: "obj", v: out }
+}
+
+// ─── decode ─────────────────────────────────────────────────────────────────
+
+/** Reconstruct the original value from a {@link Wire} form produced by {@link encode}. */
+export function decode(wire: Wire, limits: WireDecodeLimits = {}): unknown {
+  if (!isRecord(wire) || !Object.hasOwn(wire, "r") || !Array.isArray(wire.n)) {
+    throw new WireDecodeError("not a wire value: expected { r, n }")
+  }
+  const nodes = wire.n
+  const maxNodes = decodeLimit(limits.maxNodes, DEFAULT_WIRE_DECODE_LIMITS.maxNodes, "maxNodes")
+  const maxDepth = decodeLimit(limits.maxDepth, DEFAULT_WIRE_DECODE_LIMITS.maxDepth, "maxDepth")
+  const maxCollectionEntries = decodeLimit(
+    limits.maxCollectionEntries,
+    DEFAULT_WIRE_DECODE_LIMITS.maxCollectionEntries,
+    "maxCollectionEntries",
+  )
+  const maxDecodedBytes = decodeLimit(
+    limits.maxDecodedBytes,
+    DEFAULT_WIRE_DECODE_LIMITS.maxDecodedBytes,
+    "maxDecodedBytes",
+  )
+  if (nodes.length > maxNodes) throw new WireDecodeError("wire node limit exceeded")
+  const built = new Map<number, unknown>()
+  let collectionEntries = 0
+  let decodedBytes = 0
+
+  const enter = (depth: number): void => {
+    if (depth > maxDepth) throw new WireDecodeError("wire depth limit exceeded")
+  }
+  const chargeEntries = (count: number): void => {
+    collectionEntries += count
+    if (!Number.isSafeInteger(collectionEntries) || collectionEntries > maxCollectionEntries) {
+      throw new WireDecodeError("wire collection entry limit exceeded")
+    }
+  }
+  const chargeBytes = (count: number): void => {
+    decodedBytes += count
+    if (!Number.isSafeInteger(decodedBytes) || decodedBytes > maxDecodedBytes) {
+      throw new WireDecodeError("wire decoded byte limit exceeded")
+    }
+  }
+  const chargeString = (value: string): void =>
+    chargeBytes(utf8ByteLength(value, maxDecodedBytes - decodedBytes))
+
+  const inline = (w: unknown, depth: number): unknown => {
+    enter(depth)
+    if (w === null || typeof w === "boolean") return w
+    if (typeof w === "string") {
+      chargeString(w)
+      return w
+    }
+    if (typeof w === "number") {
+      if (!Number.isFinite(w) || Object.is(w, -0)) {
+        throw new WireDecodeError("malformed wire: non-JSON number inline")
+      }
+      return w
+    }
+    if (!isRecord(w)) throw new WireDecodeError("malformed wire: invalid inline value")
+    const record = w
+    const tag = record[TAG]
+    if (typeof tag !== "string")
+      throw new WireDecodeError("malformed wire: object without a tag inline")
+    switch (tag) {
+      case "undef":
+        return undefined
+      case "num": {
+        const v = record.v
+        if (v === "-0") return -0
+        if (v === "NaN") return NaN
+        if (v === "Infinity") return Infinity
+        if (v === "-Infinity") return -Infinity
+        throw new WireDecodeError(`malformed num token: ${String(v)}`)
+      }
+      case "bigint": {
+        if (typeof record.v !== "string" || !/^-?(?:0|[1-9][0-9]*)$/u.test(record.v)) {
+          throw new WireDecodeError("malformed bigint token")
+        }
+        chargeString(record.v)
+        return BigInt(record.v)
+      }
+      case "ref":
+        return resolve(record.i, depth)
+      default:
+        throw new WireDecodeError(`unexpected inline tag: ${tag}`)
+    }
+  }
+
+  const resolve = (raw: unknown, depth: number): unknown => {
+    enter(depth)
+    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0 || raw >= nodes.length) {
+      throw new WireDecodeError(`ref out of range: ${String(raw)}`)
+    }
+    const index = raw
+    const cached = built.get(index)
+    if (cached !== undefined || built.has(index)) return cached
+
+    const node = nodes[index]
+    if (!isRecord(node)) throw new WireDecodeError(`malformed node at ${index}`)
+    const record = node
+    const tag = record[TAG]
+
+    switch (tag) {
+      case "obj": {
+        if (!isRecord(record.v)) throw new WireDecodeError(`malformed obj node at ${index}`)
+        const out: Record<string, unknown> = {}
+        built.set(index, out) // publish the shell first so cycles resolve to it
+        const src = record.v
+        const keys = Object.keys(src)
+        chargeEntries(keys.length)
+        for (const key of keys) {
+          chargeString(key)
+          defineEnumerableOwn(out, key, inline(src[key], depth + 1))
+        }
+        return out
+      }
+      case "arr": {
+        if (!Array.isArray(record.v)) throw new WireDecodeError(`malformed arr node at ${index}`)
+        const out: unknown[] = []
+        built.set(index, out)
+        chargeEntries(record.v.length)
+        for (const item of record.v) out.push(inline(item, depth + 1))
+        return out
+      }
+      case "map": {
+        if (!Array.isArray(record.v)) throw new WireDecodeError(`malformed map node at ${index}`)
+        const out = new Map<unknown, unknown>()
+        built.set(index, out)
+        chargeEntries(record.v.length)
+        for (const entry of record.v) {
+          if (!Array.isArray(entry) || entry.length !== 2) {
+            throw new WireDecodeError(`malformed map entry at ${index}`)
+          }
+          out.set(inline(entry[0], depth + 1), inline(entry[1], depth + 1))
+        }
+        return out
+      }
+      case "set": {
+        if (!Array.isArray(record.v)) throw new WireDecodeError(`malformed set node at ${index}`)
+        const out = new Set<unknown>()
+        built.set(index, out)
+        chargeEntries(record.v.length)
+        for (const item of record.v) out.add(inline(item, depth + 1))
+        return out
+      }
+      case "date": {
+        if (record.v !== null && typeof record.v !== "string") {
+          throw new WireDecodeError(`malformed date node at ${index}`)
+        }
+        if (record.v !== null) chargeString(record.v)
+        const out = record.v === null ? new Date(NaN) : new Date(record.v)
+        if (record.v !== null && (Number.isNaN(out.getTime()) || out.toISOString() !== record.v)) {
+          throw new WireDecodeError(`malformed date node at ${index}`)
+        }
+        built.set(index, out)
+        return out
+      }
+      case "regexp": {
+        if (
+          !Array.isArray(record.v) ||
+          record.v.length !== 2 ||
+          typeof record.v[0] !== "string" ||
+          typeof record.v[1] !== "string"
+        ) {
+          throw new WireDecodeError(`malformed regexp node at ${index}`)
+        }
+        chargeString(record.v[0])
+        chargeString(record.v[1])
+        let out: RegExp
+        try {
+          out = new RegExp(record.v[0], record.v[1])
+        } catch {
+          throw new WireDecodeError(`malformed regexp node at ${index}`)
+        }
+        built.set(index, out)
+        return out
+      }
+      case "url": {
+        if (typeof record.v !== "string") {
+          throw new WireDecodeError(`malformed url node at ${index}`)
+        }
+        chargeString(record.v)
+        let out: URL
+        try {
+          out = new URL(record.v)
+        } catch {
+          throw new WireDecodeError(`malformed url node at ${index}`)
+        }
+        built.set(index, out)
+        return out
+      }
+      case "buf": {
+        const out = base64ToBytes(record.v, index, chargeBytes).buffer
+        built.set(index, out)
+        return out
+      }
+      case "dv": {
+        const out = new DataView(base64ToBytes(record.v, index, chargeBytes).buffer)
+        built.set(index, out)
+        return out
+      }
+      case "ta": {
+        const kind = record.k
+        if (typeof kind !== "string" || !(kind in TYPED_ARRAYS)) {
+          throw new WireDecodeError(`unknown typed array: ${String(kind)}`)
+        }
+        const Ctor = TYPED_ARRAYS[kind as TypedArrayName]
+        const bytes = base64ToBytes(record.v, index, chargeBytes)
+        if (bytes.byteLength % Ctor.BYTES_PER_ELEMENT !== 0) {
+          throw new WireDecodeError(`misaligned bytes for ${kind}`)
+        }
+        // `base64ToBytes` always allocates a fresh, non-shared ArrayBuffer, so this narrowing is sound.
+        const out = new Ctor(
+          bytes.buffer as ArrayBuffer,
+          0,
+          bytes.byteLength / Ctor.BYTES_PER_ELEMENT,
+        )
+        built.set(index, out)
+        return out
+      }
+      default:
+        throw new WireDecodeError(`unknown wire tag: ${String(tag)}`)
+    }
+  }
+
+  return inline(wire.r, 0)
+}
+
+/** `encode` + `JSON.stringify` in one call - the rich-type equivalent of `JSON.stringify`. */
+export function stringify(value: unknown): string {
+  return JSON.stringify(encode(value))
+}
+
+/** `JSON.parse` + `decode` in one call - the rich-type equivalent of `JSON.parse`. */
+export function parse(text: string, limits: WireDecodeLimits = {}): unknown {
+  return decode(JSON.parse(text) as Wire, limits)
+}
+
+// ─── base64 (portable across Bun / browser / Workers / Node / Deno) ───────────
+
+function bytesToBase64(bytes: Uint8Array): string {
+  let binary = ""
+  const CHUNK = 0x8000 // chunk so String.fromCharCode(...) never overflows the call stack
+  for (let i = 0; i < bytes.length; i += CHUNK)
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK))
+  return btoa(binary)
+}
+
+function base64ToBytes(
+  base64: unknown,
+  index: number,
+  reserve: (decodedBytes: number) => void,
+): Uint8Array {
+  if (typeof base64 !== "string" || base64.length % 4 !== 0) {
+    throw new WireDecodeError(`malformed base64 at ${index}`)
+  }
+  const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0
+  reserve((base64.length / 4) * 3 - padding)
+  if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(base64)) {
+    throw new WireDecodeError(`malformed base64 at ${index}`)
+  }
+  let binary: string
+  try {
+    binary = atob(base64)
+  } catch {
+    throw new WireDecodeError(`malformed base64 at ${index}`)
+  }
+  const bytes = new Uint8Array(binary.length)
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
+  return bytes
+}

package/src/ws.ts

@@ -1,33 +1,56 @@
 /**
- * WebSocket runtime for `@nifrajs/core` — import once at your server entry to enable `app.ws()`:
+ * The opt-in WebSocket runtime plugin.
  *
- *   import "@nifrajs/core/ws"
+ * `.use(websocket())` enables `app.ws()`:
  *
- *   const app = server().ws("/chat", { message: (ws, data) => ws.send(data) })
+ *   import { websocket } from "@nifrajs/core/ws"
  *
- * Why a subpath: an app that never uses WebSockets shouldn't ship the WS dispatcher, pub/sub
- * registry, and Bun socket plumbing in its server bundle (~1.5 KB gzipped on the minimal-app size
- * benchmark). Importing this module registers the runtime with the core server (idempotent);
- * calling `app.ws()` without it fails loud at boot with a `WS_RUNTIME_MISSING` error pointing here.
+ *   const app = server().use(websocket()).ws("/chat", { message: (ws, data) => ws.send(data) })
+ *
+ * Without it, `app.ws()` throws at registration (fail-closed), so an app that never uses WebSockets
+ * never evaluates or bundles the WS dispatcher, pub/sub registry, and Bun socket plumbing (~1.5 KB
+ * gzipped on the minimal-app size benchmark). The runtime installs on that server instance only -
+ * the same `.use()` install seam as `mcp()` / `streaming()` / `idempotency()`, not a process-global
+ * or a side-effect import.
  *
  * Serving adapters that wire standard sockets themselves (`@nifrajs/workers`) import
  * `attachWebSocket` / `TopicRegistry` from here too.
  */
 
+import { INSTALL_WS } from "./server/install.ts"
+import type { IdentityPlugin } from "./server/plugin.ts"
+import type { AnyServer } from "./server/server.ts"
 import {
   attachWebSocket,
   TopicRegistry,
   wrapWebSocketMessageValidation,
 } from "./server/websocket.ts"
 import { createBunWsHandlers } from "./server/ws-bun.ts"
-import { setWsRuntime } from "./server/ws-hook.ts"
+import type { WsRuntime } from "./server/ws-hook.ts"
 
-setWsRuntime({
+const WS_RUNTIME: WsRuntime = {
   wrapHandler: wrapWebSocketMessageValidation,
   createTopics: () => new TopicRegistry(),
   bunHandlers: createBunWsHandlers,
   attach: attachWebSocket,
-})
+}
+
+/** The install seam a server exposes so the `websocket()` plugin can hand it the runtime. */
+interface WsInstallable {
+  [INSTALL_WS](runtime: WsRuntime): void
+}
+
+/**
+ * Enable WebSocket routes on a server: `.use(websocket())` turns on `app.ws()`. Applying it twice is
+ * a no-op (named plugin dedupe).
+ */
+export function websocket(): IdentityPlugin {
+  const apply = <S extends AnyServer>(app: S): S => {
+    ;(app as unknown as WsInstallable)[INSTALL_WS](WS_RUNTIME)
+    return app
+  }
+  return Object.assign(apply, { pluginName: "nifra:websocket" }) as IdentityPlugin
+}
 
 export type {
   NifraWebSocket,

package/dist/invariants.d.ts

@@ -1,70 +0,0 @@
-/**
- * Contract-generated invariant tests: the declared contract *is* the test suite.
- *
- * `runContractInvariants(app)` reads each route's reflected contract (schemas, classification) and
- * verifies, with deterministic seeded fuzzing, the properties the contract already promises:
- *
- *  1. **Classification consistency** (static) — a route whose response fields are tagged more
- *     sensitive than its declared route-level classification is understating what it emits.
- *  2. **Valid input never crashes** (dynamic) — schema-generated valid requests must not produce 5xx.
- *  3. **Response conformance** (dynamic) — a 2xx response body must validate against the declared
- *     response schema; an undeclared response shape is exactly where sensitive data leaks.
- *  4. **Validation fails closed** (dynamic) — schema-violating bodies must be rejected (4xx), never
- *     accepted (2xx) and never crash (5xx).
- *
- * Everything is deterministic: a seeded PRNG (no ambient randomness, no wall clock), so a failing
- * case reproduces from its seed. Routes whose inputs cannot be generated from their JSON Schema are
- * reported in `skipped` — never silently dropped.
- */
-export type InvariantFindingCode = "classification-understated" | "server-error-on-valid-input" | "response-schema-violation" | "validation-bypass" | "server-error-on-invalid-input";
-export interface InvariantFinding {
-    readonly code: InvariantFindingCode;
-    readonly method: string;
-    readonly path: string;
-    /** The case's deterministic seed — rerun with it to reproduce the exact request. */
-    readonly seed?: number;
-    readonly message: string;
-}
-export interface SkippedRoute {
-    readonly method: string;
-    readonly path: string;
-    readonly reason: string;
-}
-export interface InvariantReport {
-    readonly ok: boolean;
-    /** Routes exercised dynamically. */
-    readonly tested: readonly {
-        readonly method: string;
-        readonly path: string;
-    }[];
-    /** Routes that could not be exercised, with the reason — reported, never silently dropped. */
-    readonly skipped: readonly SkippedRoute[];
-    readonly findings: readonly InvariantFinding[];
-}
-export interface RunInvariantsOptions {
-    /** Deterministic seed for the fuzzer. Default 1. */
-    readonly seed?: number;
-    /** Valid-input cases per route. Default 8. */
-    readonly casesPerRoute?: number;
-    /** Invalid-input (mutated) cases per route with a body schema. Default 4. */
-    readonly invalidCasesPerRoute?: number;
-    /**
-     * Explicit isolated executor for dynamic cases. It must point at a disposable test app, sandbox,
-     * or transaction that is rolled back. The runner never calls `source.fetch()` implicitly: doing so
-     * could charge cards, send mail, or mutate production state merely by running a verification tool.
-     */
-    readonly executor?: InvariantExecutor;
-}
-export type InvariantExecutor = (request: Request) => Response | Promise<Response>;
-/** Opaque route-reflection source. The runner never invokes an app's live fetch method implicitly. */
-type ReflectableApp = object;
-/** Deterministic PRNG (mulberry32). Ambient randomness would make failures unreproducible. */
-export declare function createSeededRandom(seed: number): () => number;
-/** Run the contract-derived invariant suite against a reflectable app. Pure; no ambient state. */
-/**
- * @deprecated Use `runAdversarialContract` from `@nifrajs/testing`. The testing package is the
- * authoritative deep contract laboratory and powers CLI L4; this export remains for compatibility.
- */
-export declare function runContractInvariants(app: ReflectableApp, options?: RunInvariantsOptions): Promise<InvariantReport>;
-export {};
-//# sourceMappingURL=invariants.d.ts.map

package/dist/invariants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invariants.d.ts","sourceRoot":"","sources":["../src/invariants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAWH,MAAM,MAAM,oBAAoB,GAC5B,4BAA4B,GAC5B,6BAA6B,GAC7B,2BAA2B,GAC3B,mBAAmB,GACnB,+BAA+B,CAAA;AAEnC,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAA;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,oFAAoF;IACpF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,oCAAoC;IACpC,QAAQ,CAAC,MAAM,EAAE,SAAS;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAC9E,8FAA8F;IAC9F,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAA;IACzC,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAA;CAC/C;AAED,MAAM,WAAW,oBAAoB;IACnC,oDAAoD;IACpD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,8CAA8C;IAC9C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B,6EAA6E;IAC7E,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;IACtC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CACtC;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;AAElF,sGAAsG;AACtG,KAAK,cAAc,GAAG,MAAM,CAAA;AA0B5B,8FAA8F;AAC9F,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,MAAM,CAS7D;AA8ND,kGAAkG;AAClG;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,cAAc,EACnB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,eAAe,CAAC,CAmG1B"}