@prisma-next/migration-tools 0.4.0-dev.9 → 0.4.2

package/dist/exports/dag.mjs

@@ -1,8 +1,107 @@
-import { f as errorNoInitialMigration, i as errorDuplicateMigrationId, m as errorSameSourceAndTarget, n as errorAmbiguousTarget, p as errorNoTarget } from "../errors-C_XuSbX7.mjs";
+import { h as errorSameSourceAndTarget, i as errorDuplicateMigrationId, m as errorNoTarget, n as errorAmbiguousTarget, p as errorNoInitialMigration } from "../errors-BmiSgz1j.mjs";
 import { t as EMPTY_CONTRACT_HASH } from "../constants-BRi0X7B_.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
+/**
+* Generic breadth-first traversal.
+*
+* Direction (forward/reverse) is expressed by the caller's `neighbours`
+* closure: return `{ next, edge }` pairs where `next` is the node to visit
+* next and `edge` is the edge that connects them. Callers that don't need
+* path reconstruction can ignore the `parent`/`incomingEdge` fields of each
+* yielded step.
+*
+* Stops are intrinsic — callers `break` out of the `for..of` loop when
+* they've found what they're looking for.
+*
+* `ordering`, if provided, controls the order in which neighbours of each
+* node are enqueued. Only matters for path-finding: a deterministic ordering
+* makes BFS return a deterministic shortest path when multiple exist.
+*/
+function* bfs(starts, neighbours, ordering) {
+	const visited = /* @__PURE__ */ new Set();
+	const parentMap = /* @__PURE__ */ new Map();
+	const queue = new Queue();
+	for (const start of starts) if (!visited.has(start)) {
+		visited.add(start);
+		queue.push(start);
+	}
+	while (!queue.isEmpty) {
+		const current = queue.shift();
+		const parentInfo = parentMap.get(current);
+		yield {
+			node: current,
+			parent: parentInfo?.parent ?? null,
+			incomingEdge: parentInfo?.edge ?? null
+		};
+		const items = neighbours(current);
+		const toVisit = ordering ? ordering([...items]) : items;
+		for (const { next, edge } of toVisit) if (!visited.has(next)) {
+			visited.add(next);
+			parentMap.set(next, {
+				parent: current,
+				edge
+			});
+			queue.push(next);
+		}
+	}
+}
+
+//#endregion
 //#region src/dag.ts
+/** Forward-edge neighbours for BFS: edge `e` from `n` visits `e.to` next. */
+function forwardNeighbours(graph, node) {
+	return (graph.forwardChain.get(node) ?? []).map((edge) => ({
+		next: edge.to,
+		edge
+	}));
+}
+/** Reverse-edge neighbours for BFS: 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();
@@ -21,16 +120,10 @@ function reconstructGraph(packages) {
 			createdAt: pkg.manifest.createdAt,
 			labels: pkg.manifest.labels
 		};
-		if (migration.migrationId !== null) {
-			if (migrationById.has(migration.migrationId)) throw errorDuplicateMigrationId(migration.migrationId);
-			migrationById.set(migration.migrationId, migration);
-		}
-		const fwd = forwardChain.get(from);
-		if (fwd) fwd.push(migration);
-		else forwardChain.set(from, [migration]);
-		const rev = reverseChain.get(to);
-		if (rev) rev.push(migration);
-		else reverseChain.set(to, [migration]);
+		if (migrationById.has(migration.migrationId)) throw errorDuplicateMigrationId(migration.migrationId);
+		migrationById.set(migration.migrationId, migration);
+		appendEdge(forwardChain, from, migration);
+		appendEdge(reverseChain, to, migration);
 	}
 	return {
 		nodes,
@@ -52,16 +145,21 @@ function labelPriority(labels) {
 	}
 	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.migrationId.localeCompare(b.migrationId);
+}
 function sortedNeighbors(edges) {
-	return [...edges].sort((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.migrationId ?? "").localeCompare(b.migrationId ?? "");
-	});
+	return [...edges].sort(compareTieBreak);
+}
+/** Ordering adapter for `bfs` — sorts `{next, edge}` pairs by tie-break. */
+function bfsOrdering(items) {
+	return items.slice().sort((a, b) => compareTieBreak(a.edge, b.edge));
 }
 /**
 * Find the shortest path from `fromHash` to `toHash` using BFS over the
@@ -73,40 +171,37 @@ function sortedNeighbors(edges) {
 */
 function findPath(graph, fromHash, toHash) {
 	if (fromHash === toHash) return [];
-	const visited = /* @__PURE__ */ new Set();
-	const parent = /* @__PURE__ */ new Map();
-	const queue = [fromHash];
-	visited.add(fromHash);
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current === void 0) break;
-		if (current === toHash) {
+	const parents = /* @__PURE__ */ new Map();
+	for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n), bfsOrdering)) {
+		if (step.parent !== null && step.incomingEdge !== null) parents.set(step.node, {
+			parent: step.parent,
+			edge: step.incomingEdge
+		});
+		if (step.node === toHash) {
 			const path = [];
-			let node = toHash;
-			let entry = parent.get(node);
-			while (entry) {
-				const { node: prev, edge } = entry;
-				path.push(edge);
-				node = prev;
-				entry = parent.get(node);
+			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;
 		}
-		const outgoing = graph.forwardChain.get(current);
-		if (!outgoing) continue;
-		for (const edge of sortedNeighbors(outgoing)) if (!visited.has(edge.to)) {
-			visited.add(edge.to);
-			parent.set(edge.to, {
-				node: current,
-				edge
-			});
-			queue.push(edge.to);
-		}
 	}
 	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.node);
+	return reached;
+}
+/**
 * Find the shortest path from `fromHash` to `toHash` and return structured
 * path-decision metadata for machine-readable output.
 */
@@ -121,14 +216,13 @@ function findPathWithDecision(graph, fromHash, toHash, refName) {
 	};
 	const path = findPath(graph, fromHash, toHash);
 	if (!path) return null;
+	const reachesTarget = collectNodesReachingTarget(graph, toHash);
 	const tieBreakReasons = [];
 	let alternativeCount = 0;
 	for (const edge of path) {
 		const outgoing = graph.forwardChain.get(edge.from);
 		if (outgoing && outgoing.length > 1) {
-			const reachable = outgoing.filter((e) => {
-				return findPath(graph, e.to, toHash) !== null || e.to === toHash;
-			});
+			const reachable = outgoing.filter((e) => reachesTarget.has(e.to));
 			if (reachable.length > 1) {
 				alternativeCount += reachable.length - 1;
 				const sorted = sortedNeighbors(reachable);
@@ -154,14 +248,7 @@ function findPathWithDecision(graph, fromHash, toHash, refName) {
 function findDivergencePoint(graph, fromHash, leaves) {
 	const ancestorSets = leaves.map((leaf) => {
 		const ancestors = /* @__PURE__ */ new Set();
-		const queue = [leaf];
-		while (queue.length > 0) {
-			const current = queue.shift();
-			if (ancestors.has(current)) continue;
-			ancestors.add(current);
-			const incoming = graph.reverseChain.get(current);
-			if (incoming) for (const edge of incoming) queue.push(edge.from);
-		}
+		for (const step of bfs([leaf], (n) => reverseNeighbours(graph, n))) ancestors.add(step.node);
 		return ancestors;
 	});
 	const commonAncestors = [...ancestorSets[0] ?? []].filter((node) => ancestorSets.every((s) => s.has(node)));
@@ -182,36 +269,26 @@ function findDivergencePoint(graph, fromHash, leaves) {
 * `fromHash` via forward edges.
 */
 function findReachableLeaves(graph, fromHash) {
-	const visited = /* @__PURE__ */ new Set();
-	const queue = [fromHash];
-	visited.add(fromHash);
 	const leaves = [];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current === void 0) break;
-		const outgoing = graph.forwardChain.get(current);
-		if (!outgoing || outgoing.length === 0) leaves.push(current);
-		else for (const edge of outgoing) if (!visited.has(edge.to)) {
-			visited.add(edge.to);
-			queue.push(edge.to);
-		}
-	}
+	for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n))) if (!graph.forwardChain.get(step.node)?.length) leaves.push(step.node);
 	return leaves;
 }
 /**
 * Find the target contract hash of the migration graph reachable from
-* EMPTY_CONTRACT_HASH. Throws NO_INITIAL_MIGRATION if the graph has
-* nodes but none originate from the empty hash.
-* Throws AMBIGUOUS_TARGET if multiple branch tips exist.
+* 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 EMPTY_CONTRACT_HASH;
+	if (graph.nodes.size === 0) return null;
 	if (!graph.nodes.has(EMPTY_CONTRACT_HASH)) 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 EMPTY_CONTRACT_HASH;
+		return null;
 	}
 	if (leaves.length > 1) {
 		const divergencePoint = findDivergencePoint(graph, EMPTY_CONTRACT_HASH, leaves);
@@ -229,8 +306,7 @@ function findLeaf(graph) {
 			})
 		});
 	}
-	const leaf = leaves[0];
-	return leaf !== void 0 ? leaf : EMPTY_CONTRACT_HASH;
+	return leaves[0];
 }
 /**
 * Find the latest migration entry by traversing from EMPTY_CONTRACT_HASH
@@ -238,12 +314,9 @@ function findLeaf(graph) {
 * Throws AMBIGUOUS_TARGET if the graph has multiple branch tips.
 */
 function findLatestMigration(graph) {
-	if (graph.nodes.size === 0) return null;
 	const leafHash = findLeaf(graph);
-	if (leafHash === EMPTY_CONTRACT_HASH) return null;
-	const path = findPath(graph, EMPTY_CONTRACT_HASH, leafHash);
-	if (!path || path.length === 0) return null;
-	return path[path.length - 1] ?? null;
+	if (leafHash === null) return null;
+	return findPath(graph, EMPTY_CONTRACT_HASH, leafHash)?.at(-1) ?? null;
 }
 function detectCycles(graph) {
 	const WHITE = 0;
@@ -253,30 +326,42 @@ function detectCycles(graph) {
 	const parentMap = /* @__PURE__ */ new Map();
 	const cycles = [];
 	for (const node of graph.nodes) color.set(node, WHITE);
-	function dfs(u) {
+	const stack = [];
+	function pushFrame(u) {
 		color.set(u, GRAY);
-		const outgoing = graph.forwardChain.get(u);
-		if (outgoing) for (const edge of outgoing) {
-			const v = edge.to;
-			if (color.get(v) === 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 = u;
+				let cur = frame.node;
 				while (cur !== v) {
 					cycle.push(cur);
 					cur = parentMap.get(cur) ?? v;
 				}
 				cycle.reverse();
 				cycles.push(cycle);
-			} else if (color.get(v) === WHITE) {
-				parentMap.set(v, u);
-				dfs(v);
+			} else if (vColor === WHITE) {
+				parentMap.set(v, frame.node);
+				pushFrame(v);
 			}
 		}
-		color.set(u, BLACK);
-	}
-	for (const node of graph.nodes) if (color.get(node) === WHITE) {
-		parentMap.set(node, null);
-		dfs(node);
 	}
 	return cycles;
 }
@@ -290,18 +375,7 @@ function detectOrphans(graph) {
 		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);
 	}
-	const queue = [...startNodes];
-	for (const hash of queue) reachable.add(hash);
-	while (queue.length > 0) {
-		const node = queue.shift();
-		if (node === void 0) break;
-		const outgoing = graph.forwardChain.get(node);
-		if (!outgoing) continue;
-		for (const migration of outgoing) if (!reachable.has(migration.to)) {
-			reachable.add(migration.to);
-			queue.push(migration.to);
-		}
-	}
+	for (const step of bfs(startNodes, (n) => forwardNeighbours(graph, n))) reachable.add(step.node);
 	const orphans = [];
 	for (const [from, migrations] of graph.forwardChain) if (!reachable.has(from)) orphans.push(...migrations);
 	return orphans;

package/dist/exports/dag.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"dag.mjs","names":["migration: MigrationChainEntry","LABEL_PRIORITY: Record<string, number>","queue: string[]","path: MigrationChainEntry[]","tieBreakReasons: string[]","leaves: string[]","cycles: string[][]","cycle: string[]","startNodes: string[]","orphans: MigrationChainEntry[]"],"sources":["../../src/dag.ts"],"sourcesContent":["import { ifDefined } from '@prisma-next/utils/defined';\nimport { EMPTY_CONTRACT_HASH } from './constants';\nimport {\n  errorAmbiguousTarget,\n  errorDuplicateMigrationId,\n  errorNoInitialMigration,\n  errorNoTarget,\n  errorSameSourceAndTarget,\n} from './errors';\nimport type { AttestedMigrationBundle, MigrationChainEntry, MigrationGraph } from './types';\n\nexport function reconstructGraph(packages: readonly AttestedMigrationBundle[]): MigrationGraph {\n  const nodes = new Set<string>();\n  const forwardChain = new Map<string, MigrationChainEntry[]>();\n  const reverseChain = new Map<string, MigrationChainEntry[]>();\n  const migrationById = new Map<string, MigrationChainEntry>();\n\n  for (const pkg of packages) {\n    const { from, to } = pkg.manifest;\n\n    if (from === to) {\n      throw errorSameSourceAndTarget(pkg.dirName, from);\n    }\n\n    nodes.add(from);\n    nodes.add(to);\n\n    const migration: MigrationChainEntry = {\n      from,\n      to,\n      migrationId: pkg.manifest.migrationId,\n      dirName: pkg.dirName,\n      createdAt: pkg.manifest.createdAt,\n      labels: pkg.manifest.labels,\n    };\n\n    if (migration.migrationId !== null) {\n      if (migrationById.has(migration.migrationId)) {\n        throw errorDuplicateMigrationId(migration.migrationId);\n      }\n      migrationById.set(migration.migrationId, migration);\n    }\n\n    const fwd = forwardChain.get(from);\n    if (fwd) {\n      fwd.push(migration);\n    } else {\n      forwardChain.set(from, [migration]);\n    }\n\n    const rev = reverseChain.get(to);\n    if (rev) {\n      rev.push(migration);\n    } else {\n      reverseChain.set(to, [migration]);\n    }\n  }\n\n  return { nodes, forwardChain, reverseChain, migrationById };\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 sortedNeighbors(edges: readonly MigrationChainEntry[]): readonly MigrationChainEntry[] {\n  return [...edges].sort((a, b) => {\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.migrationId ?? '').localeCompare(b.migrationId ?? '');\n  });\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 → migrationId.\n */\nexport function findPath(\n  graph: MigrationGraph,\n  fromHash: string,\n  toHash: string,\n): readonly MigrationChainEntry[] | null {\n  if (fromHash === toHash) return [];\n\n  const visited = new Set<string>();\n  const parent = new Map<string, { node: string; edge: MigrationChainEntry }>();\n  const queue: string[] = [fromHash];\n  visited.add(fromHash);\n\n  while (queue.length > 0) {\n    const current = queue.shift();\n    if (current === undefined) break;\n\n    if (current === toHash) {\n      const path: MigrationChainEntry[] = [];\n      let node = toHash;\n      let entry = parent.get(node);\n      while (entry) {\n        const { node: prev, edge } = entry;\n        path.push(edge);\n        node = prev;\n        entry = parent.get(node);\n      }\n      path.reverse();\n      return path;\n    }\n\n    const outgoing = graph.forwardChain.get(current);\n    if (!outgoing) continue;\n\n    for (const edge of sortedNeighbors(outgoing)) {\n      if (!visited.has(edge.to)) {\n        visited.add(edge.to);\n        parent.set(edge.to, { node: current, edge });\n        queue.push(edge.to);\n      }\n    }\n  }\n\n  return null;\n}\n\nexport interface PathDecision {\n  readonly selectedPath: readonly MigrationChainEntry[];\n  readonly fromHash: string;\n  readonly toHash: string;\n  readonly alternativeCount: number;\n  readonly tieBreakReasons: readonly string[];\n  readonly refName?: string;\n}\n\n/**\n * Find the shortest path from `fromHash` to `toHash` and return structured\n * path-decision metadata for machine-readable output.\n */\nexport function findPathWithDecision(\n  graph: MigrationGraph,\n  fromHash: string,\n  toHash: string,\n  refName?: string,\n): PathDecision | null {\n  if (fromHash === toHash) {\n    return {\n      selectedPath: [],\n      fromHash,\n      toHash,\n      alternativeCount: 0,\n      tieBreakReasons: [],\n      ...ifDefined('refName', refName),\n    };\n  }\n\n  const path = findPath(graph, fromHash, toHash);\n  if (!path) return null;\n\n  const tieBreakReasons: string[] = [];\n  let alternativeCount = 0;\n\n  for (const edge of path) {\n    const outgoing = graph.forwardChain.get(edge.from);\n    if (outgoing && outgoing.length > 1) {\n      const reachable = outgoing.filter((e) => {\n        const pathFromE = findPath(graph, e.to, toHash);\n        return pathFromE !== null || e.to === toHash;\n      });\n      if (reachable.length > 1) {\n        alternativeCount += reachable.length - 1;\n        const sorted = sortedNeighbors(reachable);\n        if (sorted[0] && sorted[0].migrationId === edge.migrationId) {\n          if (reachable.some((e) => e.migrationId !== edge.migrationId)) {\n            tieBreakReasons.push(\n              `at ${edge.from}: ${reachable.length} candidates, selected by tie-break`,\n            );\n          }\n        }\n      }\n    }\n  }\n\n  return {\n    selectedPath: path,\n    fromHash,\n    toHash,\n    alternativeCount,\n    tieBreakReasons,\n    ...ifDefined('refName', refName),\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    const queue = [leaf];\n    while (queue.length > 0) {\n      const current = queue.shift() as string;\n      if (ancestors.has(current)) continue;\n      ancestors.add(current);\n      const incoming = graph.reverseChain.get(current);\n      if (incoming) {\n        for (const edge of incoming) {\n          queue.push(edge.from);\n        }\n      }\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 visited = new Set<string>();\n  const queue: string[] = [fromHash];\n  visited.add(fromHash);\n  const leaves: string[] = [];\n\n  while (queue.length > 0) {\n    const current = queue.shift();\n    if (current === undefined) break;\n    const outgoing = graph.forwardChain.get(current);\n\n    if (!outgoing || outgoing.length === 0) {\n      leaves.push(current);\n    } else {\n      for (const edge of outgoing) {\n        if (!visited.has(edge.to)) {\n          visited.add(edge.to);\n          queue.push(edge.to);\n        }\n      }\n    }\n  }\n\n  return leaves;\n}\n\n/**\n * Find the target contract hash of the migration graph reachable from\n * EMPTY_CONTRACT_HASH. Throws NO_INITIAL_MIGRATION if the graph has\n * nodes but none originate from the empty hash.\n * Throws AMBIGUOUS_TARGET if multiple branch tips exist.\n */\nexport function findLeaf(graph: MigrationGraph): string {\n  if (graph.nodes.size === 0) {\n    return EMPTY_CONTRACT_HASH;\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 EMPTY_CONTRACT_HASH;\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  const leaf = leaves[0];\n  return leaf !== undefined ? leaf : EMPTY_CONTRACT_HASH;\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): MigrationChainEntry | null {\n  if (graph.nodes.size === 0) {\n    return null;\n  }\n\n  const leafHash = findLeaf(graph);\n  if (leafHash === EMPTY_CONTRACT_HASH) {\n    return null;\n  }\n\n  const path = findPath(graph, EMPTY_CONTRACT_HASH, leafHash);\n  if (!path || path.length === 0) {\n    return null;\n  }\n\n  return path[path.length - 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  function dfs(u: string): void {\n    color.set(u, GRAY);\n\n    const outgoing = graph.forwardChain.get(u);\n    if (outgoing) {\n      for (const edge of outgoing) {\n        const v = edge.to;\n        if (color.get(v) === GRAY) {\n          const cycle: string[] = [v];\n          let cur = u;\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 (color.get(v) === WHITE) {\n          parentMap.set(v, u);\n          dfs(v);\n        }\n      }\n    }\n\n    color.set(u, BLACK);\n  }\n\n  for (const node of graph.nodes) {\n    if (color.get(node) === WHITE) {\n      parentMap.set(node, null);\n      dfs(node);\n    }\n  }\n\n  return cycles;\n}\n\nexport function detectOrphans(graph: MigrationGraph): readonly MigrationChainEntry[] {\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  const queue = [...startNodes];\n  for (const hash of queue) {\n    reachable.add(hash);\n  }\n\n  while (queue.length > 0) {\n    const node = queue.shift();\n    if (node === undefined) break;\n    const outgoing = graph.forwardChain.get(node);\n    if (!outgoing) continue;\n\n    for (const migration of outgoing) {\n      if (!reachable.has(migration.to)) {\n        reachable.add(migration.to);\n        queue.push(migration.to);\n      }\n    }\n  }\n\n  const orphans: MigrationChainEntry[] = [];\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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"}
+{"version":3,"file":"dag.mjs","names":["migration: MigrationChainEntry","LABEL_PRIORITY: Record<string, number>","path: MigrationChainEntry[]","tieBreakReasons: string[]","leaves: string[]","cycles: string[][]","stack: Frame[]","cycle: string[]","startNodes: string[]","orphans: MigrationChainEntry[]"],"sources":["../../src/queue.ts","../../src/graph-ops.ts","../../src/dag.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 nodes — they were not\n * reached via any edge. For every other node they record the node and edge\n * by which this node was first reached.\n */\nexport interface BfsStep<E> {\n  readonly node: string;\n  readonly parent: string | 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 node 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 * Stops are intrinsic — callers `break` out of the `for..of` loop when\n * they've found what they're looking for.\n *\n * `ordering`, if provided, controls the order in which neighbours of each\n * node are enqueued. Only matters for path-finding: a deterministic ordering\n * makes BFS return a deterministic shortest path when multiple exist.\n */\nexport function* bfs<E>(\n  starts: Iterable<string>,\n  neighbours: (node: string) => Iterable<{ next: string; edge: E }>,\n  ordering?: (items: readonly { next: string; edge: E }[]) => readonly { next: string; edge: E }[],\n): Generator<BfsStep<E>> {\n  const visited = new Set<string>();\n  const parentMap = new Map<string, { parent: string; edge: E }>();\n  const queue = new Queue<string>();\n  for (const start of starts) {\n    if (!visited.has(start)) {\n      visited.add(start);\n      queue.push(start);\n    }\n  }\n  while (!queue.isEmpty) {\n    const current = queue.shift();\n    const parentInfo = parentMap.get(current);\n    yield {\n      node: current,\n      parent: parentInfo?.parent ?? null,\n      incomingEdge: parentInfo?.edge ?? null,\n    };\n\n    const items = neighbours(current);\n    const toVisit = ordering ? ordering([...items]) : items;\n    for (const { next, edge } of toVisit) {\n      if (!visited.has(next)) {\n        visited.add(next);\n        parentMap.set(next, { parent: current, edge });\n        queue.push(next);\n      }\n    }\n  }\n}\n","import { ifDefined } from '@prisma-next/utils/defined';\nimport { EMPTY_CONTRACT_HASH } from './constants';\nimport {\n  errorAmbiguousTarget,\n  errorDuplicateMigrationId,\n  errorNoInitialMigration,\n  errorNoTarget,\n  errorSameSourceAndTarget,\n} from './errors';\nimport { bfs } from './graph-ops';\nimport type { MigrationBundle, MigrationChainEntry, MigrationGraph } from './types';\n\n/** Forward-edge neighbours for BFS: 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/** Reverse-edge neighbours for BFS: 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(\n  map: Map<string, MigrationChainEntry[]>,\n  key: string,\n  entry: MigrationChainEntry,\n): 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 MigrationBundle[]): MigrationGraph {\n  const nodes = new Set<string>();\n  const forwardChain = new Map<string, MigrationChainEntry[]>();\n  const reverseChain = new Map<string, MigrationChainEntry[]>();\n  const migrationById = new Map<string, MigrationChainEntry>();\n\n  for (const pkg of packages) {\n    const { from, to } = pkg.manifest;\n\n    if (from === to) {\n      throw errorSameSourceAndTarget(pkg.dirName, from);\n    }\n\n    nodes.add(from);\n    nodes.add(to);\n\n    const migration: MigrationChainEntry = {\n      from,\n      to,\n      migrationId: pkg.manifest.migrationId,\n      dirName: pkg.dirName,\n      createdAt: pkg.manifest.createdAt,\n      labels: pkg.manifest.labels,\n    };\n\n    if (migrationById.has(migration.migrationId)) {\n      throw errorDuplicateMigrationId(migration.migrationId);\n    }\n    migrationById.set(migration.migrationId, migration);\n\n    appendEdge(forwardChain, from, migration);\n    appendEdge(reverseChain, to, migration);\n  }\n\n  return { nodes, forwardChain, reverseChain, migrationById };\n}\n\n// ---------------------------------------------------------------------------\n// Deterministic tie-breaking for BFS neighbour order.\n// Used by `findPath` and `findPathWithDecision` only; not a general-purpose\n// utility. Ordering: label priority → createdAt → to → migrationId.\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: MigrationChainEntry, b: MigrationChainEntry): 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.migrationId.localeCompare(b.migrationId);\n}\n\nfunction sortedNeighbors(edges: readonly MigrationChainEntry[]): readonly MigrationChainEntry[] {\n  return [...edges].sort(compareTieBreak);\n}\n\n/** Ordering adapter for `bfs` — sorts `{next, edge}` pairs by tie-break. */\nfunction bfsOrdering(\n  items: readonly { next: string; edge: MigrationChainEntry }[],\n): readonly { next: string; edge: MigrationChainEntry }[] {\n  return items.slice().sort((a, b) => compareTieBreak(a.edge, b.edge));\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 → migrationId.\n */\nexport function findPath(\n  graph: MigrationGraph,\n  fromHash: string,\n  toHash: string,\n): readonly MigrationChainEntry[] | null {\n  if (fromHash === toHash) return [];\n\n  const parents = new Map<string, { parent: string; edge: MigrationChainEntry }>();\n  for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n), bfsOrdering)) {\n    if (step.parent !== null && step.incomingEdge !== null) {\n      parents.set(step.node, { parent: step.parent, edge: step.incomingEdge });\n    }\n    if (step.node === toHash) {\n      const path: MigrationChainEntry[] = [];\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 * 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.node);\n  }\n  return reached;\n}\n\nexport interface PathDecision {\n  readonly selectedPath: readonly MigrationChainEntry[];\n  readonly fromHash: string;\n  readonly toHash: string;\n  readonly alternativeCount: number;\n  readonly tieBreakReasons: readonly string[];\n  readonly refName?: string;\n}\n\n/**\n * Find the shortest path from `fromHash` to `toHash` and return structured\n * path-decision metadata for machine-readable output.\n */\nexport function findPathWithDecision(\n  graph: MigrationGraph,\n  fromHash: string,\n  toHash: string,\n  refName?: string,\n): PathDecision | null {\n  if (fromHash === toHash) {\n    return {\n      selectedPath: [],\n      fromHash,\n      toHash,\n      alternativeCount: 0,\n      tieBreakReasons: [],\n      ...ifDefined('refName', refName),\n    };\n  }\n\n  const path = findPath(graph, fromHash, toHash);\n  if (!path) return null;\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\n  const tieBreakReasons: string[] = [];\n  let alternativeCount = 0;\n\n  for (const edge of path) {\n    const outgoing = graph.forwardChain.get(edge.from);\n    if (outgoing && outgoing.length > 1) {\n      const reachable = outgoing.filter((e) => reachesTarget.has(e.to));\n      if (reachable.length > 1) {\n        alternativeCount += reachable.length - 1;\n        const sorted = sortedNeighbors(reachable);\n        if (sorted[0] && sorted[0].migrationId === edge.migrationId) {\n          if (reachable.some((e) => e.migrationId !== edge.migrationId)) {\n            tieBreakReasons.push(\n              `at ${edge.from}: ${reachable.length} candidates, selected by tie-break`,\n            );\n          }\n        }\n      }\n    }\n  }\n\n  return {\n    selectedPath: path,\n    fromHash,\n    toHash,\n    alternativeCount,\n    tieBreakReasons,\n    ...ifDefined('refName', refName),\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.node);\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.node)?.length) {\n      leaves.push(step.node);\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): MigrationChainEntry | 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 MigrationChainEntry[];\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 MigrationChainEntry[] {\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.node);\n  }\n\n  const orphans: MigrationChainEntry[] = [];\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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"}

package/dist/exports/io.d.mts

@@ -1,24 +1,27 @@
-import { l as MigrationManifest, r as BaseMigrationBundle, u as MigrationOps } from "../types-D2uX4ql7.mjs";
+import { a as MigrationManifest, o as MigrationOps, t as MigrationBundle } from "../types-DyGXcWWp.mjs";
 
 //#region src/io.d.ts
 declare function writeMigrationPackage(dir: string, manifest: MigrationManifest, ops: MigrationOps): Promise<void>;
 /**
- * Copy the destination contract artifacts (`contract.json` and the
- * colocated `contract.d.ts`) into the migration package directory so
- * authors of the scaffolded `migration.ts` can import the typed
- * contract relative to the migration directory
- * (`import type { Contract } from './contract'`).
+ * Copy a list of files into `destDir`, optionally renaming each one.
  *
- * A missing `.d.ts` is tolerated (only the `.json` is required) so the
- * helper stays usable in tests that hand-roll a bare `contract.json`.
- * A missing `contract.json` — or any other I/O failure — throws.
+ * The destination directory is created (with `recursive: true`) if it
+ * does not already exist. Each source path is copied byte-for-byte into
+ * `destDir/<destName>`; missing sources throw `ENOENT`. The helper is
+ * intentionally generic: callers own the list of files (e.g. a contract
+ * emitter's emitted output) and the naming convention (e.g. renaming
+ * the destination contract to `end-contract.*` and the source contract
+ * to `start-contract.*`).
  */
-declare function copyContractToMigrationDir(packageDir: string, contractJsonPath: string): Promise<void>;
+declare function copyFilesWithRename(destDir: string, files: readonly {
+  readonly sourcePath: string;
+  readonly destName: string;
+}[]): Promise<void>;
 declare function writeMigrationManifest(dir: string, manifest: MigrationManifest): Promise<void>;
 declare function writeMigrationOps(dir: string, ops: MigrationOps): Promise<void>;
-declare function readMigrationPackage(dir: string): Promise<BaseMigrationBundle>;
-declare function readMigrationsDir(migrationsRoot: string): Promise<readonly BaseMigrationBundle[]>;
+declare function readMigrationPackage(dir: string): Promise<MigrationBundle>;
+declare function readMigrationsDir(migrationsRoot: string): Promise<readonly MigrationBundle[]>;
 declare function formatMigrationDirName(timestamp: Date, slug: string): string;
 //#endregion
-export { copyContractToMigrationDir, formatMigrationDirName, readMigrationPackage, readMigrationsDir, writeMigrationManifest, writeMigrationOps, writeMigrationPackage };
+export { copyFilesWithRename, formatMigrationDirName, readMigrationPackage, readMigrationsDir, writeMigrationManifest, writeMigrationOps, writeMigrationPackage };
 //# sourceMappingURL=io.d.mts.map

package/dist/exports/io.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"io.d.mts","names":[],"sources":["../../src/io.ts"],"sourcesContent":[],"mappings":";;;iBAwDsB,qBAAA,wBAEV,wBACL,eACJ;;AAJH;;;;;AA+BA;AAcA;AAOA;AAIA;AAkEA;AAiCgB,iBA5HM,0BAAA,CA4HgC,UAAA,EAAA,MAAA,EAAA,gBAAA,EAAA,MAAA,CAAA,EAzHnD,OAyHmD,CAAA,IAAA,CAAA;iBA9GhC,sBAAA,wBAEV,oBACT;iBAImB,iBAAA,mBAAoC,eAAe;iBAInD,oBAAA,eAAmC,QAAQ;iBAkE3C,iBAAA,0BAEnB,iBAAiB;iBA+BJ,sBAAA,YAAkC"}
+{"version":3,"file":"io.d.mts","names":[],"sources":["../../src/io.ts"],"sourcesContent":[],"mappings":";;;iBAwDsB,qBAAA,wBAEV,wBACL,eACJ;;AAJH;;;;;AA+BA;AAaA;AAOA;AAIA;AAkEA;AAiCgB,iBA3HM,mBAAA,CA2H4B,OAAI,EAAA,MAAA,EAAA,KAAA,EAAA,SAAA;;;MAxHnD;iBAUmB,sBAAA,wBAEV,oBACT;iBAImB,iBAAA,mBAAoC,eAAe;iBAInD,oBAAA,eAAmC,QAAQ;iBAkE3C,iBAAA,0BAEnB,iBAAiB;iBA+BJ,sBAAA,YAAkC"}

package/dist/exports/io.mjs

@@ -1,3 +1,3 @@
-import { a as writeMigrationManifest, i as readMigrationsDir, n as formatMigrationDirName, o as writeMigrationOps, r as readMigrationPackage, s as writeMigrationPackage, t as copyContractToMigrationDir } from "../io-Cun81AIZ.mjs";
+import { a as writeMigrationManifest, i as readMigrationsDir, n as formatMigrationDirName, o as writeMigrationOps, r as readMigrationPackage, s as writeMigrationPackage, t as copyFilesWithRename } from "../io-Cd6GLyjK.mjs";
 
-export { copyContractToMigrationDir, formatMigrationDirName, readMigrationPackage, readMigrationsDir, writeMigrationManifest, writeMigrationOps, writeMigrationPackage };
+export { copyFilesWithRename, formatMigrationDirName, readMigrationPackage, readMigrationsDir, writeMigrationManifest, writeMigrationOps, writeMigrationPackage };

package/dist/exports/migration-ts.d.mts

@@ -2,42 +2,36 @@
 /**
  * Utilities for reading/writing `migration.ts` files.
  *
- * Rendering migration.ts source is now the target's responsibility — the CLI
- * obtains source strings either from a class-flow planner's
- * `plan.renderTypeScript()` or from a descriptor-flow target's
- * `migrations.renderDescriptorTypeScript(descriptors, context)`. The helper
- * here is limited to file I/O: writing the returned source with the right
- * executable bit, probing for existence, and evaluating legacy descriptor-
- * flow files.
+ * Rendering migration.ts source is the target's responsibility — the CLI
+ * obtains source strings from a planner's `plan.renderTypeScript()`. The
+ * helper here is limited to file I/O: writing the returned source with the
+ * right executable bit and probing for existence.
  */
 /**
  * Writes a pre-rendered `migration.ts` source string to the given package
  * directory. If the source begins with a shebang, the file is written with
  * executable permissions (0o755) so it can be run directly via
- * `./migration.ts` by the authoring class's `Migration.run(...)` guard.
+ * `./migration.ts` — the rendered scaffold ends with
+ * `MigrationCLI.run(import.meta.url, M)` from
+ * `@prisma-next/cli/migration-cli` (re-exported by the postgres facade),
+ * which guards on the entrypoint and serializes when the file is the main
+ * module.
+ *
+ * The source is run through prettier before writing so migration renderers
+ * can produce structurally-correct but loosely-indented source and rely on
+ * a single canonical format on disk. Matches what `@prisma-next/emitter`
+ * already does for generated `contract.d.ts`.
  */
 declare function writeMigrationTs(packageDir: string, content: string): Promise<void>;
 /**
  * Checks whether a migration.ts file exists in the package directory.
  */
 declare function hasMigrationTs(packageDir: string): Promise<boolean>;
-/**
- * Evaluates a descriptor-flow migration.ts file by loading it via native
- * Node import. Returns the result of calling the default export (expected
- * to be a function returning an array of operation descriptors).
- *
- * Class-flow migration.ts files use a different shape — their default
- * export is a class that extends `Migration` — and are evaluated by the
- * target's `emit` capability, not this helper.
- *
- * Requires Node ≥24 for native TypeScript support.
- */
-declare function evaluateMigrationTs(packageDir: string): Promise<readonly unknown[]>;
 //#endregion
 //#region src/runtime-detection.d.ts
 type ScaffoldRuntime = 'node' | 'bun' | 'deno';
 declare function detectScaffoldRuntime(): ScaffoldRuntime;
 declare function shebangLineFor(runtime: ScaffoldRuntime): string;
 //#endregion
-export { type ScaffoldRuntime, detectScaffoldRuntime, evaluateMigrationTs, hasMigrationTs, shebangLineFor, writeMigrationTs };
+export { type ScaffoldRuntime, detectScaffoldRuntime, hasMigrationTs, shebangLineFor, writeMigrationTs };
 //# sourceMappingURL=migration-ts.d.mts.map

package/dist/exports/migration-ts.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration-ts.d.mts","names":[],"sources":["../../src/migration-ts.ts","../../src/runtime-detection.ts"],"sourcesContent":[],"mappings":";;AAuBA;AAYA;AAoBA;;;;ACvDA;AAEA;AAMA;;;;;;;;iBDesB,gBAAA,uCAAuD;;;;iBAYvD,cAAA,sBAAoC;;;;;;;;;;;;iBAoBpC,mBAAA,sBAAyC;;;KCvDnD,eAAA;ADuBU,iBCrBN,qBAAA,CAAA,CDqBoE,ECrB3C,eDqB2C;AAY9D,iBC3BN,cAAA,CD2B0C,OAAO,EC3BzB,eD2ByB,CAAA,EAAA,MAAA"}
+{"version":3,"file":"migration-ts.d.mts","names":[],"sources":["../../src/migration-ts.ts","../../src/runtime-detection.ts"],"sourcesContent":[],"mappings":";;AA8BA;AAsBA;;;;ACpDA;AAEA;AAMA;;;;;;;;;;;;;;;iBDsBsB,gBAAA,uCAAuD;;;;iBAsBvD,cAAA,sBAAoC;;;KCpD9C,eAAA;AD8BU,iBC5BN,qBAAA,CAAA,CD4BoE,EC5B3C,eD4B2C;AAsB9D,iBC5CN,cAAA,CD4C0C,OAAO,EC5CzB,eD4CyB,CAAA,EAAA,MAAA"}