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

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.4.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.4.1",
+    "@prisma-next/framework-components": "0.4.1",
+    "@prisma-next/utils": "0.4.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);
+}

package/src/dag.ts

@@ -7,9 +7,30 @@ import {
   errorNoTarget,
   errorSameSourceAndTarget,
 } from './errors';
-import type { AttestedMigrationBundle, MigrationChainEntry, MigrationGraph } from './types';
+import { bfs } from './graph-ops';
+import type { MigrationBundle, MigrationChainEntry, MigrationGraph } from './types';
 
-export function reconstructGraph(packages: readonly AttestedMigrationBundle[]): MigrationGraph {
+/** Forward-edge neighbours for BFS: edge `e` from `n` visits `e.to` next. */
+function forwardNeighbours(graph: MigrationGraph, node: string) {
+  return (graph.forwardChain.get(node) ?? []).map((edge) => ({ next: edge.to, edge }));
+}
+
+/** Reverse-edge neighbours for BFS: edge `e` from `n` visits `e.from` next. */
+function reverseNeighbours(graph: MigrationGraph, node: string) {
+  return (graph.reverseChain.get(node) ?? []).map((edge) => ({ next: edge.from, edge }));
+}
+
+function appendEdge(
+  map: Map<string, MigrationChainEntry[]>,
+  key: string,
+  entry: MigrationChainEntry,
+): void {
+  const bucket = map.get(key);
+  if (bucket) bucket.push(entry);
+  else map.set(key, [entry]);
+}
+
+export function reconstructGraph(packages: readonly MigrationBundle[]): MigrationGraph {
   const nodes = new Set<string>();
   const forwardChain = new Map<string, MigrationChainEntry[]>();
   const reverseChain = new Map<string, MigrationChainEntry[]>();
@@ -34,31 +55,24 @@ export function reconstructGraph(packages: readonly AttestedMigrationBundle[]):
       labels: pkg.manifest.labels,
     };
 
-    if (migration.migrationId !== null) {
-      if (migrationById.has(migration.migrationId)) {
-        throw errorDuplicateMigrationId(migration.migrationId);
-      }
-      migrationById.set(migration.migrationId, migration);
-    }
-
-    const fwd = forwardChain.get(from);
-    if (fwd) {
-      fwd.push(migration);
-    } else {
-      forwardChain.set(from, [migration]);
+    if (migrationById.has(migration.migrationId)) {
+      throw errorDuplicateMigrationId(migration.migrationId);
     }
+    migrationById.set(migration.migrationId, migration);
 
-    const rev = reverseChain.get(to);
-    if (rev) {
-      rev.push(migration);
-    } else {
-      reverseChain.set(to, [migration]);
-    }
+    appendEdge(forwardChain, from, migration);
+    appendEdge(reverseChain, to, migration);
   }
 
   return { nodes, forwardChain, reverseChain, migrationById };
 }
 
+// ---------------------------------------------------------------------------
+// Deterministic tie-breaking for BFS neighbour order.
+// Used by `findPath` and `findPathWithDecision` only; not a general-purpose
+// utility. Ordering: label priority → createdAt → to → migrationId.
+// ---------------------------------------------------------------------------
+
 const LABEL_PRIORITY: Record<string, number> = { main: 0, default: 1, feature: 2 };
 
 function labelPriority(labels: readonly string[]): number {
@@ -70,16 +84,25 @@ function labelPriority(labels: readonly string[]): number {
   return best;
 }
 
+function compareTieBreak(a: MigrationChainEntry, b: MigrationChainEntry): number {
+  const lp = labelPriority(a.labels) - labelPriority(b.labels);
+  if (lp !== 0) return lp;
+  const ca = a.createdAt.localeCompare(b.createdAt);
+  if (ca !== 0) return ca;
+  const tc = a.to.localeCompare(b.to);
+  if (tc !== 0) return tc;
+  return a.migrationId.localeCompare(b.migrationId);
+}
+
 function sortedNeighbors(edges: readonly MigrationChainEntry[]): readonly MigrationChainEntry[] {
-  return [...edges].sort((a, b) => {
-    const lp = labelPriority(a.labels) - labelPriority(b.labels);
-    if (lp !== 0) return lp;
-    const ca = a.createdAt.localeCompare(b.createdAt);
-    if (ca !== 0) return ca;
-    const tc = a.to.localeCompare(b.to);
-    if (tc !== 0) return tc;
-    return (a.migrationId ?? '').localeCompare(b.migrationId ?? '');
-  });
+  return [...edges].sort(compareTieBreak);
+}
+
+/** Ordering adapter for `bfs` — sorts `{next, edge}` pairs by tie-break. */
+function bfsOrdering(
+  items: readonly { next: string; edge: MigrationChainEntry }[],
+): readonly { next: string; edge: MigrationChainEntry }[] {
+  return items.slice().sort((a, b) => compareTieBreak(a.edge, b.edge));
 }
 
 /**
@@ -97,44 +120,40 @@ export function findPath(
 ): readonly MigrationChainEntry[] | null {
   if (fromHash === toHash) return [];
 
-  const visited = new Set<string>();
-  const parent = new Map<string, { node: string; edge: MigrationChainEntry }>();
-  const queue: string[] = [fromHash];
-  visited.add(fromHash);
-
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (current === undefined) break;
-
-    if (current === toHash) {
+  const parents = new Map<string, { parent: string; edge: MigrationChainEntry }>();
+  for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n), bfsOrdering)) {
+    if (step.parent !== null && step.incomingEdge !== null) {
+      parents.set(step.node, { parent: step.parent, edge: step.incomingEdge });
+    }
+    if (step.node === toHash) {
       const path: MigrationChainEntry[] = [];
-      let node = toHash;
-      let entry = parent.get(node);
-      while (entry) {
-        const { node: prev, edge } = entry;
-        path.push(edge);
-        node = prev;
-        entry = parent.get(node);
+      let cur = toHash;
+      let p = parents.get(cur);
+      while (p) {
+        path.push(p.edge);
+        cur = p.parent;
+        p = parents.get(cur);
       }
       path.reverse();
       return path;
     }
-
-    const outgoing = graph.forwardChain.get(current);
-    if (!outgoing) continue;
-
-    for (const edge of sortedNeighbors(outgoing)) {
-      if (!visited.has(edge.to)) {
-        visited.add(edge.to);
-        parent.set(edge.to, { node: current, edge });
-        queue.push(edge.to);
-      }
-    }
   }
 
   return null;
 }
 
+/**
+ * Reverse-BFS from `toHash` over `reverseChain` to collect every node from
+ * which `toHash` is reachable (inclusive of `toHash` itself).
+ */
+function collectNodesReachingTarget(graph: MigrationGraph, toHash: string): Set<string> {
+  const reached = new Set<string>();
+  for (const step of bfs([toHash], (n) => reverseNeighbours(graph, n))) {
+    reached.add(step.node);
+  }
+  return reached;
+}
+
 export interface PathDecision {
   readonly selectedPath: readonly MigrationChainEntry[];
   readonly fromHash: string;
@@ -168,16 +187,18 @@ export function findPathWithDecision(
   const path = findPath(graph, fromHash, toHash);
   if (!path) return null;
 
+  // Single reverse BFS marks every node from which `toHash` is reachable.
+  // Replaces a per-edge `findPath(e.to, toHash)` call inside the loop below,
+  // which made the whole function O(|path| · (V + E)) instead of O(V + E).
+  const reachesTarget = collectNodesReachingTarget(graph, toHash);
+
   const tieBreakReasons: string[] = [];
   let alternativeCount = 0;
 
   for (const edge of path) {
     const outgoing = graph.forwardChain.get(edge.from);
     if (outgoing && outgoing.length > 1) {
-      const reachable = outgoing.filter((e) => {
-        const pathFromE = findPath(graph, e.to, toHash);
-        return pathFromE !== null || e.to === toHash;
-      });
+      const reachable = outgoing.filter((e) => reachesTarget.has(e.to));
       if (reachable.length > 1) {
         alternativeCount += reachable.length - 1;
         const sorted = sortedNeighbors(reachable);
@@ -213,17 +234,8 @@ function findDivergencePoint(
 ): string {
   const ancestorSets = leaves.map((leaf) => {
     const ancestors = new Set<string>();
-    const queue = [leaf];
-    while (queue.length > 0) {
-      const current = queue.shift() as string;
-      if (ancestors.has(current)) continue;
-      ancestors.add(current);
-      const incoming = graph.reverseChain.get(current);
-      if (incoming) {
-        for (const edge of incoming) {
-          queue.push(edge.from);
-        }
-      }
+    for (const step of bfs([leaf], (n) => reverseNeighbours(graph, n))) {
+      ancestors.add(step.node);
     }
     return ancestors;
   });
@@ -250,40 +262,26 @@ function findDivergencePoint(
  * `fromHash` via forward edges.
  */
 export function findReachableLeaves(graph: MigrationGraph, fromHash: string): readonly string[] {
-  const visited = new Set<string>();
-  const queue: string[] = [fromHash];
-  visited.add(fromHash);
   const leaves: string[] = [];
-
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (current === undefined) break;
-    const outgoing = graph.forwardChain.get(current);
-
-    if (!outgoing || outgoing.length === 0) {
-      leaves.push(current);
-    } else {
-      for (const edge of outgoing) {
-        if (!visited.has(edge.to)) {
-          visited.add(edge.to);
-          queue.push(edge.to);
-        }
-      }
+  for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n))) {
+    if (!graph.forwardChain.get(step.node)?.length) {
+      leaves.push(step.node);
     }
   }
-
   return leaves;
 }
 
 /**
  * Find the target contract hash of the migration graph reachable from
- * EMPTY_CONTRACT_HASH. Throws NO_INITIAL_MIGRATION if the graph has
- * nodes but none originate from the empty hash.
- * Throws AMBIGUOUS_TARGET if multiple branch tips exist.
+ * EMPTY_CONTRACT_HASH. Returns `null` for a graph that has no target
+ * state (either empty, or containing only the root with no outgoing
+ * edges). Throws NO_INITIAL_MIGRATION if the graph has nodes but none
+ * originate from the empty hash, and AMBIGUOUS_TARGET if multiple
+ * branch tips exist.
  */
-export function findLeaf(graph: MigrationGraph): string {
+export function findLeaf(graph: MigrationGraph): string | null {
   if (graph.nodes.size === 0) {
-    return EMPTY_CONTRACT_HASH;
+    return null;
   }
 
   if (!graph.nodes.has(EMPTY_CONTRACT_HASH)) {
@@ -297,7 +295,7 @@ export function findLeaf(graph: MigrationGraph): string {
     if (reachable.length > 0) {
       throw errorNoTarget(reachable);
     }
-    return EMPTY_CONTRACT_HASH;
+    return null;
   }
 
   if (leaves.length > 1) {
@@ -312,8 +310,8 @@ export function findLeaf(graph: MigrationGraph): string {
     throw errorAmbiguousTarget(leaves, { divergencePoint, branches });
   }
 
-  const leaf = leaves[0];
-  return leaf !== undefined ? leaf : EMPTY_CONTRACT_HASH;
+  // biome-ignore lint/style/noNonNullAssertion: leaves.length is neither 0 nor >1 per the branches above, so exactly one leaf remains
+  return leaves[0]!;
 }
 
 /**
@@ -322,21 +320,11 @@ export function findLeaf(graph: MigrationGraph): string {
  * Throws AMBIGUOUS_TARGET if the graph has multiple branch tips.
  */
 export function findLatestMigration(graph: MigrationGraph): MigrationChainEntry | null {
-  if (graph.nodes.size === 0) {
-    return null;
-  }
-
   const leafHash = findLeaf(graph);
-  if (leafHash === EMPTY_CONTRACT_HASH) {
-    return null;
-  }
+  if (leafHash === null) return null;
 
   const path = findPath(graph, EMPTY_CONTRACT_HASH, leafHash);
-  if (!path || path.length === 0) {
-    return null;
-  }
-
-  return path[path.length - 1] ?? null;
+  return path?.at(-1) ?? null;
 }
 
 export function detectCycles(graph: MigrationGraph): readonly string[][] {
@@ -352,37 +340,50 @@ export function detectCycles(graph: MigrationGraph): readonly string[][] {
     color.set(node, WHITE);
   }
 
-  function dfs(u: string): void {
+  // Iterative three-color DFS. A frame is (node, outgoing edges, next-index).
+  interface Frame {
+    node: string;
+    outgoing: readonly MigrationChainEntry[];
+    index: number;
+  }
+  const stack: Frame[] = [];
+
+  function pushFrame(u: string): void {
     color.set(u, GRAY);
+    stack.push({ node: u, outgoing: graph.forwardChain.get(u) ?? [], index: 0 });
+  }
 
-    const outgoing = graph.forwardChain.get(u);
-    if (outgoing) {
-      for (const edge of outgoing) {
-        const v = edge.to;
-        if (color.get(v) === GRAY) {
-          const cycle: string[] = [v];
-          let cur = u;
-          while (cur !== v) {
-            cycle.push(cur);
-            cur = parentMap.get(cur) ?? v;
-          }
-          cycle.reverse();
-          cycles.push(cycle);
-        } else if (color.get(v) === WHITE) {
-          parentMap.set(v, u);
-          dfs(v);
+  for (const root of graph.nodes) {
+    if (color.get(root) !== WHITE) continue;
+    parentMap.set(root, null);
+    pushFrame(root);
+
+    while (stack.length > 0) {
+      // biome-ignore lint/style/noNonNullAssertion: stack.length > 0 should guarantee that this cannot be undefined
+      const frame = stack[stack.length - 1]!;
+      if (frame.index >= frame.outgoing.length) {
+        color.set(frame.node, BLACK);
+        stack.pop();
+        continue;
+      }
+      // biome-ignore lint/style/noNonNullAssertion: the early-continue above guarantees frame.index < frame.outgoing.length here, so this is defined
+      const edge = frame.outgoing[frame.index++]!;
+      const v = edge.to;
+      const vColor = color.get(v);
+      if (vColor === GRAY) {
+        const cycle: string[] = [v];
+        let cur = frame.node;
+        while (cur !== v) {
+          cycle.push(cur);
+          cur = parentMap.get(cur) ?? v;
         }
+        cycle.reverse();
+        cycles.push(cycle);
+      } else if (vColor === WHITE) {
+        parentMap.set(v, frame.node);
+        pushFrame(v);
       }
     }
-
-    color.set(u, BLACK);
-  }
-
-  for (const node of graph.nodes) {
-    if (color.get(node) === WHITE) {
-      parentMap.set(node, null);
-      dfs(node);
-    }
   }
 
   return cycles;
@@ -410,23 +411,8 @@ export function detectOrphans(graph: MigrationGraph): readonly MigrationChainEnt
     }
   }
 
-  const queue = [...startNodes];
-  for (const hash of queue) {
-    reachable.add(hash);
-  }
-
-  while (queue.length > 0) {
-    const node = queue.shift();
-    if (node === undefined) break;
-    const outgoing = graph.forwardChain.get(node);
-    if (!outgoing) continue;
-
-    for (const migration of outgoing) {
-      if (!reachable.has(migration.to)) {
-        reachable.add(migration.to);
-        queue.push(migration.to);
-      }
-    }
+  for (const step of bfs(startNodes, (n) => forwardNeighbours(graph, n))) {
+    reachable.add(step.node);
   }
 
   const orphans: MigrationChainEntry[] = [];

package/src/errors.ts

@@ -84,6 +84,14 @@ export function errorInvalidSlug(slug: string): MigrationToolsError {
   });
 }
 
+export function errorInvalidDestName(destName: string): MigrationToolsError {
+  return new MigrationToolsError('MIGRATION.INVALID_DEST_NAME', 'Invalid copy destination name', {
+    why: `The destination name "${destName}" must be a single path segment (no ".." or directory separators).`,
+    fix: 'Use a simple file name such as "contract.json" for each destination in the copy list.',
+    details: { destName },
+  });
+}
+
 export function errorSameSourceAndTarget(dirName: string, hash: string): MigrationToolsError {
   return new MigrationToolsError(
     'MIGRATION.SAME_SOURCE_AND_TARGET',

package/src/exports/attestation.ts

@@ -1 +1,2 @@
-export { attestMigration, computeMigrationId, verifyMigration } from '../attestation';
+export type { VerifyResult } from '../attestation';
+export { computeMigrationId, verifyMigration, verifyMigrationBundle } from '../attestation';

package/src/exports/io.ts

@@ -1,5 +1,5 @@
 export {
-  copyContractToMigrationDir,
+  copyFilesWithRename,
   formatMigrationDirName,
   readMigrationPackage,
   readMigrationsDir,

package/src/exports/migration-ts.ts

@@ -1,3 +1,3 @@
-export { evaluateMigrationTs, hasMigrationTs, writeMigrationTs } from '../migration-ts';
+export { hasMigrationTs, writeMigrationTs } from '../migration-ts';
 export type { ScaffoldRuntime } from '../runtime-detection';
 export { detectScaffoldRuntime, shebangLineFor } from '../runtime-detection';

package/src/exports/types.ts

@@ -1,16 +1,10 @@
 export { MigrationToolsError } from '../errors';
 export type {
-  AttestedMigrationBundle,
-  AttestedMigrationManifest,
-  BaseMigrationBundle,
-  BaseMigrationBundle as MigrationBundle,
-  BaseMigrationBundle as MigrationPackage,
-  DraftMigrationBundle,
-  DraftMigrationManifest,
+  MigrationBundle,
+  MigrationBundle as MigrationPackage,
   MigrationChainEntry,
   MigrationGraph,
   MigrationHints,
   MigrationManifest,
   MigrationOps,
 } from '../types';
-export { isAttested, isDraft } from '../types';