@prisma-next/cli 0.3.0-pr.99.6 → 0.4.0-dev.1

package/dist/client-DiUkJAeN.mjs

@@ -0,0 +1,987 @@
+import { t as assertFrameworkComponentsCompatible } from "./framework-components-BAsliT4V.mjs";
+import { t as enrichContract } from "./contract-enrichment-CGW6mm-E.mjs";
+import { t as extractOperationStatements } from "./extract-operation-statements-DZUJNmL3.mjs";
+import { notOk, ok } from "@prisma-next/utils/result";
+import { emit } from "@prisma-next/emitter";
+import { createControlStack, hasMigrations, hasSchemaView } from "@prisma-next/framework-components/control";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
+
+//#region src/control-api/errors.ts
+var ContractValidationError = class extends Error {
+	cause;
+	constructor(message, cause) {
+		super(message);
+		this.name = "ContractValidationError";
+		this.cause = cause;
+	}
+};
+
+//#endregion
+//#region src/control-api/operations/migration-helpers.ts
+/**
+* Strips operation objects to their public shape (id, label, operationClass).
+* Used at the API boundary to avoid leaking internal fields (precheck, execute, postcheck, etc.).
+*/
+function stripOperations(operations) {
+	return operations.map((op) => ({
+		id: op.id,
+		label: op.label,
+		operationClass: op.operationClass
+	}));
+}
+/**
+* Creates per-operation progress callbacks for the runner.
+* Returns undefined when no onProgress callback is provided.
+*/
+function createOperationCallbacks(onProgress, action, parentSpanId) {
+	if (!onProgress) return;
+	return {
+		onOperationStart: (op) => {
+			onProgress({
+				action,
+				kind: "spanStart",
+				spanId: `operation:${op.id}`,
+				parentSpanId,
+				label: op.label
+			});
+		},
+		onOperationComplete: (op) => {
+			onProgress({
+				action,
+				kind: "spanEnd",
+				spanId: `operation:${op.id}`,
+				outcome: "ok"
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/control-api/operations/db-init.ts
+/**
+* Executes the dbInit operation.
+*
+* This is the core logic extracted from the CLI command, without any file I/O,
+* process.exit(), or console output. It uses the Result pattern to return
+* success or failure details.
+*
+* @param options - The options for executing dbInit
+* @returns Result with DbInitSuccess on success, DbInitFailure on failure
+*/
+async function executeDbInit(options) {
+	const { driver, familyInstance, contract, mode, migrations, frameworkComponents, onProgress } = options;
+	const planner = migrations.createPlanner(familyInstance);
+	const runner = migrations.createRunner(familyInstance);
+	const introspectSpanId = "introspect";
+	onProgress?.({
+		action: "dbInit",
+		kind: "spanStart",
+		spanId: introspectSpanId,
+		label: "Introspecting database schema"
+	});
+	const schemaIR = await familyInstance.introspect({ driver });
+	onProgress?.({
+		action: "dbInit",
+		kind: "spanEnd",
+		spanId: introspectSpanId,
+		outcome: "ok"
+	});
+	const policy = { allowedOperationClasses: ["additive"] };
+	const planSpanId = "plan";
+	onProgress?.({
+		action: "dbInit",
+		kind: "spanStart",
+		spanId: planSpanId,
+		label: "Planning migration"
+	});
+	const plannerResult = await planner.plan({
+		contract,
+		schema: schemaIR,
+		policy,
+		frameworkComponents
+	});
+	if (plannerResult.kind === "failure") {
+		onProgress?.({
+			action: "dbInit",
+			kind: "spanEnd",
+			spanId: planSpanId,
+			outcome: "error"
+		});
+		return notOk({
+			code: "PLANNING_FAILED",
+			summary: "Migration planning failed due to conflicts",
+			conflicts: plannerResult.conflicts,
+			why: void 0,
+			meta: void 0
+		});
+	}
+	const migrationPlan = plannerResult.plan;
+	onProgress?.({
+		action: "dbInit",
+		kind: "spanEnd",
+		spanId: planSpanId,
+		outcome: "ok"
+	});
+	const checkMarkerSpanId = "checkMarker";
+	onProgress?.({
+		action: "dbInit",
+		kind: "spanStart",
+		spanId: checkMarkerSpanId,
+		label: "Checking database signature"
+	});
+	const existingMarker = await familyInstance.readMarker({ driver });
+	if (existingMarker) {
+		if (existingMarker.storageHash === migrationPlan.destination.storageHash && (!migrationPlan.destination.profileHash || existingMarker.profileHash === migrationPlan.destination.profileHash)) {
+			onProgress?.({
+				action: "dbInit",
+				kind: "spanEnd",
+				spanId: checkMarkerSpanId,
+				outcome: "skipped"
+			});
+			return ok({
+				mode,
+				plan: { operations: [] },
+				destination: {
+					storageHash: migrationPlan.destination.storageHash,
+					...ifDefined("profileHash", migrationPlan.destination.profileHash)
+				},
+				...ifDefined("execution", mode === "apply" ? {
+					operationsPlanned: 0,
+					operationsExecuted: 0
+				} : void 0),
+				...ifDefined("marker", mode === "apply" ? {
+					storageHash: existingMarker.storageHash,
+					profileHash: existingMarker.profileHash
+				} : void 0),
+				summary: "Database already at target contract state"
+			});
+		}
+		onProgress?.({
+			action: "dbInit",
+			kind: "spanEnd",
+			spanId: checkMarkerSpanId,
+			outcome: "error"
+		});
+		return notOk({
+			code: "MARKER_ORIGIN_MISMATCH",
+			summary: "Existing contract marker does not match plan destination",
+			marker: {
+				storageHash: existingMarker.storageHash,
+				profileHash: existingMarker.profileHash
+			},
+			destination: {
+				storageHash: migrationPlan.destination.storageHash,
+				profileHash: migrationPlan.destination.profileHash
+			},
+			why: void 0,
+			conflicts: void 0,
+			meta: void 0
+		});
+	}
+	onProgress?.({
+		action: "dbInit",
+		kind: "spanEnd",
+		spanId: checkMarkerSpanId,
+		outcome: "ok"
+	});
+	if (mode === "plan") {
+		const planSql = extractOperationStatements(familyInstance.familyId, migrationPlan.operations);
+		return ok({
+			mode: "plan",
+			plan: {
+				operations: stripOperations(migrationPlan.operations),
+				...ifDefined("sql", planSql)
+			},
+			destination: {
+				storageHash: migrationPlan.destination.storageHash,
+				...ifDefined("profileHash", migrationPlan.destination.profileHash)
+			},
+			summary: `Planned ${migrationPlan.operations.length} operation(s)`
+		});
+	}
+	const applySpanId = "apply";
+	onProgress?.({
+		action: "dbInit",
+		kind: "spanStart",
+		spanId: applySpanId,
+		label: "Applying migration plan"
+	});
+	const callbacks = createOperationCallbacks(onProgress, "dbInit", applySpanId);
+	const runnerResult = await runner.execute({
+		plan: migrationPlan,
+		driver,
+		destinationContract: contract,
+		policy,
+		...ifDefined("callbacks", callbacks),
+		executionChecks: {
+			prechecks: false,
+			postchecks: false,
+			idempotencyChecks: false
+		},
+		frameworkComponents
+	});
+	if (!runnerResult.ok) {
+		onProgress?.({
+			action: "dbInit",
+			kind: "spanEnd",
+			spanId: applySpanId,
+			outcome: "error"
+		});
+		return notOk({
+			code: "RUNNER_FAILED",
+			summary: runnerResult.failure.summary,
+			why: runnerResult.failure.why,
+			meta: runnerResult.failure.meta,
+			conflicts: void 0
+		});
+	}
+	const execution = runnerResult.value;
+	onProgress?.({
+		action: "dbInit",
+		kind: "spanEnd",
+		spanId: applySpanId,
+		outcome: "ok"
+	});
+	return ok({
+		mode: "apply",
+		plan: { operations: stripOperations(migrationPlan.operations) },
+		destination: {
+			storageHash: migrationPlan.destination.storageHash,
+			...ifDefined("profileHash", migrationPlan.destination.profileHash)
+		},
+		execution: {
+			operationsPlanned: execution.operationsPlanned,
+			operationsExecuted: execution.operationsExecuted
+		},
+		marker: migrationPlan.destination.profileHash ? {
+			storageHash: migrationPlan.destination.storageHash,
+			profileHash: migrationPlan.destination.profileHash
+		} : { storageHash: migrationPlan.destination.storageHash },
+		summary: `Applied ${execution.operationsExecuted} operation(s), database signed`
+	});
+}
+
+//#endregion
+//#region src/control-api/operations/db-update.ts
+const DB_UPDATE_POLICY = { allowedOperationClasses: [
+	"additive",
+	"widening",
+	"destructive"
+] };
+/**
+* Executes the db update operation: introspect → plan → (optionally) apply → marker.
+*
+* db update is a pure reconciliation command: it introspects the live schema, plans the diff
+* to the destination contract, and applies operations. The marker is bookkeeping only — written
+* after apply so that `verify` and `db init` can reference it, but never read or validated
+* by db update itself. The runner creates the marker table if it does not exist.
+*/
+async function executeDbUpdate(options) {
+	const { driver, familyInstance, contract, mode, migrations, frameworkComponents, onProgress } = options;
+	const planner = migrations.createPlanner(familyInstance);
+	const runner = migrations.createRunner(familyInstance);
+	const introspectSpanId = "introspect";
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanStart",
+		spanId: introspectSpanId,
+		label: "Introspecting database schema"
+	});
+	const schemaIR = await familyInstance.introspect({ driver });
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanEnd",
+		spanId: introspectSpanId,
+		outcome: "ok"
+	});
+	const policy = DB_UPDATE_POLICY;
+	const planSpanId = "plan";
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanStart",
+		spanId: planSpanId,
+		label: "Planning migration"
+	});
+	const plannerResult = await planner.plan({
+		contract,
+		schema: schemaIR,
+		policy,
+		frameworkComponents
+	});
+	if (plannerResult.kind === "failure") {
+		onProgress?.({
+			action: "dbUpdate",
+			kind: "spanEnd",
+			spanId: planSpanId,
+			outcome: "error"
+		});
+		return notOk({
+			code: "PLANNING_FAILED",
+			summary: "Migration planning failed due to conflicts",
+			conflicts: plannerResult.conflicts,
+			why: void 0,
+			meta: void 0
+		});
+	}
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanEnd",
+		spanId: planSpanId,
+		outcome: "ok"
+	});
+	const migrationPlan = plannerResult.plan;
+	if (mode === "plan") {
+		const planSql = extractOperationStatements(familyInstance.familyId, migrationPlan.operations);
+		return ok({
+			mode: "plan",
+			plan: {
+				operations: stripOperations(migrationPlan.operations),
+				...planSql !== void 0 ? { sql: planSql } : {}
+			},
+			destination: {
+				storageHash: migrationPlan.destination.storageHash,
+				...ifDefined("profileHash", migrationPlan.destination.profileHash)
+			},
+			summary: `Planned ${migrationPlan.operations.length} operation(s)`
+		});
+	}
+	if (!options.acceptDataLoss) {
+		const destructiveOps = migrationPlan.operations.filter((op) => op.operationClass === "destructive").map((op) => ({
+			id: op.id,
+			label: op.label
+		}));
+		if (destructiveOps.length > 0) return notOk({
+			code: "DESTRUCTIVE_CHANGES",
+			summary: `Planned ${destructiveOps.length} destructive operation(s) that require confirmation`,
+			why: "Destructive operations require confirmation — re-run with -y to accept",
+			conflicts: void 0,
+			meta: { destructiveOperations: destructiveOps }
+		});
+	}
+	const applySpanId = "apply";
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanStart",
+		spanId: applySpanId,
+		label: "Applying migration plan"
+	});
+	const callbacks = createOperationCallbacks(onProgress, "dbUpdate", applySpanId);
+	const runnerResult = await runner.execute({
+		plan: migrationPlan,
+		driver,
+		destinationContract: contract,
+		policy,
+		...callbacks ? { callbacks } : {},
+		executionChecks: {
+			prechecks: false,
+			postchecks: false,
+			idempotencyChecks: false
+		},
+		frameworkComponents
+	});
+	if (!runnerResult.ok) {
+		onProgress?.({
+			action: "dbUpdate",
+			kind: "spanEnd",
+			spanId: applySpanId,
+			outcome: "error"
+		});
+		return notOk({
+			code: "RUNNER_FAILED",
+			summary: runnerResult.failure.summary,
+			why: runnerResult.failure.why,
+			meta: runnerResult.failure.meta,
+			conflicts: void 0
+		});
+	}
+	const execution = runnerResult.value;
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanEnd",
+		spanId: applySpanId,
+		outcome: "ok"
+	});
+	return ok({
+		mode: "apply",
+		plan: { operations: stripOperations(migrationPlan.operations) },
+		destination: {
+			storageHash: migrationPlan.destination.storageHash,
+			...ifDefined("profileHash", migrationPlan.destination.profileHash)
+		},
+		execution: {
+			operationsPlanned: execution.operationsPlanned,
+			operationsExecuted: execution.operationsExecuted
+		},
+		marker: migrationPlan.destination.profileHash ? {
+			storageHash: migrationPlan.destination.storageHash,
+			profileHash: migrationPlan.destination.profileHash
+		} : { storageHash: migrationPlan.destination.storageHash },
+		summary: execution.operationsExecuted === 0 ? "Database already matches contract, signature updated" : `Applied ${execution.operationsExecuted} operation(s), signature updated`
+	});
+}
+
+//#endregion
+//#region src/control-api/operations/migration-apply.ts
+async function executeMigrationApply(options) {
+	const { driver, familyInstance, originHash, destinationHash, pendingMigrations, migrations, frameworkComponents, targetId, onProgress } = options;
+	if (pendingMigrations.length === 0) {
+		if (originHash !== destinationHash) return notOk({
+			code: "MIGRATION_PATH_NOT_FOUND",
+			summary: "No migrations provided for requested origin and destination",
+			why: `Requested ${originHash} -> ${destinationHash} but pendingMigrations is empty`,
+			meta: {
+				originHash,
+				destinationHash
+			}
+		});
+		return ok({
+			migrationsApplied: 0,
+			markerHash: originHash,
+			applied: [],
+			summary: "Already up to date"
+		});
+	}
+	const firstMigration = pendingMigrations[0];
+	const lastMigration = pendingMigrations[pendingMigrations.length - 1];
+	if (firstMigration.from !== originHash || lastMigration.to !== destinationHash) return notOk({
+		code: "MIGRATION_PATH_NOT_FOUND",
+		summary: "Migration apply path does not match requested origin and destination",
+		why: `Path resolved as ${firstMigration.from} -> ${lastMigration.to}, but requested ${originHash} -> ${destinationHash}`,
+		meta: {
+			originHash,
+			destinationHash,
+			pathOrigin: firstMigration.from,
+			pathDestination: lastMigration.to
+		}
+	});
+	for (let i = 1; i < pendingMigrations.length; i++) {
+		const previous = pendingMigrations[i - 1];
+		const current = pendingMigrations[i];
+		if (previous.to !== current.from) return notOk({
+			code: "MIGRATION_PATH_NOT_FOUND",
+			summary: "Migration apply path contains a discontinuity between adjacent migrations",
+			why: `Migration "${previous.dirName}" ends at ${previous.to}, but next migration "${current.dirName}" starts at ${current.from}`,
+			meta: {
+				originHash,
+				destinationHash,
+				previousDirName: previous.dirName,
+				previousTo: previous.to,
+				currentDirName: current.dirName,
+				currentFrom: current.from,
+				discontinuityIndex: i
+			}
+		});
+	}
+	const runner = migrations.createRunner(familyInstance);
+	const applied = [];
+	for (const migration of pendingMigrations) {
+		const migrationSpanId = `migration:${migration.dirName}`;
+		onProgress?.({
+			action: "migrationApply",
+			kind: "spanStart",
+			spanId: migrationSpanId,
+			label: `Applying ${migration.dirName}`
+		});
+		const { operations } = migration;
+		const policy = { allowedOperationClasses: [
+			"additive",
+			"widening",
+			"destructive",
+			"data"
+		] };
+		const plan = {
+			targetId,
+			origin: migration.from === EMPTY_CONTRACT_HASH ? null : { storageHash: migration.from },
+			destination: { storageHash: migration.to },
+			operations
+		};
+		const destinationContract = familyInstance.validateContract(migration.toContract);
+		const runnerResult = await runner.execute({
+			plan,
+			driver,
+			destinationContract,
+			policy,
+			executionChecks: {
+				prechecks: true,
+				postchecks: true,
+				idempotencyChecks: true
+			},
+			frameworkComponents
+		});
+		if (!runnerResult.ok) {
+			onProgress?.({
+				action: "migrationApply",
+				kind: "spanEnd",
+				spanId: migrationSpanId,
+				outcome: "error"
+			});
+			return notOk({
+				code: "RUNNER_FAILED",
+				summary: runnerResult.failure.summary,
+				why: runnerResult.failure.why,
+				meta: {
+					migration: migration.dirName,
+					from: migration.from,
+					to: migration.to,
+					...runnerResult.failure.meta ?? {}
+				}
+			});
+		}
+		onProgress?.({
+			action: "migrationApply",
+			kind: "spanEnd",
+			spanId: migrationSpanId,
+			outcome: "ok"
+		});
+		applied.push({
+			dirName: migration.dirName,
+			from: migration.from,
+			to: migration.to,
+			operationsExecuted: runnerResult.value.operationsExecuted
+		});
+	}
+	const finalHash = pendingMigrations[pendingMigrations.length - 1].to;
+	const totalOps = applied.reduce((sum, a) => sum + a.operationsExecuted, 0);
+	return ok({
+		migrationsApplied: applied.length,
+		markerHash: finalHash,
+		applied,
+		summary: `Applied ${applied.length} migration(s) (${totalOps} operation(s)), marker at ${finalHash}`
+	});
+}
+
+//#endregion
+//#region src/control-api/client.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
+*/
+function createControlClient(options) {
+	return new ControlClientImpl(options);
+}
+/**
+* Implementation of ControlClient.
+* Manages initialization and connection state, delegates operations to family instance.
+*/
+var ControlClientImpl = class {
+	options;
+	stack = null;
+	driver = null;
+	familyInstance = null;
+	frameworkComponents = null;
+	initialized = false;
+	defaultConnection;
+	constructor(options) {
+		this.options = options;
+		this.defaultConnection = options.connection;
+	}
+	init() {
+		if (this.initialized) return;
+		this.stack = createControlStack({
+			family: this.options.family,
+			target: this.options.target,
+			adapter: this.options.adapter,
+			driver: this.options.driver,
+			extensionPacks: this.options.extensionPacks
+		});
+		this.familyInstance = this.options.family.create(this.stack);
+		const rawComponents = [
+			this.options.target,
+			this.options.adapter,
+			...this.options.extensionPacks ?? []
+		];
+		this.frameworkComponents = assertFrameworkComponentsCompatible(this.options.family.familyId, this.options.target.targetId, rawComponents);
+		this.initialized = true;
+	}
+	async connect(connection) {
+		this.init();
+		if (this.driver) throw new Error("Already connected. Call close() before reconnecting.");
+		const resolvedConnection = connection ?? this.defaultConnection;
+		if (resolvedConnection === void 0) throw new Error("No connection provided. Pass a connection to connect() or provide a default connection when creating the client.");
+		if (!this.stack?.driver) throw new Error("Driver is not configured. Pass a driver descriptor when creating the control client to enable database operations.");
+		this.driver = await this.stack.driver.create(resolvedConnection);
+	}
+	async close() {
+		if (this.driver) {
+			await this.driver.close();
+			this.driver = null;
+		}
+	}
+	async ensureConnected() {
+		this.init();
+		if (!this.driver && this.defaultConnection !== void 0) await this.connect(this.defaultConnection);
+		if (!this.driver || !this.familyInstance || !this.frameworkComponents) throw new Error("Not connected. Call connect(connection) first.");
+		return {
+			driver: this.driver,
+			familyInstance: this.familyInstance,
+			frameworkComponents: this.frameworkComponents
+		};
+	}
+	async connectWithProgress(connection, action, onProgress) {
+		if (connection === void 0) return;
+		onProgress?.({
+			action,
+			kind: "spanStart",
+			spanId: "connect",
+			label: "Connecting to database..."
+		});
+		try {
+			await this.connect(connection);
+			onProgress?.({
+				action,
+				kind: "spanEnd",
+				spanId: "connect",
+				outcome: "ok"
+			});
+		} catch (error) {
+			onProgress?.({
+				action,
+				kind: "spanEnd",
+				spanId: "connect",
+				outcome: "error"
+			});
+			throw error;
+		}
+	}
+	async verify(options) {
+		const { onProgress } = options;
+		await this.connectWithProgress(options.connection, "verify", onProgress);
+		const { driver, familyInstance } = await this.ensureConnected();
+		let contract;
+		try {
+			contract = familyInstance.validateContract(options.contract);
+		} catch (error) {
+			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
+		}
+		onProgress?.({
+			action: "verify",
+			kind: "spanStart",
+			spanId: "verify",
+			label: "Verifying database marker..."
+		});
+		try {
+			const result = await familyInstance.verify({
+				driver,
+				contract,
+				expectedTargetId: this.options.target.targetId,
+				contractPath: ""
+			});
+			onProgress?.({
+				action: "verify",
+				kind: "spanEnd",
+				spanId: "verify",
+				outcome: result.ok ? "ok" : "error"
+			});
+			return result;
+		} catch (error) {
+			onProgress?.({
+				action: "verify",
+				kind: "spanEnd",
+				spanId: "verify",
+				outcome: "error"
+			});
+			throw error;
+		}
+	}
+	async schemaVerify(options) {
+		const { onProgress } = options;
+		await this.connectWithProgress(options.connection, "schemaVerify", onProgress);
+		const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
+		let contract;
+		try {
+			contract = familyInstance.validateContract(options.contract);
+		} catch (error) {
+			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
+		}
+		onProgress?.({
+			action: "schemaVerify",
+			kind: "spanStart",
+			spanId: "schemaVerify",
+			label: "Verifying database schema..."
+		});
+		try {
+			const result = await familyInstance.schemaVerify({
+				driver,
+				contract,
+				strict: options.strict ?? false,
+				contractPath: "",
+				frameworkComponents
+			});
+			onProgress?.({
+				action: "schemaVerify",
+				kind: "spanEnd",
+				spanId: "schemaVerify",
+				outcome: result.ok ? "ok" : "error"
+			});
+			return result;
+		} catch (error) {
+			onProgress?.({
+				action: "schemaVerify",
+				kind: "spanEnd",
+				spanId: "schemaVerify",
+				outcome: "error"
+			});
+			throw error;
+		}
+	}
+	async sign(options) {
+		const { onProgress } = options;
+		await this.connectWithProgress(options.connection, "sign", onProgress);
+		const { driver, familyInstance } = await this.ensureConnected();
+		let contract;
+		try {
+			contract = familyInstance.validateContract(options.contract);
+		} catch (error) {
+			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
+		}
+		onProgress?.({
+			action: "sign",
+			kind: "spanStart",
+			spanId: "sign",
+			label: "Signing database..."
+		});
+		try {
+			const result = await familyInstance.sign({
+				driver,
+				contract,
+				contractPath: options.contractPath ?? "",
+				...ifDefined("configPath", options.configPath)
+			});
+			onProgress?.({
+				action: "sign",
+				kind: "spanEnd",
+				spanId: "sign",
+				outcome: "ok"
+			});
+			return result;
+		} catch (error) {
+			onProgress?.({
+				action: "sign",
+				kind: "spanEnd",
+				spanId: "sign",
+				outcome: "error"
+			});
+			throw error;
+		}
+	}
+	async dbInit(options) {
+		const { onProgress } = options;
+		await this.connectWithProgress(options.connection, "dbInit", onProgress);
+		const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
+		if (!hasMigrations(this.options.target)) throw new Error(`Target "${this.options.target.targetId}" does not support migrations`);
+		let contract;
+		try {
+			contract = familyInstance.validateContract(options.contract);
+		} catch (error) {
+			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
+		}
+		return executeDbInit({
+			driver,
+			familyInstance,
+			contract,
+			mode: options.mode,
+			migrations: this.options.target.migrations,
+			frameworkComponents,
+			...ifDefined("onProgress", onProgress)
+		});
+	}
+	async dbUpdate(options) {
+		const { onProgress } = options;
+		await this.connectWithProgress(options.connection, "dbUpdate", onProgress);
+		const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
+		if (!hasMigrations(this.options.target)) throw new Error(`Target "${this.options.target.targetId}" does not support migrations`);
+		let contract;
+		try {
+			contract = familyInstance.validateContract(options.contract);
+		} catch (error) {
+			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
+		}
+		return executeDbUpdate({
+			driver,
+			familyInstance,
+			contract,
+			mode: options.mode,
+			migrations: this.options.target.migrations,
+			frameworkComponents,
+			...ifDefined("acceptDataLoss", options.acceptDataLoss),
+			...ifDefined("onProgress", onProgress)
+		});
+	}
+	async readMarker() {
+		const { driver, familyInstance } = await this.ensureConnected();
+		return familyInstance.readMarker({ driver });
+	}
+	async migrationApply(options) {
+		const { onProgress } = options;
+		await this.connectWithProgress(options.connection, "migrationApply", onProgress);
+		const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
+		if (!hasMigrations(this.options.target)) throw new Error(`Target "${this.options.target.targetId}" does not support migrations`);
+		return executeMigrationApply({
+			driver,
+			familyInstance,
+			originHash: options.originHash,
+			destinationHash: options.destinationHash,
+			pendingMigrations: options.pendingMigrations,
+			migrations: this.options.target.migrations,
+			frameworkComponents,
+			targetId: this.options.target.targetId,
+			...onProgress ? { onProgress } : {}
+		});
+	}
+	async introspect(options) {
+		const onProgress = options?.onProgress;
+		await this.connectWithProgress(options?.connection, "introspect", onProgress);
+		const { driver, familyInstance } = await this.ensureConnected();
+		options?.schema;
+		onProgress?.({
+			action: "introspect",
+			kind: "spanStart",
+			spanId: "introspect",
+			label: "Introspecting database schema..."
+		});
+		try {
+			const result = await familyInstance.introspect({ driver });
+			onProgress?.({
+				action: "introspect",
+				kind: "spanEnd",
+				spanId: "introspect",
+				outcome: "ok"
+			});
+			return result;
+		} catch (error) {
+			onProgress?.({
+				action: "introspect",
+				kind: "spanEnd",
+				spanId: "introspect",
+				outcome: "error"
+			});
+			throw error;
+		}
+	}
+	toSchemaView(schemaIR) {
+		this.init();
+		if (this.familyInstance && hasSchemaView(this.familyInstance)) return this.familyInstance.toSchemaView(schemaIR);
+	}
+	async emit(options) {
+		const { onProgress, contractConfig } = options;
+		this.init();
+		if (!this.familyInstance) throw new Error("Family instance was not initialized. This is a bug.");
+		let contractRaw;
+		onProgress?.({
+			action: "emit",
+			kind: "spanStart",
+			spanId: "resolveSource",
+			label: "Resolving contract source..."
+		});
+		try {
+			const sourceContext = { composedExtensionPacks: (this.options.extensionPacks ?? []).map((p) => p.id) };
+			const providerResult = await contractConfig.sourceProvider(sourceContext);
+			if (!providerResult.ok) {
+				onProgress?.({
+					action: "emit",
+					kind: "spanEnd",
+					spanId: "resolveSource",
+					outcome: "error"
+				});
+				return notOk({
+					code: "CONTRACT_SOURCE_INVALID",
+					summary: providerResult.failure.summary,
+					why: providerResult.failure.summary,
+					meta: providerResult.failure.meta,
+					diagnostics: providerResult.failure
+				});
+			}
+			contractRaw = providerResult.value;
+			onProgress?.({
+				action: "emit",
+				kind: "spanEnd",
+				spanId: "resolveSource",
+				outcome: "ok"
+			});
+		} catch (error) {
+			onProgress?.({
+				action: "emit",
+				kind: "spanEnd",
+				spanId: "resolveSource",
+				outcome: "error"
+			});
+			const message = error instanceof Error ? error.message : String(error);
+			return notOk({
+				code: "CONTRACT_SOURCE_INVALID",
+				summary: "Failed to resolve contract source",
+				why: message,
+				diagnostics: {
+					summary: "Contract source provider threw an exception",
+					diagnostics: [{
+						code: "PROVIDER_THROW",
+						message
+					}]
+				},
+				meta: void 0
+			});
+		}
+		onProgress?.({
+			action: "emit",
+			kind: "spanStart",
+			spanId: "emit",
+			label: "Emitting contract..."
+		});
+		try {
+			const enrichedIR = enrichContract(contractRaw, this.frameworkComponents ?? []);
+			try {
+				this.familyInstance.validateContract(enrichedIR);
+			} catch (error) {
+				onProgress?.({
+					action: "emit",
+					kind: "spanEnd",
+					spanId: "emit",
+					outcome: "error"
+				});
+				return notOk({
+					code: "CONTRACT_VALIDATION_FAILED",
+					summary: "Contract validation failed",
+					why: error instanceof Error ? error.message : String(error),
+					meta: void 0
+				});
+			}
+			const result = await emit(enrichedIR, this.stack, this.options.family.emission);
+			onProgress?.({
+				action: "emit",
+				kind: "spanEnd",
+				spanId: "emit",
+				outcome: "ok"
+			});
+			return ok({
+				storageHash: result.storageHash,
+				...ifDefined("executionHash", result.executionHash),
+				profileHash: result.profileHash,
+				contractJson: result.contractJson,
+				contractDts: result.contractDts
+			});
+		} catch (error) {
+			onProgress?.({
+				action: "emit",
+				kind: "spanEnd",
+				spanId: "emit",
+				outcome: "error"
+			});
+			return notOk({
+				code: "EMIT_FAILED",
+				summary: "Failed to emit contract",
+				why: error instanceof Error ? error.message : String(error),
+				meta: void 0
+			});
+		}
+	}
+};
+
+//#endregion
+export { ContractValidationError as n, createControlClient as t };
+//# sourceMappingURL=client-DiUkJAeN.mjs.map