gdp-wired 0.12.4 → 0.12.6

package/README.md

@@ -13,6 +13,9 @@ the laws it must keep. gdp-wired proves them with no proof to write, shows a rea
 npm install gdp-wired   # or bun add gdp-wired; plain JavaScript with types, Node 20+, Bun or a browser
 ```
 
+New to formal verification? [The guide](https://gdpwired.dev/guide) takes a rule from ordinary TypeScript to a proof in
+seven steps, with recipes for limits, workflows, permissions and orders with line items.
+
 ```ts
 import {min, nat, proveRule, rule, when} from 'gdp-wired'
 
@@ -52,7 +55,8 @@ All of these are proven automatically, and each proof is also a Lean theorem:
 - **Invariants**: a law that holds after every sequence of requests ("spend stays within the budget").
 - **Maps, sets and lists of names**: laws at every key ("no day passes its cap"), sets a request carries, conditions
   about every key or every two keys ("a batch is taken only when its values increase"), lists kept in order
-  (`examples/sets.ts`, `examples/lists.ts`, `examples/pairs.ts`).
+  (`examples/sets.ts`, `examples/lists.ts`, `examples/pairs.ts`), and two groups of items with a set each, decided at
+  every pair at once (`examples/groups.ts`).
 - **Step laws**: what one step does ("a balance only goes down", "a grant adds one"), and laws over up to 64 steps in
   a row (`examples/steps.ts`).
 - **Histories**: sums and queries over a log of requests, like a sliding-window rate limit.
@@ -234,7 +238,9 @@ const soon = retry.law('the next try is at most 64 after the last request', ({ne
   lemmas too, at the list's end and wherever it reads the list. A lemma reads the folds, the prefix's length and the
   params, not the items: a fact about every item is a fold's (a count of the items that meet it). A fold's start and
   step, and a lemma, may read the params (`{from: ({fee}) => fee, step: (acc, line, {ceil}) => acc.plus(min(line.amount, ceil))}`); a request is then
-  encoded with them, `rule.encodeInput(values, params)` (`examples/invoices.ts`).
+  encoded with them, `rule.encodeInput(values, params)` (`examples/invoices.ts`). `rule.foldsOf({Lines: [...]}, params)`
+  gives each fold at the list's end, computed the same way, without running the rule (to compare a decision's folds
+  with the code it describes).
 - **Folds over trees** (`fold(name).params(...).inputs(...).leaf(env => ({...})).node((env, left, right) => ({...}))`,
   `proveFold`): a tree as a value (`{leaf: inputs}` or `{node: inputs, left, right}`), each leaf's values from its inputs
   and each node's from its own and its children's; a law about the values is proven by induction over the tree (the
@@ -349,7 +355,7 @@ Proving and checking: a law over 64 steps proves in about 5 s, and Lean checks i
 | `core/` | Machines, the interpreter and JS compiler, the builders, composition (`compose.ts`), the linear solver and its checker, Houdini invariants, models, the first Lean export |
 | `kernel/` | The trusted kernel and the untrusted prover, with soundness fuzz (`kernel.test.ts`, `history.test.ts`) |
 | `lean-kernel/` | The kernel's Lean twin, its soundness proofs, and the exported trees |
-| `examples/` | The builders at work: `domains/` (187 rules across 21 domains, each with laws and broken variants), `harness.ts` (the triple check), `readme.ts`, `budget.ts`, `gdp.ts` (gdp-ts's example, its checks proven), `datatypes.ts` (records and variants), `lemmas.ts` (recurrences and their lemmas), `invoices.ts` (lists a request carries), `folds.ts` (folds over trees), `trees.ts` (trees and lists of lists in the state), `composition.ts`, `sets.ts`, `quantifiers.ts`, `functions.ts`, `lists.ts`, `sizes.ts`, `liveness.ts`, `steps.ts` (laws over up to 64 steps), and `jev-fabric/` (a Bend project's 59 proven laws, ported) |
+| `examples/` | The builders at work: `domains/` (187 rules across 21 domains, each with laws and broken variants), `harness.ts` (the triple check), `readme.ts`, `guide.ts` (the guide's code), `groups.ts` (two groups decided at every pair), `budget.ts`, `gdp.ts` (gdp-ts's example, its checks proven), `datatypes.ts` (records and variants), `lemmas.ts` (recurrences and their lemmas), `invoices.ts` (lists a request carries), `folds.ts` (folds over trees), `trees.ts` (trees and lists of lists in the state), `composition.ts`, `sets.ts`, `quantifiers.ts`, `functions.ts`, `lists.ts`, `sizes.ts`, `liveness.ts`, `steps.ts` (laws over up to 64 steps), and `jev-fabric/` (a Bend project's 59 proven laws, ported) |
 | `docs/` | The comparison with Bend and Lean, and the full scope |
 | `compare/` | The same three rules in gdp-wired, Bend and plain Lean, checked and measured |
 | `research/` | Everything around the library ([`research/README.md`](research/README.md)): the GPU searches (`search/`, `hw/`, `modal-gpu/`), invariant and rank synthesis (`synth/`), relational laws and guard synthesis (`next/`), bit-vector laws (`sat/`), the enumeration and benchmarks (`enum/`, `gpu/`, `perf/`), the first Lean checker (`lean/`) and the first prototype, the audit path (`audit/`) |
@@ -377,7 +383,7 @@ bun test core/compile.test.ts core/runtime.test.ts kernel/history.test.ts
 cd kernel && bun run-kernel.ts && bun test kernel.test.ts
 ```
 
-The whole suite (159 jobs, about 6 minutes of wall time and 22 minutes of job time) runs on [Modal](https://modal.com):
+The whole suite (163 jobs, about 10 minutes of wall time and 46 minutes of job time) runs on [Modal](https://modal.com):
 
 ```sh
 modal run modal/run.py --jobs modal/suite.json --out runs/modal/suite && sh modal/reap.sh

package/dist/core/dsl.d.ts

@@ -39,7 +39,8 @@ export declare function when(c: Cond, then: TermLike, otherwise: TermLike): Term
 export declare function when(c: Cond, then: Decimal, otherwise: Decimal | number): Decimal;
 export declare function when(c: Cond, then: Decimal | number, otherwise: Decimal): Decimal;
 export declare function when(c: Cond, then: IntLike, otherwise: IntLike): Int;
-export declare function when<K extends string>(c: Cond, then: Choice<K>, otherwise: Choice<K>): Choice<K>;
+export declare function when<K extends string>(c: Cond, then: Choice<K> | NoInfer<K>, otherwise: Choice<K>): Choice<K>;
+export declare function when<K extends string>(c: Cond, then: Choice<K>, otherwise: Choice<K> | NoInfer<K>): Choice<K>;
 export declare function when(c: Cond, then: Str, otherwise: Str): Str;
 export declare function when<V>(c: Cond, then: Maybe<V>, otherwise: Maybe<V>): Maybe<V>;
 export declare function when(c: Cond, then: Cond, otherwise: Cond): Cond;
@@ -129,6 +130,8 @@ export declare class Choice<K extends string> {
     readonly values: readonly K[];
     constructor(n: Term, values: readonly K[]);
     is(k: K): Cond;
+    of(k: K): Choice<K>;
+    private index;
     match(cases: {
         [k in K]: () => Cond;
     }): Cond;
@@ -574,20 +577,10 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     private verdict;
     private crossStep;
     compare<St extends Record<string, Raw>>(reference: {
-        init: (params: {
-            [k in keyof P]: Raw;
-        }) => St;
-        step: (params: {
-            [k in keyof P]: Raw;
-        }, st: St, request: {
-            [k in keyof I]: Raw;
-        }) => St;
-    }, opts?: Draws<{
-        [k in keyof I]: Raw;
-    }> & {
-        params?: (rand: Rand) => {
-            [k in keyof P]: Raw;
-        };
+        init(params: Value<P>): St;
+        step(params: Value<P>, st: St, request: RawInputs<I>): St;
+    }, opts?: Draws<RawInputs<I>> & {
+        params?: (rand: Rand) => Value<P>;
         depth?: number;
     }): Agreement;
     encodeParams(values: {
@@ -598,6 +591,11 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     }, params?: {
         [k in keyof P]: Raw;
     }): Request;
+    foldsOf(values: {
+        [k in keyof I]?: I[k] extends CarriedList<any, any> ? readonly Raw[] : never;
+    }, params?: {
+        [k in keyof P]: Raw;
+    }): Record<string, Record<string, number>>;
     randomParams(rand: Rand, bound: number): Record<string, number>;
     private paramValues;
     randomInput(rand: Rand, bound: number, ps?: Record<string, number>): Request;
@@ -657,6 +655,9 @@ type CaseRaw<C extends Cases, T extends string = 'tag'> = {
 type Value<T> = {
     [k in keyof T]: ValueOf<T[k]>;
 };
+type RawInputs<T> = {
+    [k in keyof T]: T[k] extends MapRef ? ReadonlySet<number> | readonly number[] | ReadonlyMap<number, number> : T[k] extends CarriedList<infer V, infer _F> ? readonly ValueOf<V>[] : ValueOf<T[k]>;
+};
 type Field = Term | Cond | Int | Decimal | Choice<string> | Str | Variant<any, any> | Maybe<any> | {
     [f: string]: Field | number;
 };
@@ -677,16 +678,8 @@ export declare class Fun<P extends Obj = {}, I extends Obj = {}, O extends Obj =
     private result;
     law(name: string, given: (env: P & I, out: O) => Cond | Cond[], then: (out: O, env: P & I) => Cond): Decision;
     relate(name: string, given: (a: P & I, b: P & I) => Cond | Cond[], then: (outA: O, outB: O, a: P & I, b: P & I) => Cond): Decision;
-    compare(reference: (values: {
-        [k in keyof I]: Raw;
-    }, params: {
-        [k in keyof P]: Raw;
-    }) => Partial<Value<O>>, opts?: Draws<{
-        [k in keyof I]: Raw;
-    }> & {
-        params?: {
-            [k in keyof P]: Raw;
-        };
+    compare(reference: (values: Value<I>, params: Value<P>) => Partial<Value<O>>, opts?: Draws<Value<I>> & {
+        params?: Value<P>;
     }): Agreement;
     get rule(): Rule<P, I>;
     private compiledRule?;
@@ -751,6 +744,10 @@ export type Verdict = {
     witness?: Record<string, number>;
     why?: string;
     trees?: Record<string, Tree>;
+    run?: {
+        params: Record<string, number>;
+        trace: Record<string, unknown>[];
+    };
 };
 export declare class Unproven extends Error {
     readonly verdict: Verdict;

package/dist/core/dsl.js

@@ -94,6 +94,11 @@ export function when(c, then, otherwise) {
             throw new Error('when: records of other fields');
         return Object.fromEntries(Object.keys(then).map(f => [f, when(c, then[f], otherwise[f])]));
     }
+    // A choice's name beside a choice is that choice's value: when(closing, 'closed', status).
+    if (then instanceof Choice && typeof otherwise === 'string')
+        return when(c, then, then.of(otherwise));
+    if (typeof then === 'string' && otherwise instanceof Choice)
+        return when(c, otherwise.of(then), otherwise);
     if (then instanceof Choice && otherwise instanceof Choice)
         return new Choice(when(c, then.n, otherwise.n), then.values);
     if (then instanceof Str && otherwise instanceof Str)
@@ -348,11 +353,14 @@ export class Choice {
         this.n = n;
         this.values = values;
     }
-    is(k) {
+    is(k) { return this.n.eq(this.index(k)); }
+    // The value named k, of this choice's kind (to write: when(c, status.of('closed'), status)).
+    of(k) { return new Choice(lit(this.index(k)), this.values); }
+    index(k) {
         const i = this.values.indexOf(k);
         if (i < 0)
             throw new Error(`${k} is not one of ${this.values.join(', ')}`);
-        return this.n.eq(i);
+        return i;
     }
     match(cases) {
         const results = this.values.map(k => [k, cases[k]()]);
@@ -2160,6 +2168,16 @@ export class Rule {
         }
         return out;
     }
+    // Each carried list's folds at its end (what `L.fold.<f>` reads), computed from its items as encodeInput computes
+    // them, without running the rule: `foldsOf({Lines: [...]})` → {Lines: {total: 30}}. Only the lists given.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    foldsOf(values, params) {
+        const at = params && this.paramValues(this.encodeParams(params));
+        return Object.fromEntries((this.spec.lists2 ?? []).filter(([n]) => n in values).map(([n, k, fs]) => {
+            const { maps, len } = new CarriedList(n, k, v(`${n}_len`), fs, part => new MapRef(part, 0), {}, at).encode(values[n]);
+            return [n, Object.fromEntries(Object.keys(fs).map(f => [f, maps[`${n}$${f}`].get(len) ?? 0]))];
+        }));
+    }
     // Random params and inputs that meet their kinds (not the user's `pre` or `assume`, which a caller checks).
     randomParams(rand, bound) { return Object.assign({}, ...this.spec.params.map(([n, k]) => k.random(n, rand, bound))); }
     // The params' values by their kinds, as constants (what a fold that reads them is computed with).
@@ -2367,11 +2385,62 @@ const goalsVerdict = (goals) => {
 };
 // The kinds' laws first, those the caller didn't pass already (by name).
 const withKinds = (r, laws) => [...r.kindLaws().filter(k => !laws.some(l => l.name === k.name)), ...laws];
+// A real run from the start that breaks a law or a step law, from a few random runs (each request drawn by its kinds,
+// those the rule's assumption refuses skipped): a false law is refused at once, with the run, where the symbolic search
+// would have to decide every case of its goal to reach one. Nothing here is trusted; a run it finds is a run the
+// interpreter took. A rule that reads functions is skipped: the kernel knows them only by their facts (a recurrence's
+// induction machine reads the function it proves things about), so a run computing them proves nothing about the goal.
+const refuteBudget = { trials: 60, depth: 6, bound: 3, ms: 150 };
+function refuteByRuns(r, laws, stepLaws = []) {
+    const m = r.machine;
+    if (Object.keys(m.fns ?? {}).length || m.facts?.length)
+        return undefined;
+    const run = interpret(m), rand = seeded(13), until = performance.now() + refuteBudget.ms, bound = refuteBudget.bound;
+    const shown = (input) => Object.fromEntries(Object.entries(input).map(([n, x]) => [n, typeof x === 'number' ? x : Object.fromEntries(x)]));
+    try {
+        for (let trial = 0; trial < refuteBudget.trials && performance.now() < until; trial++) {
+            const params = r.randomParams(rand, bound);
+            if (m.pre && !evalC(m.pre, params, { scalars: {}, maps: {} }, m))
+                continue;
+            const watching = [...laws, ...stepLaws].map(w => ({ w, on: watch(m, run, w, params, bound) }));
+            let st = run.init(params);
+            const trace = [];
+            // The witness: the params, the state the breaking step starts from (or the start) and its request's own values.
+            const broken = (w, at, before, input) => ({ goal: `${w.name} ${at}`, witness: { ...params, ...before.scalars, ...(input ? numbersOf(input) : {}) }, run: { params, trace: trace.map(shown) } });
+            for (const { w, on } of watching)
+                if (!('then' in w) && !on.start(st))
+                    return broken(w, '@start', st);
+            for (let d = 0, tries = 0; d < refuteBudget.depth && tries < 40; tries++) {
+                const input = r.randomInput(rand, bound, params);
+                if (!allowed(m, run, params, st, input))
+                    continue;
+                d++;
+                const next = run.step(params, st, input);
+                trace.push(input);
+                for (const { w, on } of watching)
+                    if (!on.step(st, input, next))
+                        return broken(w, !('then' in w) ? '@step' : (w.steps ?? 1) > 1 ? `@${w.steps} steps` : '@step law', st, input);
+                st = next;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+const refutedVerdict = (out) => ({ proven: false, checked: false, goal: out.goal, stuck: 'sat', witness: out.witness, run: out.run });
 export function proveRule(r, laws) {
+    const refuted = refuteByRuns(r, laws);
+    if (refuted)
+        return refutedVerdict(refuted);
     const out = proveLaws(r.machine, withKinds(r, laws));
     return { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}), ...(out.failed.why ? { why: out.failed.why } : {}) } : {}) };
 }
 export function proveSteps(r, laws, stepLaws) {
+    const refuted = refuteByRuns(r, laws, stepLaws);
+    if (refuted)
+        return refutedVerdict(refuted);
     const out = proveStepLaws(r.machine, withKinds(r, laws), stepLaws);
     return { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}), ...(out.failed.why ? { why: out.failed.why } : {}) } : {}) };
 }

package/dist/core/machine.js

@@ -727,15 +727,24 @@ function renameKey(lin, from, to) {
 }
 // --- real counterexamples ----------------------------------------------------------------------------------------------
 // Every sequence of up to `depth` requests, with params and inputs within 0..bound, from the start: the first that breaks
-// the law, checked with the interpreter. A law that fails here is false; one that only fails `prove` may just need a
-// stronger invariant.
+// the law, checked with the interpreter. A variable `pre` or `assume` bounds by a constant of at most 15 (a choice, a
+// yes/no, a small upTo) takes every value it may instead. A law that fails here is false; one that only fails `prove` may
+// just need a stronger invariant.
 export function search(m, law, depth = 3, bound = 2) {
     const run = interpret(m);
     const holds = (params, st) => {
         const keys = law.forall ? [...new Set([0, ...Object.values(st.maps).flatMap(cells => [...cells.keys()])])] : [0];
         return keys.every(key => evalC(law.holds, { ...params, ...(law.forall ? { [law.forall]: key } : {}) }, st, m));
     };
-    const tuples = (names) => names.reduce((acc, name) => acc.flatMap(t => Array.from({ length: bound + 1 }, (_, i) => ({ ...t, [name]: i }))), [{}]);
+    const tops = new Map();
+    const conj = (c) => (c === undefined ? [] : c.op === 'and' ? c.xs.flatMap(conj) : [c]);
+    for (const c of [...conj(m.pre), ...conj(m.assume)])
+        if ((c.op === '<' || c.op === '<=') && c.a.op === 'var' && c.b.op === 'const') {
+            const top = c.op === '<' ? c.b.value - 1 : c.b.value;
+            if (top >= 0 && top <= 15)
+                tops.set(c.a.name, Math.min(top, tops.get(c.a.name) ?? top));
+        }
+    const tuples = (names) => names.reduce((acc, name) => acc.flatMap(t => Array.from({ length: (tops.get(name) ?? bound) + 1 }, (_, i) => ({ ...t, [name]: i }))), [{}]);
     const assumed = (env, st) => m.assume === undefined || evalC(m.assume, env, st, m);
     const meetsPre = (params) => m.pre === undefined || evalC(m.pre, params, { scalars: {}, maps: {} }, m);
     for (const params of tuples(m.params)) {

package/dist/kernel/prove.js

@@ -137,9 +137,16 @@ const solveP = (rows, maxRows) => {
     s.rows += rows.length;
     return out;
 };
+// PROVE_TRACE=1 logs each goal grown from its root (hypotheses, nodes, time, outcome) to stderr.
+const proveTrace = !!globalThis.process?.env?.PROVE_TRACE;
 // The budget: 200,000 nodes and, by default, a second per hypothesis (at least 20 seconds) per goal; past either the goal
 // is left `unknown`. A goal with many instances (a law about two keys at its pairs) has that many more rows per leaf.
 export function grow(goal, path = new Map(), budget = { nodes: 0, until: performance.now() + Math.max(20_000, 1_000 * goal.hyps.length) }) {
+    if (proveTrace && !path.size && !budget.nodes) {
+        const t = performance.now(), out = growRoot(goal, path, budget);
+        console.error(`[grow] ${goal.name}: ${goal.hyps.length} hyps, ${budget.nodes} nodes, ${Math.round(performance.now() - t)} ms, ${'tree' in out ? 'proven' : `${out.stuck}${out.why ? ` (${out.why})` : ''}`}`);
+        return out;
+    }
     if (!profile.on || path.size || budget.nodes)
         return growRoot(goal, path, budget);
     const t = performance.now(), s0 = profile.solves, m0 = profile.solveMs, r0 = profile.rowsMs, n0 = profile.nodes;
@@ -667,14 +674,15 @@ const flagInstances = (m, keys, focus = []) => Object.fromEntries(Object.entries
 }));
 // A k-step law whose steps keep a condition (a flag that holds at one step and is read again at the next) fails at a
 // later step's witness only where the condition held before: so, per quantified flag over one key, the instances at the
-// law's own keys and that flag's witness at every step (a later step's witness is a key an earlier frame may name, as a
-// flag holds at every key: kernel.ts's checkStepLaws). Few instances, where the shared ones are many and mostly idle.
+// law's own keys and that flag's witness at every step (a later step's input or witness is a key an earlier frame may
+// name, as a flag holds at every key: kernel.ts's checkStepLaws). Few instances, where the shared ones are many and
+// mostly idle.
 const keptAcross = (m, laws, inst, own, k) => k < 2 ? [] : Object.entries(m.step.flags ?? {}).flatMap(([f, c]) => {
     if (c.op !== 'all' || c.keys?.length)
         return [];
     const ws = Array.from({ length: k }, (_, i) => ({ op: 'var', name: i ? `w?${f}@${i + 1}` : `w?${f}` })), keys = [...own, ...ws.slice(0, 1)];
     const keep = new Set(keys.map(e => JSON.stringify(e)));
-    return [Object.fromEntries(Object.entries(inst).map(([n, ks]) => [n, arity(m, laws, n) === 1 ? [...ks.filter(e => keep.has(JSON.stringify(e))), ...(n === `?${f}` ? ws.slice(1) : [])] : ks]))];
+    return [Object.fromEntries(Object.entries(inst).map(([n, ks]) => [n, n === `?${f}` ? [...keys, ...ws.slice(1)].filter((e, i, all) => all.findIndex(o => JSON.stringify(o) === JSON.stringify(e)) === i) : arity(m, laws, n) === 1 ? ks.filter(e => keep.has(JSON.stringify(e))) : ks]))];
 });
 const pairFlags = (m) => Object.values(m.step.flags ?? {}).some(c => c.op === 'all' && !!c.keys?.length);
 // How many keys each instance of a name takes: a law's, or a quantified flag's (?f).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdp-wired",
-  "version": "0.12.4",
+  "version": "0.12.6",
   "description": "An automatic prover for stateful rules (budgets, caps, windows, workflows, policies): laws proven with no proof to write, checked again in Lean, counterexamples found on the GPU, the rule shipped as code",
   "keywords": [
     "verification",
@@ -89,7 +89,7 @@
     "build": "bun scripts/build.ts",
     "prepublishOnly": "bun scripts/build.ts",
     "smoke": "sh scripts/smoke.sh",
-    "test": "bun scripts/gen-lean-library.ts --check && cd core && bun test solver.test.ts dsl.test.ts conformance.test.ts compose.test.ts quantifiers.test.ts functions.test.ts keyterms.test.ts lists.test.ts liveness.test.ts sizes.test.ts values.test.ts builders.test.ts gdp.test.ts datatypes.test.ts lemmas.test.ts invoices.test.ts folds.test.ts trees.test.ts pairs.test.ts && cd ../kernel && bun test tamper.test.ts refusals.test.ts steplaw.test.ts sets.test.ts && cd ../examples && bun test examples.test.ts && cd .. && bun examples/readme.ts && bun examples/composition.ts && bun examples/sets.ts && bun examples/quantifiers.ts && bun examples/functions.ts && bun examples/datatypes.ts && bun examples/lemmas.ts && bun examples/invoices.ts && bun examples/folds.ts && bun examples/trees.ts && bun examples/pairs.ts && bun examples/lists.ts && bun examples/sizes.ts && bun examples/liveness.ts && bun examples/budget.ts && bun examples/gdp.ts && bun examples/steps.ts && bun examples/jev-fabric/run.ts"
+    "test": "bun scripts/gen-lean-library.ts --check && cd core && bun test solver.test.ts dsl.test.ts conformance.test.ts compose.test.ts quantifiers.test.ts functions.test.ts keyterms.test.ts lists.test.ts liveness.test.ts sizes.test.ts values.test.ts builders.test.ts gdp.test.ts datatypes.test.ts lemmas.test.ts invoices.test.ts folds.test.ts trees.test.ts pairs.test.ts && cd ../kernel && bun test tamper.test.ts refusals.test.ts steplaw.test.ts sets.test.ts && cd ../examples && bun test examples.test.ts && cd .. && bun examples/readme.ts && bun examples/guide.ts && bun examples/composition.ts && bun examples/sets.ts && bun examples/quantifiers.ts && bun examples/functions.ts && bun examples/datatypes.ts && bun examples/lemmas.ts && bun examples/invoices.ts && bun examples/folds.ts && bun examples/trees.ts && bun examples/pairs.ts && bun examples/lists.ts && bun examples/sizes.ts && bun examples/liveness.ts && bun examples/budget.ts && bun examples/gdp.ts && bun examples/steps.ts && bun examples/jev-fabric/run.ts"
   },
   "devDependencies": {
     "@gdp-ts/core": "0.1.0",