@prisma-next/migration-tools 0.11.0-dev.5 → 0.11.0-dev.50

package/dist/exports/io.d.mts

@@ -1,83 +1,2 @@
-import { n as OnDiskMigrationPackage, t as MigrationOps } from "../package-DZj8YvD0.mjs";
-import { MigrationMetadata, MigrationPackage } from "@prisma-next/framework-components/control";
-
-//#region src/io.d.ts
-declare function writeMigrationPackage(dir: string, metadata: MigrationMetadata, ops: MigrationOps): Promise<void>;
-/**
- * Materialise an in-memory {@link MigrationPackage} to a per-space
- * directory on disk.
- *
- * Writes two files under `<targetDir>/<pkg.dirName>/`:
- *
- * - `migration.json` — the manifest (pretty-printed, matches
- *   {@link writeMigrationPackage}'s output for byte-for-byte parity with
- *   app-space migrations).
- * - `ops.json` — the operation list (pretty-printed).
- *
- * Distinct verb from the lower-level {@link writeMigrationPackage}
- * (which takes constituent `(metadata, ops)`): callers reading
- * `materialise…` know they are persisting a struct-typed package.
- *
- * Overwrite-idempotent: the per-package directory is cleared before
- * each emit, so re-running against the same `targetDir` produces
- * byte-identical contents and never leaves stale files behind. The
- * lower-level {@link writeMigrationPackage} stays strict because the
- * CLI authoring path (`migration plan` / `migration new`) deliberately
- * refuses to clobber an existing authored migration; this helper is
- * the re-emit path that is supposed to converge on a single canonical
- * on-disk shape.
- *
- * The per-space head contract lives at
- * `<projectMigrationsDir>/<spaceId>/contract.json` (written by
- * {@link import('./emit-contract-space-artefacts').emitContractSpaceArtefacts}),
- * not inside the per-package directory. The runner reads only
- * `migration.json` + `ops.json` from each package.
- */
-declare function materialiseMigrationPackage(targetDir: string, pkg: MigrationPackage): Promise<void>;
-/**
- * Idempotent variant of {@link materialiseMigrationPackage}: writes the
- * package only if `<targetDir>/<pkg.dirName>/` does not already exist on
- * disk as a directory; returns `{ written: false }` when the package
- * directory is present (no rewrite, no comparison — by-existence skip).
- *
- * Concretely:
- *   - existing directory → skip silently, return `{ written: false }`.
- *   - missing path → write three files via {@link materialiseMigrationPackage},
- *     return `{ written: true }`.
- *   - path exists but is not a directory (file/symlink) → treated as
- *     missing; {@link materialiseMigrationPackage} will attempt creation
- *     and fail with an appropriate OS error.
- *   - any other I/O error from `stat` → propagated unchanged.
- *
- * Used by the CLI's `runContractSpaceExtensionMigrationsPass` to
- * materialise extension migration packages into a project's
- * `migrations/<spaceId>/` directory, and by extension-package tests
- * that mirror the same idempotent-rematerialise property locally
- * without taking a CLI dependency.
- */
-declare function materialiseExtensionMigrationPackageIfMissing(targetDir: string, pkg: MigrationPackage): Promise<{
-  readonly written: boolean;
-}>;
-/**
- * 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.*`).
- */
-declare function copyFilesWithRename(destDir: string, files: readonly {
-  readonly sourcePath: string;
-  readonly destName: string;
-}[]): Promise<void>;
-declare function writeMigrationMetadata(dir: string, metadata: MigrationMetadata): Promise<void>;
-declare function writeMigrationOps(dir: string, ops: MigrationOps): Promise<void>;
-declare function readMigrationPackage(dir: string): Promise<OnDiskMigrationPackage>;
-declare function readMigrationsDir(migrationsRoot: string): Promise<readonly OnDiskMigrationPackage[]>;
-declare function formatMigrationDirName(timestamp: Date, slug: string): string;
-//#endregion
-export { copyFilesWithRename, formatMigrationDirName, materialiseExtensionMigrationPackageIfMissing, materialiseMigrationPackage, readMigrationPackage, readMigrationsDir, writeMigrationMetadata, writeMigrationOps, writeMigrationPackage };
-//# sourceMappingURL=io.d.mts.map
+import { a as materialiseExtensionMigrationPackageIfMissing, c as readMigrationsDir, d as writeMigrationPackage, i as formatMigrationDirName, l as writeMigrationMetadata, n as ReadMigrationsDirResult, o as materialiseMigrationPackage, r as copyFilesWithRename, s as readMigrationPackage, t as PackageLoadProblem, u as writeMigrationOps } from "../io-nqFXSSTN.mjs";
+export { type PackageLoadProblem, type ReadMigrationsDirResult, copyFilesWithRename, formatMigrationDirName, materialiseExtensionMigrationPackageIfMissing, materialiseMigrationPackage, readMigrationPackage, readMigrationsDir, writeMigrationMetadata, writeMigrationOps, writeMigrationPackage };

package/dist/exports/io.mjs

@@ -1,2 +1,2 @@
-import { a as materialiseMigrationPackage, c as writeMigrationMetadata, i as materialiseExtensionMigrationPackageIfMissing, l as writeMigrationOps, n as copyFilesWithRename, o as readMigrationPackage, r as formatMigrationDirName, s as readMigrationsDir, u as writeMigrationPackage } from "../io-BPLfzvZe.mjs";
+import { a as materialiseMigrationPackage, c as writeMigrationMetadata, i as materialiseExtensionMigrationPackageIfMissing, l as writeMigrationOps, n as copyFilesWithRename, o as readMigrationPackage, r as formatMigrationDirName, s as readMigrationsDir, u as writeMigrationPackage } from "../io-BHl0amF0.mjs";
 export { copyFilesWithRename, formatMigrationDirName, materialiseExtensionMigrationPackageIfMissing, materialiseMigrationPackage, readMigrationPackage, readMigrationsDir, writeMigrationMetadata, writeMigrationOps, writeMigrationPackage };

package/dist/exports/metadata.d.mts

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

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

@@ -1,2 +1,9 @@
-import { a as findLeaf, c as findPathWithInvariants, i as findLatestMigration, l as findReachableLeaves, n as detectCycles, o as findPath, r as detectOrphans, s as findPathWithDecision, t as PathDecision, u as reconstructGraph } from "../migration-graph-De0dUZoC.mjs";
-export { type PathDecision, detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findPathWithInvariants, findReachableLeaves, reconstructGraph };
+import { n as MigrationGraph } from "../graph-BUZuUeBC.mjs";
+import { a as findLeaf, c as findPathWithInvariants, i as findLatestMigration, l as findReachableLeaves, n as detectCycles, o as findPath, r as detectOrphans, s as findPathWithDecision, t as PathDecision, u as reconstructGraph } from "../migration-graph-DtNT-cqc.mjs";
+
+//#region src/graph-membership.d.ts
+declare function isGraphNode(hash: string, graph: MigrationGraph): boolean;
+declare function assertHashIsGraphNode(hash: string, graph: MigrationGraph): asserts hash is string;
+//#endregion
+export { type PathDecision, assertHashIsGraphNode, detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findPathWithInvariants, findReachableLeaves, isGraphNode, 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/graph-membership.ts"],"mappings":";;;;iBAIgB,WAAA,CAAY,IAAA,UAAc,KAAA,EAAO,cAAc;AAAA,iBAO/C,qBAAA,CAAsB,IAAA,UAAc,KAAA,EAAO,cAAc,WAAW,IAAA"}

package/dist/exports/migration-graph.mjs

@@ -1,2 +1,16 @@
-import { a as findPath, c as findReachableLeaves, i as findLeaf, l as reconstructGraph, n as detectOrphans, o as findPathWithDecision, r as findLatestMigration, s as findPathWithInvariants, t as detectCycles } from "../migration-graph-nlS4TRpn.mjs";
-export { detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findPathWithInvariants, findReachableLeaves, reconstructGraph };
+import { s as errorHashNotInGraph } from "../errors-4YabujxZ.mjs";
+import "../constants-DWV9_o2Z.mjs";
+import { a as findPath, c as findReachableLeaves, i as findLeaf, l as reconstructGraph, n as detectOrphans, o as findPathWithDecision, r as findLatestMigration, s as findPathWithInvariants, t as detectCycles } from "../migration-graph-kGBkIZDa.mjs";
+//#region src/graph-membership.ts
+function isGraphNode(hash, graph) {
+	if (hash === "sha256:empty") return true;
+	return graph.nodes.has(hash);
+}
+function assertHashIsGraphNode(hash, graph) {
+	if (isGraphNode(hash, graph)) return;
+	throw errorHashNotInGraph(hash, graph);
+}
+//#endregion
+export { assertHashIsGraphNode, detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findPathWithInvariants, findReachableLeaves, isGraphNode, reconstructGraph };
+
+//# sourceMappingURL=migration-graph.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration-graph.mjs","names":[],"sources":["../../src/graph-membership.ts"],"sourcesContent":["import { EMPTY_CONTRACT_HASH } from './constants';\nimport { errorHashNotInGraph } from './errors';\nimport type { MigrationGraph } from './graph';\n\nexport function isGraphNode(hash: string, graph: MigrationGraph): boolean {\n  if (hash === EMPTY_CONTRACT_HASH) {\n    return true;\n  }\n  return graph.nodes.has(hash);\n}\n\nexport function assertHashIsGraphNode(hash: string, graph: MigrationGraph): asserts hash is string {\n  if (isGraphNode(hash, graph)) {\n    return;\n  }\n  throw errorHashNotInGraph(hash, graph);\n}\n"],"mappings":";;;;AAIA,SAAgB,YAAY,MAAc,OAAgC;CACxE,IAAI,SAAA,gBACF,OAAO;CAET,OAAO,MAAM,MAAM,IAAI,IAAI;AAC7B;AAEA,SAAgB,sBAAsB,MAAc,OAA+C;CACjG,IAAI,YAAY,MAAM,KAAK,GACzB;CAEF,MAAM,oBAAoB,MAAM,KAAK;AACvC"}

package/dist/exports/migration-list-graph-topology.d.mts

@@ -0,0 +1,13 @@
+import { t as MigrationListEntry } from "../migration-list-types-BRTuXR8i.mjs";
+
+//#region src/migration-list-graph-topology.d.ts
+type MigrationEdgeKind = 'forward' | 'rollback' | 'self';
+interface MigrationListGraphTopology {
+  readonly kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>;
+  readonly forwardInDegree: ReadonlyMap<string, number>;
+  readonly forwardOutDegree: ReadonlyMap<string, number>;
+}
+declare function classifyMigrationListGraphTopology(entries: readonly MigrationListEntry[]): MigrationListGraphTopology;
+//#endregion
+export { type MigrationEdgeKind, type MigrationListGraphTopology, classifyMigrationListGraphTopology };
+//# sourceMappingURL=migration-list-graph-topology.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration-list-graph-topology.d.mts","names":[],"sources":["../../src/migration-list-graph-topology.ts"],"mappings":";;;KAGY,iBAAA;AAAA,UAEK,0BAAA;EAAA,SACN,mBAAA,EAAqB,WAAA,SAAoB,iBAAA;EAAA,SACzC,eAAA,EAAiB,WAAA;EAAA,SACjB,gBAAA,EAAkB,WAAA;AAAA;AAAA,iBAqBb,kCAAA,CACd,OAAA,WAAkB,kBAAA,KACjB,0BAA0B"}

package/dist/exports/migration-list-graph-topology.mjs

@@ -0,0 +1,105 @@
+import "../constants-DWV9_o2Z.mjs";
+//#region src/migration-list-graph-topology.ts
+function canonicalFrom(from) {
+	return from ?? "sha256:empty";
+}
+function compareDirNameDesc(a, b) {
+	return b.dirName.localeCompare(a.dirName);
+}
+function bumpDegree(map, key) {
+	map.set(key, (map.get(key) ?? 0) + 1);
+}
+function classifyMigrationListGraphTopology(entries) {
+	const nodes = /* @__PURE__ */ new Set();
+	const kindByMigrationHash = /* @__PURE__ */ new Map();
+	const outgoingByFrom = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const from = canonicalFrom(entry.from);
+		const to = entry.to;
+		nodes.add(from);
+		nodes.add(to);
+		if (from === to) {
+			kindByMigrationHash.set(entry.migrationHash, "self");
+			continue;
+		}
+		const bucket = outgoingByFrom.get(from);
+		const edge = {
+			entry,
+			from,
+			to
+		};
+		if (bucket) bucket.push(edge);
+		else outgoingByFrom.set(from, [edge]);
+	}
+	for (const bucket of outgoingByFrom.values()) bucket.sort((a, b) => compareDirNameDesc(a.entry, b.entry));
+	const nonSelfInDegree = /* @__PURE__ */ new Map();
+	for (const node of nodes) nonSelfInDegree.set(node, 0);
+	for (const bucket of outgoingByFrom.values()) for (const edge of bucket) bumpDegree(nonSelfInDegree, edge.to);
+	const dfsRoots = [];
+	for (const node of nodes) if ((nonSelfInDegree.get(node) ?? 0) === 0) dfsRoots.push(node);
+	dfsRoots.sort((a, b) => {
+		if (a === "sha256:empty") return -1;
+		if (b === "sha256:empty") return 1;
+		return a.localeCompare(b);
+	});
+	if (dfsRoots.length === 0) dfsRoots.push(...[...nodes].sort((a, b) => a.localeCompare(b)));
+	const WHITE = 0;
+	const GRAY = 1;
+	const BLACK = 2;
+	const color = /* @__PURE__ */ new Map();
+	for (const node of nodes) color.set(node, WHITE);
+	const stack = [];
+	function pushFrame(node) {
+		color.set(node, GRAY);
+		stack.push({
+			node,
+			outgoing: outgoingByFrom.get(node) ?? [],
+			index: 0
+		});
+	}
+	function runDfsFrom(root) {
+		if (color.get(root) !== WHITE) return;
+		pushFrame(root);
+		while (stack.length > 0) {
+			const frame = stack[stack.length - 1];
+			if (frame === void 0) break;
+			if (frame.index >= frame.outgoing.length) {
+				color.set(frame.node, BLACK);
+				stack.pop();
+				continue;
+			}
+			const edge = frame.outgoing[frame.index];
+			frame.index += 1;
+			if (edge === void 0) continue;
+			const v = edge.to;
+			const vColor = color.get(v);
+			if (vColor === GRAY) kindByMigrationHash.set(edge.entry.migrationHash, "rollback");
+			else {
+				kindByMigrationHash.set(edge.entry.migrationHash, "forward");
+				if (vColor === WHITE) pushFrame(v);
+			}
+		}
+	}
+	for (const root of dfsRoots) runDfsFrom(root);
+	const remainingWhite = [...nodes].filter((node) => color.get(node) === WHITE);
+	remainingWhite.sort((a, b) => a.localeCompare(b));
+	for (const root of remainingWhite) runDfsFrom(root);
+	const forwardInDegree = /* @__PURE__ */ new Map();
+	const forwardOutDegree = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (kindByMigrationHash.get(entry.migrationHash) !== "forward") continue;
+		const from = canonicalFrom(entry.from);
+		const to = entry.to;
+		bumpDegree(forwardOutDegree, from);
+		bumpDegree(forwardInDegree, to);
+	}
+	return {
+		kindByMigrationHash,
+		forwardInDegree,
+		forwardOutDegree
+	};
+}
+//#endregion
+export { classifyMigrationListGraphTopology };
+
+//# sourceMappingURL=migration-list-graph-topology.mjs.map

package/dist/exports/migration-list-graph-topology.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-list-graph-topology.mjs","names":[],"sources":["../../src/migration-list-graph-topology.ts"],"sourcesContent":["import { EMPTY_CONTRACT_HASH } from './constants';\nimport type { MigrationListEntry } from './migration-list-types';\n\nexport type MigrationEdgeKind = 'forward' | 'rollback' | 'self';\n\nexport interface MigrationListGraphTopology {\n  readonly kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>;\n  readonly forwardInDegree: ReadonlyMap<string, number>;\n  readonly forwardOutDegree: ReadonlyMap<string, number>;\n}\n\ninterface NonSelfEdge {\n  readonly entry: MigrationListEntry;\n  readonly from: string;\n  readonly to: string;\n}\n\nfunction canonicalFrom(from: string | null): string {\n  return from ?? EMPTY_CONTRACT_HASH;\n}\n\nfunction compareDirNameDesc(a: MigrationListEntry, b: MigrationListEntry): number {\n  return b.dirName.localeCompare(a.dirName);\n}\n\nfunction bumpDegree(map: Map<string, number>, key: string): void {\n  map.set(key, (map.get(key) ?? 0) + 1);\n}\n\nexport function classifyMigrationListGraphTopology(\n  entries: readonly MigrationListEntry[],\n): MigrationListGraphTopology {\n  const nodes = new Set<string>();\n  const kindByMigrationHash = new Map<string, MigrationEdgeKind>();\n  const outgoingByFrom = new Map<string, NonSelfEdge[]>();\n\n  for (const entry of entries) {\n    const from = canonicalFrom(entry.from);\n    const to = entry.to;\n    nodes.add(from);\n    nodes.add(to);\n\n    if (from === to) {\n      kindByMigrationHash.set(entry.migrationHash, 'self');\n      continue;\n    }\n\n    const bucket = outgoingByFrom.get(from);\n    const edge: NonSelfEdge = { entry, from, to };\n    if (bucket) bucket.push(edge);\n    else outgoingByFrom.set(from, [edge]);\n  }\n\n  for (const bucket of outgoingByFrom.values()) {\n    bucket.sort((a, b) => compareDirNameDesc(a.entry, b.entry));\n  }\n\n  const nonSelfInDegree = new Map<string, number>();\n  for (const node of nodes) {\n    nonSelfInDegree.set(node, 0);\n  }\n  for (const bucket of outgoingByFrom.values()) {\n    for (const edge of bucket) {\n      bumpDegree(nonSelfInDegree, edge.to);\n    }\n  }\n\n  const dfsRoots: string[] = [];\n  for (const node of nodes) {\n    if ((nonSelfInDegree.get(node) ?? 0) === 0) {\n      dfsRoots.push(node);\n    }\n  }\n  dfsRoots.sort((a, b) => {\n    if (a === EMPTY_CONTRACT_HASH) return -1;\n    if (b === EMPTY_CONTRACT_HASH) return 1;\n    return a.localeCompare(b);\n  });\n  if (dfsRoots.length === 0) {\n    dfsRoots.push(...[...nodes].sort((a, b) => a.localeCompare(b)));\n  }\n\n  const WHITE = 0;\n  const GRAY = 1;\n  const BLACK = 2;\n  const color = new Map<string, number>();\n  for (const node of nodes) {\n    color.set(node, WHITE);\n  }\n\n  interface Frame {\n    node: string;\n    outgoing: readonly NonSelfEdge[];\n    index: number;\n  }\n  const stack: Frame[] = [];\n\n  function pushFrame(node: string): void {\n    color.set(node, GRAY);\n    stack.push({ node, outgoing: outgoingByFrom.get(node) ?? [], index: 0 });\n  }\n\n  function runDfsFrom(root: string): void {\n    if (color.get(root) !== WHITE) return;\n    pushFrame(root);\n\n    while (stack.length > 0) {\n      const frame = stack[stack.length - 1];\n      if (frame === undefined) break;\n      if (frame.index >= frame.outgoing.length) {\n        color.set(frame.node, BLACK);\n        stack.pop();\n        continue;\n      }\n\n      const edge = frame.outgoing[frame.index];\n      frame.index += 1;\n      if (edge === undefined) continue;\n\n      const v = edge.to;\n      const vColor = color.get(v);\n      if (vColor === GRAY) {\n        kindByMigrationHash.set(edge.entry.migrationHash, 'rollback');\n      } else {\n        kindByMigrationHash.set(edge.entry.migrationHash, 'forward');\n        if (vColor === WHITE) {\n          pushFrame(v);\n        }\n      }\n    }\n  }\n\n  for (const root of dfsRoots) {\n    runDfsFrom(root);\n  }\n  const remainingWhite = [...nodes].filter((node) => color.get(node) === WHITE);\n  remainingWhite.sort((a, b) => a.localeCompare(b));\n  for (const root of remainingWhite) {\n    runDfsFrom(root);\n  }\n\n  const forwardInDegree = new Map<string, number>();\n  const forwardOutDegree = new Map<string, number>();\n\n  for (const entry of entries) {\n    if (kindByMigrationHash.get(entry.migrationHash) !== 'forward') continue;\n    const from = canonicalFrom(entry.from);\n    const to = entry.to;\n    bumpDegree(forwardOutDegree, from);\n    bumpDegree(forwardInDegree, to);\n  }\n\n  return {\n    kindByMigrationHash,\n    forwardInDegree,\n    forwardOutDegree,\n  };\n}\n"],"mappings":"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"}

package/dist/exports/migration-list-types.d.mts

@@ -0,0 +1,2 @@
+import { n as MigrationListResult, r as MigrationSpaceListEntry, t as MigrationListEntry } from "../migration-list-types-BRTuXR8i.mjs";
+export { type MigrationListEntry, type MigrationListResult, type MigrationSpaceListEntry };

package/dist/exports/migration-list-types.mjs

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

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"],"mappings":";;AA8BA;;;;;;;;;AAsBA;;;;;;;;ACpDA;;;;;iBD8BsB,gBAAA,CAAiB,UAAA,UAAoB,OAAA,WAAkB,OAAA;;;;iBAsBvD,cAAA,CAAe,UAAA,WAAqB,OAAA;;;KCpD9C,eAAA;AAAA,iBAEI,qBAAA,CAAA,GAAyB,eAAA;AAAA,iBAMzB,cAAA,CAAe,OAAA,EAAS,eAAA"}
+{"version":3,"file":"migration-ts.d.mts","names":[],"sources":["../../src/migration-ts.ts","../../src/runtime-detection.ts"],"mappings":";;AA8BA;;;;;;;;AAAoF;AAsBpF;;;;AAAiE;;;;ACpDjE;;;;AAA2B;iBD8BL,gBAAA,CAAiB,UAAA,UAAoB,OAAA,WAAkB,OAAO;;;;iBAsB9D,cAAA,CAAe,UAAA,WAAqB,OAAO;;;KCpDrD,eAAA;AAAA,iBAEI,qBAAA,CAAA,GAAyB,eAAe;AAAA,iBAMxC,cAAA,CAAe,OAAwB,EAAf,eAAe"}

package/dist/exports/migration-ts.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"migration-ts.mjs","names":[],"sources":["../../src/migration-ts.ts","../../src/runtime-detection.ts"],"sourcesContent":["/**\n * Utilities for reading/writing `migration.ts` files.\n *\n * Rendering migration.ts source is the target's responsibility — the CLI\n * obtains source strings from a planner's `plan.renderTypeScript()`. The\n * helper here is limited to file I/O: writing the returned source with the\n * right executable bit and probing for existence.\n */\n\nimport { stat, writeFile } from 'node:fs/promises';\nimport { join } from 'pathe';\nimport { format } from 'prettier';\n\nconst MIGRATION_TS_FILE = 'migration.ts';\n\n/**\n * Writes a pre-rendered `migration.ts` source string to the given package\n * directory. If the source begins with a shebang, the file is written with\n * executable permissions (0o755) so it can be run directly via\n * `./migration.ts` — the rendered scaffold ends with\n * `MigrationCLI.run(import.meta.url, M)` from\n * `@prisma-next/cli/migration-cli` (re-exported by the postgres facade),\n * which guards on the entrypoint and serializes when the file is the main\n * module.\n *\n * The source is run through prettier before writing so migration renderers\n * can produce structurally-correct but loosely-indented source and rely on\n * a single canonical format on disk. Matches what `@prisma-next/emitter`\n * already does for generated `contract.d.ts`.\n */\nexport async function writeMigrationTs(packageDir: string, content: string): Promise<void> {\n  const formatted = await formatMigrationTsSource(content);\n  const isExecutable = formatted.startsWith('#!');\n  await writeFile(\n    join(packageDir, MIGRATION_TS_FILE),\n    formatted,\n    isExecutable ? { mode: 0o755 } : undefined,\n  );\n}\n\nasync function formatMigrationTsSource(source: string): Promise<string> {\n  return format(source, {\n    parser: 'typescript',\n    singleQuote: true,\n    semi: true,\n    printWidth: 100,\n  });\n}\n\n/**\n * Checks whether a migration.ts file exists in the package directory.\n */\nexport async function hasMigrationTs(packageDir: string): Promise<boolean> {\n  try {\n    const s = await stat(join(packageDir, MIGRATION_TS_FILE));\n    return s.isFile();\n  } catch {\n    return false;\n  }\n}\n","export type ScaffoldRuntime = 'node' | 'bun' | 'deno';\n\nexport function detectScaffoldRuntime(): ScaffoldRuntime {\n  if (typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined') return 'bun';\n  if (typeof (globalThis as { Deno?: unknown }).Deno !== 'undefined') return 'deno';\n  return 'node';\n}\n\nexport function shebangLineFor(runtime: ScaffoldRuntime): string {\n  switch (runtime) {\n    case 'bun':\n      return '#!/usr/bin/env -S bun';\n    case 'deno':\n      return '#!/usr/bin/env -S deno run -A';\n    case 'node':\n      return '#!/usr/bin/env -S node';\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAaA,MAAM,oBAAoB;;;;;;;;;;;;;;;;AAiB1B,eAAsB,iBAAiB,YAAoB,SAAgC;CACzF,MAAM,YAAY,MAAM,wBAAwB,QAAQ;CACxD,MAAM,eAAe,UAAU,WAAW,KAAK;CAC/C,MAAM,UACJ,KAAK,YAAY,kBAAkB,EACnC,WACA,eAAe,EAAE,MAAM,KAAO,GAAG,KAAA,EAClC;;AAGH,eAAe,wBAAwB,QAAiC;CACtE,OAAO,OAAO,QAAQ;EACpB,QAAQ;EACR,aAAa;EACb,MAAM;EACN,YAAY;EACb,CAAC;;;;;AAMJ,eAAsB,eAAe,YAAsC;CACzE,IAAI;EAEF,QAAO,MADS,KAAK,KAAK,YAAY,kBAAkB,CAAC,EAChD,QAAQ;SACX;EACN,OAAO;;;;;ACvDX,SAAgB,wBAAyC;CACvD,IAAI,OAAQ,WAAiC,QAAQ,aAAa,OAAO;CACzE,IAAI,OAAQ,WAAkC,SAAS,aAAa,OAAO;CAC3E,OAAO;;AAGT,SAAgB,eAAe,SAAkC;CAC/D,QAAQ,SAAR;EACE,KAAK,OACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,KAAK,QACH,OAAO"}
+{"version":3,"file":"migration-ts.mjs","names":[],"sources":["../../src/migration-ts.ts","../../src/runtime-detection.ts"],"sourcesContent":["/**\n * Utilities for reading/writing `migration.ts` files.\n *\n * Rendering migration.ts source is the target's responsibility — the CLI\n * obtains source strings from a planner's `plan.renderTypeScript()`. The\n * helper here is limited to file I/O: writing the returned source with the\n * right executable bit and probing for existence.\n */\n\nimport { stat, writeFile } from 'node:fs/promises';\nimport { join } from 'pathe';\nimport { format } from 'prettier';\n\nconst MIGRATION_TS_FILE = 'migration.ts';\n\n/**\n * Writes a pre-rendered `migration.ts` source string to the given package\n * directory. If the source begins with a shebang, the file is written with\n * executable permissions (0o755) so it can be run directly via\n * `./migration.ts` — the rendered scaffold ends with\n * `MigrationCLI.run(import.meta.url, M)` from\n * `@prisma-next/cli/migration-cli` (re-exported by the postgres facade),\n * which guards on the entrypoint and serializes when the file is the main\n * module.\n *\n * The source is run through prettier before writing so migration renderers\n * can produce structurally-correct but loosely-indented source and rely on\n * a single canonical format on disk. Matches what `@prisma-next/emitter`\n * already does for generated `contract.d.ts`.\n */\nexport async function writeMigrationTs(packageDir: string, content: string): Promise<void> {\n  const formatted = await formatMigrationTsSource(content);\n  const isExecutable = formatted.startsWith('#!');\n  await writeFile(\n    join(packageDir, MIGRATION_TS_FILE),\n    formatted,\n    isExecutable ? { mode: 0o755 } : undefined,\n  );\n}\n\nasync function formatMigrationTsSource(source: string): Promise<string> {\n  return format(source, {\n    parser: 'typescript',\n    singleQuote: true,\n    semi: true,\n    printWidth: 100,\n  });\n}\n\n/**\n * Checks whether a migration.ts file exists in the package directory.\n */\nexport async function hasMigrationTs(packageDir: string): Promise<boolean> {\n  try {\n    const s = await stat(join(packageDir, MIGRATION_TS_FILE));\n    return s.isFile();\n  } catch {\n    return false;\n  }\n}\n","export type ScaffoldRuntime = 'node' | 'bun' | 'deno';\n\nexport function detectScaffoldRuntime(): ScaffoldRuntime {\n  if (typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined') return 'bun';\n  if (typeof (globalThis as { Deno?: unknown }).Deno !== 'undefined') return 'deno';\n  return 'node';\n}\n\nexport function shebangLineFor(runtime: ScaffoldRuntime): string {\n  switch (runtime) {\n    case 'bun':\n      return '#!/usr/bin/env -S bun';\n    case 'deno':\n      return '#!/usr/bin/env -S deno run -A';\n    case 'node':\n      return '#!/usr/bin/env -S node';\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAaA,MAAM,oBAAoB;;;;;;;;;;;;;;;;AAiB1B,eAAsB,iBAAiB,YAAoB,SAAgC;CACzF,MAAM,YAAY,MAAM,wBAAwB,OAAO;CACvD,MAAM,eAAe,UAAU,WAAW,IAAI;CAC9C,MAAM,UACJ,KAAK,YAAY,iBAAiB,GAClC,WACA,eAAe,EAAE,MAAM,IAAM,IAAI,KAAA,CACnC;AACF;AAEA,eAAe,wBAAwB,QAAiC;CACtE,OAAO,OAAO,QAAQ;EACpB,QAAQ;EACR,aAAa;EACb,MAAM;EACN,YAAY;CACd,CAAC;AACH;;;;AAKA,eAAsB,eAAe,YAAsC;CACzE,IAAI;EAEF,QAAO,MADS,KAAK,KAAK,YAAY,iBAAiB,CAAC,GAC/C,OAAO;CAClB,QAAQ;EACN,OAAO;CACT;AACF;;;ACzDA,SAAgB,wBAAyC;CACvD,IAAI,OAAQ,WAAiC,QAAQ,aAAa,OAAO;CACzE,IAAI,OAAQ,WAAkC,SAAS,aAAa,OAAO;CAC3E,OAAO;AACT;AAEA,SAAgB,eAAe,SAAkC;CAC/D,QAAQ,SAAR;EACE,KAAK,OACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,KAAK,QACH,OAAO;CACX;AACF"}

package/dist/exports/migration.d.mts

@@ -1,11 +1,10 @@
-import { n as MigrationMetadata$1 } from "../metadata-BFX0xdz8.mjs";
+import { t as MigrationMetadata$1 } from "../metadata-Bp9X04gM.mjs";
 import { ControlStack, MigrationPlan, MigrationPlanOperation } from "@prisma-next/framework-components/control";
 
 //#region src/migration-base.d.ts
 interface MigrationMeta {
   readonly from: string | null;
   readonly to: string;
-  readonly labels?: readonly string[];
 }
 /**
  * Base class for migrations.
@@ -77,10 +76,10 @@ interface MigrationArtifacts {
  * Pure conversion from a `Migration` instance (plus the previously
  * scaffolded metadata, when one exists on disk) to the in-memory
  * artifacts that downstream tooling persists. Owns metadata validation,
- * metadata synthesis/preservation, hint normalization, and the
- * content-addressed `migrationHash` computation, but performs no file I/O
- * — callers handle reads (to source `existing`) and writes (to persist
- * `opsJson` / `metadataJson`).
+ * metadata synthesis/preservation, and the content-addressed
+ * `migrationHash` computation, but performs no file I/O — callers handle
+ * reads (to source `existing`) and writes (to persist `opsJson` /
+ * `metadataJson`).
  */
 declare function buildMigrationArtifacts(instance: Migration, existing: Partial<MigrationMetadata$1> | null): MigrationArtifacts;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"migration.d.mts","names":[],"sources":["../../src/migration-base.ts"],"mappings":";;;;UAeiB,aAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA;EAAA,SACA,MAAA;AAAA;;;;;;;AAuBX;;;uBAAsB,SAAA,oBACD,sBAAA,GAAyB,sBAAA,mFAGjC,aAAA;EAAA,kBAEO,QAAA;EAWqB;;;;;;;;;EAAA,mBAApB,KAAA,EAAO,YAAA,CAAa,SAAA,EAAW,SAAA;cAEtC,KAAA,GAAQ,YAAA,CAAa,SAAA,EAAW,SAAA;EAlB5C;;;;;;EAAA,aA4Ba,UAAA,CAAA,YAAuB,UAAA;EAZjB;;;;;EAAA,SAmBV,QAAA,CAAA,GAAY,aAAA;EAAA,IAEjB,MAAA,CAAA;IAAA,SAAqB,WAAA;EAAA;EAAA,IAKrB,WAAA,CAAA;IAAA,SAA0B,WAAA;EAAA;AAAA;;;;;;;AAYhC;iBAAgB,kBAAA,CAAmB,aAAA;;;;AAsBnC;;;;;;;;UAAiB,kBAAA;EAAA,SACN,OAAA;EAAA,SACA,QAAA,EAAU,mBAAA;EAAA,SACV,YAAA;AAAA;;;;;;;;;;iBA8DK,uBAAA,CACd,QAAA,EAAU,SAAA,EACV,QAAA,EAAU,OAAA,CAAQ,mBAAA,WACjB,kBAAA"}
+{"version":3,"file":"migration.d.mts","names":[],"sources":["../../src/migration-base.ts"],"mappings":";;;;UAeiB,aAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAE;AAAA;;;AAAA;AAsBb;;;;;;uBAAsB,SAAA,oBACD,sBAAA,GAAyB,sBAAA,mFAGjC,aAAA;EAAA,kBAEO,QAAA;EAae;;;;;;;;;EAAA,mBAFd,KAAA,EAAO,YAAA,CAAa,SAAA,EAAW,SAAA;cAEtC,KAAA,GAAQ,YAAA,CAAa,SAAA,EAAW,SAAA;EAjB5C;;;;;;EAAA,aA2Ba,UAAA,CAAA,YAAuB,UAAA;EAZc;;;;;EAAA,SAmBzC,QAAA,CAAA,GAAY,aAAA;EAAA,IAEjB,MAAA,CAAA;IAAA,SAAqB,WAAA;EAAA;EAAA,IAKrB,WAAA,CAAA;IAAA,SAA0B,WAAA;EAAA;AAAA;;;AAAW;AAY3C;;;;iBAAgB,kBAAA,CAAmB,aAAqB;AAsBxD;;;;;;;;;AAGuB;AA4CvB;AA/CA,UAAiB,kBAAA;EAAA,SACN,OAAA;EAAA,SACA,QAAA,EAAU,mBAAiB;EAAA,SAC3B,YAAA;AAAA;;;;;;;;;;iBA4CK,uBAAA,CACd,QAAA,EAAU,SAAA,EACV,QAAA,EAAU,OAAA,CAAQ,mBAAA,WACjB,kBAAA"}

package/dist/exports/migration.mjs

@@ -1,6 +1,6 @@
-import { f as errorInvalidOperationEntry } from "../errors-DGYwcwXs.mjs";
-import { t as computeMigrationHash } from "../hash-Cr4WIr4Z.mjs";
-import { t as deriveProvidedInvariants } from "../invariants-0daYEzyo.mjs";
+import { f as errorInvalidOperationEntry } from "../errors-4YabujxZ.mjs";
+import { t as computeMigrationHash } from "../hash--Y7vCpN3.mjs";
+import { t as deriveProvidedInvariants } from "../invariants-CCOAyg6c.mjs";
 import { t as MigrationOpSchema } from "../op-schema-D5qkXfEf.mjs";
 import { type } from "arktype";
 import { realpathSync } from "node:fs";
@@ -8,8 +8,7 @@ import { fileURLToPath } from "node:url";
 //#region src/migration-base.ts
 const MigrationMetaSchema = type({
 	from: "string > 0 | null",
-	to: "string",
-	"labels?": type("string").array()
+	to: "string"
 });
 /**
 * Base class for migrations.
@@ -64,12 +63,11 @@ function isDirectEntrypoint(importMetaUrl) {
 * operations list, and the previously-scaffolded metadata (if any).
 *
 * When a `migration.json` already exists for this package (the common
-* case: it was scaffolded by `migration plan`), preserve the contract
-* bookends, hints, labels, and `createdAt` set there — those fields are
-* owned by the CLI scaffolder, not the authored class. Only the
-* `describe()`-derived fields (`from`, `to`) and the operations
-* change as the author iterates. When no metadata exists yet (a bare
-* `migration.ts` run from scratch), synthesize a minimal but
+* case: it was scaffolded by `migration plan`), preserve `createdAt`
+* set there — that field is owned by the CLI scaffolder, not the authored
+* class. Only the `describe()`-derived fields (`from`, `to`) and the
+* operations change as the author iterates. When no metadata exists yet
+* (a bare `migration.ts` run from scratch), synthesize a minimal but
 * schema-conformant record so the resulting package can still be read,
 * verified, and applied.
 *
@@ -80,10 +78,8 @@ function buildAttestedMetadata(meta, ops, existing) {
 	const baseMetadata = {
 		from: meta.from,
 		to: meta.to,
-		labels: meta.labels ?? existing?.labels ?? [],
 		providedInvariants: deriveProvidedInvariants(ops),
-		createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-		hints: normalizeHints(existing?.hints)
+		createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
 	};
 	const migrationHash = computeMigrationHash(baseMetadata, ops);
 	return {
@@ -92,27 +88,13 @@ function buildAttestedMetadata(meta, ops, existing) {
 	};
 }
 /**
-* Project `existing.hints` down to the known `MigrationHints` shape, dropping
-* any legacy keys that may linger in metadata scaffolded by older CLI
-* versions (e.g. `planningStrategy`). Picking fields explicitly instead of
-* spreading keeps refreshed `migration.json` files schema-clean regardless
-* of what was on disk before.
-*/
-function normalizeHints(existing) {
-	return {
-		used: existing?.used ?? [],
-		applied: existing?.applied ?? [],
-		plannerVersion: existing?.plannerVersion ?? "2.0.0"
-	};
-}
-/**
 * Pure conversion from a `Migration` instance (plus the previously
 * scaffolded metadata, when one exists on disk) to the in-memory
 * artifacts that downstream tooling persists. Owns metadata validation,
-* metadata synthesis/preservation, hint normalization, and the
-* content-addressed `migrationHash` computation, but performs no file I/O
-* — callers handle reads (to source `existing`) and writes (to persist
-* `opsJson` / `metadataJson`).
+* metadata synthesis/preservation, and the content-addressed
+* `migrationHash` computation, but performs no file I/O — callers handle
+* reads (to source `existing`) and writes (to persist `opsJson` /
+* `metadataJson`).
 */
 function buildMigrationArtifacts(instance, existing) {
 	const ops = instance.operations;

package/dist/exports/migration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"migration.mjs","names":[],"sources":["../../src/migration-base.ts"],"sourcesContent":["import { realpathSync } from 'node:fs';\nimport { fileURLToPath } from 'node:url';\nimport type {\n  ControlStack,\n  MigrationPlan,\n  MigrationPlanOperation,\n} from '@prisma-next/framework-components/control';\nimport { type } from 'arktype';\nimport { errorInvalidOperationEntry } from './errors';\nimport { computeMigrationHash } from './hash';\nimport { deriveProvidedInvariants } from './invariants';\nimport type { MigrationHints, MigrationMetadata } from './metadata';\nimport { MigrationOpSchema } from './op-schema';\nimport type { MigrationOps } from './package';\n\nexport interface MigrationMeta {\n  readonly from: string | null;\n  readonly to: string;\n  readonly labels?: readonly string[];\n}\n\n// `from` rejects empty strings to mirror `MigrationMetadataSchema` in\n// `./io.ts`. Without this match, an authored migration could `describe()` with\n// `from: ''` and pass `buildMigrationArtifacts`'s validation, only to have\n// `readMigrationPackage` reject the resulting `migration.json` later — the\n// two validators must agree on the legal value space.\nconst MigrationMetaSchema = type({\n  from: 'string > 0 | null',\n  to: 'string',\n  'labels?': type('string').array(),\n});\n\n/**\n * Base class for migrations.\n *\n * A `Migration` subclass is itself a `MigrationPlan`: CLI commands and the\n * runner can consume it directly via `targetId`, `operations`, `origin`, and\n * `destination`. The metadata-shaped inputs come from `describe()`, which\n * every migration must implement — `migration.json` is required for a\n * migration to be valid.\n */\nexport abstract class Migration<\n  TOperation extends MigrationPlanOperation = MigrationPlanOperation,\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> implements MigrationPlan\n{\n  abstract readonly targetId: string;\n\n  /**\n   * Assembled `ControlStack` injected by the orchestrator (`runMigration`).\n   *\n   * Subclasses (e.g. `PostgresMigration`) read the stack to materialize their\n   * adapter once per instance. Optional at the abstract level so unit tests can\n   * construct `Migration` instances purely for `operations` / `describe`\n   * assertions without needing a real stack; concrete subclasses that need the\n   * stack at runtime should narrow the parameter to required.\n   */\n  protected readonly stack: ControlStack<TFamilyId, TTargetId> | undefined;\n\n  constructor(stack?: ControlStack<TFamilyId, TTargetId>) {\n    this.stack = stack;\n  }\n\n  /**\n   * Ordered list of operations this migration performs.\n   *\n   * Implemented as a getter so that subclasses can either precompute the list\n   * in their constructor or build it lazily per access.\n   */\n  abstract get operations(): readonly TOperation[];\n\n  /**\n   * Metadata inputs used to build `migration.json` and to derive the plan's\n   * origin/destination identities. Every migration must provide this —\n   * omitting it would produce an invalid on-disk migration package.\n   */\n  abstract describe(): MigrationMeta;\n\n  get origin(): { readonly storageHash: string } | null {\n    const from = this.describe().from;\n    return from === null ? null : { storageHash: from };\n  }\n\n  get destination(): { readonly storageHash: string } {\n    return { storageHash: this.describe().to };\n  }\n}\n\n/**\n * Returns true when `import.meta.url` resolves to the same file that was\n * invoked as the node entrypoint (`process.argv[1]`). Used by\n * `MigrationCLI.run` (in `@prisma-next/cli/migration-cli`) to no-op when\n * the migration module is being imported (e.g. by another script) rather\n * than executed directly.\n */\nexport function isDirectEntrypoint(importMetaUrl: string): boolean {\n  const metaFilename = fileURLToPath(importMetaUrl);\n  const argv1 = process.argv[1];\n  if (!argv1) return false;\n  try {\n    return realpathSync(metaFilename) === realpathSync(argv1);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * In-memory artifacts produced from a `Migration` instance: the\n * serialized `ops.json` body, the `migration.json` metadata object, and\n * its serialized form. Returned by `buildMigrationArtifacts` so callers\n * (today: `MigrationCLI.run` in `@prisma-next/cli/migration-cli`) can\n * decide how to persist them — write to disk, print in dry-run, ship\n * over the wire — without coupling artifact construction to file I/O.\n *\n * `metadataJson` is `JSON.stringify(metadata, null, 2)` — the canonical\n * on-disk shape that the arktype loader-schema in `./io` validates.\n */\nexport interface MigrationArtifacts {\n  readonly opsJson: string;\n  readonly metadata: MigrationMetadata;\n  readonly metadataJson: string;\n}\n\n/**\n * Build the attested metadata from `describe()`-derived metadata, the\n * operations list, and the previously-scaffolded metadata (if any).\n *\n * When a `migration.json` already exists for this package (the common\n * case: it was scaffolded by `migration plan`), preserve the contract\n * bookends, hints, labels, and `createdAt` set there — those fields are\n * owned by the CLI scaffolder, not the authored class. Only the\n * `describe()`-derived fields (`from`, `to`) and the operations\n * change as the author iterates. When no metadata exists yet (a bare\n * `migration.ts` run from scratch), synthesize a minimal but\n * schema-conformant record so the resulting package can still be read,\n * verified, and applied.\n *\n * The `migrationHash` is recomputed against the current metadata + ops so\n * the on-disk artifacts are always fully attested.\n */\nfunction buildAttestedMetadata(\n  meta: MigrationMeta,\n  ops: MigrationOps,\n  existing: Partial<MigrationMetadata> | null,\n): MigrationMetadata {\n  const baseMetadata: Omit<MigrationMetadata, 'migrationHash'> = {\n    from: meta.from,\n    to: meta.to,\n    labels: meta.labels ?? existing?.labels ?? [],\n    providedInvariants: deriveProvidedInvariants(ops),\n    createdAt: existing?.createdAt ?? new Date().toISOString(),\n    hints: normalizeHints(existing?.hints),\n  };\n\n  const migrationHash = computeMigrationHash(baseMetadata, ops);\n  return { ...baseMetadata, migrationHash };\n}\n\n/**\n * Project `existing.hints` down to the known `MigrationHints` shape, dropping\n * any legacy keys that may linger in metadata scaffolded by older CLI\n * versions (e.g. `planningStrategy`). Picking fields explicitly instead of\n * spreading keeps refreshed `migration.json` files schema-clean regardless\n * of what was on disk before.\n */\nfunction normalizeHints(existing: MigrationHints | undefined): MigrationHints {\n  return {\n    used: existing?.used ?? [],\n    applied: existing?.applied ?? [],\n    plannerVersion: existing?.plannerVersion ?? '2.0.0',\n  };\n}\n\n/**\n * Pure conversion from a `Migration` instance (plus the previously\n * scaffolded metadata, when one exists on disk) to the in-memory\n * artifacts that downstream tooling persists. Owns metadata validation,\n * metadata synthesis/preservation, hint normalization, and the\n * content-addressed `migrationHash` computation, but performs no file I/O\n * — callers handle reads (to source `existing`) and writes (to persist\n * `opsJson` / `metadataJson`).\n */\nexport function buildMigrationArtifacts(\n  instance: Migration,\n  existing: Partial<MigrationMetadata> | null,\n): MigrationArtifacts {\n  const ops = instance.operations;\n  if (!Array.isArray(ops)) {\n    throw new Error('operations must be an array');\n  }\n\n  for (let index = 0; index < ops.length; index++) {\n    const result = MigrationOpSchema(ops[index]);\n    if (result instanceof type.errors) {\n      throw errorInvalidOperationEntry(index, result.summary);\n    }\n  }\n\n  const rawMeta: unknown = instance.describe();\n  const parsed = MigrationMetaSchema(rawMeta);\n  if (parsed instanceof type.errors) {\n    throw new Error(`describe() returned invalid metadata: ${parsed.summary}`);\n  }\n\n  const metadata = buildAttestedMetadata(parsed, ops, existing);\n\n  return {\n    opsJson: JSON.stringify(ops, null, 2),\n    metadata,\n    metadataJson: JSON.stringify(metadata, null, 2),\n  };\n}\n"],"mappings":";;;;;;;;AA0BA,MAAM,sBAAsB,KAAK;CAC/B,MAAM;CACN,IAAI;CACJ,WAAW,KAAK,SAAS,CAAC,OAAO;CAClC,CAAC;;;;;;;;;;AAWF,IAAsB,YAAtB,MAKA;;;;;;;;;;CAYE;CAEA,YAAY,OAA4C;EACtD,KAAK,QAAQ;;CAkBf,IAAI,SAAkD;EACpD,MAAM,OAAO,KAAK,UAAU,CAAC;EAC7B,OAAO,SAAS,OAAO,OAAO,EAAE,aAAa,MAAM;;CAGrD,IAAI,cAAgD;EAClD,OAAO,EAAE,aAAa,KAAK,UAAU,CAAC,IAAI;;;;;;;;;;AAW9C,SAAgB,mBAAmB,eAAgC;CACjE,MAAM,eAAe,cAAc,cAAc;CACjD,MAAM,QAAQ,QAAQ,KAAK;CAC3B,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI;EACF,OAAO,aAAa,aAAa,KAAK,aAAa,MAAM;SACnD;EACN,OAAO;;;;;;;;;;;;;;;;;;;;AAsCX,SAAS,sBACP,MACA,KACA,UACmB;CACnB,MAAM,eAAyD;EAC7D,MAAM,KAAK;EACX,IAAI,KAAK;EACT,QAAQ,KAAK,UAAU,UAAU,UAAU,EAAE;EAC7C,oBAAoB,yBAAyB,IAAI;EACjD,WAAW,UAAU,8BAAa,IAAI,MAAM,EAAC,aAAa;EAC1D,OAAO,eAAe,UAAU,MAAM;EACvC;CAED,MAAM,gBAAgB,qBAAqB,cAAc,IAAI;CAC7D,OAAO;EAAE,GAAG;EAAc;EAAe;;;;;;;;;AAU3C,SAAS,eAAe,UAAsD;CAC5E,OAAO;EACL,MAAM,UAAU,QAAQ,EAAE;EAC1B,SAAS,UAAU,WAAW,EAAE;EAChC,gBAAgB,UAAU,kBAAkB;EAC7C;;;;;;;;;;;AAYH,SAAgB,wBACd,UACA,UACoB;CACpB,MAAM,MAAM,SAAS;CACrB,IAAI,CAAC,MAAM,QAAQ,IAAI,EACrB,MAAM,IAAI,MAAM,8BAA8B;CAGhD,KAAK,IAAI,QAAQ,GAAG,QAAQ,IAAI,QAAQ,SAAS;EAC/C,MAAM,SAAS,kBAAkB,IAAI,OAAO;EAC5C,IAAI,kBAAkB,KAAK,QACzB,MAAM,2BAA2B,OAAO,OAAO,QAAQ;;CAK3D,MAAM,SAAS,oBADU,SAAS,UACQ,CAAC;CAC3C,IAAI,kBAAkB,KAAK,QACzB,MAAM,IAAI,MAAM,yCAAyC,OAAO,UAAU;CAG5E,MAAM,WAAW,sBAAsB,QAAQ,KAAK,SAAS;CAE7D,OAAO;EACL,SAAS,KAAK,UAAU,KAAK,MAAM,EAAE;EACrC;EACA,cAAc,KAAK,UAAU,UAAU,MAAM,EAAE;EAChD"}
+{"version":3,"file":"migration.mjs","names":[],"sources":["../../src/migration-base.ts"],"sourcesContent":["import { realpathSync } from 'node:fs';\nimport { fileURLToPath } from 'node:url';\nimport type {\n  ControlStack,\n  MigrationPlan,\n  MigrationPlanOperation,\n} from '@prisma-next/framework-components/control';\nimport { type } from 'arktype';\nimport { errorInvalidOperationEntry } from './errors';\nimport { computeMigrationHash } from './hash';\nimport { deriveProvidedInvariants } from './invariants';\nimport type { MigrationMetadata } from './metadata';\nimport { MigrationOpSchema } from './op-schema';\nimport type { MigrationOps } from './package';\n\nexport interface MigrationMeta {\n  readonly from: string | null;\n  readonly to: string;\n}\n\n// `from` rejects empty strings to mirror `MigrationMetadataSchema` in\n// `./io.ts`. Without this match, an authored migration could `describe()` with\n// `from: ''` and pass `buildMigrationArtifacts`'s validation, only to have\n// `readMigrationPackage` reject the resulting `migration.json` later — the\n// two validators must agree on the legal value space.\nconst MigrationMetaSchema = type({\n  from: 'string > 0 | null',\n  to: 'string',\n});\n\n/**\n * Base class for migrations.\n *\n * A `Migration` subclass is itself a `MigrationPlan`: CLI commands and the\n * runner can consume it directly via `targetId`, `operations`, `origin`, and\n * `destination`. The metadata-shaped inputs come from `describe()`, which\n * every migration must implement — `migration.json` is required for a\n * migration to be valid.\n */\nexport abstract class Migration<\n  TOperation extends MigrationPlanOperation = MigrationPlanOperation,\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> implements MigrationPlan\n{\n  abstract readonly targetId: string;\n\n  /**\n   * Assembled `ControlStack` injected by the orchestrator (`runMigration`).\n   *\n   * Subclasses (e.g. `PostgresMigration`) read the stack to materialize their\n   * adapter once per instance. Optional at the abstract level so unit tests can\n   * construct `Migration` instances purely for `operations` / `describe`\n   * assertions without needing a real stack; concrete subclasses that need the\n   * stack at runtime should narrow the parameter to required.\n   */\n  protected readonly stack: ControlStack<TFamilyId, TTargetId> | undefined;\n\n  constructor(stack?: ControlStack<TFamilyId, TTargetId>) {\n    this.stack = stack;\n  }\n\n  /**\n   * Ordered list of operations this migration performs.\n   *\n   * Implemented as a getter so that subclasses can either precompute the list\n   * in their constructor or build it lazily per access.\n   */\n  abstract get operations(): readonly TOperation[];\n\n  /**\n   * Metadata inputs used to build `migration.json` and to derive the plan's\n   * origin/destination identities. Every migration must provide this —\n   * omitting it would produce an invalid on-disk migration package.\n   */\n  abstract describe(): MigrationMeta;\n\n  get origin(): { readonly storageHash: string } | null {\n    const from = this.describe().from;\n    return from === null ? null : { storageHash: from };\n  }\n\n  get destination(): { readonly storageHash: string } {\n    return { storageHash: this.describe().to };\n  }\n}\n\n/**\n * Returns true when `import.meta.url` resolves to the same file that was\n * invoked as the node entrypoint (`process.argv[1]`). Used by\n * `MigrationCLI.run` (in `@prisma-next/cli/migration-cli`) to no-op when\n * the migration module is being imported (e.g. by another script) rather\n * than executed directly.\n */\nexport function isDirectEntrypoint(importMetaUrl: string): boolean {\n  const metaFilename = fileURLToPath(importMetaUrl);\n  const argv1 = process.argv[1];\n  if (!argv1) return false;\n  try {\n    return realpathSync(metaFilename) === realpathSync(argv1);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * In-memory artifacts produced from a `Migration` instance: the\n * serialized `ops.json` body, the `migration.json` metadata object, and\n * its serialized form. Returned by `buildMigrationArtifacts` so callers\n * (today: `MigrationCLI.run` in `@prisma-next/cli/migration-cli`) can\n * decide how to persist them — write to disk, print in dry-run, ship\n * over the wire — without coupling artifact construction to file I/O.\n *\n * `metadataJson` is `JSON.stringify(metadata, null, 2)` — the canonical\n * on-disk shape that the arktype loader-schema in `./io` validates.\n */\nexport interface MigrationArtifacts {\n  readonly opsJson: string;\n  readonly metadata: MigrationMetadata;\n  readonly metadataJson: string;\n}\n\n/**\n * Build the attested metadata from `describe()`-derived metadata, the\n * operations list, and the previously-scaffolded metadata (if any).\n *\n * When a `migration.json` already exists for this package (the common\n * case: it was scaffolded by `migration plan`), preserve `createdAt`\n * set there — that field is owned by the CLI scaffolder, not the authored\n * class. Only the `describe()`-derived fields (`from`, `to`) and the\n * operations change as the author iterates. When no metadata exists yet\n * (a bare `migration.ts` run from scratch), synthesize a minimal but\n * schema-conformant record so the resulting package can still be read,\n * verified, and applied.\n *\n * The `migrationHash` is recomputed against the current metadata + ops so\n * the on-disk artifacts are always fully attested.\n */\nfunction buildAttestedMetadata(\n  meta: MigrationMeta,\n  ops: MigrationOps,\n  existing: Partial<MigrationMetadata> | null,\n): MigrationMetadata {\n  const baseMetadata: Omit<MigrationMetadata, 'migrationHash'> = {\n    from: meta.from,\n    to: meta.to,\n    providedInvariants: deriveProvidedInvariants(ops),\n    createdAt: existing?.createdAt ?? new Date().toISOString(),\n  };\n\n  const migrationHash = computeMigrationHash(baseMetadata, ops);\n  return { ...baseMetadata, migrationHash };\n}\n\n/**\n * Pure conversion from a `Migration` instance (plus the previously\n * scaffolded metadata, when one exists on disk) to the in-memory\n * artifacts that downstream tooling persists. Owns metadata validation,\n * metadata synthesis/preservation, and the content-addressed\n * `migrationHash` computation, but performs no file I/O — callers handle\n * reads (to source `existing`) and writes (to persist `opsJson` /\n * `metadataJson`).\n */\nexport function buildMigrationArtifacts(\n  instance: Migration,\n  existing: Partial<MigrationMetadata> | null,\n): MigrationArtifacts {\n  const ops = instance.operations;\n  if (!Array.isArray(ops)) {\n    throw new Error('operations must be an array');\n  }\n\n  for (let index = 0; index < ops.length; index++) {\n    const result = MigrationOpSchema(ops[index]);\n    if (result instanceof type.errors) {\n      throw errorInvalidOperationEntry(index, result.summary);\n    }\n  }\n\n  const rawMeta: unknown = instance.describe();\n  const parsed = MigrationMetaSchema(rawMeta);\n  if (parsed instanceof type.errors) {\n    throw new Error(`describe() returned invalid metadata: ${parsed.summary}`);\n  }\n\n  const metadata = buildAttestedMetadata(parsed, ops, existing);\n\n  return {\n    opsJson: JSON.stringify(ops, null, 2),\n    metadata,\n    metadataJson: JSON.stringify(metadata, null, 2),\n  };\n}\n"],"mappings":";;;;;;;;AAyBA,MAAM,sBAAsB,KAAK;CAC/B,MAAM;CACN,IAAI;AACN,CAAC;;;;;;;;;;AAWD,IAAsB,YAAtB,MAKA;;;;;;;;;;CAYE;CAEA,YAAY,OAA4C;EACtD,KAAK,QAAQ;CACf;CAiBA,IAAI,SAAkD;EACpD,MAAM,OAAO,KAAK,SAAS,EAAE;EAC7B,OAAO,SAAS,OAAO,OAAO,EAAE,aAAa,KAAK;CACpD;CAEA,IAAI,cAAgD;EAClD,OAAO,EAAE,aAAa,KAAK,SAAS,EAAE,GAAG;CAC3C;AACF;;;;;;;;AASA,SAAgB,mBAAmB,eAAgC;CACjE,MAAM,eAAe,cAAc,aAAa;CAChD,MAAM,QAAQ,QAAQ,KAAK;CAC3B,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI;EACF,OAAO,aAAa,YAAY,MAAM,aAAa,KAAK;CAC1D,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;AAmCA,SAAS,sBACP,MACA,KACA,UACmB;CACnB,MAAM,eAAyD;EAC7D,MAAM,KAAK;EACX,IAAI,KAAK;EACT,oBAAoB,yBAAyB,GAAG;EAChD,WAAW,UAAU,8BAAa,IAAI,KAAK,GAAE,YAAY;CAC3D;CAEA,MAAM,gBAAgB,qBAAqB,cAAc,GAAG;CAC5D,OAAO;EAAE,GAAG;EAAc;CAAc;AAC1C;;;;;;;;;;AAWA,SAAgB,wBACd,UACA,UACoB;CACpB,MAAM,MAAM,SAAS;CACrB,IAAI,CAAC,MAAM,QAAQ,GAAG,GACpB,MAAM,IAAI,MAAM,6BAA6B;CAG/C,KAAK,IAAI,QAAQ,GAAG,QAAQ,IAAI,QAAQ,SAAS;EAC/C,MAAM,SAAS,kBAAkB,IAAI,MAAM;EAC3C,IAAI,kBAAkB,KAAK,QACzB,MAAM,2BAA2B,OAAO,OAAO,OAAO;CAE1D;CAGA,MAAM,SAAS,oBADU,SAAS,SACO,CAAC;CAC1C,IAAI,kBAAkB,KAAK,QACzB,MAAM,IAAI,MAAM,yCAAyC,OAAO,SAAS;CAG3E,MAAM,WAAW,sBAAsB,QAAQ,KAAK,QAAQ;CAE5D,OAAO;EACL,SAAS,KAAK,UAAU,KAAK,MAAM,CAAC;EACpC;EACA,cAAc,KAAK,UAAU,UAAU,MAAM,CAAC;CAChD;AACF"}

package/dist/exports/package.d.mts

@@ -1,3 +1,3 @@
-import { n as OnDiskMigrationPackage, t as MigrationOps } from "../package-DZj8YvD0.mjs";
+import { n as OnDiskMigrationPackage, t as MigrationOps } from "../package-DIttKL7X.mjs";
 import { MigrationPackage } from "@prisma-next/framework-components/control";
 export { type MigrationOps, type MigrationPackage, type OnDiskMigrationPackage };

package/dist/exports/ref-resolution.d.mts

@@ -1,5 +1,5 @@
-import { n as MigrationGraph, t as MigrationEdge } from "../graph-BrLXqoUc.mjs";
-import { n as Refs } from "../refs-CDaNerhT.mjs";
+import { r as Refs } from "../refs-C8f2IGM8.mjs";
+import { n as MigrationGraph, t as MigrationEdge } from "../graph-BUZuUeBC.mjs";
 import { Result } from "@prisma-next/utils/result";
 
 //#region src/refs/types.d.ts

package/dist/exports/ref-resolution.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ref-resolution.d.mts","names":[],"sources":["../../src/refs/types.ts","../../src/refs/contract-ref.ts","../../src/refs/migration-ref.ts"],"mappings":";;;;;;UAIiB,oBAAA;EAAA,SACN,KAAA,EAAO,cAAA;EAAA,SACP,IAAA,EAAM,IAAA;AAAA;AAAA,KAGL,qBAAA;EAAA,SACG,IAAA;EAAA,SAAuB,KAAA;AAAA;EAAA,SACvB,IAAA;EAAA,SAAsB,OAAA;AAAA;EAAA,SACtB,IAAA;EAAA,SAA+B,OAAA;AAAA;EAAA,SAC/B,IAAA;EAAA,SAAiC,OAAA;AAAA;;UAG/B,WAAA;EAAA,SACN,IAAA;EAAA,SACA,UAAA,EAAY,qBAAA;AAAA;AAAA,KAGX,sBAAA;EAAA,SACG,IAAA;EAAA,SAA2B,OAAA;AAAA;EAAA,SAC3B,IAAA;EAAA,SAAuB,KAAA;AAAA;;UAGrB,YAAA;EAAA,SACN,OAAA;EAAA,SACA,aAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;EAAA,SACA,UAAA,EAAY,sBAAA;AAAA;AAAA,UAGN,qBAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA;EAAA,SACA,OAAA;AAAA;AAAA,UAGM,sBAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;AAAA;AAAA,UAGM,yBAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA;EAAA,SACA,eAAA;EAAA,SACA,OAAA;EAAA,SACA,GAAA;AAAA;AAAA,UAGM,0BAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA;AAAA;AAAA,KAGC,kBAAA,GACR,qBAAA,GACA,sBAAA,GACA,yBAAA,GACA,0BAAA;AAAA,iBAiBY,iBAAA,CACd,KAAA,EAAO,cAAA,EACP,OAAA,WACC,aAAA;;;;;;AAjFH;;;;;;;;iBCkBgB,gBAAA,CACd,KAAA,UACA,GAAA,EAAK,oBAAA,GACJ,MAAA,CAAO,WAAA,EAAa,kBAAA;;;;;;ADrBvB;;;;;;;;;iBEcgB,iBAAA,CACd,KAAA,UACA,GAAA,EAAK,oBAAA,GACJ,MAAA,CAAO,YAAA,EAAc,kBAAA"}
+{"version":3,"file":"ref-resolution.d.mts","names":[],"sources":["../../src/refs/types.ts","../../src/refs/contract-ref.ts","../../src/refs/migration-ref.ts"],"mappings":";;;;;;UAIiB,oBAAA;EAAA,SACN,KAAA,EAAO,cAAA;EAAA,SACP,IAAA,EAAM,IAAI;AAAA;AAAA,KAGT,qBAAA;EAAA,SACG,IAAA;EAAA,SAAuB,KAAA;AAAA;EAAA,SACvB,IAAA;EAAA,SAAsB,OAAA;AAAA;EAAA,SACtB,IAAA;EAAA,SAA+B,OAAA;AAAA;EAAA,SAC/B,IAAA;EAAA,SAAiC,OAAA;AAAA;;UAG/B,WAAA;EAAA,SACN,IAAA;EAAA,SACA,UAAA,EAAY,qBAAqB;AAAA;AAAA,KAGhC,sBAAA;EAAA,SACG,IAAA;EAAA,SAA2B,OAAA;AAAA;EAAA,SAC3B,IAAA;EAAA,SAAuB,KAAA;AAAA;;UAGrB,YAAA;EAAA,SACN,OAAA;EAAA,SACA,aAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;EAAA,SACA,UAAA,EAAY,sBAAsB;AAAA;AAAA,UAG5B,qBAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA;EAAA,SACA,OAAA;AAAA;AAAA,UAGM,sBAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;AAAA;AAAA,UAGM,yBAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA;EAAA,SACA,eAAA;EAAA,SACA,OAAA;EAAA,SACA,GAAA;AAAA;AAAA,UAGM,0BAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA;AAAA;AAAA,KAGC,kBAAA,GACR,qBAAA,GACA,sBAAA,GACA,yBAAA,GACA,0BAAA;AAAA,iBAiBY,iBAAA,CACd,KAAA,EAAO,cAAA,EACP,OAAA,WACC,aAAa;;;;;;AAjFhB;;;;;;;;iBCkBgB,gBAAA,CACd,KAAA,UACA,GAAA,EAAK,oBAAA,GACJ,MAAA,CAAO,WAAA,EAAa,kBAAA;;;;;;ADrBvB;;;;;;;;;iBEcgB,iBAAA,CACd,KAAA,UACA,GAAA,EAAK,oBAAA,GACJ,MAAA,CAAO,YAAA,EAAc,kBAAA"}

package/dist/exports/ref-resolution.mjs

@@ -1,4 +1,4 @@
-import { a as validateRefName } from "../refs-BDHo5l_g.mjs";
+import { s as validateRefName } from "../refs-BBKNL45K.mjs";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/refs/types.ts
 const FULL_HASH_PATTERN = /^sha256:([0-9a-f]{64}|empty)$/;

package/dist/exports/ref-resolution.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ref-resolution.mjs","names":[],"sources":["../../src/refs/types.ts","../../src/refs/contract-ref.ts","../../src/refs/migration-ref.ts"],"sourcesContent":["import type { MigrationEdge, MigrationGraph } from '../graph';\nimport type { Refs } from '../refs';\n\n/** Context required to resolve a contract or migration reference. */\nexport interface RefResolutionContext {\n  readonly graph: MigrationGraph;\n  readonly refs: Refs;\n}\n\nexport type ContractRefProvenance =\n  | { readonly kind: 'hash'; readonly input: string }\n  | { readonly kind: 'ref'; readonly refName: string }\n  | { readonly kind: 'migration-to'; readonly dirName: string }\n  | { readonly kind: 'migration-from'; readonly dirName: string };\n\n/** A resolved contract reference: the target hash and how it was derived. */\nexport interface ContractRef {\n  readonly hash: string;\n  readonly provenance: ContractRefProvenance;\n}\n\nexport type MigrationRefProvenance =\n  | { readonly kind: 'dir-name'; readonly dirName: string }\n  | { readonly kind: 'hash'; readonly input: string };\n\n/** A resolved migration reference. */\nexport interface MigrationRef {\n  readonly dirName: string;\n  readonly migrationHash: string;\n  readonly from: string;\n  readonly to: string;\n  readonly provenance: MigrationRefProvenance;\n}\n\nexport interface RefResolutionNotFound {\n  readonly kind: 'not-found';\n  readonly input: string;\n  readonly grammar: 'contract' | 'migration';\n}\n\nexport interface RefResolutionAmbiguous {\n  readonly kind: 'ambiguous';\n  readonly input: string;\n  readonly candidates: readonly string[];\n  readonly grammar: 'contract' | 'migration';\n}\n\nexport interface RefResolutionWrongGrammar {\n  readonly kind: 'wrong-grammar';\n  readonly input: string;\n  readonly expectedGrammar: 'contract' | 'migration';\n  readonly message: string;\n  readonly fix: string;\n}\n\nexport interface RefResolutionInvalidFormat {\n  readonly kind: 'invalid-format';\n  readonly input: string;\n  readonly reason: string;\n}\n\nexport type RefResolutionError =\n  | RefResolutionNotFound\n  | RefResolutionAmbiguous\n  | RefResolutionWrongGrammar\n  | RefResolutionInvalidFormat;\n\nconst FULL_HASH_PATTERN = /^sha256:([0-9a-f]{64}|empty)$/;\nconst HEX_PREFIX_PATTERN = /^(sha256:)?[0-9a-f]{6,}$/;\n\nexport function isFullHash(input: string): boolean {\n  return FULL_HASH_PATTERN.test(input);\n}\n\nexport function isHexPrefix(input: string): boolean {\n  return HEX_PREFIX_PATTERN.test(input);\n}\n\nexport function normalizeHashPrefix(input: string): string {\n  return input.startsWith('sha256:') ? input : `sha256:${input}`;\n}\n\nexport function findEdgeByDirName(\n  graph: MigrationGraph,\n  dirName: string,\n): MigrationEdge | undefined {\n  for (const edges of graph.forwardChain.values()) {\n    for (const edge of edges) {\n      if (edge.dirName === dirName) return edge;\n    }\n  }\n  return undefined;\n}\n","import type { Result } from '@prisma-next/utils/result';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport { validateRefName } from '../refs';\nimport type {\n  ContractRef,\n  ContractRefProvenance,\n  RefResolutionContext,\n  RefResolutionError,\n} from './types';\nimport { findEdgeByDirName, isFullHash, isHexPrefix, normalizeHashPrefix } from './types';\n\n/**\n * Resolve a user-supplied string to a contract hash using the unified\n * contract-reference grammar.\n *\n * Accepted forms:\n * - Full storage hash (`sha256:<64 hex>` or `sha256:empty`)\n * - Hex prefix (6+ hex chars, must uniquely identify one contract)\n * - Ref name (looked up in the refs index)\n * - Migration directory name (resolves to the migration's `to`-contract)\n * - `<dir>^` (resolves to the migration's `from`-contract)\n */\nexport function parseContractRef(\n  input: string,\n  ctx: RefResolutionContext,\n): Result<ContractRef, RefResolutionError> {\n  if (!input) {\n    return notOk({ kind: 'invalid-format', input, reason: 'Reference cannot be empty' });\n  }\n\n  if (isFullHash(input)) {\n    if (ctx.graph.nodes.has(input)) {\n      return ok({ hash: input, provenance: { kind: 'hash', input } });\n    }\n    return notOk({ kind: 'not-found', input, grammar: 'contract' });\n  }\n\n  if (input.endsWith('^')) {\n    const dirName = input.slice(0, -1);\n    if (!dirName) {\n      return notOk({ kind: 'invalid-format', input, reason: 'Missing directory name before ^' });\n    }\n    const edge = findEdgeByDirName(ctx.graph, dirName);\n    if (edge) {\n      return ok({ hash: edge.from, provenance: { kind: 'migration-from', dirName } });\n    }\n    return notOk({ kind: 'not-found', input, grammar: 'contract' });\n  }\n\n  type Candidate = { hash: string; provenance: ContractRefProvenance; label: string };\n  const candidates: Candidate[] = [];\n\n  if (validateRefName(input) && Object.hasOwn(ctx.refs, input)) {\n    const ref = ctx.refs[input];\n    if (ref) {\n      candidates.push({\n        hash: ref.hash,\n        provenance: { kind: 'ref', refName: input },\n        label: `ref \"${input}\"`,\n      });\n    }\n  }\n\n  const edge = findEdgeByDirName(ctx.graph, input);\n  if (edge) {\n    candidates.push({\n      hash: edge.to,\n      provenance: { kind: 'migration-to', dirName: input },\n      label: `migration directory \"${input}\"`,\n    });\n  }\n\n  if (isHexPrefix(input)) {\n    const prefix = normalizeHashPrefix(input);\n    const matches = [...ctx.graph.nodes].filter((n) => n.startsWith(prefix));\n    const [firstMatch] = matches;\n    if (matches.length === 1 && firstMatch !== undefined) {\n      candidates.push({\n        hash: firstMatch,\n        provenance: { kind: 'hash', input },\n        label: `hash prefix \"${input}\"`,\n      });\n    } else if (matches.length > 1) {\n      return notOk({ kind: 'ambiguous', input, candidates: matches, grammar: 'contract' });\n    }\n  }\n\n  const [firstCandidate] = candidates;\n  if (candidates.length === 1 && firstCandidate !== undefined) {\n    return ok({ hash: firstCandidate.hash, provenance: firstCandidate.provenance });\n  }\n\n  if (candidates.length > 1) {\n    return notOk({\n      kind: 'ambiguous',\n      input,\n      candidates: candidates.map((c) => c.label),\n      grammar: 'contract',\n    });\n  }\n\n  return notOk({ kind: 'not-found', input, grammar: 'contract' });\n}\n","import type { Result } from '@prisma-next/utils/result';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport { validateRefName } from '../refs';\nimport type { MigrationRef, RefResolutionContext, RefResolutionError } from './types';\nimport { findEdgeByDirName, isFullHash, isHexPrefix, normalizeHashPrefix } from './types';\n\n/**\n * Resolve a user-supplied string to a migration using the migration-reference\n * grammar.\n *\n * Accepted forms:\n * - Migration directory name (e.g. `20260101-add-users`)\n * - Migration hash (full or 6+ hex prefix)\n *\n * Wrong-grammar diagnostics are produced when the input matches a\n * contract-grammar form (ref name, `<dir>^`, contract-only hash) so the\n * user gets a targeted hint rather than a generic \"not found\".\n */\nexport function parseMigrationRef(\n  input: string,\n  ctx: RefResolutionContext,\n): Result<MigrationRef, RefResolutionError> {\n  if (!input) {\n    return notOk({ kind: 'invalid-format', input, reason: 'Reference cannot be empty' });\n  }\n\n  if (input.endsWith('^')) {\n    return notOk({\n      kind: 'wrong-grammar',\n      input,\n      expectedGrammar: 'migration',\n      message: '`^` syntax addresses contracts, not migrations',\n      fix: 'Pass the migration directory name without `^`, or use a contract-accepting flag like `--to` or `--from`.',\n    });\n  }\n\n  if (validateRefName(input) && Object.hasOwn(ctx.refs, input)) {\n    return notOk({\n      kind: 'wrong-grammar',\n      input,\n      expectedGrammar: 'migration',\n      message: `\"${input}\" is a ref name, not a migration`,\n      fix: 'Refs point at contracts, not migrations. Use a migration directory name or migration hash.',\n    });\n  }\n\n  const edge = findEdgeByDirName(ctx.graph, input);\n  if (edge) {\n    return ok({\n      dirName: edge.dirName,\n      migrationHash: edge.migrationHash,\n      from: edge.from,\n      to: edge.to,\n      provenance: { kind: 'dir-name', dirName: input },\n    });\n  }\n\n  if (isFullHash(input)) {\n    const migEdge = ctx.graph.migrationByHash.get(input);\n    if (migEdge) {\n      return ok({\n        dirName: migEdge.dirName,\n        migrationHash: migEdge.migrationHash,\n        from: migEdge.from,\n        to: migEdge.to,\n        provenance: { kind: 'hash', input },\n      });\n    }\n    if (ctx.graph.nodes.has(input)) {\n      return notOk({\n        kind: 'wrong-grammar',\n        input,\n        expectedGrammar: 'migration',\n        message: 'Hash matched a contract but not a migration',\n        fix: 'Use a contract-accepting flag like `--to` or `--from` to reference contracts by hash. Pass `migration show <dir>` for a specific migration.',\n      });\n    }\n    return notOk({ kind: 'not-found', input, grammar: 'migration' });\n  }\n\n  if (isHexPrefix(input)) {\n    const prefix = normalizeHashPrefix(input);\n    const migMatches = [...ctx.graph.migrationByHash.entries()].filter(([hash]) =>\n      hash.startsWith(prefix),\n    );\n\n    const [firstMigMatch] = migMatches;\n    if (migMatches.length === 1 && firstMigMatch !== undefined) {\n      const [, matchedEdge] = firstMigMatch;\n      return ok({\n        dirName: matchedEdge.dirName,\n        migrationHash: matchedEdge.migrationHash,\n        from: matchedEdge.from,\n        to: matchedEdge.to,\n        provenance: { kind: 'hash', input },\n      });\n    }\n\n    if (migMatches.length > 1) {\n      return notOk({\n        kind: 'ambiguous',\n        input,\n        candidates: migMatches.map(([hash]) => hash),\n        grammar: 'migration',\n      });\n    }\n\n    const contractMatches = [...ctx.graph.nodes].filter((n) => n.startsWith(prefix));\n    if (contractMatches.length > 0) {\n      return notOk({\n        kind: 'wrong-grammar',\n        input,\n        expectedGrammar: 'migration',\n        message: 'Hash matched a contract but not a migration',\n        fix: 'Use a contract-accepting flag like `--to` or `--from` to reference contracts by hash. Pass `migration show <dir>` for a specific migration.',\n      });\n    }\n  }\n\n  return notOk({ kind: 'not-found', input, grammar: 'migration' });\n}\n"],"mappings":";;;AAmEA,MAAM,oBAAoB;AAC1B,MAAM,qBAAqB;AAE3B,SAAgB,WAAW,OAAwB;CACjD,OAAO,kBAAkB,KAAK,MAAM;;AAGtC,SAAgB,YAAY,OAAwB;CAClD,OAAO,mBAAmB,KAAK,MAAM;;AAGvC,SAAgB,oBAAoB,OAAuB;CACzD,OAAO,MAAM,WAAW,UAAU,GAAG,QAAQ,UAAU;;AAGzD,SAAgB,kBACd,OACA,SAC2B;CAC3B,KAAK,MAAM,SAAS,MAAM,aAAa,QAAQ,EAC7C,KAAK,MAAM,QAAQ,OACjB,IAAI,KAAK,YAAY,SAAS,OAAO;;;;;;;;;;;;;;;AClE3C,SAAgB,iBACd,OACA,KACyC;CACzC,IAAI,CAAC,OACH,OAAO,MAAM;EAAE,MAAM;EAAkB;EAAO,QAAQ;EAA6B,CAAC;CAGtF,IAAI,WAAW,MAAM,EAAE;EACrB,IAAI,IAAI,MAAM,MAAM,IAAI,MAAM,EAC5B,OAAO,GAAG;GAAE,MAAM;GAAO,YAAY;IAAE,MAAM;IAAQ;IAAO;GAAE,CAAC;EAEjE,OAAO,MAAM;GAAE,MAAM;GAAa;GAAO,SAAS;GAAY,CAAC;;CAGjE,IAAI,MAAM,SAAS,IAAI,EAAE;EACvB,MAAM,UAAU,MAAM,MAAM,GAAG,GAAG;EAClC,IAAI,CAAC,SACH,OAAO,MAAM;GAAE,MAAM;GAAkB;GAAO,QAAQ;GAAmC,CAAC;EAE5F,MAAM,OAAO,kBAAkB,IAAI,OAAO,QAAQ;EAClD,IAAI,MACF,OAAO,GAAG;GAAE,MAAM,KAAK;GAAM,YAAY;IAAE,MAAM;IAAkB;IAAS;GAAE,CAAC;EAEjF,OAAO,MAAM;GAAE,MAAM;GAAa;GAAO,SAAS;GAAY,CAAC;;CAIjE,MAAM,aAA0B,EAAE;CAElC,IAAI,gBAAgB,MAAM,IAAI,OAAO,OAAO,IAAI,MAAM,MAAM,EAAE;EAC5D,MAAM,MAAM,IAAI,KAAK;EACrB,IAAI,KACF,WAAW,KAAK;GACd,MAAM,IAAI;GACV,YAAY;IAAE,MAAM;IAAO,SAAS;IAAO;GAC3C,OAAO,QAAQ,MAAM;GACtB,CAAC;;CAIN,MAAM,OAAO,kBAAkB,IAAI,OAAO,MAAM;CAChD,IAAI,MACF,WAAW,KAAK;EACd,MAAM,KAAK;EACX,YAAY;GAAE,MAAM;GAAgB,SAAS;GAAO;EACpD,OAAO,wBAAwB,MAAM;EACtC,CAAC;CAGJ,IAAI,YAAY,MAAM,EAAE;EACtB,MAAM,SAAS,oBAAoB,MAAM;EACzC,MAAM,UAAU,CAAC,GAAG,IAAI,MAAM,MAAM,CAAC,QAAQ,MAAM,EAAE,WAAW,OAAO,CAAC;EACxE,MAAM,CAAC,cAAc;EACrB,IAAI,QAAQ,WAAW,KAAK,eAAe,KAAA,GACzC,WAAW,KAAK;GACd,MAAM;GACN,YAAY;IAAE,MAAM;IAAQ;IAAO;GACnC,OAAO,gBAAgB,MAAM;GAC9B,CAAC;OACG,IAAI,QAAQ,SAAS,GAC1B,OAAO,MAAM;GAAE,MAAM;GAAa;GAAO,YAAY;GAAS,SAAS;GAAY,CAAC;;CAIxF,MAAM,CAAC,kBAAkB;CACzB,IAAI,WAAW,WAAW,KAAK,mBAAmB,KAAA,GAChD,OAAO,GAAG;EAAE,MAAM,eAAe;EAAM,YAAY,eAAe;EAAY,CAAC;CAGjF,IAAI,WAAW,SAAS,GACtB,OAAO,MAAM;EACX,MAAM;EACN;EACA,YAAY,WAAW,KAAK,MAAM,EAAE,MAAM;EAC1C,SAAS;EACV,CAAC;CAGJ,OAAO,MAAM;EAAE,MAAM;EAAa;EAAO,SAAS;EAAY,CAAC;;;;;;;;;;;;;;;;ACnFjE,SAAgB,kBACd,OACA,KAC0C;CAC1C,IAAI,CAAC,OACH,OAAO,MAAM;EAAE,MAAM;EAAkB;EAAO,QAAQ;EAA6B,CAAC;CAGtF,IAAI,MAAM,SAAS,IAAI,EACrB,OAAO,MAAM;EACX,MAAM;EACN;EACA,iBAAiB;EACjB,SAAS;EACT,KAAK;EACN,CAAC;CAGJ,IAAI,gBAAgB,MAAM,IAAI,OAAO,OAAO,IAAI,MAAM,MAAM,EAC1D,OAAO,MAAM;EACX,MAAM;EACN;EACA,iBAAiB;EACjB,SAAS,IAAI,MAAM;EACnB,KAAK;EACN,CAAC;CAGJ,MAAM,OAAO,kBAAkB,IAAI,OAAO,MAAM;CAChD,IAAI,MACF,OAAO,GAAG;EACR,SAAS,KAAK;EACd,eAAe,KAAK;EACpB,MAAM,KAAK;EACX,IAAI,KAAK;EACT,YAAY;GAAE,MAAM;GAAY,SAAS;GAAO;EACjD,CAAC;CAGJ,IAAI,WAAW,MAAM,EAAE;EACrB,MAAM,UAAU,IAAI,MAAM,gBAAgB,IAAI,MAAM;EACpD,IAAI,SACF,OAAO,GAAG;GACR,SAAS,QAAQ;GACjB,eAAe,QAAQ;GACvB,MAAM,QAAQ;GACd,IAAI,QAAQ;GACZ,YAAY;IAAE,MAAM;IAAQ;IAAO;GACpC,CAAC;EAEJ,IAAI,IAAI,MAAM,MAAM,IAAI,MAAM,EAC5B,OAAO,MAAM;GACX,MAAM;GACN;GACA,iBAAiB;GACjB,SAAS;GACT,KAAK;GACN,CAAC;EAEJ,OAAO,MAAM;GAAE,MAAM;GAAa;GAAO,SAAS;GAAa,CAAC;;CAGlE,IAAI,YAAY,MAAM,EAAE;EACtB,MAAM,SAAS,oBAAoB,MAAM;EACzC,MAAM,aAAa,CAAC,GAAG,IAAI,MAAM,gBAAgB,SAAS,CAAC,CAAC,QAAQ,CAAC,UACnE,KAAK,WAAW,OAAO,CACxB;EAED,MAAM,CAAC,iBAAiB;EACxB,IAAI,WAAW,WAAW,KAAK,kBAAkB,KAAA,GAAW;GAC1D,MAAM,GAAG,eAAe;GACxB,OAAO,GAAG;IACR,SAAS,YAAY;IACrB,eAAe,YAAY;IAC3B,MAAM,YAAY;IAClB,IAAI,YAAY;IAChB,YAAY;KAAE,MAAM;KAAQ;KAAO;IACpC,CAAC;;EAGJ,IAAI,WAAW,SAAS,GACtB,OAAO,MAAM;GACX,MAAM;GACN;GACA,YAAY,WAAW,KAAK,CAAC,UAAU,KAAK;GAC5C,SAAS;GACV,CAAC;EAIJ,IADwB,CAAC,GAAG,IAAI,MAAM,MAAM,CAAC,QAAQ,MAAM,EAAE,WAAW,OAAO,CAC5D,CAAC,SAAS,GAC3B,OAAO,MAAM;GACX,MAAM;GACN;GACA,iBAAiB;GACjB,SAAS;GACT,KAAK;GACN,CAAC;;CAIN,OAAO,MAAM;EAAE,MAAM;EAAa;EAAO,SAAS;EAAa,CAAC"}
+{"version":3,"file":"ref-resolution.mjs","names":[],"sources":["../../src/refs/types.ts","../../src/refs/contract-ref.ts","../../src/refs/migration-ref.ts"],"sourcesContent":["import type { MigrationEdge, MigrationGraph } from '../graph';\nimport type { Refs } from '../refs';\n\n/** Context required to resolve a contract or migration reference. */\nexport interface RefResolutionContext {\n  readonly graph: MigrationGraph;\n  readonly refs: Refs;\n}\n\nexport type ContractRefProvenance =\n  | { readonly kind: 'hash'; readonly input: string }\n  | { readonly kind: 'ref'; readonly refName: string }\n  | { readonly kind: 'migration-to'; readonly dirName: string }\n  | { readonly kind: 'migration-from'; readonly dirName: string };\n\n/** A resolved contract reference: the target hash and how it was derived. */\nexport interface ContractRef {\n  readonly hash: string;\n  readonly provenance: ContractRefProvenance;\n}\n\nexport type MigrationRefProvenance =\n  | { readonly kind: 'dir-name'; readonly dirName: string }\n  | { readonly kind: 'hash'; readonly input: string };\n\n/** A resolved migration reference. */\nexport interface MigrationRef {\n  readonly dirName: string;\n  readonly migrationHash: string;\n  readonly from: string;\n  readonly to: string;\n  readonly provenance: MigrationRefProvenance;\n}\n\nexport interface RefResolutionNotFound {\n  readonly kind: 'not-found';\n  readonly input: string;\n  readonly grammar: 'contract' | 'migration';\n}\n\nexport interface RefResolutionAmbiguous {\n  readonly kind: 'ambiguous';\n  readonly input: string;\n  readonly candidates: readonly string[];\n  readonly grammar: 'contract' | 'migration';\n}\n\nexport interface RefResolutionWrongGrammar {\n  readonly kind: 'wrong-grammar';\n  readonly input: string;\n  readonly expectedGrammar: 'contract' | 'migration';\n  readonly message: string;\n  readonly fix: string;\n}\n\nexport interface RefResolutionInvalidFormat {\n  readonly kind: 'invalid-format';\n  readonly input: string;\n  readonly reason: string;\n}\n\nexport type RefResolutionError =\n  | RefResolutionNotFound\n  | RefResolutionAmbiguous\n  | RefResolutionWrongGrammar\n  | RefResolutionInvalidFormat;\n\nconst FULL_HASH_PATTERN = /^sha256:([0-9a-f]{64}|empty)$/;\nconst HEX_PREFIX_PATTERN = /^(sha256:)?[0-9a-f]{6,}$/;\n\nexport function isFullHash(input: string): boolean {\n  return FULL_HASH_PATTERN.test(input);\n}\n\nexport function isHexPrefix(input: string): boolean {\n  return HEX_PREFIX_PATTERN.test(input);\n}\n\nexport function normalizeHashPrefix(input: string): string {\n  return input.startsWith('sha256:') ? input : `sha256:${input}`;\n}\n\nexport function findEdgeByDirName(\n  graph: MigrationGraph,\n  dirName: string,\n): MigrationEdge | undefined {\n  for (const edges of graph.forwardChain.values()) {\n    for (const edge of edges) {\n      if (edge.dirName === dirName) return edge;\n    }\n  }\n  return undefined;\n}\n","import type { Result } from '@prisma-next/utils/result';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport { validateRefName } from '../refs';\nimport type {\n  ContractRef,\n  ContractRefProvenance,\n  RefResolutionContext,\n  RefResolutionError,\n} from './types';\nimport { findEdgeByDirName, isFullHash, isHexPrefix, normalizeHashPrefix } from './types';\n\n/**\n * Resolve a user-supplied string to a contract hash using the unified\n * contract-reference grammar.\n *\n * Accepted forms:\n * - Full storage hash (`sha256:<64 hex>` or `sha256:empty`)\n * - Hex prefix (6+ hex chars, must uniquely identify one contract)\n * - Ref name (looked up in the refs index)\n * - Migration directory name (resolves to the migration's `to`-contract)\n * - `<dir>^` (resolves to the migration's `from`-contract)\n */\nexport function parseContractRef(\n  input: string,\n  ctx: RefResolutionContext,\n): Result<ContractRef, RefResolutionError> {\n  if (!input) {\n    return notOk({ kind: 'invalid-format', input, reason: 'Reference cannot be empty' });\n  }\n\n  if (isFullHash(input)) {\n    if (ctx.graph.nodes.has(input)) {\n      return ok({ hash: input, provenance: { kind: 'hash', input } });\n    }\n    return notOk({ kind: 'not-found', input, grammar: 'contract' });\n  }\n\n  if (input.endsWith('^')) {\n    const dirName = input.slice(0, -1);\n    if (!dirName) {\n      return notOk({ kind: 'invalid-format', input, reason: 'Missing directory name before ^' });\n    }\n    const edge = findEdgeByDirName(ctx.graph, dirName);\n    if (edge) {\n      return ok({ hash: edge.from, provenance: { kind: 'migration-from', dirName } });\n    }\n    return notOk({ kind: 'not-found', input, grammar: 'contract' });\n  }\n\n  type Candidate = { hash: string; provenance: ContractRefProvenance; label: string };\n  const candidates: Candidate[] = [];\n\n  if (validateRefName(input) && Object.hasOwn(ctx.refs, input)) {\n    const ref = ctx.refs[input];\n    if (ref) {\n      candidates.push({\n        hash: ref.hash,\n        provenance: { kind: 'ref', refName: input },\n        label: `ref \"${input}\"`,\n      });\n    }\n  }\n\n  const edge = findEdgeByDirName(ctx.graph, input);\n  if (edge) {\n    candidates.push({\n      hash: edge.to,\n      provenance: { kind: 'migration-to', dirName: input },\n      label: `migration directory \"${input}\"`,\n    });\n  }\n\n  if (isHexPrefix(input)) {\n    const prefix = normalizeHashPrefix(input);\n    const matches = [...ctx.graph.nodes].filter((n) => n.startsWith(prefix));\n    const [firstMatch] = matches;\n    if (matches.length === 1 && firstMatch !== undefined) {\n      candidates.push({\n        hash: firstMatch,\n        provenance: { kind: 'hash', input },\n        label: `hash prefix \"${input}\"`,\n      });\n    } else if (matches.length > 1) {\n      return notOk({ kind: 'ambiguous', input, candidates: matches, grammar: 'contract' });\n    }\n  }\n\n  const [firstCandidate] = candidates;\n  if (candidates.length === 1 && firstCandidate !== undefined) {\n    return ok({ hash: firstCandidate.hash, provenance: firstCandidate.provenance });\n  }\n\n  if (candidates.length > 1) {\n    return notOk({\n      kind: 'ambiguous',\n      input,\n      candidates: candidates.map((c) => c.label),\n      grammar: 'contract',\n    });\n  }\n\n  return notOk({ kind: 'not-found', input, grammar: 'contract' });\n}\n","import type { Result } from '@prisma-next/utils/result';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport { validateRefName } from '../refs';\nimport type { MigrationRef, RefResolutionContext, RefResolutionError } from './types';\nimport { findEdgeByDirName, isFullHash, isHexPrefix, normalizeHashPrefix } from './types';\n\n/**\n * Resolve a user-supplied string to a migration using the migration-reference\n * grammar.\n *\n * Accepted forms:\n * - Migration directory name (e.g. `20260101-add-users`)\n * - Migration hash (full or 6+ hex prefix)\n *\n * Wrong-grammar diagnostics are produced when the input matches a\n * contract-grammar form (ref name, `<dir>^`, contract-only hash) so the\n * user gets a targeted hint rather than a generic \"not found\".\n */\nexport function parseMigrationRef(\n  input: string,\n  ctx: RefResolutionContext,\n): Result<MigrationRef, RefResolutionError> {\n  if (!input) {\n    return notOk({ kind: 'invalid-format', input, reason: 'Reference cannot be empty' });\n  }\n\n  if (input.endsWith('^')) {\n    return notOk({\n      kind: 'wrong-grammar',\n      input,\n      expectedGrammar: 'migration',\n      message: '`^` syntax addresses contracts, not migrations',\n      fix: 'Pass the migration directory name without `^`, or use a contract-accepting flag like `--to` or `--from`.',\n    });\n  }\n\n  if (validateRefName(input) && Object.hasOwn(ctx.refs, input)) {\n    return notOk({\n      kind: 'wrong-grammar',\n      input,\n      expectedGrammar: 'migration',\n      message: `\"${input}\" is a ref name, not a migration`,\n      fix: 'Refs point at contracts, not migrations. Use a migration directory name or migration hash.',\n    });\n  }\n\n  const edge = findEdgeByDirName(ctx.graph, input);\n  if (edge) {\n    return ok({\n      dirName: edge.dirName,\n      migrationHash: edge.migrationHash,\n      from: edge.from,\n      to: edge.to,\n      provenance: { kind: 'dir-name', dirName: input },\n    });\n  }\n\n  if (isFullHash(input)) {\n    const migEdge = ctx.graph.migrationByHash.get(input);\n    if (migEdge) {\n      return ok({\n        dirName: migEdge.dirName,\n        migrationHash: migEdge.migrationHash,\n        from: migEdge.from,\n        to: migEdge.to,\n        provenance: { kind: 'hash', input },\n      });\n    }\n    if (ctx.graph.nodes.has(input)) {\n      return notOk({\n        kind: 'wrong-grammar',\n        input,\n        expectedGrammar: 'migration',\n        message: 'Hash matched a contract but not a migration',\n        fix: 'Use a contract-accepting flag like `--to` or `--from` to reference contracts by hash. Pass `migration show <dir>` for a specific migration.',\n      });\n    }\n    return notOk({ kind: 'not-found', input, grammar: 'migration' });\n  }\n\n  if (isHexPrefix(input)) {\n    const prefix = normalizeHashPrefix(input);\n    const migMatches = [...ctx.graph.migrationByHash.entries()].filter(([hash]) =>\n      hash.startsWith(prefix),\n    );\n\n    const [firstMigMatch] = migMatches;\n    if (migMatches.length === 1 && firstMigMatch !== undefined) {\n      const [, matchedEdge] = firstMigMatch;\n      return ok({\n        dirName: matchedEdge.dirName,\n        migrationHash: matchedEdge.migrationHash,\n        from: matchedEdge.from,\n        to: matchedEdge.to,\n        provenance: { kind: 'hash', input },\n      });\n    }\n\n    if (migMatches.length > 1) {\n      return notOk({\n        kind: 'ambiguous',\n        input,\n        candidates: migMatches.map(([hash]) => hash),\n        grammar: 'migration',\n      });\n    }\n\n    const contractMatches = [...ctx.graph.nodes].filter((n) => n.startsWith(prefix));\n    if (contractMatches.length > 0) {\n      return notOk({\n        kind: 'wrong-grammar',\n        input,\n        expectedGrammar: 'migration',\n        message: 'Hash matched a contract but not a migration',\n        fix: 'Use a contract-accepting flag like `--to` or `--from` to reference contracts by hash. Pass `migration show <dir>` for a specific migration.',\n      });\n    }\n  }\n\n  return notOk({ kind: 'not-found', input, grammar: 'migration' });\n}\n"],"mappings":"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"}

package/dist/exports/refs.d.mts

@@ -1,2 +1,15 @@
-import { a as readRefs, c as validateRefValue, i as readRef, l as writeRef, n as Refs, o as resolveRef, r as deleteRef, s as validateRefName, t as RefEntry } from "../refs-CDaNerhT.mjs";
-export { type RefEntry, type Refs, deleteRef, readRef, readRefs, resolveRef, validateRefName, validateRefValue, writeRef };
+import { a as readRef, c as validateRefName, i as deleteRef, l as validateRefValue, o as readRefs, r as Refs, s as resolveRef, t as RefEntry, u as writeRef } from "../refs-C8f2IGM8.mjs";
+
+//#region src/refs/snapshot.d.ts
+interface ContractIR {
+  readonly contract: unknown;
+  readonly contractDts: string;
+}
+declare function writeRefSnapshot(refsDir: string, name: string, snapshot: ContractIR): Promise<void>;
+declare function readRefSnapshot(refsDir: string, name: string): Promise<ContractIR | null>;
+declare function deleteRefSnapshot(refsDir: string, name: string): Promise<void>;
+declare function writeRefPaired(refsDir: string, name: string, entry: RefEntry, snapshot: ContractIR): Promise<void>;
+declare function deleteRefPaired(refsDir: string, name: string): Promise<void>;
+//#endregion
+export { type ContractIR, type RefEntry, type Refs, deleteRef, deleteRefPaired, deleteRefSnapshot, readRef, readRefSnapshot, readRefs, resolveRef, validateRefName, validateRefValue, writeRef, writeRefPaired, writeRefSnapshot };
+//# sourceMappingURL=refs.d.mts.map