dsh-super-code 0.3.11 → 0.4.0

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

@@ -0,0 +1,128 @@
+import {
+  findLoop,
+  findTrace,
+  type Graph,
+  hasRule,
+  type Lasso,
+  type Mark,
+  must,
+  type Past,
+  pastState,
+  type PathStep,
+  type Rule,
+  stateKey,
+  type Step,
+  type Trace,
+  type TraceState,
+  type Value,
+  valuesOf,
+} from "../ir.ts";
+
+export const finder = (graph: Graph, names: string[]) => {
+  let ids: Map<string, string> | undefined;
+  const find = (values: Value[]) => {
+    if (!ids) {
+      ids = new Map();
+      for (const [id, s] of graph.states)
+        if (!s.excluded) ids.set(stateKey(valuesOf(s.vars, names)), id);
+    }
+    return ids.get(stateKey(values));
+  };
+  find.add = (id: string, values: Value[]) => ids?.set(stateKey(values), id);
+  return find;
+};
+
+export function mark(
+  graph: Graph,
+  marks: Iterable<Mark>,
+  names: string[],
+  rules: Rule[],
+  find = finder(graph, names),
+) {
+  const byName = new Map<string, Rule>();
+  for (const rule of rules) byName.set(rule.name, rule);
+  const past: Past = new Map();
+  for (const { values, broken } of marks) {
+    const id = find(values);
+    const state = id === undefined ? undefined : graph.states.get(id);
+    for (const name of broken) {
+      const rule = must(byName, name);
+      if (state) state.breaks.push(rule);
+      else past.set(stateKey(values), (past.get(stateKey(values)) ?? new Set()).add(rule));
+    }
+  }
+  return past;
+}
+
+export function deadEnds(graph: Graph, rule: Rule) {
+  const from = new Set<string>();
+  for (const t of graph.steps) from.add(t.from);
+  for (const [id, s] of graph.states) if (!s.past && !from.has(id)) s.breaks.push(rule);
+}
+
+export function addPast(
+  graph: Graph,
+  counterexample: TraceState[],
+  names: string[],
+  rule: Rule,
+  past: Past,
+  excludes: boolean,
+  find = finder(graph, names),
+) {
+  const trace = findTrace(counterexample, names, rule, find);
+  const end = trace.length - 1;
+  const from = trace[end - 1]?.id;
+  const action = trace[end].action;
+  const taken = (to: string | undefined) => {
+    for (const t of graph.steps)
+      if (t.from === from && t.to === to && t.action === action) return true;
+    return false;
+  };
+  let to = trace[end].id;
+  const reached = to === undefined ? undefined : graph.states.get(to);
+  const excluded = excludes && reached !== undefined && end > 0 && !reached.past && !taken(to);
+  if (excluded) to = `past ${to} ${action} ${from}`;
+  to ??= `past ${graph.states.size}`;
+  let last = graph.states.get(to);
+  if (!last) {
+    const marked = excluded ? reached.breaks : (past.get(stateKey(trace[end].values)) ?? []);
+    last = pastState(trace[end].vars, end === 0, marked, excluded);
+    graph.states.set(to, last);
+    if (!excluded) find.add(to, trace[end].values);
+  }
+  if (!hasRule(last.breaks, rule)) last.breaks.push(rule);
+  (last.ends ??= []).push(rule);
+  if (from !== undefined && last.past && !taken(to)) graph.steps.push({ from, to, action });
+}
+
+export function lasso(
+  graph: Graph,
+  trace: Trace,
+  names: string[],
+  find = finder(graph, names),
+): Lasso | undefined {
+  const { seq, loop } = findLoop(trace, names, find);
+  const start = seq[0]?.id;
+  if (start === undefined) return undefined;
+  const out = new Map<string | undefined, Step[]>();
+  for (const s of seq) out.set(s.id, []);
+  for (const t of graph.steps) out.get(t.from)?.push(t);
+  const route: PathStep[] = [];
+  for (let i = 1; i < seq.length; i++) {
+    let step: Step | undefined;
+    for (const t of out.get(seq[i - 1].id) ?? [])
+      if (t.to === seq[i].id && t.action === seq[i].action) {
+        step = t;
+        break;
+      }
+    if (!step) return undefined;
+    route.push({ action: step.action, state: step.to, step });
+  }
+  const stutters = loop === seq.length - 1;
+  return {
+    start,
+    path: route,
+    loop,
+    stutters,
+  };
+}

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

@@ -0,0 +1,217 @@
+import { isRecord, key, list, loopOf, must, sortBy, stateText, tupleKey, } from "../ir.mjs";
+const isLabel = (l) => typeof l === "string" && l !== "" && !/\bundefined\b|\bNaN\b|\[object Object\]/.test(l);
+const shapeOf = (shape, vars) => {
+    function fail() {
+        throw new Error(`The view's state() returned ${JSON.stringify(shape) ?? "undefined"} for the state ${stateText(vars)}. Return a string, an array of strings, or an object of those.`);
+    }
+    const path = (p) => {
+        const labels = [];
+        for (const l of [p].flat()) {
+            if (!isLabel(l))
+                fail();
+            labels.push(l);
+        }
+        if (!labels.length)
+            fail();
+        return labels;
+    };
+    const regions = isRecord(shape) ? Object.entries(shape) : [["", shape]];
+    const pairs = [];
+    for (const [k, v] of regions)
+        pairs.push([k, path(v)]);
+    return pairs.length ? Object.fromEntries(pairs) : fail();
+};
+const stepOf = (view) => (action, from, to) => {
+    const label = (view.step ?? ((a) => a))(action, from, to);
+    if (label === null || isLabel(label))
+        return label;
+    throw new Error(`The view's step() returned ${JSON.stringify(label) ?? "undefined"} for the step ${action}.`);
+};
+function unlabeled(action, before, after, bug) {
+    const changed = [];
+    for (const k of Object.keys(after))
+        if (key(before[k]) !== key(after[k]))
+            changed.push(k);
+    throw new Error(`The view's step() returned null for the step ${action} that changes ${changed.join(", ") || "nothing"}. It is on the path to the ${bug.rule.name} bug${bug.loop === undefined ? "" : " or leaves its loop"}, so label it.`);
+}
+export function ask(graph, { states: tla, nameOf, from, to }, view) {
+    const n = nameOf.length;
+    const m = from.length;
+    const state = view.state;
+    const shapes = new Array(n);
+    for (let i = 0; i < n; i++)
+        shapes[i] = shapeOf(state ? state(tla[i].vars) : nameOf[i], tla[i].vars);
+    const names = Object.keys(shapes[0] ?? { "": [] });
+    const regionsKey = tupleKey(names);
+    for (let i = 0; i < n; i++)
+        if (tupleKey(Object.keys(shapes[i])) !== regionsKey)
+            throw new Error(`The view's state() returned the regions ${names.join(", ")} for one state and ${Object.keys(shapes[i]).join(", ")} for the state ${stateText(tla[i].vars)}. Return the same regions for every state.`);
+    const step = stepOf(view);
+    const labels = new Array(m);
+    for (let j = 0; j < m; j++)
+        labels[j] = step(graph.steps[j].action, tla[from[j]].vars, tla[to[j]].vars);
+    const groups = new Array(n);
+    const asked = new Uint8Array(n);
+    const group = (i) => {
+        if (view.group && !asked[i]) {
+            groups[i] = view.group(tla[i].vars);
+            asked[i] = 1;
+        }
+        return groups[i];
+    };
+    return { names, shapes, labels, group };
+}
+export function asParents({ states: tla }, { names, shapes, labels, group }) {
+    const parents = new Array(shapes.length);
+    for (let i = 0; i < shapes.length; i++) {
+        const path = [];
+        for (const n of names)
+            for (const p of shapes[i][n])
+                path.push(`${n} ${p}`);
+        parents[i] = shapeOf(path, tla[i].vars);
+    }
+    return { names: [""], shapes: parents, labels, group };
+}
+export function labelGraph(graph, { index, from, to, action }, answers, rank, found) {
+    const { names, shapes, labels: stepLabels } = answers;
+    const n = shapes.length;
+    const m = stepLabels.length;
+    const onPath = new Set();
+    for (const b of found)
+        for (const p of b.path)
+            onPath.add(p.step);
+    const pathStepIndex = new Map();
+    if (onPath.size)
+        for (let j = 0; j < m; j++)
+            if (onPath.has(graph.steps[j]))
+                pathStepIndex.set(graph.steps[j], j);
+    const R = names.length;
+    const keys = [];
+    const kinds = [];
+    const sizes = [];
+    for (const name of names) {
+        const key = new Array(n);
+        const kind = new Int32Array(n);
+        const tops = new Map();
+        const nested = new Map();
+        const keyOf = [];
+        for (let i = 0; i < n; i++) {
+            const path = shapes[i][name];
+            const top = path.length === 1;
+            const seen = top ? tops : nested;
+            const k = top ? path[0] : tupleKey(path);
+            let c = seen.get(k);
+            if (c === undefined) {
+                seen.set(k, (c = keyOf.length));
+                keyOf.push(top ? tupleKey(path) : k);
+            }
+            key[i] = keyOf[c];
+            kind[i] = c;
+        }
+        keys.push(key);
+        kinds.push(kind);
+        sizes.push(keyOf.length);
+    }
+    for (const b of found) {
+        let t;
+        for (const p of b.path)
+            if (stepLabels[must(pathStepIndex, p.step)] === null) {
+                t = p.step;
+                break;
+            }
+        if (!t) {
+            const inLoop = loopOf(b, index);
+            if (inLoop.size)
+                for (let j = 0; j < m; j++)
+                    if (inLoop.has(from[j]) && !inLoop.has(to[j]) && stepLabels[j] === null) {
+                        t = graph.steps[j];
+                        break;
+                    }
+        }
+        if (t)
+            unlabeled(t.action, must(graph.states, t.from).vars, must(graph.states, t.to).vars, b);
+    }
+    const drawn = [];
+    const drawnLabels = new Array(m);
+    for (let j = 0; j < m; j++) {
+        const label = stepLabels[j];
+        if (label === null)
+            continue;
+        drawn.push(j);
+        drawnLabels[j] = label;
+    }
+    const fromRank = new Int32Array(m);
+    const toRank = new Int32Array(m);
+    for (let j = 0; j < m; j++) {
+        fromRank[j] = rank[from[j]];
+        toRank[j] = rank[to[j]];
+    }
+    const sorted = sortBy(Int32Array.from(drawn), [fromRank, toRank, action]);
+    const pathSteps = new Uint8Array(m);
+    for (const j of pathStepIndex.values())
+        pathSteps[j] = 1;
+    const byLabel = new Map();
+    if (R > 1)
+        for (const j of sorted) {
+            let entry = byLabel.get(drawnLabels[j]);
+            if (!entry)
+                byLabel.set(drawnLabels[j], (entry = { changed: new Uint8Array(R), sets: new Set() }));
+            const changed = [];
+            for (let r = 0; r < R; r++)
+                if (kinds[r][from[j]] !== kinds[r][to[j]]) {
+                    changed.push(names[r]);
+                    entry.changed[r] = 1;
+                }
+            if (changed.length > 1)
+                entry.sets.add(list(changed));
+        }
+    const together = new Set();
+    for (const [text, { sets }] of byLabel)
+        if (sets.size)
+            together.add(text);
+    const notes = [];
+    for (const [text, entry] of byLabel) {
+        const changed = [];
+        for (let r = 0; r < R; r++)
+            if (entry.changed[r])
+                changed.push(names[r]);
+        if (changed.length < 2)
+            continue;
+        if (!together.has(text)) {
+            notes.push(`The step ${text} changes only one of ${list(changed)} at a time.`);
+            continue;
+        }
+        const sets = [...entry.sets];
+        notes.push(`The step ${text} changes ${sets.length > 1 ? `${sets.join(", or ")},` : sets[0]} at the same time.`);
+    }
+    return {
+        ...answers,
+        drawnLabels,
+        keys,
+        kinds,
+        sizes,
+        sorted,
+        pathStepIndex,
+        pathSteps,
+        together,
+        notes,
+    };
+}
+function tell(states, found, shapeAt, labelAt) {
+    const vars = (id) => must(states, id).vars;
+    const stories = new Map();
+    for (const bug of found) {
+        const story = [{ state: shapeAt(bug.start) }];
+        let from = bug.start;
+        for (const [k, p] of bug.path.entries()) {
+            const step = labelAt(bug, k, from);
+            if (step === null)
+                unlabeled(p.action, vars(from), vars(p.state), bug);
+            story.push({ step, state: shapeAt(p.state) });
+            from = p.state;
+        }
+        stories.set(bug, story);
+    }
+    return stories;
+}
+export const storiesOf = (graph, found, { index }, { shapes, drawnLabels, pathStepIndex }) => tell(graph.states, found, (id) => shapes[must(index, id)], (bug, k) => drawnLabels[must(pathStepIndex, bug.path[k].step)]);

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

@@ -0,0 +1,269 @@
+import {
+  type Answers,
+  type Bug,
+  type Graph,
+  type Hidden,
+  isRecord,
+  key,
+  type Labels,
+  list,
+  loopOf,
+  must,
+  type Rule,
+  type Shape,
+  sortBy,
+  stateText,
+  type Step,
+  type Story,
+  tupleKey,
+  type Vars,
+  type View,
+  type Walk,
+} from "../ir.ts";
+
+const isLabel = (l: unknown): l is string =>
+  typeof l === "string" && l !== "" && !/\bundefined\b|\bNaN\b|\[object Object\]/.test(l);
+
+const shapeOf = (shape: unknown, vars: Vars): Shape => {
+  function fail(): never {
+    throw new Error(
+      `The view's state() returned ${JSON.stringify(shape) ?? "undefined"} for the state ${stateText(vars)}. Return a string, an array of strings, or an object of those.`,
+    );
+  }
+  const path = (p: unknown) => {
+    const labels: string[] = [];
+    for (const l of [p].flat()) {
+      if (!isLabel(l)) fail();
+      labels.push(l);
+    }
+    if (!labels.length) fail();
+    return labels;
+  };
+  const regions: [string, unknown][] = isRecord(shape) ? Object.entries(shape) : [["", shape]];
+  const pairs: [string, string[]][] = [];
+  for (const [k, v] of regions) pairs.push([k, path(v)]);
+  return pairs.length ? Object.fromEntries(pairs) : fail();
+};
+
+const stepOf = (view: View) => (action: string, from: Vars, to: Vars) => {
+  const label = (view.step ?? ((a: string) => a))(action, from, to);
+  if (label === null || isLabel(label)) return label;
+  throw new Error(
+    `The view's step() returned ${JSON.stringify(label) ?? "undefined"} for the step ${action}.`,
+  );
+};
+
+function unlabeled(
+  action: string,
+  before: Vars,
+  after: Vars,
+  bug: { rule: Rule; loop?: number },
+): never {
+  const changed: string[] = [];
+  for (const k of Object.keys(after)) if (key(before[k]) !== key(after[k])) changed.push(k);
+  throw new Error(
+    `The view's step() returned null for the step ${action} that changes ${changed.join(", ") || "nothing"}. It is on the path to the ${bug.rule.name} bug${bug.loop === undefined ? "" : " or leaves its loop"}, so label it.`,
+  );
+}
+
+export function ask(graph: Graph, { states: tla, nameOf, from, to }: Walk, view: View): Answers {
+  const n = nameOf.length;
+  const m = from.length;
+  const state = view.state;
+  const shapes = new Array<Shape>(n);
+  for (let i = 0; i < n; i++)
+    shapes[i] = shapeOf(state ? state(tla[i].vars) : nameOf[i], tla[i].vars);
+  const names = Object.keys(shapes[0] ?? { "": [] });
+  const regionsKey = tupleKey(names);
+  for (let i = 0; i < n; i++)
+    if (tupleKey(Object.keys(shapes[i])) !== regionsKey)
+      throw new Error(
+        `The view's state() returned the regions ${names.join(", ")} for one state and ${Object.keys(shapes[i]).join(", ")} for the state ${stateText(tla[i].vars)}. Return the same regions for every state.`,
+      );
+  const step = stepOf(view);
+  const labels = new Array<string | Hidden>(m);
+  for (let j = 0; j < m; j++)
+    labels[j] = step(graph.steps[j].action, tla[from[j]].vars, tla[to[j]].vars);
+  const groups = new Array<unknown>(n);
+  const asked = new Uint8Array(n);
+  const group = (i: number) => {
+    if (view.group && !asked[i]) {
+      groups[i] = view.group(tla[i].vars);
+      asked[i] = 1;
+    }
+    return groups[i];
+  };
+  return { names, shapes, labels, group };
+}
+
+export function asParents(
+  { states: tla }: Walk,
+  { names, shapes, labels, group }: Answers,
+): Answers {
+  const parents = new Array<Shape>(shapes.length);
+  for (let i = 0; i < shapes.length; i++) {
+    const path: string[] = [];
+    for (const n of names) for (const p of shapes[i][n]) path.push(`${n} ${p}`);
+    parents[i] = shapeOf(path, tla[i].vars);
+  }
+  return { names: [""], shapes: parents, labels, group };
+}
+
+export function labelGraph(
+  graph: Graph,
+  { index, from, to, action }: Walk,
+  answers: Answers,
+  rank: Int32Array,
+  found: Bug[],
+): Labels {
+  const { names, shapes, labels: stepLabels } = answers;
+  const n = shapes.length;
+  const m = stepLabels.length;
+  const onPath = new Set<Step>();
+  for (const b of found) for (const p of b.path) onPath.add(p.step);
+  const pathStepIndex = new Map<Step, number>();
+  if (onPath.size)
+    for (let j = 0; j < m; j++)
+      if (onPath.has(graph.steps[j])) pathStepIndex.set(graph.steps[j], j);
+  const R = names.length;
+  const keys: string[][] = [];
+  const kinds: Int32Array[] = [];
+  const sizes: number[] = [];
+  for (const name of names) {
+    const key = new Array<string>(n);
+    const kind = new Int32Array(n);
+    const tops = new Map<string, number>();
+    const nested = new Map<string, number>();
+    const keyOf: string[] = [];
+    for (let i = 0; i < n; i++) {
+      const path = shapes[i][name];
+      const top = path.length === 1;
+      const seen = top ? tops : nested;
+      const k = top ? path[0] : tupleKey(path);
+      let c = seen.get(k);
+      if (c === undefined) {
+        seen.set(k, (c = keyOf.length));
+        keyOf.push(top ? tupleKey(path) : k);
+      }
+      key[i] = keyOf[c];
+      kind[i] = c;
+    }
+    keys.push(key);
+    kinds.push(kind);
+    sizes.push(keyOf.length);
+  }
+  for (const b of found) {
+    let t: Step | undefined;
+    for (const p of b.path)
+      if (stepLabels[must(pathStepIndex, p.step)] === null) {
+        t = p.step;
+        break;
+      }
+    if (!t) {
+      const inLoop = loopOf(b, index);
+      if (inLoop.size)
+        for (let j = 0; j < m; j++)
+          if (inLoop.has(from[j]) && !inLoop.has(to[j]) && stepLabels[j] === null) {
+            t = graph.steps[j];
+            break;
+          }
+    }
+    if (t) unlabeled(t.action, must(graph.states, t.from).vars, must(graph.states, t.to).vars, b);
+  }
+  const drawn: number[] = [];
+  const drawnLabels = new Array<string>(m);
+  for (let j = 0; j < m; j++) {
+    const label = stepLabels[j];
+    if (label === null) continue;
+    drawn.push(j);
+    drawnLabels[j] = label;
+  }
+  const fromRank = new Int32Array(m);
+  const toRank = new Int32Array(m);
+  for (let j = 0; j < m; j++) {
+    fromRank[j] = rank[from[j]];
+    toRank[j] = rank[to[j]];
+  }
+  const sorted = sortBy(Int32Array.from(drawn), [fromRank, toRank, action]);
+  const pathSteps = new Uint8Array(m);
+  for (const j of pathStepIndex.values()) pathSteps[j] = 1;
+  const byLabel = new Map<string, { changed: Uint8Array; sets: Set<string> }>();
+  if (R > 1)
+    for (const j of sorted) {
+      let entry = byLabel.get(drawnLabels[j]);
+      if (!entry)
+        byLabel.set(drawnLabels[j], (entry = { changed: new Uint8Array(R), sets: new Set() }));
+      const changed: string[] = [];
+      for (let r = 0; r < R; r++)
+        if (kinds[r][from[j]] !== kinds[r][to[j]]) {
+          changed.push(names[r]);
+          entry.changed[r] = 1;
+        }
+      if (changed.length > 1) entry.sets.add(list(changed));
+    }
+  const together = new Set<string>();
+  for (const [text, { sets }] of byLabel) if (sets.size) together.add(text);
+  const notes: string[] = [];
+  for (const [text, entry] of byLabel) {
+    const changed: string[] = [];
+    for (let r = 0; r < R; r++) if (entry.changed[r]) changed.push(names[r]);
+    if (changed.length < 2) continue;
+    if (!together.has(text)) {
+      notes.push(`The step ${text} changes only one of ${list(changed)} at a time.`);
+      continue;
+    }
+    const sets = [...entry.sets];
+    notes.push(
+      `The step ${text} changes ${sets.length > 1 ? `${sets.join(", or ")},` : sets[0]} at the same time.`,
+    );
+  }
+  return {
+    ...answers,
+    drawnLabels,
+    keys,
+    kinds,
+    sizes,
+    sorted,
+    pathStepIndex,
+    pathSteps,
+    together,
+    notes,
+  };
+}
+
+type Told<Id> = { rule: Rule; start: Id; path: { action: string; state: Id }[]; loop?: number };
+
+function tell<Id, B extends Told<Id>>(
+  states: ReadonlyMap<Id, { vars: Vars }>,
+  found: B[],
+  shapeAt: (id: Id) => Shape,
+  labelAt: (bug: B, k: number, from: Id) => string | Hidden,
+) {
+  const vars = (id: Id) => must(states, id).vars;
+  const stories = new Map<B, Story>();
+  for (const bug of found) {
+    const story: Story = [{ state: shapeAt(bug.start) }];
+    let from: Id = bug.start;
+    for (const [k, p] of bug.path.entries()) {
+      const step = labelAt(bug, k, from);
+      if (step === null) unlabeled(p.action, vars(from), vars(p.state), bug);
+      story.push({ step, state: shapeAt(p.state) });
+      from = p.state;
+    }
+    stories.set(bug, story);
+  }
+  return stories;
+}
+
+export const storiesOf = (
+  graph: Graph,
+  found: Bug[],
+  { index }: Walk,
+  { shapes, drawnLabels, pathStepIndex }: Labels,
+) =>
+  tell(
+    graph.states,
+    found,
+    (id) => shapes[must(index, id)],
+    (bug, k) => drawnLabels[must(pathStepIndex, bug.path[k].step)],
+  );

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

@@ -0,0 +1,89 @@
+import { append, must, tupleKey, unkey, } from "../ir.mjs";
+export function liftToParents(states, steps) {
+    const depths = new Map();
+    const leaves = new Map();
+    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();
+    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();
+    const lifted = [];
+    for (const [prefix] of [...depths].sort((a, b) => a[1] - b[1])) {
+        const groups = new Map();
+        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 = [];
+    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) {
+    const regions = [];
+    for (const r of chart.regions) {
+        const known = new Map();
+        for (const s of r.states)
+            known.set(s.path, known.size);
+        let numbers;
+        const pathIndex = (path) => {
+            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();
+        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 };
+}