gdp-wired 0.13.0 → 0.13.1

package/dist/core/chart.d.ts

@@ -1,4 +1,4 @@
-import { type Cond, type Kind, type Rule, type Term, type TermLike, type Verdict, type Choice } from './dsl.js';
+import { type Cond, type Kind, type Rule, type Term, type TermLike, type Verdict, Choice } from './dsl.js';
 import { type Law } from './machine.js';
 import type { StepLaw } from '../kernel/kernel.js';
 export type StateNode = {
@@ -19,10 +19,10 @@ type After<X> = X & {
 };
 export type Transition<P, I, X> = {
     from: string | string[];
-    to: string;
+    to?: string;
     when?: (env: Env<P, I, X>) => Cond;
     set?: (env: Env<P, I, X>) => Partial<{
-        [k in keyof X]: TermLike | Cond | X[k];
+        [k in keyof X]: X[k] extends Choice<infer K> ? K | X[k] : TermLike | Cond | X[k];
     }>;
 };
 export declare class Chart<P extends Obj = {}, I extends Obj = {}, X extends Obj = {}> {
@@ -32,8 +32,11 @@ export declare class Chart<P extends Obj = {}, I extends Obj = {}, X extends Obj
         params: Obj;
         inputs: Obj;
         context: Obj;
+        outputs: Obj;
         regions: [string, StateNode][];
         on: [string, Transition<P, I, X>][];
+        field?: string;
+        events?: string[];
     });
     private with;
     params<K extends Record<string, Kind<unknown>>>(kinds: K): Chart<P & {
@@ -50,8 +53,18 @@ export declare class Chart<P extends Obj = {}, I extends Obj = {}, X extends Obj
             kind: Kind<infer V>;
         } ? V : Term;
     }>;
+    outputs<T extends Record<string, number | {
+        kind: Kind<unknown>;
+        init: unknown;
+    }>>(init: T): Chart<P, I, X & {
+        [k in keyof T]: T[k] extends {
+            kind: Kind<infer V>;
+        } ? V : Term;
+    }>;
+    events(...names: string[]): Chart<P, I, X>;
     states(tree: Record<string, StateNode>, opts?: {
         initial?: string;
+        field?: string;
     }): Chart<P, I, X>;
     regions(regions: Record<string, StateNode>): Chart<P, I, X>;
     on(event: string, t: Transition<P, I, X>): Chart<P, I, X>;

package/dist/core/chart.js

@@ -16,7 +16,7 @@
 // most specific source (an inner state over its parent) is taken, then the first declared; the regions react to the
 // same event at once. A transition into a compound state enters its initial child, or the child it was last in when the
 // compound keeps its history; `set` writes the extended state (a variable two regions both set takes the first region's).
-import { all, any, oneOf, proveRule, proveSteps, rule, when } from "./dsl.js";
+import { Choice, all, any, no, oneOf, proveRule, proveSteps, rule, when, yes } from "./dsl.js";
 import { interpret, numbersOf } from "./machine.js";
 import { allowed } from "./watch.js";
 export class Chart {
@@ -30,8 +30,15 @@ export class Chart {
     inputs(kinds) { return this.with({ inputs: { ...this.s.inputs, ...kinds } }); }
     // The extended state: a natural from a number, or any kind from `kind.from(init)`.
     context(init) { return this.with({ context: { ...this.s.context, ...init } }); }
-    // One region's states (a chart of one region names its states plainly: 'active.paid').
-    states(tree, opts = {}) { return this.with({ regions: [['state', { states: tree, initial: opts.initial }]] }); }
+    // What each step decides, read after it (a command, a verdict): every output starts each step at its default, and a
+    // transition taken may set it, so a step where none fires reads the default, never the last step's value. A default
+    // is a number, a choice (`oneOf(...).from('denied')`) or a yes/no (`bool.from(false)`).
+    outputs(init) { return this.with({ outputs: { ...this.s.outputs, ...init } }); }
+    // The events, in the order they are encoded (by default, the order they are first used in `on`).
+    events(...names) { return this.with({ events: names }); }
+    // One region's states (a chart of one region names its states plainly: 'active.paid'); `field` names the state
+    // variable the rule keeps them in (`state` by default).
+    states(tree, opts = {}) { return this.with({ regions: [['state', { states: tree, initial: opts.initial }]], field: opts.field }); }
     // Parallel regions, each with its own states, reacting to the same events: paths start with the region ('payment.paid').
     regions(regions) { return this.with({ regions: Object.entries(regions) }); }
     on(event, t) { return this.with({ on: [...this.s.on, [event, t]] }); }
@@ -64,7 +71,7 @@ export class Chart {
                 }
             };
             walk('', root);
-            return { name, field: single ? 'state' : name, leaves, finals, compounds };
+            return { name, field: single ? s.field ?? 'state' : name, leaves, finals, compounds };
         });
         // A path as the region and the state within it.
         const locate = (path) => {
@@ -81,14 +88,20 @@ export class Chart {
                 throw new Error(`${s.name}: no state ${path} in ${r.name}`);
             return out;
         };
-        const events = [...new Set(s.on.map(([e]) => e))];
+        const used = [...new Set(s.on.map(([e]) => e))], events = s.events ?? used;
+        for (const e of used)
+            if (!events.includes(e))
+                throw new Error(`${s.name}: the event ${e} isn't one of the events declared (${events.join(', ')})`);
+        if (new Set(events).size !== events.length)
+            throw new Error(`${s.name}: an event is declared twice`);
         if (!events.length)
             throw new Error(`${s.name}: a chart needs transitions`);
         const placed = s.on.map(([event, t], order) => {
-            const froms = (Array.isArray(t.from) ? t.from : [t.from]).map(locate), [to] = locate(t.to);
+            const froms = (Array.isArray(t.from) ? t.from : [t.from]).map(locate), [to] = t.to === undefined ? froms[0] : locate(t.to);
             if (froms.some(([r]) => r !== to))
-                throw new Error(`${s.name}: a transition on ${event} goes from one region to another (${t.to})`);
-            under(to, locate(t.to)[1]);
+                throw new Error(`${s.name}: a transition on ${event} goes from one region to another (${t.to ?? [t.from].flat().join(", ")})`);
+            if (t.to !== undefined)
+                under(to, locate(t.to)[1]);
             const sources = [...new Set(froms.flatMap(([r, p]) => under(r, p)))];
             return { ...t, event, region: to.name, sources, depth: Math.min(...froms.map(([, p]) => (p === '' ? 0 : p.split('.').length))), order };
         });
@@ -103,7 +116,7 @@ export class Chart {
                 if (history && c)
                     state[lastOf(r, c)] = kind.from(enter(c));
         }
-        for (const [k, v] of Object.entries(s.context))
+        for (const [k, v] of Object.entries({ ...s.context, ...s.outputs }))
             state[k] = v;
         const inState = (env) => (path) => { const [r, p] = locate(path); return any(...under(r, p).map(l => env[r.field].is(l))); };
         const guardEnv = (env) => this.wrap(env);
@@ -125,15 +138,17 @@ export class Chart {
             for (const r of regions) {
                 // The transitions taken in a region exclude one another: a chain of `when`s, the first in order outermost.
                 out[r.field] = placed.map((t, i) => [t, i]).filter(([t]) => t.region === r.name).reverse()
-                    .reduce((acc, [t, i]) => when(env[`take${i}`], entered(env, r, locate(t.to)[1]), acc), env[r.field]);
+                    .reduce((acc, [t, i]) => when(env[`take${i}`], t.to === undefined ? env[r.field] : entered(env, r, locate(t.to)[1]), acc), env[r.field]);
                 for (const [c, { history }] of r.compounds)
                     if (history && c)
                         out[lastOf(r, c)] = when(any(...under(r, c).map(l => out[r.field].is(l))), out[r.field], env[lastOf(r, c)]);
             }
-            for (const k of Object.keys(s.context)) {
+            // Context keeps its value where no transition taken sets it; an output falls back to its default.
+            for (const k of [...Object.keys(s.context), ...Object.keys(s.outputs)]) {
                 const sets = placed.map((t, i) => [t, i]).filter(([t]) => t.set).map(([t, i]) => [i, t.set(guardEnv(env))[k]]).filter(([, v]) => v !== undefined);
-                if (sets.length)
-                    out[k] = sets.reverse().reduce((acc, [i, v]) => when(env[`take${i}`], v, acc), env[k]);
+                const base = k in s.outputs ? defaultOf(env[k], s.outputs[k], k) : env[k];
+                if (sets.length || k in s.outputs)
+                    out[k] = sets.reverse().reduce((acc, [i, v]) => when(env[`take${i}`], v, acc), base);
             }
             return out;
         });
@@ -225,7 +240,8 @@ export class Chart {
                 const v = proveRule(r, [...this.chartLaws(), never]);
                 reached[name] = v.proven && v.checked ? 'unreachable' : 'unknown';
             }
-        const stuck = regions.flatMap(reg => reg.leaves.filter(l => !reg.finals.has(l) && !placed.some(t => t.region === reg.name && t.sources.includes(l))).map(l => label(reg, l)));
+        // A way out is a transition to a state: an internal one stays where it is.
+        const stuck = regions.flatMap(reg => reg.leaves.filter(l => !reg.finals.has(l) && !placed.some(t => t.to !== undefined && t.region === reg.name && t.sources.includes(l))).map(l => label(reg, l)));
         const ambiguous = [];
         placed.forEach((t, i) => placed.forEach((u, j) => {
             if (j <= i || t.region !== u.region || t.event !== u.event || t.depth !== u.depth || !t.sources.some(l => u.sources.includes(l)))
@@ -238,4 +254,17 @@ export class Chart {
         return { ok: !stuck.length && !ambiguous.length && Object.values(reached).every(x => x !== 'unknown'), reached, stuck, ambiguous };
     }
 }
-export const chart = (name) => new Chart({ name, params: {}, inputs: {}, context: {}, regions: [], on: [] });
+export const chart = (name) => new Chart({ name, params: {}, inputs: {}, context: {}, outputs: {}, regions: [], on: [] });
+// An output's default as a value of its kind: a number, a choice's named value, or a yes/no.
+function defaultOf(current, init, name) {
+    if (typeof init === 'number')
+        return init;
+    const { kind, init: v } = init;
+    if (current instanceof Choice)
+        return current.of(v);
+    if (typeof v === 'boolean')
+        return v ? yes : no;
+    if (typeof v === 'number')
+        return v;
+    throw new Error(`the output ${name}'s default is a number, a choice or a yes/no, not ${String(v)} of ${kind.constructor.name}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdp-wired",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "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",