@prisma/orm-toolchain 8.0.0-rc.1-dev.6 → 8.0.0-rc.1-dev.7

package/dist/cli__control-api.d.mts

@@ -1,6 +1,19 @@
-import { A as SchemaVerifyOptions, C as EmitSuccess, E as IntrospectOptions, M as VerifyOptions, N as executeDbVerify, O as OnControlProgress, S as EmitResult, T as ExecuteDbVerifyResult, _ as DbUpdateSuccess, a as ControlClient, b as EmitFailureCode, c as DbInitFailure, d as DbInitResult, f as DbInitSuccess, g as DbUpdateResult, h as DbUpdateOptions, i as ControlActionName, j as SignOptions, l as DbInitFailureCode, m as DbUpdateFailureCode, n as ContractEmitOptions, o as ControlClientOptions, p as DbUpdateFailure, r as ContractEmitResult, s as ControlProgressEvent, u as DbInitOptions, v as EmitContractConfig, w as ExecuteDbVerifyOptions, x as EmitOptions, y as EmitFailure } from "./types-2n_H3DQ9-Bks8UPEO.mjs";
+import { i as Refs, n as RefEntry } from "./refs-BNCUu58Y-BIso5Jfg.mjs";
+import { n as MigrationGraph } from "./graph-bDjJ4GL9-BhFevsJS.mjs";
+import { r as MigrationRef, t as ContractRef } from "./ref-resolution-COGOSL57.mjs";
+import { A as SchemaVerifyOptions, C as EmitSuccess, E as IntrospectOptions, M as VerifyOptions, N as executeDbVerify, O as OnControlProgress, S as EmitResult, T as ExecuteDbVerifyResult, _ as DbUpdateSuccess, a as ControlClient, b as EmitFailureCode, c as DbInitFailure, d as DbInitResult, f as DbInitSuccess, g as DbUpdateResult, h as DbUpdateOptions, i as ControlActionName, j as SignOptions, l as DbInitFailureCode, m as DbUpdateFailureCode, n as ContractEmitOptions, o as ControlClientOptions, p as DbUpdateFailure, r as ContractEmitResult, s as ControlProgressEvent, t as CliStructuredError$1, u as DbInitOptions, v as EmitContractConfig, w as ExecuteDbVerifyOptions, x as EmitOptions, y as EmitFailure } from "./cli-errors-CDr3WcJP-NFry5GHb.mjs";
+import { n as OnDiskMigrationPackage } from "./package-CfWiDNrr-ZR4HM_Iz.mjs";
+import { c as ContractSpaceAggregate, d as IntegrityQueryOptions, p as IntegrityViolation, t as AggregateContractSpace } from "./aggregate-BflrjWPO.mjs";
+import { i as executeMigrateShowPlan, n as MigrateShowMigration, r as MigrateShowPlanSuccess, t as ExecuteMigrateShowPlanOptions } from "./migrate-show-60NNqVia-oGqMaVA9.mjs";
+import { n as MigrationCheckResult, o as MigrationSpaceGraphEntry, r as MigrationListResult, s as MigrationSpaceListEntry } from "./schemas-CeGMYFYX-h3OcU__O.mjs";
+import { t as CommonCommandOptions } from "./global-flags-BpoOYtNZ-CHZD3fud.mjs";
+import "./package-N9PPdFV_.mjs";
+import { a as executeMigrationPlanCommand, i as MigrationPlanResult, n as ContractSpaceSeedPhaseRecord, o as runContractSpaceSeedPhase, r as ContractSpaceSeedPhaseResult, t as ContractSpaceSeedPhaseInputs } from "./migration-plan-BsOYRogP-CC1UFAbu.mjs";
+import { i as loadConfig } from "./index-Df9igRvP.mjs";
+import { Result } from "@prisma/orm-framework/utils/result";
 import { ControlAdapterInstance, ControlDriverInstance, ControlExtensionDescriptor, ControlFamilyInstance, ControlStack, SignDatabaseResult, TargetMigrationsCapability, VerifyDatabaseResult, VerifyDatabaseSchemaResult } from "@prisma/orm-framework/components/control";
 import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
+import { PrismaNextConfig } from "@prisma/orm-framework/config/config-types";
 import { Contract } from "@prisma/orm-framework/contract/types";
 //#region ../../../1-framework/3-tooling/cli/dist/exports/control-api.d.mts
 //#region src/control-api/client.d.ts
@@ -22,6 +35,15 @@ declare function createControlClient(options: ControlClientOptions): ControlClie
  */
 declare function enrichContract(ir: Contract, components: ReadonlyArray<TargetBoundComponentDescriptor<string, string>>): Contract;
 //#endregion
+//#region src/control-api/operations/caught-errors.d.ts
+/** CliStructuredError (including MigrationToolsError) → identity; anything else → null (caller rethrows/wraps). */
+declare function mapCaughtMigrationError(error: unknown): CliStructuredError$1 | null;
+//#endregion
+//#region src/control-api/operations/contract-at-errors.d.ts
+declare function mapContractAtError(error: unknown, options?: {
+  readonly artifactRole?: 'from' | 'to';
+}): Result<never, CliStructuredError$1>;
+//#endregion
 //#region src/control-api/operations/contract-emit.d.ts
 /**
  * Canonical contract emit operation.
@@ -45,6 +67,136 @@ declare function enrichContract(ir: Contract, components: ReadonlyArray<TargetBo
  */
 declare function executeContractEmit(options: ContractEmitOptions): Promise<ContractEmitResult>;
 //#endregion
+//#region src/control-api/operations/contract-snapshot-resolution.d.ts
+interface ResolveContractRefToSnapshotBaseOptions {
+  readonly config: PrismaNextConfig;
+  readonly migrationsDir: string;
+  /** User-supplied contract reference (hash, prefix, ref name, migration dir name, <dir>^, or ./path). */
+  readonly refInput: string;
+  /** Absolute path of the emitted contract.json (fallback source + snapshot-path derivation). */
+  readonly contractPathAbsolute: string;
+}
+/**
+ * `fallbackToEmitted` discriminates the missing-bundle behavior:
+ * true (db sign): fall back to the emitted contract when no bundle matches and its
+ * storage.storageHash matches; else the 'No contract file found for hash "<hash>"' errorRuntime.
+ * false (db update --to): missing bundle = the errorUnexpected 'No migration bundle found for
+ * <flag> "<input>" (resolved hash: <hash>)' envelope, so `missingBundleFlag` (the flag label
+ * for that message) is required in this branch.
+ */
+type ResolveContractRefToSnapshotOptions = ResolveContractRefToSnapshotBaseOptions & ({
+  readonly fallbackToEmitted: true;
+  readonly missingBundleFlag?: never;
+} | {
+  readonly fallbackToEmitted: false;
+  readonly missingBundleFlag: '--to';
+});
+interface ResolveContractRefToSnapshotSuccess {
+  readonly hash: string;
+  readonly contractJson: Record<string, unknown>;
+  /** snapshot → join(contractSnapshotDir(migrationsDir, hash), 'contract.json'); emitted → contractPathAbsolute. */
+  readonly contractJsonPath: string;
+  readonly source: 'snapshot' | 'emitted';
+}
+declare function resolveContractRefToSnapshot(options: ResolveContractRefToSnapshotOptions): Promise<Result<ResolveContractRefToSnapshotSuccess, CliStructuredError$1>>;
+//#endregion
+//#region src/control-api/operations/contract-space-aggregate-loader.d.ts
+/**
+ * Map the integrity violations `checkIntegrity` reports into a single
+ * CLI structured-error envelope, preserving the error codes the prior
+ * throw-on-load loader emitted: `MIGRATION.CONTRACT_SPACE_LAYOUT_VIOLATION`
+ * (layout drift, bundled) and `MIGRATION.CONTRACT_SPACE_VIOLATION` (target /
+ * disjointness / contract-validation / structural integrity). Returns
+ * `null` when there is nothing to refuse on.
+ *
+ * Precedence reproduces the prior loader's first-failure ordering:
+ * layout drift first (every offence bundled into one envelope), then
+ * target mismatch, then disjointness, then a contract-validation
+ * failure, then any remaining structural integrity violation.
+ */
+declare function mapIntegrityViolations(violations: readonly IntegrityViolation[]): CliStructuredError$1 | null;
+/**
+ * Inputs needed to compose the aggregate loader at the CLI surface.
+ *
+ * Keeps the loader framework-neutral (no `Config` import) by accepting
+ * already-resolved structural inputs: validated app contract, target
+ * id, migrations root directory, and the set of extension descriptors.
+ */
+interface BuildAggregateInputs<TFamilyId extends string, TTargetId extends string> {
+  readonly targetId: TTargetId;
+  readonly migrationsDir: string;
+  readonly appContract: Contract;
+  readonly extensions: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
+  readonly deserializeContract: (contractJson: unknown) => Contract;
+}
+/**
+ * Reject extension descriptors whose configured target disagrees with
+ * the project target before any on-disk read.
+ */
+declare function refuseDeclaredExtensionTargetMismatch<TFamilyId extends string, TTargetId extends string>(inputs: BuildAggregateInputs<TFamilyId, TTargetId>): CliStructuredError$1 | null;
+/**
+ * Load the tolerant {@link ContractSpaceAggregate} once at the CLI
+ * surface. Construction never throws on disk content; callers query
+ * {@link ContractSpaceAggregate.app} / extension facets instead of
+ * re-reading `migrations/`.
+ */
+declare function loadContractSpaceAggregateForCli<TFamilyId extends string, TTargetId extends string>(inputs: BuildAggregateInputs<TFamilyId, TTargetId>): Promise<Result<ContractSpaceAggregate, CliStructuredError$1>>;
+/**
+ * Run `checkIntegrity` on a loaded aggregate and map violations into
+ * the contract-space refusal envelope, or return `null` when the model
+ * is acceptable for the requested check scope.
+ */
+declare function refuseContractSpaceIntegrity(aggregate: ContractSpaceAggregate, options: IntegrityQueryOptions): CliStructuredError$1 | null;
+/**
+ * Reader-subset integrity refusal for `migration status`: package
+ * corruptions only (`hashMismatch`, `providedInvariantsMismatch`,
+ * `packageUnloadable`).
+ */
+declare function refusePackageCorruptionOnAggregate(aggregate: ContractSpaceAggregate): CliStructuredError$1 | null;
+/**
+ * Construct the tolerant {@link ContractSpaceAggregate} at the CLI
+ * surface and apply the explicit integrity refusal.
+ *
+ * App-space migration packages are read from `migrations/<app>/` by the
+ * loader itself; callers no longer thread them through.
+ */
+declare function buildContractSpaceAggregate<TFamilyId extends string, TTargetId extends string>(inputs: BuildAggregateInputs<TFamilyId, TTargetId>): Promise<Result<ContractSpaceAggregate, CliStructuredError$1>>;
+/**
+ * Build a minimal app {@link Contract} carrying only the project's
+ * contract-identity (`storage.storageHash` + `target` / `targetFamily`)
+ * when the real `contract.json` is absent or undeserializable.
+ *
+ * `loadContractSpaceAggregate` requires an `appContract` to synthesise the
+ * app space's head ref from its storage hash. Read commands query only that
+ * hash and the target — never `models` — so an empty-`models` stand-in is
+ * sufficient for them. It is *not* a valid contract for any consumer that
+ * reads schema, which is why this is confined to the read-aggregate path.
+ */
+declare function appContractStandInFromIdentity(args: {
+  readonly contractHash: string;
+  readonly targetId: string;
+  readonly targetFamily: string;
+}): Contract;
+declare function loadContractRawSafely(config: {
+  contract?: {
+    output?: string;
+  };
+}): Promise<unknown | null>;
+/**
+ * Tolerant {@link ContractSpaceAggregate} assembly for read-only CLI
+ * commands. No integrity gate — callers query `aggregate.app` (or other
+ * facets) without re-reading `migrations/`. When `contract.json` is absent
+ * or undeserializable, the app contract falls back to an identity-only
+ * stand-in ({@link appContractStandInFromIdentity}), so these commands
+ * load without requiring a readable contract.
+ */
+declare function buildReadAggregate(config: PrismaNextConfig, options: {
+  readonly migrationsDir: string;
+}): Promise<Result<{
+  readonly aggregate: ContractSpaceAggregate;
+  readonly contractHash: string;
+}, CliStructuredError$1>>;
+//#endregion
 //#region src/control-api/operations/db-init.d.ts
 /**
  * Options for executing the `db init` operation.
@@ -134,8 +286,356 @@ interface ExecuteDbUpdateOptions<TFamilyId extends string, TTargetId extends str
  */
 declare function executeDbUpdate<TFamilyId extends string, TTargetId extends string>(options: ExecuteDbUpdateOptions<TFamilyId, TTargetId>): Promise<DbUpdateResult>;
 //#endregion
+//#region src/control-api/operations/graph-queries.d.ts
+/** True when the on-disk graph contains a path fromHash → toHash. */
+declare function hasMigrationPath(graph: MigrationGraph, fromHash: string, toHash: string): boolean;
+/**
+ * Refusal for a live marker hash that is not a node of the on-disk app graph.
+ * Same errorMarkerMismatch envelope migrate raises today, or null when the marker is a node.
+ */
+declare function refuseMarkerOutsideGraph(args: {
+  readonly markerHash: string;
+  readonly graph: MigrationGraph;
+}): CliStructuredError$1 | null;
+//#endregion
+//#region src/control-api/operations/invariants.d.ts
+/** Refuses ref invariants neither declared on any graph edge nor present on the live marker. */
+declare function refuseUnknownInvariants(args: {
+  readonly graph: MigrationGraph;
+  readonly markerInvariants: readonly string[];
+  readonly refInvariants: readonly string[];
+  readonly refName?: string;
+}): CliStructuredError$1 | null;
+/** Refuses a --to target whose missing invariants no path from originHash satisfies. */
+declare function refuseMissingInvariantPath(args: {
+  readonly graph: MigrationGraph;
+  readonly originHash: string;
+  readonly targetHash: string;
+  readonly missing: readonly string[];
+  readonly refName?: string;
+}): CliStructuredError$1 | null;
+//#endregion
+//#region src/control-api/operations/migration-check.d.ts
+/**
+ * One contract space's on-disk state, resolved for the explicit graph
+ * checks `runMigrationCheck` runs per space: the space's migration
+ * packages, its user-authored refs, its induced graph, and the absolute
+ * `migrations/<space>/` + `migrations/<space>/refs/` directories the
+ * file-existence and dangling-ref `where` paths are derived from.
+ */
+interface CheckSpace {
+  readonly spaceId: string;
+  readonly packages: readonly OnDiskMigrationPackage[];
+  readonly refs: Refs;
+  readonly graph: MigrationGraph;
+  readonly migrationsDir: string;
+  readonly refsDir: string;
+  /** Migrations root the contract-snapshot store lives under — shared by every space. */
+  readonly projectMigrationsDir: string;
+}
+/**
+ * Project the loaded {@link ContractSpaceAggregate} into the
+ * {@link CheckSpace} rows the multi-space check iterates — one per on-disk
+ * contract-space directory, in the aggregate's `app`-first ordering. Mirrors
+ * `migration list`'s `migrationSpaceListEntriesFromAggregate`: space
+ * membership matches the on-disk directories, package / ref / graph data come
+ * from `aggregate.space(id)`.
+ */
+declare function enumerateCheckSpaces(aggregate: ContractSpaceAggregate, projectMigrationsDir: string): Promise<readonly CheckSpace[]>;
+/**
+ * Inputs for {@link runMigrationCheck} — the multi-space policy core of
+ * the holistic (no-arg) `migration check`. Enumeration is supplied by the
+ * caller (the CLI shell builds it from {@link enumerateCheckSpaces}); the
+ * core does not touch config, flags, or streams.
+ */
+interface RunMigrationCheckInputs {
+  readonly spaces: readonly CheckSpace[];
+  readonly spaceFilter?: string;
+}
+/**
+ * Policy core of the holistic `migration check`: validates `--space`,
+ * narrows the pre-enumerated spaces, and runs the per-space explicit graph
+ * checks (file-existence, snapshot consistency, reachability, dangling
+ * refs), aggregating every failure into one {@link MigrationCheckResult}.
+ *
+ * `--space` validation mirrors `migration list`: an invalid id →
+ * {@link errorInvalidSpaceId}; an id with no on-disk space →
+ * {@link errorSpaceNotFound}. Both map to exit `PRECONDITION` at the shell.
+ * Aggregate-integrity violations (which already span every space) are folded
+ * in by the caller, not here.
+ */
+declare function runMigrationCheck(inputs: RunMigrationCheckInputs): Promise<Result<MigrationCheckResult, CliStructuredError$1>>;
+declare function loadAggregateIntegrityViolations(config: Awaited<ReturnType<typeof loadConfig>>, migrationsDir: string): Promise<readonly IntegrityViolation[]>;
+interface MigrationCheckOutcome {
+  readonly result?: MigrationCheckResult;
+  readonly error?: CliStructuredError$1;
+  readonly exitCode: number;
+  readonly resolvedSpaceId?: string;
+}
+interface SingleTargetInputs {
+  readonly spaces: readonly CheckSpace[];
+  readonly spaceFilter?: string;
+  readonly appMigrationsDir: string;
+  readonly appMigrationsRelative: string;
+}
+/**
+ * Single-target (`check <ref/path>`) mode — resolves a migration reference
+ * across all contract spaces (or the one space narrowed by `--space <id>`).
+ *
+ * Resolution:
+ *   - filesystem path → find the owning space by checking which space's
+ *     `migrationsDir` contains the resolved path; falls back to app-relative
+ *     validation when the path is outside every space dir.
+ *   - ref → `parseMigrationRef` against each in-scope space; collect every
+ *     (space, package) hit; 0 hits = not-found, 1 = check it, >1 = ambiguity
+ *     error (qualify with `--space`).
+ *
+ * `--space <id>` is validated the same way the holistic path does it:
+ * invalid id → `errorInvalidSpaceId`; no on-disk space → `errorSpaceNotFound`.
+ */
+declare function checkSingleTarget(target: string, inputs: SingleTargetInputs): Promise<MigrationCheckOutcome>;
+//#endregion
+//#region src/control-api/operations/migration-graph.d.ts
+/**
+ * Project scoped list entries into the per-space contracts+migrations rows the migration
+ * graph --json output serializes (EMPTY_CONTRACT_HASH from-hash → null). Skips space ids
+ * the aggregate no longer resolves, mirroring the command loop.
+ */
+declare function buildMigrationSpaceGraphEntries(args: {
+  readonly aggregate: ContractSpaceAggregate;
+  readonly scopedSpaces: readonly MigrationSpaceListEntry[];
+}): readonly MigrationSpaceGraphEntry[];
+//#endregion
+//#region src/control-api/operations/migration-list.d.ts
+/**
+ * Ref names decorating a space's destination contract hashes. The
+ * 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 `space.headRef` back in to
+ * keep that output. The app space synthesises its head, so it carries
+ * no on-disk `head` ref to restore.
+ */
+declare function listRefsByContractHash(space: AggregateContractSpace): ReadonlyMap<string, readonly string[]>;
+/**
+ * Project the loaded {@link ContractSpaceAggregate} into the render-ready
+ * {@link MigrationSpaceListEntry} rows `migration list` displays.
+ *
+ * Space membership matches the on-disk contract-space directories (not the
+ * aggregate's always-present synthesized app space when `migrations/app/`
+ * is absent); package and ref data come from `aggregate.space(id)`.
+ */
+declare function migrationSpaceListEntriesFromAggregate(aggregate: ContractSpaceAggregate, projectMigrationsDir: string): Promise<readonly MigrationSpaceListEntry[]>;
+/**
+ * Inputs for {@link runMigrationList} — the policy core of `migration list`
+ * that tests exercise directly.
+ *
+ * The core does not call `loadConfig`, parse CLI flags, render a styled
+ * header, or write to any stream. Enumeration is supplied by the caller
+ * (the CLI shell builds it from {@link migrationSpaceListEntriesFromAggregate}).
+ */
+interface RunMigrationListInputs {
+  readonly spaces: readonly MigrationSpaceListEntry[];
+  readonly spaceFilter?: string;
+}
+/**
+ * Policy core of `migration list`: validates `--space`, narrows the
+ * pre-enumerated spaces, and assembles a {@link MigrationListResult}.
+ *
+ * - `migrations/` missing or contains no valid space directories →
+ *   caller passes `spaces: []`; this synthesizes `[{ spaceId: APP_SPACE_ID, migrations: [] }]`.
+ * - `--space <id>` on an existing-but-empty space → `{ spaceId, migrations: [] }` in the input.
+ * - `--space <id>` on a non-existent (or reserved) space → `SPACE_NOT_FOUND`.
+ */
+declare function runMigrationList(inputs: RunMigrationListInputs): Result<MigrationListResult, CliStructuredError$1>;
+//#endregion
+//#region src/control-api/operations/migration-new.d.ts
+interface MigrationNewOptions extends CommonCommandOptions {
+  readonly name?: string;
+  readonly from?: string;
+  readonly config?: string;
+}
+interface MigrationNewResult {
+  readonly ok: true;
+  readonly dir: string;
+  readonly from: string | null;
+  readonly to: string;
+  readonly summary: string;
+}
+declare function executeMigrationNewCommand(options: MigrationNewOptions): Promise<Result<MigrationNewResult, CliStructuredError$1>>;
+//#endregion
+//#region src/utils/formatters/migration-graph-labels.d.ts
+interface MigrationEdgeAnnotation {
+  readonly status?: 'applied' | 'pending';
+  readonly operationCount?: number;
+  readonly invariants?: readonly string[];
+  /**
+   * Path-highlight annotation for `migrate --show` preview.
+   * - `'on-path'`: migration is on the chosen path; rendered in bright green.
+   * - `'off-path'`: migration is off the chosen path; fully drawn but dim grey.
+   */
+  readonly pathHighlight?: 'on-path' | 'off-path';
+}
+//#endregion
+//#region src/control-api/operations/migration-status-overlay.d.ts
+/** Origin hash for status path computation: the live/override marker, or the empty-contract sentinel. */
+declare function originHashForStatus(markerHash: string | undefined): string;
+interface DeriveStatusEdgeAnnotationsInput {
+  readonly graph: MigrationGraph;
+  readonly targetHash: string;
+  readonly originHash: string;
+  readonly appliedMigrationHashes: ReadonlySet<string>;
+  readonly showAppliedOverlay: boolean;
+}
+declare function deriveStatusEdgeAnnotations(input: DeriveStatusEdgeAnnotationsInput): ReadonlyMap<string, MigrationEdgeAnnotation>;
+declare function appliedHashesFromLedger(ledgerEntries: ReadonlyArray<{
+  readonly migrationHash: string;
+}>): ReadonlySet<string>;
+declare function statusForMigrationHash(migrationHash: string, annotations: ReadonlyMap<string, MigrationEdgeAnnotation>): 'applied' | 'pending' | null;
+//#endregion
+//#region src/control-api/operations/plan-resolution.d.ts
+type FromResolution = {
+  kind: 'greenfield';
+  fromHash: null;
+  fromContract: null;
+} | {
+  kind: 'graph-node';
+  fromHash: string;
+  fromContract: Contract;
+} | {
+  kind: 'ref';
+  fromHash: string;
+  fromContract: Contract;
+  contractDts: string;
+  contractJson: unknown;
+} | {
+  kind: 'auto-baseline';
+  fromHash: string;
+  fromContract: Contract;
+  contractDts: string;
+  contractJson: unknown;
+};
+interface ResolveFromForPlanInput {
+  readonly optionsFrom?: string | undefined;
+  readonly space: AggregateContractSpace;
+}
+declare function resolveFromForPlan(input: ResolveFromForPlanInput): Promise<Result<FromResolution, CliStructuredError$1>>;
+interface ResolveToForPlanInput {
+  readonly space: AggregateContractSpace;
+}
+interface ResolvedContractRef {
+  readonly hash: string;
+  readonly contract: Contract;
+  readonly contractJson: unknown;
+  readonly contractDts: string;
+}
+declare function resolveToForPlan(optionsTo: string, input: ResolveToForPlanInput): Promise<Result<ResolvedContractRef, CliStructuredError$1>>;
+//#endregion
+//#region src/control-api/operations/ref.d.ts
+interface RefSetResult {
+  readonly ok: true;
+  readonly ref: string;
+  readonly hash: string;
+  readonly invariants: readonly string[];
+}
+interface RefDeleteResult {
+  readonly ok: true;
+  readonly ref: string;
+  readonly deleted: true;
+}
+interface RefListResult {
+  readonly ok: true;
+  readonly refs: Record<string, RefEntry>;
+}
+declare function executeRefSetCommand(name: string, contractInput: string, options: {
+  config?: string;
+}): Promise<Result<RefSetResult, CliStructuredError$1>>;
+declare function executeRefDeleteCommand(name: string, options: {
+  config?: string;
+}): Promise<Result<RefDeleteResult, CliStructuredError$1>>;
+declare function executeRefListCommand(options: {
+  config?: string;
+}): Promise<Result<RefListResult, CliStructuredError$1>>;
+//#endregion
+//#region src/control-api/operations/ref-advancement.d.ts
+interface ContractIR {
+  readonly contract: unknown;
+  readonly contractDts: string;
+}
+interface RefAdvancementFields {
+  readonly advancedRef: {
+    readonly name: string;
+    readonly hash: string;
+  } | null;
+  readonly plannedAdvanceRef: {
+    readonly name: string;
+    readonly hash: string;
+  } | null;
+}
+declare function computeRefAdvancementName(options: {
+  readonly advanceRef?: string;
+  readonly db?: string;
+}): string | null;
+declare function readContractIR(contractJson: Record<string, unknown>, contractJsonPath: string): Promise<ContractIR>;
+declare function executeRefAdvancement(refsDir: string, migrationsDir: string, name: string, hash: string, contractIR: ContractIR): Promise<{
+  name: string;
+  hash: string;
+}>;
+declare function buildRefAdvancementFields(options: {
+  readonly advanceRef?: string;
+  readonly db?: string;
+  readonly refsDir: string;
+  readonly migrationsDir: string;
+  readonly contractIR: ContractIR;
+  readonly mode: 'plan' | 'apply';
+  readonly hash: string;
+}): Promise<RefAdvancementFields>;
+interface ResolveRefAdvancementFieldsOptions {
+  readonly advanceRef?: string;
+  readonly db?: string;
+  readonly refsDir: string;
+  readonly migrationsDir: string;
+  readonly contractJson: Record<string, unknown>;
+  /** Path whose sibling .d.ts readContractIR derives (contract.json path). */
+  readonly contractJsonPath: string;
+  readonly mode: 'plan' | 'apply';
+  readonly hash: string;
+}
+/**
+ * Full ref-advancement phase for db init/update: ok({advancedRef:null, plannedAdvanceRef:null})
+ * when computeRefAdvancementName is null; else readContractIR + buildRefAdvancementFields with
+ * MigrationToolsError mapped, other errors rethrown.
+ */
+declare function resolveRefAdvancementFields(options: ResolveRefAdvancementFieldsOptions): Promise<Result<RefAdvancementFields, CliStructuredError$1>>;
+/** migrate's --advance-ref tail: executeRefAdvancement with MigrationToolsError passed through, others rethrown. */
+declare function advanceRefSafely(args: {
+  readonly refsDir: string;
+  readonly migrationsDir: string;
+  readonly name: string;
+  readonly hash: string;
+  readonly contractIR: ContractIR;
+}): Promise<Result<{
+  readonly name: string;
+  readonly hash: string;
+}, CliStructuredError$1>>;
+//#endregion
+//#region src/control-api/operations/ref-resolution.d.ts
+interface RefResolutionContext {
+  readonly graph: MigrationGraph;
+  readonly refs: Refs;
+  readonly contractHash?: string;
+}
+declare function resolveContractRef(input: string, context: RefResolutionContext): Result<ContractRef, CliStructuredError$1>;
+declare function resolveMigrationRef(input: string, context: {
+  readonly graph: MigrationGraph;
+  readonly refs: Refs;
+}): Result<MigrationRef, CliStructuredError$1>;
+//#endregion
+//#region src/control-api/operations/refs.d.ts
+/** Reads migrations/<app>/refs, passing MigrationToolsError through; other errors rethrow. */
+declare function readMigrationRefs(refsDir: string): Promise<Result<Refs, CliStructuredError$1>>;
+//#endregion
 //#region src/utils/emit-queue.d.ts
 declare function disposeEmitQueue(outputJsonPath: string): void;
 //#endregion
-export { type ContractEmitOptions, type ContractEmitResult, type ControlActionName, type ControlClient, type ControlClientOptions, type ControlProgressEvent, type ControlStack, type DbInitFailure, type DbInitFailureCode, type DbInitOptions, type DbInitResult, type DbInitSuccess, type DbUpdateFailure, type DbUpdateFailureCode, type DbUpdateOptions, type DbUpdateResult, type DbUpdateSuccess, type EmitContractConfig, type EmitFailure, type EmitFailureCode, type EmitOptions, type EmitResult, type EmitSuccess, type ExecuteDbInitOptions, type ExecuteDbUpdateOptions, type ExecuteDbVerifyOptions, type ExecuteDbVerifyResult, type IntrospectOptions, type OnControlProgress, type SchemaVerifyOptions, type SignDatabaseResult, type SignOptions, type VerifyDatabaseResult, type VerifyDatabaseSchemaResult, type VerifyOptions, createControlClient, disposeEmitQueue, enrichContract, executeContractEmit, executeDbInit, executeDbUpdate, executeDbVerify };
+export { type BuildAggregateInputs, type CheckSpace, type ContractEmitOptions, type ContractEmitResult, type ContractIR, type ContractSpaceSeedPhaseInputs, type ContractSpaceSeedPhaseRecord, type ContractSpaceSeedPhaseResult, type ControlActionName, type ControlClient, type ControlClientOptions, type ControlProgressEvent, type ControlStack, type DbInitFailure, type DbInitFailureCode, type DbInitOptions, type DbInitResult, type DbInitSuccess, type DbUpdateFailure, type DbUpdateFailureCode, type DbUpdateOptions, type DbUpdateResult, type DbUpdateSuccess, type EmitContractConfig, type EmitFailure, type EmitFailureCode, type EmitOptions, type EmitResult, type EmitSuccess, type ExecuteDbInitOptions, type ExecuteDbUpdateOptions, type ExecuteDbVerifyOptions, type ExecuteDbVerifyResult, type ExecuteMigrateShowPlanOptions, type FromResolution, type IntrospectOptions, type MigrateShowMigration, type MigrateShowPlanSuccess, type MigrationCheckOutcome, type MigrationPlanResult, type OnControlProgress, type RefAdvancementFields, type ResolveContractRefToSnapshotOptions, type ResolveContractRefToSnapshotSuccess, type ResolvedContractRef, type RunMigrationCheckInputs, type RunMigrationListInputs, type SchemaVerifyOptions, type SignDatabaseResult, type SignOptions, type VerifyDatabaseResult, type VerifyDatabaseSchemaResult, type VerifyOptions, advanceRefSafely, appContractStandInFromIdentity, appliedHashesFromLedger, buildContractSpaceAggregate, buildMigrationSpaceGraphEntries, buildReadAggregate, buildRefAdvancementFields, checkSingleTarget, computeRefAdvancementName, createControlClient, deriveStatusEdgeAnnotations, disposeEmitQueue, enrichContract, enumerateCheckSpaces, executeContractEmit, executeDbInit, executeDbUpdate, executeDbVerify, executeMigrateShowPlan, executeMigrationNewCommand, executeMigrationPlanCommand, executeRefAdvancement, executeRefDeleteCommand, executeRefListCommand, executeRefSetCommand, hasMigrationPath, listRefsByContractHash, loadAggregateIntegrityViolations, loadContractRawSafely, loadContractSpaceAggregateForCli, mapCaughtMigrationError, mapContractAtError, mapIntegrityViolations, migrationSpaceListEntriesFromAggregate, originHashForStatus, readContractIR, readMigrationRefs, refuseContractSpaceIntegrity, refuseDeclaredExtensionTargetMismatch, refuseMarkerOutsideGraph, refuseMissingInvariantPath, refusePackageCorruptionOnAggregate, refuseUnknownInvariants, resolveContractRef, resolveContractRefToSnapshot, resolveFromForPlan, resolveMigrationRef, resolveRefAdvancementFields, resolveToForPlan, runContractSpaceSeedPhase, runMigrationCheck, runMigrationList, statusForMigrationHash };
 //# sourceMappingURL=cli__control-api.d.mts.map

package/dist/cli__control-api.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"cli__control-api.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/exports/control-api.d.mts"],"mappings":";;;;;;;;;;;;;;;;iBAeiB,oBAAoB,SAAS,uBAAuB;;;;;;iBAMpD,eAAe,IAAI,UAAU,YAAY,cAAc,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;iBAuBzG,oBAAoB,SAAS,sBAAsB,QAAQ;;;;;;;;;;;;;;;;;;;;UAoBlE,qBAAqB,0BAA0B;WAC9C,QAAQ,sBAAsB,WAAW;WACzC,SAAS,uBAAuB,WAAW;WAC3C,gBAAgB,sBAAsB;WACtC,UAAU;WACV;WACA,YAAY,2BAA2B,WAAW,WAAW,sBAAsB;WACnF,qBAAqB,cAAc,+BAA+B,WAAW;;;;;WAK7E;;;;;WAKA,UAAU;;;;;;WAMV,aAAa,cAAc,2BAA2B,WAAW;;WAEjE,aAAa;;;;;;;;;iBASP,cAAc,0BAA0B,0BAA0B,SAAS,qBAAqB,WAAW,aAAa,QAAQ;;;;;;;;;;;;UAYvI,uBAAuB,0BAA0B;WAChD,QAAQ,sBAAsB,WAAW;WACzC,SAAS,uBAAuB,WAAW;WAC3C,gBAAgB,sBAAsB;WACtC,UAAU;WACV;WACA,YAAY,2BAA2B,WAAW,WAAW,sBAAsB;WACnF,qBAAqB,cAAc,+BAA+B,WAAW;WAC7E;WACA;WACA,UAAU;WACV,aAAa,cAAc,2BAA2B,WAAW;WACjE,aAAa;;;;;;;;;;;iBAWP,gBAAgB,0BAA0B,0BAA0B,SAAS,uBAAuB,WAAW,aAAa,QAAQ;;;iBAGpI,iBAAiB"}
+{"version":3,"file":"cli__control-api.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/exports/control-api.d.mts"],"mappings":"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"}

package/dist/cli__control-api.mjs

@@ -1,4 +1,19 @@
-import { n as disposeEmitQueue, r as executeContractEmit } from "./contract-emit-CTm2zfuG-8mtkxW8M.mjs";
+import { n as disposeEmitQueue, r as executeContractEmit } from "./contract-emit-CTm2zfuG-7PV9SBY6.mjs";
 import { t as enrichContract } from "./contract-enrichment-DrMvvY2A-DxNGeF4d.mjs";
-import { i as executeDbVerify, n as executeDbInit, r as executeDbUpdate, t as createControlClient } from "./client-7aUYC7ci-Bh9mLxkl.mjs";
-export { createControlClient, disposeEmitQueue, enrichContract, executeContractEmit, executeDbInit, executeDbUpdate, executeDbVerify };
+import { a as readContractIR, i as executeRefAdvancement, n as buildRefAdvancementFields, o as resolveRefAdvancementFields, r as computeRefAdvancementName, t as advanceRefSafely } from "./ref-advancement-DaZBzm7m-BZQtedYC.mjs";
+import { a as loadContractSpaceAggregateForCli, c as refuseDeclaredExtensionTargetMismatch, i as loadContractRawSafely, l as refusePackageCorruptionOnAggregate, n as buildContractSpaceAggregate, o as mapIntegrityViolations, r as buildReadAggregate, s as refuseContractSpaceIntegrity, t as appContractStandInFromIdentity } from "./contract-space-aggregate-loader-C5r12INu-Db_pa3rX.mjs";
+import { i as executeDbVerify, n as executeDbInit, r as executeDbUpdate, t as createControlClient } from "./client-Y6qbDk7X-BzKLmBZo.mjs";
+import { t as resolveContractRefToSnapshot } from "./contract-snapshot-resolution-SATuw0JW-CsYq7g_n.mjs";
+import { t as executeMigrationNewCommand } from "./migration-new-g98oB3nC-BcrkxAAt.mjs";
+import { t as mapContractAtError } from "./contract-at-errors-Dv1mxKYO-C29YB4RC.mjs";
+import { i as runContractSpaceSeedPhase, n as resolveFromForPlan, r as resolveToForPlan, t as executeMigrationPlanCommand } from "./migration-plan-CwuZLXVE-DAJ-JUQT.mjs";
+import { n as resolveMigrationRef, t as resolveContractRef } from "./ref-resolution-_S4xTT2L-BE5zgO2W.mjs";
+import { i as refuseUnknownInvariants, n as refuseMarkerOutsideGraph, r as refuseMissingInvariantPath, t as hasMigrationPath } from "./invariants-BzYfO9IL-BXTvx0z9.mjs";
+import { n as migrationSpaceListEntriesFromAggregate, r as runMigrationList, t as listRefsByContractHash } from "./migration-list-C9OPCMt--C28yBgVr.mjs";
+import { a as statusForMigrationHash, i as readMigrationRefs, n as deriveStatusEdgeAnnotations, r as originHashForStatus, t as appliedHashesFromLedger } from "./refs-fQLFcMoq-UTlvnijY.mjs";
+import { t as mapCaughtMigrationError } from "./caught-errors-D7Qznyrm-BzYooF6H.mjs";
+import { t as buildMigrationSpaceGraphEntries } from "./migration-graph-HKch1Xk4-DyWhXtjZ.mjs";
+import { i as runMigrationCheck, n as enumerateCheckSpaces, r as loadAggregateIntegrityViolations, t as checkSingleTarget } from "./migration-check-DONPyXff-CGTUpLv-.mjs";
+import { t as executeMigrateShowPlan } from "./migrate-show-B2LkXkoB-D1ZNl84C.mjs";
+import { n as executeRefListCommand, r as executeRefSetCommand, t as executeRefDeleteCommand } from "./ref-eJjxzYTh-CNiyDL4p.mjs";
+export { advanceRefSafely, appContractStandInFromIdentity, appliedHashesFromLedger, buildContractSpaceAggregate, buildMigrationSpaceGraphEntries, buildReadAggregate, buildRefAdvancementFields, checkSingleTarget, computeRefAdvancementName, createControlClient, deriveStatusEdgeAnnotations, disposeEmitQueue, enrichContract, enumerateCheckSpaces, executeContractEmit, executeDbInit, executeDbUpdate, executeDbVerify, executeMigrateShowPlan, executeMigrationNewCommand, executeMigrationPlanCommand, executeRefAdvancement, executeRefDeleteCommand, executeRefListCommand, executeRefSetCommand, hasMigrationPath, listRefsByContractHash, loadAggregateIntegrityViolations, loadContractRawSafely, loadContractSpaceAggregateForCli, mapCaughtMigrationError, mapContractAtError, mapIntegrityViolations, migrationSpaceListEntriesFromAggregate, originHashForStatus, readContractIR, readMigrationRefs, refuseContractSpaceIntegrity, refuseDeclaredExtensionTargetMismatch, refuseMarkerOutsideGraph, refuseMissingInvariantPath, refusePackageCorruptionOnAggregate, refuseUnknownInvariants, resolveContractRef, resolveContractRefToSnapshot, resolveFromForPlan, resolveMigrationRef, resolveRefAdvancementFields, resolveToForPlan, runContractSpaceSeedPhase, runMigrationCheck, runMigrationList, statusForMigrationHash };

package/dist/cli__migration-cli.mjs

@@ -1,6 +1,6 @@
-import { g as errorInvalidJson } from "./errors-BwusfLIN-BXM7K-ww.mjs";
+import { g as errorInvalidJson } from "./errors-Co-8oaiB-CB-6Uqki.mjs";
 import { r as loadConfig } from "./exports-CDX9kZuw.mjs";
-import { r as buildMigrationArtifacts } from "./migration-diUAhNaa.mjs";
+import { r as buildMigrationArtifacts } from "./migration-DAJY-NmR.mjs";
 import { CliStructuredError, errorMigrationCliInvalidConfigArg, errorMigrationCliUnknownFlag } from "@prisma/orm-framework/errors/control";
 import { dirname, join } from "pathe";
 import { createControlStack } from "@prisma/orm-framework/components/control";

package/dist/{client-7aUYC7ci-Bh9mLxkl.mjs → client-Y6qbDk7X-BzKLmBZo.mjs}

@@ -1,12 +1,12 @@
-import { O as errorNoInvariantPath } from "./errors-BwusfLIN-BXM7K-ww.mjs";
+import { O as errorNoInvariantPath } from "./errors-Co-8oaiB-CB-6Uqki.mjs";
 import "./constants-CM-w38DQ-Cz_EXbOc.mjs";
-import { o as findPathWithDecision } from "./migration-graph-D6bN-mX0-DwMWY8DA.mjs";
-import { t as CliStructuredError$1 } from "./command-helpers-C4WpR-QE-CK2gkj6l.mjs";
-import { t as assertFrameworkComponentsCompatible } from "./framework-components-3DdB31mk-BPGSuOyZ.mjs";
+import { o as findPathWithDecision } from "./migration-graph-DDaOHo10-yJFAbKCu.mjs";
+import { t as CliStructuredError$1 } from "./command-helpers-C4WpR-QE-DE494TSG.mjs";
+import { t as assertFrameworkComponentsCompatible } from "./framework-components-3DdB31mk-BHyX-OlJ.mjs";
 import { t as enrichContract } from "./contract-enrichment-DrMvvY2A-DxNGeF4d.mjs";
 import { t as emit } from "./exports-BCLg4CiV-okAfZydo.mjs";
-import { d as resolveRecordedPath, f as verifyMigration, l as planMigration, n as buildFabricatedMigrationEdge, r as collectAggregateNamespaces, t as allStorageElementsExternal, u as requireHeadRef } from "./aggregate-i-rfetSO.mjs";
-import { t as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-CziO_ZRW-DIoQOL0P.mjs";
+import { d as resolveRecordedPath, f as verifyMigration, l as planMigration, n as buildFabricatedMigrationEdge, r as collectAggregateNamespaces, t as allStorageElementsExternal, u as requireHeadRef } from "./aggregate-D53gnb7v.mjs";
+import { n as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-C5r12INu-Db_pa3rX.mjs";
 import { CliStructuredError } from "@prisma/orm-framework/errors/control";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
@@ -14,7 +14,7 @@ import { APP_SPACE_ID, createControlStack, hasMigrations, hasOperationPreview, h
 import { blindCast, castAs } from "@prisma/orm-framework/utils/casts";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
-//#region ../../../1-framework/3-tooling/cli/dist/client-7aUYC7ci.mjs
+//#region ../../../1-framework/3-tooling/cli/dist/client-Y6qbDk7X.mjs
 /**
 * Strips operation objects to their public shape (id, label, operationClass).
 * Used at the API boundary to avoid leaking internal fields (precheck, execute, postcheck, etc.).
@@ -1607,4 +1607,4 @@ var ControlClientImpl = class {
 //#endregion
 export { planSpacePath as a, executeDbVerify as i, executeDbInit as n, executeDbUpdate as r, createControlClient as t };
 
-//# sourceMappingURL=client-7aUYC7ci-Bh9mLxkl.mjs.map
+//# sourceMappingURL=client-Y6qbDk7X-BzKLmBZo.mjs.map