@prisma-next/cli 0.14.0 → 0.15.0-dev.1

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

@@ -1,14 +1,13 @@
-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 { F as CliStructuredError } from "./command-helpers-CUoKYTlG.mjs";
+import { t as assertFrameworkComponentsCompatible } from "./framework-components-BbnM1RYm.mjs";
 import { t as enrichContract } from "./contract-enrichment-gn9sWbPw.mjs";
-import { t as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-ClI1KN6d.mjs";
+import { t as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-DpB4x97a.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 { APP_SPACE_ID, createControlStack, hasMigrations, hasOperationPreview, hasPslContractInfer, hasSchemaSubjectClassifier, hasSchemaView } from "@prisma-next/framework-components/control";
 import { blindCast, castAs } from "@prisma-next/utils/casts";
-import { buildSynthMigrationEdge, collectAggregateNamespaces, graphWalkStrategy, planMigration, requireHeadRef, verifyMigration } from "@prisma-next/migration-tools/aggregate";
+import { buildFabricatedMigrationEdge, collectAggregateNamespaces, planMigration, requireHeadRef, resolveRecordedPath, 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 { findPathWithDecision } from "@prisma-next/migration-tools/migration-graph";
@@ -144,7 +143,7 @@ function buildPerSpaceBreakdown(orderedResolutions, appSpaceId, options) {
 }
 /**
 * Materialise the `applyOrder` ordering into resolved per-space
-* entries. Throws if the planner output is missing a member listed
+* entries. Throws if the planner output is missing a contract space listed
 * in `applyOrder` — a wiring bug that should never reach runtime.
 *
 * Exported so callers building their own success envelopes after a
@@ -196,10 +195,11 @@ const SPAN_IDS$1 = {
 *    integrity violation short-circuits with a structured error.
 * 2. **Read DB state**: marker rows (`familyInstance.readAllMarkers`)
 *    + introspected schema (`familyInstance.introspect`).
-* 3. **Plan**: {@link planMigration} chooses graph-walk vs synth per
-*    member according to `callerPolicy.ignoreGraphFor`. The app member
-*    is forced through synth (today's daily-driver behaviour); every
-*    extension member walks its on-disk graph.
+* 3. **Plan**: {@link planMigration} chooses `resolveRecordedPath` vs
+*    `planFromDiff` per space according to `callerPolicy.ignoreGraphFor`.
+*    The app space is forced through `planFromDiff` (today's daily-driver
+*    behaviour); every extension space walks its on-disk graph via
+*    `resolveRecordedPath`.
 * 4. **Apply** (when `mode === 'apply'`): every per-space `MigrationPlan`
 *    feeds into the runner's `execute` — one outer
 *    transaction across every space; failure on any space rolls back
@@ -252,7 +252,7 @@ async function executeRun(options) {
 		adapter,
 		migrations,
 		frameworkComponents,
-		callerPolicy: { ignoreGraphFor: new Set([aggregate.app.spaceId]) },
+		callerPolicy: { ignoreGraphFor: /* @__PURE__ */ new Set([aggregate.app.spaceId]) },
 		operationPolicy: policy
 	});
 	if (!planResult.ok) {
@@ -273,7 +273,7 @@ async function executeRun(options) {
 	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.");
+	if (!appResolution) throw new Error("Aggregate planner returned no plan for the app space — the planner is supposed to always emit one.");
 	const appPlan = appResolution.entry.plan;
 	if (mode === "plan") {
 		const aggregateOps = orderedResolutions.flatMap((r) => r.entry.displayOps);
@@ -325,22 +325,22 @@ function aggregatePlannerWarnings(orderedResolutions) {
 }
 /**
 * Compare the live `_prisma_marker` rows against the aggregate's
-* declared members. Any marker row whose `space` is not a member of
+* declared contract spaces. Any marker row whose `space` is not a space of
 * the aggregate is an "orphan" — typically a marker left behind by
 * an extension that was removed from `extensionPacks` without first
 * cleaning up its on-disk migrations / database tables.
 *
 * Returns a {@link CliStructuredError} envelope (code `5002`,
 * `kind: 'orphanMarker'`) for the first orphan it finds, or `null`
-* when every marker row maps to a declared member. Mirrors the M2
+* when every marker row maps to a declared contract space. Mirrors the M2
 * `runContractSpaceVerifierMarkerCheck` envelope so downstream
 * tooling (integration tests, JSON consumers) keeps asserting on the
 * same shape.
 */
 function detectOrphanMarkers(aggregate, markerRows) {
-	const memberSpaceIds = new Set([aggregate.app.spaceId, ...aggregate.extensions.map((m) => m.spaceId)]);
+	const aggregateSpaceIds = /* @__PURE__ */ new Set([aggregate.app.spaceId, ...aggregate.extensions.map((m) => m.spaceId)]);
 	const orphans = [];
-	for (const [spaceId, row] of markerRows) if (row !== null && row !== void 0 && !memberSpaceIds.has(spaceId)) orphans.push(spaceId);
+	for (const [spaceId, row] of markerRows) if (row !== null && row !== void 0 && !aggregateSpaceIds.has(spaceId)) orphans.push(spaceId);
 	if (orphans.length === 0) return null;
 	orphans.sort((a, b) => a.localeCompare(b));
 	return new CliStructuredError("5002", orphans.length === 1 ? `Orphan contract-space marker detected for "${orphans[0]}"` : `Orphan contract-space markers detected for ${orphans.length} spaces`, {
@@ -355,7 +355,7 @@ function detectOrphanMarkers(aggregate, markerRows) {
 	});
 }
 function mapPlannerError(error) {
-	if (error.kind === "appSynthFailure") return blindCast(notOk({
+	if (error.kind === "planFromDiffFailed") return blindCast(notOk({
 		code: "PLANNING_FAILED",
 		summary: "Migration planning failed due to conflicts",
 		conflicts: error.conflicts,
@@ -544,11 +544,11 @@ const SPAN_IDS = {
 *    structured CLI error.
 * 2. **Read DB state**: marker rows + (when `skipSchema` is `false`)
 *    schema introspection.
-* 3. **Verify**: {@link verifyMigration} returns per-space
-*    `markerCheck` + per-space pre-projected `schemaCheck` (closes F23).
-*    Marker mismatches map to `CliStructuredError` (code `5002`) so
-*    callers (CLI command) can render and exit. Schema results are
-*    returned to the caller verbatim.
+* 3. **Verify**: {@link verifyMigration} returns per-space `markerCheck` +
+*    per-space `schemaCheck` (each contract space verified against the full schema,
+*    then scoped to its own contract space). Marker mismatches map to
+*    `CliStructuredError` (code `5002`) so callers (CLI command) can render
+*    and exit. Verify results are returned to the caller verbatim.
 */
 async function executeDbVerify(options) {
 	const { driver, familyInstance, onProgress, skipSchema, skipMarker } = options;
@@ -562,6 +562,8 @@ async function executeDbVerify(options) {
 		onProgress,
 		contract: collectAggregateNamespaces(aggregate)
 	});
+	const classifySubjectGranularity = hasSchemaSubjectClassifier(familyInstance) ? (issue) => familyInstance.classifySubjectGranularity(issue) : void 0;
+	const classifyEntityKind = hasSchemaSubjectClassifier(familyInstance) ? (issue) => familyInstance.classifyEntityKind(issue) : void 0;
 	emitVerifySpan(onProgress, "spanStart");
 	return finaliseVerifyResult({
 		verifyResult: verifyMigration({
@@ -569,7 +571,9 @@ async function executeDbVerify(options) {
 			markersBySpaceId,
 			schemaIntrospection,
 			mode: options.mode,
-			verifySchemaForMember: createPerMemberVerifier(options)
+			verifySchemaForSpace: createPerSpaceVerifier(options),
+			...ifDefined("classifySubjectGranularity", classifySubjectGranularity),
+			...ifDefined("classifyEntityKind", classifyEntityKind)
 		}),
 		aggregate,
 		skipMarker,
@@ -616,18 +620,18 @@ async function runIntrospection(args) {
 	}
 }
 /**
-* Build the per-member schema callback handed to the aggregate verifier.
+* Build the per-space schema callback handed to the aggregate verifier.
 * When `skipSchema` is true the callback short-circuits with a synthetic
 * `ok` result so the verifier still runs the (cheap) schemaCheck loop
 * without invoking the family's verification path.
 */
-function createPerMemberVerifier(options) {
+function createPerSpaceVerifier(options) {
 	const { skipSchema, familyInstance, frameworkComponents } = options;
-	return (projectedSchema, member, verifyMode) => {
-		if (skipSchema) return buildSkippedSchemaResult(member);
+	return (schema, space, verifyMode) => {
+		if (skipSchema) return buildSkippedSchemaResult(space);
 		return familyInstance.verifySchema({
-			contract: member.contract(),
-			schema: blindCast(projectedSchema),
+			contract: space.contract(),
+			schema,
 			strict: verifyMode === "strict",
 			frameworkComponents
 		});
@@ -674,13 +678,14 @@ function finaliseVerifyResult(args) {
 	emitVerifySpan(onProgress, "spanEndOk");
 	return ok({
 		schemaResults: verifyResult.value.schemaCheck.perSpace,
-		memberOrder: [aggregate.app.spaceId, ...aggregate.extensions.map((e) => e.spaceId)],
+		unclaimed: verifyResult.value.schemaCheck.unclaimed,
+		spaceOrder: [aggregate.app.spaceId, ...aggregate.extensions.map((e) => e.spaceId)],
 		appSpaceId: aggregate.app.spaceId
 	});
 }
-function buildSkippedSchemaResult(member) {
-	const contract = member.contract();
-	const headRef = requireHeadRef(member);
+function buildSkippedSchemaResult(space) {
+	const contract = space.contract();
+	const headRef = requireHeadRef(space);
 	const profileHash = castAs(contract).profileHash;
 	return {
 		ok: true,
@@ -690,26 +695,7 @@ function buildSkippedSchemaResult(member) {
 			...profileHash ? { profileHash } : {}
 		},
 		target: { expected: contract.target },
-		schema: {
-			issues: [],
-			root: {
-				status: "pass",
-				kind: "skipped",
-				name: member.spaceId,
-				contractPath: "",
-				code: "SKIPPED",
-				message: "Schema verification skipped",
-				expected: void 0,
-				actual: void 0,
-				children: []
-			},
-			counts: {
-				pass: 0,
-				warn: 0,
-				fail: 0,
-				totalNodes: 0
-			}
-		},
+		schema: { issues: [] },
 		timings: { total: 0 }
 	};
 }
@@ -756,16 +742,16 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 /**
 * Apply pending migrations across every contract space (app +
 * extensions). Replay-only: graph-walk against the on-disk graph for
-* every member; no synth, no introspection.
+* every contract space; no synth, no introspection.
 *
 * Pipeline:
 *
 * 1. Load aggregate from disk (loader hydrates extension graphs;
 *    caller provides app-space packages).
 * 2. Read live marker rows per space (`familyInstance.readAllMarkers`).
-* 3. Per member: `graphWalkStrategy` plots the path from the live
-*    marker to `member.headRef.hash` (or `refHash` for the app
-*    member when provided). Empty-graph members fail loudly — a
+* 3. Per space: `resolveRecordedPath` plots the path from the live
+*    marker to `space.headRef.hash` (or `refHash` for the app
+*    space when provided). Empty-graph spaces fail loudly — a
 *    "never planned" space is a user-error condition for replay.
 * 4. Hand off to {@link runMigration} (the runner-driving tail
 *    shared with `db init` / `db update`). Marker advancement is
@@ -786,29 +772,29 @@ async function executeMigrate(options) {
 	if (!loaded.ok) throw loaded.failure;
 	const aggregate = loaded.value;
 	const markerRows = await familyInstance.readAllMarkers({ driver });
-	const allMembers = [aggregate.app, ...aggregate.extensions];
+	const allSpaces = [aggregate.app, ...aggregate.extensions];
 	const perSpacePlans = /* @__PURE__ */ new Map();
 	const atHeadResolutions = /* @__PURE__ */ new Map();
-	for (const member of allMembers) {
-		const isAppMember = member.spaceId === aggregate.app.spaceId;
-		const headRef = requireHeadRef(member);
-		const memberTargetHash = isAppMember && refHash !== void 0 ? refHash : headRef.hash;
-		const outcome = planMemberPath({
-			member,
+	for (const space of allSpaces) {
+		const isAppSpace = space.spaceId === aggregate.app.spaceId;
+		const headRef = requireHeadRef(space);
+		const spaceTargetHash = isAppSpace && refHash !== void 0 ? refHash : headRef.hash;
+		const outcome = planSpacePath({
+			space,
 			aggregate,
-			targetHash: memberTargetHash,
-			refInvariants: isAppMember && refHash !== void 0 ? refInvariants : void 0,
-			liveMarker: markerRows.get(member.spaceId) ?? null,
-			...isAppMember ? { refName } : {}
+			targetHash: spaceTargetHash,
+			refInvariants: isAppSpace && refHash !== void 0 ? refInvariants : void 0,
+			liveMarker: markerRows.get(space.spaceId) ?? null,
+			...isAppSpace ? { refName } : {}
 		});
 		if (outcome.kind === "at-head") {
-			atHeadResolutions.set(member.spaceId, outcome.plan);
+			atHeadResolutions.set(space.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 structural = findPathWithDecision(outcome.targetSpace.graph(), outcome.liveHash, spaceTargetHash, { required: /* @__PURE__ */ new Set() });
 			const structuralPath = structural.kind === "ok" ? structural.decision.selectedPath.map((edge) => ({
 				dirName: edge.dirName,
 				migrationHash: edge.migrationHash,
@@ -823,7 +809,7 @@ async function executeMigrate(options) {
 				structuralPath
 			});
 		}
-		perSpacePlans.set(member.spaceId, outcome.plan);
+		perSpacePlans.set(space.spaceId, outcome.plan);
 	}
 	const canonicalOrder = [...aggregate.extensions.map((m) => m.spaceId), aggregate.app.spaceId];
 	const applyOrder = canonicalOrder.filter((spaceId) => perSpacePlans.has(spaceId));
@@ -892,7 +878,7 @@ async function executeMigrate(options) {
 	}));
 }
 /**
-* Compute the graph-walk path for one contract-space member.
+* Compute the graph-walk path for one contract space.
 *
 * Encapsulates the invariant-correct input assembly that both
 * `executeMigrate` and `executeMigrateShowCommand` must use:
@@ -901,48 +887,48 @@ async function executeMigrate(options) {
 * - `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
+* Both callers map the returned `SpacePathOutcome` 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) {
+function planSpacePath({ space, aggregate, targetHash, refInvariants, liveMarker, refName }) {
+	const isAppSpace = space.spaceId === aggregate.app.spaceId;
+	const headRef = requireHeadRef(space);
+	if (space.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,
+				space,
 				targetHash,
 				liveMarker
 			})
 		};
 		return {
 			kind: "never-planned",
-			spaceId: member.spaceId,
+			spaceId: space.spaceId,
 			targetHash
 		};
 	}
-	const targetInvariants = isAppMember && refInvariants !== void 0 ? refInvariants : headRef.invariants;
-	const targetMember = targetHash === headRef.hash && targetInvariants === headRef.invariants ? member : {
-		...member,
+	const targetInvariants = isAppSpace && refInvariants !== void 0 ? refInvariants : headRef.invariants;
+	const targetSpace = targetHash === headRef.hash && targetInvariants === headRef.invariants ? space : {
+		...space,
 		headRef: {
 			hash: targetHash,
 			invariants: targetInvariants
 		}
 	};
-	const walked = graphWalkStrategy({
+	const walked = resolveRecordedPath({
 		aggregateTargetId: aggregate.targetId,
-		member: targetMember,
+		space: targetSpace,
 		currentMarker: liveMarker,
-		...isAppMember && refName !== void 0 ? { refName } : {}
+		...isAppSpace && refName !== void 0 ? { refName } : {}
 	});
 	if (walked.kind === "unreachable") return {
 		kind: "unreachable",
-		spaceId: member.spaceId,
+		spaceId: space.spaceId,
 		liveMarker,
 		targetHash
 	};
@@ -950,11 +936,11 @@ function planMemberPath({ member, aggregate, targetHash, refInvariants, liveMark
 		const liveHash = liveMarker?.storageHash ?? EMPTY_CONTRACT_HASH;
 		return {
 			kind: "unsatisfiable",
-			spaceId: member.spaceId,
-			isAppMember,
+			spaceId: space.spaceId,
+			isAppSpace,
 			missing: walked.missing,
 			targetInvariants,
-			targetMember,
+			targetSpace,
 			liveHash,
 			refName
 		};
@@ -966,26 +952,26 @@ function planMemberPath({ member, aggregate, targetHash, refInvariants, liveMark
 }
 /**
 * 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`
+* space whose live marker already matches the target. Lets the apply
+* pipeline thread the space through `perSpacePlans` -> `applyOrder`
 * -> the success envelope's `perSpace[]` block so the result reflects
 * every loaded space, even when there is nothing to execute.
 */
 function buildAtHeadResolution(args) {
-	const { aggregateTargetId, member, targetHash, liveMarker } = args;
+	const { aggregateTargetId, space, targetHash, liveMarker } = args;
 	return {
 		plan: {
 			targetId: aggregateTargetId,
-			spaceId: member.spaceId,
+			spaceId: space.spaceId,
 			origin: liveMarker === null ? null : { storageHash: liveMarker.storageHash },
 			destination: { storageHash: targetHash },
 			operations: [],
 			providedInvariants: []
 		},
 		displayOps: [],
-		destinationContract: member.contract(),
-		strategy: "graph-walk",
-		migrationEdges: [buildSynthMigrationEdge({
+		destinationContract: space.contract(),
+		strategy: "declared-state",
+		migrationEdges: [buildFabricatedMigrationEdge({
 			currentMarkerStorageHash: liveMarker?.storageHash,
 			destinationStorageHash: targetHash,
 			operationCount: 0
@@ -1494,16 +1480,15 @@ 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,
+				composedExtensionContracts: stack.extensionContracts,
 				scalarTypeDescriptors: stack.scalarTypeDescriptors,
 				authoringContributions: stack.authoringContributions,
 				codecLookup: stack.codecLookup,
 				controlMutationDefaults: stack.controlMutationDefaults,
-				resolvedInputs: contractConfig.source.inputs ?? []
+				resolvedInputs: contractConfig.source.inputs ?? [],
+				capabilities: stack.capabilities
 			};
 			const providerResult = await contractConfig.source.load(sourceContext);
 			if (!providerResult.ok) {
@@ -1558,9 +1543,10 @@ var ControlClientImpl = class {
 		});
 		try {
 			const enrichedIR = enrichContract(contractRaw, this.frameworkComponents ?? []);
+			const rawContractJson = this.options.target.contractSerializer.serializeContract(enrichedIR);
 			let deserializedContract;
 			try {
-				deserializedContract = this.familyInstance.deserializeContract(enrichedIR);
+				deserializedContract = this.familyInstance.deserializeContract(rawContractJson);
 			} catch (error) {
 				onProgress?.({
 					action: "emit",
@@ -1606,6 +1592,6 @@ var ControlClientImpl = class {
 	}
 };
 //#endregion
-export { executeDbInit as a, executeDbUpdate as i, planMemberPath as n, ContractValidationError as o, executeDbVerify as r, createControlClient as t };
+export { executeDbInit as a, executeDbUpdate as i, planSpacePath as n, ContractValidationError as o, executeDbVerify as r, createControlClient as t };
 
-//# sourceMappingURL=client-CJzuo5wX.mjs.map
+//# sourceMappingURL=client-DigVI8zX.mjs.map