dsh-super-code 0.3.10 → 0.4.0

package/builtin/skills/pstack/dsh/skills/statechart/scripts/passes/lift.ts

@@ -0,0 +1,85 @@
+import {
+  append,
+  type Chart,
+  type ChartState,
+  type ChartStep,
+  must,
+  type Region,
+  tupleKey,
+  unkey,
+} from "../ir.ts";
+
+export function liftToParents(states: ChartState[], steps: ChartStep[]) {
+  const depths = new Map<string, number>();
+  const leaves = new Map<string, number>();
+  for (const s of states.values())
+    for (let i = 1; i < s.path.length; i++) {
+      const prefix = tupleKey(s.path.slice(0, i));
+      depths.set(prefix, i);
+      leaves.set(prefix, (leaves.get(prefix) ?? 0) + 1);
+    }
+  if (!depths.size) return steps;
+  const leaving = new Map<string, ChartStep[]>();
+  for (const s of steps) {
+    let same = 0;
+    while (same < s.from.length && s.from[same] === s.to[same]) same++;
+    for (let i = 1; i < s.from.length; i++) {
+      if (i <= same && i < s.to.length) continue;
+      const prefix = tupleKey(s.from.slice(0, i));
+      if (depths.has(prefix)) append(leaving, prefix, s);
+    }
+  }
+  const removed = new Set<ChartStep>();
+  const lifted: ChartStep[] = [];
+  for (const [prefix] of [...depths].sort((a, b) => a[1] - b[1])) {
+    const groups = new Map<string, ChartStep[]>();
+    for (const s of leaving.get(prefix) ?? [])
+      if (!removed.has(s)) append(groups, tupleKey([s.label, s.when, s.to]), s);
+    const under = must(leaves, prefix);
+    for (const group of groups.values()) {
+      if (under < 2 || group.length < under) continue;
+      for (const s of group) removed.add(s);
+      lifted.push({ ...group[0], from: unkey(prefix) });
+    }
+  }
+  const kept: ChartStep[] = [];
+  for (const s of steps) if (!removed.has(s)) kept.push(s);
+  for (const s of lifted) kept.push(s);
+  return kept;
+}
+
+export function lift(chart: Chart): Chart {
+  const regions: Region[] = [];
+  for (const r of chart.regions) {
+    const known = new Map<string[], number>();
+    for (const s of r.states) known.set(s.path, known.size);
+    let numbers: Map<string, number> | undefined;
+    const pathIndex = (path: string[]) => {
+      let i = known.get(path);
+      if (i !== undefined) return i;
+      if (!numbers) {
+        numbers = new Map();
+        for (const s of r.states) numbers.set(tupleKey(s.path), numbers.size);
+      }
+      const k = tupleKey(path);
+      i = numbers.get(k);
+      if (i === undefined) numbers.set(k, (i = numbers.size));
+      known.set(path, i);
+      return i;
+    };
+    const merged = new Map<number | string, ChartStep>();
+    for (const s of liftToParents(r.states, r.steps)) {
+      const f = pathIndex(s.from);
+      const t = pathIndex(s.to);
+      const k =
+        s.when === undefined && f < 2 ** 26 && t < 2 ** 26
+          ? f * 2 ** 26 + t
+          : `${f},${t}:${s.when}`;
+      const prior = merged.get(k);
+      if (prior) prior.label += ` or ${s.label}`;
+      else merged.set(k, { ...s });
+    }
+    regions.push({ ...r, steps: [...merged.values()] });
+  }
+  return { ...chart, regions };
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/passes/loop-check.mjs

@@ -0,0 +1,57 @@
+import { append, holds, loopOf, must, tupleKey, unkey, } from "../ir.mjs";
+export function loopCheck({ regions, loops }, { names, keys, drawnLabels, sorted }, { index, from, to }, found) {
+    const R = names.length;
+    const combo = (i) => {
+        const parts = [];
+        for (let r = 0; r < R; r++)
+            parts.push(keys[r][i]);
+        return tupleKey(parts);
+    };
+    const stepsFrom = new Map();
+    const arrowsFrom = [];
+    if (loops.length) {
+        for (const j of sorted)
+            append(stepsFrom, from[j], j);
+        for (const { arrows } of regions) {
+            const out = new Map();
+            for (const a of arrows)
+                append(out, a.from, a);
+            arrowsFrom.push(out);
+        }
+    }
+    for (const b of found) {
+        if (b.loop === undefined)
+            continue;
+        const inLoop = new Set();
+        const twinsOf = new Map();
+        for (const i of loopOf(b, index)) {
+            inLoop.add(combo(i));
+            append(twinsOf, combo(i), i);
+        }
+        for (const i of loopOf(b, index)) {
+            const twins = must(twinsOf, combo(i));
+            for (const [r, name] of names.entries()) {
+                const takes = (a) => {
+                    for (const s of twins)
+                        for (const j of stepsFrom.get(s) ?? [])
+                            if (drawnLabels[j] === a.label && keys[r][to[j]] === a.to)
+                                return true;
+                    return false;
+                };
+                const rest = [];
+                for (let o = 0; o < R; o++)
+                    if (o !== r)
+                        rest.push(keys[o][i]);
+                for (const a of arrowsFrom[r].get(keys[r][i]) ?? []) {
+                    if (!holds(a.condition, rest))
+                        continue;
+                    const next = [];
+                    for (let o = 0; o < R; o++)
+                        next.push(o === r ? a.to : keys[o][i]);
+                    if (!inLoop.has(tupleKey(next)) && !takes(a))
+                        throw new Error(`The chart draws the step ${a.label} out of ${name ? `${name} ` : ""}${unkey(a.from).join(" / ")}, but the ${b.rule.name} loop cannot take it there. Show in a label what stops it.`);
+                }
+            }
+        }
+    }
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/passes/loop-check.ts

@@ -0,0 +1,68 @@
+import {
+  append,
+  type Arrow,
+  type Bug,
+  type Chart,
+  holds,
+  type Labels,
+  loopOf,
+  must,
+  tupleKey,
+  unkey,
+  type Walk,
+} from "../ir.ts";
+
+export function loopCheck(
+  { regions, loops }: Chart,
+  { names, keys, drawnLabels, sorted }: Labels,
+  { index, from, to }: Walk,
+  found: Bug[],
+) {
+  const R = names.length;
+  const combo = (i: number) => {
+    const parts: string[] = [];
+    for (let r = 0; r < R; r++) parts.push(keys[r][i]);
+    return tupleKey(parts);
+  };
+  const stepsFrom = new Map<number, number[]>();
+  const arrowsFrom: Map<string, Arrow[]>[] = [];
+  if (loops.length) {
+    for (const j of sorted) append(stepsFrom, from[j], j);
+    for (const { arrows } of regions) {
+      const out = new Map<string, Arrow[]>();
+      for (const a of arrows) append(out, a.from, a);
+      arrowsFrom.push(out);
+    }
+  }
+  for (const b of found) {
+    if (b.loop === undefined) continue;
+    const inLoop = new Set<string>();
+    const twinsOf = new Map<string, number[]>();
+    for (const i of loopOf(b, index)) {
+      inLoop.add(combo(i));
+      append(twinsOf, combo(i), i);
+    }
+    for (const i of loopOf(b, index)) {
+      const twins = must(twinsOf, combo(i));
+      for (const [r, name] of names.entries()) {
+        const takes = (a: Arrow) => {
+          for (const s of twins)
+            for (const j of stepsFrom.get(s) ?? [])
+              if (drawnLabels[j] === a.label && keys[r][to[j]] === a.to) return true;
+          return false;
+        };
+        const rest: string[] = [];
+        for (let o = 0; o < R; o++) if (o !== r) rest.push(keys[o][i]);
+        for (const a of arrowsFrom[r].get(keys[r][i]) ?? []) {
+          if (!holds(a.condition, rest)) continue;
+          const next: string[] = [];
+          for (let o = 0; o < R; o++) next.push(o === r ? a.to : keys[o][i]);
+          if (!inLoop.has(tupleKey(next)) && !takes(a))
+            throw new Error(
+              `The chart draws the step ${a.label} out of ${name ? `${name} ` : ""}${unkey(a.from).join(" / ")}, but the ${b.rule.name} loop cannot take it there. Show in a label what stops it.`,
+            );
+        }
+      }
+    }
+  }
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/passes/paths.mjs

@@ -0,0 +1,50 @@
+import { hasRule, must, stateKey, } from "../ir.mjs";
+export function pathGraph(names) {
+    const graph = { states: new Map(), steps: [] };
+    const ids = new Map();
+    const taken = new Map();
+    const idOf = (vars, start) => {
+        if (!vars)
+            throw new Error("TLC's trace has a state with no values.");
+        const k = stateKey(names.map((name) => vars[name]));
+        let id = ids.get(k);
+        if (id === undefined) {
+            ids.set(k, (id = String(ids.size)));
+            graph.states.set(id, { vars, start, breaks: [] });
+        }
+        else if (start)
+            must(graph.states, id).start = true;
+        return id;
+    };
+    const route = (seq) => {
+        const start = idOf(seq[0].vars, true);
+        const path = [];
+        let from = start;
+        for (let i = 1; i < seq.length; i++) {
+            const { action } = seq[i];
+            const to = idOf(seq[i].vars, false);
+            const k = `${from} ${to} ${action}`;
+            let step = taken.get(k);
+            if (!step) {
+                taken.set(k, (step = { from, to, action }));
+                graph.steps.push(step);
+            }
+            path.push({ action, state: to, step });
+            from = to;
+        }
+        return { start, path };
+    };
+    return {
+        graph,
+        bug: (rule, trace) => {
+            if (!trace.length)
+                throw new Error(`TLC's trace for ${rule.name} has no states.`);
+            const bug = { rule, ...route(trace) };
+            const end = must(graph.states, bug.path.at(-1)?.state ?? bug.start);
+            if (!hasRule(end.breaks, rule))
+                end.breaks.push(rule);
+            return bug;
+        },
+        lasso: ({ seq, loop }) => seq.length ? { ...route(seq), loop, stutters: loop === seq.length - 1 } : undefined,
+    };
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/passes/paths.ts

@@ -0,0 +1,60 @@
+import {
+  type Bug,
+  type Graph,
+  hasRule,
+  type Lasso,
+  must,
+  type PathStep,
+  type Rule,
+  stateKey,
+  type Step,
+  type Trace,
+  type TraceState,
+  type Vars,
+} from "../ir.ts";
+
+export function pathGraph(names: string[]) {
+  const graph: Graph = { states: new Map(), steps: [] };
+  const ids = new Map<string, string>();
+  const taken = new Map<string, Step>();
+  const idOf = (vars: Vars | undefined, start: boolean) => {
+    if (!vars) throw new Error("TLC's trace has a state with no values.");
+    const k = stateKey(names.map((name) => vars[name]));
+    let id = ids.get(k);
+    if (id === undefined) {
+      ids.set(k, (id = String(ids.size)));
+      graph.states.set(id, { vars, start, breaks: [] });
+    } else if (start) must(graph.states, id).start = true;
+    return id;
+  };
+  const route = (seq: { action: string; vars: Vars | undefined }[]) => {
+    const start = idOf(seq[0].vars, true);
+    const path: PathStep[] = [];
+    let from = start;
+    for (let i = 1; i < seq.length; i++) {
+      const { action } = seq[i];
+      const to = idOf(seq[i].vars, false);
+      const k = `${from} ${to} ${action}`;
+      let step = taken.get(k);
+      if (!step) {
+        taken.set(k, (step = { from, to, action }));
+        graph.steps.push(step);
+      }
+      path.push({ action, state: to, step });
+      from = to;
+    }
+    return { start, path };
+  };
+  return {
+    graph,
+    bug: (rule: Rule, trace: TraceState[]): Bug => {
+      if (!trace.length) throw new Error(`TLC's trace for ${rule.name} has no states.`);
+      const bug = { rule, ...route(trace) };
+      const end = must(graph.states, bug.path.at(-1)?.state ?? bug.start);
+      if (!hasRule(end.breaks, rule)) end.breaks.push(rule);
+      return bug;
+    },
+    lasso: ({ seq, loop }: Trace): Lasso | undefined =>
+      seq.length ? { ...route(seq), loop, stutters: loop === seq.length - 1 } : undefined,
+  };
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/passes/reach.mjs

@@ -0,0 +1,134 @@
+import { byText, count, defaultState, must, ruleKey, sortBy, } from "../ir.mjs";
+export function walk(graph) {
+    const ids = [];
+    const states = [];
+    const nameOf = [];
+    const starts = [];
+    const unique = new Set();
+    for (const [id, s] of graph.states) {
+        const name = defaultState(s.vars);
+        if (s.start)
+            starts.push(ids.length);
+        ids.push(id);
+        states.push(s);
+        nameOf.push(name);
+        unique.add(name);
+    }
+    const names = Array.from(unique).sort(byText);
+    const rankOf = new Map();
+    for (let i = 0; i < names.length; i++)
+        rankOf.set(names[i], i);
+    const n = ids.length;
+    const index = new Map();
+    const nameRank = new Int32Array(n);
+    for (let i = 0; i < n; i++) {
+        index.set(ids[i], i);
+        nameRank[i] = must(rankOf, nameOf[i]);
+    }
+    const m = graph.steps.length;
+    const from = new Int32Array(m);
+    const to = new Int32Array(m);
+    const action = new Int32Array(m);
+    const actions = new Map();
+    for (let j = 0; j < m; j++) {
+        const t = graph.steps[j];
+        from[j] = must(index, t.from);
+        to[j] = must(index, t.to);
+        let a = actions.get(t.action);
+        if (a === undefined)
+            actions.set(t.action, (a = actions.size));
+        action[j] = a;
+    }
+    const actionRank = new Int32Array(actions.size);
+    for (const [i, a] of [...actions.keys()].sort(byText).entries())
+        actionRank[must(actions, a)] = i;
+    const toName = new Int32Array(m);
+    for (let j = 0; j < m; j++) {
+        action[j] = actionRank[action[j]];
+        toName[j] = nameRank[to[j]];
+    }
+    const first = new Int32Array(n + 1);
+    for (let j = 0; j < m; j++)
+        first[from[j] + 1]++;
+    for (let i = 0; i < n; i++)
+        first[i + 1] += first[i];
+    const fill = first.slice(0, n);
+    const next = new Int32Array(m);
+    for (const j of sortBy(count(m), [action, toName]))
+        next[fill[from[j]]++] = j;
+    starts.sort((a, b) => nameRank[a] - nameRank[b]);
+    const depth = new Int32Array(n).fill(-1);
+    const via = new Int32Array(n).fill(-1);
+    const reached = new Int32Array(n);
+    let size = 0;
+    for (const s of starts) {
+        depth[s] = 0;
+        reached[size++] = s;
+    }
+    for (let q = 0; q < size; q++) {
+        const s = reached[q];
+        for (let e = first[s]; e < first[s + 1]; e++) {
+            const t = to[next[e]];
+            if (depth[t] >= 0)
+                continue;
+            depth[t] = depth[s] + 1;
+            via[t] = next[e];
+            reached[size++] = t;
+        }
+    }
+    return {
+        ids,
+        states,
+        index,
+        nameOf,
+        nameRank,
+        from,
+        to,
+        action,
+        depth,
+        via,
+        reached: reached.subarray(0, size),
+        starts,
+    };
+}
+export function drawOrder({ depth, nameRank }) {
+    const n = depth.length;
+    let deepest = 0;
+    for (let i = 0; i < n; i++)
+        if (depth[i] > deepest)
+            deepest = depth[i];
+    const level = new Int32Array(n);
+    for (let i = 0; i < n; i++)
+        level[i] = depth[i] < 0 ? deepest + 1 : depth[i];
+    const order = sortBy(count(n), [level, nameRank]);
+    const rank = new Int32Array(n);
+    for (let p = 0; p < n; p++)
+        rank[order[p]] = p;
+    return { order, rank };
+}
+export function bugs(graph, { ids, from, via, reached } = walk(graph)) {
+    const ends = new Map();
+    for (const [id, s] of graph.states)
+        for (const rule of s.ends ?? [])
+            ends.set(ruleKey(rule), id);
+    const first = new Map();
+    for (const i of reached) {
+        const s = must(graph.states, ids[i]);
+        for (const rule of s.past ? s.ends : s.breaks) {
+            const k = ruleKey(rule);
+            if (!first.has(k) && (ends.get(k) ?? ids[i]) === ids[i])
+                first.set(k, { rule, i });
+        }
+    }
+    const found = [];
+    for (const { rule, i } of first.values()) {
+        const path = [];
+        let start = i;
+        for (let j; (j = via[start]) >= 0; start = from[j]) {
+            const step = graph.steps[j];
+            path.unshift({ action: step.action, state: step.to, step });
+        }
+        found.push({ rule, start: ids[start], path });
+    }
+    return found;
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/passes/reach.ts

@@ -0,0 +1,135 @@
+import {
+  type Bug,
+  byText,
+  count,
+  defaultState,
+  type Graph,
+  must,
+  type PathStep,
+  type Rule,
+  ruleKey,
+  sortBy,
+  type State,
+  type Walk,
+} from "../ir.ts";
+
+export function walk(graph: Graph): Walk {
+  const ids: string[] = [];
+  const states: State[] = [];
+  const nameOf: string[] = [];
+  const starts: number[] = [];
+  const unique = new Set<string>();
+  for (const [id, s] of graph.states) {
+    const name = defaultState(s.vars);
+    if (s.start) starts.push(ids.length);
+    ids.push(id);
+    states.push(s);
+    nameOf.push(name);
+    unique.add(name);
+  }
+  const names = Array.from(unique).sort(byText);
+  const rankOf = new Map<string, number>();
+  for (let i = 0; i < names.length; i++) rankOf.set(names[i], i);
+  const n = ids.length;
+  const index = new Map<string, number>();
+  const nameRank = new Int32Array(n);
+  for (let i = 0; i < n; i++) {
+    index.set(ids[i], i);
+    nameRank[i] = must(rankOf, nameOf[i]);
+  }
+  const m = graph.steps.length;
+  const from = new Int32Array(m);
+  const to = new Int32Array(m);
+  const action = new Int32Array(m);
+  const actions = new Map<string, number>();
+  for (let j = 0; j < m; j++) {
+    const t = graph.steps[j];
+    from[j] = must(index, t.from);
+    to[j] = must(index, t.to);
+    let a = actions.get(t.action);
+    if (a === undefined) actions.set(t.action, (a = actions.size));
+    action[j] = a;
+  }
+  const actionRank = new Int32Array(actions.size);
+  for (const [i, a] of [...actions.keys()].sort(byText).entries()) actionRank[must(actions, a)] = i;
+  const toName = new Int32Array(m);
+  for (let j = 0; j < m; j++) {
+    action[j] = actionRank[action[j]];
+    toName[j] = nameRank[to[j]];
+  }
+  const first = new Int32Array(n + 1);
+  for (let j = 0; j < m; j++) first[from[j] + 1]++;
+  for (let i = 0; i < n; i++) first[i + 1] += first[i];
+  const fill = first.slice(0, n);
+  const next = new Int32Array(m);
+  for (const j of sortBy(count(m), [action, toName])) next[fill[from[j]]++] = j;
+  starts.sort((a, b) => nameRank[a] - nameRank[b]);
+  const depth = new Int32Array(n).fill(-1);
+  const via = new Int32Array(n).fill(-1);
+  const reached = new Int32Array(n);
+  let size = 0;
+  for (const s of starts) {
+    depth[s] = 0;
+    reached[size++] = s;
+  }
+  for (let q = 0; q < size; q++) {
+    const s = reached[q];
+    for (let e = first[s]; e < first[s + 1]; e++) {
+      const t = to[next[e]];
+      if (depth[t] >= 0) continue;
+      depth[t] = depth[s] + 1;
+      via[t] = next[e];
+      reached[size++] = t;
+    }
+  }
+  return {
+    ids,
+    states,
+    index,
+    nameOf,
+    nameRank,
+    from,
+    to,
+    action,
+    depth,
+    via,
+    reached: reached.subarray(0, size),
+    starts,
+  };
+}
+
+export function drawOrder({ depth, nameRank }: Walk) {
+  const n = depth.length;
+  let deepest = 0;
+  for (let i = 0; i < n; i++) if (depth[i] > deepest) deepest = depth[i];
+  const level = new Int32Array(n);
+  for (let i = 0; i < n; i++) level[i] = depth[i] < 0 ? deepest + 1 : depth[i];
+  const order = sortBy(count(n), [level, nameRank]);
+  const rank = new Int32Array(n);
+  for (let p = 0; p < n; p++) rank[order[p]] = p;
+  return { order, rank };
+}
+
+export function bugs(graph: Graph, { ids, from, via, reached }: Walk = walk(graph)) {
+  const ends = new Map<string, string>();
+  for (const [id, s] of graph.states) for (const rule of s.ends ?? []) ends.set(ruleKey(rule), id);
+  const first = new Map<string, { rule: Rule; i: number }>();
+  for (const i of reached) {
+    const s = must(graph.states, ids[i]);
+    for (const rule of s.past ? s.ends : s.breaks) {
+      const k = ruleKey(rule);
+      if (!first.has(k) && (ends.get(k) ?? ids[i]) === ids[i]) first.set(k, { rule, i });
+    }
+  }
+  const found: Bug[] = [];
+  for (const { rule, i } of first.values()) {
+    const path: PathStep[] = [];
+    let start = i;
+    for (let j: number; (j = via[start]) >= 0; start = from[j]) {
+      const step = graph.steps[j];
+      path.unshift({ action: step.action, state: step.to, step });
+    }
+    found.push({ rule, start: ids[start], path });
+  }
+  return found;
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/passes/region-check.mjs

@@ -0,0 +1,94 @@
+import { append, holds, tupleKey, unkey, } from "../ir.mjs";
+export function regionsLie(regions, { names, keys, sorted, drawnLabels, together }, { from, to, starts }, order) {
+    if (names.length < 2)
+        return undefined;
+    const combo = (i) => {
+        const c = [];
+        for (let r = 0; r < names.length; r++)
+            c.push(keys[r][i]);
+        return c;
+    };
+    const words = (c) => {
+        const parts = [];
+        for (let i = 0; i < names.length; i++)
+            parts.push(`${names[i]} ${unkey(c[i]).join(" / ")}`);
+        return parts.join(", ");
+    };
+    const addMove = (moves, m) => moves.set(tupleKey([m.from, m.text, m.to]), m);
+    let product = [[]];
+    for (const r of regions) {
+        const next = [];
+        for (const c of product)
+            for (const s of r.states)
+                if (s.start)
+                    next.push([...c, tupleKey(s.path)]);
+        product = next;
+    }
+    const realStarts = new Set();
+    for (const i of starts)
+        realStarts.add(tupleKey(combo(i)));
+    for (const c of product)
+        if (!realStarts.has(tupleKey(c)))
+            return `The regions chart starts at ${words(c)}, where the model never starts.`;
+    for (const [i, r] of regions.entries())
+        for (const a of r.arrows)
+            if (a.condition.kind === "tuples")
+                return `In ${names[i]}, ${a.label} from ${unkey(a.from).join(" / ")} depends on the other regions in a way that one "and" or "or" condition cannot say.`;
+    const real = new Map();
+    for (const j of sorted) {
+        const before = combo(from[j]);
+        const after = combo(to[j]);
+        if (tupleKey(before) !== tupleKey(after))
+            addMove(real, { from: before, text: drawnLabels[j], to: after });
+    }
+    const combos = new Map();
+    for (const i of order) {
+        const c = combo(i);
+        combos.set(tupleKey(c), c);
+    }
+    const drawn = new Map();
+    for (const c of combos.values()) {
+        const enabled = new Map();
+        for (const [i, r] of regions.entries()) {
+            const rest = [];
+            for (let k = 0; k < c.length; k++)
+                if (k !== i)
+                    rest.push(c[k]);
+            for (const a of r.arrows)
+                if (a.from === c[i] && holds(a.condition, rest))
+                    append(enabled, a.label, { i, a });
+        }
+        for (const [text, list] of enabled) {
+            let groups = [];
+            if (together.has(text)) {
+                const byRegion = new Map();
+                for (const m of list)
+                    append(byRegion, m.i, m);
+                groups = [[]];
+                for (const opts of byRegion.values()) {
+                    const next = [];
+                    for (const g of groups)
+                        for (const m of opts)
+                            next.push([...g, m]);
+                    groups = next;
+                }
+            }
+            else
+                for (const m of list)
+                    groups.push([m]);
+            for (const group of groups) {
+                const to = [...c];
+                for (const { i, a } of group)
+                    to[i] = a.to;
+                addMove(drawn, { from: c, text, to });
+            }
+        }
+    }
+    for (const [k, extra] of drawn)
+        if (!real.has(k))
+            return `The regions chart lets ${words(extra.from)} go to ${words(extra.to)} by ${extra.text}, which the model never does.`;
+    for (const [k, missing] of real)
+        if (!drawn.has(k))
+            return `The model goes from ${words(missing.from)} to ${words(missing.to)} by ${missing.text}, which the regions chart cannot show.`;
+    return undefined;
+}