dsh-pstack 0.3.0-beta.1 → 0.3.1

package/dist/pstack/skills/statechart/scripts/passes/label.mjs

@@ -1,210 +0,0 @@
-import { isRecord, key, list, loopOf, must, sortBy, stateText, tupleKey } from "../ir.mjs";
-// runtime/skills/statechart/scripts/passes/label.ts
-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 === void 0 ? "" : " or leaves its loop"}, so label it.`);
-}
-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
-	};
-}
-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
-	};
-}
-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 = /* @__PURE__ */ new Set();
-	for (const b of found) for (const p of b.path) onPath.add(p.step);
-	const pathStepIndex = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
-		const nested = /* @__PURE__ */ 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 === void 0) {
-				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 = /* @__PURE__ */ 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: /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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;
-}
-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)]);
-export { asParents, ask, labelGraph, storiesOf };

package/dist/pstack/skills/statechart/scripts/passes/lift.mjs

@@ -1,84 +0,0 @@
-import { append, must, tupleKey, unkey } from "../ir.mjs";
-// runtime/skills/statechart/scripts/passes/lift.ts
-function liftToParents(states, steps) {
-	const depths = /* @__PURE__ */ new Map();
-	const leaves = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set();
-	const lifted = [];
-	for (const [prefix] of [...depths].sort((a, b) => a[1] - b[1])) {
-		const groups = /* @__PURE__ */ 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;
-}
-function lift(chart) {
-	const regions = [];
-	for (const r of chart.regions) {
-		const known = /* @__PURE__ */ 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 !== void 0) return i;
-			if (!numbers) {
-				numbers = /* @__PURE__ */ 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 === void 0) numbers.set(k, i = numbers.size);
-			known.set(path, i);
-			return i;
-		};
-		const merged = /* @__PURE__ */ 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 === void 0 && 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
-	};
-}
-export { lift, liftToParents };

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

@@ -1,47 +0,0 @@
-import { append, holds, loopOf, must, tupleKey, unkey } from "../ir.mjs";
-// runtime/skills/statechart/scripts/passes/loop-check.ts
-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 = /* @__PURE__ */ new Map();
-	const arrowsFrom = [];
-	if (loops.length) {
-		for (const j of sorted) append(stepsFrom, from[j], j);
-		for (const { arrows } of regions) {
-			const out = /* @__PURE__ */ new Map();
-			for (const a of arrows) append(out, a.from, a);
-			arrowsFrom.push(out);
-		}
-	}
-	for (const b of found) {
-		if (b.loop === void 0) continue;
-		const inLoop = /* @__PURE__ */ new Set();
-		const twinsOf = /* @__PURE__ */ 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.`);
-				}
-			}
-		}
-	}
-}
-export { loopCheck };

package/dist/pstack/skills/statechart/scripts/passes/paths.mjs

@@ -1,72 +0,0 @@
-import { hasRule, must, stateKey } from "../ir.mjs";
-// runtime/skills/statechart/scripts/passes/paths.ts
-function pathGraph(names) {
-	const graph = {
-		states: /* @__PURE__ */ new Map(),
-		steps: []
-	};
-	const ids = /* @__PURE__ */ new Map();
-	const taken = /* @__PURE__ */ 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 === void 0) {
-			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
-		} : void 0
-	};
-}
-export { pathGraph };

package/dist/pstack/skills/statechart/scripts/passes/reach.mjs

@@ -1,135 +0,0 @@
-import { byText, count, defaultState, must, ruleKey, sortBy } from "../ir.mjs";
-// runtime/skills/statechart/scripts/passes/reach.ts
-function walk(graph) {
-	const ids = [];
-	const states = [];
-	const nameOf = [];
-	const starts = [];
-	const unique = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
-	for (let i = 0; i < names.length; i++) rankOf.set(names[i], i);
-	const n = ids.length;
-	const index = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 === void 0) 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
-	};
-}
-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
-	};
-}
-function bugs(graph, { ids, from, via, reached } = walk(graph)) {
-	const ends = /* @__PURE__ */ new Map();
-	for (const [id, s] of graph.states) for (const rule of s.ends ?? []) ends.set(ruleKey(rule), id);
-	const first = /* @__PURE__ */ 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;
-}
-export { bugs, drawOrder, walk };

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

@@ -1,82 +0,0 @@
-import { append, holds, tupleKey, unkey } from "../ir.mjs";
-// runtime/skills/statechart/scripts/passes/region-check.ts
-function regionsLie(regions, { names, keys, sorted, drawnLabels, together }, { from, to, starts }, order) {
-	if (names.length < 2) return void 0;
-	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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
-	for (const i of order) {
-		const c = combo(i);
-		combos.set(tupleKey(c), c);
-	}
-	const drawn = /* @__PURE__ */ new Map();
-	for (const c of combos.values()) {
-		const enabled = /* @__PURE__ */ 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 = /* @__PURE__ */ 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.`;
-}
-export { regionsLie };