prisma-next 0.5.0-dev.8 → 0.5.0-dev.80

package/dist/client-CrsnY58k.mjs

@@ -1,997 +0,0 @@
-import { t as assertFrameworkComponentsCompatible } from "./framework-components-Cr--XBKy.mjs";
-import { t as enrichContract } from "./contract-enrichment-CAOELa-H.mjs";
-import { t as extractOperationStatements } from "./extract-operation-statements-DsFfxXVZ.mjs";
-import { emit } from "@prisma-next/emitter";
-import { notOk, ok } from "@prisma-next/utils/result";
-import { ifDefined } from "@prisma-next/utils/defined";
-import { createControlStack, hasMigrations, hasSchemaView } from "@prisma-next/framework-components/control";
-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,
-		fromHash: "",
-		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,
-		fromHash: "",
-		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 stack = this.stack;
-			const sourceContext = {
-				composedExtensionPacks: stack.extensionPacks.map((p) => p.id),
-				scalarTypeDescriptors: stack.scalarTypeDescriptors,
-				authoringContributions: stack.authoringContributions,
-				codecLookup: stack.codecLookup,
-				controlMutationDefaults: stack.controlMutationDefaults,
-				resolvedInputs: contractConfig.source.inputs ?? []
-			};
-			const providerResult = await contractConfig.source.load(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-CrsnY58k.mjs.map