@prisma-next/cli 0.14.0-dev.4 → 0.14.0-dev.40

package/src/control-api/operations/db-run.ts

@@ -98,9 +98,9 @@ export interface ExecuteRunOptions<TFamilyId extends string, TTargetId extends s
  * 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
+ *    space according to `callerPolicy.ignoreGraphFor`. The app space
  *    is forced through synth (today's daily-driver behaviour); every
- *    extension member walks its on-disk graph.
+ *    extension space walks its on-disk graph.
  * 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
@@ -200,7 +200,7 @@ export async function executeRun<TFamilyId extends string, TTargetId extends str
   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.',
+      'Aggregate planner returned no plan for the app space — the planner is supposed to always emit one.',
     );
   }
   const appPlan = appResolution.entry.plan;
@@ -280,14 +280,14 @@ function aggregatePlannerWarnings(
 
 /**
  * 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.
@@ -296,13 +296,13 @@ function detectOrphanMarkers(
   aggregate: ContractSpaceAggregate,
   markerRows: ReadonlyMap<string, unknown>,
 ): CliStructuredError | null {
-  const memberSpaceIds = new Set<string>([
+  const aggregateSpaceIds = new Set<string>([
     aggregate.app.spaceId,
     ...aggregate.extensions.map((m) => m.spaceId),
   ]);
   const orphans: string[] = [];
   for (const [spaceId, row] of markerRows) {
-    if (row !== null && row !== undefined && !memberSpaceIds.has(spaceId)) {
+    if (row !== null && row !== undefined && !aggregateSpaceIds.has(spaceId)) {
       orphans.push(spaceId);
     }
   }

package/src/control-api/operations/db-verify.ts

@@ -7,13 +7,13 @@ import type {
   VerifyDatabaseSchemaResult,
 } from '@prisma-next/framework-components/control';
 import {
-  type ContractSpaceMember,
+  type AggregateContractSpace,
   collectAggregateNamespaces,
   requireHeadRef,
   type VerifierOutput,
   verifyMigration,
 } from '@prisma-next/migration-tools/aggregate';
-import { blindCast, castAs } from '@prisma-next/utils/casts';
+import { castAs } from '@prisma-next/utils/casts';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { CliStructuredError } from '../../utils/cli-errors';
 import {
@@ -37,9 +37,9 @@ const SPAN_IDS = {
  *
  * Loader → verifier pipeline. The loader (sole descriptor-import
  * boundary) builds a {@link import('@prisma-next/migration-tools/aggregate').ContractSpaceAggregate};
- * the aggregate verifier bundles `markerCheck` + per-space pre-projected
- * `schemaCheck`. `mode: 'strict' | 'lenient'` maps directly to the user
- * facing `--strict` flag.
+ * the aggregate verifier bundles `markerCheck` + per-space `schemaCheck`
+ * (each contract space verified against the full schema; extras stripped to its own view).
+ * `mode: 'strict' | 'lenient'` maps directly to the user facing `--strict` flag.
  */
 export interface ExecuteDbVerifyOptions<TFamilyId extends string, TTargetId extends string> {
   readonly driver: ControlDriverInstance<TFamilyId, TTargetId>;
@@ -63,13 +63,19 @@ export interface ExecuteDbVerifyOptions<TFamilyId extends string, TTargetId exte
  * emitted, so downstream tooling and integration tests assert on the
  * same shape).
  *
- * On success, the per-space schema results are returned for the CLI to
+ * On success, the per-space verify results are returned for the CLI to
  * render. When `skipSchema` is true (`--marker-only`), the schema map
  * is empty.
  */
 export interface ExecuteDbVerifySuccess {
   readonly schemaResults: ReadonlyMap<string, VerifyDatabaseSchemaResult>;
-  readonly memberOrder: readonly string[];
+  /**
+   * Live element names no contract space declares, deduplicated and reported
+   * once for the whole database (never per space). Strict mode fails on a
+   * non-empty list; lenient mode surfaces it informationally.
+   */
+  readonly unclaimed: readonly string[];
+  readonly spaceOrder: readonly string[];
   readonly appSpaceId: string;
 }
 
@@ -85,11 +91,11 @@ export type ExecuteDbVerifyResult = Result<ExecuteDbVerifySuccess, CliStructured
  *    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.
  */
 export async function executeDbVerify<TFamilyId extends string, TTargetId extends string>(
   options: ExecuteDbVerifyOptions<TFamilyId, TTargetId>,
@@ -115,7 +121,7 @@ export async function executeDbVerify<TFamilyId extends string, TTargetId extend
     markersBySpaceId,
     schemaIntrospection,
     mode: options.mode,
-    verifySchemaForMember: createPerMemberVerifier(options),
+    verifySchemaForSpace: createPerSpaceVerifier(options),
   });
   return finaliseVerifyResult({ verifyResult, aggregate, skipMarker, onProgress });
 }
@@ -166,30 +172,27 @@ async function runIntrospection<TFamilyId extends string, TTargetId extends stri
 }
 
 /**
- * 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.
  */
-export function createPerMemberVerifier<TFamilyId extends string, TTargetId extends string>(
+export function createPerSpaceVerifier<TFamilyId extends string, TTargetId extends string>(
   options: ExecuteDbVerifyOptions<TFamilyId, TTargetId>,
 ): (
-  projectedSchema: unknown,
-  member: ContractSpaceMember,
+  schema: unknown,
+  space: AggregateContractSpace,
   verifyMode: 'strict' | 'lenient',
 ) => VerifyDatabaseSchemaResult {
   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(),
-      // The family's `TSchemaIR` is opaque to migration-tools; the
-      // aggregate verifier passes through whatever we hand it. The
-      // family expects its own IR shape on the way back.
-      schema: blindCast<
-        never,
-        'family TSchemaIR is opaque to migration-tools; projectedSchema is passed straight through'
-      >(projectedSchema),
+      contract: space.contract(),
+      // `familyInstance` is `ControlFamilyInstance<_, unknown>`, so `verifySchema`
+      // takes its `TSchemaIR` as `unknown` — the introspected schema passes
+      // straight through; the family narrows to its own IR node internally.
+      schema,
       strict: verifyMode === 'strict',
       frameworkComponents,
     });
@@ -223,7 +226,7 @@ function emitVerifySpan(
  * by the CLI's `--schema-only` mode.
  */
 function finaliseVerifyResult(args: {
-  verifyResult: VerifierOutput<VerifyDatabaseSchemaResult>;
+  verifyResult: VerifierOutput;
   aggregate: {
     readonly app: { readonly spaceId: string };
     readonly extensions: ReadonlyArray<{ readonly spaceId: string }>;
@@ -253,14 +256,15 @@ 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: ContractSpaceMember): VerifyDatabaseSchemaResult {
-  const contract = member.contract();
-  const headRef = requireHeadRef(member);
+function buildSkippedSchemaResult(space: AggregateContractSpace): VerifyDatabaseSchemaResult {
+  const contract = space.contract();
+  const headRef = requireHeadRef(space);
   const profileHash = castAs<{ profileHash?: string }>(contract).profileHash;
   return {
     ok: true,
@@ -272,10 +276,11 @@ function buildSkippedSchemaResult(member: ContractSpaceMember): VerifyDatabaseSc
     target: { expected: contract.target },
     schema: {
       issues: [],
+      schemaDiffIssues: [],
       root: {
         status: 'pass',
         kind: 'skipped',
-        name: member.spaceId,
+        name: space.spaceId,
         contractPath: '',
         code: 'SKIPPED',
         message: 'Schema verification skipped',

package/src/control-api/operations/format.ts

@@ -1,13 +1,12 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { EOL } from 'node:os';
+import { loadConfig } from '@prisma-next/config-loader';
 import { type FormatOptions, format, PslFormatError } from '@prisma-next/psl-parser/format';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
-import { loadConfig } from '../../config-loader';
 import { CliStructuredError, errorRuntime, errorUnexpected } from '../../utils/cli-errors';
 
 export interface FormatOperationOptions {
   readonly configPath?: string;
-  /** Injected at the CLI boundary so the formatter engine never reads `os`. */
   readonly eol?: string;
 }
 

package/src/control-api/operations/migrate.ts

@@ -1,5 +1,5 @@
 /**
- * Backs the `migrate` command. Strategy: graph-walk-all-members, replay-only (no introspect/synth/planner).
+ * Backs the `migrate` command. Strategy: graph-walk-all-spaces, replay-only (no introspect/synth/planner).
  */
 
 import type { Contract } from '@prisma-next/contract/types';
@@ -11,10 +11,10 @@ import type {
   TargetMigrationsCapability,
 } from '@prisma-next/framework-components/control';
 import {
+  type AggregateContractSpace,
   buildSynthMigrationEdge,
   type ContractMarkerRecordLike,
   type ContractSpaceAggregate,
-  type ContractSpaceMember,
   graphWalkStrategy,
   type PerSpacePlan,
   requireHeadRef,
@@ -62,8 +62,8 @@ export interface ExecuteMigrateOptions<TFamilyId extends string, TTargetId exten
   readonly extensionPacks: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
   readonly targetId: TTargetId;
   /**
-   * Optional app-space ref override. When provided, the app member's
-   * graph-walk targets this hash instead of `member.headRef.hash`.
+   * Optional app-space ref override. When provided, the app space's
+   * graph-walk targets this hash instead of `space.headRef.hash`.
    * Extensions are unaffected — they always walk to their own head.
    */
   readonly refHash?: string;
@@ -72,7 +72,7 @@ export interface ExecuteMigrateOptions<TFamilyId extends string, TTargetId exten
    * Threaded into the graph-walk's `required` calculation so the
    * planner picks an invariant-bearing path and surfaces the
    * required/satisfied set on the success envelope. When `refHash`
-   * is absent the file's `member.headRef.invariants` are used.
+   * is absent the file's `space.headRef.invariants` are used.
    */
   readonly refInvariants?: readonly string[];
   /**
@@ -89,16 +89,16 @@ export interface ExecuteMigrateOptions<TFamilyId extends string, TTargetId exten
 /**
  * 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: `graphWalkStrategy` 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
@@ -140,41 +140,41 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
 
   const markerRows = await familyInstance.readAllMarkers({ driver });
 
-  // Plan every member via graph-walk. App member targets `refHash`
+  // Plan every space via graph-walk. App space targets `refHash`
   // when provided, otherwise its own head; extensions always walk
   // to their own head ref.
-  const allMembers: ReadonlyArray<ContractSpaceMember> = [aggregate.app, ...aggregate.extensions];
+  const allSpaces: ReadonlyArray<AggregateContractSpace> = [aggregate.app, ...aggregate.extensions];
   const perSpacePlans = new Map<string, PerSpacePlan>();
-  // Already-at-head empty-graph members (typically extensions whose
+  // Already-at-head empty-graph spaces (typically extensions whose
   // head ref is the empty sentinel, or whose live marker already
   // matches the target). Kept out of the runner schedule so we don't
   // write spurious markers for greenfield extensions, but merged back
-  // into the success envelope so every loaded member is represented.
+  // into the success envelope so every loaded space is represented.
   const atHeadResolutions = new Map<string, PerSpacePlan>();
-  for (const member of allMembers) {
-    const isAppMember = member.spaceId === aggregate.app.spaceId;
-    // The aggregate passed the integrity gate, so every member's head ref
+  for (const space of allSpaces) {
+    const isAppSpace = space.spaceId === aggregate.app.spaceId;
+    // The aggregate passed the integrity gate, so every space's head ref
     // is resolved (the app's is synthesised from the live contract).
-    const headRef = requireHeadRef(member);
-    const memberTargetHash = isAppMember && refHash !== undefined ? refHash : headRef.hash;
-    const memberRefInvariants = isAppMember && refHash !== undefined ? refInvariants : undefined;
-    const liveMarker = markerRows.get(member.spaceId) ?? null;
+    const headRef = requireHeadRef(space);
+    const spaceTargetHash = isAppSpace && refHash !== undefined ? refHash : headRef.hash;
+    const spaceRefInvariants = isAppSpace && refHash !== undefined ? refInvariants : undefined;
+    const liveMarker = markerRows.get(space.spaceId) ?? null;
 
-    const outcome = planMemberPath({
-      member,
+    const outcome = planSpacePath({
+      space,
       aggregate,
-      targetHash: memberTargetHash,
-      refInvariants: memberRefInvariants,
+      targetHash: spaceTargetHash,
+      refInvariants: spaceRefInvariants,
       liveMarker,
-      ...(isAppMember ? { refName } : {}),
+      ...(isAppSpace ? { refName } : {}),
     });
 
     if (outcome.kind === 'at-head') {
-      // Empty-graph member whose live marker already matches the target.
+      // Empty-graph space whose live marker already matches the target.
       // Kept out of the runner schedule so we don't write spurious markers
       // for greenfield extensions, but merged back into the success envelope
-      // so every loaded member is represented.
-      atHeadResolutions.set(member.spaceId, outcome.plan);
+      // so every loaded space is represented.
+      atHeadResolutions.set(space.spaceId, outcome.plan);
       continue;
     }
     if (outcome.kind === 'never-planned') {
@@ -197,9 +197,9 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
       // is never a graph node, producing an empty `structuralPath` and
       // a less actionable diagnostic.
       const structural = findPathWithDecision(
-        outcome.targetMember.graph(),
+        outcome.targetSpace.graph(),
         outcome.liveHash,
-        memberTargetHash,
+        spaceTargetHash,
         { required: new Set<string>() },
       );
       const structuralPath =
@@ -220,14 +220,14 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
       });
     }
 
-    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));
 
   // Short-circuit: nothing pending across any space (no runner-bound
-  // plans). Surfaces every loaded member — including at-head empty-
+  // plans). Surfaces every loaded space — including at-head empty-
   // graph extensions — in `perSpace[]` so the result reflects the
   // full aggregate, not just the spaces the runner would have touched.
   const totalPlannedOps = sumPlannedOps(applyOrder, perSpacePlans);
@@ -285,7 +285,7 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
   }
 
   // Merge at-head zero-op resolutions back into the canonical order
-  // so the success envelope surfaces every loaded member, not just
+  // so the success envelope surfaces every loaded space, not just
   // those the runner executed.
   const orderedAll = canonicalOrder
     .filter((spaceId) => perSpacePlans.has(spaceId) || atHeadResolutions.has(spaceId))
@@ -321,7 +321,7 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
 }
 
 /**
- * Outcome variants for one member's path computation.
+ * Outcome variants for one space's path computation.
  *
  * Callers switch on `kind` and map to their own error representation:
  * `executeMigrate` throws / returns `notOk`; `executeMigrateShowCommand`
@@ -330,7 +330,7 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
  *
  * @internal Exported for `executeMigrateShowCommand` to call.
  */
-export type MemberPathOutcome =
+export type SpacePathOutcome =
   | { readonly kind: 'ok'; readonly plan: PerSpacePlan }
   | { readonly kind: 'at-head'; readonly plan: PerSpacePlan }
   | { readonly kind: 'never-planned'; readonly spaceId: string; readonly targetHash: string }
@@ -343,16 +343,16 @@ export type MemberPathOutcome =
   | {
       readonly kind: 'unsatisfiable';
       readonly spaceId: string;
-      readonly isAppMember: boolean;
+      readonly isAppSpace: boolean;
       readonly missing: readonly string[];
       readonly targetInvariants: readonly string[];
-      readonly targetMember: ContractSpaceMember;
+      readonly targetSpace: AggregateContractSpace;
       readonly liveHash: string;
       readonly refName: string | undefined;
     };
 
 /**
- * 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:
@@ -361,71 +361,71 @@ export type MemberPathOutcome =
  * - `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`.
  */
-export function planMemberPath({
-  member,
+export function planSpacePath({
+  space,
   aggregate,
   targetHash,
   refInvariants,
   liveMarker,
   refName,
 }: {
-  readonly member: ContractSpaceMember;
+  readonly space: AggregateContractSpace;
   readonly aggregate: Pick<ContractSpaceAggregate, 'targetId' | 'app'>;
   readonly targetHash: string;
   readonly refInvariants: readonly string[] | undefined;
   readonly liveMarker: ContractMarkerRecordLike | null;
   readonly refName?: string;
-}): MemberPathOutcome {
-  const isAppMember = member.spaceId === aggregate.app.spaceId;
-  const headRef = requireHeadRef(member);
+}): SpacePathOutcome {
+  const isAppSpace = space.spaceId === aggregate.app.spaceId;
+  const headRef = requireHeadRef(space);
 
-  if (member.graph().nodes.size === 0) {
+  if (space.graph().nodes.size === 0) {
     const liveHash = liveMarker?.storageHash;
     if (targetHash === liveHash || (liveHash === undefined && targetHash === EMPTY_CONTRACT_HASH)) {
       return {
         kind: 'at-head',
         plan: buildAtHeadResolution({
           aggregateTargetId: aggregate.targetId,
-          member,
+          space,
           targetHash,
           liveMarker,
         }),
       };
     }
-    return { kind: 'never-planned', spaceId: member.spaceId, targetHash };
+    return { kind: 'never-planned', spaceId: space.spaceId, targetHash };
   }
 
   const targetInvariants =
-    isAppMember && refInvariants !== undefined ? refInvariants : headRef.invariants;
-  const targetMember: ContractSpaceMember =
+    isAppSpace && refInvariants !== undefined ? refInvariants : headRef.invariants;
+  const targetSpace: AggregateContractSpace =
     targetHash === headRef.hash && targetInvariants === headRef.invariants
-      ? member
-      : { ...member, headRef: { hash: targetHash, invariants: targetInvariants } };
+      ? space
+      : { ...space, headRef: { hash: targetHash, invariants: targetInvariants } };
 
   const walked = graphWalkStrategy({
     aggregateTargetId: aggregate.targetId,
-    member: targetMember,
+    space: targetSpace,
     currentMarker: liveMarker,
-    ...(isAppMember && refName !== undefined ? { refName } : {}),
+    ...(isAppSpace && refName !== undefined ? { refName } : {}),
   });
 
   if (walked.kind === 'unreachable') {
-    return { kind: 'unreachable', spaceId: member.spaceId, liveMarker, targetHash };
+    return { kind: 'unreachable', spaceId: space.spaceId, liveMarker, targetHash };
   }
   if (walked.kind === 'unsatisfiable') {
     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,
     };
@@ -435,29 +435,29 @@ export function planMemberPath({
 
 /**
  * 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: {
   readonly aggregateTargetId: string;
-  readonly member: ContractSpaceMember;
+  readonly space: AggregateContractSpace;
   readonly targetHash: string;
   readonly liveMarker: ContractMarkerRecordLike | null;
 }): PerSpacePlan {
-  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(),
+    destinationContract: space.contract(),
     strategy: 'graph-walk',
     migrationEdges: [
       buildSynthMigrationEdge({
@@ -494,7 +494,7 @@ interface BuildSuccessArgs {
 }
 
 function buildSuccess(args: BuildSuccessArgs): MigrateSuccess {
-  // The marker hash surfaced at the top level is the **app member's**
+  // The marker hash surfaced at the top level is the **app space's**
   // post-migrate marker (the top-level `markerHash` field).
   // Per-space markers live on `perSpace[].marker.storageHash`.
   const appResolution = args.orderedResolutions.find(
@@ -586,7 +586,7 @@ export function buildPathNotFoundFailure(
   const fromHash = marker?.storageHash ?? '<empty>';
   // The app-case phrasing names the user-visible condition (a
   // contract has been emitted that no on-disk migration reaches) so
-  // the error reads naturally for the app member. Extension spaces
+  // the error reads naturally for the app space. Extension spaces
   // see the same condition expressed against the offending space.
   const summary =
     spaceId === 'app'

package/src/control-api/operations/run-migration.ts

@@ -48,7 +48,7 @@ export interface RunMigrationInputs<TFamilyId extends string, TTargetId extends
    * {@link planMigration} pipeline (`db init` / `db update` — synth
    * for the app, graph-walk for extensions) or by direct
    * {@link graphWalkStrategy} calls (`migrate` — graph-walk
-   * for every member). Either way, the runner consumes the same shape.
+   * for every contract space). Either way, the runner consumes the same shape.
    */
   readonly perSpacePlans: ReadonlyMap<string, PerSpacePlan>;
   /**
@@ -229,7 +229,7 @@ export function buildPerSpaceBreakdown(
 
 /**
  * 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

package/src/control-api/types.ts

@@ -557,9 +557,9 @@ export interface MigrateOptions {
   /** Migrations root directory (`migrations/` under the project). */
   readonly migrationsDir: string;
   /**
-   * Optional app-space ref override. When provided, the app member's
+   * Optional app-space ref override. When provided, the app space's
    * graph-walk targets this hash instead of `contract.storage.storageHash`.
-   * Extension members always walk to their own `headRef.hash`.
+   * Extension spaces always walk to their own `headRef.hash`.
    */
   readonly refHash?: string;
   /**
@@ -631,17 +631,17 @@ export interface MigrateRanEntry {
 
 /**
  * Successful migrate result. Carries both the top-level fields
- * (`markerHash` is the **app member's** post-migrate marker) and the
+ * (`markerHash` is the **app space's** post-migrate marker) and the
  * per-space breakdown (`perSpace` — markers / operations in canonical
  * schedule order).
  */
 /**
- * Path-decision summary for the **app member** post-migrate. Surfaced
+ * Path-decision summary for the **app space** post-migrate. Surfaced
  * at the top level (and consumed by the cli-journeys suite, which
  * inspects `requiredInvariants`/`satisfiedInvariants`/
  * `selectedPath` to validate invariant routing).
  *
- * Per-space path decisions for extension members are not surfaced —
+ * Per-space path decisions for extension spaces are not surfaced —
  * extensions own their own ref/invariant control.
  */
 export interface MigratePathDecision {
@@ -673,7 +673,7 @@ export interface MigrateSuccess {
    */
   readonly perSpace: ReadonlyArray<PerSpaceExecutionEntry>;
   /**
-   * Path-decision data for the app member. Present whenever the
+   * Path-decision data for the app space. Present whenever the
    * graph-walk strategy ran for the app (i.e. always for the
    * aggregate-walking migrate path). Absent only for the no-op
    * "Already up to date" early return when the app has no plan.
@@ -864,7 +864,7 @@ export interface ControlClient {
    *   markers, and (unless `skipSchema` is true) per-space schema
    *   verification with pre-projection (closes F23).
    *
-   * @returns Result pattern: per-space schema results on success;
+   * @returns Result pattern: per-space verify results on success;
    *          structured CLI error on marker / loader failure.
    * @throws If not connected or infrastructure failure
    */

package/src/migration-cli.ts

@@ -45,6 +45,7 @@
 import { readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import type { Writable } from 'node:stream';
 import { fileURLToPath } from 'node:url';
+import { loadConfig } from '@prisma-next/config-loader';
 import {
   CliStructuredError,
   errorMigrationCliInvalidConfigArg,
@@ -57,7 +58,6 @@ import type { MigrationMetadata } from '@prisma-next/migration-tools/metadata';
 import { buildMigrationArtifacts, type Migration } from '@prisma-next/migration-tools/migration';
 import { Cli, Command, Option, UsageError } from 'clipanion';
 import { dirname, join } from 'pathe';
-import { loadConfig } from './config-loader';
 
 /**
  * Constructor shape accepted by `MigrationCLI.run`. `Migration` subclasses