dsh-pstack 0.2.0-beta.1 → 0.2.0-beta.3

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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,82 @@
+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 };

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

@@ -0,0 +1,268 @@
+import { append, byText, hasRule, holds, loopOf, must, ruleKey, seqOf, tupleKey, unkey } from "../ir.mjs";
+// runtime/skills/statechart/scripts/passes/regions.ts
+const anyRest = {
+	kind: "and",
+	otherKeys: []
+};
+function drawRegions({ states: tla, index, from, to }, { names, shapes, drawnLabels, group, keys, kinds, sizes, sorted, pathSteps, notes }, order, found, view) {
+	const n = shapes.length;
+	const m = drawnLabels.length;
+	const R = names.length;
+	const lead = new Uint8Array(n);
+	const looped = new Uint8Array(n);
+	for (const b of found) {
+		for (const i of seqOf(b, index).slice(0, b.loop)) lead[i] = 1;
+		for (const i of loopOf(b, index)) looped[i] = 1;
+	}
+	const loop = (j) => R === 1 && pathSteps[j] === 1;
+	const stays = (j) => {
+		for (let r = 0; r < R; r++) if (kinds[r][from[j]] !== kinds[r][to[j]]) return false;
+		return true;
+	};
+	let inside = 0;
+	for (const j of sorted) if (stays(j) && !loop(j)) inside++;
+	const comboOf = R === 1 ? (i) => kinds[0][i] : (i) => {
+		let c = "";
+		for (let r = 0; r < R; r++) c += (r ? "," : "") + kinds[r][i];
+		return c;
+	};
+	const dirty = /* @__PURE__ */ new Map();
+	for (const i of order) if (tla[i].breaks.length) {
+		const c = comboOf(i);
+		if (!dirty.has(c)) dirty.set(c, i);
+	}
+	const clean = new Uint8Array(n);
+	if (dirty.size) for (let i = 0; i < n; i++) clean[i] = dirty.has(comboOf(i)) ? 0 : 1;
+	else clean.fill(1);
+	const regions = [];
+	const objects = [];
+	for (const [r, name] of names.entries()) {
+		const key = keys[r];
+		const kind = kinds[r];
+		const states = /* @__PURE__ */ new Map();
+		const objectOf = new Array(sizes[r]);
+		const keyOf = new Array(sizes[r]);
+		const position = new Int32Array(sizes[r]);
+		for (const i of order) {
+			const s = tla[i];
+			let o = objectOf[kind[i]];
+			if (!o) {
+				o = {
+					path: shapes[i][name],
+					start: false,
+					members: [],
+					works: false,
+					lead: false,
+					repeats: false,
+					breaks: [],
+					group: void 0
+				};
+				objectOf[kind[i]] = o;
+				keyOf[kind[i]] = key[i];
+				position[kind[i]] = states.size;
+				states.set(key[i], o);
+			}
+			o.start ||= s.start;
+			o.works ||= clean[i] === 1;
+			o.lead ||= lead[i] === 1;
+			o.repeats ||= looped[i] === 1;
+			o.members.push(i);
+		}
+		const parents = /* @__PURE__ */ new Set();
+		for (const s of states.values()) for (let i = 1; i < s.path.length; i++) parents.add(tupleKey(s.path.slice(0, i)));
+		for (const s of states.values()) {
+			if (parents.size && parents.has(tupleKey(s.path))) throw new Error(`The view's state() returned ${s.path.join(" / ")} both as a state and as a parent state${name ? ` in ${name}` : ""}. Give that state a child name of its own.`);
+			const rules = /* @__PURE__ */ new Map();
+			for (const i of s.members) for (const rule of tla[i].breaks) rules.set(ruleKey(rule), rule);
+			s.breaks = [];
+			for (const rule of [...rules.values()].sort((a, b) => byText(a.name, b.name) || byText(a.kind, b.kind))) {
+				let always = true;
+				for (const i of s.members) always &&= hasRule(tla[i].breaks, rule);
+				s.breaks.push({
+					rule,
+					always
+				});
+			}
+			const groups = /* @__PURE__ */ new Set();
+			for (const i of s.members) groups.add(group(i));
+			s.group = groups.size === 1 ? [...groups][0] : void 0;
+		}
+		const others = [];
+		for (let o = 0; o < R; o++) if (o !== r) others.push(o);
+		const tuple = (i) => {
+			const t = [];
+			for (const o of others) t.push(keys[o][i]);
+			return t;
+		};
+		const two = others.length === 1;
+		const words = (vs) => {
+			const texts = [];
+			for (const v of vs) texts.push(unkey(v).join(" / "));
+			return texts.sort(byText).join(two ? " or " : ", ");
+		};
+		const is = (o, vs) => two ? `when ${words(vs)}` : `${names[o]} is ${vs.size > 1 ? "one of " : ""}${words(vs)}`;
+		const isNot = (o, vs) => two ? `unless ${words(vs)}` : `${names[o]} is ${vs.length > 1 ? "none of" : "not"} ${words(vs)}`;
+		const moves = [];
+		const pairs = /* @__PURE__ */ new Map();
+		const size = sizes[r];
+		for (const j of sorted) {
+			const f = kind[from[j]];
+			const t = kind[to[j]];
+			if (f === t && !loop(j)) continue;
+			const text = drawnLabels[j];
+			const pair = position[f] * size + position[t];
+			let move = pairs.get(pair);
+			while (move && move.text !== text) move = move.other;
+			if (!move) {
+				move = {
+					f,
+					t,
+					text,
+					group: [],
+					other: pairs.get(pair)
+				};
+				pairs.set(pair, move);
+				moves.push(move);
+			}
+			if (R > 1) move.group.push(j);
+		}
+		const tuplesAt = /* @__PURE__ */ new Map();
+		const seenAt = /* @__PURE__ */ new Map();
+		if (R > 1) for (const i of order) append(tuplesAt, kind[i], i);
+		const arrows = [];
+		for (const move of moves) {
+			const fromKey = keyOf[move.f];
+			const toKey = keyOf[move.t];
+			if (R === 1) {
+				arrows.push({
+					from: fromKey,
+					to: toKey,
+					label: move.text,
+					condition: anyRest,
+					when: void 0
+				});
+				continue;
+			}
+			const ok = /* @__PURE__ */ new Set();
+			for (const j of move.group) ok.add(tupleKey(tuple(from[j])));
+			const takes = (t) => ok.has(tupleKey(t));
+			let seen = seenAt.get(move.f);
+			if (!seen) {
+				seen = [];
+				const seenKeys = /* @__PURE__ */ new Set();
+				for (const i of must(tuplesAt, move.f)) {
+					const t = tuple(i);
+					const k = tupleKey(t);
+					if (seenKeys.has(k)) continue;
+					seenKeys.add(k);
+					seen.push(t);
+				}
+				seenAt.set(move.f, seen);
+			}
+			const all = [];
+			const and = [];
+			const or = [];
+			for (let j = 0; j < others.length; j++) {
+				const values = /* @__PURE__ */ new Set();
+				const taken = /* @__PURE__ */ new Set();
+				const untaken = /* @__PURE__ */ new Set();
+				for (const t of seen) {
+					values.add(t[j]);
+					if (takes(t)) taken.add(t[j]);
+					else untaken.add(t[j]);
+				}
+				const only = /* @__PURE__ */ new Set();
+				for (const v of values) if (!untaken.has(v)) only.add(v);
+				all.push(values);
+				and.push(taken);
+				or.push(only);
+			}
+			const fits = (condition) => {
+				for (const t of seen) if (holds(condition, t) !== takes(t)) return false;
+				return true;
+			};
+			const andHolds = {
+				kind: "and",
+				otherKeys: and
+			};
+			const orHolds = {
+				kind: "or",
+				otherKeys: or
+			};
+			const text = move.text;
+			if (fits(andHolds)) {
+				const parts = [];
+				for (let j = 0; j < others.length; j++) {
+					const no = [];
+					for (const v of all[j]) if (!and[j].has(v)) no.push(v);
+					if (no.length) parts.push(and[j].size <= no.length ? is(others[j], and[j]) : isNot(others[j], no));
+				}
+				arrows.push({
+					from: fromKey,
+					to: toKey,
+					label: text,
+					condition: andHolds,
+					when: parts.length ? two ? parts[0] : `when ${parts.join(" and ")}` : void 0
+				});
+			} else if (fits(orHolds)) {
+				const parts = [];
+				for (let j = 0; j < others.length; j++) if (or[j].size) parts.push(is(others[j], or[j]));
+				arrows.push({
+					from: fromKey,
+					to: toKey,
+					label: text,
+					condition: orHolds,
+					when: `when ${parts.join(" or ")}`
+				});
+			} else arrows.push({
+				from: fromKey,
+				to: toKey,
+				label: text,
+				condition: {
+					kind: "tuples",
+					otherTuples: ok
+				}
+			});
+		}
+		const steps = [];
+		for (const [k, a] of arrows.entries()) steps.push({
+			from: objectOf[moves[k].f].path,
+			to: objectOf[moves[k].t].path,
+			label: a.label,
+			when: a.label.endsWith("]") ? void 0 : a.when
+		});
+		regions.push({
+			name,
+			states: [...states.values()],
+			steps,
+			arrows
+		});
+		objects.push(objectOf);
+	}
+	const hidden = [];
+	for (const i of dirty.values()) {
+		const ps = [];
+		for (let r = 0; r < R; r++) ps.push(objects[r][kinds[r][i]]);
+		let works = true;
+		for (const s of ps) works &&= s.works;
+		if (works) hidden.push(ps);
+	}
+	for (const ps of hidden) for (const s of ps) s.works = false;
+	const paths = [];
+	const loops = [];
+	for (const b of found) {
+		if (b.loop !== 0) paths.push(b.rule.name);
+		if (b.loop !== void 0) loops.push(b.rule.name);
+	}
+	return {
+		title: view.title,
+		regions,
+		notes,
+		inside,
+		quiet: m - sorted.length,
+		colors: view.colors ?? {},
+		paths,
+		loops
+	};
+}
+export { drawRegions };

package/dist/pstack/skills/statechart/scripts/pipeline.mjs

@@ -0,0 +1,72 @@
+import { ruleKey } from "./ir.mjs";
+import { mermaidLines } from "./backends/mermaid.mjs";
+import { plainText } from "./backends/plain-text.mjs";
+import { report } from "./backends/report.mjs";
+import { asParents, ask, labelGraph, storiesOf } from "./passes/label.mjs";
+import { lift } from "./passes/lift.mjs";
+import { loopCheck } from "./passes/loop-check.mjs";
+import { bugs, drawOrder, walk } from "./passes/reach.mjs";
+import { regionsLie } from "./passes/region-check.mjs";
+import { drawRegions } from "./passes/regions.mjs";
+// runtime/skills/statechart/scripts/pipeline.ts
+function* inParts(lines) {
+	let start = 0;
+	let size = 0;
+	for (let i = 0; i < lines.length; i++) {
+		size += lines[i].length + 1;
+		if (size > 16777216 || i === lines.length - 1) {
+			yield (start ? "\n" : "") + lines.slice(start, i + 1).join("\n");
+			start = i + 1;
+			size = 0;
+		}
+	}
+}
+const shortestFirst = (a, b) => a.path.length - b.path.length;
+function project(graph, walked, view, found) {
+	const { order, rank } = drawOrder(walked);
+	const draw = (answers) => {
+		const labels = labelGraph(graph, walked, answers, rank, found);
+		return {
+			labels,
+			chart: drawRegions(walked, labels, order, found, view)
+		};
+	};
+	const answers = ask(graph, walked, view);
+	const first = draw(answers);
+	const lie = regionsLie(first.chart.regions, first.labels, walked, order);
+	const { labels, chart } = lie ? draw(asParents(walked, answers)) : first;
+	loopCheck(chart, labels, walked, found);
+	return {
+		chart: lift(lie ? {
+			...chart,
+			lie
+		} : chart),
+		stories: storiesOf(graph, found, walked, first.labels)
+	};
+}
+function compile(result, view) {
+	const walked = walk(result.graph);
+	const found = [...result.paths ?? bugs(result.graph, walked)].sort(shortestFirst);
+	for (const p of result.properties) if (p.bug) found.push({
+		rule: p.rule,
+		...p.bug
+	});
+	const { chart, stories } = found.length || !result.paths ? project(result.graph, walked, view, found) : {
+		chart: void 0,
+		stories: /* @__PURE__ */ new Map()
+	};
+	const text = report(result, found, chart, stories);
+	const files = /* @__PURE__ */ new Map();
+	if (chart) files.set("chart.mmd", inParts(mermaidLines(chart)));
+	files.set("report.md", [text]);
+	files.set("tlc.out", plainText(result.messages));
+	const drawn = /* @__PURE__ */ new Set();
+	for (const b of found) if (b.rule.kind !== "property") drawn.add(ruleKey(b.rule));
+	for (const { rule, outcome, messages } of [...result.rules, ...result.properties]) if (outcome === "broken" && messages && !drawn.has(ruleKey(rule))) files.set(`tlc-${rule.name}.out`, plainText(messages));
+	return {
+		report: text,
+		files,
+		exit: result.exit
+	};
+}
+export { compile, project };