@prisma-next/migration-tools 0.5.0-dev.67 → 0.5.0-dev.68

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

@@ -1 +1 @@
-{"version":3,"file":"spaces.d.mts","names":[],"sources":["../../src/concatenate-space-apply-inputs.ts","../../src/detect-space-contract-drift.ts","../../src/emit-pinned-space-artefacts.ts","../../src/plan-all-spaces.ts","../../src/read-pinned-contract-hash.ts","../../src/space-layout.ts","../../src/verify-contract-spaces.ts"],"mappings":"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"}
+{"version":3,"file":"spaces.d.mts","names":[],"sources":["../../src/assert-descriptor-self-consistency.ts","../../src/read-contract-space-head-ref.ts","../../src/compute-extension-space-apply-path.ts","../../src/concatenate-space-apply-inputs.ts","../../src/detect-space-contract-drift.ts","../../src/emit-contract-space-artefacts.ts","../../src/verify-contract-spaces.ts","../../src/gather-disk-contract-space-state.ts","../../src/plan-all-spaces.ts","../../src/read-contract-space-contract.ts","../../src/space-layout.ts"],"mappings":"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"}

package/dist/exports/spaces.mjs

@@ -1,137 +1,115 @@
-import { S as errorPinnedArtefactsAppSpace, f as errorInvalidRefFile, g as errorInvalidSpaceId, l as errorInvalidJson, o as errorDuplicateSpaceId } from "../errors-5KVuWV_5.mjs";
+import { r as errorDescriptorHeadHashMismatch, s as errorDuplicateSpaceId } from "../errors-EPL_9p9f.mjs";
 import { r as canonicalizeJson } from "../hash-By50zM_E.mjs";
-import { t as MANIFEST_FILE } from "../io-TX8RPDeh.mjs";
+import { s as readMigrationsDir } from "../io-D13dLvUh.mjs";
+import "../constants-DWV9_o2Z.mjs";
+import { l as reconstructGraph, o as findPathWithDecision } from "../migration-graph-DGNnKDY5.mjs";
+import { a as readContractSpaceHeadRef, c as isValidSpaceId, i as detectSpaceContractDrift, l as spaceMigrationDirectory, n as listContractSpaceDirectories, o as APP_SPACE_ID, r as verifyContractSpaces, s as assertValidSpaceId, t as readContractSpaceContract } from "../read-contract-space-contract-C3-1eyaI.mjs";
 import { join } from "pathe";
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
-//#region src/space-layout.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { computeStorageHash } from "@prisma-next/contract/hashing";
+//#region src/assert-descriptor-self-consistency.ts
 /**
-* Pattern a contract-space identifier must match. The constraint is
-* filesystem-friendly: lowercase letters / digits / hyphen / underscore,
-* starts with a letter, max 64 characters.
-*
-* @see specs/framework-mechanism.spec.md § 3.
+* Assert that an extension descriptor is self-consistent: the
+* `headRef.hash` it publishes must match the canonical hash recomputed
+* from its `contractSpace.contractJson`.
+*
+* Recomputes via {@link computeStorageHash} — the same canonical-JSON
+* pipeline the descriptor's own emit pipeline produced the hash with —
+* over `(target, targetFamily, storage)`. Mismatch indicates the
+* extension author bumped `contractJson` without rerunning emit, leaving
+* the descriptor's `headRef.hash` stale; the consumer-side helpers
+* (drift detection, on-disk artefact emission, runner marker writes) all
+* trust `headRef.hash` as the canonical identity, so a stale value would
+* silently corrupt every downstream boundary.
+*
+* Synchronous, pure, no I/O. Throws
+* `MIGRATION.DESCRIPTOR_HEAD_HASH_MISMATCH` on failure with both the
+* recomputed and published hashes in `details` so callers can surface a
+* clear remediation hint without re-deriving them.
 */
-const SPACE_ID_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
-function isValidSpaceId(spaceId) {
-	return SPACE_ID_PATTERN.test(spaceId);
-}
-function assertValidSpaceId(spaceId) {
-	if (!isValidSpaceId(spaceId)) throw errorInvalidSpaceId(spaceId);
-}
-/**
-* Resolve the migrations subdirectory for a given contract space.
-*
-* - **App space** (`spaceId === APP_SPACE_ID`) keeps today's layout: the
-*   project's `migrations/` directory is the migrations directory, no
-*   subdirectory.
-* - **Extension space** lands under `<projectMigrationsDir>/<spaceId>/`.
-*   The space id is validated against {@link SPACE_ID_PATTERN} because
-*   it becomes a filesystem directory name verbatim.
-*
-* `projectMigrationsDir` is the project's top-level `migrations/`
-* directory; the helper does not assume anything about its absolute /
-* relative shape and is symmetric with `pathe.join`.
-*/
-function spaceMigrationDirectory(projectMigrationsDir, spaceId) {
-	if (spaceId === APP_SPACE_ID) return projectMigrationsDir;
-	assertValidSpaceId(spaceId);
-	return join(projectMigrationsDir, spaceId);
-}
-//#endregion
-//#region src/concatenate-space-apply-inputs.ts
-/**
-* Order a set of per-space apply inputs into the canonical cross-space
-* sequence the runner applies under a single transaction.
-*
-* Cross-space ordering convention (sub-spec § 4):
-*
-* 1. **Extension spaces first**, alphabetically by `spaceId`.
-* 2. **App space last** — only one `'app'` entry expected, at most.
-*
-* Rationale: extensions install their own structural objects (types,
-* functions, helper tables) before the app's structural ops reference
-* them. Putting app-space last lets app-space ops freely depend on any
-* extension-space declaration in the same transaction.
-*
-* Determinism (NFR6): the output order is independent of the input
-* order, so two callers with the same set of `extensionPacks` produce
-* identical apply sequences.
-*
-* Atomicity: rejects duplicate `spaceId`s with
-* `MIGRATION.DUPLICATE_SPACE_ID` before producing any output. This
-* mirrors {@link import('./plan-all-spaces').planAllSpaces} so the
-* planner-side and runner-side helpers reject malformed inputs the same
-* way (callers don't need a separate dedup pass).
-*
-* Synchronous, pure, no I/O: callers resolve marker rows and `path`
-* before invoking this helper. The actual DB application — driving the
-* transaction, committing marker writes, recording the per-space marker
-* rows — happens at the SQL-family consumption site (per the
-* helper-location convention from R3).
-*/
-function concatenateSpaceApplyInputs(inputs) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const input of inputs) {
-		if (seen.has(input.spaceId)) throw errorDuplicateSpaceId(input.spaceId);
-		seen.add(input.spaceId);
-	}
-	const extensions = [];
-	let appSpace;
-	for (const input of inputs) if (input.spaceId === APP_SPACE_ID) appSpace = input;
-	else extensions.push(input);
-	extensions.sort((a, b) => {
-		if (a.spaceId < b.spaceId) return -1;
-		if (a.spaceId > b.spaceId) return 1;
-		return 0;
+function assertDescriptorSelfConsistency(inputs) {
+	const { storageHash: _stripped, ...storageWithoutHash } = inputs.storage;
+	const recomputed = computeStorageHash({
+		target: inputs.target,
+		targetFamily: inputs.targetFamily,
+		storage: storageWithoutHash
+	});
+	if (recomputed !== inputs.headRefHash) throw errorDescriptorHeadHashMismatch({
+		extensionId: inputs.extensionId,
+		recomputedHash: recomputed,
+		headRefHash: inputs.headRefHash
 	});
-	return appSpace ? [...extensions, appSpace] : extensions;
 }
 //#endregion
-//#region src/detect-space-contract-drift.ts
+//#region src/compute-extension-space-apply-path.ts
 /**
-* Pure drift-detection primitive for a single contract space.
-*
-* Runs once per loaded extension space, just before computing the
-* `priorContract` that feeds {@link import('./plan-all-spaces').planAllSpaces}.
-* Hash equality is byte-for-byte (no normalisation) — both sides are
-* already canonical hashes produced by the same pipeline, so any
-* difference is meaningful drift.
+* Compute the apply path for an extension contract space — the shortest
+* sequence of on-disk migration packages that walks the live marker
+* forward to the on-disk head ref hash, covering every required
+* invariant.
 *
-* Synchronous, pure, no I/O. The caller (SQL family in M2 R1) reads
-* the pinned `contract.json` and computes its hash, then invokes this
-* helper alongside the descriptor's `headRef.hash`. Composes naturally
-* with {@link import('./read-pinned-contract-hash').readPinnedContractHash}
-* which provides the read-side primitive.
+* Reads only on-disk artefacts (`migrations/<spaceId>/refs/head.json`
+* and the per-space migration packages). **Does not import any
+* extension descriptor module** — `db init` / `db update` must remain
+* runnable without the descriptor source on disk.
 *
-* @see specs/framework-mechanism.spec.md § 3 — Drift detection (T1.9).
-* @see specs/framework-mechanism.spec.md AM7 — drift warning surfaces
-*   the extension name and the diff direction.
+* Behaviour:
+* - Returns `{ kind: 'ok', pathOps: [], … }` when the marker is already
+*   at the recorded head and no required invariants are missing.
+* - Returns `{ kind: 'unreachable' }` when the marker hash is not
+*   structurally connected to the recorded head in the graph.
+* - Returns `{ kind: 'unsatisfiable', missing, … }` when the marker is
+*   reachable but no path covers the required invariants.
+* - Returns `{ kind: 'contractSpaceHeadRefMissing' }` when the per-space
+*   `refs/head.json` is absent — the precheck verifier should already
+*   have rejected this case, but the helper is defensive so callers can
+*   surface a coherent error rather than throw.
 */
-function detectSpaceContractDrift(spaceId, inputs) {
-	if (inputs.pinnedHash === null) return {
-		kind: "firstEmit",
-		spaceId,
-		descriptorHash: inputs.descriptorHash,
-		pinnedHash: null
+async function computeExtensionSpaceApplyPath(inputs) {
+	const { projectMigrationsDir, spaceId, currentMarkerHash, currentMarkerInvariants } = inputs;
+	const contractSpaceHeadRef = await readContractSpaceHeadRef(projectMigrationsDir, spaceId);
+	if (contractSpaceHeadRef === null) return { kind: "contractSpaceHeadRefMissing" };
+	const packages = await readMigrationsDir(spaceMigrationDirectory(projectMigrationsDir, spaceId));
+	const graph = reconstructGraph(packages);
+	const fromHash = currentMarkerHash ?? "sha256:empty";
+	const required = new Set(contractSpaceHeadRef.invariants.filter((id) => !currentMarkerInvariants.includes(id)));
+	const outcome = findPathWithDecision(graph, fromHash, contractSpaceHeadRef.hash, { required });
+	if (outcome.kind === "unreachable") return {
+		kind: "unreachable",
+		contractSpaceHeadRef
 	};
-	if (inputs.descriptorHash === inputs.pinnedHash) return {
-		kind: "noDrift",
-		spaceId,
-		descriptorHash: inputs.descriptorHash,
-		pinnedHash: inputs.pinnedHash
+	if (outcome.kind === "unsatisfiable") return {
+		kind: "unsatisfiable",
+		contractSpaceHeadRef,
+		missing: outcome.missing,
+		structuralPath: outcome.structuralPath.map(({ dirName, to }) => ({
+			dirName,
+			to
+		}))
 	};
+	const packagesByHash = new Map(packages.map((pkg) => [pkg.metadata.migrationHash, pkg]));
+	const pathOps = [];
+	const walkedMigrationDirs = [];
+	const providedInvariantsSet = /* @__PURE__ */ new Set();
+	for (const edge of outcome.decision.selectedPath) {
+		const pkg = packagesByHash.get(edge.migrationHash);
+		if (!pkg) throw new Error(`Migration package missing for edge ${edge.migrationHash} in space "${spaceId}"`);
+		walkedMigrationDirs.push(pkg.dirName);
+		for (const op of pkg.ops) pathOps.push(op);
+		for (const invariant of pkg.metadata.providedInvariants) providedInvariantsSet.add(invariant);
+	}
 	return {
-		kind: "drift",
-		spaceId,
-		descriptorHash: inputs.descriptorHash,
-		pinnedHash: inputs.pinnedHash
+		kind: "ok",
+		contractSpaceHeadRef,
+		providedInvariants: [...providedInvariantsSet].sort(),
+		pathOps,
+		walkedMigrationDirs
 	};
 }
 //#endregion
-//#region src/emit-pinned-space-artefacts.ts
+//#region src/emit-contract-space-artefacts.ts
 /**
-* Emit the pinned per-space artefacts (`contract.json`, `contract.d.ts`,
+* Emit the per-space artefacts (`contract.json`, `contract.d.ts`,
 * `refs/head.json`) under `<projectMigrationsDir>/<spaceId>/`.
 *
 * Always-overwrite: the framework owns these files; running `migrate`
@@ -139,23 +117,16 @@ function detectSpaceContractDrift(spaceId, inputs) {
 * helper does not check pre-existing contents — re-emit always wins.
 *
 * Path layout matches the convention in
-* [`spaceMigrationDirectory`](./space-layout.ts), with two restrictions
-* specific to pinned artefacts:
-*
-* - Rejects the app space (`spaceId === APP_SPACE_ID`): the app space's
-*   canonical `contract.json` lives at the project root, not under
-*   `migrations/`. Callers that want to emit it use the app-space
-*   contract emit pipeline.
-* - Validates `spaceId` against `[a-z][a-z0-9_-]{0,63}` via
-*   {@link assertValidSpaceId} for the same filesystem-safety reasons.
+* [`spaceMigrationDirectory`](./space-layout.ts). The space id is
+* validated against `[a-z][a-z0-9_-]{0,63}` via
+* {@link assertValidSpaceId} for filesystem-safety reasons; the helper
+* accepts every space uniformly (including the app space, default
+* `'app'`).
 *
 * The migrations directory and space subdirectory are created if they
 * do not yet exist (`mkdir { recursive: true }`).
-*
-* @see specs/framework-mechanism.spec.md § 3 — Pinned artefact emission (T1.8).
 */
-async function emitPinnedSpaceArtefacts(projectMigrationsDir, spaceId, inputs) {
-	if (spaceId === APP_SPACE_ID) throw errorPinnedArtefactsAppSpace();
+async function emitContractSpaceArtefacts(projectMigrationsDir, spaceId, inputs) {
 	assertValidSpaceId(spaceId);
 	const dir = join(projectMigrationsDir, spaceId);
 	await mkdir(join(dir, "refs"), { recursive: true });
@@ -169,6 +140,40 @@ async function emitPinnedSpaceArtefacts(projectMigrationsDir, spaceId, inputs) {
 	await writeFile(join(dir, "refs", "head.json"), `${headJson}\n`);
 }
 //#endregion
+//#region src/gather-disk-contract-space-state.ts
+/**
+* Read the on-disk state the per-space verifier needs:
+*
+* - The list of contract-space directories under
+*   `<projectMigrationsDir>/` (via
+*   {@link import('./verify-contract-spaces').listContractSpaceDirectories}).
+* - The on-disk head ref `(hash, invariants)` for each declared extension space
+*   (via {@link readContractSpaceHeadRef}; missing on-disk artefacts are simply
+*   omitted — the verifier reports them as `declaredButUnmigrated`).
+*
+* Synchronous in spirit but async due to filesystem reads. Reads only
+* the user's repo. **Does not import any extension descriptor module.**
+*
+* Composition convention: pure target-agnostic primitive in
+* `1-framework`; the SQL family (and any future target family) wires
+* it into its `dbInit` / `verify` flows alongside its own marker-row
+* read before invoking `verifyContractSpaces`.
+*/
+async function gatherDiskContractSpaceState(args) {
+	const { projectMigrationsDir, loadedSpaceIds } = args;
+	const spaceDirsOnDisk = await listContractSpaceDirectories(projectMigrationsDir);
+	const headRefsBySpace = /* @__PURE__ */ new Map();
+	for (const spaceId of loadedSpaceIds) {
+		if (spaceId === APP_SPACE_ID) continue;
+		const head = await readContractSpaceHeadRef(projectMigrationsDir, spaceId);
+		if (head !== null) headRefsBySpace.set(spaceId, head);
+	}
+	return {
+		spaceDirsOnDisk,
+		headRefsBySpace
+	};
+}
+//#endregion
 //#region src/plan-all-spaces.ts
 /**
 * Iterate the per-space planner across a set of loaded contract spaces
@@ -176,7 +181,7 @@ async function emitPinnedSpaceArtefacts(projectMigrationsDir, spaceId, inputs) {
 *
 * Behaviour:
 *
-* - The output is sorted alphabetically by `spaceId` (AM3). Two callers
+* - The output is sorted alphabetically by `spaceId`. Two callers
 *   passing the same set of inputs in different orders observe
 *   byte-identical outputs.
 * - The per-space planner (`planSpace`) is called exactly once per
@@ -193,11 +198,9 @@ async function emitPinnedSpaceArtefacts(projectMigrationsDir, spaceId, inputs) {
 *
 * Synchronous: the underlying per-space planner (target's
 * `MigrationPlanner.plan(...)`) is synchronous; callers that need to
-* resolve async I/O (e.g. reading pinned `contract.json` from disk)
+* resolve async I/O (e.g. reading on-disk `contract.json` from disk)
 * resolve it before calling `planAllSpaces` and pass the materialised
 * inputs through.
-*
-* @see specs/framework-mechanism.spec.md § 3 — Per-space planner (T1.3).
 */
 function planAllSpaces(inputs, planSpace) {
 	const seen = /* @__PURE__ */ new Set();
@@ -215,211 +218,6 @@ function planAllSpaces(inputs, planSpace) {
 	}));
 }
 //#endregion
-//#region src/read-pinned-contract-hash.ts
-function hasErrnoCode$1(error, code) {
-	return error instanceof Error && error.code === code;
-}
-/**
-* Read the pinned head hash for an extension space.
-*
-* Returns the `hash` field of `<projectMigrationsDir>/<spaceId>/refs/head.json`
-* — i.e. the canonical contract hash the framework wrote on the last
-* `migrate` for this space. Returns `null` when the file does not exist
-* (or the migrations directory is missing entirely), which is the
-* "first emit" signal {@link import('./detect-space-contract-drift').detectSpaceContractDrift}
-* uses to distinguish a brand-new extension from drift.
-*
-* Pure I/O (read + parse). The "comparison hash" is stored on disk by
-* {@link import('./emit-pinned-space-artefacts').emitPinnedSpaceArtefacts}
-* via the descriptor's `headRef.hash`, so reading it back here matches
-* the descriptor's hashing pipeline by construction — neither side
-* recomputes anything.
-*
-* Validation:
-*
-* - Rejects the app space — pinned head refs are an extension-space
-*   concept; the app space's contract-of-record lives at the project
-*   root, not under `migrations/`.
-* - Validates the space id against the same `[a-z][a-z0-9_-]{0,63}`
-*   pattern as the rest of the per-space helpers.
-* - Surfaces `MIGRATION.INVALID_JSON` / `MIGRATION.INVALID_REF_FILE`
-*   on a corrupt `refs/head.json` so callers can distinguish "no
-*   pinned file" (returns `null`) from "pinned file but unreadable"
-*   (throws).
-*
-* @see specs/framework-mechanism.spec.md § 3 — Drift detection (T1.9).
-*/
-async function readPinnedContractHash(projectMigrationsDir, spaceId) {
-	if (spaceId === APP_SPACE_ID) throw errorPinnedArtefactsAppSpace();
-	assertValidSpaceId(spaceId);
-	const filePath = join(projectMigrationsDir, spaceId, "refs", "head.json");
-	let raw;
-	try {
-		raw = await readFile(filePath, "utf-8");
-	} catch (error) {
-		if (hasErrnoCode$1(error, "ENOENT")) return null;
-		throw error;
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch (e) {
-		throw errorInvalidJson(filePath, e instanceof Error ? e.message : String(e));
-	}
-	if (typeof parsed !== "object" || parsed === null || typeof parsed.hash !== "string") throw errorInvalidRefFile(filePath, "expected an object with a string `hash` field");
-	return parsed.hash;
-}
-//#endregion
-//#region src/verify-contract-spaces.ts
-function hasErrnoCode(error, code) {
-	return error instanceof Error && error.code === code;
-}
-/**
-* List the per-space pinned subdirectories under
-* `<projectRoot>/migrations/`. Returns space-id directory names (sorted
-* alphabetically) — i.e. any non-dot-prefixed subdirectory whose root
-* does **not** contain a `migration.json` manifest. The manifest is the
-* structural marker of a user-authored migration directory (see
-* `readMigrationsDir` in `./io`); directory names themselves belong to
-* the user and are not part of the contract.
-*
-* Returns `[]` if the migrations directory does not exist (greenfield
-* project).
-*
-* Reads only the user's repo. **No descriptor import.** The caller
-* (verifier) feeds the result into {@link verifyContractSpaces} alongside
-* the loaded-space set and the marker rows.
-*
-* @see specs/framework-mechanism.spec.md § 4 — Verifier (steps 5–6).
-*/
-async function listPinnedSpaceDirectories(projectMigrationsDir) {
-	let entries;
-	try {
-		entries = (await readdir(projectMigrationsDir, { withFileTypes: true })).map((d) => ({
-			name: d.name,
-			isDirectory: d.isDirectory()
-		}));
-	} catch (error) {
-		if (hasErrnoCode(error, "ENOENT")) return [];
-		throw error;
-	}
-	const namedCandidates = entries.filter((e) => e.isDirectory).map((e) => e.name).filter((name) => !name.startsWith(".")).sort();
-	return (await Promise.all(namedCandidates.map(async (name) => {
-		try {
-			await stat(join(projectMigrationsDir, name, MANIFEST_FILE));
-			return {
-				name,
-				isMigrationDir: true
-			};
-		} catch (error) {
-			if (hasErrnoCode(error, "ENOENT")) return {
-				name,
-				isMigrationDir: false
-			};
-			throw error;
-		}
-	}))).filter((c) => !c.isMigrationDir).map((c) => c.name);
-}
-/**
-* Pure structural verifier for the per-space mechanism. Aggregates the
-* three orphan / missing checks (FR6 cases a–c) plus per-space hash and
-* invariant comparison.
-*
-* Algorithm (sub-spec § 4):
-*
-* - For every extension space declared in `loadedSpaces` (`'app'`
-*   excluded — its pinned `contract.json` lives at the project root):
-*   - If no pinned dir on disk → `declaredButUnmigrated`.
-*   - Else if `markerRowsBySpace` lacks an entry → no violation here;
-*     the live-DB compare in step 8 (out of scope of this helper) is
-*     where the absence shows up.
-*   - Else compare marker hash / invariants vs. pinned hash /
-*     invariants → `hashMismatch` / `invariantsMismatch` on drift.
-* - For every pinned dir on disk that is not in `loadedSpaces` →
-*   `orphanPinnedDir`.
-* - For every marker row whose `space` is not in `loadedSpaces` →
-*   `orphanMarker`. The app-space marker is always loaded (`'app'` is
-*   in `loadedSpaces` by definition).
-*
-* Output is deterministic (NFR6): violations are sorted first by `kind`
-* (`declaredButUnmigrated` → `orphanMarker` → `orphanPinnedDir` →
-* `hashMismatch` → `invariantsMismatch`) then by `spaceId`. Two callers
-* passing equivalent inputs see byte-identical violation lists.
-*
-* Synchronous, pure, no I/O. **Does not import the extension descriptor**
-* (the inputs are pre-resolved by the caller). This is the property
-* AC-15 / AC-26 ("verifier reads only the user repo, not
-* `node_modules`") locks in.
-*
-* @see specs/framework-mechanism.spec.md § 4 — Verifier (T1.5).
-*/
-function verifyContractSpaces(inputs) {
-	const violations = [];
-	for (const spaceId of [...inputs.loadedSpaces].sort()) {
-		if (spaceId === APP_SPACE_ID) continue;
-		if (!inputs.pinnedDirsOnDisk.includes(spaceId)) {
-			violations.push({
-				kind: "declaredButUnmigrated",
-				spaceId,
-				remediation: `Extension '${spaceId}' is declared in extensionPacks but has not been emitted; run \`prisma-next migrate\`.`
-			});
-			continue;
-		}
-		const pinned = inputs.pinnedHashesBySpace.get(spaceId);
-		const marker = inputs.markerRowsBySpace.get(spaceId);
-		if (!pinned || !marker) continue;
-		if (pinned.hash !== marker.hash) {
-			violations.push({
-				kind: "hashMismatch",
-				spaceId,
-				pinnedHash: pinned.hash,
-				markerHash: marker.hash,
-				remediation: `Marker row for space '${spaceId}' is keyed at ${marker.hash}, but the pinned ${join("migrations", spaceId, "contract.json")} resolves to ${pinned.hash}. Run \`prisma-next db update\` to advance the database, or \`prisma-next migrate\` if the descriptor was bumped without re-emitting.`
-			});
-			continue;
-		}
-		const pinnedInvariants = [...pinned.invariants].sort();
-		const markerInvariants = new Set(marker.invariants);
-		const missing = pinnedInvariants.filter((id) => !markerInvariants.has(id));
-		if (missing.length > 0) violations.push({
-			kind: "invariantsMismatch",
-			spaceId,
-			pinnedInvariants,
-			markerInvariants: [...marker.invariants].sort(),
-			remediation: `Marker row for space '${spaceId}' is missing invariants [${missing.map((s) => JSON.stringify(s)).join(", ")}]. Run \`prisma-next db update\` to apply the corresponding data-transform migrations.`
-		});
-	}
-	for (const dir of [...inputs.pinnedDirsOnDisk].sort()) if (!inputs.loadedSpaces.has(dir)) violations.push({
-		kind: "orphanPinnedDir",
-		spaceId: dir,
-		remediation: `Orphan pinned directory \`${join("migrations", dir)}/\` for an extension not in extensionPacks; remove the directory or re-add the extension.`
-	});
-	for (const space of [...inputs.markerRowsBySpace.keys()].sort()) if (!inputs.loadedSpaces.has(space)) violations.push({
-		kind: "orphanMarker",
-		spaceId: space,
-		remediation: `Orphan marker row for space '${space}' (no longer in extensionPacks); remediation: manually delete the row from \`prisma_contract.marker\`.`
-	});
-	if (violations.length === 0) return { ok: true };
-	const kindOrder = {
-		declaredButUnmigrated: 0,
-		orphanMarker: 1,
-		orphanPinnedDir: 2,
-		hashMismatch: 3,
-		invariantsMismatch: 4
-	};
-	violations.sort((a, b) => {
-		const k = kindOrder[a.kind] - kindOrder[b.kind];
-		if (k !== 0) return k;
-		if (a.spaceId < b.spaceId) return -1;
-		if (a.spaceId > b.spaceId) return 1;
-		return 0;
-	});
-	return {
-		ok: false,
-		violations
-	};
-}
-//#endregion
-export { APP_SPACE_ID, assertValidSpaceId, concatenateSpaceApplyInputs, detectSpaceContractDrift, emitPinnedSpaceArtefacts, isValidSpaceId, listPinnedSpaceDirectories, planAllSpaces, readPinnedContractHash, spaceMigrationDirectory, verifyContractSpaces };
+export { APP_SPACE_ID, assertDescriptorSelfConsistency, assertValidSpaceId, computeExtensionSpaceApplyPath, detectSpaceContractDrift, emitContractSpaceArtefacts, gatherDiskContractSpaceState, isValidSpaceId, listContractSpaceDirectories, planAllSpaces, readContractSpaceContract, readContractSpaceHeadRef, spaceMigrationDirectory, verifyContractSpaces };
 
 //# sourceMappingURL=spaces.mjs.map