process-graph 1.0.6 → 1.1.0

package/dist/queries-CCexJAE2.js

@@ -0,0 +1,2202 @@
+import { a as findCycles, d as lookup$1, f as CycleError, i as assertAcyclic, o as stronglyConnectedComponents, p as UnknownNodeError, r as loopTransitions, t as controlDag, u as buildDag } from "./control-aDk9560d.js";
+import { createSyncEvaluator } from "trilean";
+//#region ../../core/graph/projection/dist/actors.js
+const actorMap = (model) => {
+	const actors = /* @__PURE__ */ new Map();
+	for (const element of model.elements) if ((element.kind === "activity" || element.kind === "decision") && element.actor !== void 0) actors.set(element.id, element.actor);
+	return actors;
+};
+//#endregion
+//#region ../../core/graph/dag/dist/layers.js
+/**
+* Layers the graph by the longest `needs` chain below each node, so everything in one layer can run once the earlier layers are done.
+*
+* Defined on the acyclic part of the graph: a node on a cycle, or one that needs such a node directly or transitively, has no finite chain length and is reported in `unlayered` rather than being given a level. Every other node is layered exactly as in an acyclic graph. Unknown references are not edges and contribute nothing to a level. Iterative (Kahn's algorithm), so depth cannot overflow the call stack.
+*/
+function topologicalLayers(dag) {
+	const depth = new Map(dag.nodes.map((id) => [id, 0]));
+	const waitingOn = new Map(dag.nodes.map((id) => [id, lookup$1(dag.needs, id).length]));
+	const ready = dag.nodes.filter((id) => lookup$1(waitingOn, id) === 0);
+	for (const current of ready) {
+		const above = lookup$1(depth, current) + 1;
+		for (const dependent of lookup$1(dag.dependents, current)) {
+			depth.set(dependent, Math.max(lookup$1(depth, dependent), above));
+			const remaining = lookup$1(waitingOn, dependent) - 1;
+			waitingOn.set(dependent, remaining);
+			if (remaining === 0) ready.push(dependent);
+		}
+	}
+	const levels = /* @__PURE__ */ new Map();
+	const layers = [];
+	const unlayered = [];
+	for (const id of dag.nodes) {
+		if (lookup$1(waitingOn, id) !== 0) {
+			unlayered.push(id);
+			continue;
+		}
+		const level = lookup$1(depth, id);
+		levels.set(id, level);
+		(layers[level] ??= []).push(id);
+	}
+	return {
+		levels,
+		layers,
+		unlayered
+	};
+}
+//#endregion
+//#region ../../core/graph/dag/dist/dominators.js
+/**
+* The immediate dominator of every node reachable from `root` along `needs` edges. A node `d` dominates `n` when every path from `root` to `n` passes through `d`; the immediate dominator is the dominator closest to `n` other than `n` itself. Read with `needs` edges pointing from a step to the steps before it and `root` a virtual end every last step needs, this gives post-dominators: where every way forward from a step meets again.
+*
+* Found by the Lengauer-Tarjan algorithm with path compression, so the work is the number of reachable nodes and edges times a slowly growing factor, and every walk uses an explicit stack, so depth is bounded by memory, not the call stack. Cycles are allowed.
+* @param dag - The graph to read.
+* @param root - Where every path starts.
+* @returns Each node reachable from `root` other than `root`, mapped to its immediate dominator, in the order a depth-first walk from `root` first reaches the nodes. A node `root` does not reach has no entry.
+* @throws UnknownNodeError when `root` is not a node of `dag`.
+*/
+function immediateDominators(dag, root) {
+	lookup$1(dag.needs, root);
+	const number = /* @__PURE__ */ new Map();
+	const order = [];
+	const parent = [];
+	const frames = [];
+	const enter = (node, from) => {
+		number.set(node, order.length);
+		order.push(node);
+		parent.push(from);
+		frames.push({
+			node,
+			next: 0
+		});
+	};
+	enter(root, -1);
+	for (let frame = frames.at(-1); frame !== void 0; frame = frames.at(-1)) {
+		const target = lookup$1(dag.needs, frame.node)[frame.next];
+		if (target === void 0) {
+			frames.pop();
+			continue;
+		}
+		frame.next += 1;
+		if (!number.has(target)) enter(target, lookup$1(number, frame.node));
+	}
+	const predecessors = order.map(() => []);
+	for (const [index, node] of order.entries()) for (const target of lookup$1(dag.needs, node)) predecessors[lookup$1(number, target)]?.push(index);
+	const semi = order.map((_, index) => index);
+	const idom = order.map(() => 0);
+	const ancestor = order.map(() => -1);
+	const label = order.map((_, index) => index);
+	const bucket = order.map(() => []);
+	/** Path compression up the forest built by `link`, done with an explicit stack. */
+	const compress = (start) => {
+		const path = [];
+		for (let node = start; (ancestor[ancestor[node] ?? -1] ?? -1) !== -1; node = ancestor[node] ?? -1) path.push(node);
+		for (const node of path.toReversed()) {
+			const up = ancestor[node] ?? -1;
+			const upLabel = label[up] ?? up;
+			if ((semi[upLabel] ?? 0) < (semi[label[node] ?? node] ?? 0)) label[node] = upLabel;
+			ancestor[node] = ancestor[up] ?? -1;
+		}
+	};
+	/** The node with the least semidominator on the forest path to `node`. */
+	const evaluate = (node) => {
+		if (ancestor[node] === -1) return node;
+		compress(node);
+		return label[node] ?? node;
+	};
+	for (let index = order.length - 1; index > 0; index -= 1) {
+		for (const from of predecessors[index] ?? []) {
+			const least = semi[evaluate(from)] ?? index;
+			if (least < (semi[index] ?? index)) semi[index] = least;
+		}
+		bucket[semi[index] ?? index]?.push(index);
+		const up = parent[index] ?? 0;
+		ancestor[index] = up;
+		for (const waiting of bucket[up] ?? []) {
+			const least = evaluate(waiting);
+			idom[waiting] = (semi[least] ?? 0) < (semi[waiting] ?? 0) ? least : up;
+		}
+		bucket[up] = [];
+	}
+	const dominators = /* @__PURE__ */ new Map();
+	for (let index = 1; index < order.length; index += 1) {
+		if (idom[index] !== semi[index]) idom[index] = idom[idom[index] ?? 0] ?? 0;
+		const node = order[index];
+		const dominator = order[idom[index] ?? 0];
+		if (node !== void 0 && dominator !== void 0) dominators.set(node, dominator);
+	}
+	return dominators;
+}
+//#endregion
+//#region ../../core/graph/dag/dist/critical-path.js
+/**
+* The longest weighted chain along `needs`, where a chain's weight is the sum of its nodes' weights.
+*
+* `weight` is called exactly once per node, in node order, and must return a finite number that is not negative. The returned path always runs back to a node with no needs and ends at the node whose chain is heaviest.
+*
+* Ties are broken deterministically, and the rule is part of the contract. Where several needs of a node give an equally heavy chain, the one that comes first in node order is followed. Where several nodes end an equally heavy chain, the one that comes first in node order ends it. A zero-weight node therefore never shortens the path back to the start, and a zero-weight dependent never extends the path past an earlier node of equal total.
+*
+* Defined for acyclic graphs. An empty graph returns `{ path: [], weight: 0 }`. Unknown references are not edges.
+* @throws CycleError when the graph contains a cycle: a chain through a cycle has no greatest weight.
+* @throws RangeError when `weight` returns a negative or non-finite number.
+*/
+function criticalPath$1(dag, weight) {
+	assertAcyclic(dag);
+	const weights = /* @__PURE__ */ new Map();
+	for (const id of dag.nodes) {
+		const value = weight(id);
+		if (!Number.isFinite(value) || value < 0) throw new RangeError(`The weight of "${String(id)}" must be a finite, non-negative number, got ${String(value)}`);
+		weights.set(id, value);
+	}
+	const position = new Map(dag.nodes.map((id, order) => [id, order]));
+	const total = /* @__PURE__ */ new Map();
+	const previous = /* @__PURE__ */ new Map();
+	for (const layer of topologicalLayers(dag).layers) for (const id of layer) {
+		let best;
+		let bestTotal = 0;
+		for (const need of lookup$1(dag.needs, id)) {
+			const candidate = lookup$1(total, need);
+			if (best === void 0 || candidate > bestTotal || candidate === bestTotal && lookup$1(position, need) < lookup$1(position, best)) {
+				best = need;
+				bestTotal = candidate;
+			}
+		}
+		total.set(id, lookup$1(weights, id) + bestTotal);
+		if (best !== void 0) previous.set(id, best);
+	}
+	let end;
+	for (const id of dag.nodes) if (end === void 0 || lookup$1(total, id) > lookup$1(total, end)) end = id;
+	if (end === void 0) return {
+		path: [],
+		weight: 0
+	};
+	const path = [];
+	for (let node = end; node !== void 0; node = previous.get(node)) path.push(node);
+	return {
+		path: path.reverse(),
+		weight: lookup$1(total, end)
+	};
+}
+//#endregion
+//#region ../../core/graph/projection/dist/chains.js
+/** The transitions leaving each element, in model order. */
+const outgoingMap = (model) => {
+	const outgoing = /* @__PURE__ */ new Map();
+	for (const transition of model.transitions) {
+		const list = outgoing.get(transition.source);
+		if (list === void 0) outgoing.set(transition.source, [transition]);
+		else list.push(transition);
+	}
+	return outgoing;
+};
+/** Appends `value` to the list `map` holds under `key`. */
+const append$1 = (map, key, value) => {
+	const list = map.get(key);
+	if (list === void 0) map.set(key, [value]);
+	else list.push(value);
+};
+/** A computation run once, on first call, and remembered. */
+const once = (compute) => {
+	let memo;
+	return () => {
+		memo ??= { value: compute() };
+		return memo.value;
+	};
+};
+/** More than this many distinct entrances or targets is counted as "many": the folding rule only needs to tell one, two and more apart. */
+const enough = 3;
+/** Adds `values` to a capped set: once it would hold `enough`, it stands for "many" and keeps no more. */
+const addCapped = (set, values) => {
+	for (const value of values) {
+		if (set.size >= enough) return;
+		set.add(value);
+	}
+};
+/**
+* The elements a notation would fold that it must not, because folding them would multiply edges.
+*
+* Folding an element replaces the routes through it with one chain per pair of a way in and a drawn element it leads to. Through a folded region, an element is reached by some set of entering transitions (transitions from an element that is not folded) and leads to some set of accepted targets; folding it can draw up to entering times targets chains where the model had entering plus targets transitions. So an element is folded only when that product is no more than that sum: when one side is a single item, or both are two. Counting k sources into one message that leads to k ends, or into a run of messages that fans out to k ends further on, both fail, so neither draws k times k edges. The counts are the distinct entering transitions reaching each element and the distinct targets it reaches, both through folded elements, each held as a set capped at `enough` and carried over the condensed folded graph once in each direction, so deciding every element costs linear work. The counts are taken before any element is unfolded, so an element downstream of an unfolded one may be unfolded too; that errs towards drawing less, never towards multiplying.
+*/
+const multiplying = (model, outgoing, foldable, accepted) => {
+	const components = stronglyConnectedComponents(buildDag([...foldable], (id) => (outgoing.get(id) ?? []).map((transition) => transition.target).filter((target) => foldable.has(target))));
+	const componentOf = /* @__PURE__ */ new Map();
+	for (const [index, members] of components.entries()) for (const member of members) componentOf.set(member, index);
+	const entering = components.map(() => /* @__PURE__ */ new Set());
+	const reaching = components.map(() => /* @__PURE__ */ new Set());
+	const before = components.map(() => []);
+	const after = components.map(() => []);
+	for (const transition of model.transitions) {
+		const from = componentOf.get(transition.source);
+		const to = componentOf.get(transition.target);
+		if (to !== void 0 && from === void 0) addCapped(entering[to] ?? /* @__PURE__ */ new Set(), [transition.id]);
+		if (from !== void 0 && to === void 0 && accepted(transition.target)) addCapped(reaching[from] ?? /* @__PURE__ */ new Set(), [transition.target]);
+		if (from !== void 0 && to !== void 0 && from !== to) {
+			before[to]?.push(from);
+			after[from]?.push(to);
+		}
+	}
+	for (const [index] of components.entries()) for (const successor of after[index] ?? []) addCapped(reaching[index] ?? /* @__PURE__ */ new Set(), reaching[successor] ?? []);
+	for (let index = components.length - 1; index >= 0; index -= 1) for (const predecessor of before[index] ?? []) addCapped(entering[index] ?? /* @__PURE__ */ new Set(), entering[predecessor] ?? []);
+	const unfolded = /* @__PURE__ */ new Set();
+	for (const [index, members] of components.entries()) {
+		const ways = entering[index]?.size ?? 0;
+		const ends = reaching[index]?.size ?? 0;
+		if (ways * ends > ways + ends) for (const member of members) unfolded.add(member);
+	}
+	return unfolded;
+};
+/**
+* Indexes a model's folded elements so chains can be read off for any first transition.
+*
+* An element the notation would fold is left unfolded when folding it would multiply edges (see `multiplying`), and is then drawn no more than any element the notation has no shape for; `unfolded` lists them so the projection can report them.
+*
+* The folded elements that lead to some accepted element are found first, by one walk back from the accepted elements, and no walk enters any other, so a run that leads nowhere costs nothing. The folded elements are condensed into strongly connected components in one pass, and the condensed graph is read in reverse topological order. A component gets a flat array of its accepted targets only when something reads it on its own: it is entered from an element that is not folded, or from two or more components. Every other component has at most one component before it and is read as part of that one, so it is visited once in all. Arrays are built on demand and remembered, so a region no start reaches costs nothing; a generation stamp per target removes duplicates in constant time, a component with nothing of its own to add shares the one array it reads, and the only builder of an array nothing else reads extends it in place instead of copying it. The total work is linear in the elements and transitions plus the sizes of the arrays that must be copied, which is where two or more starts, or two or more components, read the same targets. Folded elements entered from exactly one folded element, outside any cycle, form a forest of routes; each records how deep it is and the last trigger, effect and guard on the way down to it, so a single-route chain's labels are found from its ends in constant time.
+*
+* Merged chains' lists, and every chain's lists, are built only when read.
+*/
+const chainIndex = (model, folding) => {
+	const outgoing = outgoingMap(model);
+	const foldable = /* @__PURE__ */ new Set();
+	for (const element of model.elements) if (folding.folded(element.id)) foldable.add(element.id);
+	const unfolded = multiplying(model, outgoing, foldable, folding.accepted);
+	const isFolded = new Set([...foldable].filter((id) => !unfolded.has(id)));
+	const events = /* @__PURE__ */ new Map();
+	for (const id of isFolded) {
+		const event = folding.eventOf?.(id);
+		if (event !== void 0) events.set(id, event);
+	}
+	const foldedIn = /* @__PURE__ */ new Map();
+	const arrivingIn = /* @__PURE__ */ new Map();
+	for (const transition of model.transitions) {
+		if (!isFolded.has(transition.source)) continue;
+		append$1(isFolded.has(transition.target) ? foldedIn : arrivingIn, transition.target, transition);
+	}
+	const live = /* @__PURE__ */ new Set();
+	const towards = [];
+	for (const [target, into] of arrivingIn) {
+		if (!folding.accepted(target)) continue;
+		for (const { source } of into) if (!live.has(source)) {
+			live.add(source);
+			towards.push(source);
+		}
+	}
+	for (let at = towards.pop(); at !== void 0; at = towards.pop()) for (const { source } of foldedIn.get(at) ?? []) if (!live.has(source)) {
+		live.add(source);
+		towards.push(source);
+	}
+	/** Whether a walk follows a transition: into a folded element that leads somewhere, or into an accepted element. */
+	const followed = (target) => isFolded.has(target) ? live.has(target) : folding.accepted(target);
+	const foldedIds = [...isFolded];
+	const components = stronglyConnectedComponents(buildDag(foldedIds, (id) => (outgoing.get(id) ?? []).map((transition) => transition.target).filter((target) => isFolded.has(target))));
+	const componentOf = /* @__PURE__ */ new Map();
+	for (const [index, members] of components.entries()) for (const member of members) componentOf.set(member, index);
+	const cyclic = /* @__PURE__ */ new Set();
+	for (const members of components) {
+		const [only] = members;
+		const selfLoop = only !== void 0 && (outgoing.get(only) ?? []).some((transition) => transition.target === only);
+		if (members.length > 1 || selfLoop) for (const member of members) cyclic.add(member);
+	}
+	const observe = folding.observe;
+	const successorsOf = components.map(() => []);
+	const predecessors = components.map(() => 0);
+	for (const [index, members] of components.entries()) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const member of members) for (const { target } of outgoing.get(member) ?? []) {
+			const successor = componentOf.get(target);
+			if (successor !== void 0 && successor !== index && !seen.has(successor)) {
+				seen.add(successor);
+				successorsOf[index]?.push(successor);
+				predecessors[successor] = (predecessors[successor] ?? 0) + 1;
+			}
+		}
+	}
+	const enteredFromOutside = /* @__PURE__ */ new Set();
+	for (const transition of model.transitions) {
+		const component = componentOf.get(transition.target);
+		if (component !== void 0 && !isFolded.has(transition.source)) enteredFromOutside.add(component);
+	}
+	const standalone = (component) => enteredFromOutside.has(component) || (predecessors[component] ?? 0) > 1;
+	const ownOf = (component) => {
+		const own = [];
+		for (const member of components[component] ?? []) for (const { target } of outgoing.get(member) ?? []) if (!isFolded.has(target) && folding.accepted(target)) own.push(target);
+		return own;
+	};
+	/** What a standalone component's targets are made of, in reading order: its own targets, then each way on's in order, reading through components that stand only on it and stopping at the next standalone ones. */
+	const piecesOf = (component) => {
+		const found = [];
+		const stack = [{
+			component,
+			visit: true
+		}];
+		for (let next = stack.pop(); next !== void 0; next = stack.pop()) {
+			if (!next.visit) {
+				observe?.(1);
+				found.push({ component: next.component });
+				continue;
+			}
+			const own = ownOf(next.component);
+			if (own.length > 0) {
+				observe?.(own.length);
+				found.push({ own });
+			}
+			for (const successor of (successorsOf[next.component] ?? []).toReversed()) stack.push({
+				component: successor,
+				visit: !standalone(successor)
+			});
+		}
+		return found;
+	};
+	const piecesFor = /* @__PURE__ */ new Map();
+	const pieces = (component) => {
+		const known = piecesFor.get(component);
+		if (known !== void 0) return known;
+		const found = piecesOf(component);
+		piecesFor.set(component, found);
+		return found;
+	};
+	const builders = /* @__PURE__ */ new Map();
+	for (const [index] of components.entries()) {
+		if (!standalone(index)) continue;
+		const readFrom = new Set(pieces(index).flatMap((piece) => piece.component === void 0 ? [] : [piece.component]));
+		for (const read of readFrom) builders.set(read, (builders.get(read) ?? 0) + 1);
+	}
+	const pinnedFor = (component) => enteredFromOutside.has(component) || (builders.get(component) ?? 0) > 1;
+	const arrays = /* @__PURE__ */ new Map();
+	const stamp = /* @__PURE__ */ new Map();
+	let generation = 0;
+	const build = (component) => {
+		const parts = pieces(component);
+		const only = parts.length === 1 ? parts[0] : void 0;
+		const onlyArray = only?.component === void 0 ? void 0 : arrays.get(only.component);
+		if (onlyArray !== void 0) {
+			onlyArray.pinned ||= pinnedFor(component);
+			return onlyArray;
+		}
+		const last = parts.at(-1);
+		const lastArray = last?.component === void 0 ? void 0 : arrays.get(last.component);
+		const takeOver = lastArray !== void 0 && !lastArray.pinned && lastArray.members !== void 0;
+		const target = takeOver ? lastArray : {
+			reversed: [],
+			members: void 0,
+			pinned: pinnedFor(component)
+		};
+		target.pinned = pinnedFor(component);
+		generation += 1;
+		const members = target.members;
+		const present = (value) => members === void 0 ? stamp.get(value) === generation : members.has(value);
+		const add = (value) => {
+			if (present(value)) return;
+			observe?.(1);
+			target.reversed.push(value);
+			if (members === void 0) stamp.set(value, generation);
+			else members.add(value);
+		};
+		for (let index = parts.length - (takeOver ? 2 : 1); index >= 0; index -= 1) {
+			const piece = parts[index];
+			if (piece === void 0) continue;
+			if (piece.own !== void 0) {
+				for (const value of piece.own.toReversed()) add(value);
+				continue;
+			}
+			for (const value of arrays.get(piece.component)?.reversed ?? []) add(value);
+		}
+		if (target.pinned) target.members = void 0;
+		else if (target.members === void 0) {
+			observe?.(target.reversed.length);
+			target.members = new Set(target.reversed);
+		}
+		return target;
+	};
+	const arrayOf = (component) => {
+		const frames = [{
+			component,
+			expanded: false
+		}];
+		for (let frame = frames.at(-1); frame !== void 0; frame = frames.at(-1)) {
+			if (arrays.has(frame.component)) {
+				frames.pop();
+				continue;
+			}
+			if (!frame.expanded) {
+				frame.expanded = true;
+				for (const piece of pieces(frame.component)) if (piece.component !== void 0 && !arrays.has(piece.component)) frames.push({
+					component: piece.component,
+					expanded: false
+				});
+				continue;
+			}
+			arrays.set(frame.component, build(frame.component));
+			frames.pop();
+		}
+		const found = arrays.get(component);
+		if (found === void 0) throw new Error("Invariant violated: a component's targets were not built");
+		return found;
+	};
+	const leads = [];
+	for (const [index] of components.entries()) leads[index] = ownOf(index).length > 0 || (successorsOf[index] ?? []).some((successor) => leads[successor] === true);
+	/** A start component's targets in reading order; only ever asked of a component entered from outside, which is standalone. */
+	const targetsOf = (component) => arrayOf(component).reversed.toReversed();
+	const parentLink = /* @__PURE__ */ new Map();
+	const children = /* @__PURE__ */ new Map();
+	for (const id of foldedIds) {
+		const into = foldedIn.get(id);
+		const link = into?.length === 1 ? into[0] : void 0;
+		if (link !== void 0 && !cyclic.has(id) && !cyclic.has(link.source)) {
+			parentLink.set(id, link);
+			append$1(children, link.source, id);
+		}
+	}
+	const depth = /* @__PURE__ */ new Map();
+	const enter = /* @__PURE__ */ new Map();
+	const leave = /* @__PURE__ */ new Map();
+	const lastTrigger = /* @__PURE__ */ new Map();
+	const lastEffect = /* @__PURE__ */ new Map();
+	const guardsTo = /* @__PURE__ */ new Map();
+	let clock = 0;
+	for (const root of foldedIds) {
+		if (parentLink.has(root)) continue;
+		const stack = [{
+			id: root,
+			next: 0
+		}];
+		const visit = (id, level) => {
+			depth.set(id, level);
+			enter.set(id, clock);
+			clock += 1;
+			const link = parentLink.get(id);
+			const parent = link?.source;
+			const event = events.get(id);
+			const trigger = event !== void 0 ? {
+				value: event,
+				depth: level,
+				atElement: true
+			} : link?.trigger !== void 0 ? {
+				value: link.trigger,
+				depth: level,
+				atElement: false
+			} : parent === void 0 ? void 0 : lastTrigger.get(parent);
+			if (trigger !== void 0) lastTrigger.set(id, trigger);
+			const effect = link?.effect !== void 0 ? {
+				value: link.effect,
+				depth: level,
+				atElement: false
+			} : parent === void 0 ? void 0 : lastEffect.get(parent);
+			if (effect !== void 0) lastEffect.set(id, effect);
+			const above = parent === void 0 ? void 0 : guardsTo.get(parent);
+			const guards = link?.guard !== void 0 ? {
+				guard: link.guard,
+				depth: level,
+				previous: above
+			} : above;
+			if (guards !== void 0) guardsTo.set(id, guards);
+		};
+		visit(root, 0);
+		for (let top = stack.at(-1); top !== void 0; top = stack.at(-1)) {
+			const child = (children.get(top.id) ?? [])[top.next];
+			if (child === void 0) {
+				leave.set(top.id, clock);
+				stack.pop();
+				continue;
+			}
+			top.next += 1;
+			visit(child, (depth.get(top.id) ?? 0) + 1);
+			stack.push({
+				id: child,
+				next: 0
+			});
+		}
+	}
+	/** Whether `ancestor` is `node` or above it in the route forest. */
+	const above = (ancestor, node) => {
+		const start = enter.get(ancestor);
+		const stop = leave.get(ancestor);
+		const at = enter.get(node);
+		return start !== void 0 && stop !== void 0 && at !== void 0 && start <= at && at < stop;
+	};
+	const position = new Map(foldedIds.map((id, index) => [id, index]));
+	const rootOf = (component) => {
+		let root;
+		for (const member of components[component] ?? []) if (root === void 0 || (position.get(member) ?? 0) < (position.get(root) ?? 0)) root = member;
+		return root;
+	};
+	const walks = /* @__PURE__ */ new Map();
+	const walkFrom = (element) => {
+		const component = componentOf.get(element);
+		const known = component === void 0 ? void 0 : walks.get(component);
+		if (known !== void 0) return known;
+		const start = (component === void 0 ? void 0 : rootOf(component)) ?? element;
+		const order = /* @__PURE__ */ new Map();
+		const entered = /* @__PURE__ */ new Map([[start, 0]]);
+		const into = /* @__PURE__ */ new Map();
+		const stack = [{
+			id: start,
+			next: 0
+		}];
+		for (let top = stack.at(-1); top !== void 0; top = stack.at(-1)) {
+			const transition = (outgoing.get(top.id) ?? [])[top.next];
+			if (transition === void 0) {
+				stack.pop();
+				continue;
+			}
+			top.next += 1;
+			if (!followed(transition.target)) continue;
+			order.set(transition, order.size);
+			append$1(into, transition.target, transition);
+			if (isFolded.has(transition.target) && !entered.has(transition.target)) {
+				entered.set(transition.target, entered.size);
+				stack.push({
+					id: transition.target,
+					next: 0
+				});
+			}
+		}
+		const walk = {
+			order,
+			entered,
+			into
+		};
+		if (component !== void 0) walks.set(component, walk);
+		return walk;
+	};
+	/** The union of every route from `first` to `target`: walking back from `target` over the shared walk's index of what arrives where, so the work is the size of this union, then put in the order the walk met each transition and element. */
+	const union = (first, target) => {
+		const walk = walkFrom(first.target);
+		const leading = /* @__PURE__ */ new Set([target]);
+		const back = [target];
+		const transitions = [];
+		for (let at = back.pop(); at !== void 0; at = back.pop()) for (const transition of walk.into.get(at) ?? []) {
+			transitions.push(transition);
+			if (!leading.has(transition.source)) {
+				leading.add(transition.source);
+				back.push(transition.source);
+			}
+		}
+		const metAt = (transition) => walk.order.get(transition) ?? 0;
+		const enteredAt = (element) => walk.entered.get(element) ?? 0;
+		return {
+			transitions: [first, ...transitions.sort((a, b) => metAt(a) - metAt(b))],
+			through: [...leading].filter((element) => walk.entered.has(element)).sort((a, b) => enteredAt(a) - enteredAt(b))
+		};
+	};
+	const from = (first) => {
+		const start = first.target;
+		if (!isFolded.has(start)) return folding.accepted(start) ? [{
+			first,
+			target: start,
+			merged: false,
+			transitions: () => [first],
+			through: () => [],
+			guards: () => first.guard === void 0 ? [] : [first.guard],
+			guarded: first.guard !== void 0,
+			trigger: first.trigger,
+			effect: first.effect
+		}] : [];
+		const component = componentOf.get(start);
+		const reached = component === void 0 ? [] : targetsOf(component);
+		const level = depth.get(start);
+		return reached.map((target) => {
+			const into = arrivingIn.get(target);
+			const last = into?.length === 1 ? into[0] : void 0;
+			const source = last?.source;
+			const single = last !== void 0 && source !== void 0 && level !== void 0 && above(start, source);
+			const lists = once(() => union(first, target));
+			if (!single) return {
+				first,
+				target,
+				merged: true,
+				transitions: () => lists().transitions,
+				through: () => lists().through,
+				guards: () => [],
+				guarded: false,
+				trigger: void 0,
+				effect: void 0
+			};
+			const onRoute = (found) => found !== void 0 && (found.depth > level || found.depth === level && found.atElement);
+			const triggerFound = lastTrigger.get(source);
+			const effectFound = lastEffect.get(source);
+			const guardsFound = guardsTo.get(source);
+			const routeGuards = once(() => {
+				const middle = [];
+				for (let link = guardsFound; link !== void 0 && link.depth > level; link = link.previous) middle.push(link.guard);
+				return [
+					...first.guard === void 0 ? [] : [first.guard],
+					...middle.toReversed(),
+					...last.guard === void 0 ? [] : [last.guard]
+				];
+			});
+			const route = once(() => {
+				const nodes = [];
+				const links = [];
+				for (let at = source; at !== void 0;) {
+					nodes.push(at);
+					if (at === start) break;
+					const link = parentLink.get(at);
+					if (link !== void 0) links.push(link);
+					at = link?.source;
+				}
+				return {
+					through: nodes.toReversed(),
+					transitions: [
+						first,
+						...links.toReversed(),
+						last
+					]
+				};
+			});
+			return {
+				first,
+				target,
+				merged: false,
+				transitions: () => route().transitions,
+				through: () => route().through,
+				guards: routeGuards,
+				guarded: first.guard !== void 0 || last.guard !== void 0 || guardsFound !== void 0 && guardsFound.depth > level,
+				trigger: last.trigger ?? (onRoute(triggerFound) ? triggerFound?.value : void 0) ?? first.trigger,
+				effect: last.effect ?? (effectFound !== void 0 && effectFound.depth > level ? effectFound.value : void 0) ?? first.effect
+			};
+		});
+	};
+	const carried = (firsts) => {
+		const reached = /* @__PURE__ */ new Set();
+		const stack = [];
+		for (const first of firsts) if (live.has(first.target) && !reached.has(first.target)) {
+			reached.add(first.target);
+			stack.push(first.target);
+		}
+		for (let at = stack.pop(); at !== void 0; at = stack.pop()) for (const transition of outgoing.get(at) ?? []) if (live.has(transition.target) && !reached.has(transition.target)) {
+			reached.add(transition.target);
+			stack.push(transition.target);
+		}
+		return reached;
+	};
+	return {
+		from,
+		arriving: (element) => arrivingIn.get(element) ?? [],
+		carried,
+		unfolded
+	};
+};
+//#endregion
+//#region ../../core/graph/projection/dist/handoffs.js
+/**
+* Swimlane view: a transition between two elements with different actors is a hand-off. A transition into a `message` element continues through it to the element after it, so a message between two steps is part of the hand-off it carries, not an end of it. Elements without an actor never produce one.
+* @param model - The model to read.
+* @returns The hand-offs, in the order of the transitions they start with.
+*/
+const handoffs = (model) => {
+	const actorOf = actorMap(model);
+	const messages = new Set(model.elements.flatMap((element) => element.kind === "message" ? [element.id] : []));
+	const index = chainIndex(model, {
+		folded: (id) => messages.has(id),
+		accepted: (id) => actorOf.has(id)
+	});
+	const found = [];
+	for (const transition of model.transitions) {
+		const from = actorOf.get(transition.source);
+		if (from === void 0) continue;
+		for (const chain of index.from(transition)) {
+			const to = actorOf.get(chain.target);
+			if (to === void 0 || from === to) continue;
+			found.push(transition.target === chain.target ? {
+				transition: transition.id,
+				from,
+				to
+			} : {
+				transition: transition.id,
+				from,
+				to,
+				get through() {
+					return chain.through();
+				}
+			});
+		}
+	}
+	return found;
+};
+//#endregion
+//#region ../../core/graph/projection/dist/loss.js
+/**
+* The elements the notation cannot draw: every element that is neither in `accounted` (drawn, or folded away by design, as a decision is in a state machine) nor a `message`, which `commonLoss` reports as `message-elements` when it is not shown.
+* @param model - The model being projected.
+* @param notation - The notation that cannot draw them.
+* @param accounted - Elements the projection draws or folds away by design.
+* @returns A single `unrepresented-elements` loss, or none when every element is accounted for.
+*/
+const unrepresentedLoss = (model, notation, accounted, unfolded) => {
+	const elements = [];
+	for (const element of model.elements) {
+		if (element.kind === "message" && !unfolded.has(element.id) || accounted.has(element.id)) continue;
+		elements.push({
+			element: element.id,
+			kind: element.kind === "pseudo" ? element.role : element.kind
+		});
+	}
+	if (elements.length === 0) return [];
+	const lost = new Set(elements.map((entry) => entry.element));
+	return [{
+		kind: "unrepresented-elements",
+		notation,
+		elements,
+		transitions: model.transitions.filter((transition) => lost.has(transition.source) || lost.has(transition.target)).map((transition) => transition.id)
+	}];
+};
+/**
+* The losses every projection can have, whatever its notation: dropped layout, notation-only extensions, message elements and authored fragments.
+* @param model - The model projected.
+* @param notation - The notation whose recorded positions are dropped.
+* @param shown - The message elements and fragments the projection did draw, which are therefore not reported.
+*/
+const commonLoss = (model, notation, shown) => {
+	const positions = model.views?.[notation];
+	const positioned = model.elements.filter((element) => positions?.[element.id] !== void 0);
+	const withExtensions = model.elements.filter((element) => element.extensions !== void 0 && Object.keys(element.extensions).length > 0);
+	const messages = model.elements.filter((element) => element.kind === "message" && !shown.messages.has(element.id));
+	const hidden = model.fragments.filter((fragment) => !shown.fragments.has(fragment.id));
+	const losses = [];
+	if (positioned.length > 0) losses.push({
+		kind: "layout",
+		elements: positioned.map((element) => element.id)
+	});
+	if (withExtensions.length > 0) losses.push({
+		kind: "extensions",
+		elements: withExtensions.map((element) => element.id)
+	});
+	if (messages.length > 0) losses.push({
+		kind: "message-elements",
+		elements: messages.map((element) => element.id)
+	});
+	if (hidden.length > 0) losses.push({
+		kind: "fragments",
+		fragments: hidden.map((fragment) => fragment.id)
+	});
+	return losses;
+};
+//#endregion
+//#region ../../core/graph/projection/dist/flowchart.js
+const flowNode = (element) => {
+	switch (element.kind) {
+		case "activity": return {
+			id: element.id,
+			label: element.label,
+			shape: "process"
+		};
+		case "decision": return {
+			id: element.id,
+			label: element.label,
+			shape: "decision"
+		};
+		case "pseudo": switch (element.role) {
+			case "initial": return {
+				id: element.id,
+				label: "Start",
+				shape: "terminator"
+			};
+			case "final": return {
+				id: element.id,
+				label: "End",
+				shape: "terminator"
+			};
+			case "fork": return {
+				id: element.id,
+				label: "Fork",
+				shape: "bar"
+			};
+			case "join": return {
+				id: element.id,
+				label: "Join",
+				shape: "bar"
+			};
+		}
+	}
+};
+/**
+* What a flowchart-shaped projection drops: the common losses, then the elements the flowchart has no node for (`state` elements and `history` pseudo-states) and the transitions that touch them.
+* @param model - The model projected.
+* @param notation - The notation the result is for, `flowchart` or `swimlane`.
+* @param drawn - What the projection drew.
+*/
+const flowchartLoss = (model, notation, drawn) => [...commonLoss(model, notation, {
+	fragments: /* @__PURE__ */ new Set(),
+	messages: /* @__PURE__ */ new Set([...drawn.carried, ...drawn.unfolded])
+}), ...unrepresentedLoss(model, notation, new Set(drawn.nodes.map((node) => node.id)), drawn.unfolded)];
+/**
+* The edge a chain draws. On a single route its label is the route's guards joined with "and", or, when none is guarded, the labels of the messages on it; where several routes are merged the guards belong to different routes and cannot be joined, so the label is the carried messages' labels. An edge through messages builds its lists and label only when they are read, so edges sharing a long run of messages do not each copy it.
+*/
+const edgeOf = (chain, messageLabels) => {
+	const from = chain.first.source;
+	if (chain.first.target === chain.target) {
+		const { guard } = chain.first;
+		return {
+			from,
+			to: chain.target,
+			...guard === void 0 ? {} : { label: guard },
+			transitions: [chain.first.id]
+		};
+	}
+	const ids = once(() => chain.transitions().map((transition) => transition.id));
+	const label = once(() => {
+		if (!chain.merged && chain.guarded) return chain.guards().join(" and ");
+		return chain.through().flatMap((id) => {
+			const message = messageLabels.get(id);
+			return message === void 0 ? [] : [message];
+		}).join(", ");
+	});
+	return {
+		from,
+		to: chain.target,
+		get label() {
+			return label();
+		},
+		get transitions() {
+			return ids();
+		},
+		get through() {
+			return chain.through();
+		}
+	};
+};
+/**
+* The flowchart and the parts its inverse needs.
+* @param model - The model to project.
+*/
+const flowchartParts = (model) => {
+	const nodes = [];
+	const messageLabels = /* @__PURE__ */ new Map();
+	for (const element of model.elements) {
+		if (element.kind === "message") messageLabels.set(element.id, element.label);
+		const node = flowNode(element);
+		if (node !== void 0) nodes.push(node);
+	}
+	const included = new Set(nodes.map((node) => node.id));
+	const index = chainIndex(model, {
+		folded: (id) => messageLabels.has(id),
+		accepted: (id) => included.has(id)
+	});
+	const firsts = model.transitions.filter((transition) => included.has(transition.source));
+	const edges = [];
+	const origins = [];
+	for (const first of firsts) for (const chain of index.from(first)) {
+		edges.push(edgeOf(chain, messageLabels));
+		origins.push({
+			first,
+			target: chain.target
+		});
+	}
+	const carried = index.carried(firsts);
+	return {
+		flowchart: {
+			nodes,
+			edges,
+			loss: flowchartLoss(model, "flowchart", {
+				nodes,
+				carried,
+				unfolded: index.unfolded
+			})
+		},
+		origins,
+		index,
+		carried
+	};
+};
+/**
+* Activities, decisions and terminators, joined by the transitions between them. A `message` element is not a node: a transition into it continues through it, so the edge runs from the step before the message to the step after it and carries the message (`through`). There is one edge per transition leaving a node and node it leads to, however many routes through message elements connect them; such an edge's `transitions`, `through` and `label` are built when first read. A message element no edge carries is reported as a `message-elements` loss. `state` elements and `history` pseudo-states have no flowchart shape and are reported as unrepresented, with the transitions that touch them.
+* @param model - The model to project.
+* @returns The nodes in model order, the edges in the order of the transitions they start with, and what was dropped.
+*/
+const toFlowchart = (model) => flowchartParts(model).flowchart;
+//#endregion
+//#region ../../core/graph/projection/dist/swimlane.js
+/**
+* A flowchart plus partitions: a lane for every declared role or system, in declaration order and empty when nothing is assigned to it, then a lane for each actor that was named but never declared. Hand-offs are the edges that change lane.
+*/
+const toSwimlane = (model) => {
+	const parts = flowchartParts(model);
+	const flow = parts.flowchart;
+	const actors = actorMap(model);
+	const members = /* @__PURE__ */ new Map();
+	const unassigned = [];
+	for (const node of flow.nodes) {
+		const actor = actors.get(node.id);
+		if (actor === void 0) {
+			unassigned.push(node.id);
+			continue;
+		}
+		const lane = members.get(actor);
+		if (lane === void 0) members.set(actor, [node.id]);
+		else lane.push(node.id);
+	}
+	const lanes = [];
+	const declared = /* @__PURE__ */ new Set();
+	for (const participant of model.participants) {
+		if (participant.kind === "entity") continue;
+		declared.add(participant.id);
+		lanes.push({
+			participant: participant.id,
+			label: participant.label,
+			nodes: members.get(participant.id) ?? []
+		});
+	}
+	for (const [actor, nodes] of members) if (!declared.has(actor)) lanes.push({
+		participant: actor,
+		label: actor,
+		nodes
+	});
+	return {
+		...flow,
+		lanes,
+		unassigned,
+		handoffs: handoffs(model),
+		loss: flowchartLoss(model, "swimlane", {
+			nodes: flow.nodes,
+			carried: parts.carried,
+			unfolded: parts.index.unfolded
+		})
+	};
+};
+//#endregion
+//#region ../../core/graph/projection/dist/state-machine.js
+const stateOf = (element) => {
+	switch (element.kind) {
+		case "activity":
+		case "state": return {
+			id: element.id,
+			label: element.label,
+			role: "state"
+		};
+		case "pseudo":
+			if (element.role === "initial") return {
+				id: element.id,
+				label: "Start",
+				role: "initial"
+			};
+			if (element.role === "final") return {
+				id: element.id,
+				label: "End",
+				role: "final"
+			};
+	}
+};
+/**
+* The state machine and the parts its inverse needs; see `toStateMachine`.
+* @param model - The model to project.
+* @param subject - The entity whose lifecycle the machine shows.
+*/
+const stateMachineParts = (model, subject) => {
+	if (model.participants.find((participant) => participant.id === subject)?.kind !== "entity") throw new Error(`State machine subject "${subject}" must be a declared entity participant`);
+	const elements = new Map(model.elements.map((element) => [element.id, element]));
+	const outgoing = outgoingMap(model);
+	const scoped = model.elements.some((element) => element.kind === "activity" && element.affects !== void 0);
+	/** Whether an element is folded through rather than shown as a state: a decision, a `message` element, or an activity that does not affect the subject in a model that declares what activities affect. */
+	const isTransparent = (element) => element.kind === "decision" || element.kind === "message" || element.kind === "activity" && scoped && element.affects?.includes(subject) !== true;
+	/** The transition a chain draws. On a single route, the event is the last trigger along it, counting a folded message's own event right after the transition that arrives at it; guards are joined in order; the effect is the entry action of the target activity, or else the last effect along the route. Where several routes are merged their triggers, guards and effects belong to different routes, so only the target's entry action is kept. A transition through folded elements builds its lists and guard only when they are read. */
+	const transitionOf = (chain) => {
+		const target = elements.get(chain.target);
+		const event = chain.trigger;
+		const effect = (target?.kind === "activity" ? target.action : void 0) ?? chain.effect;
+		const base = {
+			source: chain.first.source,
+			target: chain.target,
+			...event === void 0 ? {} : { event },
+			...effect === void 0 ? {} : { effect }
+		};
+		if (chain.first.target === chain.target) {
+			const { guard } = chain.first;
+			return {
+				...base,
+				...guard === void 0 ? {} : { guard },
+				transitions: [chain.first.id]
+			};
+		}
+		const ids = once(() => chain.transitions().map((transition) => transition.id));
+		const guard = once(() => chain.guards().join(" and "));
+		return chain.guarded ? {
+			...base,
+			get guard() {
+				return guard();
+			},
+			get transitions() {
+				return ids();
+			},
+			get through() {
+				return chain.through();
+			}
+		} : {
+			...base,
+			get transitions() {
+				return ids();
+			},
+			get through() {
+				return chain.through();
+			}
+		};
+	};
+	const states = [];
+	const stateIds = /* @__PURE__ */ new Set();
+	const folded = /* @__PURE__ */ new Set();
+	for (const element of model.elements) if (isTransparent(element)) folded.add(element.id);
+	else if (stateOf(element) !== void 0) stateIds.add(element.id);
+	const index = chainIndex(model, {
+		folded: (id) => folded.has(id),
+		accepted: (id) => stateIds.has(id),
+		eventOf: (id) => {
+			const element = elements.get(id);
+			return element?.kind === "message" ? element.event : void 0;
+		}
+	});
+	const transitions = [];
+	const origins = [];
+	const firsts = [];
+	for (const element of model.elements) {
+		const state = isTransparent(element) ? void 0 : stateOf(element);
+		if (state === void 0) continue;
+		states.push(state);
+		for (const transition of outgoing.get(element.id) ?? []) {
+			firsts.push(transition);
+			for (const chain of index.from(transition)) {
+				transitions.push(transitionOf(chain));
+				origins.push({
+					first: transition,
+					target: chain.target
+				});
+			}
+		}
+	}
+	const carried = index.carried(firsts);
+	const loss = [...commonLoss(model, "stateMachine", {
+		fragments: /* @__PURE__ */ new Set(),
+		messages: /* @__PURE__ */ new Set([...carried, ...index.unfolded])
+	}), ...unrepresentedLoss(model, "stateMachine", /* @__PURE__ */ new Set([...stateIds, ...[...folded].filter((id) => !index.unfolded.has(id))]), index.unfolded)];
+	const skipped = model.elements.filter((element) => element.kind === "activity" && isTransparent(element) && !index.unfolded.has(element.id));
+	if (skipped.length > 0) loss.push({
+		kind: "subject",
+		subject,
+		elements: skipped.map((element) => element.id)
+	});
+	return {
+		machine: {
+			subject,
+			states,
+			transitions,
+			loss
+		},
+		origins,
+		index
+	};
+};
+/**
+* Activity-as-state projection. Each activity that affects the subject becomes a state the subject entity rests in, and a decision collapses into guarded transitions leaving the state before it. The target activity's action becomes the effect of the transition that enters it.
+*
+* Which activities affect the subject is declared by their `affects`. An activity that does not list the subject is not a state of it: transitions through it are folded into the transition that leaves the previous state, exactly as a decision is. Authored `state` elements and pseudo-states are always kept. When no activity in the model declares `affects`, the model carries no such information and every activity is kept, which is the unscoped behaviour.
+*
+* A `message` element is folded the same way, and its `event`, when it has one, triggers the transition that carries it. A message element no drawn transition carries is reported as a `message-elements` loss.
+*
+* Each drawn transition lists the model `transitions` it stands for and the elements folded into it (`through`), so an edit to it maps back to the model. Several routes through folded elements from the same transition to the same state are one drawn transition whose `transitions` and `through` are the union over the routes, each once in the order met; it carries no event or guard, which differ by route, and its effect is only the target's entry action.
+*
+* Decisions are folded into guards by design and are not a loss. Fork, join and history pseudo-states have no state of their own here and are reported as unrepresented, together with the transitions that touch them, which are left out rather than pointing at a state that is not drawn.
+*
+* Other conventions exist, such as steps as transitions with states between them. Naming states such as "Paid" needs authored states, which the model can hold as `state` elements.
+* @param model - The model to project.
+* @param subject - The entity whose lifecycle the machine shows.
+* @returns The states in model order, the transitions leaving each in turn, and what was dropped.
+* @throws Error when `subject` is not a declared entity participant, which only a runtime model can cause.
+*/
+const toStateMachine = (model, subject) => stateMachineParts(model, subject).machine;
+//#endregion
+//#region ../../core/graph/projection/dist/fragments.js
+/** A choice or a split needs at least two branches, and an `opt` is exactly a choice between doing something and skipping it. */
+const minBranches = 2;
+/** The virtual end every last step leads to, for finding where branches meet. A number, so it never equals an element id, which is a string. */
+const end = 0;
+const derivedItem = (element, operator) => (operands) => ({
+	kind: "fragment",
+	element,
+	operator,
+	operands
+});
+/** Appends `value` to the list `map` holds under `key`, starting the list when there is none. */
+const append = (map, key, value) => {
+	const list = map.get(key);
+	if (list === void 0) map.set(key, [value]);
+	else list.push(value);
+};
+/**
+* The fragments the model's structure implies along the scenario, in model order of the decision or fork each comes from, each decision's loop before its other fragments.
+*
+* - A decision transition whose target is in the decision's strongly connected component goes round again, the rule `graph-domain` uses for a legal cycle. Each component holding such a decision on the path draws one `loop`, holding the messages that arrive inside the component, guarded by those transitions' guards joined with "or".
+* - Each time the path takes one of a decision's other (forward) branches, when it has at least two, an `alt` holds the messages from that step until the path reaches where the branches meet: the decision's immediate post-dominator over forward transitions, or the end of the path when they never meet. With exactly two branches, one going straight to where they meet, it is an `opt`, and taking that empty branch draws nothing. The path coming back to the decision ends the earlier occurrence.
+* - Each time the path leaves a fork, a `par` holds one operand per branch taken, each with the messages of the steps that follow on from that branch until it reaches the fork's immediate post-dominator; a branch taken again starts a new `par`.
+*
+* One pass finds every component and one pass every post-dominator, both only when the path passes a decision or fork, and the path is then read once, so the work is the size of the model and of the path, not their product.
+*/
+const deriveCandidates = ({ model, steps, entries, onPath, observe }) => {
+	const branching = model.elements.filter((element) => onPath.has(element.id) && (element.kind === "decision" || element.kind === "pseudo" && element.role === "fork"));
+	if (branching.length === 0) return [];
+	const outgoing = outgoingMap(model);
+	const ids = model.elements.map((element) => element.id);
+	const component = /* @__PURE__ */ new Map();
+	for (const members of stronglyConnectedComponents(buildDag(ids, (id) => (outgoing.get(id) ?? []).map((transition) => transition.target)))) for (const member of members) component.set(member, members);
+	const loops = /* @__PURE__ */ new Set();
+	for (const element of model.elements) {
+		const own = component.get(element.id);
+		if (element.kind !== "decision" || own === void 0) continue;
+		for (const transition of outgoing.get(element.id) ?? []) if (component.get(transition.target) === own) loops.add(transition.id);
+	}
+	const before = /* @__PURE__ */ new Map();
+	const last = [];
+	for (const id of ids) {
+		const forward = (outgoing.get(id) ?? []).filter((transition) => !loops.has(transition.id));
+		if (forward.length === 0) last.push(id);
+		for (const transition of forward) append(before, transition.target, id);
+	}
+	const meets = immediateDominators(buildDag([end, ...ids], (id) => id === end ? last : before.get(id) ?? []), end);
+	/** Where an element's ways forward meet, or `undefined` when they only meet at the end. */
+	const meetOf = (id) => {
+		const meet = meets.get(id);
+		return meet === void 0 || meet === end ? void 0 : meet;
+	};
+	const found = /* @__PURE__ */ new Map();
+	const add = (element, candidate) => {
+		append(found, element, candidate);
+	};
+	const looping = /* @__PURE__ */ new Map();
+	const loopGuards = /* @__PURE__ */ new Map();
+	for (const element of branching) {
+		const own = component.get(element.id);
+		const back = (outgoing.get(element.id) ?? []).filter((transition) => loops.has(transition.id));
+		if (own === void 0 || back.length === 0) continue;
+		if (!looping.has(own)) {
+			looping.set(own, element.id);
+			loopGuards.set(own, /* @__PURE__ */ new Set());
+		}
+		for (const transition of back) if (transition.guard !== void 0) loopGuards.get(own)?.add(transition.guard);
+	}
+	const inside = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const own = component.get(entry.target);
+		if (own !== void 0 && looping.has(own)) {
+			observe?.(1);
+			append(inside, own, entry.index);
+		}
+	}
+	for (const [own, element] of looping) {
+		const guards = [...loopGuards.get(own) ?? []];
+		add(element, {
+			authored: void 0,
+			operands: [{
+				guard: guards.length > 0 ? guards.join(" or ") : void 0,
+				positions: inside.get(own) ?? []
+			}],
+			item: derivedItem(element, "loop")
+		});
+	}
+	/** Each branching element's forward branch count, where they meet, and, for a decision, whether it draws an `opt`: found once per element, not once per step that leaves it. */
+	const shapes = /* @__PURE__ */ new Map();
+	for (const element of branching) {
+		const forward = (outgoing.get(element.id) ?? []).filter((transition) => !loops.has(transition.id));
+		const meet = meetOf(element.id);
+		const direct = forward.filter((branch) => branch.target === meet).length;
+		shapes.set(element.id, {
+			branches: forward.length,
+			meet,
+			operator: forward.length === minBranches && direct === 1 ? "opt" : "alt"
+		});
+	}
+	const decisions = new Set(branching.flatMap((element) => element.kind === "decision" ? [element.id] : []));
+	const waiting = /* @__PURE__ */ new Map();
+	const openAt = /* @__PURE__ */ new Map();
+	const closed = /* @__PURE__ */ new Set();
+	const close = (occurrence, stop) => {
+		if (closed.has(occurrence)) return;
+		closed.add(occurrence);
+		if (openAt.get(occurrence.element) === occurrence) openAt.delete(occurrence.element);
+		if (stop > occurrence.start) add(occurrence.element, {
+			authored: void 0,
+			operands: [{
+				guard: occurrence.guard,
+				from: occurrence.start,
+				to: stop - 1
+			}],
+			item: derivedItem(occurrence.element, occurrence.operator)
+		});
+	};
+	const labels = /* @__PURE__ */ new Map();
+	const openParallel = /* @__PURE__ */ new Map();
+	const parallels = [];
+	/** The label a step carrying `label` leaves on `target`: the enclosing one when `target` is where its `par` meets. */
+	const after = (label, target) => label?.parallel.meet === target ? label.parallel.outer : label;
+	const relabel = (target, label) => {
+		const next = after(label, target);
+		if (next === void 0) labels.delete(target);
+		else labels.set(target, next);
+	};
+	for (const [index, step] of steps.entries()) {
+		const { transition } = step;
+		const position = (steps[index + 1]?.before ?? entries.length) > step.before ? step.before : void 0;
+		const source = transition.source;
+		const shape = shapes.get(source);
+		if (decisions.has(source) && shape !== void 0 && shape.branches >= minBranches && !loops.has(transition.id)) {
+			const earlier = openAt.get(source);
+			if (earlier !== void 0) close(earlier, step.before);
+			const { meet, operator } = shape;
+			if (!(operator === "opt" && transition.target === meet)) {
+				const occurrence = {
+					element: source,
+					operator,
+					guard: transition.guard,
+					start: step.before
+				};
+				openAt.set(source, occurrence);
+				if (meet !== void 0) append(waiting, meet, occurrence);
+			}
+		}
+		let label = labels.get(source);
+		if (!decisions.has(source) && shape !== void 0 && shape.branches >= minBranches) {
+			let parallel = openParallel.get(source);
+			if (parallel === void 0 || parallel.taken.has(transition.id)) {
+				parallel = {
+					element: source,
+					meet: shape.meet,
+					outer: label,
+					operands: [],
+					taken: /* @__PURE__ */ new Set()
+				};
+				openParallel.set(source, parallel);
+				parallels.push(parallel);
+			}
+			parallel.taken.add(transition.id);
+			parallel.operands.push({
+				guard: transition.guard,
+				positions: []
+			});
+			label = {
+				parallel,
+				operand: parallel.operands.length - 1
+			};
+		}
+		const holder = after(label, transition.target);
+		if (holder !== void 0 && position !== void 0) {
+			observe?.(1);
+			holder.parallel.operands[holder.operand]?.positions.push(position);
+		}
+		relabel(transition.target, label);
+		for (const occurrence of waiting.get(transition.target) ?? []) close(occurrence, step.before);
+		waiting.delete(transition.target);
+	}
+	for (const occurrence of openAt.values()) close(occurrence, entries.length);
+	for (const parallel of parallels) add(parallel.element, {
+		authored: void 0,
+		operands: parallel.operands,
+		item: derivedItem(parallel.element, "par")
+	});
+	return model.elements.flatMap((element) => found.get(element.id) ?? []);
+};
+/**
+* The authored fragments as candidates. An operand counts when its body is non-empty and wholly on the path; it holds the messages arriving at an element of its body that no earlier operand of the same fragment holds. The positions arriving at each element are found once and shared by every operand holding that element, so an operand is its elements and their shared lists, and matching costs the messages plus the bodies, never a message once per fragment.
+*/
+const authoredCandidates = (fragments, entries, onPath, observe) => {
+	const arrivals = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		observe?.(1);
+		append(arrivals, entry.target, entry.index);
+	}
+	return fragments.map(({ id, operator, operands }) => {
+		const taken = /* @__PURE__ */ new Set();
+		const held = [];
+		for (const operand of operands) {
+			if (operand.body.length === 0 || !operand.body.every((element) => onPath.has(element))) continue;
+			const elements = [];
+			for (const element of operand.body) {
+				observe?.(1);
+				const positions = arrivals.get(element);
+				if (!taken.has(element) && positions !== void 0) elements.push({
+					element,
+					positions
+				});
+				taken.add(element);
+			}
+			if (elements.length > 0) held.push({
+				guard: operand.guard,
+				elements
+			});
+		}
+		return {
+			authored: id,
+			operands: held,
+			item: (drawn) => ({
+				kind: "fragment",
+				fragment: id,
+				operator,
+				operands: drawn
+			})
+		};
+	});
+};
+/** How many of the ascending `positions` lie between `from` and `to` inclusive, by two binary searches. */
+const countBetween = (positions, from, to) => {
+	const firstAtLeast = (value) => {
+		let low = 0;
+		let high = positions.length;
+		while (low < high) {
+			const middle = low + high >>> 1;
+			if ((positions[middle] ?? value) < value) low = middle + 1;
+			else high = middle;
+		}
+		return low;
+	};
+	return firstAtLeast(to + 1) - firstAtLeast(from);
+};
+/** The first and last position an operand holds and how many it holds, from its ends or its list's ends. */
+const extentOf = (held) => {
+	if (held.elements !== void 0) {
+		let first = Number.POSITIVE_INFINITY;
+		let last = Number.NEGATIVE_INFINITY;
+		let count = 0;
+		for (const { positions } of held.elements) {
+			count += positions.length;
+			first = Math.min(first, positions[0] ?? first);
+			last = Math.max(last, positions.at(-1) ?? last);
+		}
+		return count === 0 ? void 0 : {
+			first,
+			last,
+			count
+		};
+	}
+	if (held.positions === void 0) return held.to < held.from ? void 0 : {
+		first: held.from,
+		last: held.to,
+		count: held.to - held.from + 1
+	};
+	const first = held.positions[0];
+	const last = held.positions.at(-1);
+	return first === void 0 || last === void 0 ? void 0 : {
+		first,
+		last,
+		count: held.positions.length
+	};
+};
+/** Whether an operand holds every position from `first` to `last`. */
+const holdsAll = (held, first, last) => {
+	if (held.elements !== void 0) {
+		let count = 0;
+		for (const { positions } of held.elements) count += countBetween(positions, first, last);
+		return count === last - first + 1;
+	}
+	return held.positions === void 0 ? held.from <= first && last <= held.to : countBetween(held.positions, first, last) === last - first + 1;
+};
+/** Each operand's body elements as a set, built the first time the operand is asked whether it holds a nested fragment. */
+const elementSets = /* @__PURE__ */ new WeakMap();
+/**
+* Whether a fragment spanning `first` to `last` lies wholly inside operand `slot` of the placed fragment around it, in constant or logarithmic time per check. The outer fragment's messages are consecutive, and both ends of the inner span lie inside it, so a fragment with one operand holds the whole span. A run or list of positions is checked by its ends or by binary search. An operand held by elements holds every message arriving at them, so an authored inner fragment, whose messages are exactly its own elements' and fill the span, fits when its elements are among the operand's; any other inner span is checked against the operand's elements by binary search when they are fewer than the span's positions, and otherwise position by position.
+*/
+const fits = (outer, slot, inner, { first, last }) => {
+	const { operands } = outer.candidate;
+	const operand = operands[slot];
+	if (operand === void 0) return false;
+	if (operands.length === 1) return true;
+	if (operand.elements === void 0) return holdsAll(operand, first, last);
+	let elements = elementSets.get(operand);
+	if (elements === void 0) {
+		elements = new Set(operand.elements.map(({ element }) => element));
+		elementSets.set(operand, elements);
+	}
+	const held = elements;
+	const innerElements = inner.operands.flatMap((part) => part.elements === void 0 ? [] : [part.elements]);
+	if (innerElements.length === inner.operands.length) return innerElements.every((list) => list.every(({ element }) => held.has(element)));
+	if (operand.elements.length <= last - first + 1) return holdsAll(operand, first, last);
+	for (let position = first; position <= last; position += 1) {
+		const element = outer.elementAt(position);
+		if (element === void 0 || !held.has(element)) return false;
+	}
+	return true;
+};
+/**
+* Which of a fragment's operands holds a position: listed positions are looked up in a map built from the lists, which together hold no more positions than the fragment does, and runs are found by a binary search over their starts. No run is expanded.
+*/
+const slotIndex = (operands, elementAt, observe) => {
+	if (operands.length === 1) return () => 0;
+	const listed = /* @__PURE__ */ new Map();
+	const byElement = /* @__PURE__ */ new Map();
+	const runs = [];
+	for (const [slot, operand] of operands.entries()) {
+		if (operand.elements !== void 0) {
+			for (const { element } of operand.elements) {
+				observe?.(1);
+				byElement.set(element, slot);
+			}
+			continue;
+		}
+		if (operand.positions === void 0) {
+			runs.push({
+				from: operand.from,
+				to: operand.to,
+				slot
+			});
+			continue;
+		}
+		for (const position of operand.positions) {
+			observe?.(1);
+			listed.set(position, slot);
+		}
+	}
+	runs.sort((a, b) => a.from - b.from);
+	return (position) => {
+		const element = elementAt(position);
+		const found = listed.get(position) ?? (element === void 0 ? void 0 : byElement.get(element));
+		if (found !== void 0) return found;
+		let low = 0;
+		let high = runs.length;
+		while (low < high) {
+			const middle = low + high >>> 1;
+			if ((runs[middle]?.from ?? position) <= position) low = middle + 1;
+			else high = middle;
+		}
+		const run = runs[low - 1];
+		return run !== void 0 && position <= run.to ? run.slot : 0;
+	};
+};
+/**
+* Which placed fragment is innermost at each position, without visiting the positions a fragment covers: fragments are placed largest first, so the innermost at a position is the one placed last among those covering it. A segment tree over the positions records, on the nodes that exactly cover each placed span, when it was placed; the innermost at a position is the latest placement on the path from its leaf to the root. Placing and asking each visit a number of nodes that grows with the logarithm of the number of positions.
+*/
+const placementTree = (size) => {
+	const latest = Array.from({ length: 2 * size }, () => void 0);
+	return {
+		place: (first, last, time) => {
+			let low = first + size;
+			let high = last + size + 1;
+			while (low < high) {
+				if ((low & 1) === 1) {
+					latest[low] = time;
+					low += 1;
+				}
+				if ((high & 1) === 1) {
+					high -= 1;
+					latest[high] = time;
+				}
+				low >>>= 1;
+				high >>>= 1;
+			}
+		},
+		at: (position) => {
+			let best;
+			for (let node = position + size; node >= 1; node >>>= 1) {
+				const time = latest[node];
+				if (time !== void 0 && (best === void 0 || time > best)) best = time;
+			}
+			return best;
+		}
+	};
+};
+/**
+* Wraps the scenario's messages in the fragments they fall inside: the authored ones first, then those derived from the model's structure.
+*
+* A fragment is drawn when it holds at least one message and the messages it holds are consecutive. Larger fragments are placed first; a fragment nests inside a placed one when all its messages lie in one of that fragment's operands, and is left out when it overlaps one without nesting. A derived fragment holding exactly the messages an authored one holds is not drawn: the authored fragment is the author's notation for the same structure.
+*
+* Fragments are compared and placed by the ends of their spans, and a segment tree answers which placed fragment is innermost at a position, so no span is ever expanded into its positions; the items are then built in one pass over the messages.
+* @param path - The scenario; its `observe`, when given, is told of the work done over message positions.
+* @returns The items and the ids of the authored fragments drawn.
+*/
+const wrapFragments = (path) => {
+	const { model, entries, onPath, observe } = path;
+	const candidates = [...authoredCandidates(model.fragments, entries, onPath, observe), ...deriveCandidates(path)];
+	const spans = [];
+	const authoredSpans = /* @__PURE__ */ new Set();
+	for (const [order, candidate] of candidates.entries()) {
+		let first = Number.POSITIVE_INFINITY;
+		let last = Number.NEGATIVE_INFINITY;
+		let count = 0;
+		for (const operand of candidate.operands) {
+			const extent = extentOf(operand);
+			if (extent !== void 0) {
+				count += extent.count;
+				first = Math.min(first, extent.first);
+				last = Math.max(last, extent.last);
+			}
+		}
+		const key = `${String(first)}:${String(last)}`;
+		if (count === 0 || last - first + 1 !== count) continue;
+		if (candidate.authored !== void 0) authoredSpans.add(key);
+		else if (authoredSpans.has(key)) continue;
+		spans.push({
+			candidate,
+			first,
+			last,
+			order
+		});
+	}
+	spans.sort((a, b) => b.last - b.first - (a.last - a.first) || a.order - b.order);
+	const tree = placementTree(entries.length);
+	const elementAt = (position) => entries[position]?.target;
+	const placed = [];
+	const innermost = (position) => {
+		const time = tree.at(position);
+		return time === void 0 ? void 0 : placed[time];
+	};
+	for (const { candidate, first, last, order } of spans) {
+		const outer = innermost(first);
+		if (outer !== innermost(last)) continue;
+		let parent;
+		if (outer !== void 0) {
+			const slot = outer.slotOf(first);
+			if (!fits(outer, slot, candidate, {
+				first,
+				last
+			})) continue;
+			parent = {
+				placed: outer,
+				slot
+			};
+		}
+		const node = {
+			candidate,
+			first,
+			last,
+			slotOf: slotIndex(candidate.operands, elementAt, observe),
+			elementAt,
+			parent,
+			order
+		};
+		tree.place(first, last, placed.length);
+		placed.push(node);
+	}
+	const top = [];
+	const contents = new Map(placed.map((node) => [node, node.candidate.operands.map(() => [])]));
+	const contentOf = (holder) => holder === void 0 ? top : contents.get(holder.placed)?.[holder.slot] ?? top;
+	const starting = /* @__PURE__ */ new Map();
+	for (const node of placed) append(starting, node.first, node);
+	for (const entry of entries) {
+		observe?.(1);
+		for (const node of starting.get(entry.index) ?? []) contentOf(node.parent).push({ placed: node });
+		const owner = innermost(entry.index);
+		contentOf(owner === void 0 ? void 0 : {
+			placed: owner,
+			slot: owner.slotOf(entry.index)
+		}).push({ entry });
+	}
+	const built = /* @__PURE__ */ new Map();
+	const itemsOf = (content) => content.flatMap((part) => {
+		if ("entry" in part) return [{
+			kind: "message",
+			message: part.entry.message
+		}];
+		const item = built.get(part.placed);
+		return item === void 0 ? [] : [item];
+	});
+	const drawn = /* @__PURE__ */ new Set();
+	for (const node of placed.toReversed()) {
+		const operands = (contents.get(node) ?? []).map((content, slot) => {
+			const guard = node.candidate.operands[slot]?.guard;
+			return {
+				...guard === void 0 ? {} : { guard },
+				items: itemsOf(content)
+			};
+		});
+		built.set(node, node.candidate.item(operands));
+		if (node.candidate.authored !== void 0) drawn.add(node.candidate.authored);
+	}
+	return {
+		items: itemsOf(top),
+		drawn
+	};
+};
+//#endregion
+//#region ../../core/graph/projection/dist/sequence.js
+/**
+* `toSequence`, telling `observe` of the work done over message positions so a caller can measure it.
+* @param model - The model to project.
+* @param scenario - The transitions the path takes, in order.
+* @param observe - Told of work done over message positions.
+*/
+const sequenceObserved = (model, scenario, observe) => {
+	const actors = actorMap(model);
+	const elements = new Map(model.elements.map((element) => [element.id, element]));
+	const transitions = new Map(model.transitions.map((transition) => [transition.id, transition]));
+	const eventNames = new Map(model.events.map((event) => [event.id, event.name]));
+	const labelOf = (id) => {
+		const element = elements.get(id);
+		return element?.kind === "activity" || element?.kind === "decision" ? element.label : void 0;
+	};
+	const skipped = [];
+	const lifelines = [];
+	const onLifeline = /* @__PURE__ */ new Set();
+	const messages = [];
+	const entries = [];
+	const steps = [];
+	const shownMessages = /* @__PURE__ */ new Set();
+	const holder = /* @__PURE__ */ new Map();
+	let arrivedAt;
+	const draw = (message, target) => {
+		for (const participant of [message.from, message.to]) if (!onLifeline.has(participant)) {
+			onLifeline.add(participant);
+			lifelines.push(participant);
+		}
+		entries.push({
+			index: messages.length,
+			message,
+			target
+		});
+		messages.push(message);
+	};
+	for (const id of scenario) {
+		const transition = transitions.get(id);
+		if (transition === void 0) throw new Error(`Scenario step "${id}" is not a declared transition`);
+		steps.push({
+			transition,
+			before: entries.length
+		});
+		const source = elements.get(transition.source);
+		const target = elements.get(transition.target);
+		const previous = arrivedAt;
+		arrivedAt = transition.target;
+		if (target?.kind === "message") {
+			shownMessages.add(target.id);
+			holder.set(target.id, target.to);
+			draw({
+				transition: id,
+				from: target.from,
+				to: target.to,
+				label: target.label,
+				element: target.id,
+				mode: target.mode
+			}, target.id);
+			continue;
+		}
+		if (source?.kind === "message") {
+			if (previous !== source.id) {
+				shownMessages.add(source.id);
+				draw({
+					transition: id,
+					from: source.from,
+					to: source.to,
+					label: source.label,
+					element: source.id,
+					mode: source.mode
+				}, source.id);
+			}
+			const to = actors.get(transition.target);
+			holder.set(transition.target, to ?? source.to);
+			continue;
+		}
+		const from = actors.get(transition.source) ?? holder.get(transition.source);
+		const to = actors.get(transition.target);
+		const held = to ?? from;
+		if (held !== void 0) holder.set(transition.target, held);
+		if (from === void 0 || to === void 0) {
+			skipped.push(id);
+			continue;
+		}
+		draw({
+			transition: id,
+			from,
+			to,
+			label: (transition.trigger === void 0 ? void 0 : eventNames.get(transition.trigger)) ?? labelOf(transition.target) ?? id
+		}, transition.target);
+	}
+	const onPath = /* @__PURE__ */ new Set();
+	const taken = new Set(scenario);
+	for (const id of taken) {
+		const transition = transitions.get(id);
+		if (transition !== void 0) {
+			onPath.add(transition.source);
+			onPath.add(transition.target);
+		}
+	}
+	const offPath = model.elements.filter((element) => !onPath.has(element.id));
+	const unshown = model.transitions.filter((transition) => !taken.has(transition.id) && onPath.has(transition.source));
+	const { items, drawn } = wrapFragments({
+		model,
+		steps,
+		entries,
+		onPath,
+		...observe === void 0 ? {} : { observe }
+	});
+	const loss = [...commonLoss(model, "sequence", {
+		fragments: drawn,
+		messages: shownMessages
+	})];
+	if (offPath.length > 0) loss.push({
+		kind: "scenario",
+		elements: offPath.map((element) => element.id)
+	});
+	if (unshown.length > 0) loss.push({
+		kind: "unshown-branches",
+		transitions: unshown.map((transition) => transition.id)
+	});
+	if (skipped.length > 0) loss.push({
+		kind: "skipped-steps",
+		transitions: skipped
+	});
+	return {
+		lifelines,
+		messages,
+		items,
+		loss
+	};
+};
+/**
+* One path through the process as messages.
+*
+* A step between two elements with actors becomes a message, labelled by the transition's event when it has one and by the target's label otherwise. A step arriving at a `message` element draws that message, with its own `from`, `to`, `label` and `mode`, and the step leaving it continues the same message rather than drawing another. An element with no actor that the scenario passes through, such as a fork or join, passes on whoever reached it: a step leaving it is sent by the actor of the step that arrived. A step that still has no sender, or that arrives at an element with no actor, draws nothing and is reported as `skipped-steps`. Branches off the path are not drawn, which is why this direction is lossy and one-to-many.
+*
+* `messages` is the flat list. `items` is the same messages with fragments wrapped around the ones that fall inside them: the authored `fragments` the scenario passes through, and those its structure implies (an `alt` or `opt` at a decision, a `loop` back through a decision, a `par` at a fork), each derived fragment naming the decision or fork it comes from. A fragment that cannot be drawn faithfully is left out, and an authored one left out is reported in `loss`.
+* @param model - The model to project.
+* @param scenario - The transitions the path takes, in order.
+* @returns Lifelines in order of first appearance, the messages, the items and what was dropped.
+* @throws Error when a scenario step is not a declared transition.
+*/
+const toSequence = (model, scenario) => sequenceObserved(model, scenario, void 0);
+//#endregion
+//#region ../../core/graph/domain/dist/facts.js
+/** The only field of a reserved key. Keys that carry it are resolved from the overlay, so a `Facts` implementation must not use it. */
+const elementField = "$element";
+/**
+* Builds the reserved key that reads another element's run state inside a condition. It resolves to the text `"done"` or `"open"`, and is not found (so the condition is indeterminate) when the overlay says `"unknown"` or the id is not an element of the model.
+*
+* The value is the overlay's own state, not the derived status: a condition therefore never depends on the derivation that evaluates it, and cannot form a cycle.
+* @param id - The element whose state is read.
+* @returns A key to put in a trilean `reference` node.
+*/
+const elementStatusKey = (id) => ({ [elementField]: id });
+/** The only field of the key the package puts to the port to ask whether an input artefact is provided. */
+const artefactField = "$artefact";
+/**
+* Builds the key the package asks the facts port when it needs to know whether an artefact has been provided from outside the process. An artefact is provided exactly when the port answers `{ found: true }` with the boolean `true`; a not-found or `false` answer means it is not.
+*
+* A provided artefact satisfies every consumer, whether or not an activity also produces it.
+* @param id - The artefact.
+* @returns The key the port is asked.
+*/
+const artefactKey = (id) => ({ [artefactField]: id });
+/**
+* Whether the facts port reports an artefact as provided.
+* @param facts - The injected source of facts.
+* @param id - The artefact.
+*/
+const isProvided = (facts, id) => {
+	const answer = facts(artefactKey(id));
+	return answer.found && answer.value.kind === "boolean" && answer.value.value;
+};
+/**
+* Thrown when a condition uses a node whose evaluation needs a table or a collection from the facts port, which answers single keys only.
+*/
+var UnsupportedConditionError = class extends Error {
+	/** The kind of reference the condition used. */
+	reference;
+	/**
+	* @param reference - The unsupported kind of reference.
+	*/
+	constructor(reference) {
+		super(`A condition uses a ${reference} reference, which the Facts port does not answer: it resolves single keys only`);
+		this.name = "UnsupportedConditionError";
+		this.reference = reference;
+	}
+};
+const evaluator = createSyncEvaluator({});
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Evaluates every transition's condition.
+*
+* A definite true is `taken`, a definite false is `not-taken` and an indeterminate result is `indeterminate`. A transition without a condition is `taken`. Conditions are evaluated for every transition regardless of the state of its source.
+* @param model - The model whose transitions are evaluated.
+* @param overlay - Run state, read by `elementStatusKey` references.
+* @param facts - The injected source of facts.
+* @returns The outcome of every transition, in transition order.
+* @throws UnsupportedConditionError when a condition contains a `lookup`, `some`, `every` or fold node.
+*/
+const evaluateBranches = (model, overlay, facts) => {
+	const elementIds = new Set(model.elements.map(({ id }) => id));
+	const overlayOf = new Map(Object.entries(overlay));
+	const resolvers = {
+		resolveValue: (key) => {
+			if (!isRecord(key) || !(elementField in key)) return facts(key);
+			const id = key[elementField];
+			if (typeof id !== "string" || !elementIds.has(id)) return { found: false };
+			const state = overlayOf.get(id);
+			if (state === "unknown") return { found: false };
+			return {
+				found: true,
+				value: {
+					kind: "text",
+					value: state === "done" ? "done" : "open"
+				}
+			};
+		},
+		resolveLookup: () => {
+			throw new UnsupportedConditionError("lookup");
+		},
+		resolveCollection: () => {
+			throw new UnsupportedConditionError("collection");
+		}
+	};
+	return new Map(model.transitions.map(({ id, condition }) => {
+		if (condition === void 0) return [id, "taken"];
+		const result = evaluator.evaluatePredicate(condition, void 0, resolvers);
+		if (result.status === "indeterminate") return [id, "indeterminate"];
+		return [id, result.value ? "taken" : "not-taken"];
+	}));
+};
+//#endregion
+//#region ../../core/graph/domain/dist/lookup.js
+/**
+* Reads a value out of a map built over every element of a model.
+* @throws UnknownNodeError when the key is absent, which for such a map means the model refers to an element it does not declare.
+*/
+const lookup = (map, id) => {
+	const value = map.get(id);
+	if (value === void 0) throw new UnknownNodeError(id);
+	return value;
+};
+//#endregion
+//#region ../../core/graph/domain/dist/derive.js
+/** Which of the derivation's rules decided an element's status, in the order the rules are applied. */
+const statusRules = [
+	"overlay-done",
+	"overlay-unknown",
+	"unknown-need",
+	"all-cut",
+	"needs-met",
+	"waiting"
+];
+/**
+* Derives the status of every element and the structures the queries share.
+*
+* Elements are visited in dependency order of the control graph. For each element, with its incoming non-loop transitions:
+*
+* 1. A transition is cut when its condition is definitely false or its source is `skipped`. The others are live.
+* 2. `done` when the overlay says `done`.
+* 3. `unknown` when the overlay says `unknown`, a live transition's condition is indeterminate or its source is `unknown`, or a consumed artefact that is not provided and has no done producer has an `unknown` producer.
+* 4. `skipped` when it has incoming transitions and every one is cut.
+* 5. `ready` when every live transition's source is `done` and each consumed artefact is provided or has a done producer; `blocked` otherwise. This single rule is also the join rule: a join, like any element, waits for every incoming source that is not skipped.
+* 6. A `decision` or `pseudo` element has no work of its own: when the rule above gives it `ready`, it is `done`, so downstream elements are not held up by a step nobody can perform. An overlay `unknown` still applies to it.
+*
+* An element with no overlay entry is open. `unknown` dominates `blocked`: an element that has an unknown need is `unknown` even if another need is open.
+*/
+const analyse = ({ model, overlay, facts }) => {
+	const loops = new Set(loopTransitions(model));
+	const dag = controlDag(model);
+	const cycles = findCycles(dag);
+	if (cycles.length > 0) throw new CycleError(cycles);
+	const branches = evaluateBranches(model, overlay, facts);
+	const elements = new Map(model.elements.map((element) => [element.id, element]));
+	const incoming = new Map(model.elements.map(({ id }) => [id, []]));
+	for (const transition of model.transitions) if (!loops.has(transition.id)) lookup(incoming, transition.target).push(transition.id);
+	const transitions = new Map(model.transitions.map((transition) => [transition.id, transition]));
+	const producers = /* @__PURE__ */ new Map();
+	for (const element of model.elements) if (element.kind === "activity") for (const artefact of element.produces ?? []) producers.set(artefact, [...producers.get(artefact) ?? [], element.id]);
+	const statuses = /* @__PURE__ */ new Map();
+	const liveNeeds = /* @__PURE__ */ new Map();
+	const basis = /* @__PURE__ */ new Map();
+	for (const id of topologicalLayers(dag).layers.flat()) {
+		const element = lookup(elements, id);
+		const edges = lookup(incoming, id).map((transitionId) => {
+			const source = lookup(transitions, transitionId).source;
+			const branch = lookup(branches, transitionId);
+			const sourceStatus = lookup(statuses, source);
+			return {
+				transition: transitionId,
+				source,
+				branch,
+				sourceStatus,
+				cut: branch === "not-taken" || sourceStatus === "skipped"
+			};
+		});
+		const live = edges.filter(({ cut }) => !cut);
+		const dataNeeds = /* @__PURE__ */ new Set();
+		const artefacts = [];
+		let dataUnknown = false;
+		let dataUnmet = false;
+		for (const artefact of element.kind === "activity" ? element.consumes ?? [] : []) {
+			const makers = producers.get(artefact) ?? [];
+			const made = makers.map((maker) => lookup(statuses, maker));
+			const provided = isProvided(facts, artefact);
+			const satisfied = provided || made.includes("done");
+			artefacts.push({
+				artefact,
+				provided,
+				producers: makers.map((maker) => ({
+					element: maker,
+					status: lookup(statuses, maker)
+				})),
+				satisfied
+			});
+			if (satisfied) continue;
+			dataUnmet = true;
+			dataUnknown ||= made.includes("unknown");
+			for (const maker of makers) if (lookup(statuses, maker) !== "skipped") dataNeeds.add(maker);
+		}
+		liveNeeds.set(id, [.../* @__PURE__ */ new Set([...live.map(({ source }) => source), ...dataNeeds])]);
+		const own = overlay[id];
+		let status;
+		let rule;
+		if (own === "done") {
+			status = "done";
+			rule = "overlay-done";
+		} else if (own === "unknown") {
+			status = "unknown";
+			rule = "overlay-unknown";
+		} else if (dataUnknown || live.some(({ branch, sourceStatus }) => branch === "indeterminate" || sourceStatus === "unknown")) {
+			status = "unknown";
+			rule = "unknown-need";
+		} else if (edges.length > 0 && live.length === 0) {
+			status = "skipped";
+			rule = "all-cut";
+		} else if (!dataUnmet && live.every(({ sourceStatus }) => sourceStatus === "done")) {
+			status = element.kind === "decision" || element.kind === "pseudo" ? "done" : "ready";
+			rule = "needs-met";
+		} else {
+			status = "blocked";
+			rule = "waiting";
+		}
+		statuses.set(id, status);
+		basis.set(id, {
+			rule,
+			transitions: edges,
+			artefacts
+		});
+	}
+	return {
+		dag,
+		branches,
+		statuses: new Map(dag.nodes.map((id) => [id, lookup(statuses, id)])),
+		liveNeeds,
+		basis
+	};
+};
+/**
+* The derived status of every element. See `analyse` for the rules; the semantics are documented in the package README.
+* @param model - The model to read.
+* @param overlay - Run state by element id.
+* @param facts - The injected source of facts conditions read, and of which input artefacts are provided (see `artefactKey`).
+* @returns A status for every element, in model order.
+* @throws CycleError when the control graph contains an illegal cycle (see `illegalCycles`), since status is undefined on it.
+* @throws UnknownNodeError when a transition refers to an element the model does not declare.
+* @throws UnsupportedConditionError when a condition needs a table or collection from the facts port.
+*/
+const deriveStatuses = (model, overlay, facts) => analyse({
+	model,
+	overlay,
+	facts
+}).statuses;
+//#endregion
+//#region ../../core/graph/domain/dist/progress.js
+/** Whether an element still has work ahead of it: it is neither finished nor going to be skipped. */
+const isLive = (status) => status !== "done" && status !== "skipped";
+/** The live needs of an element that are not done: what it is still waiting for. A finished or skipped element waits on nothing, even when the overlay marked it done ahead of its needs or it consumes an artefact still to be made. */
+const waitingOn = (analysis, id) => isLive(lookup(analysis.statuses, id)) ? lookup(analysis.liveNeeds, id).filter((need) => lookup(analysis.statuses, need) !== "done") : [];
+//#endregion
+//#region ../../core/graph/domain/dist/explain.js
+/**
+* Explains an element's status: the rule that decided it, the transitions and artefacts it was decided from, and the chain of unfinished work behind it. The explanation is the derivation's own record, so it always agrees with `deriveStatuses` and `blockedBy`.
+* @param model - The model to read.
+* @param overlay - Run state by element id.
+* @param facts - The injected source of facts conditions read, and of which input artefacts are provided.
+* @param id - The element asked about.
+* @returns The explanation.
+* @throws UnknownNodeError when `id` is not an element.
+* @throws CycleError when the control graph has an illegal cycle.
+*/
+const explainStatus = (model, overlay, facts, id) => {
+	const analysis = analyse({
+		model,
+		overlay,
+		facts
+	});
+	const basis = lookup(analysis.basis, id);
+	const reached = /* @__PURE__ */ new Map();
+	const pending = [id];
+	for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
+		if (reached.has(next)) continue;
+		const needs = waitingOn(analysis, next);
+		reached.set(next, needs);
+		pending.push(...needs);
+	}
+	const link = (element) => ({
+		element,
+		status: lookup(analysis.statuses, element),
+		waitingOn: analysis.dag.nodes.filter((node) => lookup(reached, element).includes(node))
+	});
+	return {
+		element: id,
+		status: lookup(analysis.statuses, id),
+		rule: basis.rule,
+		transitions: basis.transitions,
+		artefacts: basis.artefacts,
+		chain: [link(id), ...analysis.dag.nodes.filter((node) => node !== id && reached.has(node)).map(link)]
+	};
+};
+//#endregion
+//#region ../../core/graph/domain/dist/queries.js
+/**
+* The elements that can be worked on now: every element whose status is `ready`, in model order. Pure control elements (decisions and pseudo-states) are derived `done` and never appear.
+* @param model - The model to read.
+* @param overlay - Run state by element id.
+* @param facts - The injected source of facts conditions read, and of which input artefacts are provided.
+* @returns The ready elements.
+* @throws CycleError when the control graph has an illegal cycle.
+*/
+const readySet = (model, overlay, facts) => [...analyse({
+	model,
+	overlay,
+	facts
+}).statuses].filter(([, status]) => status === "ready").map(([id]) => id);
+/**
+* What is holding an element back: the minimal set of open elements to finish first.
+*
+* Starting from the element's unfinished needs, follows each one's own unfinished needs until it reaches elements that wait on nothing further, and returns exactly those leaves, in model order. Cut transitions (a branch not taken, a skipped source) and provided artefacts are not needs. A leaf is open work that is `ready`, or an element whose own state or condition is `unknown`. An element that is `done`, `skipped` or `ready` is blocked by nothing, and neither is one whose only obstacle is its own unknown state.
+* @param model - The model to read.
+* @param overlay - Run state by element id.
+* @param facts - The injected source of facts conditions read, and of which input artefacts are provided.
+* @param id - The element asked about.
+* @returns The leaves of the unfinished-needs closure, in model order.
+* @throws UnknownNodeError when `id` is not an element.
+* @throws CycleError when the control graph has an illegal cycle.
+*/
+const blockedBy = (model, overlay, facts, id) => {
+	const analysis = analyse({
+		model,
+		overlay,
+		facts
+	});
+	lookup(analysis.statuses, id);
+	const leaves = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [...waitingOn(analysis, id)];
+	for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
+		if (seen.has(next)) continue;
+		seen.add(next);
+		const further = waitingOn(analysis, next);
+		if (further.length === 0) leaves.add(next);
+		else pending.push(...further);
+	}
+	return analysis.dag.nodes.filter((node) => leaves.has(node));
+};
+/**
+* What finishing, delaying or dropping an element affects: the elements that transitively depend on it through paths that are still live.
+*
+* Traversal follows each dependent's live needs (see `Analysis.liveNeeds`), so a transition cut by a branch not taken, a skipped element and a loop edge carry no impact, and an element already `done` is neither affected nor traversed through. The element itself is not included.
+* @param model - The model to read.
+* @param overlay - Run state by element id.
+* @param facts - The injected source of facts conditions read, and of which input artefacts are provided.
+* @param id - The element asked about.
+* @returns The affected elements, in model order.
+* @throws UnknownNodeError when `id` is not an element.
+* @throws CycleError when the control graph has an illegal cycle.
+*/
+const impact = (model, overlay, facts, id) => {
+	const analysis = analyse({
+		model,
+		overlay,
+		facts
+	});
+	lookup(analysis.statuses, id);
+	const live = analysis.dag.nodes.filter((node) => isLive(lookup(analysis.statuses, node)));
+	const affected = /* @__PURE__ */ new Set();
+	const pending = [id];
+	for (let next = pending.pop(); next !== void 0; next = pending.pop()) for (const node of live) if (!affected.has(node) && node !== id && lookup(analysis.liveNeeds, node).includes(next)) {
+		affected.add(node);
+		pending.push(node);
+	}
+	return live.filter((node) => affected.has(node));
+};
+/**
+* Derives the run again with an element marked `done` in the overlay and reports what changes. Nothing is mutated.
+* @param model - The model to read.
+* @param overlay - Run state by element id.
+* @param facts - The injected source of facts conditions read, and of which input artefacts are provided.
+* @param id - The element to finish.
+* @returns The elements that become ready and every status change.
+* @throws UnknownNodeError when `id` is not an element.
+* @throws CycleError when the control graph has an illegal cycle.
+*/
+const whatIfDone = (model, overlay, facts, id) => {
+	const before = analyse({
+		model,
+		overlay,
+		facts
+	}).statuses;
+	lookup(before, id);
+	const changes = [...analyse({
+		model,
+		overlay: {
+			...overlay,
+			[id]: "done"
+		},
+		facts
+	}).statuses].flatMap(([element, status]) => {
+		const was = lookup(before, element);
+		return was === status ? [] : [{
+			id: element,
+			before: was,
+			after: status
+		}];
+	});
+	return {
+		becomesReady: changes.filter((change) => change.after === "ready").map((change) => change.id),
+		changes
+	};
+};
+/**
+* The heaviest chain through the work that is still ahead: the live elements, those that are neither `done` nor `skipped`, ordered by the live needs that are themselves live.
+*
+* A finished or skipped element contributes nothing and does not appear. The chain is computed with `graph-dag`'s `criticalPath`, so its tie-breaking rule holds (the earliest element in model order wins).
+* @param model - The model to read.
+* @param overlay - Run state by element id.
+* @param facts - The injected source of facts conditions read, and of which input artefacts are provided.
+* @param weight - The cost of an element: finite and not negative.
+* @returns The path in dependency order and its total weight; empty when nothing is live.
+* @throws RangeError when `weight` returns a negative or non-finite number.
+* @throws CycleError when the control graph has an illegal cycle.
+*/
+const criticalPath = (model, overlay, facts, weight) => {
+	const analysis = analyse({
+		model,
+		overlay,
+		facts
+	});
+	const live = analysis.dag.nodes.filter((node) => isLive(lookup(analysis.statuses, node)));
+	return criticalPath$1(buildDag(live, (id) => lookup(analysis.liveNeeds, id).filter((need) => isLive(lookup(analysis.statuses, need)))), weight);
+};
+/**
+* Every deliverable artefact that is still to be produced, with what is needed to produce it.
+*
+* A deliverable is met when it is provided or one of its producers is `done`. An unmet one lists its producers, the unfinished elements that must finish (its unfinished producers and everything those transitively wait on, skipped elements excluded) and the inputs that no one produces and nobody has provided, so a deliverable that can only ever be reached through an unproduced input shows exactly which input is missing.
+* @param model - The model to read.
+* @param overlay - Run state by element id.
+* @param facts - The injected source of facts conditions read, and of which input artefacts are provided.
+* @returns One entry per unmet deliverable, in declaration order.
+* @throws CycleError when the control graph has an illegal cycle.
+*/
+const unmetOutputs = (model, overlay, facts) => {
+	const analysis = analyse({
+		model,
+		overlay,
+		facts
+	});
+	const producersOf = (artefact) => model.elements.flatMap((element) => element.kind === "activity" && element.produces?.includes(artefact) === true ? [element.id] : []);
+	const unmet = [];
+	for (const { id: artefact, deliverable } of model.artefacts) {
+		const producers = producersOf(artefact);
+		if (deliverable !== true || isProvided(facts, artefact) || producers.some((id) => lookup(analysis.statuses, id) === "done")) continue;
+		const needed = /* @__PURE__ */ new Set();
+		const pending = producers.filter((id) => isLive(lookup(analysis.statuses, id)));
+		for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
+			if (needed.has(next)) continue;
+			needed.add(next);
+			pending.push(...waitingOn(analysis, next));
+		}
+		const wanted = /* @__PURE__ */ new Set();
+		for (const element of model.elements) {
+			if (element.kind !== "activity" || !needed.has(element.id)) continue;
+			for (const consumed of element.consumes ?? []) if (!isProvided(facts, consumed) && producersOf(consumed).length === 0) wanted.add(consumed);
+		}
+		unmet.push({
+			artefact,
+			producers,
+			needed: analysis.dag.nodes.filter((id) => needed.has(id)),
+			missingInputs: [...wanted]
+		});
+	}
+	return unmet;
+};
+//#endregion
+export { topologicalLayers as C, immediateDominators as S, toSwimlane as _, unmetOutputs as a, handoffs as b, deriveStatuses as c, artefactKey as d, elementStatusKey as f, toStateMachine as g, stateMachineParts as h, readySet as i, statusRules as l, toSequence as m, criticalPath as n, whatIfDone as o, evaluateBranches as p, impact as r, explainStatus as s, blockedBy as t, UnsupportedConditionError as u, flowchartParts as v, actorMap as w, criticalPath$1 as x, toFlowchart as y };