@sema-ai/core 1.275.1

package/dist/core/pricing.js

@@ -0,0 +1,46 @@
+/**
+ * Cost computation (1.37). core never hardcodes provider pricing — a deployment injects it via
+ * `RunnerDeps.pricing` or each `Model.cost`. All prices are **absolute per-1M-token USD**, not
+ * multipliers: each provider's adapter precomputes its discount into an absolute value
+ * (OpenAI/DeepSeek: the cache-hit price; Anthropic: base×0.1 read / ×1.25 5min-write / ×2.0 1h-write).
+ */
+const per1M = (tokens, price) => price && tokens ? (tokens * price) / 1e6 : 0;
+/**
+ * Cost in **integer micro-USD** (1e-6 USD) — integer to avoid float-accumulation error in billing
+ * reconcile (Stripe/AWS-style). Convergent across providers: full-price input = `totalInputTokens`
+ * minus all cache tokens; cache read/write priced at their own absolute rates; output at its rate.
+ *
+ * DeepSeek (hit price as `cacheReadPer1M`, no cache-write) and OpenAI (no 1h write) fall out by their
+ * zero token counts; Anthropic uses all fields. This fixes P2 (cached charged at full price) by
+ * pricing the cache subset separately instead of trusting the brain's possibly-overstated cost total.
+ */
+export function computeCostMicroUsd(counts, pricing) {
+    // A-4: a cache subset with NO configured price falls back to FULL-PRICE input (the documented
+    // contract: "absent ⇒ treated as full-price input"), not free. Only an EXPLICIT 0 means free.
+    // Previously the subset was unconditionally removed from fullInput AND priced via per1M(_, undefined)=0,
+    // so a cost table with just {input,output} (common for OpenAI auto-cache) billed cacheRead at 0 — a
+    // warm loop (80-95% cacheRead) under-billed to ~1/5, defeating overBudget/cascade/verify cost ceilings.
+    const billedCacheRead = pricing.cacheReadPer1M !== undefined ? counts.cacheReadTokens : 0;
+    const billedCacheWrite = pricing.cacheWritePer1M !== undefined ? counts.cacheWriteTokens : 0;
+    const billedCacheWriteLong = pricing.cacheWriteLongPer1M !== undefined ? counts.cacheWriteTokensLong : 0;
+    // Cache subsets WITHOUT a price stay in fullInput (charged at the input rate); priced ones are removed.
+    const fullInput = Math.max(0, counts.totalInputTokens - billedCacheRead - billedCacheWrite - billedCacheWriteLong);
+    const usd = per1M(fullInput, pricing.inputPer1M) +
+        per1M(billedCacheRead, pricing.cacheReadPer1M) +
+        per1M(billedCacheWrite, pricing.cacheWritePer1M) +
+        per1M(billedCacheWriteLong, pricing.cacheWriteLongPer1M) +
+        per1M(counts.outputTokens, pricing.outputPer1M);
+    return Math.round(usd * 1e6);
+}
+/** Map a vendor `Model.cost` (already per-1M absolute) to `ModelPricing`. We don't emit 1h cache
+ *  writes, so `cacheWriteLongPer1M` defaults to the 5-min write price (irrelevant while that count is 0). */
+export function modelCostToPricing(cost) {
+    return {
+        inputPer1M: cost?.input ?? 0,
+        outputPer1M: cost?.output ?? 0,
+        cacheReadPer1M: cost?.cacheRead,
+        cacheWritePer1M: cost?.cacheWrite,
+        cacheWriteLongPer1M: cost?.cacheWrite,
+    };
+}
+//# sourceMappingURL=pricing.js.map

package/dist/core/pricing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pricing.js","sourceRoot":"","sources":["../../src/core/pricing.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2BH,MAAM,KAAK,GAAG,CAAC,MAAc,EAAE,KAAyB,EAAU,EAAE,CAClE,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAE/C;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAmB,EAAE,OAAqB;IAC5E,8FAA8F;IAC9F,8FAA8F;IAC9F,yGAAyG;IACzG,oGAAoG;IACpG,wGAAwG;IACxG,MAAM,eAAe,GAAG,OAAO,CAAC,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1F,MAAM,gBAAgB,GAAG,OAAO,CAAC,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7F,MAAM,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC;IACzG,wGAAwG;IACxG,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,gBAAgB,GAAG,eAAe,GAAG,gBAAgB,GAAG,oBAAoB,CAAC,CAAC;IACnH,MAAM,GAAG,GACP,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,UAAU,CAAC;QACpC,KAAK,CAAC,eAAe,EAAE,OAAO,CAAC,cAAc,CAAC;QAC9C,KAAK,CAAC,gBAAgB,EAAE,OAAO,CAAC,eAAe,CAAC;QAChD,KAAK,CAAC,oBAAoB,EAAE,OAAO,CAAC,mBAAmB,CAAC;QACxD,KAAK,CAAC,MAAM,CAAC,YAAY,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAClD,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;AAC/B,CAAC;AAED;6GAC6G;AAC7G,MAAM,UAAU,kBAAkB,CAChC,IAA8F;IAE9F,OAAO;QACL,UAAU,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC;QAC5B,WAAW,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;QAC9B,cAAc,EAAE,IAAI,EAAE,SAAS;QAC/B,eAAe,EAAE,IAAI,EAAE,UAAU;QACjC,mBAAmB,EAAE,IAAI,EAAE,UAAU;KACtC,CAAC;AACJ,CAAC"}

package/dist/core/property-harness.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Property-harness (design/57 §9 / design/58) — the **oracle-free** half of the trusted-oracle problem.
+ *
+ * From a **trusted contract** (supplied by the spec / leader — NEVER the worker, so it dodges BUG8: a worker
+ * can't write `assert(true)` here) this derives executable **invariants** that hold for ANY correct
+ * implementation, with **no expected values** (no oracle — dodging the "expected is LLM-computed" trap of a
+ * generated test) and **no LLM** (pure deterministic — design/56's "execute > analyze"). Run against an
+ * implementation over many generated inputs, they catch the **structural-contract** bug class deterministically
+ * at **0 false positives** (probe-13: structural 16/16 caught, FP 0/12).
+ *
+ * It is a thin **complement** to the mechanical exit gate ({@link runExecGate}), not a replacement: it provably
+ * **cannot** catch value-semantic bugs — wrong output that is still structurally valid (`abs → square`,
+ * titlecase `don't → Don'T`). Those still need a real test suite (MECH) or the L3 judge. The value is the
+ * **sound invariant library + the contract→invariant derivation** centralized here (a profile re-deriving it
+ * risks unsound invariants = false positives = the thing that makes a gate harmful).
+ *
+ * Honest limits (two independent probes converged — core probe-13 + search [52], both FP=0):
+ * - **The only false-positive risk is an UNFAITHFUL contract.** Each invariant is sound by construction, so a
+ *   *correct* impl can't violate one — UNLESS the contract misdescribes the intended behavior (declaring a
+ *   property the correct impl doesn't have). The contract must faithfully describe intent (it is trusted input).
+ * - **Order/positional blindness.** `permutation`/`subset`/multiset-based invariants are order-agnostic, so a
+ *   wrong-order-but-same-elements result (concat `b+a`, a mis-ordered flatten) passes. That is the value-semantic
+ *   class — catch it with a positional contract entry, a real test (MECH), or the judge.
+ * - **No contract ⇒ no signal.** A function with no declared contract derives zero invariants (zero coverage);
+ *   the catch comes from the *contract* you declare, not from the type alone — this is not magic from signatures.
+ *
+ * Scope (design/58 §2): no type→input generation (caller supplies `genInput`), no multi-language rendering
+ * (this is the JS/TS reference; other languages render their own from {@link FunctionContract}), no
+ * non-termination detection (a sync infinite loop blocks {@link checkInvariants} — gate it with the
+ * env/exec timeout via `runExecGate`; `totalNoThrow` only catches throws).
+ */
+/** Sound, oracle-free invariant kinds (design/58 §1.3). Each holds for ANY correct implementation. */
+export type InvariantKind = "permutation" | "lengthPreserving" | "subset" | "distinctOutput" | "idempotent" | "involution" | "outputPredicate" | "rangeBound" | "nonNegative" | "nonEmptyPreserving" | "concatPreserving" | "chunkMaxLen" | "lengthEq" | "roundtrip" | "totalNoThrow";
+/**
+ * The TRUSTED contract a function is expected to satisfy — from the spec / leader, **never the worker** (BUG8).
+ * The predicate/bound fields carry trusted JS supplied by the spec author (not worker output), so the
+ * in-process model is safe for them.
+ */
+export interface FunctionContract {
+    /** Output is a permutation (same multiset) of the input collection — sort / shuffle / reverse / rotate. */
+    permutation?: boolean;
+    /** `|output| === |input collection|`. */
+    lengthPreserving?: boolean;
+    /** Output is a sub-multiset of the input collection — filter / take. */
+    subset?: boolean;
+    /** Output has no duplicate elements — dedupe / unique. */
+    distinctOutput?: boolean;
+    /** `f(f(x))` deep-equals `f(x)` — normalize / sort / dedupe. (Output type must equal input type.) */
+    idempotent?: boolean;
+    /** `f(f(x))` deep-equals `x` — reverse / negate. (Output type must equal input type.) */
+    involution?: boolean;
+    /** Numeric output is `>= 0` — abs / length / count. */
+    nonNegative?: boolean;
+    /** A non-empty input collection implies a non-empty output — titlecase / dedupe. */
+    nonEmptyPreserving?: boolean;
+    /** Concatenating the output groups in order deep-equals the input collection — chunk / split. */
+    concatPreserving?: boolean;
+    /** The function is an `{ encode, decode }` pair and `decode(encode(x))` deep-equals `x` — serde / base62. */
+    roundtrip?: boolean;
+    /** The function must not throw on any valid-typed input. (Non-termination is NOT covered — see file header.) */
+    totalNoThrow?: boolean;
+    /** Every output element satisfies this trusted predicate — filter-by-P. */
+    outputPredicate?: (el: any) => boolean;
+    /** Numeric output lies within `[lo, hi]` computed from the input by this trusted fn — clamp. */
+    rangeBound?: (input: any) => readonly [number, number];
+    /** Every output group has length in `(0, n]` where `n` is this trusted fn of the input — chunk. */
+    chunkMaxLen?: (input: any) => number;
+    /** `|output| === ` this trusted fn of the input — e.g. `countdown(n)` has length `n + 1`. */
+    lengthEq?: (input: any) => number;
+    /**
+     * Extract the input collection when the input WRAPS it — e.g. `(x) => x.a` for `{ a, k }`. Default: the input
+     * IS the collection. 🔴 Required for the collection invariants when the input is a wrapper object, else they
+     * compare the output against the wrapper instead of the collection (probe-13 soundness fix).
+     */
+    inputCollection?: (input: any) => unknown[];
+}
+/** One derived, runnable invariant. `check(fn, input)` returns `true` iff the invariant HOLDS. */
+export interface Invariant {
+    kind: InvariantKind;
+    /** Human-readable description (surfaced in a violation). */
+    description: string;
+    /** For `roundtrip`, `fn` is the `{ encode, decode }` pair; otherwise a unary function. A throw propagates to the runner. */
+    check: (fn: any, input: any) => boolean;
+}
+/** A concrete invariant violation found by {@link checkInvariants}. */
+export interface InvariantViolation {
+    kind: InvariantKind;
+    description: string;
+    /** The input that triggered it (the first one observed). */
+    input: unknown;
+    /** A-5 fold: the violation was detected via the check THROWING on a structurally wrong return value
+     *  (e.g. `.length` of undefined) rather than returning false — the impl's output doesn't even have
+     *  the shape the contract implies. fn itself did NOT throw (that is `totalNoThrow`'s domain). */
+    evaluationThrew?: true;
+}
+/** The outcome of running invariants over generated inputs. */
+export interface CheckResult {
+    /** True iff no invariant was violated across all trials. */
+    ok: boolean;
+    /** One entry per violated invariant (first triggering input). */
+    violations: InvariantViolation[];
+    /** How many inputs were tried. */
+    trials: number;
+}
+/**
+ * Derive the sound, oracle-free invariants implied by a trusted {@link FunctionContract}. Pure and
+ * deterministic. The collection invariants honor `contract.inputCollection` (default: the input is the
+ * collection) so a wrapper-object input (`{ a, k }`) is handled correctly.
+ */
+export declare function deriveInvariants(contract: FunctionContract): Invariant[];
+/**
+ * Run derived `invariants` against `fn` over `opts.trials` generated inputs (default 200). Returns the
+ * violated invariants (first triggering input each).
+ *
+ * 🔴 Runs `fn` **in the caller's process** (design/58 §1.2). Pass only a TRUSTED `fn`, or invoke this INSIDE
+ * the worker's sandbox (a generated test the leader drops into the env and runs via `runExecGate`, gating on
+ * exit code). **Non-termination is NOT caught here** — a sync infinite loop blocks the call; bound it with the
+ * env/exec timeout. An impl throw is detected by the self-contained `totalNoThrow` invariant (recorded ONLY
+ * when totality was contracted — soundness over recall); the runner's `catch` is just a safety net so one
+ * pathological input can't crash the whole run. Note: `fn` is invoked once per invariant per trial (twice for
+ * `idempotent`/`involution`) — pass a PURE function (the intended use); a side-effecting `fn` is amplified.
+ */
+export declare function checkInvariants(fn: unknown, genInput: (i: number) => unknown, invariants: Invariant[], opts?: {
+    trials?: number;
+}): CheckResult;
+//# sourceMappingURL=property-harness.d.ts.map

package/dist/core/property-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property-harness.d.ts","sourceRoot":"","sources":["../../src/core/property-harness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,sGAAsG;AACtG,MAAM,MAAM,aAAa,GACrB,aAAa,GACb,kBAAkB,GAClB,QAAQ,GACR,gBAAgB,GAChB,YAAY,GACZ,YAAY,GACZ,iBAAiB,GACjB,YAAY,GACZ,aAAa,GACb,oBAAoB,GACpB,kBAAkB,GAClB,aAAa,GACb,UAAU,GACV,WAAW,GACX,cAAc,CAAC;AAEnB;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2GAA2G;IAC3G,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,yCAAyC;IACzC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wEAAwE;IACxE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,qGAAqG;IACrG,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,yFAAyF;IACzF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,uDAAuD;IACvD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oFAAoF;IACpF,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,iGAAiG;IACjG,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,6GAA6G;IAC7G,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gHAAgH;IAChH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,2EAA2E;IAC3E,eAAe,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC;IACvC,gGAAgG;IAChG,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvD,mGAAmG;IACnG,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAC;IACrC,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAC;IAClC;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,EAAE,CAAC;CAC7C;AAED,kGAAkG;AAClG,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,4HAA4H;IAC5H,KAAK,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC;CACzC;AAED,uEAAuE;AACvE,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,aAAa,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,KAAK,EAAE,OAAO,CAAC;IACf;;qGAEiG;IACjG,eAAe,CAAC,EAAE,IAAI,CAAC;CACxB;AAED,+DAA+D;AAC/D,MAAM,WAAW,WAAW;IAC1B,4DAA4D;IAC5D,EAAE,EAAE,OAAO,CAAC;IACZ,iEAAiE;IACjE,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;CAChB;AAgDD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EAAE,CA0BxE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,OAAO,EACX,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,EAChC,UAAU,EAAE,SAAS,EAAE,EACvB,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7B,WAAW,CAgCb"}

package/dist/core/property-harness.js

@@ -0,0 +1,192 @@
+/**
+ * Property-harness (design/57 §9 / design/58) — the **oracle-free** half of the trusted-oracle problem.
+ *
+ * From a **trusted contract** (supplied by the spec / leader — NEVER the worker, so it dodges BUG8: a worker
+ * can't write `assert(true)` here) this derives executable **invariants** that hold for ANY correct
+ * implementation, with **no expected values** (no oracle — dodging the "expected is LLM-computed" trap of a
+ * generated test) and **no LLM** (pure deterministic — design/56's "execute > analyze"). Run against an
+ * implementation over many generated inputs, they catch the **structural-contract** bug class deterministically
+ * at **0 false positives** (probe-13: structural 16/16 caught, FP 0/12).
+ *
+ * It is a thin **complement** to the mechanical exit gate ({@link runExecGate}), not a replacement: it provably
+ * **cannot** catch value-semantic bugs — wrong output that is still structurally valid (`abs → square`,
+ * titlecase `don't → Don'T`). Those still need a real test suite (MECH) or the L3 judge. The value is the
+ * **sound invariant library + the contract→invariant derivation** centralized here (a profile re-deriving it
+ * risks unsound invariants = false positives = the thing that makes a gate harmful).
+ *
+ * Honest limits (two independent probes converged — core probe-13 + search [52], both FP=0):
+ * - **The only false-positive risk is an UNFAITHFUL contract.** Each invariant is sound by construction, so a
+ *   *correct* impl can't violate one — UNLESS the contract misdescribes the intended behavior (declaring a
+ *   property the correct impl doesn't have). The contract must faithfully describe intent (it is trusted input).
+ * - **Order/positional blindness.** `permutation`/`subset`/multiset-based invariants are order-agnostic, so a
+ *   wrong-order-but-same-elements result (concat `b+a`, a mis-ordered flatten) passes. That is the value-semantic
+ *   class — catch it with a positional contract entry, a real test (MECH), or the judge.
+ * - **No contract ⇒ no signal.** A function with no declared contract derives zero invariants (zero coverage);
+ *   the catch comes from the *contract* you declare, not from the type alone — this is not magic from signatures.
+ *
+ * Scope (design/58 §2): no type→input generation (caller supplies `genInput`), no multi-language rendering
+ * (this is the JS/TS reference; other languages render their own from {@link FunctionContract}), no
+ * non-termination detection (a sync infinite loop blocks {@link checkInvariants} — gate it with the
+ * env/exec timeout via `runExecGate`; `totalNoThrow` only catches throws).
+ */
+// ---------- internal: a sound canonicalizer + multiset helpers (deterministic) ----------
+/**
+ * Structural canonical string of a value — the equality basis. `JSON.stringify` is unusable for a 0-FP
+ * guarantee (council): it THROWS on `BigInt` / circular refs (a throw a correct impl never made), is
+ * object-key-order-sensitive (`{a,b}` ≠ `{b,a}` → false inequality), and maps `NaN`/`Infinity`/`-0` to
+ * `"null"`/`"0"` (collisions). This never throws, sorts object keys, and keeps `NaN`/`±Infinity`/`-0`/
+ * `undefined`/`BigInt` distinct — so a correct implementation can never be flagged by a serialization artifact.
+ */
+function canon(v, seen = new WeakSet()) {
+    if (v === null)
+        return "null";
+    if (v === undefined)
+        return "undefined";
+    const t = typeof v;
+    if (t === "number")
+        return Object.is(v, -0) ? "-0" : String(v); // String() gives NaN/Infinity/-Infinity
+    if (t === "bigint")
+        return `${v}n`;
+    if (t === "string")
+        return JSON.stringify(v);
+    if (t === "boolean")
+        return String(v);
+    if (t === "function" || t === "symbol")
+        return `[${t}]`;
+    if (Array.isArray(v)) {
+        if (seen.has(v))
+            return "[Circular]";
+        seen.add(v);
+        const s = `[${v.map((e) => canon(e, seen)).join(",")}]`;
+        seen.delete(v);
+        return s;
+    }
+    const o = v;
+    if (seen.has(o))
+        return "[Circular]";
+    seen.add(o);
+    const s = `{${Object.keys(o).sort().map((k) => `${JSON.stringify(k)}:${canon(o[k], seen)}`).join(",")}}`;
+    seen.delete(o);
+    return s;
+}
+const structEq = (a, b) => canon(a) === canon(b);
+const multisetEq = (a, b) => structEq(a.map((x) => canon(x)).sort(), b.map((x) => canon(x)).sort());
+function multisetSubset(out, inp) {
+    const c = new Map();
+    for (const x of inp) {
+        const k = canon(x);
+        c.set(k, (c.get(k) ?? 0) + 1);
+    }
+    for (const x of out) {
+        const k = canon(x);
+        const n = (c.get(k) ?? 0) - 1;
+        if (n < 0)
+            return false;
+        c.set(k, n);
+    }
+    return true;
+}
+const lenOf = (x) => (typeof x === "string" || Array.isArray(x) ? x.length : 0);
+/**
+ * Derive the sound, oracle-free invariants implied by a trusted {@link FunctionContract}. Pure and
+ * deterministic. The collection invariants honor `contract.inputCollection` (default: the input is the
+ * collection) so a wrapper-object input (`{ a, k }`) is handled correctly.
+ */
+export function deriveInvariants(contract) {
+    const inv = [];
+    const call = (fn, x) => fn(x);
+    const coll = (x) => (contract.inputCollection ? contract.inputCollection(x) : x);
+    const add = (kind, description, check) => inv.push({ kind, description, check });
+    if (contract.permutation)
+        add("permutation", "output is a permutation of the input collection", (f, x) => multisetEq(call(f, x), coll(x)));
+    if (contract.lengthPreserving)
+        add("lengthPreserving", "|output| === |input collection|", (f, x) => call(f, x).length === coll(x).length);
+    if (contract.subset)
+        add("subset", "output is a sub-multiset of the input collection", (f, x) => multisetSubset(call(f, x), coll(x)));
+    if (contract.distinctOutput)
+        add("distinctOutput", "output has no duplicate elements", (f, x) => { const o = call(f, x); return new Set(o.map((e) => canon(e))).size === o.length; });
+    if (contract.idempotent)
+        add("idempotent", "f(f(x)) === f(x)", (f, x) => { const once = call(f, x); return structEq(call(f, once), once); });
+    if (contract.involution)
+        add("involution", "f(f(x)) === x", (f, x) => structEq(call(f, call(f, x)), x));
+    if (contract.outputPredicate)
+        add("outputPredicate", "every output element satisfies the contract predicate", (f, x) => call(f, x).every((e) => contract.outputPredicate(e)));
+    if (contract.rangeBound)
+        add("rangeBound", "output is within the contract range", (f, x) => { const o = call(f, x); const [lo, hi] = contract.rangeBound(x); return typeof o === "number" && o >= lo && o <= hi; });
+    if (contract.nonNegative)
+        add("nonNegative", "output >= 0", (f, x) => call(f, x) >= 0);
+    if (contract.nonEmptyPreserving)
+        add("nonEmptyPreserving", "non-empty input collection => non-empty output", (f, x) => (lenOf(coll(x)) > 0 ? lenOf(call(f, x)) > 0 : true));
+    if (contract.concatPreserving)
+        add("concatPreserving", "concatenation of output groups === input collection", (f, x) => structEq([].concat(...call(f, x)), coll(x)));
+    if (contract.chunkMaxLen)
+        add("chunkMaxLen", "every output group has length in (0, n]", (f, x) => { const n = contract.chunkMaxLen(x); return call(f, x).every((g) => g.length > 0 && g.length <= n); });
+    if (contract.lengthEq)
+        add("lengthEq", "|output| === the contract length", (f, x) => call(f, x).length === contract.lengthEq(x));
+    if (contract.roundtrip)
+        add("roundtrip", "decode(encode(x)) === x", (pair, x) => { const p = pair; return structEq(p.decode(p.encode(x)), x); });
+    // `totalNoThrow` is self-contained (council): it exercises the function and returns false on a throw — the
+    // violation is recorded via the normal `!check` path, NOT by relying on the runner's catch. The `typeof`
+    // guard only avoids a TypeError on a non-function `fn` (e.g. a roundtrip pair).
+    if (contract.totalNoThrow)
+        add("totalNoThrow", "must not throw on a valid input", (f, x) => { try {
+            if (typeof f === "function")
+                f(x);
+            return true;
+        }
+        catch {
+            return false;
+        } });
+    return inv;
+}
+/**
+ * Run derived `invariants` against `fn` over `opts.trials` generated inputs (default 200). Returns the
+ * violated invariants (first triggering input each).
+ *
+ * 🔴 Runs `fn` **in the caller's process** (design/58 §1.2). Pass only a TRUSTED `fn`, or invoke this INSIDE
+ * the worker's sandbox (a generated test the leader drops into the env and runs via `runExecGate`, gating on
+ * exit code). **Non-termination is NOT caught here** — a sync infinite loop blocks the call; bound it with the
+ * env/exec timeout. An impl throw is detected by the self-contained `totalNoThrow` invariant (recorded ONLY
+ * when totality was contracted — soundness over recall); the runner's `catch` is just a safety net so one
+ * pathological input can't crash the whole run. Note: `fn` is invoked once per invariant per trial (twice for
+ * `idempotent`/`involution`) — pass a PURE function (the intended use); a side-effecting `fn` is amplified.
+ */
+export function checkInvariants(fn, genInput, invariants, opts = {}) {
+    const trials = Math.max(1, Math.floor(opts.trials ?? 200));
+    const found = new Map();
+    for (let i = 0; i < trials; i++) {
+        const input = genInput(i);
+        for (const iv of invariants) {
+            if (found.has(iv.kind))
+                continue; // first triggering input is enough per kind
+            try {
+                if (!iv.check(fn, input))
+                    found.set(iv.kind, { kind: iv.kind, description: iv.description, input });
+            }
+            catch {
+                // A-5 fold (round-2 audit): a throw here has TWO possible sources and they must not be
+                // conflated. RE-PROBE fn(input) directly to tell them apart:
+                //  - fn itself throws → an impl throw: `totalNoThrow`'s domain (recorded only when totality
+                //    was contracted — soundness over recall). Skip, so it isn't misattributed to this kind.
+                //  - fn returns normally → the throw came from THIS check inspecting a structurally WRONG
+                //    return value (`.map`/`.length`/spread on undefined/number — the most common worker
+                //    structural bug). That IS a violation of this kind: the output doesn't even have the
+                //    shape the contract implies. Record it (closes the completeness gap where deterministic
+                //    wrong-type returns sailed through as {ok:true} with zero signal).
+                // The probe costs one extra fn call on an already-pathological input; fn is contractually
+                // PURE (see the runner JSDoc), and the found-set caps this at one probe per kind.
+                try {
+                    if (typeof fn === "function")
+                        fn(input);
+                    found.set(iv.kind, { kind: iv.kind, description: iv.description, input, evaluationThrew: true });
+                }
+                catch {
+                    /* impl throw — totalNoThrow's job (when contracted); not this kind's violation */
+                }
+            }
+        }
+    }
+    const violations = [...found.values()];
+    return { ok: violations.length === 0, violations, trials };
+}
+//# sourceMappingURL=property-harness.js.map

package/dist/core/property-harness.js.map

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

package/dist/core/push-queue.d.ts

@@ -0,0 +1,10 @@
+/** A minimal async iterable you can push values into and close. Backpressure-free (buffers). */
+export declare class PushQueue<T> implements AsyncIterable<T> {
+    private buffer;
+    private waiters;
+    private closed;
+    push(value: T): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+//# sourceMappingURL=push-queue.d.ts.map

package/dist/core/push-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push-queue.d.ts","sourceRoot":"","sources":["../../src/core/push-queue.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,qBAAa,SAAS,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IACnD,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,OAAO,CAA0C;IACzD,OAAO,CAAC,MAAM,CAAS;IAEvB,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAYpB,KAAK,IAAI,IAAI;IAON,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAelD"}

package/dist/core/push-queue.js

@@ -0,0 +1,42 @@
+/** A minimal async iterable you can push values into and close. Backpressure-free (buffers). */
+export class PushQueue {
+    buffer = [];
+    waiters = [];
+    closed = false;
+    push(value) {
+        if (this.closed) {
+            return;
+        }
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter({ value, done: false });
+        }
+        else {
+            this.buffer.push(value);
+        }
+    }
+    close() {
+        this.closed = true;
+        while (this.waiters.length > 0) {
+            this.waiters.shift()({ value: undefined, done: true });
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        for (;;) {
+            if (this.buffer.length > 0) {
+                yield this.buffer.shift();
+            }
+            else if (this.closed) {
+                return;
+            }
+            else {
+                const r = await new Promise((resolve) => this.waiters.push(resolve));
+                if (r.done) {
+                    return;
+                }
+                yield r.value;
+            }
+        }
+    }
+}
+//# sourceMappingURL=push-queue.js.map

package/dist/core/push-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"push-queue.js","sourceRoot":"","sources":["../../src/core/push-queue.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,MAAM,OAAO,SAAS;IACZ,MAAM,GAAQ,EAAE,CAAC;IACjB,OAAO,GAAuC,EAAE,CAAC;IACjD,MAAM,GAAG,KAAK,CAAC;IAEvB,IAAI,CAAC,KAAQ;QACX,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO;QACT,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACpC,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACjC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC;IAED,KAAK;QACH,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,IAAI,CAAC,OAAO,CAAC,KAAK,EAAG,CAAC,EAAE,KAAK,EAAE,SAAkB,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IAED,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,SAAS,CAAC;YACR,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC3B,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAG,CAAC;YAC7B,CAAC;iBAAM,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;gBACvB,OAAO;YACT,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,GAAG,MAAM,IAAI,OAAO,CAAoB,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;gBACxF,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;oBACX,OAAO;gBACT,CAAC;gBACD,MAAM,CAAC,CAAC,KAAK,CAAC;YAChB,CAAC;QACH,CAAC;IACH,CAAC;CACF"}