@prisma-next/migration-tools 0.5.0-dev.9 → 0.5.1

package/dist/migration-graph-DGNnKDY5.mjs

@@ -0,0 +1,523 @@
+import { S as errorNoTarget, b as errorNoInitialMigration, n as errorAmbiguousTarget, o as errorDuplicateMigrationHash, w as errorSameSourceAndTarget } from "./errors-EPL_9p9f.mjs";
+import { t as EMPTY_CONTRACT_HASH } from "./constants-DWV9_o2Z.mjs";
+import { ifDefined } from "@prisma-next/utils/defined";
+//#region src/queue.ts
+/**
+* FIFO queue with amortised O(1) push and shift.
+*
+* Uses a head-index cursor over a backing array rather than
+* `Array.prototype.shift()`, which is O(n) on V8. Intended for BFS-shaped
+* traversals where the queue is drained in a single pass — it does not
+* reclaim memory for already-shifted items, so it is not suitable for
+* long-lived queues with many push/shift cycles.
+*/
+var Queue = class {
+	items;
+	head = 0;
+	constructor(initial = []) {
+		this.items = [...initial];
+	}
+	push(item) {
+		this.items.push(item);
+	}
+	/**
+	* Remove and return the next item. Caller must check `isEmpty` first —
+	* shifting an empty queue throws.
+	*/
+	shift() {
+		if (this.head >= this.items.length) throw new Error("Queue.shift called on empty queue");
+		return this.items[this.head++];
+	}
+	get isEmpty() {
+		return this.head >= this.items.length;
+	}
+};
+//#endregion
+//#region src/graph-ops.ts
+function* bfs(starts, neighbours, key = (state) => state) {
+	const visited = /* @__PURE__ */ new Set();
+	const parentMap = /* @__PURE__ */ new Map();
+	const queue = new Queue();
+	for (const start of starts) {
+		const k = key(start);
+		if (!visited.has(k)) {
+			visited.add(k);
+			queue.push({
+				state: start,
+				key: k
+			});
+		}
+	}
+	while (!queue.isEmpty) {
+		const { state: current, key: curKey } = queue.shift();
+		const parentInfo = parentMap.get(curKey);
+		yield {
+			state: current,
+			parent: parentInfo?.parent ?? null,
+			incomingEdge: parentInfo?.edge ?? null
+		};
+		for (const { next, edge } of neighbours(current)) {
+			const k = key(next);
+			if (!visited.has(k)) {
+				visited.add(k);
+				parentMap.set(k, {
+					parent: current,
+					edge
+				});
+				queue.push({
+					state: next,
+					key: k
+				});
+			}
+		}
+	}
+}
+//#endregion
+//#region src/migration-graph.ts
+/** Forward-edge neighbours: edge `e` from `n` visits `e.to` next. */
+function forwardNeighbours(graph, node) {
+	return (graph.forwardChain.get(node) ?? []).map((edge) => ({
+		next: edge.to,
+		edge
+	}));
+}
+/**
+* Forward-edge neighbours, sorted by the deterministic tie-break.
+* Used by path-finding so the resulting shortest path is stable across runs.
+*/
+function sortedForwardNeighbours(graph, node) {
+	return [...graph.forwardChain.get(node) ?? []].sort(compareTieBreak).map((edge) => ({
+		next: edge.to,
+		edge
+	}));
+}
+/** Reverse-edge neighbours: edge `e` from `n` visits `e.from` next. */
+function reverseNeighbours(graph, node) {
+	return (graph.reverseChain.get(node) ?? []).map((edge) => ({
+		next: edge.from,
+		edge
+	}));
+}
+function appendEdge(map, key, entry) {
+	const bucket = map.get(key);
+	if (bucket) bucket.push(entry);
+	else map.set(key, [entry]);
+}
+function reconstructGraph(packages) {
+	const nodes = /* @__PURE__ */ new Set();
+	const forwardChain = /* @__PURE__ */ new Map();
+	const reverseChain = /* @__PURE__ */ new Map();
+	const migrationByHash = /* @__PURE__ */ new Map();
+	for (const pkg of packages) {
+		const from = pkg.metadata.from ?? "sha256:empty";
+		const { to } = pkg.metadata;
+		if (from === to) {
+			if (!pkg.ops.some((op) => op.operationClass === "data")) throw errorSameSourceAndTarget(pkg.dirPath, from);
+		}
+		nodes.add(from);
+		nodes.add(to);
+		const migration = {
+			from,
+			to,
+			migrationHash: pkg.metadata.migrationHash,
+			dirName: pkg.dirName,
+			createdAt: pkg.metadata.createdAt,
+			labels: pkg.metadata.labels,
+			invariants: pkg.metadata.providedInvariants
+		};
+		if (migrationByHash.has(migration.migrationHash)) throw errorDuplicateMigrationHash(migration.migrationHash);
+		migrationByHash.set(migration.migrationHash, migration);
+		appendEdge(forwardChain, from, migration);
+		appendEdge(reverseChain, to, migration);
+	}
+	return {
+		nodes,
+		forwardChain,
+		reverseChain,
+		migrationByHash
+	};
+}
+const LABEL_PRIORITY = {
+	main: 0,
+	default: 1,
+	feature: 2
+};
+function labelPriority(labels) {
+	let best = 3;
+	for (const l of labels) {
+		const p = LABEL_PRIORITY[l];
+		if (p !== void 0 && p < best) best = p;
+	}
+	return best;
+}
+function compareTieBreak(a, b) {
+	const lp = labelPriority(a.labels) - labelPriority(b.labels);
+	if (lp !== 0) return lp;
+	const ca = a.createdAt.localeCompare(b.createdAt);
+	if (ca !== 0) return ca;
+	const tc = a.to.localeCompare(b.to);
+	if (tc !== 0) return tc;
+	return a.migrationHash.localeCompare(b.migrationHash);
+}
+function sortedNeighbors(edges) {
+	return [...edges].sort(compareTieBreak);
+}
+/**
+* Find the shortest path from `fromHash` to `toHash` using BFS over the
+* contract-hash graph. Returns the ordered list of edges, or null if no path
+* exists. Returns an empty array when `fromHash === toHash` (no-op).
+*
+* Neighbor ordering is deterministic via the tie-break sort key:
+* label priority → createdAt → to → migrationHash.
+*/
+function findPath(graph, fromHash, toHash) {
+	if (fromHash === toHash) return [];
+	const parents = /* @__PURE__ */ new Map();
+	for (const step of bfs([fromHash], (n) => sortedForwardNeighbours(graph, n))) {
+		if (step.parent !== null && step.incomingEdge !== null) parents.set(step.state, {
+			parent: step.parent,
+			edge: step.incomingEdge
+		});
+		if (step.state === toHash) {
+			const path = [];
+			let cur = toHash;
+			let p = parents.get(cur);
+			while (p) {
+				path.push(p.edge);
+				cur = p.parent;
+				p = parents.get(cur);
+			}
+			path.reverse();
+			return path;
+		}
+	}
+	return null;
+}
+/**
+* Find the shortest path from `fromHash` to `toHash` whose edges collectively
+* cover every invariant in `required`. Returns `null` when no such path exists
+* (either `fromHash`→`toHash` is structurally unreachable, or every reachable
+* path leaves at least one required invariant uncovered). When `required` is
+* empty, delegates to `findPath` so the result is byte-identical for that case.
+*
+* Algorithm: BFS over `(node, coveredSubset)` states with state-level dedup.
+* The covered subset is a `Set<string>` of invariant ids; the state's dedup
+* key is `${node}\0${[...covered].sort().join('\0')}`. State keys distinguish
+* distinct `(node, covered)` tuples regardless of node-name length because
+* `\0` cannot appear in any invariant id (validation rejects whitespace and
+* control chars at authoring time).
+*
+* Neighbour ordering when `required ≠ ∅`: edges covering ≥1 still-needed
+* invariant come first, with `labelPriority → createdAt → to → migrationHash`
+* as the secondary key. The heuristic steers BFS toward the satisfying path;
+* correctness (shortest, deterministic) does not depend on it.
+*/
+function findPathWithInvariants(graph, fromHash, toHash, required) {
+	if (required.size === 0) return findPath(graph, fromHash, toHash);
+	const stateKey = (s) => {
+		if (s.covered.size === 0) return `${s.node}\0`;
+		return `${s.node}\0${[...s.covered].sort().join("\0")}`;
+	};
+	const neighbours = (s) => {
+		const outgoing = graph.forwardChain.get(s.node) ?? [];
+		if (outgoing.length === 0) return [];
+		return [...outgoing].map((edge) => {
+			let useful = false;
+			let next = null;
+			for (const inv of edge.invariants) if (required.has(inv) && !s.covered.has(inv)) {
+				if (next === null) next = new Set(s.covered);
+				next.add(inv);
+				useful = true;
+			}
+			return {
+				edge,
+				useful,
+				nextCovered: next ?? s.covered
+			};
+		}).sort((a, b) => {
+			if (a.useful !== b.useful) return a.useful ? -1 : 1;
+			return compareTieBreak(a.edge, b.edge);
+		}).map(({ edge, nextCovered }) => ({
+			next: {
+				node: edge.to,
+				covered: nextCovered
+			},
+			edge
+		}));
+	};
+	const parents = /* @__PURE__ */ new Map();
+	for (const step of bfs([{
+		node: fromHash,
+		covered: /* @__PURE__ */ new Set()
+	}], neighbours, stateKey)) {
+		const curKey = stateKey(step.state);
+		if (step.parent !== null && step.incomingEdge !== null) parents.set(curKey, {
+			parentKey: stateKey(step.parent),
+			edge: step.incomingEdge
+		});
+		if (step.state.node === toHash && step.state.covered.size === required.size) {
+			const path = [];
+			let cur = curKey;
+			while (cur !== void 0) {
+				const p = parents.get(cur);
+				if (!p) break;
+				path.push(p.edge);
+				cur = p.parentKey;
+			}
+			path.reverse();
+			return path;
+		}
+	}
+	return null;
+}
+/**
+* Reverse-BFS from `toHash` over `reverseChain` to collect every node from
+* which `toHash` is reachable (inclusive of `toHash` itself).
+*/
+function collectNodesReachingTarget(graph, toHash) {
+	const reached = /* @__PURE__ */ new Set();
+	for (const step of bfs([toHash], (n) => reverseNeighbours(graph, n))) reached.add(step.state);
+	return reached;
+}
+/**
+* Find the shortest path from `fromHash` to `toHash` and return structured
+* path-decision metadata for machine-readable output. When `required` is
+* non-empty, the returned path is the shortest one whose edges collectively
+* cover every required invariant.
+*
+* The discriminated return type tells the caller *why* a path could not be
+* found, so the CLI can pick the right structured error without re-running
+* a structural BFS.
+*/
+function findPathWithDecision(graph, fromHash, toHash, options = {}) {
+	const { refName, required = /* @__PURE__ */ new Set() } = options;
+	const requiredInvariants = [...required].sort();
+	if (fromHash === toHash && required.size === 0) return {
+		kind: "ok",
+		decision: {
+			selectedPath: [],
+			fromHash,
+			toHash,
+			alternativeCount: 0,
+			tieBreakReasons: [],
+			requiredInvariants,
+			satisfiedInvariants: [],
+			...ifDefined("refName", refName)
+		}
+	};
+	const path = findPathWithInvariants(graph, fromHash, toHash, required);
+	if (!path) {
+		if (required.size === 0) return { kind: "unreachable" };
+		const structural = findPath(graph, fromHash, toHash);
+		if (structural === null) return { kind: "unreachable" };
+		const coveredByStructural = /* @__PURE__ */ new Set();
+		for (const edge of structural) for (const inv of edge.invariants) if (required.has(inv)) coveredByStructural.add(inv);
+		return {
+			kind: "unsatisfiable",
+			structuralPath: structural,
+			missing: requiredInvariants.filter((id) => !coveredByStructural.has(id))
+		};
+	}
+	const satisfiedInvariants = computeSatisfiedInvariants(required, path);
+	const reachesTarget = collectNodesReachingTarget(graph, toHash);
+	const coveragePrefixes = requiredCoveragePrefixes(required, path);
+	const tieBreakReasons = [];
+	let alternativeCount = 0;
+	for (const [i, edge] of path.entries()) {
+		const outgoing = graph.forwardChain.get(edge.from);
+		if (!outgoing || outgoing.length <= 1) continue;
+		const reachable = outgoing.filter((e) => reachesTarget.has(e.to));
+		if (reachable.length <= 1) continue;
+		let comparisonPool = reachable;
+		if (required.size > 0) {
+			const prefixSet = coveragePrefixes[i];
+			if (prefixSet === void 0) continue;
+			comparisonPool = invariantViableAlternativesAtStep(required, prefixSet, reachable);
+		}
+		alternativeCount += reachable.length - 1;
+		if (sortedNeighbors(reachable)[0]?.migrationHash !== edge.migrationHash) continue;
+		if (!reachable.some((e) => e.migrationHash !== edge.migrationHash)) continue;
+		const sortedViable = sortedNeighbors(comparisonPool);
+		if (sortedViable.length > 1 && sortedViable[0]?.migrationHash === edge.migrationHash && sortedViable.some((e) => e.migrationHash !== edge.migrationHash)) tieBreakReasons.push(`at ${edge.from}: ${comparisonPool.length} candidates, selected by tie-break`);
+	}
+	return {
+		kind: "ok",
+		decision: {
+			selectedPath: path,
+			fromHash,
+			toHash,
+			alternativeCount,
+			tieBreakReasons,
+			requiredInvariants,
+			satisfiedInvariants,
+			...ifDefined("refName", refName)
+		}
+	};
+}
+function computeSatisfiedInvariants(required, path) {
+	if (required.size === 0) return [];
+	const covered = /* @__PURE__ */ new Set();
+	for (const edge of path) for (const inv of edge.invariants) if (required.has(inv)) covered.add(inv);
+	return [...covered].sort();
+}
+/**
+* For each edge on path, invariant coverage accumulated from earlier edges only —
+* `(required ∩ ∪_{j<i} path[j].invariants)` represented as cumulative set along `required`,
+* keyed as "full set of required ids satisfied before taking path[i]".
+*/
+function requiredCoveragePrefixes(required, path) {
+	const prefixes = [];
+	const acc = /* @__PURE__ */ new Set();
+	for (const edge of path) {
+		prefixes.push(new Set(acc));
+		for (const inv of edge.invariants) if (required.has(inv)) acc.add(inv);
+	}
+	return prefixes;
+}
+function invariantViableAlternativesAtStep(required, coverageBeforeTakingEdge, outgoing) {
+	if (required.size === 0) return [...outgoing];
+	return outgoing.filter((e) => [...required].every((id) => coverageBeforeTakingEdge.has(id) || e.invariants.includes(id)));
+}
+/**
+* Walk ancestors of each branch tip back to find the last node
+* that appears on all paths. Returns `fromHash` if no shared ancestor is found.
+*/
+function findDivergencePoint(graph, fromHash, leaves) {
+	const ancestorSets = leaves.map((leaf) => {
+		const ancestors = /* @__PURE__ */ new Set();
+		for (const step of bfs([leaf], (n) => reverseNeighbours(graph, n))) ancestors.add(step.state);
+		return ancestors;
+	});
+	const commonAncestors = [...ancestorSets[0] ?? []].filter((node) => ancestorSets.every((s) => s.has(node)));
+	let deepest = fromHash;
+	let deepestDepth = -1;
+	for (const ancestor of commonAncestors) {
+		const path = findPath(graph, fromHash, ancestor);
+		const depth = path ? path.length : 0;
+		if (depth > deepestDepth) {
+			deepestDepth = depth;
+			deepest = ancestor;
+		}
+	}
+	return deepest;
+}
+/**
+* Find all branch tips (nodes with no outgoing edges) reachable from
+* `fromHash` via forward edges.
+*/
+function findReachableLeaves(graph, fromHash) {
+	const leaves = [];
+	for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n))) if (!graph.forwardChain.get(step.state)?.length) leaves.push(step.state);
+	return leaves;
+}
+/**
+* Find the target contract hash of the migration graph reachable from
+* EMPTY_CONTRACT_HASH. Returns `null` for a graph that has no target
+* state (either empty, or containing only the root with no outgoing
+* edges). Throws NO_INITIAL_MIGRATION if the graph has nodes but none
+* originate from the empty hash, and AMBIGUOUS_TARGET if multiple
+* branch tips exist.
+*/
+function findLeaf(graph) {
+	if (graph.nodes.size === 0) return null;
+	if (!graph.nodes.has("sha256:empty")) throw errorNoInitialMigration([...graph.nodes]);
+	const leaves = findReachableLeaves(graph, EMPTY_CONTRACT_HASH);
+	if (leaves.length === 0) {
+		const reachable = [...graph.nodes].filter((n) => n !== EMPTY_CONTRACT_HASH);
+		if (reachable.length > 0) throw errorNoTarget(reachable);
+		return null;
+	}
+	if (leaves.length > 1) {
+		const divergencePoint = findDivergencePoint(graph, EMPTY_CONTRACT_HASH, leaves);
+		throw errorAmbiguousTarget(leaves, {
+			divergencePoint,
+			branches: leaves.map((tip) => {
+				return {
+					tip,
+					edges: (findPath(graph, divergencePoint, tip) ?? []).map((e) => ({
+						dirName: e.dirName,
+						from: e.from,
+						to: e.to
+					}))
+				};
+			})
+		});
+	}
+	return leaves[0];
+}
+/**
+* Find the latest migration entry by traversing from EMPTY_CONTRACT_HASH
+* to the single target. Returns null for an empty graph.
+* Throws AMBIGUOUS_TARGET if the graph has multiple branch tips.
+*/
+function findLatestMigration(graph) {
+	const leafHash = findLeaf(graph);
+	if (leafHash === null) return null;
+	return findPath(graph, "sha256:empty", leafHash)?.at(-1) ?? null;
+}
+function detectCycles(graph) {
+	const WHITE = 0;
+	const GRAY = 1;
+	const BLACK = 2;
+	const color = /* @__PURE__ */ new Map();
+	const parentMap = /* @__PURE__ */ new Map();
+	const cycles = [];
+	for (const node of graph.nodes) color.set(node, WHITE);
+	const stack = [];
+	function pushFrame(u) {
+		color.set(u, GRAY);
+		stack.push({
+			node: u,
+			outgoing: graph.forwardChain.get(u) ?? [],
+			index: 0
+		});
+	}
+	for (const root of graph.nodes) {
+		if (color.get(root) !== WHITE) continue;
+		parentMap.set(root, null);
+		pushFrame(root);
+		while (stack.length > 0) {
+			const frame = stack[stack.length - 1];
+			if (frame.index >= frame.outgoing.length) {
+				color.set(frame.node, BLACK);
+				stack.pop();
+				continue;
+			}
+			const v = frame.outgoing[frame.index++].to;
+			const vColor = color.get(v);
+			if (vColor === GRAY) {
+				const cycle = [v];
+				let cur = frame.node;
+				while (cur !== v) {
+					cycle.push(cur);
+					cur = parentMap.get(cur) ?? v;
+				}
+				cycle.reverse();
+				cycles.push(cycle);
+			} else if (vColor === WHITE) {
+				parentMap.set(v, frame.node);
+				pushFrame(v);
+			}
+		}
+	}
+	return cycles;
+}
+function detectOrphans(graph) {
+	if (graph.nodes.size === 0) return [];
+	const reachable = /* @__PURE__ */ new Set();
+	const startNodes = [];
+	if (graph.forwardChain.has("sha256:empty")) startNodes.push(EMPTY_CONTRACT_HASH);
+	else {
+		const allTargets = /* @__PURE__ */ new Set();
+		for (const edges of graph.forwardChain.values()) for (const edge of edges) allTargets.add(edge.to);
+		for (const node of graph.nodes) if (!allTargets.has(node)) startNodes.push(node);
+	}
+	for (const step of bfs(startNodes, (n) => forwardNeighbours(graph, n))) reachable.add(step.state);
+	const orphans = [];
+	for (const [from, migrations] of graph.forwardChain) if (!reachable.has(from)) orphans.push(...migrations);
+	return orphans;
+}
+//#endregion
+export { findPath as a, findReachableLeaves as c, findLeaf as i, reconstructGraph as l, detectOrphans as n, findPathWithDecision as o, findLatestMigration as r, findPathWithInvariants as s, detectCycles as t };
+
+//# sourceMappingURL=migration-graph-DGNnKDY5.mjs.map

package/dist/migration-graph-DGNnKDY5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-graph-DGNnKDY5.mjs","names":[],"sources":["../src/queue.ts","../src/graph-ops.ts","../src/migration-graph.ts"],"sourcesContent":["/**\n * FIFO queue with amortised O(1) push and shift.\n *\n * Uses a head-index cursor over a backing array rather than\n * `Array.prototype.shift()`, which is O(n) on V8. Intended for BFS-shaped\n * traversals where the queue is drained in a single pass — it does not\n * reclaim memory for already-shifted items, so it is not suitable for\n * long-lived queues with many push/shift cycles.\n */\nexport class Queue<T> {\n  private readonly items: T[];\n  private head = 0;\n\n  constructor(initial: Iterable<T> = []) {\n    this.items = [...initial];\n  }\n\n  push(item: T): void {\n    this.items.push(item);\n  }\n\n  /**\n   * Remove and return the next item. Caller must check `isEmpty` first —\n   * shifting an empty queue throws.\n   */\n  shift(): T {\n    if (this.head >= this.items.length) {\n      throw new Error('Queue.shift called on empty queue');\n    }\n    // biome-ignore lint/style/noNonNullAssertion: bounds-checked on the line above\n    return this.items[this.head++]!;\n  }\n\n  get isEmpty(): boolean {\n    return this.head >= this.items.length;\n  }\n}\n","import { Queue } from './queue';\n\n/**\n * One step of a BFS traversal.\n *\n * `parent` and `incomingEdge` are `null` for start states — they were not\n * reached via any edge. For every other state they record the predecessor\n * state and the edge by which this state was first reached.\n *\n * `state` is the BFS state, most often a string (graph node identifier) but\n * can be a composite object. The string overload keeps the common case\n * ergonomic; the generic overload accepts a caller-supplied `key` function\n * that produces a stable equality key for dedup.\n */\nexport interface BfsStep<S, E> {\n  readonly state: S;\n  readonly parent: S | null;\n  readonly incomingEdge: E | null;\n}\n\n/**\n * Generic breadth-first traversal.\n *\n * Direction (forward/reverse) is expressed by the caller's `neighbours`\n * closure: return `{ next, edge }` pairs where `next` is the state to visit\n * next and `edge` is the edge that connects them. Callers that don't need\n * path reconstruction can ignore the `parent`/`incomingEdge` fields of each\n * yielded step.\n *\n * Ordering — when the result needs to be deterministic (path-finding) the\n * caller is responsible for sorting inside `neighbours`; this generator\n * does not impose an ordering hook of its own. State-dependent orderings\n * have full access to the source state inside the closure.\n *\n * Stops are intrinsic — callers `break` out of the `for..of` loop when\n * they've found what they're looking for.\n */\nexport function bfs<E>(\n  starts: Iterable<string>,\n  neighbours: (state: string) => Iterable<{ next: string; edge: E }>,\n): Generator<BfsStep<string, E>>;\nexport function bfs<S, E>(\n  starts: Iterable<S>,\n  neighbours: (state: S) => Iterable<{ next: S; edge: E }>,\n  key: (state: S) => string,\n): Generator<BfsStep<S, E>>;\nexport function* bfs<S, E>(\n  starts: Iterable<S>,\n  neighbours: (state: S) => Iterable<{ next: S; edge: E }>,\n  // Identity default for the string overload. TypeScript can't express\n  // \"default applies only when S = string\", so this cast bridges the\n  // generic implementation signature to the public overloads — which\n  // guarantee `key` is omitted only when S = string at the call site.\n  key: (state: S) => string = (state) => state as unknown as string,\n): Generator<BfsStep<S, E>> {\n  // Queue entries carry the state alongside its key so we don't recompute\n  // key() twice per visit (once on dedup, once on parent lookup). Composite\n  // keys can be non-trivial to compute; string-overload callers pay nothing\n  // since key() is identity there.\n  interface Entry {\n    readonly state: S;\n    readonly key: string;\n  }\n  const visited = new Set<string>();\n  const parentMap = new Map<string, { parent: S; edge: E }>();\n  const queue = new Queue<Entry>();\n  for (const start of starts) {\n    const k = key(start);\n    if (!visited.has(k)) {\n      visited.add(k);\n      queue.push({ state: start, key: k });\n    }\n  }\n  while (!queue.isEmpty) {\n    const { state: current, key: curKey } = queue.shift();\n    const parentInfo = parentMap.get(curKey);\n    yield {\n      state: current,\n      parent: parentInfo?.parent ?? null,\n      incomingEdge: parentInfo?.edge ?? null,\n    };\n\n    for (const { next, edge } of neighbours(current)) {\n      const k = key(next);\n      if (!visited.has(k)) {\n        visited.add(k);\n        parentMap.set(k, { parent: current, edge });\n        queue.push({ state: next, key: k });\n      }\n    }\n  }\n}\n","import { ifDefined } from '@prisma-next/utils/defined';\nimport { EMPTY_CONTRACT_HASH } from './constants';\nimport {\n  errorAmbiguousTarget,\n  errorDuplicateMigrationHash,\n  errorNoInitialMigration,\n  errorNoTarget,\n  errorSameSourceAndTarget,\n} from './errors';\nimport type { MigrationEdge, MigrationGraph } from './graph';\nimport { bfs } from './graph-ops';\nimport type { OnDiskMigrationPackage } from './package';\n\n/** Forward-edge neighbours: edge `e` from `n` visits `e.to` next. */\nfunction forwardNeighbours(graph: MigrationGraph, node: string) {\n  return (graph.forwardChain.get(node) ?? []).map((edge) => ({ next: edge.to, edge }));\n}\n\n/**\n * Forward-edge neighbours, sorted by the deterministic tie-break.\n * Used by path-finding so the resulting shortest path is stable across runs.\n */\nfunction sortedForwardNeighbours(graph: MigrationGraph, node: string) {\n  const edges = graph.forwardChain.get(node) ?? [];\n  return [...edges].sort(compareTieBreak).map((edge) => ({ next: edge.to, edge }));\n}\n\n/** Reverse-edge neighbours: edge `e` from `n` visits `e.from` next. */\nfunction reverseNeighbours(graph: MigrationGraph, node: string) {\n  return (graph.reverseChain.get(node) ?? []).map((edge) => ({ next: edge.from, edge }));\n}\n\nfunction appendEdge(map: Map<string, MigrationEdge[]>, key: string, entry: MigrationEdge): void {\n  const bucket = map.get(key);\n  if (bucket) bucket.push(entry);\n  else map.set(key, [entry]);\n}\n\nexport function reconstructGraph(packages: readonly OnDiskMigrationPackage[]): MigrationGraph {\n  const nodes = new Set<string>();\n  const forwardChain = new Map<string, MigrationEdge[]>();\n  const reverseChain = new Map<string, MigrationEdge[]>();\n  const migrationByHash = new Map<string, MigrationEdge>();\n\n  for (const pkg of packages) {\n    // Manifest `from` is `string | null` (null = baseline). The graph layer\n    // is the marker/path layer where \"no prior state\" is encoded as the\n    // EMPTY_CONTRACT_HASH sentinel; bridge here so pathfinding stays string-\n    // keyed.\n    const from = pkg.metadata.from ?? EMPTY_CONTRACT_HASH;\n    const { to } = pkg.metadata;\n\n    if (from === to) {\n      const hasDataOp = pkg.ops.some((op) => op.operationClass === 'data');\n      if (!hasDataOp) {\n        throw errorSameSourceAndTarget(pkg.dirPath, from);\n      }\n    }\n\n    nodes.add(from);\n    nodes.add(to);\n\n    const migration: MigrationEdge = {\n      from,\n      to,\n      migrationHash: pkg.metadata.migrationHash,\n      dirName: pkg.dirName,\n      createdAt: pkg.metadata.createdAt,\n      labels: pkg.metadata.labels,\n      invariants: pkg.metadata.providedInvariants,\n    };\n\n    if (migrationByHash.has(migration.migrationHash)) {\n      throw errorDuplicateMigrationHash(migration.migrationHash);\n    }\n    migrationByHash.set(migration.migrationHash, migration);\n\n    appendEdge(forwardChain, from, migration);\n    appendEdge(reverseChain, to, migration);\n  }\n\n  return { nodes, forwardChain, reverseChain, migrationByHash };\n}\n\n// ---------------------------------------------------------------------------\n// Deterministic tie-breaking for BFS neighbour order.\n// Used by path-finders only; not a general-purpose utility.\n// Ordering: label priority → createdAt → to → migrationHash.\n// ---------------------------------------------------------------------------\n\nconst LABEL_PRIORITY: Record<string, number> = { main: 0, default: 1, feature: 2 };\n\nfunction labelPriority(labels: readonly string[]): number {\n  let best = 3;\n  for (const l of labels) {\n    const p = LABEL_PRIORITY[l];\n    if (p !== undefined && p < best) best = p;\n  }\n  return best;\n}\n\nfunction compareTieBreak(a: MigrationEdge, b: MigrationEdge): number {\n  const lp = labelPriority(a.labels) - labelPriority(b.labels);\n  if (lp !== 0) return lp;\n  const ca = a.createdAt.localeCompare(b.createdAt);\n  if (ca !== 0) return ca;\n  const tc = a.to.localeCompare(b.to);\n  if (tc !== 0) return tc;\n  return a.migrationHash.localeCompare(b.migrationHash);\n}\n\nfunction sortedNeighbors(edges: readonly MigrationEdge[]): readonly MigrationEdge[] {\n  return [...edges].sort(compareTieBreak);\n}\n\n/**\n * Find the shortest path from `fromHash` to `toHash` using BFS over the\n * contract-hash graph. Returns the ordered list of edges, or null if no path\n * exists. Returns an empty array when `fromHash === toHash` (no-op).\n *\n * Neighbor ordering is deterministic via the tie-break sort key:\n * label priority → createdAt → to → migrationHash.\n */\nexport function findPath(\n  graph: MigrationGraph,\n  fromHash: string,\n  toHash: string,\n): readonly MigrationEdge[] | null {\n  if (fromHash === toHash) return [];\n\n  const parents = new Map<string, { parent: string; edge: MigrationEdge }>();\n  for (const step of bfs([fromHash], (n) => sortedForwardNeighbours(graph, n))) {\n    if (step.parent !== null && step.incomingEdge !== null) {\n      parents.set(step.state, { parent: step.parent, edge: step.incomingEdge });\n    }\n    if (step.state === toHash) {\n      const path: MigrationEdge[] = [];\n      let cur = toHash;\n      let p = parents.get(cur);\n      while (p) {\n        path.push(p.edge);\n        cur = p.parent;\n        p = parents.get(cur);\n      }\n      path.reverse();\n      return path;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Find the shortest path from `fromHash` to `toHash` whose edges collectively\n * cover every invariant in `required`. Returns `null` when no such path exists\n * (either `fromHash`→`toHash` is structurally unreachable, or every reachable\n * path leaves at least one required invariant uncovered). When `required` is\n * empty, delegates to `findPath` so the result is byte-identical for that case.\n *\n * Algorithm: BFS over `(node, coveredSubset)` states with state-level dedup.\n * The covered subset is a `Set<string>` of invariant ids; the state's dedup\n * key is `${node}\\0${[...covered].sort().join('\\0')}`. State keys distinguish\n * distinct `(node, covered)` tuples regardless of node-name length because\n * `\\0` cannot appear in any invariant id (validation rejects whitespace and\n * control chars at authoring time).\n *\n * Neighbour ordering when `required ≠ ∅`: edges covering ≥1 still-needed\n * invariant come first, with `labelPriority → createdAt → to → migrationHash`\n * as the secondary key. The heuristic steers BFS toward the satisfying path;\n * correctness (shortest, deterministic) does not depend on it.\n */\nexport function findPathWithInvariants(\n  graph: MigrationGraph,\n  fromHash: string,\n  toHash: string,\n  required: ReadonlySet<string>,\n): readonly MigrationEdge[] | null {\n  if (required.size === 0) {\n    return findPath(graph, fromHash, toHash);\n  }\n\n  interface InvState {\n    readonly node: string;\n    readonly covered: ReadonlySet<string>;\n  }\n  // `\\0` is a safe segment separator: `validateInvariantId` rejects any id\n  // containing whitespace or control characters (NUL is U+0000), and node\n  // hashes are hex strings. Distinct `(node, covered)` tuples therefore\n  // map to distinct strings. If `validateInvariantId` is ever relaxed,\n  // re-confirm dedup correctness here.\n  const stateKey = (s: InvState): string => {\n    if (s.covered.size === 0) return `${s.node}\\0`;\n    return `${s.node}\\0${[...s.covered].sort().join('\\0')}`;\n  };\n\n  const neighbours = (s: InvState): Iterable<{ next: InvState; edge: MigrationEdge }> => {\n    const outgoing = graph.forwardChain.get(s.node) ?? [];\n    if (outgoing.length === 0) return [];\n    return [...outgoing]\n      .map((edge) => {\n        let useful = false;\n        let next: Set<string> | null = null;\n        for (const inv of edge.invariants) {\n          if (required.has(inv) && !s.covered.has(inv)) {\n            if (next === null) next = new Set(s.covered);\n            next.add(inv);\n            useful = true;\n          }\n        }\n        return { edge, useful, nextCovered: next ?? s.covered };\n      })\n      .sort((a, b) => {\n        if (a.useful !== b.useful) return a.useful ? -1 : 1;\n        return compareTieBreak(a.edge, b.edge);\n      })\n      .map(({ edge, nextCovered }) => ({\n        next: { node: edge.to, covered: nextCovered },\n        edge,\n      }));\n  };\n\n  // Path reconstruction is consumer-side, keyed on stateKey, same shape as\n  // findPath's parents map.\n  const parents = new Map<string, { parentKey: string; edge: MigrationEdge }>();\n  for (const step of bfs<InvState, MigrationEdge>(\n    [{ node: fromHash, covered: new Set() }],\n    neighbours,\n    stateKey,\n  )) {\n    const curKey = stateKey(step.state);\n    if (step.parent !== null && step.incomingEdge !== null) {\n      parents.set(curKey, { parentKey: stateKey(step.parent), edge: step.incomingEdge });\n    }\n    if (step.state.node === toHash && step.state.covered.size === required.size) {\n      const path: MigrationEdge[] = [];\n      let cur: string | undefined = curKey;\n      while (cur !== undefined) {\n        const p = parents.get(cur);\n        if (!p) break;\n        path.push(p.edge);\n        cur = p.parentKey;\n      }\n      path.reverse();\n      return path;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Reverse-BFS from `toHash` over `reverseChain` to collect every node from\n * which `toHash` is reachable (inclusive of `toHash` itself).\n */\nfunction collectNodesReachingTarget(graph: MigrationGraph, toHash: string): Set<string> {\n  const reached = new Set<string>();\n  for (const step of bfs([toHash], (n) => reverseNeighbours(graph, n))) {\n    reached.add(step.state);\n  }\n  return reached;\n}\n\nexport interface PathDecision {\n  readonly selectedPath: readonly MigrationEdge[];\n  readonly fromHash: string;\n  readonly toHash: string;\n  readonly alternativeCount: number;\n  readonly tieBreakReasons: readonly string[];\n  readonly refName?: string;\n  /** The caller-supplied required invariant set, sorted ascending. */\n  readonly requiredInvariants: readonly string[];\n  /**\n   * The subset of `requiredInvariants` actually covered by edges on\n   * `selectedPath`. Always a subset of `requiredInvariants` (when the path\n   * is satisfying, equal to it); always derived from `selectedPath`.\n   */\n  readonly satisfiedInvariants: readonly string[];\n}\n\n/**\n * Outcome of {@link findPathWithDecision}. The pathfinder distinguishes\n * three cases up front so callers don't re-derive structural reachability:\n *\n * - `ok` — a path covering `required` exists; `decision` carries the\n *   selection metadata and per-edge invariants.\n * - `unreachable` — `from`→`to` has no structural path. Mapped by callers\n *   to the existing no-path / `NO_TARGET` diagnostic.\n * - `unsatisfiable` — `from`→`to` is structurally reachable but no path\n *   covers every required invariant. `structuralPath` is the\n *   `findPath(graph, from, to)` result, included so callers don't have to\n *   recompute it when raising `MIGRATION.NO_INVARIANT_PATH`. `missing` is\n *   the subset of `required` that the structural path does *not* cover —\n *   correctly accounts for partial coverage when some required invariants\n *   are met by the fallback path. Only emitted when `required` is\n *   non-empty.\n */\nexport type FindPathOutcome =\n  | { readonly kind: 'ok'; readonly decision: PathDecision }\n  | { readonly kind: 'unreachable' }\n  | {\n      readonly kind: 'unsatisfiable';\n      readonly structuralPath: readonly MigrationEdge[];\n      readonly missing: readonly string[];\n    };\n\n/**\n * Routing context for {@link findPathWithDecision}. Both fields are optional;\n * `refName` is only used to decorate the resulting `PathDecision` for the\n * JSON envelope, and `required` defaults to an empty set (purely structural\n * routing). They are passed via a single options object so the call sites\n * cannot silently swap two adjacent string parameters.\n */\nexport interface FindPathWithDecisionOptions {\n  readonly refName?: string;\n  readonly required?: ReadonlySet<string>;\n}\n\n/**\n * Find the shortest path from `fromHash` to `toHash` and return structured\n * path-decision metadata for machine-readable output. When `required` is\n * non-empty, the returned path is the shortest one whose edges collectively\n * cover every required invariant.\n *\n * The discriminated return type tells the caller *why* a path could not be\n * found, so the CLI can pick the right structured error without re-running\n * a structural BFS.\n */\nexport function findPathWithDecision(\n  graph: MigrationGraph,\n  fromHash: string,\n  toHash: string,\n  options: FindPathWithDecisionOptions = {},\n): FindPathOutcome {\n  const { refName, required = new Set<string>() } = options;\n  const requiredInvariants = [...required].sort();\n\n  if (fromHash === toHash && required.size === 0) {\n    return {\n      kind: 'ok',\n      decision: {\n        selectedPath: [],\n        fromHash,\n        toHash,\n        alternativeCount: 0,\n        tieBreakReasons: [],\n        requiredInvariants,\n        satisfiedInvariants: [],\n        ...ifDefined('refName', refName),\n      },\n    };\n  }\n\n  const path = findPathWithInvariants(graph, fromHash, toHash, required);\n  if (!path) {\n    if (required.size === 0) {\n      return { kind: 'unreachable' };\n    }\n    const structural = findPath(graph, fromHash, toHash);\n    if (structural === null) {\n      return { kind: 'unreachable' };\n    }\n    const coveredByStructural = new Set<string>();\n    for (const edge of structural) {\n      for (const inv of edge.invariants) {\n        if (required.has(inv)) coveredByStructural.add(inv);\n      }\n    }\n    const missing = requiredInvariants.filter((id) => !coveredByStructural.has(id));\n    return { kind: 'unsatisfiable', structuralPath: structural, missing };\n  }\n\n  const satisfiedInvariants = computeSatisfiedInvariants(required, path);\n\n  // Single reverse BFS marks every node from which `toHash` is reachable.\n  // Replaces a per-edge `findPath(e.to, toHash)` call inside the loop below,\n  // which made the whole function O(|path| · (V + E)) instead of O(V + E).\n  const reachesTarget = collectNodesReachingTarget(graph, toHash);\n  const coveragePrefixes = requiredCoveragePrefixes(required, path);\n\n  const tieBreakReasons: string[] = [];\n  let alternativeCount = 0;\n\n  for (const [i, edge] of path.entries()) {\n    const outgoing = graph.forwardChain.get(edge.from);\n    if (!outgoing || outgoing.length <= 1) continue;\n    const reachable = outgoing.filter((e) => reachesTarget.has(e.to));\n    if (reachable.length <= 1) continue;\n\n    let comparisonPool: readonly MigrationEdge[] = reachable;\n    if (required.size > 0) {\n      // coveragePrefixes is built one-per-edge from path, so the index is\n      // always in range here; the explicit guard keeps the type narrowed\n      // without a non-null assertion.\n      const prefixSet = coveragePrefixes[i];\n      if (prefixSet === undefined) continue;\n      comparisonPool = invariantViableAlternativesAtStep(required, prefixSet, reachable);\n    }\n\n    alternativeCount += reachable.length - 1;\n    const sorted = sortedNeighbors(reachable);\n    if (sorted[0]?.migrationHash !== edge.migrationHash) continue;\n    if (!reachable.some((e) => e.migrationHash !== edge.migrationHash)) continue;\n\n    const sortedViable = sortedNeighbors(comparisonPool);\n    if (\n      sortedViable.length > 1 &&\n      sortedViable[0]?.migrationHash === edge.migrationHash &&\n      sortedViable.some((e) => e.migrationHash !== edge.migrationHash)\n    ) {\n      tieBreakReasons.push(\n        `at ${edge.from}: ${comparisonPool.length} candidates, selected by tie-break`,\n      );\n    }\n  }\n\n  return {\n    kind: 'ok',\n    decision: {\n      selectedPath: path,\n      fromHash,\n      toHash,\n      alternativeCount,\n      tieBreakReasons,\n      requiredInvariants,\n      satisfiedInvariants,\n      ...ifDefined('refName', refName),\n    },\n  };\n}\n\nfunction computeSatisfiedInvariants(\n  required: ReadonlySet<string>,\n  path: readonly MigrationEdge[],\n): readonly string[] {\n  if (required.size === 0) return [];\n  const covered = new Set<string>();\n  for (const edge of path) {\n    for (const inv of edge.invariants) {\n      if (required.has(inv)) covered.add(inv);\n    }\n  }\n  return [...covered].sort();\n}\n\n/**\n * For each edge on path, invariant coverage accumulated from earlier edges only —\n * `(required ∩ ∪_{j<i} path[j].invariants)` represented as cumulative set along `required`,\n * keyed as \"full set of required ids satisfied before taking path[i]\".\n */\nfunction requiredCoveragePrefixes(\n  required: ReadonlySet<string>,\n  path: readonly MigrationEdge[],\n): readonly ReadonlySet<string>[] {\n  const prefixes: ReadonlySet<string>[] = [];\n  const acc = new Set<string>();\n  for (const edge of path) {\n    prefixes.push(new Set(acc));\n    for (const inv of edge.invariants) {\n      if (required.has(inv)) acc.add(inv);\n    }\n  }\n  return prefixes;\n}\n\nfunction invariantViableAlternativesAtStep(\n  required: ReadonlySet<string>,\n  coverageBeforeTakingEdge: ReadonlySet<string>,\n  outgoing: readonly MigrationEdge[],\n): readonly MigrationEdge[] {\n  if (required.size === 0) return [...outgoing];\n  return outgoing.filter((e) =>\n    [...required].every((id) => coverageBeforeTakingEdge.has(id) || e.invariants.includes(id)),\n  );\n}\n\n/**\n * Walk ancestors of each branch tip back to find the last node\n * that appears on all paths. Returns `fromHash` if no shared ancestor is found.\n */\nfunction findDivergencePoint(\n  graph: MigrationGraph,\n  fromHash: string,\n  leaves: readonly string[],\n): string {\n  const ancestorSets = leaves.map((leaf) => {\n    const ancestors = new Set<string>();\n    for (const step of bfs([leaf], (n) => reverseNeighbours(graph, n))) {\n      ancestors.add(step.state);\n    }\n    return ancestors;\n  });\n\n  const commonAncestors = [...(ancestorSets[0] ?? [])].filter((node) =>\n    ancestorSets.every((s) => s.has(node)),\n  );\n\n  let deepest = fromHash;\n  let deepestDepth = -1;\n  for (const ancestor of commonAncestors) {\n    const path = findPath(graph, fromHash, ancestor);\n    const depth = path ? path.length : 0;\n    if (depth > deepestDepth) {\n      deepestDepth = depth;\n      deepest = ancestor;\n    }\n  }\n  return deepest;\n}\n\n/**\n * Find all branch tips (nodes with no outgoing edges) reachable from\n * `fromHash` via forward edges.\n */\nexport function findReachableLeaves(graph: MigrationGraph, fromHash: string): readonly string[] {\n  const leaves: string[] = [];\n  for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n))) {\n    if (!graph.forwardChain.get(step.state)?.length) {\n      leaves.push(step.state);\n    }\n  }\n  return leaves;\n}\n\n/**\n * Find the target contract hash of the migration graph reachable from\n * EMPTY_CONTRACT_HASH. Returns `null` for a graph that has no target\n * state (either empty, or containing only the root with no outgoing\n * edges). Throws NO_INITIAL_MIGRATION if the graph has nodes but none\n * originate from the empty hash, and AMBIGUOUS_TARGET if multiple\n * branch tips exist.\n */\nexport function findLeaf(graph: MigrationGraph): string | null {\n  if (graph.nodes.size === 0) {\n    return null;\n  }\n\n  if (!graph.nodes.has(EMPTY_CONTRACT_HASH)) {\n    throw errorNoInitialMigration([...graph.nodes]);\n  }\n\n  const leaves = findReachableLeaves(graph, EMPTY_CONTRACT_HASH);\n\n  if (leaves.length === 0) {\n    const reachable = [...graph.nodes].filter((n) => n !== EMPTY_CONTRACT_HASH);\n    if (reachable.length > 0) {\n      throw errorNoTarget(reachable);\n    }\n    return null;\n  }\n\n  if (leaves.length > 1) {\n    const divergencePoint = findDivergencePoint(graph, EMPTY_CONTRACT_HASH, leaves);\n    const branches = leaves.map((tip) => {\n      const path = findPath(graph, divergencePoint, tip);\n      return {\n        tip,\n        edges: (path ?? []).map((e) => ({ dirName: e.dirName, from: e.from, to: e.to })),\n      };\n    });\n    throw errorAmbiguousTarget(leaves, { divergencePoint, branches });\n  }\n\n  // biome-ignore lint/style/noNonNullAssertion: leaves.length is neither 0 nor >1 per the branches above, so exactly one leaf remains\n  return leaves[0]!;\n}\n\n/**\n * Find the latest migration entry by traversing from EMPTY_CONTRACT_HASH\n * to the single target. Returns null for an empty graph.\n * Throws AMBIGUOUS_TARGET if the graph has multiple branch tips.\n */\nexport function findLatestMigration(graph: MigrationGraph): MigrationEdge | null {\n  const leafHash = findLeaf(graph);\n  if (leafHash === null) return null;\n\n  const path = findPath(graph, EMPTY_CONTRACT_HASH, leafHash);\n  return path?.at(-1) ?? null;\n}\n\nexport function detectCycles(graph: MigrationGraph): readonly string[][] {\n  const WHITE = 0;\n  const GRAY = 1;\n  const BLACK = 2;\n\n  const color = new Map<string, number>();\n  const parentMap = new Map<string, string | null>();\n  const cycles: string[][] = [];\n\n  for (const node of graph.nodes) {\n    color.set(node, WHITE);\n  }\n\n  // Iterative three-color DFS. A frame is (node, outgoing edges, next-index).\n  interface Frame {\n    node: string;\n    outgoing: readonly MigrationEdge[];\n    index: number;\n  }\n  const stack: Frame[] = [];\n\n  function pushFrame(u: string): void {\n    color.set(u, GRAY);\n    stack.push({ node: u, outgoing: graph.forwardChain.get(u) ?? [], index: 0 });\n  }\n\n  for (const root of graph.nodes) {\n    if (color.get(root) !== WHITE) continue;\n    parentMap.set(root, null);\n    pushFrame(root);\n\n    while (stack.length > 0) {\n      // biome-ignore lint/style/noNonNullAssertion: stack.length > 0 should guarantee that this cannot be undefined\n      const frame = stack[stack.length - 1]!;\n      if (frame.index >= frame.outgoing.length) {\n        color.set(frame.node, BLACK);\n        stack.pop();\n        continue;\n      }\n      // biome-ignore lint/style/noNonNullAssertion: the early-continue above guarantees frame.index < frame.outgoing.length here, so this is defined\n      const edge = frame.outgoing[frame.index++]!;\n      const v = edge.to;\n      const vColor = color.get(v);\n      if (vColor === GRAY) {\n        const cycle: string[] = [v];\n        let cur = frame.node;\n        while (cur !== v) {\n          cycle.push(cur);\n          cur = parentMap.get(cur) ?? v;\n        }\n        cycle.reverse();\n        cycles.push(cycle);\n      } else if (vColor === WHITE) {\n        parentMap.set(v, frame.node);\n        pushFrame(v);\n      }\n    }\n  }\n\n  return cycles;\n}\n\nexport function detectOrphans(graph: MigrationGraph): readonly MigrationEdge[] {\n  if (graph.nodes.size === 0) return [];\n\n  const reachable = new Set<string>();\n  const startNodes: string[] = [];\n\n  if (graph.forwardChain.has(EMPTY_CONTRACT_HASH)) {\n    startNodes.push(EMPTY_CONTRACT_HASH);\n  } else {\n    const allTargets = new Set<string>();\n    for (const edges of graph.forwardChain.values()) {\n      for (const edge of edges) {\n        allTargets.add(edge.to);\n      }\n    }\n    for (const node of graph.nodes) {\n      if (!allTargets.has(node)) {\n        startNodes.push(node);\n      }\n    }\n  }\n\n  for (const step of bfs(startNodes, (n) => forwardNeighbours(graph, n))) {\n    reachable.add(step.state);\n  }\n\n  const orphans: MigrationEdge[] = [];\n  for (const [from, migrations] of graph.forwardChain) {\n    if (!reachable.has(from)) {\n      orphans.push(...migrations);\n    }\n  }\n\n  return orphans;\n}\n"],"mappings":"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"}