@prisma-next/cli 0.11.0-dev.65 → 0.11.0-dev.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/cli",
-  "version": "0.11.0-dev.65",
+  "version": "0.11.0-dev.67",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -14,15 +14,15 @@
   "dependencies": {
     "@clack/prompts": "^1.4.0",
     "@dagrejs/dagre": "^3.0.0",
-    "@prisma-next/config": "0.11.0-dev.65",
-    "@prisma-next/contract": "0.11.0-dev.65",
-    "@prisma-next/emitter": "0.11.0-dev.65",
-    "@prisma-next/errors": "0.11.0-dev.65",
-    "@prisma-next/framework-components": "0.11.0-dev.65",
-    "@prisma-next/migration-tools": "0.11.0-dev.65",
-    "@prisma-next/psl-printer": "0.11.0-dev.65",
-    "@prisma-next/cli-telemetry": "0.11.0-dev.65",
-    "@prisma-next/utils": "0.11.0-dev.65",
+    "@prisma-next/config": "0.11.0-dev.67",
+    "@prisma-next/contract": "0.11.0-dev.67",
+    "@prisma-next/emitter": "0.11.0-dev.67",
+    "@prisma-next/errors": "0.11.0-dev.67",
+    "@prisma-next/framework-components": "0.11.0-dev.67",
+    "@prisma-next/migration-tools": "0.11.0-dev.67",
+    "@prisma-next/psl-printer": "0.11.0-dev.67",
+    "@prisma-next/cli-telemetry": "0.11.0-dev.67",
+    "@prisma-next/utils": "0.11.0-dev.67",
     "arktype": "^2.2.0",
     "c12": "^3.3.4",
     "ci-info": "^4.3.1",
@@ -39,14 +39,14 @@
     "wrap-ansi": "^10.0.0"
   },
   "devDependencies": {
-    "@prisma-next/sql-contract": "0.11.0-dev.65",
-    "@prisma-next/sql-contract-emitter": "0.11.0-dev.65",
-    "@prisma-next/sql-contract-ts": "0.11.0-dev.65",
-    "@prisma-next/sql-operations": "0.11.0-dev.65",
-    "@prisma-next/sql-runtime": "0.11.0-dev.65",
-    "@prisma-next/test-utils": "0.11.0-dev.65",
-    "@prisma-next/tsconfig": "0.11.0-dev.65",
-    "@prisma-next/tsdown": "0.11.0-dev.65",
+    "@prisma-next/sql-contract": "0.11.0-dev.67",
+    "@prisma-next/sql-contract-emitter": "0.11.0-dev.67",
+    "@prisma-next/sql-contract-ts": "0.11.0-dev.67",
+    "@prisma-next/sql-operations": "0.11.0-dev.67",
+    "@prisma-next/sql-runtime": "0.11.0-dev.67",
+    "@prisma-next/test-utils": "0.11.0-dev.67",
+    "@prisma-next/tsconfig": "0.11.0-dev.67",
+    "@prisma-next/tsdown": "0.11.0-dev.67",
     "@types/node": "25.6.0",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",

package/src/commands/migrate.ts

@@ -11,9 +11,9 @@ import { Command } from 'commander';
 import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import type {
-  AggregatePerSpaceExecutionEntry,
   MigrationApplyFailure,
   MigrationApplyPathDecision,
+  PerSpaceExecutionEntry,
 } from '../control-api/types';
 import {
   CliStructuredError,
@@ -75,7 +75,7 @@ export interface MigrateResult {
     readonly operationsExecuted: number;
   }[];
   readonly summary: string;
-  readonly perSpace: readonly AggregatePerSpaceExecutionEntry[];
+  readonly perSpace: readonly PerSpaceExecutionEntry[];
   readonly pathDecision?: MigrationApplyPathDecision;
   readonly timings: {
     readonly total: number;

package/src/commands/migration-plan.ts

@@ -186,7 +186,7 @@ export interface MigrationPlanResult {
    *
    * Surfacing these in the result (rather than only via `ui.step` log
    * lines) makes the cross-space side effect explicit to JSON consumers
-   * and the success-summary renderer — the same multi-space side effect
+   * and the success-summary renderer — the same cross-space side effect
    * that `migrate` will replay.
    */
   readonly emittedExtensionDirs: readonly { readonly spaceId: string; readonly dirName: string }[];

package/src/commands/migration-status.ts

@@ -190,10 +190,9 @@ export interface MigrationStatusResult {
    * migrations directory) where the existing diagnostics already
    * surface the failure.
    *
-   * The legacy top-level fields (`migrations`, `markerHash`,
-   * `targetHash`, `pathDecision`, …) describe the **app member**
-   * specifically — back-compat with single-space callers. Per-space
-   * detail for extension members lives only on this list.
+   * The top-level fields (`migrations`, `markerHash`, `targetHash`,
+   * `pathDecision`, …) describe the **app member** specifically.
+   * Per-space detail for extension members lives only on this list.
    */
   readonly spaces?: readonly MigrationStatusSpaceEntry[];
   /** Cross-space pending-migration total (sum of `spaces[].pendingCount`). Present when `spaces` is. */
@@ -430,13 +429,12 @@ function resolveDisplayChain(
 /**
  * Build the aggregate enumeration of contract spaces for the status
  * output. Loads the aggregate from disk (lossy on failure — extension
- * spaces are simply omitted, the existing single-space app behaviour
- * keeps working), reads per-space marker rows when online, and uses
+ * spaces are simply omitted, the app member's output keeps working),
+ * reads per-space marker rows when online, and uses
  * {@link graphWalkStrategy} to compute each space's pending count.
  *
- * Sub-spec § `migration status` semantics — the aggregate-walking
- * version reports per-space marker + pending state alongside the
- * cross-space totals.
+ * The aggregate-walking status reports per-space marker + pending
+ * state alongside the cross-space totals.
  */
 export async function loadAggregateStatusSpaces(args: {
   readonly aggregate: ContractSpaceAggregate;
@@ -452,8 +450,7 @@ export async function loadAggregateStatusSpaces(args: {
   ) {
     // Full integrity refusal (drift, layout violation, etc.) — surfacing
     // it as a status diagnostic would duplicate `migration plan`'s job.
-    // The single-space app pipeline still runs; extensions are simply
-    // not enumerated.
+    // The app pipeline still runs; extensions are simply not enumerated.
     return [];
   }
   const aggregate = args.aggregate;
@@ -795,8 +792,8 @@ async function executeMigrationStatusCommand(
       mode = 'online';
       // Read every space's marker so the aggregate enumeration can
       // surface per-space marker state. `readAllMarkers` mirrors what
-      // `db init` / `db update` already use to drive the multi-space
-      // planner; here it powers the aggregate status output.
+      // `db init` / `db update` already use to drive the planner;
+      // here it powers the aggregate status output.
       //
       // Probe for the method first so we only swallow the
       // unsupported-method case: older family instances may not
@@ -1258,7 +1255,7 @@ export function formatStatusSummary(result: MigrationStatusResult, colorize: boo
   }
 
   // Per-space section. Suppressed when there's no extension space —
-  // the legacy single-space output already covers the app member.
+  // the top-level output already covers the app member.
   // When extensions exist, render every space (including the app)
   // for consistency, plus a cross-space pending total + apply hint.
   if (result.spaces?.some((s) => s.kind === 'extension')) {

package/src/control-api/operations/{apply-aggregate.ts → apply.ts}

@@ -3,19 +3,12 @@ import type {
   ControlDriverInstance,
   ControlFamilyInstance,
   MigrationOperationPolicy,
-  MultiSpaceCapableRunner,
-  MultiSpaceRunnerPerSpaceOptions,
   TargetMigrationsCapability,
 } from '@prisma-next/framework-components/control';
-import { hasMultiSpaceRunner } from '@prisma-next/framework-components/control';
-import type {
-  AggregatePerSpacePlan,
-  ContractSpaceAggregate,
-} from '@prisma-next/migration-tools/aggregate';
+import type { ContractSpaceAggregate, PerSpacePlan } from '@prisma-next/migration-tools/aggregate';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
-import { errorRunnerFailed } from '../../utils/cli-errors';
-import type { AggregatePerSpaceExecutionEntry, OnControlProgress } from '../types';
+import type { OnControlProgress, PerSpaceExecutionEntry } from '../types';
 
 /**
  * Span id emitted via `onProgress` for the apply phase. Stable
@@ -28,35 +21,35 @@ const APPLY_SPAN_ID = 'apply' as const;
  * events so the parent CLI command can attribute the span correctly,
  * and used to compose action-specific summary phrasing.
  */
-export type AggregateApplyAction = 'dbInit' | 'dbUpdate' | 'migrationApply';
+export type ApplyAction = 'dbInit' | 'dbUpdate' | 'migrationApply';
 
 /**
- * Failure variant emitted by {@link applyAggregate} when the multi-space
- * runner itself rejects the apply. Mirrors the failure shape callers
+ * Failure variant emitted by {@link applyMigration} when the runner
+ * itself rejects the apply. Mirrors the failure shape callers
  * already wrap into their own action-specific failure envelopes
  * (`DbInitFailure`, `DbUpdateFailure`, `MigrationApplyFailure`) so each
  * caller keeps owning its own discriminated failure code.
  */
-export interface AggregateApplyRunnerFailure {
+export interface ApplyRunnerFailure {
   readonly summary: string;
   readonly why?: string;
   readonly meta: Record<string, unknown>;
 }
 
-export interface ApplyAggregateInputs<TFamilyId extends string, TTargetId extends string> {
+export interface ApplyMigrationInputs<TFamilyId extends string, TTargetId extends string> {
   readonly aggregate: ContractSpaceAggregate;
   /**
    * Per-space plans, keyed by `spaceId`. Produced by either the full
-   * {@link planAggregate} pipeline (`db init` / `db update` — synth
+   * {@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.
    */
-  readonly perSpacePlans: ReadonlyMap<string, AggregatePerSpacePlan>;
+  readonly perSpacePlans: ReadonlyMap<string, PerSpacePlan>;
   /**
    * Canonical schedule order — extensions alphabetically by `spaceId`,
    * then app. Mirrors {@link import('@prisma-next/migration-tools/concatenate-space-apply-inputs').concatenateSpaceApplyInputs}'s
-   * convention so `MultiSpaceRunnerFailure.failingSpace` attribution
+   * convention so `MigrationRunnerFailure.failingSpace` attribution
    * stays byte-for-byte stable across callers.
    */
   readonly applyOrder: readonly string[];
@@ -69,22 +62,22 @@ export interface ApplyAggregateInputs<TFamilyId extends string, TTargetId extend
   >;
   readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;
   readonly policy: MigrationOperationPolicy;
-  readonly action: AggregateApplyAction;
+  readonly action: ApplyAction;
   readonly onProgress?: OnControlProgress;
 }
 
 /**
  * Resolved per-space plan in canonical schedule order. Surfaced from
- * {@link applyAggregate} to callers so each one can build its own
+ * {@link applyMigration} to callers so each one can build its own
  * action-specific success envelope (e.g. `DbInitSuccess` vs
  * `MigrationApplySuccess`) without re-deriving the ordering.
  */
 export interface OrderedResolution {
   readonly spaceId: string;
-  readonly entry: AggregatePerSpacePlan;
+  readonly entry: PerSpacePlan;
 }
 
-export interface ApplyAggregateValue {
+export interface ApplyMigrationValue {
   readonly orderedResolutions: readonly OrderedResolution[];
   readonly totalOpsPlanned: number;
   readonly totalOpsExecuted: number;
@@ -93,30 +86,30 @@ export interface ApplyAggregateValue {
    * envelopes. Each entry carries the post-apply marker (live storage hash
    * plus invariants) so callers can render it directly without re-reading.
    */
-  readonly perSpace: readonly AggregatePerSpaceExecutionEntry[];
+  readonly perSpace: readonly PerSpaceExecutionEntry[];
 }
 
-export type ApplyAggregateResult = Result<ApplyAggregateValue, AggregateApplyRunnerFailure>;
+export type ApplyMigrationResult = Result<ApplyMigrationValue, ApplyRunnerFailure>;
 
 /**
- * Runner-driving tail shared by every aggregate apply caller — `db init`,
+ * Runner-driving tail shared by every apply caller — `db init`,
  * `db update`, and `migrate`. Consumes already-resolved per-space
  * plans (the planner-vs-replay distinction is owned by the caller) and
- * dispatches them to the multi-space runner in canonical order.
+ * dispatches them to the runner in canonical order.
  *
  * Marker advancement is part of the runner's per-space transaction
  * (the SQL family runner writes the marker as the last step of each
  * space's transaction), so this primitive does not advance markers
- * separately — by the time `executeAcrossSpaces` returns ok, every
+ * separately — by the time `execute` returns ok, every
  * space's marker has been advanced to its plan's destination.
  *
  * Span emission (`spanStart 'apply'` / `spanEnd 'apply'`) is owned here
  * so callers don't have to duplicate it; the `action` field on each
  * progress event is taken from the caller's `action` argument.
  */
-export async function applyAggregate<TFamilyId extends string, TTargetId extends string>(
-  inputs: ApplyAggregateInputs<TFamilyId, TTargetId>,
-): Promise<ApplyAggregateResult> {
+export async function applyMigration<TFamilyId extends string, TTargetId extends string>(
+  inputs: ApplyMigrationInputs<TFamilyId, TTargetId>,
+): Promise<ApplyMigrationResult> {
   const {
     aggregate,
     perSpacePlans,
@@ -133,14 +126,6 @@ export async function applyAggregate<TFamilyId extends string, TTargetId extends
   const orderedResolutions = collectOrdered(applyOrder, perSpacePlans);
 
   const runner = migrations.createRunner(familyInstance);
-  if (!hasMultiSpaceRunner(runner)) {
-    throw errorRunnerFailed(
-      `Runner for target "${aggregate.targetId}" does not implement \`executeAcrossSpaces\``,
-      {
-        why: `${labelForAction(action)} requires multi-space-capable runners (today: every SQL family runner).`,
-      },
-    );
-  }
 
   onProgress?.({
     action,
@@ -149,26 +134,21 @@ export async function applyAggregate<TFamilyId extends string, TTargetId extends
     label: progressLabelForAction(action),
   });
 
-  const perSpaceOptions: MultiSpaceRunnerPerSpaceOptions<TFamilyId, TTargetId>[] =
-    orderedResolutions.map((r) => ({
-      space: r.spaceId,
-      plan: r.entry.plan,
-      driver,
-      destinationContract: r.entry.destinationContract,
-      policy,
-      frameworkComponents,
-      // Per-space post-apply schema verification is non-strict: each
-      // space's `destinationContract` describes only its own slice; a
-      // strict verifier would treat every other space's tables as
-      // `extras`. Tolerant mode still catches missing tables / columns.
-      // SQL family runners read `strictVerification` via structural
-      // typing.
-      strictVerification: false,
-    })) as MultiSpaceRunnerPerSpaceOptions<TFamilyId, TTargetId>[];
+  const perSpaceOptions = orderedResolutions.map((r) => ({
+    space: r.spaceId,
+    plan: r.entry.plan,
+    driver,
+    destinationContract: r.entry.destinationContract,
+    policy,
+    frameworkComponents,
+    // Per-space post-apply schema verification is non-strict: each
+    // space's `destinationContract` describes only its own slice; a
+    // strict verifier would treat every other space's tables as
+    // `extras`. Tolerant mode still catches missing tables / columns.
+    strictVerification: false,
+  }));
 
-  const runnerResult = await (
-    runner as MultiSpaceCapableRunner<TFamilyId, TTargetId>
-  ).executeAcrossSpaces({ driver, perSpaceOptions });
+  const runnerResult = await runner.execute({ driver, perSpaceOptions });
 
   if (!runnerResult.ok) {
     onProgress?.({ action, kind: 'spanEnd', spanId: APPLY_SPAN_ID, outcome: 'error' });
@@ -207,28 +187,28 @@ export async function applyAggregate<TFamilyId extends string, TTargetId extends
 
 /**
  * Project the planner's per-space resolutions into the
- * `AggregatePerSpaceExecutionEntry[]` shape the CLI surfaces.
+ * `PerSpaceExecutionEntry[]` shape the CLI surfaces.
  *
  * `includeMarkers` is `true` for apply-mode (each space's marker is
  * the `destination.storageHash` of its plan, which the runner
  * advances as the last step of each space's transaction) and `false`
  * for plan-mode (no marker has been written yet).
  *
- * Exported alongside {@link applyAggregate} so plan-mode callers can
+ * Exported alongside {@link applyMigration} so plan-mode callers can
  * assemble the same per-space block without going through the runner.
  */
 export function buildPerSpaceBreakdown(
   orderedResolutions: readonly OrderedResolution[],
   appSpaceId: string,
   options: { readonly includeMarkers: boolean },
-): readonly AggregatePerSpaceExecutionEntry[] {
+): readonly PerSpaceExecutionEntry[] {
   return orderedResolutions.map((r) => {
     const operations = r.entry.displayOps.map((op) => ({
       id: op.id,
       label: op.label,
       operationClass: op.operationClass,
     }));
-    const base: AggregatePerSpaceExecutionEntry = {
+    const base: PerSpaceExecutionEntry = {
       spaceId: r.spaceId,
       kind: r.spaceId === appSpaceId ? 'app' : 'extension',
       operations,
@@ -251,12 +231,12 @@ export function buildPerSpaceBreakdown(
  */
 export function collectOrdered(
   applyOrder: readonly string[],
-  perSpace: ReadonlyMap<string, AggregatePerSpacePlan>,
+  perSpace: ReadonlyMap<string, PerSpacePlan>,
 ): readonly OrderedResolution[] {
   return applyOrder.map((spaceId) => {
     const entry = perSpace.get(spaceId);
     if (!entry) {
-      throw new Error(`Aggregate planner output missing per-space plan for "${spaceId}"`);
+      throw new Error(`planner output missing per-space plan for "${spaceId}"`);
     }
     return { spaceId, entry };
   });
@@ -264,11 +244,11 @@ export function collectOrdered(
 
 /**
  * Action-appropriate label for the `spanStart` event the apply
- * primitive emits. `applyAggregate` is shared by `db init`, `db update`,
+ * primitive emits. `applyMigration` is shared by `db init`, `db update`,
  * and `migrate`; the span label tracks the user-visible action
  * so structured-progress output reads naturally for each surface.
  */
-export function progressLabelForAction(action: AggregateApplyAction): string {
+export function progressLabelForAction(action: ApplyAction): string {
   switch (action) {
     case 'dbInit':
       return 'Initialising database across spaces';
@@ -278,14 +258,3 @@ export function progressLabelForAction(action: AggregateApplyAction): string {
       return 'Applying migration plan across spaces';
   }
 }
-
-function labelForAction(action: AggregateApplyAction): string {
-  switch (action) {
-    case 'dbInit':
-      return 'db init';
-    case 'dbUpdate':
-      return 'db update';
-    case 'migrationApply':
-      return 'migrate';
-  }
-}

package/src/control-api/operations/{db-apply-aggregate.ts → db-apply.ts}

@@ -11,9 +11,9 @@ import type {
 } from '@prisma-next/framework-components/control';
 import { hasOperationPreview } from '@prisma-next/framework-components/control';
 import {
-  type AggregatePlannerError,
   type ContractSpaceAggregate,
-  planAggregate,
+  type PlannerError,
+  planMigration,
 } from '@prisma-next/migration-tools/aggregate';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
@@ -23,7 +23,6 @@ import {
   buildContractSpaceAggregate,
 } from '../../utils/contract-space-aggregate-loader';
 import type {
-  AggregatePerSpaceExecutionEntry,
   DbInitFailure,
   DbInitResult,
   DbInitSuccess,
@@ -31,15 +30,16 @@ import type {
   DbUpdateResult,
   DbUpdateSuccess,
   OnControlProgress,
+  PerSpaceExecutionEntry,
 } from '../types';
-import { applyAggregate, buildPerSpaceBreakdown, collectOrdered } from './apply-aggregate';
+import { applyMigration, buildPerSpaceBreakdown, collectOrdered } from './apply';
 import { stripOperations } from './migration-helpers';
 
 /**
- * Span IDs emitted via `onProgress` during the aggregate apply flow.
+ * Span IDs emitted via `onProgress` during the apply flow.
  * Stable identifiers consumed by the structured-output renderer and by
  * tests asserting on span ids. The `apply` span itself is owned by
- * the {@link applyAggregate} primitive — only the introspect / plan
+ * the {@link applyMigration} primitive — only the introspect / plan
  * spans are emitted directly here.
  */
 const SPAN_IDS = {
@@ -48,13 +48,13 @@ const SPAN_IDS = {
 } as const;
 
 /**
- * Inputs shared by `db init` and `db update` aggregate apply flows.
+ * Inputs shared by `db init` and `db update` apply flows.
  *
  * Accepts the already-validated app contract + descriptor list — the
  * loader gathers the rest from disk + descriptors. The CLI is the
  * descriptor-import boundary; everything downstream is descriptor-free.
  */
-export interface ExecuteAggregateApplyOptions<TFamilyId extends string, TTargetId extends string> {
+export interface ExecuteApplyOptions<TFamilyId extends string, TTargetId extends string> {
   readonly driver: ControlDriverInstance<TFamilyId, TTargetId>;
   readonly familyInstance: ControlFamilyInstance<TFamilyId, unknown>;
   readonly contract: Contract;
@@ -83,17 +83,17 @@ export interface ExecuteAggregateApplyOptions<TFamilyId extends string, TTargetI
  *    integrity violation short-circuits with a structured error.
  * 2. **Read DB state**: marker rows (`familyInstance.readAllMarkers`)
  *    + introspected schema (`familyInstance.introspect`).
- * 3. **Plan**: {@link planAggregate} chooses graph-walk vs synth per
+ * 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.
  * 4. **Apply** (when `mode === 'apply'`): every per-space `MigrationPlan`
- *    feeds into the runner's `executeAcrossSpaces` — one outer
+ *    feeds into the runner's `execute` — one outer
  *    transaction across every space; failure on any space rolls back
  *    every space's writes.
  */
-export async function executeAggregateApply<TFamilyId extends string, TTargetId extends string>(
-  options: ExecuteAggregateApplyOptions<TFamilyId, TTargetId>,
+export async function executeApply<TFamilyId extends string, TTargetId extends string>(
+  options: ExecuteApplyOptions<TFamilyId, TTargetId>,
 ): Promise<DbInitResult | DbUpdateResult> {
   const {
     driver,
@@ -159,7 +159,7 @@ export async function executeAggregateApply<TFamilyId extends string, TTargetId
     spanId: SPAN_IDS.plan,
     label: 'Planning migration',
   });
-  const planResult = await planAggregate<TFamilyId, TTargetId>({
+  const planResult = await planMigration<TFamilyId, TTargetId>({
     aggregate,
     currentDBState: { markersBySpaceId: markerRows, schemaIntrospection: schemaIR },
     familyInstance,
@@ -205,13 +205,13 @@ export async function executeAggregateApply<TFamilyId extends string, TTargetId
     });
   }
 
-  // 5. Apply mode: hand off to the shared `applyAggregate` primitive.
+  // 5. Apply mode: hand off to the shared `applyMigration` primitive.
   // The runner-driving tail is identical for `db init` / `db update` /
   // `migrate` — only how each caller produces `perSpacePlans`
-  // differs (synth + graph-walk via planAggregate here; graph-walk
+  // differs (synth + graph-walk via planMigration here; graph-walk
   // only for migrate). Each caller produces perSpacePlans differently;
   // this helper handles the shared apply tail.
-  const applied = await applyAggregate({
+  const applied = await applyMigration({
     aggregate,
     perSpacePlans: planResult.value.perSpace,
     applyOrder: planResult.value.applyOrder,
@@ -298,7 +298,7 @@ function detectOrphanMarkers(
   });
 }
 
-function mapPlannerError(error: AggregatePlannerError): DbInitResult | DbUpdateResult {
+function mapPlannerError(error: PlannerError): DbInitResult | DbUpdateResult {
   if (error.kind === 'appSynthFailure') {
     const failure: DbInitFailure | DbUpdateFailure = {
       code: 'PLANNING_FAILED',
@@ -337,7 +337,7 @@ function wrapPlanResult(args: {
   readonly operations: readonly MigrationPlanOperation[];
   readonly destination: { readonly storageHash: string; readonly profileHash?: string };
   readonly preview: OperationPreview | undefined;
-  readonly perSpace: readonly AggregatePerSpaceExecutionEntry[];
+  readonly perSpace: readonly PerSpaceExecutionEntry[];
   readonly summary: string;
 }): DbInitResult | DbUpdateResult {
   const success: DbInitSuccess | DbUpdateSuccess = {
@@ -361,7 +361,7 @@ function wrapApplyResult(args: {
   readonly destination: { readonly storageHash: string; readonly profileHash?: string };
   readonly operationsPlanned: number;
   readonly operationsExecuted: number;
-  readonly perSpace: readonly AggregatePerSpaceExecutionEntry[];
+  readonly perSpace: readonly PerSpaceExecutionEntry[];
   readonly summary: string;
 }): DbInitResult | DbUpdateResult {
   const success: DbInitSuccess | DbUpdateSuccess = {

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

@@ -8,20 +8,20 @@ import type {
 } from '@prisma-next/framework-components/control';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { DbInitResult, OnControlProgress } from '../types';
-import { executeAggregateApply } from './db-apply-aggregate';
+import { executeApply } from './db-apply';
 
 /**
  * Options for executing the `db init` operation.
  *
  * `db init` runs the loader → planner → runner pipeline:
  *
- * 1. {@link executeAggregateApply} loads a `ContractSpaceAggregate` via
+ * 1. {@link executeApply} loads a `ContractSpaceAggregate` via
  *    {@link import('@prisma-next/migration-tools/aggregate').loadContractSpaceAggregate}
  *    from the supplied descriptor set + on-disk on-disk artefacts.
  * 2. The aggregate planner runs with `callerPolicy.ignoreGraphFor`
  *    locked to the app member — synth strategy for the app, graph-walk
  *    for every extension.
- * 3. The runner's `executeAcrossSpaces` applies the per-space plans
+ * 3. The runner's `execute` applies the per-space plans
  *    inside one outer transaction.
  *
  * `extensionPacks` mirrors `Config.extensionPacks` (descriptor list).
@@ -68,7 +68,7 @@ export interface ExecuteDbInitOptions<TFamilyId extends string, TTargetId extend
 export async function executeDbInit<TFamilyId extends string, TTargetId extends string>(
   options: ExecuteDbInitOptions<TFamilyId, TTargetId>,
 ): Promise<DbInitResult> {
-  const result = await executeAggregateApply<TFamilyId, TTargetId>({
+  const result = await executeApply<TFamilyId, TTargetId>({
     driver: options.driver,
     familyInstance: options.familyInstance,
     contract: options.contract,

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

@@ -9,7 +9,7 @@ import type {
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk } from '@prisma-next/utils/result';
 import type { DbUpdateResult, OnControlProgress } from '../types';
-import { executeAggregateApply } from './db-apply-aggregate';
+import { executeApply } from './db-apply';
 
 const DB_UPDATE_POLICY = {
   allowedOperationClasses: ['additive', 'widening', 'destructive'] as const,
@@ -71,7 +71,7 @@ export async function executeDbUpdate<TFamilyId extends string, TTargetId extend
     const gate = await guardDestructiveChanges<TFamilyId, TTargetId>(sharedInputs);
     if (gate !== null) return gate;
   }
-  return (await executeAggregateApply<TFamilyId, TTargetId>({
+  return (await executeApply<TFamilyId, TTargetId>({
     ...sharedInputs,
     mode: options.mode,
   })) as DbUpdateResult;
@@ -85,9 +85,9 @@ export async function executeDbUpdate<TFamilyId extends string, TTargetId extend
  * run.
  */
 async function guardDestructiveChanges<TFamilyId extends string, TTargetId extends string>(
-  sharedInputs: Omit<Parameters<typeof executeAggregateApply<TFamilyId, TTargetId>>[0], 'mode'>,
+  sharedInputs: Omit<Parameters<typeof executeApply<TFamilyId, TTargetId>>[0], 'mode'>,
 ): Promise<DbUpdateResult | null> {
-  const planResult = (await executeAggregateApply<TFamilyId, TTargetId>({
+  const planResult = (await executeApply<TFamilyId, TTargetId>({
     ...sharedInputs,
     mode: 'plan',
   })) as DbUpdateResult;

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

@@ -7,10 +7,10 @@ import type {
   VerifyDatabaseSchemaResult,
 } from '@prisma-next/framework-components/control';
 import {
-  type AggregateVerifierOutput,
   type ContractSpaceMember,
   requireHeadRef,
-  verifyAggregate,
+  type VerifierOutput,
+  verifyMigration,
 } from '@prisma-next/migration-tools/aggregate';
 import { castAs } from '@prisma-next/utils/casts';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
@@ -84,7 +84,7 @@ export type ExecuteDbVerifyResult = Result<ExecuteDbVerifySuccess, CliStructured
  *    structured CLI error.
  * 2. **Read DB state**: marker rows + (when `skipSchema` is `false`)
  *    schema introspection.
- * 3. **Verify**: {@link verifyAggregate} returns per-space
+ * 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
@@ -104,7 +104,7 @@ export async function executeDbVerify<TFamilyId extends string, TTargetId extend
     : await runIntrospection({ driver, familyInstance, onProgress });
 
   emitVerifySpan(onProgress, 'spanStart');
-  const verifyResult = verifyAggregate({
+  const verifyResult = verifyMigration({
     aggregate,
     markersBySpaceId,
     schemaIntrospection,
@@ -208,12 +208,12 @@ function emitVerifySpan(
 }
 
 /**
- * Map an {@link AggregateVerifierOutput} to the operation's
+ * Map an {@link VerifierOutput} to the operation's
  * {@link ExecuteDbVerifyResult}, applying the `skipMarker` policy used
  * by the CLI's `--schema-only` mode.
  */
 function finaliseVerifyResult(args: {
-  verifyResult: AggregateVerifierOutput<VerifyDatabaseSchemaResult>;
+  verifyResult: VerifierOutput<VerifyDatabaseSchemaResult>;
   aggregate: {
     readonly app: { readonly spaceId: string };
     readonly extensions: ReadonlyArray<{ readonly spaceId: string }>;