@prisma/orm-toolchain 0.16.0-dev.36

package/dist/cli__commands__migration-new.d.mts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+//#region ../../../1-framework/3-tooling/cli/dist/commands/migration-new.d.mts
+//#region src/commands/migration-new.d.ts
+declare function createMigrationNewCommand(): Command;
+//#endregion
+export { createMigrationNewCommand };
+//# sourceMappingURL=cli__commands__migration-new.d.mts.map

package/dist/cli__commands__migration-new.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli__commands__migration-new.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/commands/migration-new.d.mts"],"mappings":";;;iBAEiB,6BAA6B"}

package/dist/cli__commands__migration-new.mjs

@@ -0,0 +1,2 @@
+import { t as createMigrationNewCommand } from "./migration-new-BurCjyaQ.mjs";
+export { createMigrationNewCommand };

package/dist/cli__commands__migration-plan.d.mts

@@ -0,0 +1,79 @@
+import { n as GlobalFlags } from "./global-flags-BpoOYtNZ-CHZD3fud.mjs";
+import { Result } from "@prisma/orm-framework/utils/result";
+import { OperationPreview } from "@prisma/orm-framework/components/control";
+import { Command } from "commander";
+//#region ../../../1-framework/3-tooling/cli/dist/commands/migration-plan.d.mts
+//#region src/commands/migration-plan.d.ts
+interface MigrationPlanResult {
+  readonly ok: boolean;
+  readonly noOp: boolean;
+  readonly from: string | null;
+  readonly to: string;
+  readonly dir?: string;
+  readonly baselineDir?: string;
+  /**
+   * Extension-space migration packages materialised onto disk during this
+   * `plan` run. Each entry names a `migrations/<spaceId>/<dirName>/`
+   * tree the framework wrote alongside the app-space migration directory.
+   * Empty when the project has no extension packs declaring a contract
+   * space, or when every extension-space package is already on disk.
+   *
+   * 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 cross-space side effect
+   * that `migrate` will replay.
+   */
+  readonly emittedExtensionDirs: readonly {
+    readonly spaceId: string;
+    readonly dirName: string;
+  }[];
+  readonly operations: readonly {
+    readonly id: string;
+    readonly label: string;
+    readonly operationClass: string;
+  }[];
+  /**
+   * Family-agnostic textual preview of the migration plan operations.
+   * Replaces the previous `sql?: readonly string[]` field; consumers should
+   * read `result.preview?.statements`.
+   */
+  readonly preview?: OperationPreview;
+  readonly summary: string;
+  /**
+   * When true, `migration.ts` was written but contains unfilled
+   * `placeholder(...)` calls. The user must edit the file and then run
+   * `node migration.ts` to self-emit `ops.json` / `migration.json`.
+   */
+  readonly pendingPlaceholders?: boolean;
+  readonly timings: {
+    readonly total: number;
+  };
+}
+declare function createMigrationPlanCommand(): Command;
+declare function formatMigrationPlanOutput(result: MigrationPlanResult, flags: GlobalFlags): string;
+type PrefixResolutionFailure = {
+  reason: 'ambiguous';
+  count: number;
+} | {
+  reason: 'not-found';
+};
+/**
+ * Resolve a migration package by **target contract hash** (`metadata.to`)
+ * using exact match or prefix match.
+ *
+ * Note: matches `metadata.to` (the contract hash this migration produces),
+ * not `metadata.migrationHash` (the package's content-addressed identity).
+ * Tries exact match first, then prefix match. Returns the matched package on
+ * success, or a discriminated failure indicating whether the prefix was
+ * ambiguous or simply not found.
+ *
+ * @internal Exported for testing only.
+ */
+declare function resolveBundleByPrefix<T extends {
+  metadata: {
+    to: string;
+  };
+}>(bundles: readonly T[], needle: string): Result<T, PrefixResolutionFailure>;
+//#endregion
+export { MigrationPlanResult, PrefixResolutionFailure, createMigrationPlanCommand, formatMigrationPlanOutput, resolveBundleByPrefix };
+//# sourceMappingURL=cli__commands__migration-plan.d.mts.map

package/dist/cli__commands__migration-plan.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli__commands__migration-plan.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/commands/migration-plan.d.mts"],"mappings":";;;;;;UAKU;WACC;WACA;WACA;WACA;WACA;WACA;;;;;;;;;;;;;WAaA;aACE;aACA;;WAEF;aACE;aACA;aACA;;;;;;;WAOF,UAAU;WACV;;;;;;WAMA;WACA;aACE;;;iBAGI,8BAA8B;iBAC9B,0BAA0B,QAAQ,qBAAqB,OAAO;KAC1E;EACH;EACA;;EAEA;;;;;;;;;;;;;;iBAce,sBAAsB;EACrC;IACE;;GAED,kBAAkB,KAAK,iBAAiB,OAAO,GAAG"}

package/dist/cli__commands__migration-plan.mjs

@@ -0,0 +1,2 @@
+import { n as formatMigrationPlanOutput, r as resolveBundleByPrefix, t as createMigrationPlanCommand } from "./migration-plan-q_L84PN1-BWE0LTH6.mjs";
+export { createMigrationPlanCommand, formatMigrationPlanOutput, resolveBundleByPrefix };

package/dist/cli__commands__migration-show.d.mts

@@ -0,0 +1,27 @@
+import { a as MigrationShowResult } from "./schemas-CeGMYFYX-h3OcU__O.mjs";
+import { Command } from "commander";
+//#region ../../../1-framework/3-tooling/cli/dist/commands/migration-show.d.mts
+//#region src/commands/migration-show.d.ts
+interface MigrationShowPresent {
+  readonly space: string;
+  readonly name: string;
+  readonly fromContract: string | null;
+  readonly toContract: string;
+  readonly hash: string;
+  readonly createdAt: string;
+  readonly operations: {
+    id: string;
+    label: string;
+    operationClass: string;
+  }[];
+  readonly preview: {
+    statements: {
+      text: string;
+      language: string;
+    }[];
+  };
+}
+declare function createMigrationShowCommand(): Command;
+//#endregion
+export { MigrationShowPresent, type MigrationShowResult, createMigrationShowCommand };
+//# sourceMappingURL=cli__commands__migration-show.d.mts.map

package/dist/cli__commands__migration-show.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli__commands__migration-show.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/commands/migration-show.d.mts"],"mappings":";;;;UAGU;WACC;WACA;WACA;WACA;WACA;WACA;WACA;IACP;IACA;IACA;;WAEO;IACP;MACE;MACA;;;;iBAIW,8BAA8B"}

package/dist/cli__commands__migration-show.mjs

@@ -0,0 +1,2 @@
+import { t as createMigrationShowCommand } from "./migration-show-Bx5I5aW9.mjs";
+export { createMigrationShowCommand };

package/dist/cli__commands__migration-status.d.mts

@@ -0,0 +1,55 @@
+import { t as CliStructuredError$1 } from "./types-DZWEs4si-D8UlyJI0.mjs";
+import { c as MigrationStatusEntry, d as StatusDiagnosticJson, l as MigrationStatusResult, p as migrationStatusJsonResultSchema, u as MigrationStatusSpace } from "./schemas-CeGMYFYX-h3OcU__O.mjs";
+import { n as GlobalFlags, t as CommonCommandOptions } from "./global-flags-BpoOYtNZ-CHZD3fud.mjs";
+import { n as TerminalUI } from "./terminal-ui-BN4QOsm5-Bf3pim46.mjs";
+import { Result } from "@prisma/orm-framework/utils/result";
+import { Command } from "commander";
+//#region ../../../1-framework/3-tooling/cli/dist/commands/migration-status.d.mts
+//#region src/utils/migration-types.d.ts
+interface StatusRef {
+  readonly name: string;
+  readonly hash: string;
+  readonly active: boolean;
+}
+//#endregion
+//#region src/commands/migration-status.d.ts
+interface MigrationStatusOptions extends CommonCommandOptions {
+  readonly db?: string;
+  readonly config?: string;
+  readonly to?: string;
+  readonly from?: string;
+  readonly space?: string;
+  readonly legend?: boolean;
+  readonly ascii?: boolean;
+}
+interface MigrationStatusTreeSection {
+  readonly space: string;
+  readonly tree: string;
+  readonly showHeading: boolean;
+}
+interface MigrationStatusCommandResult {
+  readonly ok: true;
+  readonly spaces: readonly MigrationStatusSpace[];
+  readonly summary: string;
+  readonly diagnostics: readonly StatusDiagnosticJson[];
+  readonly treeSections: readonly MigrationStatusTreeSection[];
+}
+declare function buildNoPathSummary(args: {
+  readonly markerHash: string | undefined;
+  readonly targetHash: string;
+  readonly explicitTarget: boolean;
+  readonly refName: string | undefined;
+}): string;
+declare function buildStatusHeadline(args: {
+  readonly pendingCount: number;
+  readonly targetHash: string;
+  readonly markerDiverged: boolean;
+  readonly markerHash: string | undefined;
+}): string;
+declare function formatStatusSummary(result: MigrationStatusCommandResult, colorize: boolean): string;
+declare function formatStatusHumanOutput(result: MigrationStatusCommandResult, colorize: boolean): string;
+declare function executeMigrationStatusCommand(options: MigrationStatusOptions, flags: GlobalFlags, ui: TerminalUI): Promise<Result<MigrationStatusCommandResult, CliStructuredError$1>>;
+declare function createMigrationStatusCommand(): Command;
+//#endregion
+export { type MigrationStatusEntry, MigrationStatusOptions, type MigrationStatusResult, type MigrationStatusSpace, MigrationStatusTreeSection, type StatusDiagnosticJson, type StatusRef, buildNoPathSummary, buildStatusHeadline, createMigrationStatusCommand, executeMigrationStatusCommand, formatStatusHumanOutput, formatStatusSummary, migrationStatusJsonResultSchema };
+//# sourceMappingURL=cli__commands__migration-status.d.mts.map

package/dist/cli__commands__migration-status.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli__commands__migration-status.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/commands/migration-status.d.mts"],"mappings":";;;;;;;;UAOU;WACC;WACA;WACA;;;;UAID,+BAA+B;WAC9B;WACA;WACA;WACA;WACA;WACA;WACA;;UAED;WACC;WACA;WACA;;UAED;WACC;WACA,iBAAiB;WACjB;WACA,sBAAsB;WACtB,uBAAuB;;iBAEjB,mBAAmB;WACzB;WACA;WACA;WACA;;iBAEM,oBAAoB;WAC1B;WACA;WACA;WACA;;iBAEM,oBAAoB,QAAQ,8BAA8B;iBAC1D,wBAAwB,QAAQ,8BAA8B;iBAC9D,8BAA8B,SAAS,wBAAwB,OAAO,aAAa,IAAI,aAAa,QAAQ,OAAO,8BAA8B;iBACjJ,gCAAgC"}

package/dist/cli__commands__migration-status.mjs

@@ -0,0 +1,3 @@
+import { n as migrationStatusJsonResultSchema } from "./schemas-KhXMzNA_-CzZ7GFX_.mjs";
+import { a as formatStatusHumanOutput, i as executeMigrationStatusCommand, n as buildStatusHeadline, o as formatStatusSummary, r as createMigrationStatusCommand, t as buildNoPathSummary } from "./migration-status-CFlzlRmu-DewBN8Ys.mjs";
+export { buildNoPathSummary, buildStatusHeadline, createMigrationStatusCommand, executeMigrationStatusCommand, formatStatusHumanOutput, formatStatusSummary, migrationStatusJsonResultSchema };

package/dist/cli__commands__ref.d.mts

@@ -0,0 +1,34 @@
+import { n as RefEntry } from "./refs-BNCUu58Y-BIso5Jfg.mjs";
+import { t as CliStructuredError$1 } from "./types-DZWEs4si-D8UlyJI0.mjs";
+import { Result } from "@prisma/orm-framework/utils/result";
+import { Command } from "commander";
+//#region ../../../1-framework/3-tooling/cli/dist/commands/ref.d.mts
+//#region src/commands/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>>;
+declare function createRefCommand(): Command;
+//#endregion
+export { createRefCommand, executeRefDeleteCommand, executeRefListCommand, executeRefSetCommand };
+//# sourceMappingURL=cli__commands__ref.d.mts.map

package/dist/cli__commands__ref.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli__commands__ref.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/commands/ref.d.mts"],"mappings":";;;;;;UAKU;WACC;WACA;WACA;WACA;;UAED;WACC;WACA;WACA;;UAED;WACC;WACA,MAAM,eAAe;;iBAEf,qBAAqB,cAAc,uBAAuB;EACzE;IACE,QAAQ,OAAO,cAAc;iBAChB,wBAAwB,cAAc;EACrD;IACE,QAAQ,OAAO,iBAAiB;iBACnB,sBAAsB;EACrC;IACE,QAAQ,OAAO,eAAe;iBACjB,oBAAoB"}

package/dist/cli__commands__ref.mjs

@@ -0,0 +1,2 @@
+import { i as executeRefSetCommand, n as executeRefDeleteCommand, r as executeRefListCommand, t as createRefCommand } from "./ref-B6cTthTi.mjs";
+export { createRefCommand, executeRefDeleteCommand, executeRefListCommand, executeRefSetCommand };

package/dist/cli__commands__telemetry.d.mts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+//#region ../../../1-framework/3-tooling/cli/dist/commands/telemetry/index.d.mts
+//#region src/commands/telemetry/index.d.ts
+declare function createTelemetryCommand(): Command;
+//#endregion
+export { createTelemetryCommand };
+//# sourceMappingURL=cli__commands__telemetry.d.mts.map

package/dist/cli__commands__telemetry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli__commands__telemetry.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/commands/telemetry/index.d.mts"],"mappings":";;;iBAEiB,0BAA0B"}

package/dist/cli__commands__telemetry.mjs

@@ -0,0 +1,2 @@
+import { t as createTelemetryCommand } from "./telemetry-CmbCa3Ld-CmE5zcIG.mjs";
+export { createTelemetryCommand };

package/dist/cli__config-types.d.mts

@@ -0,0 +1,2 @@
+import { ContractConfig, ContractSourceContext, PrismaNextConfig, defineConfig } from "@prisma/orm-framework/config/config-types";
+export { type ContractConfig, type ContractSourceContext, type PrismaNextConfig, defineConfig };

package/dist/cli__config-types.mjs

@@ -0,0 +1,2 @@
+import { defineConfig } from "@prisma/orm-framework/config/config-types";
+export { defineConfig };

package/dist/cli__control-api.d.mts

@@ -0,0 +1,141 @@
+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-DZWEs4si-D8UlyJI0.mjs";
+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 { 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
+/**
+ * Creates a programmatic control client for Prisma Next operations.
+ *
+ * The client accepts framework component descriptors at creation time,
+ * manages driver lifecycle via connect()/close(), and exposes domain
+ * operations that delegate to the existing family instance methods.
+ *
+ * @see {@link ControlClient} for the client interface
+ * @see README.md "Programmatic Control API" section for usage examples
+ */
+declare function createControlClient(options: ControlClientOptions): ControlClient;
+//#endregion
+//#region src/control-api/contract-enrichment.d.ts
+/**
+ * Enriches a raw contract with framework-derived metadata: capabilities from all component descriptors and extension pack metadata from extension descriptors. Produces deterministically sorted output.
+ */
+declare function enrichContract(ir: Contract, components: ReadonlyArray<TargetBoundComponentDescriptor<string, string>>): Contract;
+//#endregion
+//#region src/control-api/operations/contract-emit.d.ts
+/**
+ * Canonical contract emit operation.
+ *
+ * This is the SINGLE publication path used by both the CLI command
+ * (`prisma-next contract emit`) and the Vite plugin
+ * (`@internal/vite-plugin-contract-emit`). New callers must go through this
+ * function rather than re-implementing load → emit → publish.
+ *
+ * The whole flow (load config → resolve source → emit bytes → atomic publish)
+ * is serialized per output JSON path via `queueEmitByOutput`. Concurrent calls
+ * for the same output line up FIFO; the user-visible outcome is "last
+ * submission wins on disk" without any supersession bookkeeping. Within a
+ * single emit, `publishContractArtifactPair` stages temp files, renames
+ * `contract.d.ts` before `contract.json`, and attempts to restore the previous
+ * pair if either rename fails — so type-only consumers never observe a
+ * mismatched pair.
+ *
+ * @throws {CliStructuredError} on config/source/validation problems
+ * @throws {DOMException} `AbortError` if cancelled via `signal`
+ */
+declare function executeContractEmit(options: ContractEmitOptions): Promise<ContractEmitResult>;
+//#endregion
+//#region src/control-api/operations/db-init.d.ts
+/**
+ * Options for executing the `db init` operation.
+ *
+ * `db init` runs the loader → planner → runner pipeline:
+ *
+ * 1. {@link executeRun} loads a `ContractSpaceAggregate` via
+ *    {@link import('@prisma/orm-toolchain/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 space — synth strategy for the app, graph-walk
+ *    for every extension.
+ * 3. The runner's `execute` applies the per-space plans
+ *    inside one outer transaction.
+ *
+ * `extensions` mirrors `Config.extensions` (descriptor list).
+ * The loader (sub-spec § Loader) is the sole descriptor-import boundary.
+ */
+interface ExecuteDbInitOptions<TFamilyId extends string, TTargetId extends string> {
+  readonly driver: ControlDriverInstance<TFamilyId, TTargetId>;
+  readonly adapter: ControlAdapterInstance<TFamilyId, TTargetId>;
+  readonly familyInstance: ControlFamilyInstance<TFamilyId, unknown>;
+  readonly contract: Contract;
+  readonly mode: 'plan' | 'apply';
+  readonly migrations: TargetMigrationsCapability<TFamilyId, TTargetId, ControlFamilyInstance<TFamilyId, unknown>>;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;
+  /**
+   * On-disk migrations directory the aggregate loader reads on-disk
+   * artefacts from. Required.
+   */
+  readonly migrationsDir: string;
+  /**
+   * Resolved adapter target id. Threaded through to the loader for
+   * target-consistency checks across descriptors and the app contract.
+   */
+  readonly targetId: TTargetId;
+  /**
+   * Declared extension descriptors. Defaults to an empty list, which
+   * routes through the same loader → planner → runner pipeline with no
+   * extension spaces in the aggregate.
+   */
+  readonly extensions?: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+/**
+ * Execute `db init` against the configured contract.
+ *
+ * Routes through the loader → planner → runner pipeline (sub-spec
+ * "Commit-by-commit § Commit 4"). Always additive-only; destructive
+ * changes belong to `db update`.
+ */
+declare function executeDbInit<TFamilyId extends string, TTargetId extends string>(options: ExecuteDbInitOptions<TFamilyId, TTargetId>): Promise<DbInitResult>;
+//#endregion
+//#region src/control-api/operations/db-update.d.ts
+/**
+ * Options for the `db update` operation.
+ *
+ * Same loader → planner → runner pipeline as `db init`, but with the
+ * widened operation policy (additive + widening + destructive). The
+ * destructive-change confirmation gate runs at this layer: when
+ * `mode === 'apply'` and `acceptDataLoss` is `false`, the operation
+ * pre-plans, surfaces destructive ops to the caller, and aborts.
+ */
+interface ExecuteDbUpdateOptions<TFamilyId extends string, TTargetId extends string> {
+  readonly driver: ControlDriverInstance<TFamilyId, TTargetId>;
+  readonly adapter: ControlAdapterInstance<TFamilyId, TTargetId>;
+  readonly familyInstance: ControlFamilyInstance<TFamilyId, unknown>;
+  readonly contract: Contract;
+  readonly mode: 'plan' | 'apply';
+  readonly migrations: TargetMigrationsCapability<TFamilyId, TTargetId, ControlFamilyInstance<TFamilyId, unknown>>;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;
+  readonly acceptDataLoss?: boolean;
+  readonly migrationsDir: string;
+  readonly targetId: TTargetId;
+  readonly extensions?: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
+  readonly onProgress?: OnControlProgress;
+}
+/**
+ * Execute `db update` against the configured contract.
+ *
+ * Routes through the loader → planner → runner pipeline. Destructive
+ * operations require either `acceptDataLoss: true` or a prior
+ * `mode: 'plan'` invocation that surfaces the destructive ops; the
+ * confirmation gate is implemented here so the lower-level applier
+ * remains policy-agnostic.
+ */
+declare function executeDbUpdate<TFamilyId extends string, TTargetId extends string>(options: ExecuteDbUpdateOptions<TFamilyId, TTargetId>): Promise<DbUpdateResult>;
+//#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 };
+//# sourceMappingURL=cli__control-api.d.mts.map

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

@@ -0,0 +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"}

package/dist/cli__control-api.mjs

@@ -0,0 +1,4 @@
+import { n as disposeEmitQueue, r as executeContractEmit } from "./contract-emit-B6odMoem-CK3diBPk.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-75qrAPqf-DZAVUxFa.mjs";
+export { createControlClient, disposeEmitQueue, enrichContract, executeContractEmit, executeDbInit, executeDbUpdate, executeDbVerify };

package/dist/cli__init-output.d.mts

@@ -0,0 +1,37 @@
+import "./terminal-ui-BN4QOsm5-Bf3pim46.mjs";
+//#region ../../../1-framework/3-tooling/cli/dist/exports/init-output.d.mts
+//#region src/commands/init/output.d.ts
+/**
+ * arktype schema for the structured success document `init --json` writes
+ * to stdout (FR1.5). The same shape backs the human-readable outro
+ * renderer (FR10), so the two output modes carry identical information.
+ *
+ * `target` is normalised to the user-facing flag value (`mongodb` rather
+ * than the internal `mongo`) so consumers can round-trip the document
+ * straight into a follow-up `--target` invocation.
+ *
+ * The `ok: true` literal is the documented success/error discriminator —
+ * see [Style Guide § JSON Semantics](../../../../../../../docs/CLI%20Style%20Guide.md#json-semantics).
+ * Error envelopes (`CliErrorEnvelope`) carry `ok: false` so consumers can
+ * branch with `if (doc.ok)` without inspecting the rest of the structure.
+ */
+declare const InitOutputSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+  ok: true;
+  target: "postgres" | "mongodb";
+  authoring: "psl" | "typescript";
+  schemaPath: string;
+  filesWritten: string[];
+  filesDeleted: string[];
+  packagesInstalled: {
+    skipped: boolean;
+    deps: string[];
+    devDeps: string[];
+  };
+  contractEmitted: boolean;
+  nextSteps: string[];
+  warnings: string[];
+}, {}>;
+type InitOutput = typeof InitOutputSchema.infer;
+//#endregion
+export { type InitOutput, InitOutputSchema };
+//# sourceMappingURL=cli__init-output.d.mts.map

package/dist/cli__init-output.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli__init-output.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/exports/init-output.d.mts"],"mappings":";;;;;;;;;;;;;;;;;cAgBc,gEAAgE;EAC5E;EACA;EACA;EACA;EACA;EACA;EACA;IACE;IACA;IACA;;EAEF;EACA;EACA;;KAEG,oBAAoB,iBAAiB"}

package/dist/cli__init-output.mjs

@@ -0,0 +1,2 @@
+import { t as InitOutputSchema } from "./output-DWNYqZGc-D2sRgLAm.mjs";
+export { InitOutputSchema };

package/dist/cli__migration-cli.d.mts

@@ -0,0 +1,79 @@
+import { t as Migration } from "./migration-B2ljMJim.mjs";
+import { Writable } from "node:stream";
+//#region ../../../1-framework/3-tooling/cli/dist/migration-cli.d.mts
+//#region src/migration-cli.d.ts
+/**
+ * Constructor shape accepted by `MigrationCLI.run`. `Migration` subclasses
+ * accept an optional `ControlStack` in their constructor (each subclass
+ * narrows the stack to its own family/target generics); the CLI always
+ * passes one assembled from the loaded config. We use a rest-args `any[]`
+ * constructor signature so that subclass constructors with narrower
+ * parameter types remain assignable - constructor type compatibility in
+ * TS is contravariant in the parameter, and a wider `unknown` parameter
+ * on the alias side would reject any narrower subclass signature.
+ *
+ * The CLI only ever passes one argument (`new MigrationClass(stack)`);
+ * the rest-arity is purely a type-compatibility concession for subclass
+ * constructors that declare narrower parameter types, not an extension
+ * point for additional construction arguments.
+ */
+type MigrationConstructor = new (...args: any[]) => Migration;
+/**
+ * Stream surface accepted by `MigrationCLI.run`'s `options.stdout` /
+ * `options.stderr`. Aliases node's `Writable` because clipanion's
+ * `BaseContext.stdout`/`stderr` are typed as `Writable`, and the CLI
+ * forwards the injected streams into clipanion's context.
+ *
+ * `process.stdout` and `process.stderr` are `Writable`-shaped, so the
+ * default-fallback path remains a no-op for existing two-argument
+ * callers like `MigrationCLI.run(import.meta.url, MyMigration)`.
+ *
+ * Tests inject a `Writable` subclass that captures chunks for
+ * assertions.
+ */
+type MigrationCliWritable = Writable;
+/**
+ * The CLI surface invoked by an authored `migration.ts` file. Exposed as
+ * a class with a static `run` method (rather than a free function) to
+ * give the concept a stable identity in the ubiquitous language: this is
+ * the "migration-file CLI", distinct from the apply-time runner that
+ * executes migration JSON ops.
+ *
+ * Currently a single static method. Future surface (e.g. a programmatic
+ * `MigrationCLI.serializeOnly(...)` for tests, or extra subcommands) can
+ * land here without changing the import shape used by every authored
+ * migration.
+ */
+declare class MigrationCLI {
+  /**
+   * Orchestrates a class-flow `migration.ts` script run.
+   *
+   * The third argument is the in-process testability surface: callers
+   * (and tests) may inject `argv`, `stdout`, and `stderr` instead of
+   * relying on `process.argv` / `process.stdout` / `process.stderr`.
+   * Each option defaults to its `process` global when omitted, so
+   * existing two-argument call sites
+   * (`MigrationCLI.run(import.meta.url, MyMigration)`) continue to
+   * compile and behave identically.
+   *
+   * Returns the exit code so the caller can branch on it. Also writes
+   * the same code to `process.exitCode` so script-style callers that
+   * don't await the return value still surface a non-zero exit when
+   * something fails.
+   *
+   * Exit codes:
+   * - 0 — success, or `--help`, or imported-not-entrypoint no-op.
+   * - 1 — runtime/orchestration error (config not found, target
+   *   mismatch, etc.).
+   * - 2 — usage error (unknown flag, malformed `--config`). Aligns
+   *   with `docs/CLI Style Guide.md` § Exit Codes.
+   */
+  static run(importMetaUrl: string, MigrationClass: MigrationConstructor, options?: {
+    readonly argv?: readonly string[];
+    readonly stdout?: MigrationCliWritable;
+    readonly stderr?: MigrationCliWritable;
+  }): Promise<number>;
+}
+//#endregion
+export { MigrationCLI, MigrationCliWritable, MigrationConstructor };
+//# sourceMappingURL=cli__migration-cli.d.mts.map

package/dist/cli__migration-cli.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli__migration-cli.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/migration-cli.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;KAkBK,+BAA+B,gBAAgB;;;;;;;;;;;;;;KAc/C,uBAAuB;;;;;;;;;;;;;cAad;;;;;;;;;;;;;;;;;;;;;;;;SAwBL,IAAI,uBAAuB,gBAAgB,sBAAsB;aAC7D;aACA,SAAS;aACT,SAAS;MAChB"}