process-graph 1.0.5 → 1.1.0

package/dist/index.js

@@ -1,5 +1,929 @@
-// The primary entry point: the model, its projections and its reasoning under one install. The schema, projection and domain packages are re-exported flat. The DAG package is namespaced as `dag` because its `criticalPath` has the same name as the domain package's, which answers a different question over the model and a run overlay. The whole layer is namespaced, not only the colliding name, so the rule is one sentence and a name added to a layer later cannot start colliding silently: TypeScript rejects a duplicate `export *` name and `index.unit.test.ts` checks the runtime surface against each package's own exports.
-export * from "@exadev/process-graph-schema";
-export * from "@exadev/process-graph-projection";
-export * from "@exadev/process-graph-domain";
-export * as dag from "@exadev/process-graph-dag";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { a as validateOverlay, c as fragmentOperators, d as overlayStatuses, f as participantKinds, i as parseOverlay, l as messageModes, n as OverlayParseError, p as pseudoRoles, r as overlaySchema, s as elementKinds, t as modelSchema, u as notations } from "./schema-CVnS6HiX.js";
+import { t as validate } from "./validate-DF3mQZww.js";
+import { n as parseModel, t as ModelParseError } from "./parse-CuipC_2K.js";
+import { C as topologicalLayers, S as immediateDominators, _ as toSwimlane, a as unmetOutputs, b as handoffs, c as deriveStatuses, d as artefactKey, f as elementStatusKey, g as toStateMachine, h as stateMachineParts, i as readySet, l as statusRules, m as toSequence, n as criticalPath, o as whatIfDone, p as evaluateBranches, r as impact, s as explainStatus, t as blockedBy, u as UnsupportedConditionError, v as flowchartParts, w as actorMap, x as criticalPath$1, y as toFlowchart } from "./queries-CCexJAE2.js";
+import { a as findCycles, c as descendantsOf, d as lookup, f as CycleError, i as assertAcyclic, l as assembleDag, n as illegalCycles, o as stronglyConnectedComponents, p as UnknownNodeError, r as loopTransitions, s as ancestorsOf, t as controlDag, u as buildDag } from "./control-aDk9560d.js";
+import { t as statuses } from "./status-Bm1CGu9C.js";
+//#region ../../core/graph/schema/dist/artefacts.js
+/**
+* The artefacts the process takes as given: those no activity produces, in declaration order.
+* @param model - The model to read.
+* @returns The declared artefacts that appear in no activity's `produces`.
+*/
+const inputsOf = (model) => {
+	const produced = new Set(model.elements.flatMap((element) => element.kind === "activity" ? element.produces ?? [] : []));
+	return model.artefacts.filter((artefact) => !produced.has(artefact.id));
+};
+/**
+* The artefacts the process exists to deliver: those flagged `deliverable`, in declaration order.
+* @param model - The model to read.
+* @returns The declared artefacts flagged `deliverable`.
+*/
+const outputsOf = (model) => model.artefacts.filter((artefact) => artefact.deliverable === true);
+//#endregion
+//#region ../../core/graph/schema/dist/model.js
+/**
+* Declare a model. Each identifier union is inferred from the declaring arrays only, so every reference elsewhere is checked against what was declared.
+*
+* The participants array is captured whole, with each kind kept as a literal. Actors and message ends are then checked against the role and system participants, and a state machine subject against the entity participants.
+*/
+const defineModel = (model) => model;
+//#endregion
+//#region ../../core/graph/dag/dist/reduction.js
+/**
+* The transitive reduction: the same nodes with every redundant edge removed, so a node keeps a direct need only when no other need of it already depends on that node, transitively.
+*
+* Defined for acyclic graphs, where it is unique and has exactly the same ancestors and descendants as the input. Each node's remaining needs keep the order they had. Unknown references are carried over unchanged; they are not edges and take no part in reduction.
+*
+* Builds each node's full set of ancestors, so memory grows with the size of the transitive closure.
+* @throws CycleError when the graph contains a cycle: with one the reduction is not unique, so nothing is guessed.
+*/
+function transitiveReduction(dag) {
+	assertAcyclic(dag);
+	const ancestors = /* @__PURE__ */ new Map();
+	for (const layer of topologicalLayers(dag).layers) for (const id of layer) {
+		const closure = /* @__PURE__ */ new Set();
+		for (const need of lookup(dag.needs, id)) {
+			closure.add(need);
+			for (const further of lookup(ancestors, need)) closure.add(further);
+		}
+		ancestors.set(id, closure);
+	}
+	const reduced = /* @__PURE__ */ new Map();
+	for (const id of dag.nodes) {
+		const direct = lookup(dag.needs, id);
+		reduced.set(id, direct.filter((candidate) => !direct.some((other) => lookup(ancestors, other).has(candidate))));
+	}
+	return assembleDag(dag.nodes, reduced, dag.unknownReferences);
+}
+//#endregion
+//#region ../../core/graph/dag/dist/index.js
+var dist_exports = /* @__PURE__ */ __exportAll({
+	CycleError: () => CycleError,
+	UnknownNodeError: () => UnknownNodeError,
+	ancestorsOf: () => ancestorsOf,
+	buildDag: () => buildDag,
+	criticalPath: () => criticalPath$1,
+	descendantsOf: () => descendantsOf,
+	findCycles: () => findCycles,
+	immediateDominators: () => immediateDominators,
+	stronglyConnectedComponents: () => stronglyConnectedComponents,
+	topologicalLayers: () => topologicalLayers,
+	transitiveReduction: () => transitiveReduction
+});
+//#endregion
+//#region ../../core/graph/projection/dist/diff.js
+/** Thrown by `applyModelDiff` when the diff still holds changes the inverse inferred and nobody confirmed. */
+var UnconfirmedChangeError = class extends Error {
+	/** The changes still marked `inferred`. */
+	changes;
+	constructor(changes) {
+		super(`The diff holds inferred changes that have not been confirmed: ${changes.map((change) => change.kind).join(", ")}`);
+		this.name = "UnconfirmedChangeError";
+		this.changes = changes;
+	}
+};
+/**
+* Marks inferred changes as confirmed, so `applyModelDiff` will apply them.
+* @param diff - A diff returned by one of the view inverses.
+* @param accept - Chooses which inferred changes to confirm; the rest stay inferred.
+* @returns A new diff; `diff` is not modified.
+*/
+const confirmChanges = (diff, accept) => ({
+	elements: diff.elements.map((change) => change.inferred && accept(change) ? {
+		...change,
+		inferred: false
+	} : change),
+	transitions: diff.transitions.map((change) => change.inferred && accept(change) ? {
+		...change,
+		inferred: false
+	} : change),
+	events: diff.events.map((change) => change.inferred && accept(change) ? {
+		...change,
+		inferred: false
+	} : change)
+});
+/** A copy of `value` without `key`, for clearing an optional field, which `exactOptionalPropertyTypes` will not let be set to `undefined`. */
+const without = (value, key) => {
+	const copy = { ...value };
+	Reflect.deleteProperty(copy, key);
+	return copy;
+};
+/** Applies one change to the element it names; additions and removals are applied to the element list instead. */
+const applyElementChange = (element, change) => {
+	if (change.kind === "renamed") {
+		if (element.kind === "pseudo") throw new Error(`Element "${element.id}" is a pseudo-state and has no label to rename`);
+		return {
+			...element,
+			label: change.to
+		};
+	}
+	if (change.kind === "relaned") {
+		if (element.kind !== "activity" && element.kind !== "decision") throw new Error(`Element "${element.id}" is a ${element.kind} and has no actor to move`);
+		return change.to === void 0 ? without(element, "actor") : {
+			...element,
+			actor: change.to
+		};
+	}
+	if (change.kind === "readdressed") {
+		if (element.kind !== "message") throw new Error(`Element "${element.id}" is a ${element.kind}, not a message`);
+		return {
+			...element,
+			from: change.to.from,
+			to: change.to.to
+		};
+	}
+	return element;
+};
+/** Applies one change to the transition it names; additions and removals are applied to the transition list instead. */
+const applyTransitionChange = (transition, change) => {
+	if (change.kind === "rewired") return {
+		...transition,
+		...change.to
+	};
+	if (change.kind !== "changed") return transition;
+	if (change.field === "guard") return change.to === void 0 ? without(transition, "guard") : {
+		...transition,
+		guard: change.to
+	};
+	if (change.field === "trigger") return change.to === void 0 ? without(transition, "trigger") : {
+		...transition,
+		trigger: change.to
+	};
+	return change.to === void 0 ? without(transition, "effect") : {
+		...transition,
+		effect: change.to
+	};
+};
+/** The items of `items` grouped by the key `keyOf` gives each, every group in the order of `items`; one pass, so looking a group up afterwards costs nothing per item. */
+const groupBy = (items, keyOf) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = keyOf(item);
+		const group = groups.get(key);
+		if (group === void 0) groups.set(key, [item]);
+		else group.push(item);
+	}
+	return groups;
+};
+/** The identifier a change is about, used to find what it applies to. */
+const subjectOf = (change) => change.kind === "added" ? change.element.id : change.element;
+const transitionSubjectOf = (change) => change.kind === "added" ? change.transition.id : change.transition;
+/**
+* Applies a confirmed diff to the model, returning a new model.
+*
+* Removing an element also takes it out of fragment bodies and recorded positions; removing a transition also takes it out of every sequence scenario. Transitions that touched a removed element are only removed when the diff says so, as every view inverse does, so a diff built by hand that leaves one dangling yields a model `validate` reports.
+* @param model - The model the diff was computed against.
+* @param diff - The changes, with every inferred one confirmed.
+* @returns The changed model; `model` is not modified.
+* @throws UnconfirmedChangeError when a change is still marked `inferred`.
+* @throws Error when a change names an element, transition or event the model does not have, or asks for something the element's kind cannot carry, such as a label on a pseudo-state.
+*/
+const applyModelDiff = (model, diff) => {
+	const unconfirmed = [
+		...diff.elements,
+		...diff.transitions,
+		...diff.events
+	].filter((change) => change.inferred);
+	if (unconfirmed.length > 0) throw new UnconfirmedChangeError(unconfirmed);
+	const elementIds = new Set(model.elements.map((element) => element.id));
+	for (const change of diff.elements) if (change.kind !== "added" && !elementIds.has(subjectOf(change))) throw new Error(`Element "${subjectOf(change)}" is not in the model`);
+	const transitionIds = new Set(model.transitions.map((transition) => transition.id));
+	for (const change of diff.transitions) {
+		const id = transitionSubjectOf(change);
+		if (change.kind !== "added" && !transitionIds.has(id)) throw new Error(`Transition "${id}" is not in the model`);
+	}
+	const eventIds = new Set(model.events.map((event) => event.id));
+	for (const change of diff.events) if (!eventIds.has(change.event)) throw new Error(`Event "${change.event}" is not in the model`);
+	const removedElements = new Set(diff.elements.flatMap((change) => change.kind === "removed" ? [change.element] : []));
+	const removedTransitions = new Set(diff.transitions.flatMap((change) => change.kind === "removed" ? [change.transition] : []));
+	const elementChanges = groupBy(diff.elements, subjectOf);
+	const transitionChanges = groupBy(diff.transitions, transitionSubjectOf);
+	const eventChanges = groupBy(diff.events, (change) => change.event);
+	const elements = [...model.elements.filter((element) => !removedElements.has(element.id)).map((element) => (elementChanges.get(element.id) ?? []).reduce(applyElementChange, element)), ...diff.elements.flatMap((change) => change.kind === "added" ? [change.element] : [])];
+	const transitions = [...model.transitions.filter((transition) => !removedTransitions.has(transition.id)).map((transition) => (transitionChanges.get(transition.id) ?? []).reduce(applyTransitionChange, transition)), ...diff.transitions.flatMap((change) => change.kind === "added" ? [change.transition] : [])];
+	const events = model.events.map((event) => (eventChanges.get(event.id) ?? []).reduce((renamed, change) => ({
+		...renamed,
+		name: change.to
+	}), event));
+	const fragments = model.fragments.map((fragment) => ({
+		...fragment,
+		operands: fragment.operands.map((operand) => ({
+			...operand,
+			body: operand.body.filter((id) => !removedElements.has(id))
+		}))
+	}));
+	const projections = model.projections.map((projection) => projection.notation === "sequence" ? {
+		...projection,
+		scenario: projection.scenario.filter((id) => !removedTransitions.has(id))
+	} : projection);
+	const views = model.views === void 0 ? void 0 : Object.fromEntries(Object.entries(model.views).map(([notation, positions]) => [notation, Object.fromEntries(Object.entries(positions).filter(([id]) => !removedElements.has(id)))]));
+	return {
+		...model,
+		elements,
+		transitions,
+		events,
+		fragments,
+		projections,
+		...views === void 0 ? {} : { views }
+	};
+};
+//#endregion
+//#region ../../core/graph/projection/dist/inverse-flowchart.js
+const degreesOf = (edges) => {
+	const incoming = /* @__PURE__ */ new Map();
+	const outgoing = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		incoming.set(edge.to, (incoming.get(edge.to) ?? 0) + 1);
+		outgoing.set(edge.from, (outgoing.get(edge.from) ?? 0) + 1);
+	}
+	return {
+		in: incoming,
+		out: outgoing
+	};
+};
+/** What an added node becomes, with whether the inverse had to choose. A terminator is a start when nothing arrives at it and an end otherwise; a bar is a fork when it has more ways out than in and a join otherwise. */
+const addedElement = (node, degrees, actor) => {
+	const owned = actor === void 0 ? {} : { actor };
+	if (node.shape === "process") return {
+		kind: "added",
+		element: {
+			kind: "activity",
+			id: node.id,
+			label: node.label,
+			...owned
+		},
+		inferred: false
+	};
+	if (node.shape === "decision") return {
+		kind: "added",
+		element: {
+			kind: "decision",
+			id: node.id,
+			label: node.label,
+			...owned
+		},
+		inferred: false
+	};
+	if (node.shape === "terminator") return {
+		kind: "added",
+		element: {
+			kind: "pseudo",
+			id: node.id,
+			role: (degrees.in.get(node.id) ?? 0) > 0 ? "final" : "initial"
+		},
+		inferred: true
+	};
+	const ins = degrees.in.get(node.id) ?? 0;
+	const outs = degrees.out.get(node.id) ?? 0;
+	return {
+		kind: "added",
+		element: {
+			kind: "pseudo",
+			id: node.id,
+			role: outs > ins ? "fork" : "join"
+		},
+		inferred: true
+	};
+};
+/**
+* The element and transition changes shared by the flowchart and swimlane inverses. `actorOf` gives the actor an edited node is placed with, for the swimlane; the flowchart has none and passes a function that always returns `undefined`.
+*/
+const diffFlow = (model, edited, actorOf) => {
+	const parts = flowchartParts(model);
+	const original = parts.flowchart;
+	const elements = new Map(model.elements.map((element) => [element.id, element]));
+	const drawn = new Map(original.nodes.map((node) => [node.id, node]));
+	const kept = new Set(edited.nodes.map((node) => node.id));
+	const degrees = degreesOf(edited.edges);
+	const elementChanges = [];
+	for (const node of original.nodes) if (!kept.has(node.id)) elementChanges.push({
+		kind: "removed",
+		element: node.id,
+		inferred: false
+	});
+	for (const node of edited.nodes) {
+		const before = drawn.get(node.id);
+		if (before === void 0) {
+			if (elements.has(node.id)) throw new Error(`Node "${node.id}" is a model element the flowchart does not draw`);
+			elementChanges.push(addedElement(node, degrees, actorOf(node.id)));
+			continue;
+		}
+		if (before.shape !== node.shape) throw new Error(`Node "${node.id}" changed shape from ${before.shape} to ${node.shape}; an element's kind is its identity, so remove it and add one under a new id`);
+		if (before.label !== node.label) {
+			if (node.shape === "terminator" || node.shape === "bar") throw new Error(`Node "${node.id}" is a ${node.shape}, whose label the projection supplies and the model does not hold`);
+			elementChanges.push({
+				kind: "renamed",
+				element: node.id,
+				from: before.label,
+				to: node.label,
+				inferred: false
+			});
+		}
+	}
+	const transitionChanges = [];
+	const transitions = new Map(model.transitions.map((transition) => [transition.id, transition]));
+	const keyOf = (first, target) => JSON.stringify([first, target]);
+	const originals = /* @__PURE__ */ new Map();
+	for (const [position, origin] of parts.origins.entries()) {
+		const edge = original.edges[position];
+		if (edge !== void 0) originals.set(keyOf(origin.first.id, origin.target), {
+			edge,
+			origin
+		});
+	}
+	/** An edited edge's key: its first transition and the node one of its transitions arrives at, or `undefined` for an edge whose first transition is new. */
+	const editedKey = (edge) => {
+		const [first] = edge.transitions;
+		if (first === void 0 || !transitions.has(first)) return;
+		for (const id of edge.transitions) {
+			const target = transitions.get(id)?.target;
+			if (target !== void 0 && drawn.has(target)) return keyOf(first, target);
+		}
+	};
+	const editedKeys = new Set(edited.edges.map(editedKey));
+	const removed = /* @__PURE__ */ new Set();
+	const endsLeft = /* @__PURE__ */ new Set();
+	for (const [key, { origin }] of originals) {
+		if (editedKeys.has(key)) continue;
+		if (origin.first.target !== origin.target) endsLeft.add(origin.target);
+		else if (!removed.has(origin.first.id)) {
+			removed.add(origin.first.id);
+			transitionChanges.push({
+				kind: "removed",
+				transition: origin.first.id,
+				inferred: false
+			});
+		}
+	}
+	for (const end of endsLeft) for (const transition of parts.index.arriving(end)) if (!removed.has(transition.id)) {
+		removed.add(transition.id);
+		transitionChanges.push({
+			kind: "removed",
+			transition: transition.id,
+			inferred: true
+		});
+	}
+	const movedEnds = /* @__PURE__ */ new Map();
+	for (const edge of edited.edges) {
+		const key = editedKey(edge);
+		const before = key === void 0 ? void 0 : originals.get(key);
+		const [first] = edge.transitions;
+		if (before === void 0) {
+			if (first === void 0 || edge.transitions.length > 1 || transitions.has(first) || edge.through !== void 0) throw new Error(`Edge ${JSON.stringify(edge.transitions)} is neither an edge of the model nor a new edge with a single new transition id`);
+			transitionChanges.push({
+				kind: "added",
+				transition: {
+					id: first,
+					source: edge.from,
+					target: edge.to,
+					...edge.label === void 0 ? {} : { guard: edge.label }
+				},
+				inferred: false
+			});
+			continue;
+		}
+		const { origin } = before;
+		const head = origin.first;
+		if (!(head.target !== origin.target)) {
+			if (before.edge.from !== edge.from || before.edge.to !== edge.to) transitionChanges.push({
+				kind: "rewired",
+				transition: head.id,
+				from: {
+					source: head.source,
+					target: head.target
+				},
+				to: {
+					source: edge.from,
+					target: edge.to
+				},
+				inferred: false
+			});
+			if (before.edge.label !== edge.label) transitionChanges.push({
+				kind: "changed",
+				field: "guard",
+				transition: head.id,
+				from: head.guard,
+				to: edge.label,
+				inferred: false
+			});
+			continue;
+		}
+		if (before.edge.label !== edge.label) throw new Error(`Edge ${JSON.stringify(edge.transitions)} carries a message; edit the message or its steps rather than the edge's label`);
+		if (head.source !== edge.from) transitionChanges.push({
+			kind: "rewired",
+			transition: head.id,
+			from: {
+				source: head.source,
+				target: head.target
+			},
+			to: {
+				source: edge.from,
+				target: head.target
+			},
+			inferred: false
+		});
+		if (origin.target === edge.to) continue;
+		const already = movedEnds.get(origin.target);
+		if (already === edge.to) continue;
+		if (already !== void 0) throw new Error(`Edges ending at "${origin.target}" through the same steps were moved to different ends, "${already}" and "${edge.to}"`);
+		movedEnds.set(origin.target, edge.to);
+		for (const tail of parts.index.arriving(origin.target)) transitionChanges.push({
+			kind: "rewired",
+			transition: tail.id,
+			from: {
+				source: tail.source,
+				target: tail.target
+			},
+			to: {
+				source: tail.source,
+				target: edge.to
+			},
+			inferred: true
+		});
+	}
+	return {
+		elements: elementChanges,
+		transitions: transitionChanges
+	};
+};
+/**
+* The inverse of `toFlowchart`: what an edited flowchart changes in the model, matched by element and transition id.
+*
+* A node not in the projection is an added element: a process an activity, a decision a decision, both certain; a terminator or bar a pseudo-state whose role is inferred from its edges. A projected node missing from the edit is removed, and a changed label renames the element. An edge is matched by where it comes from: the transition it starts with and the node one of its transitions arrives at. A new edge must carry one new transition id and is an added transition; a projected edge missing from the edit removes its transition; moved ends rewire it; a changed label changes its guard. An edge that carries messages stands for every route through them, so its earlier steps are shared with other edges: moving its source rewires its first transition, which is certain, while removing it or moving its target acts on each step from a message into its end, once however many edges share them, and is inferred.
+* @param model - The model the flowchart was projected from.
+* @param edited - The projected flowchart after editing. Its `loss` is not read.
+* @returns The changes, with no event changes, since a flowchart draws no events.
+* @throws Error when the edit cannot be expressed in the model: a node that is a model element the flowchart does not draw, a changed shape, a relabelled terminator or bar, an unmatched edge that is not a single new transition, a relabelled edge that carries a message, or edges sharing their last steps moved to different ends.
+*/
+const diffFlowchart = (model, edited) => ({
+	...diffFlow(model, edited, () => void 0),
+	events: []
+});
+/**
+* The inverse of `toSwimlane`: the flowchart changes plus the lane moves. A node is placed with the actor of the lane it is in, or with none when it is in `unassigned`; an activity or decision whose actor differs from the model's is relaned, and an added activity or decision takes its lane's actor. Hand-offs are derived and not read.
+* @param model - The model the swimlane was projected from.
+* @param edited - The projected swimlane after editing.
+* @returns The changes; see `diffFlowchart` for nodes and edges.
+* @throws Error in the cases `diffFlowchart` does, when a lane belongs to a participant that cannot act, or when a pseudo-state is put in a lane.
+*/
+const diffSwimlane = (model, edited) => {
+	const actors = /* @__PURE__ */ new Set([...model.participants.flatMap((participant) => participant.kind === "entity" ? [] : [participant.id]), ...model.elements.flatMap((element) => (element.kind === "activity" || element.kind === "decision") && element.actor !== void 0 ? [element.actor] : [])]);
+	const canAct = (participant) => actors.has(participant);
+	const placed = /* @__PURE__ */ new Map();
+	for (const lane of edited.lanes) {
+		if (!canAct(lane.participant)) throw new Error(`Lane "${lane.participant}" belongs to a participant that cannot act`);
+		for (const node of lane.nodes) placed.set(node, lane.participant);
+	}
+	const flow = diffFlow(model, edited, (node) => placed.get(node));
+	const relaned = [];
+	const shapes = new Map(edited.nodes.map((node) => [node.id, node.shape]));
+	for (const node of placed.keys()) {
+		const shape = shapes.get(node);
+		if (shape === "terminator" || shape === "bar") throw new Error(`Node "${node}" is a pseudo-state and has no actor to put in a lane`);
+	}
+	for (const element of model.elements) {
+		if (element.kind !== "activity" && element.kind !== "decision" || !shapes.has(element.id)) continue;
+		const to = placed.get(element.id);
+		if (to !== element.actor) relaned.push({
+			kind: "relaned",
+			element: element.id,
+			from: element.actor,
+			to,
+			inferred: false
+		});
+	}
+	return {
+		elements: [...flow.elements, ...relaned],
+		transitions: flow.transitions,
+		events: []
+	};
+};
+//#endregion
+//#region ../../core/graph/projection/dist/inverse-state-machine.js
+/** The element an added state becomes: an authored `state`, or an initial or final pseudo-state. */
+const addedState = (state) => ({
+	kind: "added",
+	element: state.role === "state" ? {
+		kind: "state",
+		id: state.id,
+		label: state.label
+	} : {
+		kind: "pseudo",
+		id: state.id,
+		role: state.role
+	},
+	inferred: false
+});
+/**
+* The inverse of `toStateMachine`: what an edited state machine changes in the model, matched by element and transition id.
+*
+* A state not in the projection is an added element: a `state` element for a plain state, or an initial or final pseudo-state. A projected state missing from the edit is removed, and a changed label renames the activity or state behind it.
+*
+* A drawn transition is matched by where it comes from: its first model transition and the state one of its model transitions arrives at. One that stands for a single transition maps straight back: moved ends rewire it, and a changed event, guard or effect changes that transition's trigger, guard or effect. One that stands for a chain through folded elements (decisions, activities that do not affect the subject, messages) shares its later steps with every other chain through the same elements, so the inverse has to choose: moving its source rewires the first step and is certain, but moving its target, changing its labels or removing it acts on each step from a folded element into its target state, once however many drawn transitions share it, and is marked `inferred`. A new transition must carry one new transition id and is added with its event, guard and effect.
+* @param model - The model the machine was projected from.
+* @param edited - The projected machine after editing; `subject` says which projection it was. Its `loss` is not read.
+* @returns The changes, with no event changes, since a state machine names events by id.
+* @throws Error when the edit cannot be expressed in the model: a state that is a model element the machine does not draw, a changed role, a relabelled initial or final state, an unmatched transition that is not a single new transition, or a changed effect where the effect is the target activity's action.
+*/
+const diffStateMachine = (model, edited) => {
+	const parts = stateMachineParts(model, edited.subject);
+	const original = parts.machine;
+	const elements = new Map(model.elements.map((element) => [element.id, element]));
+	const drawn = new Map(original.states.map((state) => [state.id, state]));
+	const kept = new Set(edited.states.map((state) => state.id));
+	const elementChanges = [];
+	for (const state of original.states) if (!kept.has(state.id)) elementChanges.push({
+		kind: "removed",
+		element: state.id,
+		inferred: false
+	});
+	for (const state of edited.states) {
+		const before = drawn.get(state.id);
+		if (before === void 0) {
+			if (elements.has(state.id)) throw new Error(`State "${state.id}" is a model element the state machine does not draw`);
+			elementChanges.push(addedState(state));
+			continue;
+		}
+		if (before.role !== state.role) throw new Error(`State "${state.id}" changed role from ${before.role} to ${state.role}; remove it and add one under a new id`);
+		if (before.label !== state.label) {
+			if (state.role !== "state") throw new Error(`State "${state.id}" is ${state.role === "initial" ? "an" : "a"} ${state.role} pseudo-state, whose label the projection supplies`);
+			elementChanges.push({
+				kind: "renamed",
+				element: state.id,
+				from: before.label,
+				to: state.label,
+				inferred: false
+			});
+		}
+	}
+	const transitions = new Map(model.transitions.map((transition) => [transition.id, transition]));
+	const keyOf = (first, target) => JSON.stringify([first, target]);
+	const originals = /* @__PURE__ */ new Map();
+	for (const [position, origin] of parts.origins.entries()) {
+		const drawnTransition = original.transitions[position];
+		if (drawnTransition !== void 0) originals.set(keyOf(origin.first.id, origin.target), {
+			drawn: drawnTransition,
+			origin
+		});
+	}
+	/** An edited transition's key: its first model transition and the state one of its model transitions arrives at, or `undefined` when its first transition is new. */
+	const editedKey = (edit) => {
+		const [first] = edit.transitions;
+		if (first === void 0 || !transitions.has(first)) return;
+		for (const id of edit.transitions) {
+			const target = transitions.get(id)?.target;
+			if (target !== void 0 && drawn.has(target)) return keyOf(first, target);
+		}
+	};
+	const editedKeys = new Set(edited.transitions.map(editedKey));
+	/** The model transitions arriving at a drawn transition's state: its one transition, or every step from a folded element into that state. */
+	const arriving = (origin) => origin.first.target === origin.target ? [origin.first] : parts.index.arriving(origin.target);
+	const transitionChanges = [];
+	const made = /* @__PURE__ */ new Set();
+	const push = (change) => {
+		const key = JSON.stringify(change);
+		if (!made.has(key)) {
+			made.add(key);
+			transitionChanges.push(change);
+		}
+	};
+	const endsLeft = /* @__PURE__ */ new Set();
+	for (const [key, { origin }] of originals) {
+		if (editedKeys.has(key)) continue;
+		if (origin.first.target === origin.target) push({
+			kind: "removed",
+			transition: origin.first.id,
+			inferred: false
+		});
+		else endsLeft.add(origin.target);
+	}
+	for (const end of endsLeft) for (const tail of parts.index.arriving(end)) push({
+		kind: "removed",
+		transition: tail.id,
+		inferred: true
+	});
+	const editedEnds = /* @__PURE__ */ new Map();
+	const firstAtEnd = (end, kind, value) => {
+		const key = JSON.stringify([end, kind]);
+		const wanted = value === void 0 ? "" : `=${JSON.stringify(value)}`;
+		const already = editedEnds.get(key);
+		if (already === void 0) {
+			editedEnds.set(key, wanted);
+			return true;
+		}
+		if (already !== wanted) throw new Error(`Transitions into "${end}" through the same steps were edited differently (${kind})`);
+		return false;
+	};
+	for (const edit of edited.transitions) {
+		const key = editedKey(edit);
+		const before = key === void 0 ? void 0 : originals.get(key);
+		const [first] = edit.transitions;
+		if (before === void 0) {
+			if (first === void 0 || edit.transitions.length > 1 || transitions.has(first) || edit.through !== void 0) throw new Error(`Transition ${JSON.stringify(edit.transitions)} is neither a transition of the model nor a new transition with a single new id`);
+			push({
+				kind: "added",
+				transition: {
+					id: first,
+					source: edit.source,
+					target: edit.target,
+					...edit.event === void 0 ? {} : { trigger: edit.event },
+					...edit.guard === void 0 ? {} : { guard: edit.guard },
+					...edit.effect === void 0 ? {} : { effect: edit.effect }
+				},
+				inferred: false
+			});
+			continue;
+		}
+		const { origin, drawn: previous } = before;
+		const head = origin.first;
+		const chain = head.target !== origin.target;
+		const tails = arriving(origin);
+		/** The arriving steps to act on for one kind of edit: the transition itself, or the shared steps into the state the first time that kind of edit reaches it. */
+		const acting = (kind, value) => !chain || firstAtEnd(origin.target, kind, value) ? tails : [];
+		if (!chain && (previous.source !== edit.source || previous.target !== edit.target)) push({
+			kind: "rewired",
+			transition: head.id,
+			from: {
+				source: head.source,
+				target: head.target
+			},
+			to: {
+				source: edit.source,
+				target: edit.target
+			},
+			inferred: false
+		});
+		else if (chain) {
+			if (previous.source !== edit.source) push({
+				kind: "rewired",
+				transition: head.id,
+				from: {
+					source: head.source,
+					target: head.target
+				},
+				to: {
+					source: edit.source,
+					target: head.target
+				},
+				inferred: false
+			});
+			for (const tail of previous.target === edit.target ? [] : acting("target", edit.target)) push({
+				kind: "rewired",
+				transition: tail.id,
+				from: {
+					source: tail.source,
+					target: tail.target
+				},
+				to: {
+					source: tail.source,
+					target: edit.target
+				},
+				inferred: true
+			});
+		}
+		for (const tail of previous.event === edit.event ? [] : acting("trigger", edit.event)) push({
+			kind: "changed",
+			field: "trigger",
+			transition: tail.id,
+			from: tail.trigger,
+			to: edit.event,
+			inferred: chain
+		});
+		for (const tail of previous.guard === edit.guard ? [] : acting("guard", edit.guard)) push({
+			kind: "changed",
+			field: "guard",
+			transition: tail.id,
+			from: tail.guard,
+			to: edit.guard,
+			inferred: chain
+		});
+		if (previous.effect !== edit.effect) {
+			const target = elements.get(previous.target);
+			if (target?.kind === "activity" && target.action !== void 0) throw new Error(`The effect of ${JSON.stringify(edit.transitions)} is the action of "${target.id}"; change that activity's action instead`);
+			for (const tail of acting("effect", edit.effect)) push({
+				kind: "changed",
+				field: "effect",
+				transition: tail.id,
+				from: tail.effect,
+				to: edit.effect,
+				inferred: chain
+			});
+		}
+	}
+	return {
+		elements: elementChanges,
+		transitions: transitionChanges,
+		events: []
+	};
+};
+//#endregion
+//#region ../../core/graph/projection/dist/occurrences.js
+/**
+* Items grouped by key, each group kept in its original order and read off one at a time: the projected messages of a sequence diagram grouped by transition, matched against an edited diagram occurrence by occurrence, since a loop repeats a step.
+*
+* Storing an item appends it to its group and reading one advances a position in that group, so building and draining the groups touches each item a constant number of times however often a key repeats.
+*/
+var Occurrences = class {
+	#groups = /* @__PURE__ */ new Map();
+	/**
+	* @param items - The items, in order.
+	* @param keyOf - The key an item is grouped by.
+	* @param observe - Told of each item as it is stored, so a caller can measure the work done.
+	*/
+	constructor(items, keyOf, observe) {
+		for (const item of items) {
+			observe?.(item);
+			const key = keyOf(item);
+			const group = this.#groups.get(key);
+			if (group === void 0) this.#groups.set(key, {
+				items: [item],
+				read: 0
+			});
+			else group.items.push(item);
+		}
+	}
+	/**
+	* The next unread item of a key's group, which is then read.
+	* @param key - The group to read from.
+	* @returns The item, or `undefined` when the key has no group or every item in it has been read.
+	*/
+	next(key) {
+		const group = this.#groups.get(key);
+		const item = group?.items[group.read];
+		if (group !== void 0 && item !== void 0) group.read += 1;
+		return item;
+	}
+	/**
+	* The keys with items still unread, in the order their groups were first stored.
+	* @returns The keys.
+	*/
+	unread() {
+		return [...this.#groups].filter(([, group]) => group.read < group.items.length).map(([key]) => key);
+	}
+};
+//#endregion
+//#region ../../core/graph/projection/dist/inverse-sequence.js
+/** The changes in the order found, each once: a step a loop repeats yields the same change on every pass. */
+const distinct = (changes) => {
+	const seen = /* @__PURE__ */ new Set();
+	return changes.filter((change) => {
+		const key = JSON.stringify(change);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+};
+/**
+* The inverse of `toSequence`: what an edited sequence diagram changes in the model. A sequence diagram shows one path and leaves out who owns which step, so most of what it implies has to be inferred, and every such change is marked `inferred` until it is confirmed.
+*
+* Messages are matched to the projection by transition id, occurrence by occurrence, since a loop repeats a step. For a matched message:
+*
+* - a changed label renames what the label came from, which is certain: the `message` element it draws, the event that triggers the step, or the step's target element;
+* - changed ends on a `message` element readdress it, which is certain;
+* - a changed receiver relanes the step's target and a changed sender relanes its source, both inferred, since the edit could equally mean a different element.
+*
+* A projected message missing from the edit removes its transition, inferred, since it may only have left this scenario. A message with a new transition id is a new step, inferred: it must name the element it arrives at in `element` (an existing element, or a new activity owned by its receiver, labelled with the message), and it leaves from where the latest earlier message to its sender arrived. When the message after it was a step from that same place, that step is rewired to leave from the new element instead, inferred. Lifelines and items are derived from the messages and not read.
+* @param model - The model the diagram was projected from.
+* @param scenario - The scenario it was projected for.
+* @param edited - The projected diagram after editing.
+* @returns The changes, each listed once.
+* @throws Error when the edit cannot be expressed in the model: a model transition added to the diagram that the scenario does not take (a scenario change, not a model change), a changed `element` on a drawn message, a changed sender on a step whose sender comes from an earlier step, or a new message with no `element` or with no earlier message to its sender.
+*/
+const diffSequence = (model, scenario, edited) => {
+	const original = toSequence(model, scenario);
+	const transitions = new Map(model.transitions.map((transition) => [transition.id, transition]));
+	const events = new Map(model.events.map((event) => [event.id, event]));
+	const elementIds = new Set(model.elements.map((element) => element.id));
+	const actors = actorMap(model);
+	const pending = new Occurrences(original.messages, (message) => message.transition);
+	const elementChanges = [];
+	const transitionChanges = [];
+	const eventChanges = [];
+	/** Where the latest edited message to each actor arrived, for placing a new step that actor sends. */
+	const arrivals = /* @__PURE__ */ new Map();
+	/** A new step just placed, and where it left from, so the next drawn step can be rewired after it. */
+	let inserted;
+	for (const message of edited.messages) {
+		const before = pending.next(message.transition);
+		const transition = transitions.get(message.transition);
+		if (before === void 0 || transition === void 0) {
+			if (transition !== void 0) throw new Error(`Transition "${message.transition}" is in the model but not on this scenario; a scenario change is not a model change`);
+			const target = message.element;
+			if (target === void 0) throw new Error(`New message "${message.transition}" must name the element it arrives at in \`element\``);
+			const source = arrivals.get(message.from);
+			if (source === void 0) throw new Error(`New message "${message.transition}" has no earlier message to "${message.from}" to leave from`);
+			if (!elementIds.has(target)) elementChanges.push({
+				kind: "added",
+				element: {
+					kind: "activity",
+					id: target,
+					label: message.label,
+					actor: message.to
+				},
+				inferred: true
+			});
+			transitionChanges.push({
+				kind: "added",
+				transition: {
+					id: message.transition,
+					source,
+					target
+				},
+				inferred: true
+			});
+			arrivals.set(message.to, target);
+			inserted = {
+				from: source,
+				element: target
+			};
+			continue;
+		}
+		if (message.element !== before.element) throw new Error(`Message "${message.transition}" draws "${String(before.element)}"; which element a drawn message is cannot be edited`);
+		if (inserted?.from === transition.source) transitionChanges.push({
+			kind: "rewired",
+			transition: transition.id,
+			from: {
+				source: transition.source,
+				target: transition.target
+			},
+			to: {
+				source: inserted.element,
+				target: transition.target
+			},
+			inferred: true
+		});
+		inserted = void 0;
+		arrivals.set(message.to, before.element ?? transition.target);
+		if (before.label !== message.label) {
+			const trigger = transition.trigger === void 0 ? void 0 : events.get(transition.trigger);
+			if (before.element !== void 0) elementChanges.push({
+				kind: "renamed",
+				element: before.element,
+				from: before.label,
+				to: message.label,
+				inferred: false
+			});
+			else if (trigger === void 0) elementChanges.push({
+				kind: "renamed",
+				element: transition.target,
+				from: before.label,
+				to: message.label,
+				inferred: false
+			});
+			else eventChanges.push({
+				kind: "renamed",
+				event: trigger.id,
+				from: trigger.name,
+				to: message.label,
+				inferred: false
+			});
+		}
+		if (before.element !== void 0) {
+			if (before.from !== message.from || before.to !== message.to) elementChanges.push({
+				kind: "readdressed",
+				element: before.element,
+				from: {
+					from: before.from,
+					to: before.to
+				},
+				to: {
+					from: message.from,
+					to: message.to
+				},
+				inferred: false
+			});
+			continue;
+		}
+		if (before.to !== message.to) elementChanges.push({
+			kind: "relaned",
+			element: transition.target,
+			from: before.to,
+			to: message.to,
+			inferred: true
+		});
+		if (before.from !== message.from) {
+			if (actors.get(transition.source) === void 0) throw new Error(`The sender of "${message.transition}" is whoever reached "${transition.source}"; change the earlier step instead`);
+			elementChanges.push({
+				kind: "relaned",
+				element: transition.source,
+				from: before.from,
+				to: message.from,
+				inferred: true
+			});
+		}
+	}
+	for (const transition of pending.unread()) transitionChanges.push({
+		kind: "removed",
+		transition,
+		inferred: true
+	});
+	return {
+		elements: distinct(elementChanges),
+		transitions: distinct(transitionChanges),
+		events: distinct(eventChanges)
+	};
+};
+//#endregion
+export { ModelParseError, OverlayParseError, UnconfirmedChangeError, UnsupportedConditionError, applyModelDiff, artefactKey, blockedBy, confirmChanges, controlDag, criticalPath, dist_exports as dag, defineModel, deriveStatuses, diffFlowchart, diffSequence, diffStateMachine, diffSwimlane, elementKinds, elementStatusKey, evaluateBranches, explainStatus, fragmentOperators, handoffs, illegalCycles, impact, inputsOf, loopTransitions, messageModes, modelSchema, notations, outputsOf, overlaySchema, overlayStatuses, parseModel, parseOverlay, participantKinds, pseudoRoles, readySet, statusRules, statuses, toFlowchart, toSequence, toStateMachine, toSwimlane, unmetOutputs, validate, validateOverlay, whatIfDone };