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

package/src/commands/migrate.ts

@@ -1,7 +1,11 @@
 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';
@@ -11,9 +15,8 @@ import { readRefs } from '@prisma-next/migration-tools/refs';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
-import { loadConfig } from '../config-loader';
 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

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
+import { loadConfig } from '@prisma-next/config-loader';
 import { createControlStack } from '@prisma-next/framework-components/control';
 import type {
   ContractSpaceAggregate,
@@ -25,7 +26,6 @@ import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { join, relative } from 'pathe';
-import { loadConfig } from '../config-loader';
 import {
   type CliStructuredError,
   errorAmbiguousMigrationRef,
@@ -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

@@ -1,9 +1,9 @@
+import { loadConfig } from '@prisma-next/config-loader';
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
 import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
-import { loadConfig } from '../config-loader';
 import type { CliStructuredError } from '../utils/cli-errors';
 import {
   addGlobalOptions,
@@ -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,6 +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';
@@ -13,7 +14,6 @@ import {
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
-import { loadConfig } from '../config-loader';
 import {
   type CliStructuredError,
   errorInvalidSpaceId,
@@ -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-log.ts

@@ -1,9 +1,9 @@
+import { loadConfig } from '@prisma-next/config-loader';
 import type { LedgerEntryRecord } from '@prisma-next/contract/types';
 import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
-import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import {
   CliStructuredError,

package/src/commands/migration-new.ts

@@ -9,6 +9,7 @@
  */
 
 import { readFile } from 'node:fs/promises';
+import { loadConfig } from '@prisma-next/config-loader';
 import type { Contract } from '@prisma-next/contract/types';
 import { getEmittedArtifactPaths } from '@prisma-next/emitter';
 import { APP_SPACE_ID, createControlStack } from '@prisma-next/framework-components/control';
@@ -25,7 +26,6 @@ import { writeMigrationTs } from '@prisma-next/migration-tools/migration-ts';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { join, relative } from 'pathe';
-import { loadConfig } from '../config-loader';
 import {
   CliStructuredError,
   errorFileNotFound,

package/src/commands/migration-plan.ts

@@ -1,4 +1,5 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { loadConfig } from '@prisma-next/config-loader';
 import type { Contract } from '@prisma-next/contract/types';
 import { getEmittedArtifactPaths } from '@prisma-next/emitter';
 import {
@@ -6,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';
@@ -21,7 +23,6 @@ import { writeMigrationTs } from '@prisma-next/migration-tools/migration-ts';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { join, relative } from 'pathe';
-import { loadConfig } from '../config-loader';
 import {
   type CliErrorConflict,
   CliStructuredError,
@@ -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-show.ts

@@ -1,4 +1,5 @@
 import { readFile } from 'node:fs/promises';
+import { loadConfig } from '@prisma-next/config-loader';
 import type { Contract } from '@prisma-next/contract/types';
 import {
   APP_SPACE_ID,
@@ -13,7 +14,6 @@ import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { relative } from 'pathe';
-import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import {
   type CliStructuredError,

package/src/commands/migration-status.ts

@@ -1,7 +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 {
@@ -17,7 +18,6 @@ import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { dim, yellow } from 'colorette';
 import { Command } from 'commander';
-import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import {
   CliStructuredError,
@@ -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/commands/ref.ts

@@ -1,4 +1,5 @@
 import { readFile } from 'node:fs/promises';
+import { loadConfig } from '@prisma-next/config-loader';
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
 import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
 import { findLatestMigration, isGraphNode } from '@prisma-next/migration-tools/migration-graph';
@@ -14,7 +15,6 @@ import {
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { join } from 'pathe';
-import { loadConfig } from '../config-loader';
 import {
   CliStructuredError,
   errorFileNotFound,

package/src/control-api/client.ts

@@ -27,10 +27,10 @@ import {
   hasSchemaView,
 } from '@prisma-next/framework-components/control';
 import type { PslDocumentAst } from '@prisma-next/framework-components/psl-ast';
-import { blindCast } from '@prisma-next/utils/casts';
+
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
-import { toExtensionInputs } from '../utils/extension-pack-inputs';
+
 import { assertFrameworkComponentsCompatible } from '../utils/framework-components';
 import { enrichContract } from './contract-enrichment';
 import { ContractValidationError } from './errors';
@@ -606,31 +606,15 @@ class ControlClientImpl implements ControlClient {
 
     try {
       const stack = this.stack!;
-      const extensionInputs = toExtensionInputs(
-        blindCast<
-          readonly unknown[],
-          'toExtensionInputs accepts readonly unknown[] per its documented structural cast boundary'
-        >(stack.extensionPacks),
-      );
-      const composedExtensionContracts = new Map<string, Contract>(
-        extensionInputs
-          .filter((p) => p.contractSpace !== undefined)
-          .map((p) => [
-            p.id,
-            blindCast<
-              Contract,
-              'contractSpace.contractJson is the typed contract for this extension space'
-            >(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 ?? [],
+        capabilities: stack.capabilities,
       };
       const providerResult = await contractConfig.source.load(sourceContext);
       if (!providerResult.ok) {
@@ -696,17 +680,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',