@prisma-next/cli 0.11.0 → 0.12.0

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/contract-emit.ts

@@ -5,7 +5,7 @@ import { createControlStack } from '@prisma-next/framework-components/control';
 import { abortable } from '@prisma-next/utils/abortable';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { JsonObject } from '@prisma-next/utils/json';
-import { dirname } from 'pathe';
+import { dirname, join } from 'pathe';
 import { loadConfig } from '../../config-loader';
 import { errorContractConfigMissing, errorRuntime } from '../../utils/cli-errors';
 import { queueEmitByOutput } from '../../utils/emit-queue';
@@ -153,7 +153,7 @@ function validateProviderResult(providerResult: unknown): ValidatedProviderResul
 export async function executeContractEmit(
   options: ContractEmitOptions,
 ): Promise<ContractEmitResult> {
-  const { configPath, signal = new AbortController().signal, onProgress } = options;
+  const { configPath, outputPath, signal = new AbortController().signal, onProgress } = options;
   const unlessAborted = abortable(signal);
 
   const config = await unlessAborted(loadConfig(configPath));
@@ -166,7 +166,10 @@ export async function executeContractEmit(
 
   const contractConfig = config.contract;
 
-  if (!contractConfig.output) {
+  const effectiveOutput =
+    outputPath !== undefined ? join(outputPath, 'contract.json') : contractConfig.output;
+
+  if (!effectiveOutput) {
     throw errorContractConfigMissing({
       why: 'Contract config must have output path. This should not happen if defineConfig() was used.',
     });
@@ -180,7 +183,7 @@ export async function executeContractEmit(
 
   let outputPaths: ReturnType<typeof getEmittedArtifactPaths>;
   try {
-    outputPaths = getEmittedArtifactPaths(contractConfig.output);
+    outputPaths = getEmittedArtifactPaths(effectiveOutput);
   } catch (error) {
     throw errorContractConfigMissing({
       why: error instanceof Error ? error.message : String(error),
@@ -250,13 +253,18 @@ export async function executeContractEmit(
       // on-disk JSON envelope is constructed by target-owned code
       // rather than by walking the in-memory contract with
       // `Object.entries` (which would leak runtime-only class API
-      // fields into the persisted shape).
+      // fields into the persisted shape). The optional `shouldPreserveEmpty`
+      // and `sortStorage` hooks let the family contribute storage-specific
+      // canonicalization rules without the framework importing family code.
+      const { contractSerializer } = config.target;
       const serializeContract = (c: Contract): JsonObject =>
-        config.target.contractSerializer.serializeContract(c);
+        contractSerializer.serializeContract(c);
       emitResult = await unlessAborted(
         emit(enrichedIR, stack, config.family.emission, {
           outputJsonPath,
           serializeContract,
+          ...ifDefined('shouldPreserveEmpty', contractSerializer.shouldPreserveEmpty),
+          ...ifDefined('sortStorage', contractSerializer.sortStorage),
         }),
       );
     } catch (error) {

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,12 @@ import type {
   VerifyDatabaseSchemaResult,
 } from '@prisma-next/framework-components/control';
 import {
-  type AggregateVerifierOutput,
   type ContractSpaceMember,
-  verifyAggregate,
+  requireHeadRef,
+  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';
 import { CliStructuredError } from '../../utils/cli-errors';
 import {
@@ -82,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
@@ -102,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,
@@ -162,7 +164,7 @@ async function runIntrospection<TFamilyId extends string, TTargetId extends stri
  * `ok` result so the verifier still runs the (cheap) schemaCheck loop
  * without invoking the family's verification path.
  */
-function createPerMemberVerifier<TFamilyId extends string, TTargetId extends string>(
+export function createPerMemberVerifier<TFamilyId extends string, TTargetId extends string>(
   options: ExecuteDbVerifyOptions<TFamilyId, TTargetId>,
 ): (
   projectedSchema: unknown,
@@ -173,7 +175,7 @@ function createPerMemberVerifier<TFamilyId extends string, TTargetId extends str
   return (projectedSchema, member, verifyMode) => {
     if (skipSchema) return buildSkippedSchemaResult(member);
     return familyInstance.verifySchema({
-      contract: member.contract,
+      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.
@@ -206,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 }>;
@@ -247,15 +249,17 @@ function finaliseVerifyResult(args: {
 }
 
 function buildSkippedSchemaResult(member: ContractSpaceMember): VerifyDatabaseSchemaResult {
-  const profileHash = (member.contract as { profileHash?: string }).profileHash;
+  const contract = member.contract();
+  const headRef = requireHeadRef(member);
+  const profileHash = castAs<{ profileHash?: string }>(contract).profileHash;
   return {
     ok: true,
     summary: 'Schema verification skipped',
     contract: {
-      storageHash: member.headRef.hash,
+      storageHash: headRef.hash,
       ...(profileHash ? { profileHash } : {}),
     },
-    target: { expected: member.contract.target },
+    target: { expected: contract.target },
     schema: {
       issues: [],
       root: {