@prisma-next/migration-tools 0.4.0-dev.8 → 0.4.1

package/src/graph-ops.ts

@@ -0,0 +1,65 @@
+import { Queue } from './queue';
+
+/**
+ * One step of a BFS traversal.
+ *
+ * `parent` and `incomingEdge` are `null` for start nodes — they were not
+ * reached via any edge. For every other node they record the node and edge
+ * by which this node was first reached.
+ */
+export interface BfsStep<E> {
+  readonly node: string;
+  readonly parent: string | null;
+  readonly incomingEdge: E | null;
+}
+
+/**
+ * Generic breadth-first traversal.
+ *
+ * Direction (forward/reverse) is expressed by the caller's `neighbours`
+ * closure: return `{ next, edge }` pairs where `next` is the node to visit
+ * next and `edge` is the edge that connects them. Callers that don't need
+ * path reconstruction can ignore the `parent`/`incomingEdge` fields of each
+ * yielded step.
+ *
+ * Stops are intrinsic — callers `break` out of the `for..of` loop when
+ * they've found what they're looking for.
+ *
+ * `ordering`, if provided, controls the order in which neighbours of each
+ * node are enqueued. Only matters for path-finding: a deterministic ordering
+ * makes BFS return a deterministic shortest path when multiple exist.
+ */
+export function* bfs<E>(
+  starts: Iterable<string>,
+  neighbours: (node: string) => Iterable<{ next: string; edge: E }>,
+  ordering?: (items: readonly { next: string; edge: E }[]) => readonly { next: string; edge: E }[],
+): Generator<BfsStep<E>> {
+  const visited = new Set<string>();
+  const parentMap = new Map<string, { parent: string; edge: E }>();
+  const queue = new Queue<string>();
+  for (const start of starts) {
+    if (!visited.has(start)) {
+      visited.add(start);
+      queue.push(start);
+    }
+  }
+  while (!queue.isEmpty) {
+    const current = queue.shift();
+    const parentInfo = parentMap.get(current);
+    yield {
+      node: current,
+      parent: parentInfo?.parent ?? null,
+      incomingEdge: parentInfo?.edge ?? null,
+    };
+
+    const items = neighbours(current);
+    const toVisit = ordering ? ordering([...items]) : items;
+    for (const { next, edge } of toVisit) {
+      if (!visited.has(next)) {
+        visited.add(next);
+        parentMap.set(next, { parent: current, edge });
+        queue.push(next);
+      }
+    }
+  }
+}

package/src/io.ts

@@ -3,12 +3,13 @@ import { type } from 'arktype';
 import { basename, dirname, join } from 'pathe';
 import {
   errorDirectoryExists,
+  errorInvalidDestName,
   errorInvalidJson,
   errorInvalidManifest,
   errorInvalidSlug,
   errorMissingFile,
 } from './errors';
-import type { BaseMigrationBundle, MigrationManifest, MigrationOps } from './types';
+import type { MigrationBundle, MigrationManifest, MigrationOps } from './types';
 
 const MANIFEST_FILE = 'migration.json';
 const OPS_FILE = 'ops.json';
@@ -22,13 +23,12 @@ const MigrationHintsSchema = type({
   used: 'string[]',
   applied: 'string[]',
   plannerVersion: 'string',
-  planningStrategy: 'string',
 });
 
 const MigrationManifestSchema = type({
   from: 'string',
   to: 'string',
-  migrationId: 'string | null',
+  migrationId: 'string',
   kind: "'regular' | 'baseline'",
   fromContract: 'object | null',
   toContract: 'object',
@@ -75,27 +75,26 @@ export async function writeMigrationPackage(
 }
 
 /**
- * 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.*`).
  */
-export async function copyContractToMigrationDir(
-  packageDir: string,
-  contractJsonPath: string,
+export async function copyFilesWithRename(
+  destDir: string,
+  files: readonly { readonly sourcePath: string; readonly destName: string }[],
 ): Promise<void> {
-  await copyFile(contractJsonPath, join(packageDir, 'contract.json'));
-  const dtsPath = `${contractJsonPath.slice(0, -'.json'.length)}.d.ts`;
-  try {
-    await copyFile(dtsPath, join(packageDir, 'contract.d.ts'));
-  } catch (error) {
-    if (hasErrnoCode(error, 'ENOENT')) return;
-    throw error;
+  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));
   }
 }
 
@@ -110,7 +109,7 @@ export async function writeMigrationOps(dir: string, ops: MigrationOps): Promise
   await writeFile(join(dir, OPS_FILE), `${JSON.stringify(ops, null, 2)}\n`);
 }
 
-export async function readMigrationPackage(dir: string): Promise<BaseMigrationBundle> {
+export async function readMigrationPackage(dir: string): Promise<MigrationBundle> {
   const manifestPath = join(dir, MANIFEST_FILE);
   const opsPath = join(dir, OPS_FILE);
 
@@ -178,7 +177,7 @@ function validateOps(ops: unknown, filePath: string): asserts ops is MigrationOp
 
 export async function readMigrationsDir(
   migrationsRoot: string,
-): Promise<readonly BaseMigrationBundle[]> {
+): Promise<readonly MigrationBundle[]> {
   let entries: string[];
   try {
     entries = await readdir(migrationsRoot);
@@ -189,7 +188,7 @@ export async function readMigrationsDir(
     throw error;
   }
 
-  const packages: BaseMigrationBundle[] = [];
+  const packages: MigrationBundle[] = [];
 
   for (const entry of entries.sort()) {
     const entryPath = join(migrationsRoot, entry);

package/src/migration-base.ts

@@ -9,7 +9,7 @@ import { ifDefined } from '@prisma-next/utils/defined';
 import { type } from 'arktype';
 import { dirname, join } from 'pathe';
 import { computeMigrationId } from './attestation';
-import type { MigrationManifest, MigrationOps } from './types';
+import type { MigrationHints, MigrationManifest, MigrationOps } from './types';
 
 export interface MigrationMeta {
   readonly from: string;
@@ -26,7 +26,7 @@ const MigrationMetaSchema = type({
 });
 
 /**
- * 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
@@ -140,9 +140,8 @@ function printHelp(): void {
  * 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: string,
@@ -151,8 +150,7 @@ function buildAttestedManifest(
 ): MigrationManifest {
   const existing = readExistingManifest(join(migrationDir, 'migration.json'));
 
-  const baseManifest: MigrationManifest = {
-    migrationId: null,
+  const baseManifest: Omit<MigrationManifest, 'migrationId'> = {
     from: meta.from,
     to: meta.to,
     kind: meta.kind ?? 'regular',
@@ -165,12 +163,7 @@ function buildAttestedManifest(
     // (everything else is stripped by `computeMigrationId`), and a real
     // contract bookend would only be available after `migration plan`.
     toContract: existing?.toContract ?? ({ storage: { storageHash: meta.to } } as Contract),
-    hints: existing?.hints ?? {
-      used: [],
-      applied: [],
-      plannerVersion: '2.0.0',
-      planningStrategy: 'class-based',
-    },
+    hints: normalizeHints(existing?.hints),
     ...ifDefined('authorship', existing?.authorship),
   };
 
@@ -178,6 +171,21 @@ function buildAttestedManifest(
   return { ...baseManifest, migrationId };
 }
 
+/**
+ * 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: MigrationHints | undefined): MigrationHints {
+  return {
+    used: existing?.used ?? [],
+    applied: existing?.applied ?? [],
+    plannerVersion: existing?.plannerVersion ?? '2.0.0',
+  };
+}
+
 function readExistingManifest(manifestPath: string): Partial<MigrationManifest> | null {
   let raw: string;
   try {

package/src/migration-ts.ts

@@ -1,17 +1,15 @@
 /**
  * Utilities for reading/writing `migration.ts` files.
  *
- * Rendering migration.ts source is now the target's responsibility — the CLI
- * obtains source strings either from a class-flow planner's
- * `plan.renderTypeScript()` or from a descriptor-flow target's
- * `migrations.renderDescriptorTypeScript(descriptors, context)`. The helper
- * here is limited to file I/O: writing the returned source with the right
- * executable bit, probing for existence, and evaluating legacy descriptor-
- * flow files.
+ * Rendering migration.ts source is the target's responsibility — the CLI
+ * obtains source strings from a planner's `plan.renderTypeScript()`. The
+ * helper here is limited to file I/O: writing the returned source with the
+ * right executable bit and probing for existence.
  */
 
 import { stat, writeFile } from 'node:fs/promises';
-import { join, resolve } from 'pathe';
+import { join } from 'pathe';
+import { format } from 'prettier';
 
 const MIGRATION_TS_FILE = 'migration.ts';
 
@@ -20,16 +18,31 @@ const MIGRATION_TS_FILE = 'migration.ts';
  * directory. If the source begins with a shebang, the file is written with
  * executable permissions (0o755) so it can be run directly via
  * `./migration.ts` by the authoring class's `Migration.run(...)` guard.
+ *
+ * The source is run through prettier before writing so migration renderers
+ * can produce structurally-correct but loosely-indented source and rely on
+ * a single canonical format on disk. Matches what `@prisma-next/emitter`
+ * already does for generated `contract.d.ts`.
  */
 export async function writeMigrationTs(packageDir: string, content: string): Promise<void> {
-  const isExecutable = content.startsWith('#!');
+  const formatted = await formatMigrationTsSource(content);
+  const isExecutable = formatted.startsWith('#!');
   await writeFile(
     join(packageDir, MIGRATION_TS_FILE),
-    content,
+    formatted,
     isExecutable ? { mode: 0o755 } : undefined,
   );
 }
 
+async function formatMigrationTsSource(source: string): Promise<string> {
+  return format(source, {
+    parser: 'typescript',
+    singleQuote: true,
+    semi: true,
+    printWidth: 100,
+  });
+}
+
 /**
  * Checks whether a migration.ts file exists in the package directory.
  */
@@ -41,42 +54,3 @@ export async function hasMigrationTs(packageDir: string): Promise<boolean> {
     return false;
   }
 }
-
-/**
- * Evaluates a descriptor-flow migration.ts file by loading it via native
- * Node import. Returns the result of calling the default export (expected
- * to be a function returning an array of operation descriptors).
- *
- * Class-flow migration.ts files use a different shape — their default
- * export is a class that extends `Migration` — and are evaluated by the
- * target's `emit` capability, not this helper.
- *
- * Requires Node ≥24 for native TypeScript support.
- */
-export async function evaluateMigrationTs(packageDir: string): Promise<readonly unknown[]> {
-  const filePath = resolve(join(packageDir, MIGRATION_TS_FILE));
-
-  try {
-    await stat(filePath);
-  } catch {
-    throw new Error(`migration.ts not found at "${filePath}"`);
-  }
-
-  const mod = (await import(filePath)) as { default?: unknown };
-
-  if (typeof mod.default !== 'function') {
-    throw new Error(
-      `migration.ts must export a default function returning an operation list. Got: ${typeof mod.default}`,
-    );
-  }
-
-  const result: unknown = mod.default();
-
-  if (!Array.isArray(result)) {
-    throw new Error(
-      `migration.ts default export must return an array of operations. Got: ${typeof result}`,
-    );
-  }
-
-  return result;
-}

package/src/queue.ts

@@ -0,0 +1,37 @@
+/**
+ * FIFO queue with amortised O(1) push and shift.
+ *
+ * Uses a head-index cursor over a backing array rather than
+ * `Array.prototype.shift()`, which is O(n) on V8. Intended for BFS-shaped
+ * traversals where the queue is drained in a single pass — it does not
+ * reclaim memory for already-shifted items, so it is not suitable for
+ * long-lived queues with many push/shift cycles.
+ */
+export class Queue<T> {
+  private readonly items: T[];
+  private head = 0;
+
+  constructor(initial: Iterable<T> = []) {
+    this.items = [...initial];
+  }
+
+  push(item: T): void {
+    this.items.push(item);
+  }
+
+  /**
+   * Remove and return the next item. Caller must check `isEmpty` first —
+   * shifting an empty queue throws.
+   */
+  shift(): T {
+    if (this.head >= this.items.length) {
+      throw new Error('Queue.shift called on empty queue');
+    }
+    // biome-ignore lint/style/noNonNullAssertion: bounds-checked on the line above
+    return this.items[this.head++]!;
+  }
+
+  get isEmpty(): boolean {
+    return this.head >= this.items.length;
+  }
+}

package/src/types.ts

@@ -5,13 +5,22 @@ export interface MigrationHints {
   readonly used: readonly string[];
   readonly applied: readonly string[];
   readonly plannerVersion: string;
-  readonly planningStrategy: string;
 }
 
 /**
- * Shared fields for all migration manifests (draft and attested).
+ * 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 MigrationManifestBase {
+export interface MigrationManifest {
+  readonly migrationId: string;
   readonly from: string;
   readonly to: string;
   readonly kind: 'regular' | 'baseline';
@@ -24,37 +33,12 @@ interface MigrationManifestBase {
   readonly createdAt: string;
 }
 
-/**
- * A draft migration that has been planned but not yet attested.
- * Draft migrations have `migrationId: null` and are excluded from
- * graph reconstruction and apply.
- */
-export interface DraftMigrationManifest extends MigrationManifestBase {
-  readonly migrationId: null;
-}
-
-/**
- * An attested migration with a content-addressed migrationId.
- * Only attested migrations participate in the migration graph.
- */
-export interface AttestedMigrationManifest extends MigrationManifestBase {
-  readonly migrationId: string;
-}
-
-/**
- * Union of draft and attested manifests. This is what the on-disk
- * format represents — `migrationId` is `null` for drafts, a string
- * for attested migrations.
- */
-export type MigrationManifest = DraftMigrationManifest | AttestedMigrationManifest;
-
 export type MigrationOps = readonly MigrationPlanOperation[];
 
 /**
  * An on-disk migration directory containing a manifest and operations.
- * The manifest may be draft or attested.
  */
-export interface BaseMigrationBundle {
+export interface MigrationBundle {
   readonly dirName: string;
   readonly dirPath: string;
   readonly manifest: MigrationManifest;
@@ -62,20 +46,8 @@ export interface BaseMigrationBundle {
 }
 
 /**
- * A bundle known to be attested (migrationId is a string).
- * Use this after filtering bundles to attested-only.
- */
-export interface AttestedMigrationBundle extends BaseMigrationBundle {
-  readonly manifest: AttestedMigrationManifest;
-}
-
-export interface DraftMigrationBundle extends BaseMigrationBundle {
-  readonly manifest: DraftMigrationManifest;
-}
-
-/**
- * An entry in the migration graph. Only attested migrations appear in the
- * graph, so `migrationId` is always a string.
+ * An entry in the migration graph. All on-disk migrations are attested,
+ * so `migrationId` is always a string.
  */
 export interface MigrationChainEntry {
   readonly from: string;
@@ -92,15 +64,3 @@ export interface MigrationGraph {
   readonly reverseChain: ReadonlyMap<string, readonly MigrationChainEntry[]>;
   readonly migrationById: ReadonlyMap<string, MigrationChainEntry>;
 }
-
-/**
- * Type guard that narrows a MigrationBundle to an AttestedMigrationBundle.
- * Use with `.filter(isAttested)` to get a typed array of attested bundles.
- */
-export function isAttested(bundle: BaseMigrationBundle): bundle is AttestedMigrationBundle {
-  return typeof bundle.manifest.migrationId === 'string';
-}
-
-export function isDraft(bundle: BaseMigrationBundle): bundle is DraftMigrationBundle {
-  return bundle.manifest.migrationId === null;
-}

package/dist/attestation-DnebS4XZ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"attestation-DnebS4XZ.mjs","names":["sorted: Record<string, unknown>"],"sources":["../src/canonicalize-json.ts","../src/attestation.ts"],"sourcesContent":["function sortKeys(value: unknown): unknown {\n  if (value === null || typeof value !== 'object') {\n    return value;\n  }\n  if (Array.isArray(value)) {\n    return value.map(sortKeys);\n  }\n  const sorted: Record<string, unknown> = {};\n  for (const key of Object.keys(value).sort()) {\n    sorted[key] = sortKeys((value as Record<string, unknown>)[key]);\n  }\n  return sorted;\n}\n\nexport function canonicalizeJson(value: unknown): string {\n  return JSON.stringify(sortKeys(value));\n}\n","import { createHash } from 'node:crypto';\nimport { canonicalizeJson } from './canonicalize-json';\nimport { readMigrationPackage, writeMigrationManifest } from './io';\nimport type { MigrationManifest, MigrationOps } from './types';\n\nexport interface VerifyResult {\n  readonly ok: boolean;\n  readonly reason?: 'draft' | 'mismatch';\n  readonly storedMigrationId?: string;\n  readonly computedMigrationId?: string;\n}\n\nfunction sha256Hex(input: string): string {\n  return createHash('sha256').update(input).digest('hex');\n}\n\n/**\n * Content-addressed migration identity over (manifest envelope sans\n * contracts/hints, ops). See ADR 199 \"Storage-only migration identity\"\n * for the rationale: contracts are anchored separately by the\n * storage-hash bookends inside the envelope; planner hints are advisory\n * and must not affect identity.\n */\nexport function computeMigrationId(manifest: MigrationManifest, ops: MigrationOps): string {\n  const {\n    migrationId: _migrationId,\n    signature: _signature,\n    fromContract: _fromContract,\n    toContract: _toContract,\n    hints: _hints,\n    ...strippedMeta\n  } = manifest;\n\n  const canonicalManifest = canonicalizeJson(strippedMeta);\n  const canonicalOps = canonicalizeJson(ops);\n\n  const partHashes = [canonicalManifest, canonicalOps].map(sha256Hex);\n  const hash = sha256Hex(canonicalizeJson(partHashes));\n\n  return `sha256:${hash}`;\n}\n\n/** Compute and persist `migrationId` to `manifest.json`. */\nexport async function attestMigration(dir: string): Promise<string> {\n  const pkg = await readMigrationPackage(dir);\n  const migrationId = computeMigrationId(pkg.manifest, pkg.ops);\n\n  const updated = { ...pkg.manifest, migrationId };\n  await writeMigrationManifest(dir, updated);\n\n  return migrationId;\n}\n\nexport async function verifyMigration(dir: string): Promise<VerifyResult> {\n  const pkg = await readMigrationPackage(dir);\n\n  if (pkg.manifest.migrationId === null) {\n    return { ok: false, reason: 'draft' };\n  }\n\n  const computed = computeMigrationId(pkg.manifest, pkg.ops);\n\n  if (pkg.manifest.migrationId === computed) {\n    return { ok: true, storedMigrationId: pkg.manifest.migrationId, computedMigrationId: computed };\n  }\n\n  return {\n    ok: false,\n    reason: 'mismatch',\n    storedMigrationId: pkg.manifest.migrationId,\n    computedMigrationId: computed,\n  };\n}\n"],"mappings":";;;;AAAA,SAAS,SAAS,OAAyB;AACzC,KAAI,UAAU,QAAQ,OAAO,UAAU,SACrC,QAAO;AAET,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,IAAI,SAAS;CAE5B,MAAMA,SAAkC,EAAE;AAC1C,MAAK,MAAM,OAAO,OAAO,KAAK,MAAM,CAAC,MAAM,CACzC,QAAO,OAAO,SAAU,MAAkC,KAAK;AAEjE,QAAO;;AAGT,SAAgB,iBAAiB,OAAwB;AACvD,QAAO,KAAK,UAAU,SAAS,MAAM,CAAC;;;;;ACHxC,SAAS,UAAU,OAAuB;AACxC,QAAO,WAAW,SAAS,CAAC,OAAO,MAAM,CAAC,OAAO,MAAM;;;;;;;;;AAUzD,SAAgB,mBAAmB,UAA6B,KAA2B;CACzF,MAAM,EACJ,aAAa,cACb,WAAW,YACX,cAAc,eACd,YAAY,aACZ,OAAO,QACP,GAAG,iBACD;AAQJ,QAAO,UAFM,UAAU,iBADJ,CAHO,iBAAiB,aAAa,EACnC,iBAAiB,IAAI,CAEU,CAAC,IAAI,UAAU,CAChB,CAAC;;;AAMtD,eAAsB,gBAAgB,KAA8B;CAClE,MAAM,MAAM,MAAM,qBAAqB,IAAI;CAC3C,MAAM,cAAc,mBAAmB,IAAI,UAAU,IAAI,IAAI;AAG7D,OAAM,uBAAuB,KADb;EAAE,GAAG,IAAI;EAAU;EAAa,CACN;AAE1C,QAAO;;AAGT,eAAsB,gBAAgB,KAAoC;CACxE,MAAM,MAAM,MAAM,qBAAqB,IAAI;AAE3C,KAAI,IAAI,SAAS,gBAAgB,KAC/B,QAAO;EAAE,IAAI;EAAO,QAAQ;EAAS;CAGvC,MAAM,WAAW,mBAAmB,IAAI,UAAU,IAAI,IAAI;AAE1D,KAAI,IAAI,SAAS,gBAAgB,SAC/B,QAAO;EAAE,IAAI;EAAM,mBAAmB,IAAI,SAAS;EAAa,qBAAqB;EAAU;AAGjG,QAAO;EACL,IAAI;EACJ,QAAQ;EACR,mBAAmB,IAAI,SAAS;EAChC,qBAAqB;EACtB"}

package/dist/errors-C_XuSbX7.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-C_XuSbX7.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Structured error for migration tooling operations.\n *\n * Follows the NAMESPACE.SUBCODE convention from ADR 027. All codes live under\n * the MIGRATION namespace. These are tooling-time errors (file I/O, attestation,\n * migration history reconstruction), distinct from the runtime MIGRATION.* codes for apply-time\n * failures (PRECHECK_FAILED, POSTCHECK_FAILED, etc.).\n *\n * Fields:\n * - code:     Stable machine-readable code (MIGRATION.SUBCODE)\n * - category: Always 'MIGRATION'\n * - why:      Explains the cause in plain language\n * - fix:      Actionable remediation step\n * - details:  Machine-readable structured data for agents\n */\nexport class MigrationToolsError extends Error {\n  readonly code: string;\n  readonly category = 'MIGRATION' as const;\n  readonly why: string;\n  readonly fix: string;\n  readonly details: Record<string, unknown> | undefined;\n\n  constructor(\n    code: string,\n    summary: string,\n    options: {\n      readonly why: string;\n      readonly fix: string;\n      readonly details?: Record<string, unknown>;\n    },\n  ) {\n    super(summary);\n    this.name = 'MigrationToolsError';\n    this.code = code;\n    this.why = options.why;\n    this.fix = options.fix;\n    this.details = options.details;\n  }\n\n  static is(error: unknown): error is MigrationToolsError {\n    if (!(error instanceof Error)) return false;\n    const candidate = error as MigrationToolsError;\n    return candidate.name === 'MigrationToolsError' && typeof candidate.code === 'string';\n  }\n}\n\nexport function errorDirectoryExists(dir: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.DIR_EXISTS', 'Migration directory already exists', {\n    why: `The directory \"${dir}\" already exists. Each migration must have a unique directory.`,\n    fix: 'Use --name to pick a different name, or delete the existing directory and re-run.',\n    details: { dir },\n  });\n}\n\nexport function errorMissingFile(file: string, dir: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.FILE_MISSING', `Missing ${file}`, {\n    why: `Expected \"${file}\" in \"${dir}\" but the file does not exist.`,\n    fix: 'Ensure the migration directory contains both migration.json and ops.json. If the directory is corrupt, delete it and re-run migration plan.',\n    details: { file, dir },\n  });\n}\n\nexport function errorInvalidJson(filePath: string, parseError: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_JSON', 'Invalid JSON in migration file', {\n    why: `Failed to parse \"${filePath}\": ${parseError}`,\n    fix: 'Fix the JSON syntax error, or delete the migration directory and re-run migration plan.',\n    details: { filePath, parseError },\n  });\n}\n\nexport function errorInvalidManifest(filePath: string, reason: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_MANIFEST', 'Invalid migration manifest', {\n    why: `Manifest at \"${filePath}\" is invalid: ${reason}`,\n    fix: 'Ensure the manifest has all required fields (from, to, kind, toContract). If corrupt, delete and re-plan.',\n    details: { filePath, reason },\n  });\n}\n\nexport function errorInvalidSlug(slug: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_NAME', 'Invalid migration name', {\n    why: `The slug \"${slug}\" contains no valid characters after sanitization (only a-z, 0-9 are kept).`,\n    fix: 'Provide a name with at least one alphanumeric character, e.g. --name add_users.',\n    details: { slug },\n  });\n}\n\nexport function errorSameSourceAndTarget(dirName: string, hash: string): MigrationToolsError {\n  return new MigrationToolsError(\n    'MIGRATION.SAME_SOURCE_AND_TARGET',\n    'Migration has same source and target',\n    {\n      why: `Migration \"${dirName}\" has from === to === \"${hash}\". A migration must transition between two different contract states.`,\n      fix: 'Delete the invalid migration directory and re-run migration plan.',\n      details: { dirName, hash },\n    },\n  );\n}\n\nexport function errorAmbiguousTarget(\n  branchTips: readonly string[],\n  context?: {\n    divergencePoint: string;\n    branches: readonly {\n      tip: string;\n      edges: readonly { dirName: string; from: string; to: string }[];\n    }[];\n  },\n): MigrationToolsError {\n  const divergenceInfo = context\n    ? `\\nDivergence point: ${context.divergencePoint}\\nBranches:\\n${context.branches.map((b) => `  → ${b.tip} (${b.edges.length} edge(s): ${b.edges.map((e) => e.dirName).join(' → ') || 'direct'})`).join('\\n')}`\n    : '';\n  return new MigrationToolsError('MIGRATION.AMBIGUOUS_TARGET', 'Ambiguous migration target', {\n    why: `The migration history has diverged into multiple branches: ${branchTips.join(', ')}. This typically happens when two developers plan migrations from the same starting point.${divergenceInfo}`,\n    fix: 'Use `migration ref set <name> <hash>` to target a specific branch, delete one of the conflicting migration directories and re-run `migration plan`, or use --from <hash> to explicitly select a starting point.',\n    details: {\n      branchTips,\n      ...(context ? { divergencePoint: context.divergencePoint, branches: context.branches } : {}),\n    },\n  });\n}\n\nexport function errorNoInitialMigration(nodes: readonly string[]): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.NO_INITIAL_MIGRATION', 'No initial migration found', {\n    why: `No migration starts from the empty contract state (known hashes: ${nodes.join(', ')}). At least one migration must originate from the empty state.`,\n    fix: 'Inspect the migrations directory for corrupted migration.json files. At least one migration must start from the empty contract hash.',\n    details: { nodes },\n  });\n}\n\nexport function errorInvalidRefs(refsPath: string, reason: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_REFS', 'Invalid refs.json', {\n    why: `refs.json at \"${refsPath}\" is invalid: ${reason}`,\n    fix: 'Ensure refs.json is a flat object mapping valid ref names to contract hash strings.',\n    details: { path: refsPath, reason },\n  });\n}\n\nexport function errorInvalidRefFile(filePath: string, reason: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_REF_FILE', 'Invalid ref file', {\n    why: `Ref file at \"${filePath}\" is invalid: ${reason}`,\n    fix: 'Ensure the ref file contains valid JSON with { \"hash\": \"sha256:<64 hex chars>\", \"invariants\": [\"...\"] }.',\n    details: { path: filePath, reason },\n  });\n}\n\nexport function errorInvalidRefName(refName: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_REF_NAME', 'Invalid ref name', {\n    why: `Ref name \"${refName}\" is invalid. Names must be lowercase alphanumeric with hyphens or forward slashes (no \".\" or \"..\" segments).`,\n    fix: `Use a valid ref name (e.g., \"staging\", \"envs/production\").`,\n    details: { refName },\n  });\n}\n\nexport function errorNoTarget(reachableHashes: readonly string[]): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.NO_TARGET', 'No migration target could be resolved', {\n    why: `The migration history contains cycles and no target can be resolved automatically (reachable hashes: ${reachableHashes.join(', ')}). This typically happens after rollback migrations (e.g., C1→C2→C1).`,\n    fix: 'Use --from <hash> to specify the planning origin explicitly.',\n    details: { reachableHashes },\n  });\n}\n\nexport function errorInvalidRefValue(value: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_REF_VALUE', 'Invalid ref value', {\n    why: `Ref value \"${value}\" is not a valid contract hash. Values must be in the format \"sha256:<64 hex chars>\" or \"sha256:empty\".`,\n    fix: 'Use a valid storage hash from `prisma-next contract emit` output or an existing migration.',\n    details: { value },\n  });\n}\n\nexport function errorDuplicateMigrationId(migrationId: string): MigrationToolsError {\n  return new MigrationToolsError(\n    'MIGRATION.DUPLICATE_MIGRATION_ID',\n    'Duplicate migrationId in migration graph',\n    {\n      why: `Multiple migrations share migrationId \"${migrationId}\". Each migration must have a unique content-addressed identity.`,\n      fix: 'Regenerate one of the conflicting migrations so each migrationId is unique, then re-run migration commands.',\n      details: { migrationId },\n    },\n  );\n}\n"],"mappings":"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"}

package/dist/exports/types.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.mjs","names":[],"sources":["../../src/types.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { MigrationPlanOperation } from '@prisma-next/framework-components/control';\n\nexport interface MigrationHints {\n  readonly used: readonly string[];\n  readonly applied: readonly string[];\n  readonly plannerVersion: string;\n  readonly planningStrategy: string;\n}\n\n/**\n * Shared fields for all migration manifests (draft and attested).\n */\ninterface MigrationManifestBase {\n  readonly from: string;\n  readonly to: string;\n  readonly kind: 'regular' | 'baseline';\n  readonly fromContract: Contract | null;\n  readonly toContract: Contract;\n  readonly hints: MigrationHints;\n  readonly labels: readonly string[];\n  readonly authorship?: { readonly author?: string; readonly email?: string };\n  readonly signature?: { readonly keyId: string; readonly value: string } | null;\n  readonly createdAt: string;\n}\n\n/**\n * A draft migration that has been planned but not yet attested.\n * Draft migrations have `migrationId: null` and are excluded from\n * graph reconstruction and apply.\n */\nexport interface DraftMigrationManifest extends MigrationManifestBase {\n  readonly migrationId: null;\n}\n\n/**\n * An attested migration with a content-addressed migrationId.\n * Only attested migrations participate in the migration graph.\n */\nexport interface AttestedMigrationManifest extends MigrationManifestBase {\n  readonly migrationId: string;\n}\n\n/**\n * Union of draft and attested manifests. This is what the on-disk\n * format represents — `migrationId` is `null` for drafts, a string\n * for attested migrations.\n */\nexport type MigrationManifest = DraftMigrationManifest | AttestedMigrationManifest;\n\nexport type MigrationOps = readonly MigrationPlanOperation[];\n\n/**\n * An on-disk migration directory containing a manifest and operations.\n * The manifest may be draft or attested.\n */\nexport interface BaseMigrationBundle {\n  readonly dirName: string;\n  readonly dirPath: string;\n  readonly manifest: MigrationManifest;\n  readonly ops: MigrationOps;\n}\n\n/**\n * A bundle known to be attested (migrationId is a string).\n * Use this after filtering bundles to attested-only.\n */\nexport interface AttestedMigrationBundle extends BaseMigrationBundle {\n  readonly manifest: AttestedMigrationManifest;\n}\n\nexport interface DraftMigrationBundle extends BaseMigrationBundle {\n  readonly manifest: DraftMigrationManifest;\n}\n\n/**\n * An entry in the migration graph. Only attested migrations appear in the\n * graph, so `migrationId` is always a string.\n */\nexport interface MigrationChainEntry {\n  readonly from: string;\n  readonly to: string;\n  readonly migrationId: string;\n  readonly dirName: string;\n  readonly createdAt: string;\n  readonly labels: readonly string[];\n}\n\nexport interface MigrationGraph {\n  readonly nodes: ReadonlySet<string>;\n  readonly forwardChain: ReadonlyMap<string, readonly MigrationChainEntry[]>;\n  readonly reverseChain: ReadonlyMap<string, readonly MigrationChainEntry[]>;\n  readonly migrationById: ReadonlyMap<string, MigrationChainEntry>;\n}\n\n/**\n * Type guard that narrows a MigrationBundle to an AttestedMigrationBundle.\n * Use with `.filter(isAttested)` to get a typed array of attested bundles.\n */\nexport function isAttested(bundle: BaseMigrationBundle): bundle is AttestedMigrationBundle {\n  return typeof bundle.manifest.migrationId === 'string';\n}\n\nexport function isDraft(bundle: BaseMigrationBundle): bundle is DraftMigrationBundle {\n  return bundle.manifest.migrationId === null;\n}\n"],"mappings":";;;;;;;AAmGA,SAAgB,WAAW,QAAgE;AACzF,QAAO,OAAO,OAAO,SAAS,gBAAgB;;AAGhD,SAAgB,QAAQ,QAA6D;AACnF,QAAO,OAAO,SAAS,gBAAgB"}

package/dist/io-Cun81AIZ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"io-Cun81AIZ.mjs","names":["manifestRaw: string","opsRaw: string","manifest: MigrationManifest","ops: MigrationOps","entries: string[]","packages: BaseMigrationBundle[]"],"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  errorInvalidJson,\n  errorInvalidManifest,\n  errorInvalidSlug,\n  errorMissingFile,\n} from './errors';\nimport type { BaseMigrationBundle, 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  planningStrategy: 'string',\n});\n\nconst MigrationManifestSchema = type({\n  from: 'string',\n  to: 'string',\n  migrationId: 'string | null',\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 the destination contract artifacts (`contract.json` and the\n * colocated `contract.d.ts`) into the migration package directory so\n * authors of the scaffolded `migration.ts` can import the typed\n * contract relative to the migration directory\n * (`import type { Contract } from './contract'`).\n *\n * A missing `.d.ts` is tolerated (only the `.json` is required) so the\n * helper stays usable in tests that hand-roll a bare `contract.json`.\n * A missing `contract.json` — or any other I/O failure — throws.\n */\nexport async function copyContractToMigrationDir(\n  packageDir: string,\n  contractJsonPath: string,\n): Promise<void> {\n  await copyFile(contractJsonPath, join(packageDir, 'contract.json'));\n  const dtsPath = `${contractJsonPath.slice(0, -'.json'.length)}.d.ts`;\n  try {\n    await copyFile(dtsPath, join(packageDir, 'contract.d.ts'));\n  } catch (error) {\n    if (hasErrnoCode(error, 'ENOENT')) return;\n    throw error;\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<BaseMigrationBundle> {\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 BaseMigrationBundle[]> {\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: BaseMigrationBundle[] = [];\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-D2uX4ql7.d.mts

@@ -1,100 +0,0 @@
-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;
-  readonly planningStrategy: string;
-}
-/**
- * Shared fields for all migration manifests (draft and attested).
- */
-interface MigrationManifestBase {
-  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;
-}
-/**
- * A draft migration that has been planned but not yet attested.
- * Draft migrations have `migrationId: null` and are excluded from
- * graph reconstruction and apply.
- */
-interface DraftMigrationManifest extends MigrationManifestBase {
-  readonly migrationId: null;
-}
-/**
- * An attested migration with a content-addressed migrationId.
- * Only attested migrations participate in the migration graph.
- */
-interface AttestedMigrationManifest extends MigrationManifestBase {
-  readonly migrationId: string;
-}
-/**
- * Union of draft and attested manifests. This is what the on-disk
- * format represents — `migrationId` is `null` for drafts, a string
- * for attested migrations.
- */
-type MigrationManifest = DraftMigrationManifest | AttestedMigrationManifest;
-type MigrationOps = readonly MigrationPlanOperation[];
-/**
- * An on-disk migration directory containing a manifest and operations.
- * The manifest may be draft or attested.
- */
-interface BaseMigrationBundle {
-  readonly dirName: string;
-  readonly dirPath: string;
-  readonly manifest: MigrationManifest;
-  readonly ops: MigrationOps;
-}
-/**
- * A bundle known to be attested (migrationId is a string).
- * Use this after filtering bundles to attested-only.
- */
-interface AttestedMigrationBundle extends BaseMigrationBundle {
-  readonly manifest: AttestedMigrationManifest;
-}
-interface DraftMigrationBundle extends BaseMigrationBundle {
-  readonly manifest: DraftMigrationManifest;
-}
-/**
- * An entry in the migration graph. Only attested migrations appear in the
- * graph, 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>;
-}
-/**
- * Type guard that narrows a MigrationBundle to an AttestedMigrationBundle.
- * Use with `.filter(isAttested)` to get a typed array of attested bundles.
- */
-declare function isAttested(bundle: BaseMigrationBundle): bundle is AttestedMigrationBundle;
-declare function isDraft(bundle: BaseMigrationBundle): bundle is DraftMigrationBundle;
-//#endregion
-export { DraftMigrationManifest as a, MigrationHints as c, isAttested as d, isDraft as f, DraftMigrationBundle as i, MigrationManifest as l, AttestedMigrationManifest as n, MigrationChainEntry as o, BaseMigrationBundle as r, MigrationGraph as s, AttestedMigrationBundle as t, MigrationOps as u };
-//# sourceMappingURL=types-D2uX4ql7.d.mts.map