@prisma-next/cli 0.14.0-dev.5 → 0.14.0-dev.50

package/src/commands/db-verify.ts

@@ -1,10 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { loadConfig } from '@prisma-next/config-loader';
 import type { Contract } from '@prisma-next/contract/types';
-import type {
-  VerifyDatabaseResult,
-  VerifyDatabaseSchemaResult,
-} from '@prisma-next/framework-components/control';
+import type { VerifyDatabaseResult } from '@prisma-next/framework-components/control';
 import {
   createControlStack,
   VERIFY_CODE_HASH_MISMATCH,
@@ -29,7 +26,7 @@ import {
   errorTargetMismatch,
   errorUnexpected,
 } from '../utils/cli-errors';
-import { combineSchemaResults } from '../utils/combine-schema-results';
+import { type CombinedVerifyResult, combineVerifyResults } from '../utils/combine-verify-results';
 import {
   addGlobalOptions,
   maskConnectionUrl,
@@ -103,7 +100,7 @@ function mapVerifyFailure(verifyResult: VerifyDatabaseResult): CliStructuredErro
   return errorRuntime(verifyResult.summary);
 }
 
-type DbVerifyFailure = CliStructuredError | VerifyDatabaseSchemaResult;
+type DbVerifyFailure = CliStructuredError | CombinedVerifyResult;
 
 function errorInvalidVerifyMode(options: {
   readonly why: string;
@@ -419,12 +416,13 @@ async function executeDbVerifyCommand(
       });
     }
 
-    const combined = combineSchemaResults(
+    const combined = combineVerifyResults(
       aggregateResult.value.schemaResults,
       aggregateResult.value.appSpaceId,
       options.strict ?? false,
+      aggregateResult.value.unclaimed,
     );
-    if (!combined.ok) {
+    if (!combined.result.ok) {
       return notOk(combined);
     }
 
@@ -438,10 +436,11 @@ async function executeDbVerifyCommand(
       ...ifDefined('missingCodecs', verifyResult.missingCodecs),
       ...ifDefined('codecCoverageSkipped', verifyResult.codecCoverageSkipped),
       schema: {
-        summary: combined.summary,
-        counts: combined.schema.counts,
-        strict: combined.meta?.strict ?? false,
+        summary: combined.result.summary,
+        strict: combined.result.meta?.strict ?? false,
+        warnings: (combined.result.schema.warnings?.issues ?? []).map((issue) => issue.message),
       },
+      unclaimed: combined.unclaimed,
       meta: {
         ...(verifyResult.meta ?? {}),
         schemaVerification: 'performed',
@@ -459,7 +458,7 @@ async function executeDbSchemaOnlyVerifyCommand(
   options: DbVerifyOptions,
   flags: GlobalFlags,
   ui: TerminalUI,
-): Promise<Result<VerifyDatabaseSchemaResult, CliStructuredError>> {
+): Promise<Result<CombinedVerifyResult, CliStructuredError>> {
   const paths = await resolveVerifyPaths(options);
   renderVerifyHeader(paths, options, 'schema-only', flags, ui);
 
@@ -484,10 +483,11 @@ async function executeDbSchemaOnlyVerifyCommand(
     if (!aggregateResult.ok) return notOk(aggregateResult.failure);
 
     return ok(
-      combineSchemaResults(
+      combineVerifyResults(
         aggregateResult.value.schemaResults,
         aggregateResult.value.appSpaceId,
         options.strict ?? false,
+        aggregateResult.value.unclaimed,
       ),
     );
   } catch (error) {
@@ -542,18 +542,26 @@ export function createDbVerifyCommand(): Command {
 
       if (mode === 'schema-only') {
         const result = await executeDbSchemaOnlyVerifyCommand(options, flags, ui);
-        const exitCode = handleResult(result, flags, ui, (schemaVerifyResult) => {
+        const exitCode = handleResult(result, flags, ui, (combined) => {
           if (flags.json) {
-            ui.output(formatSchemaVerifyJson(schemaVerifyResult));
+            ui.output(formatSchemaVerifyJson(combined.result, combined.unclaimed));
           } else {
-            const output = formatSchemaVerifyOutput(schemaVerifyResult, flags);
+            // Always show schema-drift failures, even in quiet mode — exiting 1
+            // without diagnostics is unhelpful (same policy as the full-mode
+            // failure branch below).
+            const renderFlags = combined.result.ok ? flags : { ...flags, quiet: false };
+            const output = formatSchemaVerifyOutput(
+              combined.result,
+              renderFlags,
+              combined.unclaimed,
+            );
             if (output) {
               ui.log(output);
             }
           }
         });
 
-        if (result.ok && !result.value.ok) {
+        if (result.ok && !result.value.result.ok) {
           process.exit(1);
         }
 
@@ -580,11 +588,15 @@ export function createDbVerifyCommand(): Command {
       }
 
       if (flags.json) {
-        ui.output(formatSchemaVerifyJson(result.failure));
+        ui.output(formatSchemaVerifyJson(result.failure.result, result.failure.unclaimed));
       } else {
         // Always show schema-drift failures, even in quiet mode — exiting 1 without
         // diagnostics is unhelpful.
-        const output = formatSchemaVerifyOutput(result.failure, { ...flags, quiet: false });
+        const output = formatSchemaVerifyOutput(
+          result.failure.result,
+          { ...flags, quiet: false },
+          result.failure.unclaimed,
+        );
         if (output) {
           ui.log(output);
         }

package/src/commands/lsp.ts

@@ -11,7 +11,9 @@ export function createLspCommand(): Command {
     command,
     'Start the Prisma Next language server',
     'Launches a Language Server Protocol server that publishes PSL parse diagnostics\n' +
-      'for the schema inputs declared in your config (contract.source.inputs).\n' +
+      'and handles whole-document PSL formatting for the schema inputs declared in\n' +
+      'your config (contract.source.inputs). Formatting uses the Prisma Next PSL\n' +
+      'formatter and the formatter block from the project config.\n' +
       'Communicates over stdio; intended to be spawned by an\n' +
       'editor, not run interactively. The server keeps running until the editor client\n' +
       'disconnects.',

package/src/commands/migrate.ts

@@ -2,7 +2,10 @@ import { readFile } from 'node:fs/promises';
 import { loadConfig } from '@prisma-next/config-loader';
 import type { Contract } from '@prisma-next/contract/types';
 import { createControlStack } from '@prisma-next/framework-components/control';
-import { type ContractSpaceMember, requireHeadRef } from '@prisma-next/migration-tools/aggregate';
+import {
+  type AggregateContractSpace,
+  requireHeadRef,
+} from '@prisma-next/migration-tools/aggregate';
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
 import { errorUnknownInvariant, MigrationToolsError } from '@prisma-next/migration-tools/errors';
 import { findLatestMigration, isGraphNode } from '@prisma-next/migration-tools/migration-graph';
@@ -13,7 +16,7 @@ import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { createControlClient } from '../control-api/client';
-import { planMemberPath } from '../control-api/operations/migrate';
+import { planSpacePath } from '../control-api/operations/migrate';
 import type {
   MigrateFailure,
   MigratePathDecision,
@@ -149,8 +152,8 @@ export interface MigrateResult {
  * Computes the path through the SAME seam as `executeMigrate`:
  * - `readAllMarkers()` for the from-state (when no `--from` is given), preserving
  *   the full marker including `invariants` (not just `storageHash`).
- * - `planMemberPath()` (shared with `executeMigrate`) for per-member path selection,
- *   which feeds `graphWalkStrategy()` with the same target hash, target invariants,
+ * - `planSpacePath()` (shared with `executeMigrate`) for per-space path selection,
+ *   which feeds `resolveRecordedPath()` with the same target hash, target invariants,
  *   and current marker as the real apply path uses.
  *
  * Returns BEFORE any write boundary (`runMigration` / marker / DDL). No
@@ -203,7 +206,7 @@ async function executeMigrateShowCommand(
   const appGraph = aggregate.app.graph();
 
   // Resolve the --to target (defaults to the on-disk contract, same as migrate).
-  // Also capture the ref's invariants so planMemberPath feeds graphWalkStrategy the
+  // Also capture the ref's invariants so planSpacePath feeds resolveRecordedPath the
   // same target invariants that real migrate would use (refInvariants ?? headRef.invariants).
   let targetHash: string = contractHash;
   let refInvariants: readonly string[] | undefined;
@@ -258,13 +261,13 @@ async function executeMigrateShowCommand(
   // - Explicit --from: parse it offline (no connection).
   // - Omitted: read the live DB marker via readAllMarkers() — the same source migrate uses.
   //
-  // Full marker records (storageHash + invariants) are preserved so planMemberPath
-  // can feed graphWalkStrategy the complete currentMarker — exactly as executeMigrate
+  // Full marker records (storageHash + invariants) are preserved so planSpacePath
+  // can feed resolveRecordedPath the complete currentMarker — exactly as executeMigrate
   // does via familyInstance.readAllMarkers(). A stripped { storageHash, invariants: [] }
   // marker would produce a different `required` set and a different (incorrect) path.
   type LiveMarker = { readonly storageHash: string; readonly invariants: readonly string[] };
   const markerBySpace = new Map<string, LiveMarker | null>();
-  const allMembers: ReadonlyArray<ContractSpaceMember> = [aggregate.app, ...aggregate.extensions];
+  const allSpaces: ReadonlyArray<AggregateContractSpace> = [aggregate.app, ...aggregate.extensions];
 
   if (hasExplicitFrom) {
     // @db with explicit --from requires a connection
@@ -301,7 +304,7 @@ async function executeMigrateShowCommand(
       } else {
         // Offline hypothetical: the --from ref only carries a hash (no live invariants).
         // Apply the from-hash marker to the APP space only. Extension spaces are left
-        // absent from markerBySpace (treated as null / greenfield by planMemberPath),
+        // absent from markerBySpace (treated as null / greenfield by planSpacePath),
         // so they plan from their own marker → own head — exactly as executeMigrate does.
         const fromHash = fromResult.value.hash;
         const offlineMarker: LiveMarker | null =
@@ -334,9 +337,9 @@ async function executeMigrateShowCommand(
       const allMarkers = await client.readAllMarkers();
       // Store the full marker record (storageHash + invariants) per space.
       // This is the same data executeMigrate uses via familyInstance.readAllMarkers().
-      for (const member of allMembers) {
-        const marker = allMarkers.get(member.spaceId);
-        markerBySpace.set(member.spaceId, marker ?? null);
+      for (const space of allSpaces) {
+        const marker = allMarkers.get(space.spaceId);
+        markerBySpace.set(space.spaceId, marker ?? null);
       }
     } catch (error) {
       if (CliStructuredError.is(error)) {
@@ -355,35 +358,35 @@ async function executeMigrateShowCommand(
     }
   }
 
-  // Walk the path via planMemberPath — the same helper executeMigrate uses.
-  // planMemberPath feeds graphWalkStrategy identical inputs (targetHash, targetInvariants,
+  // Walk the path via planSpacePath — the same helper executeMigrate uses.
+  // planSpacePath feeds resolveRecordedPath identical inputs (targetHash, targetInvariants,
   // currentMarker with full invariants), so the preview path is always the path migrate runs.
   //
   // Canonical schedule order: extensions alphabetically first, then app — mirroring the
   // runner's `applyOrder` in operations/migrate.ts so the "Will run, in order:" list
   // reflects the actual execution sequence (extensions install first, app last).
-  const canonicalOrderMembers: ReadonlyArray<ContractSpaceMember> = [
+  const canonicalOrderSpaces: ReadonlyArray<AggregateContractSpace> = [
     ...aggregate.extensions,
     aggregate.app,
   ];
   const orderedMigrations: MigrateShowMigration[] = [];
-  for (const member of canonicalOrderMembers) {
-    const isAppMember = member.spaceId === aggregate.app.spaceId;
-    const headRef = requireHeadRef(member);
-    const memberTargetHash = isAppMember ? targetHash : headRef.hash;
-    const memberRefInvariants = isAppMember ? refInvariants : undefined;
-    const liveMarker = markerBySpace.get(member.spaceId) ?? null;
-
-    const outcome = planMemberPath({
-      member,
+  for (const space of canonicalOrderSpaces) {
+    const isAppSpace = space.spaceId === aggregate.app.spaceId;
+    const headRef = requireHeadRef(space);
+    const spaceTargetHash = isAppSpace ? targetHash : headRef.hash;
+    const spaceRefInvariants = isAppSpace ? refInvariants : undefined;
+    const liveMarker = markerBySpace.get(space.spaceId) ?? null;
+
+    const outcome = planSpacePath({
+      space,
       aggregate,
-      targetHash: memberTargetHash,
-      refInvariants: memberRefInvariants,
+      targetHash: spaceTargetHash,
+      refInvariants: spaceRefInvariants,
       liveMarker,
     });
 
     if (outcome.kind === 'at-head') {
-      // Empty-graph member already at target — nothing to run for this space.
+      // Empty-graph space already at target — nothing to run for this space.
       continue;
     }
     if (outcome.kind === 'never-planned') {
@@ -417,7 +420,7 @@ async function executeMigrateShowCommand(
 
     for (const edge of outcome.plan.migrationEdges) {
       orderedMigrations.push({
-        spaceId: member.spaceId,
+        spaceId: space.spaceId,
         dirName: edge.dirName,
         migrationHash: edge.migrationHash,
         from: edge.from,
@@ -445,12 +448,12 @@ async function executeMigrateShowCommand(
     // before rendering. This ensures the name column, hash column, and ops column
     // start at the same horizontal offset across every space section AND the
     // "Will run, in order:" list below.
-    const memberLayouts = allMembers.map((member) => {
-      const isApp = member.spaceId === aggregate.app.spaceId;
-      const memberGraph = member.graph();
-      const rowModel = buildMigrationGraphRows(memberGraph, isApp ? { contractHash } : {});
+    const spaceLayouts = allSpaces.map((space) => {
+      const isApp = space.spaceId === aggregate.app.spaceId;
+      const spaceGraph = space.graph();
+      const rowModel = buildMigrationGraphRows(spaceGraph, isApp ? { contractHash } : {});
       const edgeAnnotations = new Map<string, MigrationEdgeAnnotation>();
-      for (const edge of memberGraph.migrationByHash.values()) {
+      for (const edge of spaceGraph.migrationByHash.values()) {
         edgeAnnotations.set(edge.migrationHash, {
           pathHighlight: onPathHashes.has(edge.migrationHash) ? 'on-path' : 'off-path',
         });
@@ -459,17 +462,17 @@ async function executeMigrateShowCommand(
       // green/continuous; off-path lanes dim. Rows, gutter, and labels all come
       // from this one grid.
       const grid = buildGrid(rowModel, {}, highlightFromEdgeAnnotations(edgeAnnotations));
-      return { member, isApp, memberGraph, rowModel, grid, edgeAnnotations };
+      return { space, isApp, spaceGraph, rowModel, grid, edgeAnnotations };
     });
 
     // Global max across all space grids so every section's labels share columns.
     const globalLabelColumn =
-      memberLayouts.length > 1
-        ? Math.max(...memberLayouts.map(({ grid }) => computeLabelColumn(grid, 'unicode')))
+      spaceLayouts.length > 1
+        ? Math.max(...spaceLayouts.map(({ grid }) => computeLabelColumn(grid, 'unicode')))
         : undefined;
     const globalMaxDirNameWidthFromLayouts =
-      memberLayouts.length > 1
-        ? Math.max(...memberLayouts.map(({ rowModel }) => computeMaxDirNameWidth(rowModel)))
+      spaceLayouts.length > 1
+        ? Math.max(...spaceLayouts.map(({ rowModel }) => computeMaxDirNameWidth(rowModel)))
         : undefined;
     // The run-list name column width must be at least as wide as the global tree dirName
     // width so that tree sections and the list align at the hash column.
@@ -485,10 +488,10 @@ async function executeMigrateShowCommand(
     runListLeftPad = globalLabelColumn;
 
     // Render each space section with globally computed widths.
-    const showSpaceHeadings = allMembers.length > 1;
+    const showSpaceHeadings = allSpaces.length > 1;
     const sections: string[] = [];
-    for (const { member, isApp, rowModel, grid, edgeAnnotations } of memberLayouts) {
-      const liveMarker = markerBySpace.get(member.spaceId) ?? null;
+    for (const { space, isApp, rowModel, grid, edgeAnnotations } of spaceLayouts) {
+      const liveMarker = markerBySpace.get(space.spaceId) ?? null;
       const liveMarkerHash = liveMarker?.storageHash ?? EMPTY_CONTRACT_HASH;
       const tree = renderMigrationGraphCommand({
         grid,
@@ -496,7 +499,7 @@ async function executeMigrateShowCommand(
         contractHash,
         isAppSpace: isApp,
         ...(needsLiveMarker ? { dbHash: liveMarkerHash } : {}),
-        refsByHash: listRefsByContractHash(member),
+        refsByHash: listRefsByContractHash(space),
         edgeAnnotationsByHash: edgeAnnotations,
         colorize,
         glyphMode: 'unicode',
@@ -505,7 +508,7 @@ async function executeMigrateShowCommand(
       });
       if (tree.length === 0) continue;
       if (showSpaceHeadings) {
-        sections.push(`${member.spaceId}:\n${indentMigrationGraphTreeBlock(tree, '  ')}`);
+        sections.push(`${space.spaceId}:\n${indentMigrationGraphTreeBlock(tree, '  ')}`);
       } else {
         sections.push(tree);
       }

package/src/commands/migration-check.ts

@@ -156,16 +156,16 @@ export async function enumerateCheckSpaces(
     candidateDirs.filter((name) => !RESERVED_SPACE_SUBDIR_NAMES.has(name)).filter(isValidSpaceId),
   );
   const spaces: CheckSpace[] = [];
-  for (const member of aggregate.spaces()) {
-    const spaceId = member.spaceId;
+  for (const space of aggregate.spaces()) {
+    const spaceId = space.spaceId;
     if (!isValidSpaceId(spaceId)) continue;
     if (!onDiskSpaceIds.has(spaceId)) continue;
     const migrationsDir = spaceMigrationDirectory(projectMigrationsDir, spaceId);
     spaces.push({
       spaceId,
-      packages: member.packages,
-      refs: member.refs,
-      graph: member.graph(),
+      packages: space.packages,
+      refs: space.refs,
+      graph: space.graph(),
       migrationsDir,
       refsDir: spaceRefsDirectory(migrationsDir),
     });

package/src/commands/migration-graph.ts

@@ -154,13 +154,13 @@ export async function executeMigrationGraphCommand(
   const treeSections: MigrationGraphTreeSection[] = [];
   const spaces: MigrationSpaceGraphEntry[] = [];
   for (const spaceEntry of scopedSpaces) {
-    const member = aggregate.space(spaceEntry.space);
-    if (member === undefined) {
+    const space = aggregate.space(spaceEntry.space);
+    if (space === undefined) {
       continue;
     }
-    const graph = member.graph();
+    const graph = space.graph();
     const isAppSpace = spaceEntry.space === aggregate.app.spaceId;
-    const refsByHash = listRefsByContractHash(member);
+    const refsByHash = listRefsByContractHash(space);
     const tree =
       spaceEntry.migrations.length === 0
         ? ''

package/src/commands/migration-list.ts

@@ -1,7 +1,7 @@
 import { loadConfig } from '@prisma-next/config-loader';
 import type {
+  AggregateContractSpace,
   ContractSpaceAggregate,
-  ContractSpaceMember,
 } from '@prisma-next/migration-tools/aggregate';
 import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
 import { HEAD_REF_NAME, refsByContractHash } from '@prisma-next/migration-tools/refs';
@@ -59,18 +59,18 @@ function compareDirNamesDescending(a: MigrationListEntry, b: MigrationListEntry)
 
 /**
  * Ref names decorating a space's destination contract hashes. The
- * tolerant `member.refs` deliberately omits the structural `head.json`;
+ * tolerant `space.refs` deliberately omits the structural `head.json`;
  * for extension spaces the old enumerator surfaced it as a `head`
- * decoration on the tip migration, so fold `member.headRef` back in to
+ * decoration on the tip migration, so fold `space.headRef` back in to
  * keep that output. The app space synthesises its head, so it carries
  * no on-disk `head` ref to restore.
  */
 export function listRefsByContractHash(
-  member: ContractSpaceMember,
+  space: AggregateContractSpace,
 ): ReadonlyMap<string, readonly string[]> {
-  const byHash = new Map(refsByContractHash(member.refs));
-  if (member.spaceId !== APP_SPACE_ID && member.headRef !== null) {
-    const hash = member.headRef.hash;
+  const byHash = new Map(refsByContractHash(space.refs));
+  if (space.spaceId !== APP_SPACE_ID && space.headRef !== null) {
+    const hash = space.headRef.hash;
     const bucket = byHash.get(hash) ?? [];
     if (!bucket.includes(HEAD_REF_NAME)) {
       byHash.set(hash, [...bucket, HEAD_REF_NAME].sort());
@@ -92,7 +92,7 @@ async function orderedOnDiskSpaceIds(projectMigrationsDir: string): Promise<read
  * {@link MigrationSpaceListEntry} rows `migration list` displays.
  *
  * Space membership matches the on-disk contract-space directories (not the
- * aggregate's always-present synthesized app member when `migrations/app/`
+ * aggregate's always-present synthesized app space when `migrations/app/`
  * is absent); package and ref data come from `aggregate.space(id)`.
  */
 export async function migrationSpaceListEntriesFromAggregate(
@@ -103,12 +103,12 @@ export async function migrationSpaceListEntriesFromAggregate(
   const spaces: MigrationSpaceListEntry[] = [];
 
   for (const spaceId of spaceIds) {
-    const member = aggregate.space(spaceId);
-    if (member === undefined) {
+    const space = aggregate.space(spaceId);
+    if (space === undefined) {
       continue;
     }
-    const refsByHash = listRefsByContractHash(member);
-    const migrations: MigrationListEntry[] = member.packages
+    const refsByHash = listRefsByContractHash(space);
+    const migrations: MigrationListEntry[] = space.packages
       .map((pkg) => ({
         name: pkg.dirName,
         hash: pkg.metadata.migrationHash,

package/src/commands/migration-plan.ts

@@ -7,6 +7,7 @@ import {
   hasOperationPreview,
   type MigrationPlanOperation,
   type OperationPreview,
+  type SchemaOwnership,
 } from '@prisma-next/framework-components/control';
 import { canonicalizeJson } from '@prisma-next/framework-components/utils';
 import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
@@ -97,6 +98,7 @@ async function runPlannerLeg(
   contract: Contract,
   fromContract: Contract | null,
   spaceId: string,
+  ownership: SchemaOwnership,
 ): Promise<Result<PlannerSuccess, CliStructuredError>> {
   const fromSchema = migrations.contractToSchema(fromContract, frameworkComponents);
   const plannerResult = planner.plan({
@@ -106,6 +108,12 @@ async function runPlannerLeg(
     fromContract,
     frameworkComponents,
     spaceId,
+    // Offline `migration plan` is the aggregate-of-(possibly one) degenerate
+    // case: the same ownership consultation the live aggregate flow uses. A
+    // from→to extra (a table removed from the contract) is not declared by any
+    // space in the aggregate, so it stays a genuine drop; a table another
+    // space owns is never dropped.
+    ownership,
   });
   if (plannerResult.kind === 'failure') {
     return notOk(
@@ -321,11 +329,11 @@ async function executeMigrationPlanCommand(
   if (!tolerantAggregateResult.ok) {
     return notOk(tolerantAggregateResult.failure);
   }
-  const resolutionMember = tolerantAggregateResult.value.app;
+  const resolutionSpace = tolerantAggregateResult.value.app;
 
   const resolutionResult = await resolveFromForPlan({
     optionsFrom: options.from,
-    member: resolutionMember,
+    space: resolutionSpace,
   });
 
   if (!resolutionResult.ok) {
@@ -365,7 +373,7 @@ async function executeMigrationPlanCommand(
   // change.
   if (options.to !== undefined) {
     const toResolution = await resolveToForPlan(options.to, {
-      member: resolutionMember,
+      space: resolutionSpace,
     });
     if (!toResolution.ok) {
       return notOk(toResolution.failure);
@@ -498,6 +506,7 @@ async function executeMigrationPlanCommand(
         fromContract,
         null,
         aggregate.app.spaceId,
+        aggregate,
       );
       if (!baselineLeg.ok) {
         return notOk(baselineLeg.failure);
@@ -567,6 +576,7 @@ async function executeMigrationPlanCommand(
         aggregate.app.contract(),
         fromContract,
         aggregate.app.spaceId,
+        aggregate,
       );
       if (!deltaLeg.ok) {
         return notOk(deltaLeg.failure);
@@ -640,6 +650,7 @@ async function executeMigrationPlanCommand(
       aggregate.app.contract(),
       fromContract,
       aggregate.app.spaceId,
+      aggregate,
     );
     if (!deltaLeg.ok) {
       return notOk(deltaLeg.failure);

package/src/commands/migration-status.ts

@@ -1,8 +1,8 @@
 import { loadConfig } from '@prisma-next/config-loader';
 import type { LedgerEntryRecord } from '@prisma-next/contract/types';
 import type {
+  AggregateContractSpace,
   ContractMarkerRecordLike,
-  ContractSpaceMember,
 } from '@prisma-next/migration-tools/aggregate';
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
 import {
@@ -130,7 +130,7 @@ function buildStatusMigrations(
 }
 
 function renderSpaceTree(args: {
-  readonly member: ContractSpaceMember;
+  readonly space: AggregateContractSpace;
   readonly liveContractHash: string;
   readonly migrations: readonly MigrationListEntry[];
   readonly markerHash: string | undefined;
@@ -142,7 +142,7 @@ function renderSpaceTree(args: {
   readonly globalMaxEdgeTreePrefixWidth?: number;
   readonly globalMaxDirNameWidth?: number;
 }): string {
-  const graph = args.member.graph();
+  const graph = args.space.graph();
   if (graph.nodes.size === 0) {
     return '';
   }
@@ -150,7 +150,7 @@ function renderSpaceTree(args: {
     graph,
     migrations: args.migrations,
     liveContractHash: args.liveContractHash,
-    refsByHash: listRefsByContractHash(args.member),
+    refsByHash: listRefsByContractHash(args.space),
     statusOverlayByHash: args.statusOverlay,
     colorize: args.colorize,
     glyphMode: args.glyphMode,
@@ -493,12 +493,12 @@ export async function executeMigrationStatusCommand(
     globalLayoutInputs.length > 0 ? computeGlobalMaxDirNameWidth(globalLayoutInputs) : undefined;
 
   for (const spaceEntry of scopedSpaces) {
-    const member = aggregate.space(spaceEntry.space);
-    if (member === undefined) {
+    const space = aggregate.space(spaceEntry.space);
+    if (space === undefined) {
       continue;
     }
-    const graph = member.graph();
-    const spaceContractHash = member.contract().storage.storageHash;
+    const graph = space.graph();
+    const spaceContractHash = space.contract().storage.storageHash;
     const targetHash = resolveTarget(spaceContractHash, activeRefHash);
     if (spaceEntry.space === aggregate.app.spaceId) {
       headlineTargetHash = targetHash;
@@ -547,7 +547,7 @@ export async function executeMigrationStatusCommand(
     });
     const isAppSpace = spaceEntry.space === aggregate.app.spaceId;
     const tree = renderSpaceTree({
-      member,
+      space,
       liveContractHash: contractHash,
       migrations: spaceEntry.migrations,
       markerHash,

package/src/control-api/client.ts

@@ -631,6 +631,7 @@ class ControlClientImpl implements ControlClient {
         codecLookup: stack.codecLookup,
         controlMutationDefaults: stack.controlMutationDefaults,
         resolvedInputs: contractConfig.source.inputs ?? [],
+        capabilities: stack.capabilities,
       };
       const providerResult = await contractConfig.source.load(sourceContext);
       if (!providerResult.ok) {
@@ -696,17 +697,18 @@ class ControlClientImpl implements ControlClient {
       // payload — `enrichContract` only adds capability + extension
       // metadata onto whatever shape it receives. The structural
       // check happens immediately afterwards via
-      // `familyInstance.deserializeContract(enrichedIR)`, which is
-      // the seam-of-record and the only thing that may surface
+      // `familyInstance.deserializeContract`, which is the
+      // seam-of-record and the only thing that may surface
       // structural errors to the caller.
       const enrichedIR = enrichContract(
         contractRaw as unknown as Contract,
         this.frameworkComponents ?? [],
       );
+      const rawContractJson = this.options.target.contractSerializer.serializeContract(enrichedIR);
 
       let deserializedContract: Contract;
       try {
-        deserializedContract = this.familyInstance.deserializeContract(enrichedIR);
+        deserializedContract = this.familyInstance.deserializeContract(rawContractJson);
       } catch (error) {
         onProgress?.({
           action: 'emit',

package/src/control-api/operations/contract-emit.ts

@@ -221,6 +221,7 @@ export async function executeContractEmit(
       codecLookup: stack.codecLookup,
       controlMutationDefaults: stack.controlMutationDefaults,
       resolvedInputs: contractConfig.source.inputs ?? [],
+      capabilities: stack.capabilities,
     };
 
     startSpan(onProgress, 'resolveSource', 'Resolving contract source...');
@@ -258,16 +259,16 @@ export async function executeContractEmit(
       // Blind cast: `validateProviderResult` upstream has already
       // pinned `validatedContract.value` to the provider's loose
       // `Contract` envelope, but the local `Contract` type at this
-      // call site is the precise structural interface. Re-narrowing
-      // the envelope into the precise type is exactly what the
-      // `familyInstance.deserializeContract(enrichedIR)` call on the
-      // next line does — the cast just defers the structural check
-      // by one statement so `enrichContract` can decorate first.
+      // call site is the precise structural interface. The cast just
+      // defers the structural check by one statement so `enrichContract`
+      // can decorate first; the subsequent serialize→deserialize round-trip
+      // re-narrows the envelope into the precise type.
       const enrichedIR = enrichContract(
         validatedContract.value as unknown as Contract,
         frameworkComponents,
       );
-      const deserializedContract = familyInstance.deserializeContract(enrichedIR);
+      const rawContractJson = config.target.contractSerializer.serializeContract(enrichedIR);
+      const deserializedContract = familyInstance.deserializeContract(rawContractJson);
       // Each target's descriptor ships a `contractSerializer` SPI; the
       // framework canonicalizer threads its `serializeContract` so the
       // on-disk JSON envelope is constructed by target-owned code