@prisma-next/migration-tools 0.5.0-dev.3 → 0.5.0-dev.31

package/dist/exports/io.mjs

@@ -1,3 +1,163 @@
-import { a as writeMigrationManifest, i as readMigrationsDir, n as formatMigrationDirName, o as writeMigrationOps, r as readMigrationPackage, s as writeMigrationPackage, t as copyFilesWithRename } from "../io-CCnYsUHU.mjs";
+import { c as errorInvalidJson, g as errorMissingFile, h as errorMigrationHashMismatch, l as errorInvalidManifest, m as errorInvalidSlug, o as errorInvalidDestName, r as errorDirectoryExists, y as errorProvidedInvariantsMismatch } from "../errors-Bl3cKiM8.mjs";
+import { n as verifyMigrationHash } from "../hash-BARZdVgW.mjs";
+import { t as deriveProvidedInvariants } from "../invariants-BmrTBQ0A.mjs";
+import { n as MigrationOpsSchema } from "../op-schema-DZKFua46.mjs";
+import { basename, dirname, join } from "pathe";
+import { copyFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { type } from "arktype";
 
-export { copyFilesWithRename, formatMigrationDirName, readMigrationPackage, readMigrationsDir, writeMigrationManifest, writeMigrationOps, writeMigrationPackage };
+//#region src/io.ts
+const MANIFEST_FILE = "migration.json";
+const OPS_FILE = "ops.json";
+const MAX_SLUG_LENGTH = 64;
+function hasErrnoCode(error, code) {
+	return error instanceof Error && error.code === code;
+}
+const MigrationHintsSchema = type({
+	used: "string[]",
+	applied: "string[]",
+	plannerVersion: "string"
+});
+const MigrationMetadataSchema = type({
+	"+": "reject",
+	from: "string > 0 | null",
+	to: "string",
+	migrationHash: "string",
+	fromContract: "object | null",
+	toContract: "object",
+	hints: MigrationHintsSchema,
+	labels: "string[]",
+	providedInvariants: "string[]",
+	"authorship?": type({
+		"author?": "string",
+		"email?": "string"
+	}),
+	"signature?": type({
+		keyId: "string",
+		value: "string"
+	}).or("null"),
+	createdAt: "string"
+});
+async function writeMigrationPackage(dir, metadata, ops) {
+	await mkdir(dirname(dir), { recursive: true });
+	try {
+		await mkdir(dir);
+	} catch (error) {
+		if (hasErrnoCode(error, "EEXIST")) throw errorDirectoryExists(dir);
+		throw error;
+	}
+	await writeFile(join(dir, MANIFEST_FILE), JSON.stringify(metadata, null, 2), { flag: "wx" });
+	await writeFile(join(dir, OPS_FILE), JSON.stringify(ops, null, 2), { flag: "wx" });
+}
+/**
+* Copy a list of files into `destDir`, optionally renaming each one.
+*
+* 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.*`).
+*/
+async function copyFilesWithRename(destDir, files) {
+	await mkdir(destDir, { recursive: true });
+	for (const file of files) {
+		if (basename(file.destName) !== file.destName) throw errorInvalidDestName(file.destName);
+		await copyFile(file.sourcePath, join(destDir, file.destName));
+	}
+}
+async function writeMigrationMetadata(dir, metadata) {
+	await writeFile(join(dir, MANIFEST_FILE), `${JSON.stringify(metadata, null, 2)}\n`);
+}
+async function writeMigrationOps(dir, ops) {
+	await writeFile(join(dir, OPS_FILE), `${JSON.stringify(ops, null, 2)}\n`);
+}
+async function readMigrationPackage(dir) {
+	const manifestPath = join(dir, MANIFEST_FILE);
+	const opsPath = join(dir, OPS_FILE);
+	let manifestRaw;
+	try {
+		manifestRaw = await readFile(manifestPath, "utf-8");
+	} catch (error) {
+		if (hasErrnoCode(error, "ENOENT")) throw errorMissingFile(MANIFEST_FILE, dir);
+		throw error;
+	}
+	let opsRaw;
+	try {
+		opsRaw = await readFile(opsPath, "utf-8");
+	} catch (error) {
+		if (hasErrnoCode(error, "ENOENT")) throw errorMissingFile(OPS_FILE, dir);
+		throw error;
+	}
+	let metadata;
+	try {
+		metadata = JSON.parse(manifestRaw);
+	} catch (e) {
+		throw errorInvalidJson(manifestPath, e instanceof Error ? e.message : String(e));
+	}
+	let ops;
+	try {
+		ops = JSON.parse(opsRaw);
+	} catch (e) {
+		throw errorInvalidJson(opsPath, e instanceof Error ? e.message : String(e));
+	}
+	validateMetadata(metadata, manifestPath);
+	validateOps(ops, opsPath);
+	const derivedInvariants = deriveProvidedInvariants(ops);
+	if (!arraysEqual(metadata.providedInvariants, derivedInvariants)) throw errorProvidedInvariantsMismatch(manifestPath, metadata.providedInvariants, derivedInvariants);
+	const pkg = {
+		dirName: basename(dir),
+		dirPath: dir,
+		metadata,
+		ops
+	};
+	const verification = verifyMigrationHash(pkg);
+	if (!verification.ok) throw errorMigrationHashMismatch(dir, verification.storedHash, verification.computedHash);
+	return pkg;
+}
+function arraysEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function validateMetadata(metadata, filePath) {
+	const result = MigrationMetadataSchema(metadata);
+	if (result instanceof type.errors) throw errorInvalidManifest(filePath, result.summary);
+}
+function validateOps(ops, filePath) {
+	const result = MigrationOpsSchema(ops);
+	if (result instanceof type.errors) throw errorInvalidManifest(filePath, result.summary);
+}
+async function readMigrationsDir(migrationsRoot) {
+	let entries;
+	try {
+		entries = await readdir(migrationsRoot);
+	} catch (error) {
+		if (hasErrnoCode(error, "ENOENT")) return [];
+		throw error;
+	}
+	const packages = [];
+	for (const entry of entries.sort()) {
+		const entryPath = join(migrationsRoot, entry);
+		if (!(await stat(entryPath)).isDirectory()) continue;
+		const manifestPath = join(entryPath, MANIFEST_FILE);
+		try {
+			await stat(manifestPath);
+		} catch {
+			continue;
+		}
+		packages.push(await readMigrationPackage(entryPath));
+	}
+	return packages;
+}
+function formatMigrationDirName(timestamp, slug) {
+	const sanitized = slug.toLowerCase().replace(/[^a-z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+	if (sanitized.length === 0) throw errorInvalidSlug(slug);
+	const truncated = sanitized.slice(0, MAX_SLUG_LENGTH);
+	return `${timestamp.getUTCFullYear()}${String(timestamp.getUTCMonth() + 1).padStart(2, "0")}${String(timestamp.getUTCDate()).padStart(2, "0")}T${String(timestamp.getUTCHours()).padStart(2, "0")}${String(timestamp.getUTCMinutes()).padStart(2, "0")}_${truncated}`;
+}
+
+//#endregion
+export { copyFilesWithRename, formatMigrationDirName, readMigrationPackage, readMigrationsDir, writeMigrationMetadata, writeMigrationOps, writeMigrationPackage };
+//# sourceMappingURL=io.mjs.map

package/dist/exports/io.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"io.mjs","names":["manifestRaw: string","opsRaw: string","metadata: MigrationMetadata","ops: MigrationOps","pkg: MigrationPackage","entries: string[]","packages: MigrationPackage[]"],"sources":["../../src/io.ts"],"sourcesContent":["import { copyFile, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';\nimport { type } from 'arktype';\nimport { basename, dirname, join } from 'pathe';\nimport {\n  errorDirectoryExists,\n  errorInvalidDestName,\n  errorInvalidJson,\n  errorInvalidManifest,\n  errorInvalidSlug,\n  errorMigrationHashMismatch,\n  errorMissingFile,\n  errorProvidedInvariantsMismatch,\n} from './errors';\nimport { verifyMigrationHash } from './hash';\nimport { deriveProvidedInvariants } from './invariants';\nimport type { MigrationMetadata } from './metadata';\nimport { MigrationOpsSchema } from './op-schema';\nimport type { MigrationOps, MigrationPackage } from './package';\n\nconst MANIFEST_FILE = 'migration.json';\nconst OPS_FILE = 'ops.json';\nconst MAX_SLUG_LENGTH = 64;\n\nfunction hasErrnoCode(error: unknown, code: string): boolean {\n  return error instanceof Error && (error as { code?: string }).code === code;\n}\n\nconst MigrationHintsSchema = type({\n  used: 'string[]',\n  applied: 'string[]',\n  plannerVersion: 'string',\n});\n\nconst MigrationMetadataSchema = type({\n  '+': 'reject',\n  from: 'string > 0 | null',\n  to: 'string',\n  migrationHash: 'string',\n  fromContract: 'object | null',\n  toContract: 'object',\n  hints: MigrationHintsSchema,\n  labels: 'string[]',\n  providedInvariants: 'string[]',\n  'authorship?': type({\n    'author?': 'string',\n    'email?': 'string',\n  }),\n  'signature?': type({\n    keyId: 'string',\n    value: 'string',\n  }).or('null'),\n  createdAt: 'string',\n});\n\nexport async function writeMigrationPackage(\n  dir: string,\n  metadata: MigrationMetadata,\n  ops: MigrationOps,\n): Promise<void> {\n  await mkdir(dirname(dir), { recursive: true });\n\n  try {\n    await mkdir(dir);\n  } catch (error) {\n    if (hasErrnoCode(error, 'EEXIST')) {\n      throw errorDirectoryExists(dir);\n    }\n    throw error;\n  }\n\n  await writeFile(join(dir, MANIFEST_FILE), JSON.stringify(metadata, null, 2), {\n    flag: 'wx',\n  });\n  await writeFile(join(dir, OPS_FILE), JSON.stringify(ops, null, 2), { flag: 'wx' });\n}\n\n/**\n * Copy a list of files into `destDir`, optionally renaming each one.\n *\n * The destination directory is created (with `recursive: true`) if it\n * does not already exist. Each source path is copied byte-for-byte into\n * `destDir/<destName>`; missing sources throw `ENOENT`. The helper is\n * intentionally generic: callers own the list of files (e.g. a contract\n * emitter's emitted output) and the naming convention (e.g. renaming\n * the destination contract to `end-contract.*` and the source contract\n * to `start-contract.*`).\n */\nexport async function copyFilesWithRename(\n  destDir: string,\n  files: readonly { readonly sourcePath: string; readonly destName: string }[],\n): Promise<void> {\n  await mkdir(destDir, { recursive: true });\n  for (const file of files) {\n    if (basename(file.destName) !== file.destName) {\n      throw errorInvalidDestName(file.destName);\n    }\n    await copyFile(file.sourcePath, join(destDir, file.destName));\n  }\n}\n\nexport async function writeMigrationMetadata(\n  dir: string,\n  metadata: MigrationMetadata,\n): Promise<void> {\n  await writeFile(join(dir, MANIFEST_FILE), `${JSON.stringify(metadata, null, 2)}\\n`);\n}\n\nexport async function writeMigrationOps(dir: string, ops: MigrationOps): Promise<void> {\n  await writeFile(join(dir, OPS_FILE), `${JSON.stringify(ops, null, 2)}\\n`);\n}\n\nexport async function readMigrationPackage(dir: string): Promise<MigrationPackage> {\n  const manifestPath = join(dir, MANIFEST_FILE);\n  const opsPath = join(dir, OPS_FILE);\n\n  let manifestRaw: string;\n  try {\n    manifestRaw = await readFile(manifestPath, 'utf-8');\n  } catch (error) {\n    if (hasErrnoCode(error, 'ENOENT')) {\n      throw errorMissingFile(MANIFEST_FILE, dir);\n    }\n    throw error;\n  }\n\n  let opsRaw: string;\n  try {\n    opsRaw = await readFile(opsPath, 'utf-8');\n  } catch (error) {\n    if (hasErrnoCode(error, 'ENOENT')) {\n      throw errorMissingFile(OPS_FILE, dir);\n    }\n    throw error;\n  }\n\n  let metadata: MigrationMetadata;\n  try {\n    metadata = JSON.parse(manifestRaw);\n  } catch (e) {\n    throw errorInvalidJson(manifestPath, e instanceof Error ? e.message : String(e));\n  }\n\n  let ops: MigrationOps;\n  try {\n    ops = JSON.parse(opsRaw);\n  } catch (e) {\n    throw errorInvalidJson(opsPath, e instanceof Error ? e.message : String(e));\n  }\n\n  validateMetadata(metadata, manifestPath);\n  validateOps(ops, opsPath);\n\n  // Re-derive before the hash check so format/duplicate diagnostics\n  // fire with their dedicated codes rather than as a generic hash mismatch.\n  const derivedInvariants = deriveProvidedInvariants(ops);\n  if (!arraysEqual(metadata.providedInvariants, derivedInvariants)) {\n    throw errorProvidedInvariantsMismatch(\n      manifestPath,\n      metadata.providedInvariants,\n      derivedInvariants,\n    );\n  }\n\n  const pkg: MigrationPackage = {\n    dirName: basename(dir),\n    dirPath: dir,\n    metadata,\n    ops,\n  };\n\n  const verification = verifyMigrationHash(pkg);\n  if (!verification.ok) {\n    throw errorMigrationHashMismatch(dir, verification.storedHash, verification.computedHash);\n  }\n\n  return pkg;\n}\n\nfunction arraysEqual(a: readonly string[], b: readonly string[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\n\nfunction validateMetadata(\n  metadata: unknown,\n  filePath: string,\n): asserts metadata is MigrationMetadata {\n  const result = MigrationMetadataSchema(metadata);\n  if (result instanceof type.errors) {\n    throw errorInvalidManifest(filePath, result.summary);\n  }\n}\n\nfunction validateOps(ops: unknown, filePath: string): asserts ops is MigrationOps {\n  const result = MigrationOpsSchema(ops);\n  if (result instanceof type.errors) {\n    throw errorInvalidManifest(filePath, result.summary);\n  }\n}\n\nexport async function readMigrationsDir(\n  migrationsRoot: string,\n): Promise<readonly MigrationPackage[]> {\n  let entries: string[];\n  try {\n    entries = await readdir(migrationsRoot);\n  } catch (error) {\n    if (hasErrnoCode(error, 'ENOENT')) {\n      return [];\n    }\n    throw error;\n  }\n\n  const packages: MigrationPackage[] = [];\n\n  for (const entry of entries.sort()) {\n    const entryPath = join(migrationsRoot, entry);\n    const entryStat = await stat(entryPath);\n    if (!entryStat.isDirectory()) continue;\n\n    const manifestPath = join(entryPath, MANIFEST_FILE);\n    try {\n      await stat(manifestPath);\n    } catch {\n      continue; // skip non-migration directories\n    }\n\n    packages.push(await readMigrationPackage(entryPath));\n  }\n\n  return packages;\n}\n\nexport function formatMigrationDirName(timestamp: Date, slug: string): string {\n  const sanitized = slug\n    .toLowerCase()\n    .replace(/[^a-z0-9]/g, '_')\n    .replace(/_+/g, '_')\n    .replace(/^_|_$/g, '');\n\n  if (sanitized.length === 0) {\n    throw errorInvalidSlug(slug);\n  }\n\n  const truncated = sanitized.slice(0, MAX_SLUG_LENGTH);\n\n  const y = timestamp.getUTCFullYear();\n  const mo = String(timestamp.getUTCMonth() + 1).padStart(2, '0');\n  const d = String(timestamp.getUTCDate()).padStart(2, '0');\n  const h = String(timestamp.getUTCHours()).padStart(2, '0');\n  const mi = String(timestamp.getUTCMinutes()).padStart(2, '0');\n\n  return `${y}${mo}${d}T${h}${mi}_${truncated}`;\n}\n"],"mappings":"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"}

package/dist/exports/metadata.d.mts

@@ -0,0 +1,2 @@
+import { n as MigrationMetadata, t as MigrationHints } from "../metadata-BP1cmU7Z.mjs";
+export { type MigrationHints, type MigrationMetadata };

package/dist/exports/metadata.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/exports/{dag.d.mts → migration-graph.d.mts}

@@ -1,18 +1,39 @@
-import { n as MigrationChainEntry, r as MigrationGraph, t as MigrationBundle } from "../types-DyGXcWWp.mjs";
+import { n as MigrationGraph, t as MigrationEdge } from "../graph-BHPv-9Gl.mjs";
+import { n as MigrationPackage } from "../package-5HCCg0z-.mjs";
 
-//#region src/dag.d.ts
-declare function reconstructGraph(packages: readonly MigrationBundle[]): MigrationGraph;
+//#region src/migration-graph.d.ts
+declare function reconstructGraph(packages: readonly MigrationPackage[]): MigrationGraph;
 /**
  * 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 → migrationId.
+ * label priority → createdAt → to → migrationHash.
  */
-declare function findPath(graph: MigrationGraph, fromHash: string, toHash: string): readonly MigrationChainEntry[] | null;
+declare function findPath(graph: MigrationGraph, fromHash: string, toHash: string): readonly MigrationEdge[] | 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.
+ */
+declare function findPathWithInvariants(graph: MigrationGraph, fromHash: string, toHash: string, required: ReadonlySet<string>): readonly MigrationEdge[] | null;
 interface PathDecision {
-  readonly selectedPath: readonly MigrationChainEntry[];
+  readonly selectedPath: readonly MigrationEdge[];
   readonly fromHash: string;
   readonly toHash: string;
   readonly alternativeCount: number;
@@ -43,9 +64,9 @@ declare function findLeaf(graph: MigrationGraph): string | null;
  * to the single target. Returns null for an empty graph.
  * Throws AMBIGUOUS_TARGET if the graph has multiple branch tips.
  */
-declare function findLatestMigration(graph: MigrationGraph): MigrationChainEntry | null;
+declare function findLatestMigration(graph: MigrationGraph): MigrationEdge | null;
 declare function detectCycles(graph: MigrationGraph): readonly string[][];
-declare function detectOrphans(graph: MigrationGraph): readonly MigrationChainEntry[];
+declare function detectOrphans(graph: MigrationGraph): readonly MigrationEdge[];
 //#endregion
-export { type PathDecision, detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findReachableLeaves, reconstructGraph };
-//# sourceMappingURL=dag.d.mts.map
+export { type PathDecision, detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findPathWithInvariants, findReachableLeaves, reconstructGraph };
+//# sourceMappingURL=migration-graph.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration-graph.d.mts","names":[],"sources":["../../src/migration-graph.ts"],"sourcesContent":[],"mappings":";;;;iBAsCgB,gBAAA,oBAAoC,qBAAqB;;AAAzE;AAkFA;AAgDA;;;;;AA0FiB,iBA1ID,QAAA,CA2IkB,KAAA,EA1IzB,cA0IsC,EAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAAA,MAAA,CAAA,EAAA,SAvInC,aAuImC,EAAA,GAAA,IAAA;AAY/C;AA8FA;AAkBA;AAwCA;AAQA;AA8DA;;;;;;;;;;;;;;iBArUgB,sBAAA,QACP,4DAGG,+BACA;UAqFK,YAAA;kCACiB;;;;;;;;;;;iBAYlB,oBAAA,QACP,qEAIN;;;;;iBAyFa,mBAAA,QAA2B;;;;;;;;;iBAkB3B,QAAA,QAAgB;;;;;;iBAwChB,mBAAA,QAA2B,iBAAiB;iBAQ5C,YAAA,QAAoB;iBA8DpB,aAAA,QAAqB,0BAA0B"}

package/dist/exports/{dag.mjs → migration-graph.mjs}

@@ -1,5 +1,5 @@
-import { h as errorSameSourceAndTarget, i as errorDuplicateMigrationId, m as errorNoTarget, n as errorAmbiguousTarget, p as errorNoInitialMigration } from "../errors-BKbRGCJM.mjs";
-import { t as EMPTY_CONTRACT_HASH } from "../constants-BRi0X7B_.mjs";
+import { _ as errorNoInitialMigration, a as errorDuplicateMigrationHash, b as errorSameSourceAndTarget, n as errorAmbiguousTarget, v as errorNoTarget } from "../errors-Bl3cKiM8.mjs";
+import { t as EMPTY_CONTRACT_HASH } from "../constants-BQEHsaEx.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 
 //#region src/queue.ts
@@ -36,61 +36,65 @@ var Queue = class {
 
 //#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) {
+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) if (!visited.has(start)) {
-		visited.add(start);
-		queue.push(start);
+	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 current = queue.shift();
-		const parentInfo = parentMap.get(current);
+		const { state: current, key: curKey } = queue.shift();
+		const parentInfo = parentMap.get(curKey);
 		yield {
-			node: current,
+			state: 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);
+		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/dag.ts
-/** Forward-edge neighbours for BFS: edge `e` from `n` visits `e.to` next. */
+//#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
 	}));
 }
-/** Reverse-edge neighbours for BFS: edge `e` from `n` visits `e.from` next. */
+/**
+* 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,
@@ -106,22 +110,24 @@ function reconstructGraph(packages) {
 	const nodes = /* @__PURE__ */ new Set();
 	const forwardChain = /* @__PURE__ */ new Map();
 	const reverseChain = /* @__PURE__ */ new Map();
-	const migrationById = /* @__PURE__ */ new Map();
+	const migrationByHash = /* @__PURE__ */ new Map();
 	for (const pkg of packages) {
-		const { from, to } = pkg.manifest;
-		if (from === to) throw errorSameSourceAndTarget(pkg.dirName, from);
+		const from = pkg.metadata.from ?? EMPTY_CONTRACT_HASH;
+		const { to } = pkg.metadata;
+		if (from === to) throw errorSameSourceAndTarget(pkg.dirPath, from);
 		nodes.add(from);
 		nodes.add(to);
 		const migration = {
 			from,
 			to,
-			migrationId: pkg.manifest.migrationId,
+			migrationHash: pkg.metadata.migrationHash,
 			dirName: pkg.dirName,
-			createdAt: pkg.manifest.createdAt,
-			labels: pkg.manifest.labels
+			createdAt: pkg.metadata.createdAt,
+			labels: pkg.metadata.labels,
+			invariants: pkg.metadata.providedInvariants
 		};
-		if (migrationById.has(migration.migrationId)) throw errorDuplicateMigrationId(migration.migrationId);
-		migrationById.set(migration.migrationId, migration);
+		if (migrationByHash.has(migration.migrationHash)) throw errorDuplicateMigrationHash(migration.migrationHash);
+		migrationByHash.set(migration.migrationHash, migration);
 		appendEdge(forwardChain, from, migration);
 		appendEdge(reverseChain, to, migration);
 	}
@@ -129,7 +135,7 @@ function reconstructGraph(packages) {
 		nodes,
 		forwardChain,
 		reverseChain,
-		migrationById
+		migrationByHash
 	};
 }
 const LABEL_PRIORITY = {
@@ -152,32 +158,28 @@ function compareTieBreak(a, b) {
 	if (ca !== 0) return ca;
 	const tc = a.to.localeCompare(b.to);
 	if (tc !== 0) return tc;
-	return a.migrationId.localeCompare(b.migrationId);
+	return a.migrationHash.localeCompare(b.migrationHash);
 }
 function sortedNeighbors(edges) {
 	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
 * 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 → migrationId.
+* 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) => forwardNeighbours(graph, n), bfsOrdering)) {
-		if (step.parent !== null && step.incomingEdge !== null) parents.set(step.node, {
+	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.node === toHash) {
+		if (step.state === toHash) {
 			const path = [];
 			let cur = toHash;
 			let p = parents.get(cur);
@@ -193,12 +195,90 @@ function findPath(graph, fromHash, toHash) {
 	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);
+	if (fromHash === toHash) return null;
+	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.node);
+	for (const step of bfs([toHash], (n) => reverseNeighbours(graph, n))) reached.add(step.state);
 	return reached;
 }
 /**
@@ -226,8 +306,8 @@ function findPathWithDecision(graph, fromHash, toHash, refName) {
 			if (reachable.length > 1) {
 				alternativeCount += reachable.length - 1;
 				const sorted = sortedNeighbors(reachable);
-				if (sorted[0] && sorted[0].migrationId === edge.migrationId) {
-					if (reachable.some((e) => e.migrationId !== edge.migrationId)) tieBreakReasons.push(`at ${edge.from}: ${reachable.length} candidates, selected by tie-break`);
+				if (sorted[0] && sorted[0].migrationHash === edge.migrationHash) {
+					if (reachable.some((e) => e.migrationHash !== edge.migrationHash)) tieBreakReasons.push(`at ${edge.from}: ${reachable.length} candidates, selected by tie-break`);
 				}
 			}
 		}
@@ -248,7 +328,7 @@ function findPathWithDecision(graph, fromHash, toHash, refName) {
 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.node);
+		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)));
@@ -270,7 +350,7 @@ function findDivergencePoint(graph, fromHash, leaves) {
 */
 function findReachableLeaves(graph, fromHash) {
 	const leaves = [];
-	for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n))) if (!graph.forwardChain.get(step.node)?.length) leaves.push(step.node);
+	for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n))) if (!graph.forwardChain.get(step.state)?.length) leaves.push(step.state);
 	return leaves;
 }
 /**
@@ -375,12 +455,12 @@ 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);
 	}
-	for (const step of bfs(startNodes, (n) => forwardNeighbours(graph, n))) reachable.add(step.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 { detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findReachableLeaves, reconstructGraph };
-//# sourceMappingURL=dag.mjs.map
+export { detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findPathWithInvariants, findReachableLeaves, reconstructGraph };
+//# sourceMappingURL=migration-graph.mjs.map