@prisma-next/migration-tools 0.11.0-dev.4 → 0.11.0-dev.40

package/dist/exports/enumerate-migration-spaces.mjs

@@ -0,0 +1,107 @@
+import { s as readMigrationsDir } from "../io-Dc64lvaL.mjs";
+import { r as readRefs } from "../refs-HhOkD8BT.mjs";
+import { c as spaceMigrationDirectory, i as RESERVED_SPACE_SUBDIR_NAMES, l as spaceRefsDirectory, r as APP_SPACE_ID, s as isValidSpaceId, t as listContractSpaceDirectories } from "../verify-contract-spaces-DIdQLGo7.mjs";
+//#region src/enumerate-migration-spaces.ts
+/**
+* Index `migrations/<space>/refs/*.json` by the contract hash each ref
+* points at, so callers can attach `(ref names)` decorations to every
+* row whose destination contract hash matches.
+*
+* Each bucket is sorted lex-asc to keep rendered output deterministic
+* (adjacent rows pointing at the same hash render their ref decorations
+* in the same order).
+*
+* Refs whose hash matches no migration on disk are still indexed; the
+* caller decides whether to surface them. Migration rows only carry
+* `(refs)` decorations when a matching destination contract hash exists
+* on disk — orphan refs are not rendered on any row.
+*
+* Returns an empty map when the refs directory does not exist
+* ({@link readRefs} treats `ENOENT` as "no refs").
+*/
+async function resolveRefsByContractHash(refsDir) {
+	const refs = await readRefs(refsDir);
+	const byHash = /* @__PURE__ */ new Map();
+	for (const [name, entry] of Object.entries(refs)) {
+		const bucket = byHash.get(entry.hash);
+		if (bucket) bucket.push(name);
+		else byHash.set(entry.hash, [name]);
+	}
+	for (const bucket of byHash.values()) bucket.sort();
+	return byHash;
+}
+/**
+* Compare two contract-space IDs for the inter-space ordering rule:
+* {@link APP_SPACE_ID} first if present, then lex-asc on the rest.
+*/
+function compareSpaceIds(a, b) {
+	if (a === APP_SPACE_ID) return b === APP_SPACE_ID ? 0 : -1;
+	if (b === APP_SPACE_ID) return 1;
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+}
+/**
+* Sort `dirName` descending so the rendered output reads latest-first,
+* matching the `git log` latest-first convention.
+*/
+function compareDirNamesDescending(a, b) {
+	if (a.dirName < b.dirName) return 1;
+	if (a.dirName > b.dirName) return -1;
+	return 0;
+}
+/**
+* Enumerate every contract space's on-disk migrations under
+* `<projectMigrationsDir>/`. For each valid space directory:
+*
+* - Loads on-disk packages via {@link readMigrationsDir}.
+* - Attaches ref decorations: each migration's `refs[]` lists every ref
+*   name from `migrations/<spaceId>/refs/*.json` whose hash equals the
+*   migration's destination contract hash.
+* - Sorts migrations within the space by `dirName` descending
+*   (reverse-filename, latest first).
+*
+* Contract spaces are returned with {@link APP_SPACE_ID} first when
+* present, then the remaining ids lex-asc. A contract-space directory
+* that contains no migrations becomes `{ spaceId, migrations: [] }` so
+* the renderer's empty-state path can surface it.
+*
+* Directory entries that are not valid {@link isValidSpaceId} names are
+* skipped (a stray non-space directory under `migrations/` does not
+* spawn a phantom space entry). Entries whose name appears in
+* {@link RESERVED_SPACE_SUBDIR_NAMES} are also skipped — the per-space
+* `refs/` subdirectory name shape would otherwise satisfy
+* {@link isValidSpaceId} and surface as a phantom contract space.
+*
+* Returns `[]` when `<projectMigrationsDir>` does not exist — a fresh
+* project that has not authored any migration yet.
+*/
+async function enumerateMigrationSpaces(args) {
+	const { projectMigrationsDir } = args;
+	const spaceIds = (await listContractSpaceDirectories(projectMigrationsDir)).filter((name) => !RESERVED_SPACE_SUBDIR_NAMES.has(name)).filter(isValidSpaceId).sort(compareSpaceIds);
+	const spaces = [];
+	for (const spaceId of spaceIds) {
+		const spaceDir = spaceMigrationDirectory(projectMigrationsDir, spaceId);
+		const packages = await readMigrationsDir(spaceDir);
+		const refsByHash = await resolveRefsByContractHash(spaceRefsDirectory(spaceDir));
+		const migrations = packages.map((pkg) => ({
+			dirName: pkg.dirName,
+			from: pkg.metadata.from,
+			to: pkg.metadata.to,
+			migrationHash: pkg.metadata.migrationHash,
+			operationCount: pkg.ops.length,
+			createdAt: pkg.metadata.createdAt,
+			refs: refsByHash.get(pkg.metadata.to) ?? [],
+			providedInvariants: pkg.metadata.providedInvariants
+		})).sort(compareDirNamesDescending);
+		spaces.push({
+			spaceId,
+			migrations
+		});
+	}
+	return spaces;
+}
+//#endregion
+export { enumerateMigrationSpaces, resolveRefsByContractHash };
+
+//# sourceMappingURL=enumerate-migration-spaces.mjs.map

package/dist/exports/enumerate-migration-spaces.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumerate-migration-spaces.mjs","names":[],"sources":["../../src/enumerate-migration-spaces.ts"],"sourcesContent":["import { readMigrationsDir } from './io';\nimport type { MigrationListEntry, MigrationSpaceListEntry } from './migration-list-types';\nimport { readRefs } from './refs';\nimport {\n  APP_SPACE_ID,\n  isValidSpaceId,\n  RESERVED_SPACE_SUBDIR_NAMES,\n  spaceMigrationDirectory,\n  spaceRefsDirectory,\n} from './space-layout';\nimport { listContractSpaceDirectories } from './verify-contract-spaces';\n\n/**\n * Index `migrations/<space>/refs/*.json` by the contract hash each ref\n * points at, so callers can attach `(ref names)` decorations to every\n * row whose destination contract hash matches.\n *\n * Each bucket is sorted lex-asc to keep rendered output deterministic\n * (adjacent rows pointing at the same hash render their ref decorations\n * in the same order).\n *\n * Refs whose hash matches no migration on disk are still indexed; the\n * caller decides whether to surface them. Migration rows only carry\n * `(refs)` decorations when a matching destination contract hash exists\n * on disk — orphan refs are not rendered on any row.\n *\n * Returns an empty map when the refs directory does not exist\n * ({@link readRefs} treats `ENOENT` as \"no refs\").\n */\nexport async function resolveRefsByContractHash(\n  refsDir: string,\n): Promise<ReadonlyMap<string, readonly string[]>> {\n  const refs = await readRefs(refsDir);\n  const byHash = new Map<string, string[]>();\n  for (const [name, entry] of Object.entries(refs)) {\n    const bucket = byHash.get(entry.hash);\n    if (bucket) bucket.push(name);\n    else byHash.set(entry.hash, [name]);\n  }\n  for (const bucket of byHash.values()) {\n    bucket.sort();\n  }\n  return byHash;\n}\n\n/**\n * Compare two contract-space IDs for the inter-space ordering rule:\n * {@link APP_SPACE_ID} first if present, then lex-asc on the rest.\n */\nfunction compareSpaceIds(a: string, b: string): number {\n  if (a === APP_SPACE_ID) return b === APP_SPACE_ID ? 0 : -1;\n  if (b === APP_SPACE_ID) return 1;\n  if (a < b) return -1;\n  if (a > b) return 1;\n  return 0;\n}\n\n/**\n * Sort `dirName` descending so the rendered output reads latest-first,\n * matching the `git log` latest-first convention.\n */\nfunction compareDirNamesDescending(a: MigrationListEntry, b: MigrationListEntry): number {\n  if (a.dirName < b.dirName) return 1;\n  if (a.dirName > b.dirName) return -1;\n  return 0;\n}\n\n/**\n * Enumerate every contract space's on-disk migrations under\n * `<projectMigrationsDir>/`. For each valid space directory:\n *\n * - Loads on-disk packages via {@link readMigrationsDir}.\n * - Attaches ref decorations: each migration's `refs[]` lists every ref\n *   name from `migrations/<spaceId>/refs/*.json` whose hash equals the\n *   migration's destination contract hash.\n * - Sorts migrations within the space by `dirName` descending\n *   (reverse-filename, latest first).\n *\n * Contract spaces are returned with {@link APP_SPACE_ID} first when\n * present, then the remaining ids lex-asc. A contract-space directory\n * that contains no migrations becomes `{ spaceId, migrations: [] }` so\n * the renderer's empty-state path can surface it.\n *\n * Directory entries that are not valid {@link isValidSpaceId} names are\n * skipped (a stray non-space directory under `migrations/` does not\n * spawn a phantom space entry). Entries whose name appears in\n * {@link RESERVED_SPACE_SUBDIR_NAMES} are also skipped — the per-space\n * `refs/` subdirectory name shape would otherwise satisfy\n * {@link isValidSpaceId} and surface as a phantom contract space.\n *\n * Returns `[]` when `<projectMigrationsDir>` does not exist — a fresh\n * project that has not authored any migration yet.\n */\nexport async function enumerateMigrationSpaces(args: {\n  readonly projectMigrationsDir: string;\n}): Promise<readonly MigrationSpaceListEntry[]> {\n  const { projectMigrationsDir } = args;\n  const candidateDirs = await listContractSpaceDirectories(projectMigrationsDir);\n  const spaceIds = candidateDirs\n    .filter((name) => !RESERVED_SPACE_SUBDIR_NAMES.has(name))\n    .filter(isValidSpaceId)\n    .sort(compareSpaceIds);\n\n  const spaces: MigrationSpaceListEntry[] = [];\n  for (const spaceId of spaceIds) {\n    const spaceDir = spaceMigrationDirectory(projectMigrationsDir, spaceId);\n    const packages = await readMigrationsDir(spaceDir);\n    const refsByHash = await resolveRefsByContractHash(spaceRefsDirectory(spaceDir));\n\n    const migrations: MigrationListEntry[] = packages\n      .map((pkg) => ({\n        dirName: pkg.dirName,\n        from: pkg.metadata.from,\n        to: pkg.metadata.to,\n        migrationHash: pkg.metadata.migrationHash,\n        operationCount: pkg.ops.length,\n        createdAt: pkg.metadata.createdAt,\n        refs: refsByHash.get(pkg.metadata.to) ?? [],\n        providedInvariants: pkg.metadata.providedInvariants,\n      }))\n      .sort(compareDirNamesDescending);\n\n    spaces.push({ spaceId, migrations });\n  }\n\n  return spaces;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA6BA,eAAsB,0BACpB,SACiD;CACjD,MAAM,OAAO,MAAM,SAAS,OAAO;CACnC,MAAM,yBAAS,IAAI,IAAsB;CACzC,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,IAAI,GAAG;EAChD,MAAM,SAAS,OAAO,IAAI,MAAM,IAAI;EACpC,IAAI,QAAQ,OAAO,KAAK,IAAI;OACvB,OAAO,IAAI,MAAM,MAAM,CAAC,IAAI,CAAC;CACpC;CACA,KAAK,MAAM,UAAU,OAAO,OAAO,GACjC,OAAO,KAAK;CAEd,OAAO;AACT;;;;;AAMA,SAAS,gBAAgB,GAAW,GAAmB;CACrD,IAAI,MAAM,cAAc,OAAO,MAAM,eAAe,IAAI;CACxD,IAAI,MAAM,cAAc,OAAO;CAC/B,IAAI,IAAI,GAAG,OAAO;CAClB,IAAI,IAAI,GAAG,OAAO;CAClB,OAAO;AACT;;;;;AAMA,SAAS,0BAA0B,GAAuB,GAA+B;CACvF,IAAI,EAAE,UAAU,EAAE,SAAS,OAAO;CAClC,IAAI,EAAE,UAAU,EAAE,SAAS,OAAO;CAClC,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,eAAsB,yBAAyB,MAEC;CAC9C,MAAM,EAAE,yBAAyB;CAEjC,MAAM,YAAW,MADW,6BAA6B,oBAAoB,GAE1E,QAAQ,SAAS,CAAC,4BAA4B,IAAI,IAAI,CAAC,EACvD,OAAO,cAAc,EACrB,KAAK,eAAe;CAEvB,MAAM,SAAoC,CAAC;CAC3C,KAAK,MAAM,WAAW,UAAU;EAC9B,MAAM,WAAW,wBAAwB,sBAAsB,OAAO;EACtE,MAAM,WAAW,MAAM,kBAAkB,QAAQ;EACjD,MAAM,aAAa,MAAM,0BAA0B,mBAAmB,QAAQ,CAAC;EAE/E,MAAM,aAAmC,SACtC,KAAK,SAAS;GACb,SAAS,IAAI;GACb,MAAM,IAAI,SAAS;GACnB,IAAI,IAAI,SAAS;GACjB,eAAe,IAAI,SAAS;GAC5B,gBAAgB,IAAI,IAAI;GACxB,WAAW,IAAI,SAAS;GACxB,MAAM,WAAW,IAAI,IAAI,SAAS,EAAE,KAAK,CAAC;GAC1C,oBAAoB,IAAI,SAAS;EACnC,EAAE,EACD,KAAK,yBAAyB;EAEjC,OAAO,KAAK;GAAE;GAAS;EAAW,CAAC;CACrC;CAEA,OAAO;AACT"}

package/dist/exports/errors.d.mts

@@ -37,8 +37,8 @@ declare function errorDescriptorHeadHashMismatch(args: {
 /**
  * Wire-shape edge surfaced through the JSON envelope's
  * `meta.structuralPath` of `MIGRATION.NO_INVARIANT_PATH`. Slim by design —
- * authoring metadata (`createdAt`, `labels`) lives on `MigrationEdge` but
- * is intentionally dropped here so the envelope stays stable across
+ * authoring metadata (`createdAt`) lives on `MigrationEdge` but is
+ * intentionally dropped here so the envelope stays stable across
  * graph-internal refactors.
  *
  * Stability: any field added here is part of the public CLI JSON contract.

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../../src/errors.ts"],"mappings":";;AAmCA;;;;;;;;;;;;;;;cAAa,mBAAA,SAA4B,KAAA;EAAA,SAC9B,IAAA;EAAA,SACA,QAAA;EAAA,SACA,GAAA;EAAA,SACA,GAAA;EAAA,SACA,OAAA,EAAS,MAAA;cAGhB,IAAA,UACA,OAAA,UACA,OAAA;IAAA,SACW,GAAA;IAAA,SACA,GAAA;IAAA,SACA,OAAA,GAAU,MAAA;EAAA;EAAA,OAWhB,EAAA,CAAG,KAAA,YAAiB,KAAA,IAAS,mBAAA;AAAA;AAAA,iBA0BtB,gBAAA,CAAiB,QAAA,UAAkB,UAAA,WAAqB,mBAAA;AAAA,iBAwDxD,+BAAA,CAAgC,IAAA;EAAA,SACrC,WAAA;EAAA,SACA,cAAA;EAAA,SACA,WAAA;AAAA,IACP,mBAAA;;;;;;;;;;;AA0NJ;UAlCiB,6BAAA;EAAA,SACN,OAAA;EAAA,SACA,aAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;EAAA,SACA,UAAA;AAAA;AAAA,iBAGK,oBAAA,CAAqB,IAAA;EAAA,SAC1B,OAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,cAAA,WAAyB,6BAAA;AAAA,IAChC,mBAAA;AAAA,iBAqBY,qBAAA,CAAsB,IAAA;EAAA,SAC3B,OAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;AAAA,IACP,mBAAA"}
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../../src/errors.ts"],"mappings":";AAoCA;;;;;;;;;;;;;;;;AAAA,cAAa,mBAAA,SAA4B,KAAA;EAAA,SAC9B,IAAA;EAAA,SACA,QAAA;EAAA,SACA,GAAA;EAAA,SACA,GAAA;EAAA,SACA,OAAA,EAAS,MAAA;cAGhB,IAAA,UACA,OAAA,UACA,OAAA;IAAA,SACW,GAAA;IAAA,SACA,GAAA;IAAA,SACA,OAAA,GAAU,MAAA;EAAA;EAAA,OAWhB,EAAA,CAAG,KAAA,YAAiB,KAAA,IAAS,mBAAA;AAAA;AAAA,iBA0BtB,gBAAA,CAAiB,QAAA,UAAkB,UAAA,WAAqB,mBAAmB;AAAA,iBAwD3E,+BAAA,CAAgC,IAAA;EAAA,SACrC,WAAA;EAAA,SACA,cAAA;EAAA,SACA,WAAA;AAAA,IACP,mBAAmB;;;;;;;;;AAqMA;AAqBvB;;UAlCiB,6BAAA;EAAA,SACN,OAAA;EAAA,SACA,aAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;EAAA,SACA,UAAA;AAAA;AAAA,iBAGK,oBAAA,CAAqB,IAAA;EAAA,SAC1B,OAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,cAAA,WAAyB,6BAAA;AAAA,IAChC,mBAAmB;AAAA,iBAqBP,qBAAA,CAAsB,IAAA;EAAA,SAC3B,OAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;AAAA,IACP,mBAAmB"}

package/dist/exports/errors.mjs

@@ -1,2 +1,2 @@
-import { T as errorUnknownInvariant, r as errorDescriptorHeadHashMismatch, t as MigrationToolsError, u as errorInvalidJson, x as errorNoInvariantPath } from "../errors-DGYwcwXs.mjs";
+import { E as errorUnknownInvariant, S as errorNoInvariantPath, d as errorInvalidJson, r as errorDescriptorHeadHashMismatch, t as MigrationToolsError } from "../errors-CoEN114u.mjs";
 export { MigrationToolsError, errorDescriptorHeadHashMismatch, errorInvalidJson, errorNoInvariantPath, errorUnknownInvariant };

package/dist/exports/graph.d.mts

@@ -1,2 +1,2 @@
-import { n as MigrationGraph, t as MigrationEdge } from "../graph-BrLXqoUc.mjs";
+import { n as MigrationGraph, t as MigrationEdge } from "../graph-ZAIvH6p4.mjs";
 export { type MigrationEdge, type MigrationGraph };

package/dist/exports/hash.d.mts

@@ -1,5 +1,5 @@
-import { n as OnDiskMigrationPackage, t as MigrationOps } from "../package-DZj8YvD0.mjs";
-import { n as MigrationMetadata } from "../metadata-BFX0xdz8.mjs";
+import { n as OnDiskMigrationPackage, t as MigrationOps } from "../package-DIttKL7X.mjs";
+import { t as MigrationMetadata } from "../metadata-BCH1rNsk.mjs";
 
 //#region src/hash.d.ts
 interface VerifyResult {
@@ -9,13 +9,12 @@ interface VerifyResult {
   readonly computedHash: string;
 }
 /**
- * Content-addressed migration hash over (metadata envelope sans hints,
- * ops). See ADR 199 — Storage-only migration identity for the
- * rationale: the storage-hash bookends (`from`, `to`) inside the
- * envelope anchor the contract identity by hash, and planner hints are
- * advisory and must not affect identity. The full contract IRs are not
- * part of the manifest — they live in sibling `*-contract.json` files
- * authored alongside the migration, never inlined here.
+ * Content-addressed migration hash over (metadata envelope, ops). See
+ * ADR 199 — Storage-only migration identity for the rationale: the
+ * storage-hash bookends (`from`, `to`) inside the envelope anchor the
+ * contract identity by hash. The full contract IRs are not part of the
+ * manifest — they live in sibling `*-contract.json` files authored
+ * alongside the migration, never inlined here.
  *
  * The integrity check is purely structural, not semantic. The function
  * canonicalizes its inputs via `sortKeys` (recursive) + `JSON.stringify`

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

@@ -1 +1 @@
-{"version":3,"file":"hash.d.mts","names":[],"sources":["../../src/hash.ts"],"mappings":";;;;UAKiB,YAAA;EAAA,SACN,EAAA;EAAA,SACA,MAAA;EAAA,SACA,UAAA;EAAA,SACA,YAAA;AAAA;;;;;;;AAmCX;;;;;;;;;;;;;;;;AAwBA;;;;;;iBAxBgB,oBAAA,CACd,QAAA,EAAU,IAAA,CAAK,iBAAA;EAAA,SAAiD,aAAA;AAAA,GAChE,GAAA,EAAK,YAAA;;;;;;;;;;iBAsBS,mBAAA,CAAoB,GAAA,EAAK,sBAAA,GAAyB,YAAA"}
+{"version":3,"file":"hash.d.mts","names":[],"sources":["../../src/hash.ts"],"mappings":";;;;UAKiB,YAAA;EAAA,SACN,EAAA;EAAA,SACA,MAAA;EAAA,SACA,UAAA;EAAA,SACA,YAAA;AAAA;;;;;;AAAY;AAkCvB;;;;;;;;;;;;;;;AAEmB;AAsBnB;;;;;iBAxBgB,oBAAA,CACd,QAAA,EAAU,IAAA,CAAK,iBAAA;EAAA,SAAiD,aAAA;AAAA,GAChE,GAAA,EAAK,YAAA;AAsBuE;;;;;;;;;AAAA,iBAA9D,mBAAA,CAAoB,GAAA,EAAK,sBAAA,GAAyB,YAAY"}

package/dist/exports/hash.mjs

@@ -1,2 +1,2 @@
-import { n as verifyMigrationHash, t as computeMigrationHash } from "../hash-Cr4WIr4Z.mjs";
+import { n as verifyMigrationHash, t as computeMigrationHash } from "../hash--Y7vCpN3.mjs";
 export { computeMigrationHash, verifyMigrationHash };

package/dist/exports/invariants.d.mts

@@ -1,4 +1,4 @@
-import { t as MigrationOps } from "../package-DZj8YvD0.mjs";
+import { t as MigrationOps } from "../package-DIttKL7X.mjs";
 
 //#region src/invariants.d.ts
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"invariants.d.mts","names":[],"sources":["../../src/invariants.ts"],"mappings":";;;;;AAUA;;;;iBAAgB,mBAAA,CAAoB,WAAA;AA8BpC;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iBAAgB,wBAAA,CAAyB,GAAA,EAAK,YAAA"}
+{"version":3,"file":"invariants.d.mts","names":[],"sources":["../../src/invariants.ts"],"mappings":";;;;;AAUA;;;;iBAAgB,mBAAA,CAAoB,WAAmB;AA8BvD;;;;AAA0D;;;;;;;;;;;;;;;;;;;;;AAA1D,iBAAgB,wBAAA,CAAyB,GAAiB,EAAZ,YAAY"}

package/dist/exports/invariants.mjs

@@ -1,2 +1,2 @@
-import { n as validateInvariantId, t as deriveProvidedInvariants } from "../invariants-0daYEzyo.mjs";
+import { n as validateInvariantId, t as deriveProvidedInvariants } from "../invariants-lbJddL-S.mjs";
 export { deriveProvidedInvariants, validateInvariantId };

package/dist/exports/io.d.mts

@@ -1,4 +1,4 @@
-import { n as OnDiskMigrationPackage, t as MigrationOps } from "../package-DZj8YvD0.mjs";
+import { n as OnDiskMigrationPackage, t as MigrationOps } from "../package-DIttKL7X.mjs";
 import { MigrationMetadata, MigrationPackage } from "@prisma-next/framework-components/control";
 
 //#region src/io.d.ts

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

@@ -1 +1 @@
-{"version":3,"file":"io.d.mts","names":[],"sources":["../../src/io.ts"],"mappings":";;;;iBA+CsB,qBAAA,CACpB,GAAA,UACA,QAAA,EAAU,iBAAA,EACV,GAAA,EAAK,YAAA,GACJ,OAAA;AAJH;;;;;;;;;;;;;;;;AAoDA;;;;;;;;;;AA8BA;;;;AAlFA,iBAoDsB,2BAAA,CACpB,SAAA,UACA,GAAA,EAAK,gBAAA,GACJ,OAAA;;;;;;;AA2DH;;;;;;;;;;;AAaA;;;;iBA7CsB,6CAAA,CACpB,SAAA,UACA,GAAA,EAAK,gBAAA,GACJ,OAAA;EAAA,SAAmB,OAAA;AAAA;;;;AAiDtB;;;;;;;;iBApBsB,mBAAA,CACpB,OAAA,UACA,KAAA;EAAA,SAA2B,UAAA;EAAA,SAA6B,QAAA;AAAA,MACvD,OAAA;AAAA,iBAUmB,sBAAA,CACpB,GAAA,UACA,QAAA,EAAU,iBAAA,GACT,OAAA;AAAA,iBAImB,iBAAA,CAAkB,GAAA,UAAa,GAAA,EAAK,YAAA,GAAe,OAAA;AAAA,iBAInD,oBAAA,CAAqB,GAAA,WAAc,OAAA,CAAQ,sBAAA;AAAA,iBAiG3C,iBAAA,CACpB,cAAA,WACC,OAAA,UAAiB,sBAAA;AAAA,iBA+BJ,sBAAA,CAAuB,SAAA,EAAW,IAAA,EAAM,IAAA"}
+{"version":3,"file":"io.d.mts","names":[],"sources":["../../src/io.ts"],"mappings":";;;;iBAuCsB,qBAAA,CACpB,GAAA,UACA,QAAA,EAAU,iBAAA,EACV,GAAA,EAAK,YAAA,GACJ,OAAA;AAJH;;;;;;;;;;;;;;;AAIU;AAgDV;;;;;;;;;AAGU;AA2BV;;;;AAlFA,iBAoDsB,2BAAA,CACpB,SAAA,UACA,GAAA,EAAK,gBAAA,GACJ,OAAO;;;;;;AA8BmB;AA6B7B;;;;;;;;;;AAGU;AAUV;;;;iBA7CsB,6CAAA,CACpB,SAAA,UACA,GAAA,EAAK,gBAAA,GACJ,OAAO;EAAA,SAAY,OAAA;AAAA;;;AA6CZ;AAIV;;;;;;;;iBApBsB,mBAAA,CACpB,OAAA,UACA,KAAA;EAAA,SAA2B,UAAA;EAAA,SAA6B,QAAA;AAAA,MACvD,OAAO;AAAA,iBAUY,sBAAA,CACpB,GAAA,UACA,QAAA,EAAU,iBAAA,GACT,OAAO;AAAA,iBAIY,iBAAA,CAAkB,GAAA,UAAa,GAAA,EAAK,YAAA,GAAe,OAAO;AAAA,iBAI1D,oBAAA,CAAqB,GAAA,WAAc,OAAO,CAAC,sBAAA;AAAA,iBAiG3C,iBAAA,CACpB,cAAA,WACC,OAAO,UAAU,sBAAA;AAAA,iBA+BJ,sBAAA,CAAuB,SAAA,EAAW,IAAI,EAAE,IAAA"}

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-Dc64lvaL.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-BCH1rNsk.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-ZAIvH6p4.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-D97XMWVH.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 { c as errorHashNotInGraph } from "../errors-CoEN114u.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-D5JeadSE.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-types.d.mts

@@ -0,0 +1,2 @@
+import { n as MigrationListResult, r as MigrationSpaceListEntry, t as MigrationListEntry } from "../migration-list-types-B-qimPet.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-BCH1rNsk.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 { p as errorInvalidOperationEntry } from "../errors-CoEN114u.mjs";
+import { t as computeMigrationHash } from "../hash--Y7vCpN3.mjs";
+import { t as deriveProvidedInvariants } from "../invariants-lbJddL-S.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 { n as MigrationGraph, t as MigrationEdge } from "../graph-ZAIvH6p4.mjs";
+import { n as Refs } from "../refs-BaygQaFD.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 { a as validateRefName } from "../refs-HhOkD8BT.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":"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"}
+{"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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"}