@prisma-next/cli 0.12.0 → 0.13.0-dev.10

package/dist/{client-KgJorIvG.mjs → client-CJzuo5wX.mjs}

@@ -1,15 +1,16 @@
-import { A as CliStructuredError } from "./command-helpers-Bbw1GbwL.mjs";
-import { t as assertFrameworkComponentsCompatible } from "./framework-components-fYXjz_in.mjs";
-import { t as enrichContract } from "./contract-enrichment-a0V5Y_mL.mjs";
-import { n as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-DvZwdkrr.mjs";
+import { F as CliStructuredError } from "./command-helpers-DGMvGBeX.mjs";
+import { n as toExtensionInputs } from "./extension-pack-inputs-1ySHqxKG.mjs";
+import { t as assertFrameworkComponentsCompatible } from "./framework-components-YVQHhPH7.mjs";
+import { t as enrichContract } from "./contract-enrichment-gn9sWbPw.mjs";
+import { t as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-ClI1KN6d.mjs";
 import { emit } from "@prisma-next/emitter";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
 import { APP_SPACE_ID, createControlStack, hasMigrations, hasOperationPreview, hasPslContractInfer, hasSchemaView } from "@prisma-next/framework-components/control";
-import { graphWalkStrategy, planMigration, requireHeadRef, verifyMigration } from "@prisma-next/migration-tools/aggregate";
+import { blindCast, castAs } from "@prisma-next/utils/casts";
+import { buildSynthMigrationEdge, collectAggregateNamespaces, graphWalkStrategy, planMigration, requireHeadRef, verifyMigration } from "@prisma-next/migration-tools/aggregate";
 import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
 import { errorNoInvariantPath } from "@prisma-next/migration-tools/errors";
-import { castAs } from "@prisma-next/utils/casts";
 import { findPathWithDecision } from "@prisma-next/migration-tools/migration-graph";
 //#region src/control-api/errors.ts
 var ContractValidationError = class extends Error {
@@ -21,14 +22,27 @@ var ContractValidationError = class extends Error {
 	}
 };
 //#endregion
-//#region src/control-api/operations/apply.ts
+//#region src/control-api/operations/migration-helpers.ts
+/**
+* Strips operation objects to their public shape (id, label, operationClass).
+* Used at the API boundary to avoid leaking internal fields (precheck, execute, postcheck, etc.).
+*/
+function stripOperations(operations) {
+	return operations.map((op) => ({
+		id: op.id,
+		label: op.label,
+		operationClass: op.operationClass
+	}));
+}
+//#endregion
+//#region src/control-api/operations/run-migration.ts
 /**
-* Span id emitted via `onProgress` for the apply phase. Stable
+* Span id emitted via `onProgress` for the run phase. Stable
 * identifier consumed by the structured-output renderer and by tests.
 */
-const APPLY_SPAN_ID = "apply";
+const RUN_SPAN_ID = "apply";
 /**
-* Runner-driving tail shared by every apply caller — `db init`,
+* Runner-driving tail shared by every run caller — `db init`,
 * `db update`, and `migrate`. Consumes already-resolved per-space
 * plans (the planner-vs-replay distinction is owned by the caller) and
 * dispatches them to the runner in canonical order.
@@ -43,14 +57,14 @@ const APPLY_SPAN_ID = "apply";
 * so callers don't have to duplicate it; the `action` field on each
 * progress event is taken from the caller's `action` argument.
 */
-async function applyMigration(inputs) {
+async function runMigration(inputs) {
 	const { aggregate, perSpacePlans, applyOrder, driver, familyInstance, migrations, frameworkComponents, policy, action, onProgress } = inputs;
 	const orderedResolutions = collectOrdered(applyOrder, perSpacePlans);
 	const runner = migrations.createRunner(familyInstance);
 	onProgress?.({
 		action,
 		kind: "spanStart",
-		spanId: APPLY_SPAN_ID,
+		spanId: RUN_SPAN_ID,
 		label: progressLabelForAction(action)
 	});
 	const perSpaceOptions = orderedResolutions.map((r) => ({
@@ -60,6 +74,7 @@ async function applyMigration(inputs) {
 		destinationContract: r.entry.destinationContract,
 		policy,
 		frameworkComponents,
+		migrationEdges: r.entry.migrationEdges,
 		strictVerification: false
 	}));
 	const runnerResult = await runner.execute({
@@ -70,7 +85,7 @@ async function applyMigration(inputs) {
 		onProgress?.({
 			action,
 			kind: "spanEnd",
-			spanId: APPLY_SPAN_ID,
+			spanId: RUN_SPAN_ID,
 			outcome: "error"
 		});
 		return notOk({
@@ -86,7 +101,7 @@ async function applyMigration(inputs) {
 	onProgress?.({
 		action,
 		kind: "spanEnd",
-		spanId: APPLY_SPAN_ID,
+		spanId: RUN_SPAN_ID,
 		outcome: "ok"
 	});
 	return ok({
@@ -105,7 +120,7 @@ async function applyMigration(inputs) {
 * advances as the last step of each space's transaction) and `false`
 * for plan-mode (no marker has been written yet).
 *
-* Exported alongside {@link applyMigration} so plan-mode callers can
+* Exported alongside {@link runMigration} so plan-mode callers can
 * assemble the same per-space block without going through the runner.
 */
 function buildPerSpaceBreakdown(orderedResolutions, appSpaceId, options) {
@@ -146,8 +161,8 @@ function collectOrdered(applyOrder, perSpace) {
 	});
 }
 /**
-* Action-appropriate label for the `spanStart` event the apply
-* primitive emits. `applyMigration` is shared by `db init`, `db update`,
+* Action-appropriate label for the `spanStart` event the run
+* primitive emits. `runMigration` is shared by `db init`, `db update`,
 * and `migrate`; the span label tracks the user-visible action
 * so structured-progress output reads naturally for each surface.
 */
@@ -155,29 +170,16 @@ function progressLabelForAction(action) {
 	switch (action) {
 		case "dbInit": return "Initialising database across spaces";
 		case "dbUpdate": return "Updating database across spaces";
-		case "migrationApply": return "Applying migration plan across spaces";
+		case "migrate": return "Running migration plan across spaces";
 	}
 }
 //#endregion
-//#region src/control-api/operations/migration-helpers.ts
-/**
-* Strips operation objects to their public shape (id, label, operationClass).
-* Used at the API boundary to avoid leaking internal fields (precheck, execute, postcheck, etc.).
-*/
-function stripOperations(operations) {
-	return operations.map((op) => ({
-		id: op.id,
-		label: op.label,
-		operationClass: op.operationClass
-	}));
-}
-//#endregion
-//#region src/control-api/operations/db-apply.ts
+//#region src/control-api/operations/db-run.ts
 /**
-* Span IDs emitted via `onProgress` during the apply flow.
+* Span IDs emitted via `onProgress` during the run flow.
 * Stable identifiers consumed by the structured-output renderer and by
 * tests asserting on span ids. The `apply` span itself is owned by
-* the {@link applyMigration} primitive — only the introspect / plan
+* the {@link runMigration} primitive — only the introspect / plan
 * spans are emitted directly here.
 */
 const SPAN_IDS$1 = {
@@ -203,8 +205,8 @@ const SPAN_IDS$1 = {
 *    transaction across every space; failure on any space rolls back
 *    every space's writes.
 */
-async function executeApply(options) {
-	const { driver, familyInstance, contract, mode, migrations, frameworkComponents, migrationsDir, extensionPacks, targetId, policy, action, onProgress } = options;
+async function executeRun(options) {
+	const { driver, adapter, familyInstance, contract, mode, migrations, frameworkComponents, migrationsDir, extensionPacks, targetId, policy, action, onProgress } = options;
 	const loaded = await buildContractSpaceAggregate({
 		targetId,
 		migrationsDir,
@@ -225,7 +227,10 @@ async function executeApply(options) {
 		spanId: SPAN_IDS$1.introspect,
 		label: "Introspecting database schema"
 	});
-	const schemaIR = await familyInstance.introspect({ driver });
+	const schemaIR = await familyInstance.introspect({
+		driver,
+		contract: collectAggregateNamespaces(aggregate)
+	});
 	onProgress?.({
 		action,
 		kind: "spanEnd",
@@ -244,7 +249,7 @@ async function executeApply(options) {
 			markersBySpaceId: markerRows,
 			schemaIntrospection: schemaIR
 		},
-		familyInstance,
+		adapter,
 		migrations,
 		frameworkComponents,
 		callerPolicy: { ignoreGraphFor: new Set([aggregate.app.spaceId]) },
@@ -266,6 +271,7 @@ async function executeApply(options) {
 		outcome: "ok"
 	});
 	const orderedResolutions = collectOrdered(planResult.value.applyOrder, planResult.value.perSpace);
+	const plannerWarnings = aggregatePlannerWarnings(orderedResolutions);
 	const appResolution = orderedResolutions.find((r) => r.spaceId === aggregate.app.spaceId);
 	if (!appResolution) throw new Error("Aggregate planner returned no plan for the app member — the planner is supposed to always emit one.");
 	const appPlan = appResolution.entry.plan;
@@ -279,10 +285,11 @@ async function executeApply(options) {
 			destination: appPlan.destination,
 			preview,
 			perSpace,
-			summary
+			summary,
+			...ifDefined("warnings", plannerWarnings)
 		});
 	}
-	const applied = await applyMigration({
+	const applied = await runMigration({
 		aggregate,
 		perSpacePlans: planResult.value.perSpace,
 		applyOrder: planResult.value.applyOrder,
@@ -297,7 +304,8 @@ async function executeApply(options) {
 	if (!applied.ok) return buildRunnerFailure({
 		summary: applied.failure.summary,
 		...ifDefined("why", applied.failure.why),
-		meta: applied.failure.meta
+		meta: applied.failure.meta,
+		...ifDefined("warnings", plannerWarnings)
 	});
 	const aggregateOps = applied.value.orderedResolutions.flatMap((r) => r.entry.displayOps);
 	const summary = action === "dbInit" ? `Applied ${applied.value.totalOpsExecuted} operation(s) across ${applied.value.orderedResolutions.length} space(s), database signed` : applied.value.totalOpsExecuted === 0 ? `Database already matches contract across ${applied.value.orderedResolutions.length} space(s), signature updated` : `Applied ${applied.value.totalOpsExecuted} operation(s) across ${applied.value.orderedResolutions.length} space(s), signature updated`;
@@ -307,9 +315,14 @@ async function executeApply(options) {
 		operationsPlanned: applied.value.totalOpsPlanned,
 		operationsExecuted: applied.value.totalOpsExecuted,
 		perSpace: applied.value.perSpace,
-		summary
+		summary,
+		...ifDefined("warnings", plannerWarnings)
 	});
 }
+function aggregatePlannerWarnings(orderedResolutions) {
+	const warnings = orderedResolutions.flatMap((r) => r.entry.warnings ?? []);
+	return warnings.length > 0 ? warnings : void 0;
+}
 /**
 * Compare the live `_prisma_marker` rows against the aggregate's
 * declared members. Any marker row whose `space` is not a member of
@@ -342,13 +355,13 @@ function detectOrphanMarkers(aggregate, markerRows) {
 	});
 }
 function mapPlannerError(error) {
-	if (error.kind === "appSynthFailure") return notOk({
+	if (error.kind === "appSynthFailure") return blindCast(notOk({
 		code: "PLANNING_FAILED",
 		summary: "Migration planning failed due to conflicts",
 		conflicts: error.conflicts,
 		why: void 0,
 		meta: void 0
-	});
+	}));
 	if (error.kind === "extensionPathUnreachable") return buildRunnerFailure({
 		summary: `Cannot resolve apply path for extension space "${error.spaceId}"`,
 		why: `No path in the on-disk migration graph for extension space "${error.spaceId}" reaches the on-disk head ref hash "${error.target}".`,
@@ -383,7 +396,8 @@ function wrapPlanResult(args) {
 			...ifDefined("profileHash", args.destination.profileHash)
 		},
 		perSpace: args.perSpace,
-		summary: args.summary
+		summary: args.summary,
+		...ifDefined("warnings", args.warnings)
 	});
 }
 function wrapApplyResult(args) {
@@ -403,17 +417,19 @@ function wrapApplyResult(args) {
 			profileHash: args.destination.profileHash
 		} : { storageHash: args.destination.storageHash },
 		perSpace: args.perSpace,
-		summary: args.summary
+		summary: args.summary,
+		...ifDefined("warnings", args.warnings)
 	});
 }
 function buildRunnerFailure(args) {
-	return notOk({
+	return blindCast(notOk({
 		code: "RUNNER_FAILED",
 		summary: args.summary,
 		why: args.why,
 		meta: args.meta,
-		conflicts: void 0
-	});
+		conflicts: void 0,
+		...ifDefined("warnings", args.warnings)
+	}));
 }
 //#endregion
 //#region src/control-api/operations/db-init.ts
@@ -425,8 +441,9 @@ function buildRunnerFailure(args) {
 * changes belong to `db update`.
 */
 async function executeDbInit(options) {
-	return await executeApply({
+	return await executeRun({
 		driver: options.driver,
+		adapter: options.adapter,
 		familyInstance: options.familyInstance,
 		contract: options.contract,
 		mode: options.mode,
@@ -459,6 +476,7 @@ const DB_UPDATE_POLICY = { allowedOperationClasses: [
 async function executeDbUpdate(options) {
 	const sharedInputs = {
 		driver: options.driver,
+		adapter: options.adapter,
 		familyInstance: options.familyInstance,
 		contract: options.contract,
 		migrations: options.migrations,
@@ -474,7 +492,7 @@ async function executeDbUpdate(options) {
 		const gate = await guardDestructiveChanges(sharedInputs);
 		if (gate !== null) return gate;
 	}
-	return await executeApply({
+	return await executeRun({
 		...sharedInputs,
 		mode: options.mode
 	});
@@ -487,7 +505,7 @@ async function executeDbUpdate(options) {
 * run.
 */
 async function guardDestructiveChanges(sharedInputs) {
-	const planResult = await executeApply({
+	const planResult = await executeRun({
 		...sharedInputs,
 		mode: "plan"
 	});
@@ -541,7 +559,8 @@ async function executeDbVerify(options) {
 	const schemaIntrospection = skipSchema ? null : await runIntrospection({
 		driver,
 		familyInstance,
-		onProgress
+		onProgress,
+		contract: collectAggregateNamespaces(aggregate)
 	});
 	emitVerifySpan(onProgress, "spanStart");
 	return finaliseVerifyResult({
@@ -567,7 +586,7 @@ function buildLoadInputs(options) {
 	};
 }
 async function runIntrospection(args) {
-	const { driver, familyInstance, onProgress } = args;
+	const { driver, familyInstance, onProgress, contract } = args;
 	onProgress?.({
 		action: "dbVerify",
 		kind: "spanStart",
@@ -575,7 +594,10 @@ async function runIntrospection(args) {
 		label: "Introspecting database schema"
 	});
 	try {
-		const result = await familyInstance.introspect({ driver });
+		const result = await familyInstance.introspect({
+			driver,
+			contract
+		});
 		onProgress?.({
 			action: "dbVerify",
 			kind: "spanEnd",
@@ -605,7 +627,7 @@ function createPerMemberVerifier(options) {
 		if (skipSchema) return buildSkippedSchemaResult(member);
 		return familyInstance.verifySchema({
 			contract: member.contract(),
-			schema: projectedSchema,
+			schema: blindCast(projectedSchema),
 			strict: verifyMode === "strict",
 			frameworkComponents
 		});
@@ -730,7 +752,7 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 	});
 }
 //#endregion
-//#region src/control-api/operations/migration-apply.ts
+//#region src/control-api/operations/migrate.ts
 /**
 * Apply pending migrations across every contract space (app +
 * extensions). Replay-only: graph-walk against the on-disk graph for
@@ -745,14 +767,14 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 *    marker to `member.headRef.hash` (or `refHash` for the app
 *    member when provided). Empty-graph members fail loudly — a
 *    "never planned" space is a user-error condition for replay.
-* 4. Hand off to {@link applyMigration} (the runner-driving tail
+* 4. Hand off to {@link runMigration} (the runner-driving tail
 *    shared with `db init` / `db update`). Marker advancement is
 *    inside the per-space transaction.
 *
 * Encodes the replay-only contract: every contract space must have an
 * authored migration graph on disk before this operation can advance it.
 */
-async function executeMigrationApply(options) {
+async function executeMigrate(options) {
 	const { driver, familyInstance, contract, migrations, frameworkComponents, migrationsDir, extensionPacks, targetId, refHash, refInvariants, refName, onProgress } = options;
 	const loaded = await buildContractSpaceAggregate({
 		targetId,
@@ -770,39 +792,23 @@ async function executeMigrationApply(options) {
 	for (const member of allMembers) {
 		const isAppMember = member.spaceId === aggregate.app.spaceId;
 		const headRef = requireHeadRef(member);
-		const targetHash = isAppMember && refHash !== void 0 ? refHash : headRef.hash;
-		const liveMarker = markerRows.get(member.spaceId) ?? null;
-		if (member.graph().nodes.size === 0) {
-			const liveHash = liveMarker?.storageHash;
-			if (targetHash === liveHash || liveHash === void 0 && targetHash === EMPTY_CONTRACT_HASH) {
-				atHeadResolutions.set(member.spaceId, buildAtHeadResolution({
-					aggregateTargetId: aggregate.targetId,
-					member,
-					targetHash,
-					liveMarker
-				}));
-				continue;
-			}
-			return notOk(buildNeverPlannedFailure(member.spaceId, targetHash));
-		}
-		const targetInvariants = isAppMember && refHash !== void 0 && refInvariants !== void 0 ? refInvariants : headRef.invariants;
-		const targetMember = targetHash === headRef.hash && targetInvariants === headRef.invariants ? member : {
-			...member,
-			headRef: {
-				hash: targetHash,
-				invariants: targetInvariants
-			}
-		};
-		const walked = graphWalkStrategy({
-			aggregateTargetId: aggregate.targetId,
-			member: targetMember,
-			currentMarker: liveMarker,
-			...isAppMember && refName !== void 0 ? { refName } : {}
+		const memberTargetHash = isAppMember && refHash !== void 0 ? refHash : headRef.hash;
+		const outcome = planMemberPath({
+			member,
+			aggregate,
+			targetHash: memberTargetHash,
+			refInvariants: isAppMember && refHash !== void 0 ? refInvariants : void 0,
+			liveMarker: markerRows.get(member.spaceId) ?? null,
+			...isAppMember ? { refName } : {}
 		});
-		if (walked.kind === "unreachable") return notOk(buildPathNotFoundFailure(member.spaceId, liveMarker, targetHash));
-		if (walked.kind === "unsatisfiable") {
-			const fromHash = liveMarker?.storageHash ?? EMPTY_CONTRACT_HASH;
-			const structural = findPathWithDecision(targetMember.graph(), fromHash, targetHash, { required: /* @__PURE__ */ new Set() });
+		if (outcome.kind === "at-head") {
+			atHeadResolutions.set(member.spaceId, outcome.plan);
+			continue;
+		}
+		if (outcome.kind === "never-planned") return notOk(buildNeverPlannedFailure(outcome.spaceId, outcome.targetHash));
+		if (outcome.kind === "unreachable") return notOk(buildPathNotFoundFailure(outcome.spaceId, outcome.liveMarker, outcome.targetHash));
+		if (outcome.kind === "unsatisfiable") {
+			const structural = findPathWithDecision(outcome.targetMember.graph(), outcome.liveHash, memberTargetHash, { required: /* @__PURE__ */ new Set() });
 			const structuralPath = structural.kind === "ok" ? structural.decision.selectedPath.map((edge) => ({
 				dirName: edge.dirName,
 				migrationHash: edge.migrationHash,
@@ -811,13 +817,13 @@ async function executeMigrationApply(options) {
 				invariants: edge.invariants
 			})) : [];
 			throw errorNoInvariantPath({
-				...isAppMember && refName !== void 0 ? { refName } : {},
-				required: targetInvariants,
-				missing: walked.missing,
+				...outcome.refName !== void 0 ? { refName: outcome.refName } : {},
+				required: outcome.targetInvariants,
+				missing: outcome.missing,
 				structuralPath
 			});
 		}
-		perSpacePlans.set(member.spaceId, walked.result);
+		perSpacePlans.set(member.spaceId, outcome.plan);
 	}
 	const canonicalOrder = [...aggregate.extensions.map((m) => m.spaceId), aggregate.app.spaceId];
 	const applyOrder = canonicalOrder.filter((spaceId) => perSpacePlans.has(spaceId));
@@ -840,7 +846,7 @@ async function executeMigrationApply(options) {
 			summary: totalSpaces === 0 ? "Already up to date — no contract spaces are loaded" : totalSpaces === 1 ? "Already up to date" : `Already up to date across ${totalSpaces} space(s)`
 		}));
 	}
-	const applied = await applyMigration({
+	const applied = await runMigration({
 		aggregate,
 		perSpacePlans,
 		applyOrder,
@@ -854,7 +860,7 @@ async function executeMigrationApply(options) {
 			"destructive",
 			"data"
 		] },
-		action: "migrationApply",
+		action: "migrate",
 		...ifDefined("onProgress", onProgress)
 	});
 	if (!applied.ok) return notOk({
@@ -876,7 +882,7 @@ async function executeMigrationApply(options) {
 		};
 	});
 	const perSpaceAll = buildPerSpaceBreakdown(orderedAll, aggregate.app.spaceId, { includeMarkers: true });
-	const summary = `Applied ${applied.value.orderedResolutions.reduce((sum, r) => sum + (r.entry.migrationEdges?.length ?? 0), 0)} migration(s) (${applied.value.totalOpsExecuted} operation(s)) across ${orderedAll.length} contract space(s)`;
+	const summary = `Applied ${applied.value.orderedResolutions.reduce((sum, r) => sum + r.entry.migrationEdges.length, 0)} migration(s) (${applied.value.totalOpsExecuted} operation(s)) across ${orderedAll.length} contract space(s)`;
 	return ok(buildSuccess({
 		aggregate,
 		orderedResolutions: orderedAll,
@@ -886,6 +892,79 @@ async function executeMigrationApply(options) {
 	}));
 }
 /**
+* Compute the graph-walk path for one contract-space member.
+*
+* Encapsulates the invariant-correct input assembly that both
+* `executeMigrate` and `executeMigrateShowCommand` must use:
+* - `currentMarker` carries the full live marker including `invariants`
+*   (not a stripped `{ storageHash, invariants: [] }` shell).
+* - `targetInvariants` uses the caller-supplied `refInvariants` when a
+*   `--to` ref was resolved (not always the file head ref's invariants).
+*
+* Both callers map the returned `MemberPathOutcome` to their own error
+* representation; the path-compute logic is shared and identical.
+*
+* @internal Exported for `executeMigrateShowCommand`.
+*/
+function planMemberPath({ member, aggregate, targetHash, refInvariants, liveMarker, refName }) {
+	const isAppMember = member.spaceId === aggregate.app.spaceId;
+	const headRef = requireHeadRef(member);
+	if (member.graph().nodes.size === 0) {
+		const liveHash = liveMarker?.storageHash;
+		if (targetHash === liveHash || liveHash === void 0 && targetHash === EMPTY_CONTRACT_HASH) return {
+			kind: "at-head",
+			plan: buildAtHeadResolution({
+				aggregateTargetId: aggregate.targetId,
+				member,
+				targetHash,
+				liveMarker
+			})
+		};
+		return {
+			kind: "never-planned",
+			spaceId: member.spaceId,
+			targetHash
+		};
+	}
+	const targetInvariants = isAppMember && refInvariants !== void 0 ? refInvariants : headRef.invariants;
+	const targetMember = targetHash === headRef.hash && targetInvariants === headRef.invariants ? member : {
+		...member,
+		headRef: {
+			hash: targetHash,
+			invariants: targetInvariants
+		}
+	};
+	const walked = graphWalkStrategy({
+		aggregateTargetId: aggregate.targetId,
+		member: targetMember,
+		currentMarker: liveMarker,
+		...isAppMember && refName !== void 0 ? { refName } : {}
+	});
+	if (walked.kind === "unreachable") return {
+		kind: "unreachable",
+		spaceId: member.spaceId,
+		liveMarker,
+		targetHash
+	};
+	if (walked.kind === "unsatisfiable") {
+		const liveHash = liveMarker?.storageHash ?? EMPTY_CONTRACT_HASH;
+		return {
+			kind: "unsatisfiable",
+			spaceId: member.spaceId,
+			isAppMember,
+			missing: walked.missing,
+			targetInvariants,
+			targetMember,
+			liveHash,
+			refName
+		};
+	}
+	return {
+		kind: "ok",
+		plan: walked.result
+	};
+}
+/**
 * Build a zero-op {@link PerSpacePlan} for an empty-graph
 * member whose live marker already matches the target. Lets the apply
 * pipeline thread the member through `perSpacePlans` -> `applyOrder`
@@ -906,7 +985,11 @@ function buildAtHeadResolution(args) {
 		displayOps: [],
 		destinationContract: member.contract(),
 		strategy: "graph-walk",
-		migrationEdges: []
+		migrationEdges: [buildSynthMigrationEdge({
+			currentMarkerStorageHash: liveMarker?.storageHash,
+			destinationStorageHash: targetHash,
+			operationCount: 0
+		})]
 	};
 }
 function sumPlannedOps(applyOrder, perSpacePlans) {
@@ -922,7 +1005,7 @@ function buildSuccess(args) {
 	const appResolution = args.orderedResolutions.find((r) => r.spaceId === args.aggregate.app.spaceId);
 	const appMarkerHash = appResolution?.entry.plan.destination.storageHash ?? requireHeadRef(args.aggregate.app).hash;
 	const applied = args.orderedResolutions.flatMap((r) => {
-		return (r.entry.migrationEdges ?? []).map((edge) => ({
+		return r.entry.migrationEdges.map((edge) => ({
 			spaceId: r.spaceId,
 			dirName: edge.dirName,
 			migrationHash: edge.migrationHash,
@@ -1064,6 +1147,18 @@ var ControlClientImpl = class {
 			this.driver = null;
 		}
 	}
+	/**
+	* Construct the control adapter once for a migration operation and return
+	* it, mirroring how the runtime plane builds the execution adapter once in
+	* `createExecutionStack`. Only `dbInit` / `dbUpdate` need it (it lowers the
+	* planner's DDL); read-only operations never build it. The descriptor is
+	* optional on the stack — targets without migrations omit it.
+	*/
+	buildControlAdapter() {
+		this.init();
+		if (!this.stack?.adapter) throw new Error(`Target "${this.options.target.targetId}" requires an adapter for migrations`);
+		return this.stack.adapter.create(this.stack);
+	}
 	async ensureConnected() {
 		this.init();
 		if (!this.driver && this.defaultConnection !== void 0) await this.connect(this.defaultConnection);
@@ -1229,6 +1324,7 @@ var ControlClientImpl = class {
 		await this.connectWithProgress(options.connection, "dbInit", onProgress);
 		const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
 		if (!hasMigrations(this.options.target)) throw new Error(`Target "${this.options.target.targetId}" does not support migrations`);
+		const adapter = this.buildControlAdapter();
 		let contract;
 		try {
 			contract = familyInstance.deserializeContract(options.contract);
@@ -1237,6 +1333,7 @@ var ControlClientImpl = class {
 		}
 		return executeDbInit({
 			driver,
+			adapter,
 			familyInstance,
 			contract,
 			mode: options.mode,
@@ -1253,6 +1350,7 @@ var ControlClientImpl = class {
 		await this.connectWithProgress(options.connection, "dbUpdate", onProgress);
 		const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
 		if (!hasMigrations(this.options.target)) throw new Error(`Target "${this.options.target.targetId}" does not support migrations`);
+		const adapter = this.buildControlAdapter();
 		let contract;
 		try {
 			contract = familyInstance.deserializeContract(options.contract);
@@ -1261,6 +1359,7 @@ var ControlClientImpl = class {
 		}
 		return executeDbUpdate({
 			driver,
+			adapter,
 			familyInstance,
 			contract,
 			mode: options.mode,
@@ -1302,9 +1401,17 @@ var ControlClientImpl = class {
 		const { driver, familyInstance } = await this.ensureConnected();
 		return familyInstance.readAllMarkers({ driver });
 	}
-	async migrationApply(options) {
+	/** Reads the per-migration journal; omit `space` to return every space. */
+	async readLedger(space) {
+		const { driver, familyInstance } = await this.ensureConnected();
+		return familyInstance.readLedger({
+			driver,
+			...ifDefined("space", space)
+		});
+	}
+	async migrate(options) {
 		const { onProgress } = options;
-		await this.connectWithProgress(options.connection, "migrationApply", onProgress);
+		await this.connectWithProgress(options.connection, "migrate", onProgress);
 		const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
 		if (!hasMigrations(this.options.target)) throw new Error(`Target "${this.options.target.targetId}" does not support migrations`);
 		let contract;
@@ -1313,7 +1420,7 @@ var ControlClientImpl = class {
 		} catch (error) {
 			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
 		}
-		return executeMigrationApply({
+		return executeMigrate({
 			driver,
 			familyInstance,
 			contract,
@@ -1366,6 +1473,10 @@ var ControlClientImpl = class {
 		this.init();
 		if (this.familyInstance && hasPslContractInfer(this.familyInstance)) return this.familyInstance.inferPslContract(schemaIR);
 	}
+	getPslBlockDescriptors() {
+		this.init();
+		return this.stack.authoringContributions.pslBlockDescriptors;
+	}
 	toOperationPreview(operations) {
 		this.init();
 		if (this.familyInstance && hasOperationPreview(this.familyInstance)) return this.familyInstance.toOperationPreview(operations);
@@ -1383,8 +1494,11 @@ var ControlClientImpl = class {
 		});
 		try {
 			const stack = this.stack;
+			const extensionInputs = toExtensionInputs(blindCast(stack.extensionPacks));
+			const composedExtensionContracts = new Map(extensionInputs.filter((p) => p.contractSpace !== void 0).map((p) => [p.id, blindCast(p.contractSpace.contractJson)]));
 			const sourceContext = {
 				composedExtensionPacks: stack.extensionPacks.map((p) => p.id),
+				composedExtensionContracts,
 				scalarTypeDescriptors: stack.scalarTypeDescriptors,
 				authoringContributions: stack.authoringContributions,
 				codecLookup: stack.codecLookup,
@@ -1444,8 +1558,9 @@ var ControlClientImpl = class {
 		});
 		try {
 			const enrichedIR = enrichContract(contractRaw, this.frameworkComponents ?? []);
+			let deserializedContract;
 			try {
-				this.familyInstance.deserializeContract(enrichedIR);
+				deserializedContract = this.familyInstance.deserializeContract(enrichedIR);
 			} catch (error) {
 				onProgress?.({
 					action: "emit",
@@ -1460,7 +1575,7 @@ var ControlClientImpl = class {
 					meta: void 0
 				});
 			}
-			const result = await emit(enrichedIR, this.stack, this.options.family.emission, { serializeContract: (contract) => this.options.target.contractSerializer.serializeContract(contract) });
+			const result = await emit(deserializedContract, this.stack, this.options.family.emission, { serializeContract: (contract) => this.options.target.contractSerializer.serializeContract(contract) });
 			onProgress?.({
 				action: "emit",
 				kind: "spanEnd",
@@ -1491,6 +1606,6 @@ var ControlClientImpl = class {
 	}
 };
 //#endregion
-export { ContractValidationError as a, executeDbInit as i, executeDbVerify as n, executeDbUpdate as r, createControlClient as t };
+export { executeDbInit as a, executeDbUpdate as i, planMemberPath as n, ContractValidationError as o, executeDbVerify as r, createControlClient as t };
 
-//# sourceMappingURL=client-KgJorIvG.mjs.map
+//# sourceMappingURL=client-CJzuo5wX.mjs.map