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

package/dist/errors-BmiSgz1j.mjs

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

package/dist/errors-BmiSgz1j.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-BmiSgz1j.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 errorInvalidDestName(destName: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_DEST_NAME', 'Invalid copy destination name', {\n    why: `The destination name \"${destName}\" must be a single path segment (no \"..\" or directory separators).`,\n    fix: 'Use a simple file name such as \"contract.json\" for each destination in the copy list.',\n    details: { destName },\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/attestation.d.mts

@@ -1,37 +0,0 @@
-import { a as MigrationManifest, o as MigrationOps, t as MigrationBundle } from "../types-DyGXcWWp.mjs";
-
-//#region src/attestation.d.ts
-interface VerifyResult {
-  readonly ok: boolean;
-  readonly reason?: 'mismatch';
-  readonly storedMigrationId?: string;
-  readonly computedMigrationId?: string;
-}
-/**
- * Content-addressed migration identity over (manifest envelope sans
- * contracts/hints, ops). See ADR 199 "Storage-only migration identity"
- * 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).
- */
-declare function computeMigrationId(manifest: Omit<MigrationManifest, 'migrationId'> & {
-  readonly migrationId?: string;
-}, ops: MigrationOps): string;
-/**
- * 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.
- */
-declare function verifyMigrationBundle(bundle: MigrationBundle): VerifyResult;
-/** Convenience wrapper: read the package from disk then verify it. */
-declare function verifyMigration(dir: string): Promise<VerifyResult>;
-//#endregion
-export { type VerifyResult, computeMigrationId, verifyMigration, verifyMigrationBundle };
-//# sourceMappingURL=attestation.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attestation.d.mts","names":[],"sources":["../../src/attestation.ts"],"sourcesContent":[],"mappings":";;;UAKiB,YAAA;;EAAA,SAAA,MAAY,CAAA,EAAA,UAAA;EAsBb,SAAA,iBAAkB,CAAA,EAAA,MAAA;EACjB,SAAA,mBAAA,CAAA,EAAA,MAAA;;;;AA6BjB;AAoBA;;;;;;;;iBAlDgB,kBAAA,WACJ,KAAK;;QACV;;;;;;;;;iBA4BS,qBAAA,SAA8B,kBAAkB;;iBAoB1C,eAAA,eAA8B,QAAQ"}

package/dist/exports/attestation.mjs

@@ -1,4 +0,0 @@
-import "../io-Cd6GLyjK.mjs";
-import { n as verifyMigration, r as verifyMigrationBundle, t as computeMigrationId } from "../attestation-BnzTb0Qp.mjs";
-
-export { computeMigrationId, verifyMigration, verifyMigrationBundle };

package/dist/exports/dag.d.mts

@@ -1,51 +0,0 @@
-import { n as MigrationChainEntry, r as MigrationGraph, t as MigrationBundle } from "../types-DyGXcWWp.mjs";
-
-//#region src/dag.d.ts
-declare function reconstructGraph(packages: readonly MigrationBundle[]): MigrationGraph;
-/**
- * Find the shortest path from `fromHash` to `toHash` using BFS over the
- * contract-hash graph. Returns the ordered list of edges, or null if no path
- * exists. Returns an empty array when `fromHash === toHash` (no-op).
- *
- * Neighbor ordering is deterministic via the tie-break sort key:
- * label priority → createdAt → to → migrationId.
- */
-declare function findPath(graph: MigrationGraph, fromHash: string, toHash: string): readonly MigrationChainEntry[] | null;
-interface PathDecision {
-  readonly selectedPath: readonly MigrationChainEntry[];
-  readonly fromHash: string;
-  readonly toHash: string;
-  readonly alternativeCount: number;
-  readonly tieBreakReasons: readonly string[];
-  readonly refName?: string;
-}
-/**
- * Find the shortest path from `fromHash` to `toHash` and return structured
- * path-decision metadata for machine-readable output.
- */
-declare function findPathWithDecision(graph: MigrationGraph, fromHash: string, toHash: string, refName?: string): PathDecision | null;
-/**
- * Find all branch tips (nodes with no outgoing edges) reachable from
- * `fromHash` via forward edges.
- */
-declare function findReachableLeaves(graph: MigrationGraph, fromHash: string): readonly string[];
-/**
- * Find the target contract hash of the migration graph reachable from
- * 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.
- */
-declare function findLeaf(graph: MigrationGraph): string | null;
-/**
- * Find the latest migration entry by traversing from EMPTY_CONTRACT_HASH
- * to the single target. Returns null for an empty graph.
- * Throws AMBIGUOUS_TARGET if the graph has multiple branch tips.
- */
-declare function findLatestMigration(graph: MigrationGraph): MigrationChainEntry | null;
-declare function detectCycles(graph: MigrationGraph): readonly string[][];
-declare function detectOrphans(graph: MigrationGraph): readonly MigrationChainEntry[];
-//#endregion
-export { type PathDecision, detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findReachableLeaves, reconstructGraph };
-//# sourceMappingURL=dag.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"dag.d.mts","names":[],"sources":["../../src/dag.ts"],"sourcesContent":[],"mappings":";;;iBAgCgB,gBAAA,oBAAoC,oBAAoB;;AAAxE;AAmFA;AAyCA;AAaA;AA8FA;AAkBA;AAwCA;AAQgB,iBAtNA,QAAA,CAsNoB,KAAA,EArN3B,cAqNyC,EAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAAA,MAAA,CAAA,EAAA,SAlNtC,mBAkNsC,EAAA,GAAA,IAAA;AA8DlC,UA3OC,YAAA,CA2OY;kCA1OK;;;;;;;;;;;iBAYlB,oBAAA,QACP,qEAIN;;;;;iBAyFa,mBAAA,QAA2B;;;;;;;;;iBAkB3B,QAAA,QAAgB;;;;;;iBAwChB,mBAAA,QAA2B,iBAAiB;iBAQ5C,YAAA,QAAoB;iBA8DpB,aAAA,QAAqB,0BAA0B"}

package/dist/exports/dag.mjs

@@ -1,386 +0,0 @@
-import { h as errorSameSourceAndTarget, i as errorDuplicateMigrationId, m as errorNoTarget, n as errorAmbiguousTarget, p as errorNoInitialMigration } from "../errors-BmiSgz1j.mjs";
-import { t as EMPTY_CONTRACT_HASH } from "../constants-BRi0X7B_.mjs";
-import { ifDefined } from "@prisma-next/utils/defined";
-
-//#region src/queue.ts
-/**
-* 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.
-*/
-var Queue = class {
-	items;
-	head = 0;
-	constructor(initial = []) {
-		this.items = [...initial];
-	}
-	push(item) {
-		this.items.push(item);
-	}
-	/**
-	* Remove and return the next item. Caller must check `isEmpty` first —
-	* shifting an empty queue throws.
-	*/
-	shift() {
-		if (this.head >= this.items.length) throw new Error("Queue.shift called on empty queue");
-		return this.items[this.head++];
-	}
-	get isEmpty() {
-		return this.head >= this.items.length;
-	}
-};
-
-//#endregion
-//#region src/graph-ops.ts
-/**
-* 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.
-*/
-function* bfs(starts, neighbours, ordering) {
-	const visited = /* @__PURE__ */ new Set();
-	const parentMap = /* @__PURE__ */ new Map();
-	const queue = new Queue();
-	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);
-		}
-	}
-}
-
-//#endregion
-//#region src/dag.ts
-/** Forward-edge neighbours for BFS: edge `e` from `n` visits `e.to` next. */
-function forwardNeighbours(graph, node) {
-	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, node) {
-	return (graph.reverseChain.get(node) ?? []).map((edge) => ({
-		next: edge.from,
-		edge
-	}));
-}
-function appendEdge(map, key, entry) {
-	const bucket = map.get(key);
-	if (bucket) bucket.push(entry);
-	else map.set(key, [entry]);
-}
-function reconstructGraph(packages) {
-	const nodes = /* @__PURE__ */ new Set();
-	const forwardChain = /* @__PURE__ */ new Map();
-	const reverseChain = /* @__PURE__ */ new Map();
-	const migrationById = /* @__PURE__ */ new Map();
-	for (const pkg of packages) {
-		const { from, to } = pkg.manifest;
-		if (from === to) throw errorSameSourceAndTarget(pkg.dirName, from);
-		nodes.add(from);
-		nodes.add(to);
-		const migration = {
-			from,
-			to,
-			migrationId: pkg.manifest.migrationId,
-			dirName: pkg.dirName,
-			createdAt: pkg.manifest.createdAt,
-			labels: pkg.manifest.labels
-		};
-		if (migrationById.has(migration.migrationId)) throw errorDuplicateMigrationId(migration.migrationId);
-		migrationById.set(migration.migrationId, migration);
-		appendEdge(forwardChain, from, migration);
-		appendEdge(reverseChain, to, migration);
-	}
-	return {
-		nodes,
-		forwardChain,
-		reverseChain,
-		migrationById
-	};
-}
-const LABEL_PRIORITY = {
-	main: 0,
-	default: 1,
-	feature: 2
-};
-function labelPriority(labels) {
-	let best = 3;
-	for (const l of labels) {
-		const p = LABEL_PRIORITY[l];
-		if (p !== void 0 && p < best) best = p;
-	}
-	return best;
-}
-function compareTieBreak(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);
-}
-function sortedNeighbors(edges) {
-	return [...edges].sort(compareTieBreak);
-}
-/** Ordering adapter for `bfs` — sorts `{next, edge}` pairs by tie-break. */
-function bfsOrdering(items) {
-	return items.slice().sort((a, b) => compareTieBreak(a.edge, b.edge));
-}
-/**
-* Find the shortest path from `fromHash` to `toHash` using BFS over the
-* contract-hash graph. Returns the ordered list of edges, or null if no path
-* exists. Returns an empty array when `fromHash === toHash` (no-op).
-*
-* Neighbor ordering is deterministic via the tie-break sort key:
-* label priority → createdAt → to → migrationId.
-*/
-function findPath(graph, fromHash, toHash) {
-	if (fromHash === toHash) return [];
-	const parents = /* @__PURE__ */ new Map();
-	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 = [];
-			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;
-		}
-	}
-	return null;
-}
-/**
-* Reverse-BFS from `toHash` over `reverseChain` to collect every node from
-* which `toHash` is reachable (inclusive of `toHash` itself).
-*/
-function collectNodesReachingTarget(graph, toHash) {
-	const reached = /* @__PURE__ */ new Set();
-	for (const step of bfs([toHash], (n) => reverseNeighbours(graph, n))) reached.add(step.node);
-	return reached;
-}
-/**
-* Find the shortest path from `fromHash` to `toHash` and return structured
-* path-decision metadata for machine-readable output.
-*/
-function findPathWithDecision(graph, fromHash, toHash, refName) {
-	if (fromHash === toHash) return {
-		selectedPath: [],
-		fromHash,
-		toHash,
-		alternativeCount: 0,
-		tieBreakReasons: [],
-		...ifDefined("refName", refName)
-	};
-	const path = findPath(graph, fromHash, toHash);
-	if (!path) return null;
-	const reachesTarget = collectNodesReachingTarget(graph, toHash);
-	const tieBreakReasons = [];
-	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) => reachesTarget.has(e.to));
-			if (reachable.length > 1) {
-				alternativeCount += reachable.length - 1;
-				const sorted = sortedNeighbors(reachable);
-				if (sorted[0] && sorted[0].migrationId === edge.migrationId) {
-					if (reachable.some((e) => e.migrationId !== edge.migrationId)) tieBreakReasons.push(`at ${edge.from}: ${reachable.length} candidates, selected by tie-break`);
-				}
-			}
-		}
-	}
-	return {
-		selectedPath: path,
-		fromHash,
-		toHash,
-		alternativeCount,
-		tieBreakReasons,
-		...ifDefined("refName", refName)
-	};
-}
-/**
-* Walk ancestors of each branch tip back to find the last node
-* that appears on all paths. Returns `fromHash` if no shared ancestor is found.
-*/
-function findDivergencePoint(graph, fromHash, leaves) {
-	const ancestorSets = leaves.map((leaf) => {
-		const ancestors = /* @__PURE__ */ new Set();
-		for (const step of bfs([leaf], (n) => reverseNeighbours(graph, n))) ancestors.add(step.node);
-		return ancestors;
-	});
-	const commonAncestors = [...ancestorSets[0] ?? []].filter((node) => ancestorSets.every((s) => s.has(node)));
-	let deepest = fromHash;
-	let deepestDepth = -1;
-	for (const ancestor of commonAncestors) {
-		const path = findPath(graph, fromHash, ancestor);
-		const depth = path ? path.length : 0;
-		if (depth > deepestDepth) {
-			deepestDepth = depth;
-			deepest = ancestor;
-		}
-	}
-	return deepest;
-}
-/**
-* Find all branch tips (nodes with no outgoing edges) reachable from
-* `fromHash` via forward edges.
-*/
-function findReachableLeaves(graph, fromHash) {
-	const leaves = [];
-	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. 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.
-*/
-function findLeaf(graph) {
-	if (graph.nodes.size === 0) return null;
-	if (!graph.nodes.has(EMPTY_CONTRACT_HASH)) throw errorNoInitialMigration([...graph.nodes]);
-	const leaves = findReachableLeaves(graph, EMPTY_CONTRACT_HASH);
-	if (leaves.length === 0) {
-		const reachable = [...graph.nodes].filter((n) => n !== EMPTY_CONTRACT_HASH);
-		if (reachable.length > 0) throw errorNoTarget(reachable);
-		return null;
-	}
-	if (leaves.length > 1) {
-		const divergencePoint = findDivergencePoint(graph, EMPTY_CONTRACT_HASH, leaves);
-		throw errorAmbiguousTarget(leaves, {
-			divergencePoint,
-			branches: leaves.map((tip) => {
-				return {
-					tip,
-					edges: (findPath(graph, divergencePoint, tip) ?? []).map((e) => ({
-						dirName: e.dirName,
-						from: e.from,
-						to: e.to
-					}))
-				};
-			})
-		});
-	}
-	return leaves[0];
-}
-/**
-* Find the latest migration entry by traversing from EMPTY_CONTRACT_HASH
-* to the single target. Returns null for an empty graph.
-* Throws AMBIGUOUS_TARGET if the graph has multiple branch tips.
-*/
-function findLatestMigration(graph) {
-	const leafHash = findLeaf(graph);
-	if (leafHash === null) return null;
-	return findPath(graph, EMPTY_CONTRACT_HASH, leafHash)?.at(-1) ?? null;
-}
-function detectCycles(graph) {
-	const WHITE = 0;
-	const GRAY = 1;
-	const BLACK = 2;
-	const color = /* @__PURE__ */ new Map();
-	const parentMap = /* @__PURE__ */ new Map();
-	const cycles = [];
-	for (const node of graph.nodes) color.set(node, WHITE);
-	const stack = [];
-	function pushFrame(u) {
-		color.set(u, GRAY);
-		stack.push({
-			node: u,
-			outgoing: graph.forwardChain.get(u) ?? [],
-			index: 0
-		});
-	}
-	for (const root of graph.nodes) {
-		if (color.get(root) !== WHITE) continue;
-		parentMap.set(root, null);
-		pushFrame(root);
-		while (stack.length > 0) {
-			const frame = stack[stack.length - 1];
-			if (frame.index >= frame.outgoing.length) {
-				color.set(frame.node, BLACK);
-				stack.pop();
-				continue;
-			}
-			const v = frame.outgoing[frame.index++].to;
-			const vColor = color.get(v);
-			if (vColor === GRAY) {
-				const cycle = [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);
-			}
-		}
-	}
-	return cycles;
-}
-function detectOrphans(graph) {
-	if (graph.nodes.size === 0) return [];
-	const reachable = /* @__PURE__ */ new Set();
-	const startNodes = [];
-	if (graph.forwardChain.has(EMPTY_CONTRACT_HASH)) startNodes.push(EMPTY_CONTRACT_HASH);
-	else {
-		const allTargets = /* @__PURE__ */ new Set();
-		for (const edges of graph.forwardChain.values()) for (const edge of edges) allTargets.add(edge.to);
-		for (const node of graph.nodes) if (!allTargets.has(node)) startNodes.push(node);
-	}
-	for (const step of bfs(startNodes, (n) => forwardNeighbours(graph, n))) reachable.add(step.node);
-	const orphans = [];
-	for (const [from, migrations] of graph.forwardChain) if (!reachable.has(from)) orphans.push(...migrations);
-	return orphans;
-}
-
-//#endregion
-export { detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findReachableLeaves, reconstructGraph };
-//# sourceMappingURL=dag.mjs.map