dsh-pstack 0.3.0-beta.1 → 0.3.1

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

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

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