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

package/dist/exports/migration.mjs

@@ -1,9 +1,8 @@
-import "../io-Cun81AIZ.mjs";
-import { n as computeMigrationId } from "../attestation-DnebS4XZ.mjs";
+import "../io-CCnYsUHU.mjs";
+import { t as computeMigrationId } from "../attestation-DtF8tEOM.mjs";
 import { type } from "arktype";
-import { dirname, join } from "pathe";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
 //#region src/migration-base.ts
@@ -14,7 +13,7 @@ const MigrationMetaSchema = type({
 	"labels?": type("string").array()
 });
 /**
-* Base class for class-flow migrations.
+* Base class for migrations.
 *
 * A `Migration` subclass is itself a `MigrationPlan`: CLI commands and the
 * runner can consume it directly via `targetId`, `operations`, `origin`, and
@@ -23,6 +22,19 @@ const MigrationMetaSchema = type({
 * migration to be valid.
 */
 var Migration = class {
+	/**
+	* Assembled `ControlStack` injected by the orchestrator (`runMigration`).
+	*
+	* Subclasses (e.g. `PostgresMigration`) read the stack to materialize their
+	* adapter once per instance. Optional at the abstract level so unit tests can
+	* construct `Migration` instances purely for `operations` / `describe`
+	* assertions without needing a real stack; concrete subclasses that need the
+	* stack at runtime should narrow the parameter to required.
+	*/
+	stack;
+	constructor(stack) {
+		this.stack = stack;
+	}
 	get origin() {
 		const from = this.describe().from;
 		return from === "" ? null : { storageHash: from };
@@ -30,46 +42,27 @@ var Migration = class {
 	get destination() {
 		return { storageHash: this.describe().to };
 	}
-	/**
-	* Entrypoint guard for migration files. When called at module scope,
-	* detects whether the file is being run directly (e.g. `node migration.ts`)
-	* and if so, serializes the migration plan to `ops.json` and
-	* `migration.json` in the same directory. When the file is imported by
-	* another module, this is a no-op.
-	*
-	* Usage (at module scope, after the class definition):
-	*
-	*     class MyMigration extends Migration { ... }
-	*     export default MyMigration;
-	*     Migration.run(import.meta.url, MyMigration);
-	*/
-	static run(importMetaUrl, MigrationClass) {
-		if (!importMetaUrl) return;
-		const metaFilename = fileURLToPath(importMetaUrl);
-		const argv1 = process.argv[1];
-		if (!argv1) return;
-		let isEntrypoint;
-		try {
-			isEntrypoint = realpathSync(metaFilename) === realpathSync(argv1);
-		} catch {
-			return;
-		}
-		if (!isEntrypoint) return;
-		const args = process.argv.slice(2);
-		if (args.includes("--help")) {
-			printHelp();
-			return;
-		}
-		const dryRun = args.includes("--dry-run");
-		const migrationDir = dirname(metaFilename);
-		try {
-			serializeMigration(MigrationClass, migrationDir, dryRun);
-		} catch (err) {
-			process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
-			process.exitCode = 1;
-		}
-	}
 };
+/**
+* Returns true when `import.meta.url` resolves to the same file that was
+* invoked as the node entrypoint (`process.argv[1]`). Used by
+* `MigrationCLI.run` (in `@prisma-next/cli/migration-cli`) to no-op when
+* the migration module is being imported (e.g. by another script) rather
+* than executed directly.
+*/
+function isDirectEntrypoint(importMetaUrl) {
+	const metaFilename = fileURLToPath(importMetaUrl);
+	const argv1 = process.argv[1];
+	if (!argv1) return false;
+	try {
+		return realpathSync(metaFilename) === realpathSync(argv1);
+	} catch {
+		return false;
+	}
+}
+function printMigrationHelp() {
+	printHelp();
+}
 function printHelp() {
 	process.stdout.write([
 		"Usage: node <migration-file> [options]",
@@ -81,10 +74,11 @@ function printHelp() {
 	].join("\n"));
 }
 /**
-* Build the attested manifest written by `Migration.run()`.
+* Build the attested manifest from `describe()`-derived metadata, the
+* operations list, and the previously-scaffolded manifest (if any).
 *
-* When a `migration.json` already exists in the directory (the common case:
-* the package was scaffolded by `migration plan`), preserve the contract
+* 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`, `kind`) and the operations
@@ -93,14 +87,11 @@ function printHelp() {
 * schema-conformant manifest so the resulting package can still be read,
 * verified, and applied.
 *
-* In both cases the `migrationId` is recomputed against the current
-* manifest + ops so the on-disk artifacts are always fully attested — no
-* draft (`migrationId: null`) ever leaves this function.
+* The `migrationId` is recomputed against the current manifest + ops so
+* the on-disk artifacts are always fully attested.
 */
-function buildAttestedManifest(migrationDir, meta, ops) {
-	const existing = readExistingManifest(join(migrationDir, "migration.json"));
+function buildAttestedManifest(meta, ops, existing) {
 	const baseManifest = {
-		migrationId: null,
 		from: meta.from,
 		to: meta.to,
 		kind: meta.kind ?? "regular",
@@ -108,12 +99,7 @@ function buildAttestedManifest(migrationDir, meta, ops) {
 		createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
 		fromContract: existing?.fromContract ?? null,
 		toContract: existing?.toContract ?? { storage: { storageHash: meta.to } },
-		hints: existing?.hints ?? {
-			used: [],
-			applied: [],
-			plannerVersion: "2.0.0",
-			planningStrategy: "class-based"
-		},
+		hints: normalizeHints(existing?.hints),
 		...ifDefined("authorship", existing?.authorship)
 	};
 	const migrationId = computeMigrationId(baseManifest, ops);
@@ -122,38 +108,42 @@ function buildAttestedManifest(migrationDir, meta, ops) {
 		migrationId
 	};
 }
-function readExistingManifest(manifestPath) {
-	let raw;
-	try {
-		raw = readFileSync(manifestPath, "utf-8");
-	} catch {
-		return null;
-	}
-	try {
-		return JSON.parse(raw);
-	} catch {
-		return null;
-	}
+/**
+* Project `existing.hints` down to the known `MigrationHints` shape, dropping
+* any legacy keys that may linger in manifests 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"
+	};
 }
-function serializeMigration(MigrationClass, migrationDir, dryRun) {
-	const instance = new MigrationClass();
+/**
+* Pure conversion from a `Migration` instance (plus the previously
+* scaffolded manifest, when one exists on disk) to the in-memory
+* artifacts that downstream tooling persists. Owns metadata validation,
+* manifest synthesis/preservation, hint normalization, and the
+* content-addressed `migrationId` computation, but performs no file I/O
+* — callers handle reads (to source `existing`) and writes (to persist
+* `opsJson` / `manifestJson`).
+*/
+function buildMigrationArtifacts(instance, existing) {
 	const ops = instance.operations;
 	if (!Array.isArray(ops)) throw new Error("operations must be an array");
-	const serializedOps = JSON.stringify(ops, null, 2);
 	const parsed = MigrationMetaSchema(instance.describe());
 	if (parsed instanceof type.errors) throw new Error(`describe() returned invalid metadata: ${parsed.summary}`);
-	const manifest = buildAttestedManifest(migrationDir, parsed, ops);
-	if (dryRun) {
-		process.stdout.write(`--- migration.json ---\n${JSON.stringify(manifest, null, 2)}\n`);
-		process.stdout.write("--- ops.json ---\n");
-		process.stdout.write(`${serializedOps}\n`);
-		return;
-	}
-	writeFileSync(join(migrationDir, "ops.json"), serializedOps);
-	writeFileSync(join(migrationDir, "migration.json"), JSON.stringify(manifest, null, 2));
-	process.stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\n`);
+	const manifest = buildAttestedManifest(parsed, ops, existing);
+	return {
+		opsJson: JSON.stringify(ops, null, 2),
+		manifest,
+		manifestJson: JSON.stringify(manifest, null, 2)
+	};
 }
 
 //#endregion
-export { Migration };
+export { Migration, buildMigrationArtifacts, isDirectEntrypoint, printMigrationHelp };
 //# sourceMappingURL=migration.mjs.map

package/dist/exports/migration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"migration.mjs","names":["isEntrypoint: boolean","baseManifest: MigrationManifest","raw: string"],"sources":["../../src/migration-base.ts"],"sourcesContent":["import { readFileSync, realpathSync, writeFileSync } from 'node:fs';\nimport { fileURLToPath } from 'node:url';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationPlan,\n  MigrationPlanOperation,\n} from '@prisma-next/framework-components/control';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { type } from 'arktype';\nimport { dirname, join } from 'pathe';\nimport { computeMigrationId } from './attestation';\nimport type { MigrationManifest, MigrationOps } from './types';\n\nexport interface MigrationMeta {\n  readonly from: string;\n  readonly to: string;\n  readonly kind?: 'regular' | 'baseline';\n  readonly labels?: readonly string[];\n}\n\nconst MigrationMetaSchema = type({\n  from: 'string',\n  to: 'string',\n  'kind?': \"'regular' | 'baseline'\",\n  'labels?': type('string').array(),\n});\n\n/**\n * Base class for class-flow 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 manifest-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<TOperation extends MigrationPlanOperation = MigrationPlanOperation>\n  implements MigrationPlan\n{\n  abstract readonly targetId: string;\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    // An empty `from` represents a migration with no prior origin (e.g.\n    // initial baseline, or an in-process plan that was never persisted).\n    // Surface that as a null origin so runners treat the plan as\n    // origin-less rather than matching against an empty storage hash.\n    return from === '' ? null : { storageHash: from };\n  }\n\n  get destination(): { readonly storageHash: string } {\n    return { storageHash: this.describe().to };\n  }\n\n  /**\n   * Entrypoint guard for migration files. When called at module scope,\n   * detects whether the file is being run directly (e.g. `node migration.ts`)\n   * and if so, serializes the migration plan to `ops.json` and\n   * `migration.json` in the same directory. When the file is imported by\n   * another module, this is a no-op.\n   *\n   * Usage (at module scope, after the class definition):\n   *\n   *     class MyMigration extends Migration { ... }\n   *     export default MyMigration;\n   *     Migration.run(import.meta.url, MyMigration);\n   */\n  static run(importMetaUrl: string, MigrationClass: new () => Migration): void {\n    if (!importMetaUrl) return;\n\n    const metaFilename = fileURLToPath(importMetaUrl);\n    const argv1 = process.argv[1];\n    if (!argv1) return;\n\n    let isEntrypoint: boolean;\n    try {\n      isEntrypoint = realpathSync(metaFilename) === realpathSync(argv1);\n    } catch {\n      return;\n    }\n    if (!isEntrypoint) return;\n\n    const args = process.argv.slice(2);\n\n    if (args.includes('--help')) {\n      printHelp();\n      return;\n    }\n\n    const dryRun = args.includes('--dry-run');\n    const migrationDir = dirname(metaFilename);\n\n    try {\n      serializeMigration(MigrationClass, migrationDir, dryRun);\n    } catch (err) {\n      process.stderr.write(`${err instanceof Error ? err.message : String(err)}\\n`);\n      process.exitCode = 1;\n    }\n  }\n}\n\nfunction printHelp(): void {\n  process.stdout.write(\n    [\n      'Usage: node <migration-file> [options]',\n      '',\n      'Options:',\n      '  --dry-run  Print operations to stdout without writing files',\n      '  --help     Show this help message',\n      '',\n    ].join('\\n'),\n  );\n}\n\n/**\n * Build the attested manifest written by `Migration.run()`.\n *\n * When a `migration.json` already exists in the directory (the common case:\n * the package 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`, `kind`) and the operations\n * change as the author iterates. When no manifest exists yet (a bare\n * `migration.ts` run from scratch), synthesize a minimal but\n * schema-conformant manifest so the resulting package can still be read,\n * verified, and applied.\n *\n * In both cases the `migrationId` is recomputed against the current\n * manifest + ops so the on-disk artifacts are always fully attested — no\n * draft (`migrationId: null`) ever leaves this function.\n */\nfunction buildAttestedManifest(\n  migrationDir: string,\n  meta: MigrationMeta,\n  ops: MigrationOps,\n): MigrationManifest {\n  const existing = readExistingManifest(join(migrationDir, 'migration.json'));\n\n  const baseManifest: MigrationManifest = {\n    migrationId: null,\n    from: meta.from,\n    to: meta.to,\n    kind: meta.kind ?? 'regular',\n    labels: meta.labels ?? existing?.labels ?? [],\n    createdAt: existing?.createdAt ?? new Date().toISOString(),\n    fromContract: existing?.fromContract ?? null,\n    // When no scaffolded manifest exists we synthesize a minimal contract\n    // stub so the package is still readable end-to-end. The cast is\n    // intentional: only the storage bookend matters for hash computation\n    // (everything else is stripped by `computeMigrationId`), and a real\n    // contract bookend would only be available after `migration plan`.\n    toContract: existing?.toContract ?? ({ storage: { storageHash: meta.to } } as Contract),\n    hints: existing?.hints ?? {\n      used: [],\n      applied: [],\n      plannerVersion: '2.0.0',\n      planningStrategy: 'class-based',\n    },\n    ...ifDefined('authorship', existing?.authorship),\n  };\n\n  const migrationId = computeMigrationId(baseManifest, ops);\n  return { ...baseManifest, migrationId };\n}\n\nfunction readExistingManifest(manifestPath: string): Partial<MigrationManifest> | null {\n  let raw: string;\n  try {\n    raw = readFileSync(manifestPath, 'utf-8');\n  } catch {\n    return null;\n  }\n  try {\n    return JSON.parse(raw) as Partial<MigrationManifest>;\n  } catch {\n    return null;\n  }\n}\n\nfunction serializeMigration(\n  MigrationClass: new () => Migration,\n  migrationDir: string,\n  dryRun: boolean,\n): void {\n  const instance = new MigrationClass();\n\n  const ops = instance.operations;\n\n  if (!Array.isArray(ops)) {\n    throw new Error('operations must be an array');\n  }\n\n  const serializedOps = JSON.stringify(ops, null, 2);\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 manifest = buildAttestedManifest(migrationDir, parsed, ops);\n\n  if (dryRun) {\n    process.stdout.write(`--- migration.json ---\\n${JSON.stringify(manifest, null, 2)}\\n`);\n    process.stdout.write('--- ops.json ---\\n');\n    process.stdout.write(`${serializedOps}\\n`);\n    return;\n  }\n\n  writeFileSync(join(migrationDir, 'ops.json'), serializedOps);\n  writeFileSync(join(migrationDir, 'migration.json'), JSON.stringify(manifest, null, 2));\n\n  process.stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\\n`);\n}\n"],"mappings":";;;;;;;;;AAoBA,MAAM,sBAAsB,KAAK;CAC/B,MAAM;CACN,IAAI;CACJ,SAAS;CACT,WAAW,KAAK,SAAS,CAAC,OAAO;CAClC,CAAC;;;;;;;;;;AAWF,IAAsB,YAAtB,MAEA;CAkBE,IAAI,SAAkD;EACpD,MAAM,OAAO,KAAK,UAAU,CAAC;AAK7B,SAAO,SAAS,KAAK,OAAO,EAAE,aAAa,MAAM;;CAGnD,IAAI,cAAgD;AAClD,SAAO,EAAE,aAAa,KAAK,UAAU,CAAC,IAAI;;;;;;;;;;;;;;;CAgB5C,OAAO,IAAI,eAAuB,gBAA2C;AAC3E,MAAI,CAAC,cAAe;EAEpB,MAAM,eAAe,cAAc,cAAc;EACjD,MAAM,QAAQ,QAAQ,KAAK;AAC3B,MAAI,CAAC,MAAO;EAEZ,IAAIA;AACJ,MAAI;AACF,kBAAe,aAAa,aAAa,KAAK,aAAa,MAAM;UAC3D;AACN;;AAEF,MAAI,CAAC,aAAc;EAEnB,MAAM,OAAO,QAAQ,KAAK,MAAM,EAAE;AAElC,MAAI,KAAK,SAAS,SAAS,EAAE;AAC3B,cAAW;AACX;;EAGF,MAAM,SAAS,KAAK,SAAS,YAAY;EACzC,MAAM,eAAe,QAAQ,aAAa;AAE1C,MAAI;AACF,sBAAmB,gBAAgB,cAAc,OAAO;WACjD,KAAK;AACZ,WAAQ,OAAO,MAAM,GAAG,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,CAAC,IAAI;AAC7E,WAAQ,WAAW;;;;AAKzB,SAAS,YAAkB;AACzB,SAAQ,OAAO,MACb;EACE;EACA;EACA;EACA;EACA;EACA;EACD,CAAC,KAAK,KAAK,CACb;;;;;;;;;;;;;;;;;;;AAoBH,SAAS,sBACP,cACA,MACA,KACmB;CACnB,MAAM,WAAW,qBAAqB,KAAK,cAAc,iBAAiB,CAAC;CAE3E,MAAMC,eAAkC;EACtC,aAAa;EACb,MAAM,KAAK;EACX,IAAI,KAAK;EACT,MAAM,KAAK,QAAQ;EACnB,QAAQ,KAAK,UAAU,UAAU,UAAU,EAAE;EAC7C,WAAW,UAAU,8BAAa,IAAI,MAAM,EAAC,aAAa;EAC1D,cAAc,UAAU,gBAAgB;EAMxC,YAAY,UAAU,cAAe,EAAE,SAAS,EAAE,aAAa,KAAK,IAAI,EAAE;EAC1E,OAAO,UAAU,SAAS;GACxB,MAAM,EAAE;GACR,SAAS,EAAE;GACX,gBAAgB;GAChB,kBAAkB;GACnB;EACD,GAAG,UAAU,cAAc,UAAU,WAAW;EACjD;CAED,MAAM,cAAc,mBAAmB,cAAc,IAAI;AACzD,QAAO;EAAE,GAAG;EAAc;EAAa;;AAGzC,SAAS,qBAAqB,cAAyD;CACrF,IAAIC;AACJ,KAAI;AACF,QAAM,aAAa,cAAc,QAAQ;SACnC;AACN,SAAO;;AAET,KAAI;AACF,SAAO,KAAK,MAAM,IAAI;SAChB;AACN,SAAO;;;AAIX,SAAS,mBACP,gBACA,cACA,QACM;CACN,MAAM,WAAW,IAAI,gBAAgB;CAErC,MAAM,MAAM,SAAS;AAErB,KAAI,CAAC,MAAM,QAAQ,IAAI,CACrB,OAAM,IAAI,MAAM,8BAA8B;CAGhD,MAAM,gBAAgB,KAAK,UAAU,KAAK,MAAM,EAAE;CAGlD,MAAM,SAAS,oBADU,SAAS,UAAU,CACD;AAC3C,KAAI,kBAAkB,KAAK,OACzB,OAAM,IAAI,MAAM,yCAAyC,OAAO,UAAU;CAG5E,MAAM,WAAW,sBAAsB,cAAc,QAAQ,IAAI;AAEjE,KAAI,QAAQ;AACV,UAAQ,OAAO,MAAM,2BAA2B,KAAK,UAAU,UAAU,MAAM,EAAE,CAAC,IAAI;AACtF,UAAQ,OAAO,MAAM,qBAAqB;AAC1C,UAAQ,OAAO,MAAM,GAAG,cAAc,IAAI;AAC1C;;AAGF,eAAc,KAAK,cAAc,WAAW,EAAE,cAAc;AAC5D,eAAc,KAAK,cAAc,iBAAiB,EAAE,KAAK,UAAU,UAAU,MAAM,EAAE,CAAC;AAEtF,SAAQ,OAAO,MAAM,sCAAsC,aAAa,IAAI"}
+{"version":3,"file":"migration.mjs","names":["baseManifest: Omit<MigrationManifest, 'migrationId'>"],"sources":["../../src/migration-base.ts"],"sourcesContent":["import { realpathSync } from 'node:fs';\nimport { fileURLToPath } from 'node:url';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type {\n  ControlStack,\n  MigrationPlan,\n  MigrationPlanOperation,\n} from '@prisma-next/framework-components/control';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { type } from 'arktype';\nimport { computeMigrationId } from './attestation';\nimport type { MigrationHints, MigrationManifest, MigrationOps } from './types';\n\nexport interface MigrationMeta {\n  readonly from: string;\n  readonly to: string;\n  readonly kind?: 'regular' | 'baseline';\n  readonly labels?: readonly string[];\n}\n\nconst MigrationMetaSchema = type({\n  from: 'string',\n  to: 'string',\n  'kind?': \"'regular' | 'baseline'\",\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 manifest-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    // An empty `from` represents a migration with no prior origin (e.g.\n    // initial baseline, or an in-process plan that was never persisted).\n    // Surface that as a null origin so runners treat the plan as\n    // origin-less rather than matching against an empty storage hash.\n    return from === '' ? 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\nexport function printMigrationHelp(): void {\n  printHelp();\n}\n\nfunction printHelp(): void {\n  process.stdout.write(\n    [\n      'Usage: node <migration-file> [options]',\n      '',\n      'Options:',\n      '  --dry-run  Print operations to stdout without writing files',\n      '  --help     Show this help message',\n      '',\n    ].join('\\n'),\n  );\n}\n\n/**\n * In-memory artifacts produced from a `Migration` instance: the\n * serialized `ops.json` body, the `migration.json` manifest 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 */\nexport interface MigrationArtifacts {\n  readonly opsJson: string;\n  readonly manifest: MigrationManifest;\n  readonly manifestJson: string;\n}\n\n/**\n * Build the attested manifest from `describe()`-derived metadata, the\n * operations list, and the previously-scaffolded manifest (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`, `kind`) and the operations\n * change as the author iterates. When no manifest exists yet (a bare\n * `migration.ts` run from scratch), synthesize a minimal but\n * schema-conformant manifest so the resulting package can still be read,\n * verified, and applied.\n *\n * The `migrationId` is recomputed against the current manifest + ops so\n * the on-disk artifacts are always fully attested.\n */\nfunction buildAttestedManifest(\n  meta: MigrationMeta,\n  ops: MigrationOps,\n  existing: Partial<MigrationManifest> | null,\n): MigrationManifest {\n  const baseManifest: Omit<MigrationManifest, 'migrationId'> = {\n    from: meta.from,\n    to: meta.to,\n    kind: meta.kind ?? 'regular',\n    labels: meta.labels ?? existing?.labels ?? [],\n    createdAt: existing?.createdAt ?? new Date().toISOString(),\n    fromContract: existing?.fromContract ?? null,\n    // When no scaffolded manifest exists we synthesize a minimal contract\n    // stub so the package is still readable end-to-end. The cast is\n    // intentional: only the storage bookend matters for hash computation\n    // (everything else is stripped by `computeMigrationId`), and a real\n    // contract bookend would only be available after `migration plan`.\n    toContract: existing?.toContract ?? ({ storage: { storageHash: meta.to } } as Contract),\n    hints: normalizeHints(existing?.hints),\n    ...ifDefined('authorship', existing?.authorship),\n  };\n\n  const migrationId = computeMigrationId(baseManifest, ops);\n  return { ...baseManifest, migrationId };\n}\n\n/**\n * Project `existing.hints` down to the known `MigrationHints` shape, dropping\n * any legacy keys that may linger in manifests 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 manifest, when one exists on disk) to the in-memory\n * artifacts that downstream tooling persists. Owns metadata validation,\n * manifest synthesis/preservation, hint normalization, and the\n * content-addressed `migrationId` computation, but performs no file I/O\n * — callers handle reads (to source `existing`) and writes (to persist\n * `opsJson` / `manifestJson`).\n */\nexport function buildMigrationArtifacts(\n  instance: Migration,\n  existing: Partial<MigrationManifest> | 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  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 manifest = buildAttestedManifest(parsed, ops, existing);\n\n  return {\n    opsJson: JSON.stringify(ops, null, 2),\n    manifest,\n    manifestJson: JSON.stringify(manifest, null, 2),\n  };\n}\n"],"mappings":";;;;;;;;AAoBA,MAAM,sBAAsB,KAAK;CAC/B,MAAM;CACN,IAAI;CACJ,SAAS;CACT,WAAW,KAAK,SAAS,CAAC,OAAO;CAClC,CAAC;;;;;;;;;;AAWF,IAAsB,YAAtB,MAKA;;;;;;;;;;CAYE,AAAmB;CAEnB,YAAY,OAA4C;AACtD,OAAK,QAAQ;;CAkBf,IAAI,SAAkD;EACpD,MAAM,OAAO,KAAK,UAAU,CAAC;AAK7B,SAAO,SAAS,KAAK,OAAO,EAAE,aAAa,MAAM;;CAGnD,IAAI,cAAgD;AAClD,SAAO,EAAE,aAAa,KAAK,UAAU,CAAC,IAAI;;;;;;;;;;AAW9C,SAAgB,mBAAmB,eAAgC;CACjE,MAAM,eAAe,cAAc,cAAc;CACjD,MAAM,QAAQ,QAAQ,KAAK;AAC3B,KAAI,CAAC,MAAO,QAAO;AACnB,KAAI;AACF,SAAO,aAAa,aAAa,KAAK,aAAa,MAAM;SACnD;AACN,SAAO;;;AAIX,SAAgB,qBAA2B;AACzC,YAAW;;AAGb,SAAS,YAAkB;AACzB,SAAQ,OAAO,MACb;EACE;EACA;EACA;EACA;EACA;EACA;EACD,CAAC,KAAK,KAAK,CACb;;;;;;;;;;;;;;;;;;;AAkCH,SAAS,sBACP,MACA,KACA,UACmB;CACnB,MAAMA,eAAuD;EAC3D,MAAM,KAAK;EACX,IAAI,KAAK;EACT,MAAM,KAAK,QAAQ;EACnB,QAAQ,KAAK,UAAU,UAAU,UAAU,EAAE;EAC7C,WAAW,UAAU,8BAAa,IAAI,MAAM,EAAC,aAAa;EAC1D,cAAc,UAAU,gBAAgB;EAMxC,YAAY,UAAU,cAAe,EAAE,SAAS,EAAE,aAAa,KAAK,IAAI,EAAE;EAC1E,OAAO,eAAe,UAAU,MAAM;EACtC,GAAG,UAAU,cAAc,UAAU,WAAW;EACjD;CAED,MAAM,cAAc,mBAAmB,cAAc,IAAI;AACzD,QAAO;EAAE,GAAG;EAAc;EAAa;;;;;;;;;AAUzC,SAAS,eAAe,UAAsD;AAC5E,QAAO;EACL,MAAM,UAAU,QAAQ,EAAE;EAC1B,SAAS,UAAU,WAAW,EAAE;EAChC,gBAAgB,UAAU,kBAAkB;EAC7C;;;;;;;;;;;AAYH,SAAgB,wBACd,UACA,UACoB;CACpB,MAAM,MAAM,SAAS;AACrB,KAAI,CAAC,MAAM,QAAQ,IAAI,CACrB,OAAM,IAAI,MAAM,8BAA8B;CAIhD,MAAM,SAAS,oBADU,SAAS,UAAU,CACD;AAC3C,KAAI,kBAAkB,KAAK,OACzB,OAAM,IAAI,MAAM,yCAAyC,OAAO,UAAU;CAG5E,MAAM,WAAW,sBAAsB,QAAQ,KAAK,SAAS;AAE7D,QAAO;EACL,SAAS,KAAK,UAAU,KAAK,MAAM,EAAE;EACrC;EACA,cAAc,KAAK,UAAU,UAAU,MAAM,EAAE;EAChD"}

package/dist/exports/refs.mjs

@@ -1,4 +1,4 @@
-import { c as errorInvalidRefValue, l as errorInvalidRefs, s as errorInvalidRefName, t as MigrationToolsError } from "../errors-C_XuSbX7.mjs";
+import { c as errorInvalidRefName, l as errorInvalidRefValue, t as MigrationToolsError, u as errorInvalidRefs } from "../errors-BKbRGCJM.mjs";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { type } from "arktype";
 import { dirname, join } from "pathe";

package/dist/exports/types.d.mts

@@ -1,4 +1,4 @@
-import { a as DraftMigrationManifest, c as MigrationHints, d as isAttested, f as isDraft, i as DraftMigrationBundle, l as MigrationManifest, n as AttestedMigrationManifest, o as MigrationChainEntry, r as BaseMigrationBundle, s as MigrationGraph, t as AttestedMigrationBundle, u as MigrationOps } from "../types-D2uX4ql7.mjs";
+import { a as MigrationManifest, i as MigrationHints, n as MigrationChainEntry, o as MigrationOps, r as MigrationGraph, t as MigrationBundle } from "../types-DyGXcWWp.mjs";
 
 //#region src/errors.d.ts
 
@@ -31,5 +31,5 @@ declare class MigrationToolsError extends Error {
   static is(error: unknown): error is MigrationToolsError;
 }
 //#endregion
-export { type AttestedMigrationBundle, type AttestedMigrationManifest, type BaseMigrationBundle, type BaseMigrationBundle as MigrationBundle, type BaseMigrationBundle as MigrationPackage, type DraftMigrationBundle, type DraftMigrationManifest, type MigrationChainEntry, type MigrationGraph, type MigrationHints, type MigrationManifest, type MigrationOps, MigrationToolsError, isAttested, isDraft };
+export { type MigrationBundle, type MigrationBundle as MigrationPackage, type MigrationChainEntry, type MigrationGraph, type MigrationHints, type MigrationManifest, type MigrationOps, MigrationToolsError };
 //# sourceMappingURL=types.d.mts.map

package/dist/exports/types.mjs

@@ -1,17 +1,3 @@
-import { t as MigrationToolsError } from "../errors-C_XuSbX7.mjs";
+import { t as MigrationToolsError } from "../errors-BKbRGCJM.mjs";
 
-//#region src/types.ts
-/**
-* Type guard that narrows a MigrationBundle to an AttestedMigrationBundle.
-* Use with `.filter(isAttested)` to get a typed array of attested bundles.
-*/
-function isAttested(bundle) {
-	return typeof bundle.manifest.migrationId === "string";
-}
-function isDraft(bundle) {
-	return bundle.manifest.migrationId === null;
-}
-
-//#endregion
-export { MigrationToolsError, isAttested, isDraft };
-//# sourceMappingURL=types.mjs.map
+export { MigrationToolsError };

package/dist/{io-Cun81AIZ.mjs → io-CCnYsUHU.mjs}

@@ -1,4 +1,4 @@
-import { a as errorInvalidJson, d as errorMissingFile, o as errorInvalidManifest, r as errorDirectoryExists, u as errorInvalidSlug } from "./errors-C_XuSbX7.mjs";
+import { a as errorInvalidDestName, d as errorInvalidSlug, f as errorMissingFile, o as errorInvalidJson, r as errorDirectoryExists, s as errorInvalidManifest } from "./errors-BKbRGCJM.mjs";
 import { copyFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { type } from "arktype";
 import { basename, dirname, join } from "pathe";
@@ -13,15 +13,14 @@ function hasErrnoCode(error, code) {
 const MigrationManifestSchema = type({
 	from: "string",
 	to: "string",
-	migrationId: "string | null",
+	migrationId: "string",
 	kind: "'regular' | 'baseline'",
 	fromContract: "object | null",
 	toContract: "object",
 	hints: type({
 		used: "string[]",
 		applied: "string[]",
-		plannerVersion: "string",
-		planningStrategy: "string"
+		plannerVersion: "string"
 	}),
 	labels: "string[]",
 	"authorship?": type({
@@ -51,24 +50,21 @@ async function writeMigrationPackage(dir, manifest, ops) {
 	await writeFile(join(dir, OPS_FILE), JSON.stringify(ops, null, 2), { flag: "wx" });
 }
 /**
-* Copy the destination contract artifacts (`contract.json` and the
-* colocated `contract.d.ts`) into the migration package directory so
-* authors of the scaffolded `migration.ts` can import the typed
-* contract relative to the migration directory
-* (`import type { Contract } from './contract'`).
+* Copy a list of files into `destDir`, optionally renaming each one.
 *
-* A missing `.d.ts` is tolerated (only the `.json` is required) so the
-* helper stays usable in tests that hand-roll a bare `contract.json`.
-* A missing `contract.json` — or any other I/O failure — throws.
+* The destination directory is created (with `recursive: true`) if it
+* does not already exist. Each source path is copied byte-for-byte into
+* `destDir/<destName>`; missing sources throw `ENOENT`. The helper is
+* intentionally generic: callers own the list of files (e.g. a contract
+* emitter's emitted output) and the naming convention (e.g. renaming
+* the destination contract to `end-contract.*` and the source contract
+* to `start-contract.*`).
 */
-async function copyContractToMigrationDir(packageDir, contractJsonPath) {
-	await copyFile(contractJsonPath, join(packageDir, "contract.json"));
-	const dtsPath = `${contractJsonPath.slice(0, -5)}.d.ts`;
-	try {
-		await copyFile(dtsPath, join(packageDir, "contract.d.ts"));
-	} catch (error) {
-		if (hasErrnoCode(error, "ENOENT")) return;
-		throw error;
+async function copyFilesWithRename(destDir, files) {
+	await mkdir(destDir, { recursive: true });
+	for (const file of files) {
+		if (basename(file.destName) !== file.destName) throw errorInvalidDestName(file.destName);
+		await copyFile(file.sourcePath, join(destDir, file.destName));
 	}
 }
 async function writeMigrationManifest(dir, manifest) {
@@ -153,5 +149,5 @@ function formatMigrationDirName(timestamp, slug) {
 }
 
 //#endregion
-export { writeMigrationManifest as a, readMigrationsDir as i, formatMigrationDirName as n, writeMigrationOps as o, readMigrationPackage as r, writeMigrationPackage as s, copyContractToMigrationDir as t };
-//# sourceMappingURL=io-Cun81AIZ.mjs.map
+export { writeMigrationManifest as a, readMigrationsDir as i, formatMigrationDirName as n, writeMigrationOps as o, readMigrationPackage as r, writeMigrationPackage as s, copyFilesWithRename as t };
+//# sourceMappingURL=io-CCnYsUHU.mjs.map

package/dist/io-CCnYsUHU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"io-CCnYsUHU.mjs","names":["manifestRaw: string","opsRaw: string","manifest: MigrationManifest","ops: MigrationOps","entries: string[]","packages: MigrationBundle[]"],"sources":["../src/io.ts"],"sourcesContent":["import { copyFile, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';\nimport { type } from 'arktype';\nimport { basename, dirname, join } from 'pathe';\nimport {\n  errorDirectoryExists,\n  errorInvalidDestName,\n  errorInvalidJson,\n  errorInvalidManifest,\n  errorInvalidSlug,\n  errorMissingFile,\n} from './errors';\nimport type { MigrationBundle, MigrationManifest, MigrationOps } from './types';\n\nconst MANIFEST_FILE = 'migration.json';\nconst OPS_FILE = 'ops.json';\nconst MAX_SLUG_LENGTH = 64;\n\nfunction hasErrnoCode(error: unknown, code: string): boolean {\n  return error instanceof Error && (error as { code?: string }).code === code;\n}\n\nconst MigrationHintsSchema = type({\n  used: 'string[]',\n  applied: 'string[]',\n  plannerVersion: 'string',\n});\n\nconst MigrationManifestSchema = type({\n  from: 'string',\n  to: 'string',\n  migrationId: 'string',\n  kind: \"'regular' | 'baseline'\",\n  fromContract: 'object | null',\n  toContract: 'object',\n  hints: MigrationHintsSchema,\n  labels: 'string[]',\n  'authorship?': type({\n    'author?': 'string',\n    'email?': 'string',\n  }),\n  'signature?': type({\n    keyId: 'string',\n    value: 'string',\n  }).or('null'),\n  createdAt: 'string',\n});\n\nconst MigrationOpSchema = type({\n  id: 'string',\n  label: 'string',\n  operationClass: \"'additive' | 'widening' | 'destructive' | 'data'\",\n});\n\n// Intentionally shallow: operation-specific payload validation is owned by planner/runner layers.\nconst MigrationOpsSchema = MigrationOpSchema.array();\n\nexport async function writeMigrationPackage(\n  dir: string,\n  manifest: MigrationManifest,\n  ops: MigrationOps,\n): Promise<void> {\n  await mkdir(dirname(dir), { recursive: true });\n\n  try {\n    await mkdir(dir);\n  } catch (error) {\n    if (hasErrnoCode(error, 'EEXIST')) {\n      throw errorDirectoryExists(dir);\n    }\n    throw error;\n  }\n\n  await writeFile(join(dir, MANIFEST_FILE), JSON.stringify(manifest, null, 2), { flag: 'wx' });\n  await writeFile(join(dir, OPS_FILE), JSON.stringify(ops, null, 2), { flag: 'wx' });\n}\n\n/**\n * Copy a list of files into `destDir`, optionally renaming each one.\n *\n * The destination directory is created (with `recursive: true`) if it\n * does not already exist. Each source path is copied byte-for-byte into\n * `destDir/<destName>`; missing sources throw `ENOENT`. The helper is\n * intentionally generic: callers own the list of files (e.g. a contract\n * emitter's emitted output) and the naming convention (e.g. renaming\n * the destination contract to `end-contract.*` and the source contract\n * to `start-contract.*`).\n */\nexport async function copyFilesWithRename(\n  destDir: string,\n  files: readonly { readonly sourcePath: string; readonly destName: string }[],\n): Promise<void> {\n  await mkdir(destDir, { recursive: true });\n  for (const file of files) {\n    if (basename(file.destName) !== file.destName) {\n      throw errorInvalidDestName(file.destName);\n    }\n    await copyFile(file.sourcePath, join(destDir, file.destName));\n  }\n}\n\nexport async function writeMigrationManifest(\n  dir: string,\n  manifest: MigrationManifest,\n): Promise<void> {\n  await writeFile(join(dir, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}\\n`);\n}\n\nexport async function writeMigrationOps(dir: string, ops: MigrationOps): Promise<void> {\n  await writeFile(join(dir, OPS_FILE), `${JSON.stringify(ops, null, 2)}\\n`);\n}\n\nexport async function readMigrationPackage(dir: string): Promise<MigrationBundle> {\n  const manifestPath = join(dir, MANIFEST_FILE);\n  const opsPath = join(dir, OPS_FILE);\n\n  let manifestRaw: string;\n  try {\n    manifestRaw = await readFile(manifestPath, 'utf-8');\n  } catch (error) {\n    if (hasErrnoCode(error, 'ENOENT')) {\n      throw errorMissingFile(MANIFEST_FILE, dir);\n    }\n    throw error;\n  }\n\n  let opsRaw: string;\n  try {\n    opsRaw = await readFile(opsPath, 'utf-8');\n  } catch (error) {\n    if (hasErrnoCode(error, 'ENOENT')) {\n      throw errorMissingFile(OPS_FILE, dir);\n    }\n    throw error;\n  }\n\n  let manifest: MigrationManifest;\n  try {\n    manifest = JSON.parse(manifestRaw);\n  } catch (e) {\n    throw errorInvalidJson(manifestPath, e instanceof Error ? e.message : String(e));\n  }\n\n  let ops: MigrationOps;\n  try {\n    ops = JSON.parse(opsRaw);\n  } catch (e) {\n    throw errorInvalidJson(opsPath, e instanceof Error ? e.message : String(e));\n  }\n\n  validateManifest(manifest, manifestPath);\n  validateOps(ops, opsPath);\n\n  return {\n    dirName: basename(dir),\n    dirPath: dir,\n    manifest,\n    ops,\n  };\n}\n\nfunction validateManifest(\n  manifest: unknown,\n  filePath: string,\n): asserts manifest is MigrationManifest {\n  const result = MigrationManifestSchema(manifest);\n  if (result instanceof type.errors) {\n    throw errorInvalidManifest(filePath, result.summary);\n  }\n}\n\nfunction validateOps(ops: unknown, filePath: string): asserts ops is MigrationOps {\n  const result = MigrationOpsSchema(ops);\n  if (result instanceof type.errors) {\n    throw errorInvalidManifest(filePath, result.summary);\n  }\n}\n\nexport async function readMigrationsDir(\n  migrationsRoot: string,\n): Promise<readonly MigrationBundle[]> {\n  let entries: string[];\n  try {\n    entries = await readdir(migrationsRoot);\n  } catch (error) {\n    if (hasErrnoCode(error, 'ENOENT')) {\n      return [];\n    }\n    throw error;\n  }\n\n  const packages: MigrationBundle[] = [];\n\n  for (const entry of entries.sort()) {\n    const entryPath = join(migrationsRoot, entry);\n    const entryStat = await stat(entryPath);\n    if (!entryStat.isDirectory()) continue;\n\n    const manifestPath = join(entryPath, MANIFEST_FILE);\n    try {\n      await stat(manifestPath);\n    } catch {\n      continue; // skip non-migration directories\n    }\n\n    packages.push(await readMigrationPackage(entryPath));\n  }\n\n  return packages;\n}\n\nexport function formatMigrationDirName(timestamp: Date, slug: string): string {\n  const sanitized = slug\n    .toLowerCase()\n    .replace(/[^a-z0-9]/g, '_')\n    .replace(/_+/g, '_')\n    .replace(/^_|_$/g, '');\n\n  if (sanitized.length === 0) {\n    throw errorInvalidSlug(slug);\n  }\n\n  const truncated = sanitized.slice(0, MAX_SLUG_LENGTH);\n\n  const y = timestamp.getUTCFullYear();\n  const mo = String(timestamp.getUTCMonth() + 1).padStart(2, '0');\n  const d = String(timestamp.getUTCDate()).padStart(2, '0');\n  const h = String(timestamp.getUTCHours()).padStart(2, '0');\n  const mi = String(timestamp.getUTCMinutes()).padStart(2, '0');\n\n  return `${y}${mo}${d}T${h}${mi}_${truncated}`;\n}\n"],"mappings":"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"}

package/dist/types-DyGXcWWp.d.mts

@@ -0,0 +1,71 @@
+import { Contract } from "@prisma-next/contract/types";
+import { MigrationPlanOperation } from "@prisma-next/framework-components/control";
+
+//#region src/types.d.ts
+interface MigrationHints {
+  readonly used: readonly string[];
+  readonly applied: readonly string[];
+  readonly plannerVersion: string;
+}
+/**
+ * On-disk migration manifest. Every migration is content-addressed: the
+ * `migrationId` is a hash over the manifest envelope plus the operations
+ * list, computed at write time. There is no draft state — a migration
+ * directory either exists with a fully attested manifest or it does not.
+ *
+ * When the planner cannot lower an operation because of an unfilled
+ * `placeholder(...)` slot, the migration is still written with
+ * `migrationId` hashed over `ops: []`. Re-running self-emit after the
+ * user fills the placeholder produces a *different* `migrationId`
+ * (committed to the real ops); this is intentional.
+ */
+interface MigrationManifest {
+  readonly migrationId: string;
+  readonly from: string;
+  readonly to: string;
+  readonly kind: 'regular' | 'baseline';
+  readonly fromContract: Contract | null;
+  readonly toContract: Contract;
+  readonly hints: MigrationHints;
+  readonly labels: readonly string[];
+  readonly authorship?: {
+    readonly author?: string;
+    readonly email?: string;
+  };
+  readonly signature?: {
+    readonly keyId: string;
+    readonly value: string;
+  } | null;
+  readonly createdAt: string;
+}
+type MigrationOps = readonly MigrationPlanOperation[];
+/**
+ * An on-disk migration directory containing a manifest and operations.
+ */
+interface MigrationBundle {
+  readonly dirName: string;
+  readonly dirPath: string;
+  readonly manifest: MigrationManifest;
+  readonly ops: MigrationOps;
+}
+/**
+ * An entry in the migration graph. All on-disk migrations are attested,
+ * so `migrationId` is always a string.
+ */
+interface MigrationChainEntry {
+  readonly from: string;
+  readonly to: string;
+  readonly migrationId: string;
+  readonly dirName: string;
+  readonly createdAt: string;
+  readonly labels: readonly string[];
+}
+interface MigrationGraph {
+  readonly nodes: ReadonlySet<string>;
+  readonly forwardChain: ReadonlyMap<string, readonly MigrationChainEntry[]>;
+  readonly reverseChain: ReadonlyMap<string, readonly MigrationChainEntry[]>;
+  readonly migrationById: ReadonlyMap<string, MigrationChainEntry>;
+}
+//#endregion
+export { MigrationManifest as a, MigrationHints as i, MigrationChainEntry as n, MigrationOps as o, MigrationGraph as r, MigrationBundle as t };
+//# sourceMappingURL=types-DyGXcWWp.d.mts.map

package/dist/types-DyGXcWWp.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DyGXcWWp.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;UAGiB,cAAA;;EAAA,SAAA,OAAA,EAAc,SAAA,MAAA,EAAA;EAkBd,SAAA,cAAiB,EAAA,MAAA;;;;;AAclC;AAKA;AAWA;AASA;;;;;;AAI8C,UA3C7B,iBAAA,CA2C6B;EAApB,SAAA,WAAA,EAAA,MAAA;EAAW,SAAA,IAAA,EAAA,MAAA;;;yBAtCZ;uBACF;kBACL;;;;;;;;;;;;KAON,YAAA,YAAwB;;;;UAKnB,eAAA;;;qBAGI;gBACL;;;;;;UAOC,mBAAA;;;;;;;;UASA,cAAA;kBACC;yBACO,6BAA6B;yBAC7B,6BAA6B;0BAC5B,oBAAoB"}

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@prisma-next/migration-tools",
-  "version": "0.4.0-dev.9",
+  "version": "0.5.0-dev.1",
   "type": "module",
   "sideEffects": false,
   "description": "On-disk migration persistence, attestation, and chain reconstruction for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.29",
     "pathe": "^2.0.3",
-    "@prisma-next/contract": "0.4.0-dev.9",
-    "@prisma-next/framework-components": "0.4.0-dev.9",
-    "@prisma-next/utils": "0.4.0-dev.9"
+    "prettier": "^3.6.2",
+    "@prisma-next/contract": "0.5.0-dev.1",
+    "@prisma-next/utils": "0.5.0-dev.1",
+    "@prisma-next/framework-components": "0.5.0-dev.1"
   },
   "devDependencies": {
     "tsdown": "0.18.4",

package/src/attestation.ts

@@ -1,11 +1,11 @@
 import { createHash } from 'node:crypto';
 import { canonicalizeJson } from './canonicalize-json';
-import { readMigrationPackage, writeMigrationManifest } from './io';
-import type { MigrationManifest, MigrationOps } from './types';
+import { readMigrationPackage } from './io';
+import type { MigrationBundle, MigrationManifest, MigrationOps } from './types';
 
 export interface VerifyResult {
   readonly ok: boolean;
-  readonly reason?: 'draft' | 'mismatch';
+  readonly reason?: 'mismatch';
   readonly storedMigrationId?: string;
   readonly computedMigrationId?: string;
 }
@@ -20,8 +20,15 @@ function sha256Hex(input: string): string {
  * for the rationale: contracts are anchored separately by the
  * storage-hash bookends inside the envelope; planner hints are advisory
  * and must not affect identity.
+ *
+ * The `migrationId` field on the manifest is stripped before hashing so
+ * the function can be used both at write time (when no id exists yet)
+ * and at verify time (rehashing an already-attested manifest).
  */
-export function computeMigrationId(manifest: MigrationManifest, ops: MigrationOps): string {
+export function computeMigrationId(
+  manifest: Omit<MigrationManifest, 'migrationId'> & { readonly migrationId?: string },
+  ops: MigrationOps,
+): string {
   const {
     migrationId: _migrationId,
     signature: _signature,
@@ -40,34 +47,35 @@ export function computeMigrationId(manifest: MigrationManifest, ops: MigrationOp
   return `sha256:${hash}`;
 }
 
-/** Compute and persist `migrationId` to `manifest.json`. */
-export async function attestMigration(dir: string): Promise<string> {
-  const pkg = await readMigrationPackage(dir);
-  const migrationId = computeMigrationId(pkg.manifest, pkg.ops);
-
-  const updated = { ...pkg.manifest, migrationId };
-  await writeMigrationManifest(dir, updated);
-
-  return migrationId;
-}
-
-export async function verifyMigration(dir: string): Promise<VerifyResult> {
-  const pkg = await readMigrationPackage(dir);
-
-  if (pkg.manifest.migrationId === null) {
-    return { ok: false, reason: 'draft' };
-  }
-
-  const computed = computeMigrationId(pkg.manifest, pkg.ops);
+/**
+ * Re-hash an on-disk migration bundle and compare against the stored
+ * `migrationId`. Returns `{ ok: true }` when the package is internally
+ * consistent (manifest + ops still produce the recorded id), or
+ * `{ ok: false, reason: 'mismatch', stored, computed }` when they do
+ * not — typically a sign of FS corruption, partial writes, or a
+ * post-emit hand edit.
+ */
+export function verifyMigrationBundle(bundle: MigrationBundle): VerifyResult {
+  const computed = computeMigrationId(bundle.manifest, bundle.ops);
 
-  if (pkg.manifest.migrationId === computed) {
-    return { ok: true, storedMigrationId: pkg.manifest.migrationId, computedMigrationId: computed };
+  if (bundle.manifest.migrationId === computed) {
+    return {
+      ok: true,
+      storedMigrationId: bundle.manifest.migrationId,
+      computedMigrationId: computed,
+    };
   }
 
   return {
     ok: false,
     reason: 'mismatch',
-    storedMigrationId: pkg.manifest.migrationId,
+    storedMigrationId: bundle.manifest.migrationId,
     computedMigrationId: computed,
   };
 }
+
+/** Convenience wrapper: read the package from disk then verify it. */
+export async function verifyMigration(dir: string): Promise<VerifyResult> {
+  const pkg = await readMigrationPackage(dir);
+  return verifyMigrationBundle(pkg);
+}