prisma-next 0.5.0-dev.67 → 0.5.0-dev.68

package/dist/client-0ZX24FXF.mjs

@@ -0,0 +1,1398 @@
+import { p as errorRunnerFailed, t as CliStructuredError } from "./cli-errors-D3_sMh2K.mjs";
+import { t as assertFrameworkComponentsCompatible } from "./framework-components-gwAHl7ml.mjs";
+import { t as enrichContract } from "./contract-enrichment-CF6ogEJ_.mjs";
+import { emit } from "@prisma-next/emitter";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { notOk, ok } from "@prisma-next/utils/result";
+import { APP_SPACE_ID, createControlStack, hasMigrations, hasMultiSpaceRunner, hasOperationPreview, hasPslContractInfer, hasSchemaView } from "@prisma-next/framework-components/control";
+import { loadContractSpaceAggregate, planAggregate, verifyAggregate } from "@prisma-next/migration-tools/aggregate";
+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/utils/contract-space-aggregate-loader.ts
+/**
+* Convert the CLI's `Config.extensionPacks` array into the loader's
+* `DeclaredExtensionEntry[]` shape.
+*
+* The loader hashes `contractSpace.contractJson` to compare against the
+* on-disk `refs/head.json.hash` (drift detection). Rather than re-running
+* the canonical-JSON + SHA-256 pipeline at the CLI surface, we look up
+* the descriptor's pre-computed `headRef.hash` via reference identity
+* on the contract JSON value — the loader passes the same
+* `entry.contractSpace.contractJson` reference through to the hasher,
+* so identity-keyed lookup is safe.
+*/
+function toDeclaredExtensions(extensionPacks) {
+	const entries = [];
+	const hashByContractJson = /* @__PURE__ */ new Map();
+	for (const pack of extensionPacks) {
+		const entry = pack.contractSpace ? {
+			id: pack.id,
+			targetId: pack.targetId,
+			contractSpace: { contractJson: pack.contractSpace.contractJson }
+		} : {
+			id: pack.id,
+			targetId: pack.targetId
+		};
+		entries.push(entry);
+		if (pack.contractSpace) hashByContractJson.set(pack.contractSpace.contractJson, pack.contractSpace.headRef.hash);
+	}
+	return {
+		entries,
+		hashByContractJson
+	};
+}
+/**
+* Render a {@link LoadAggregateError} into a CLI structured-error
+* envelope. Preserves error codes `5001` (layout) and `5002` (marker /
+* drift / disjointness / etc.) so existing integration tests and
+* downstream tooling continue to assert on the same `meta.violations[]`
+* shape they did under the old precheck/marker-check helpers.
+*/
+function mapLoadAggregateError(error) {
+	if (error.kind === "layoutViolation") {
+		const lines = error.violations.map((v) => `- [${v.kind}] ${v.spaceId}`);
+		return new CliStructuredError("5001", error.violations.length === 1 ? "Contract-space layout violation detected" : `Contract-space layout violations detected (${error.violations.length})`, {
+			domain: "MIG",
+			why: `The on-disk \`migrations/\` directory and your \`extensionPacks\` declaration are not in agreement.\n${lines.join("\n")}`,
+			fix: "Run `prisma-next migrate` to materialise on-disk artefacts for declared extensions, or remove the orphan directory.",
+			docsUrl: "https://pris.ly/contract-spaces",
+			meta: { violations: error.violations.map((v) => ({
+				kind: v.kind,
+				spaceId: v.spaceId
+			})) }
+		});
+	}
+	if (error.kind === "driftViolation") return new CliStructuredError("5002", `Contract-space drift detected for "${error.spaceId}"`, {
+		domain: "MIG",
+		why: `The on-disk contract for space "${error.spaceId}" (hash ${error.priorHeadHash}) does not match the live extension descriptor (hash ${error.liveHash}).`,
+		fix: "Run `prisma-next migrate` to refresh the on-disk artefacts to match the live descriptor.",
+		docsUrl: "https://pris.ly/contract-spaces",
+		meta: { violations: [{
+			kind: "drift",
+			spaceId: error.spaceId,
+			priorHeadHash: error.priorHeadHash,
+			liveHash: error.liveHash
+		}] }
+	});
+	if (error.kind === "disjointnessViolation") return new CliStructuredError("5002", `Contract-space disjointness violation: storage element "${error.element}" claimed by multiple spaces`, {
+		domain: "MIG",
+		why: `Spaces ${error.claimedBy.map((s) => `"${s}"`).join(", ")} all claim the storage element "${error.element}". Each storage element must be owned by exactly one contract space.`,
+		fix: "Update the conflicting contracts so each storage element is claimed by exactly one space.",
+		docsUrl: "https://pris.ly/contract-spaces",
+		meta: { violations: [{
+			kind: "disjointness",
+			spaceId: error.claimedBy.join(","),
+			element: error.element,
+			claimedBy: error.claimedBy
+		}] }
+	});
+	if (error.kind === "integrityFailure") return new CliStructuredError("5002", `Contract-space integrity failure for "${error.spaceId}"`, {
+		domain: "MIG",
+		why: error.detail,
+		fix: "Run `prisma-next migrate` to refresh on-disk artefacts, or restore the on-disk `migrations/` directory from version control.",
+		docsUrl: "https://pris.ly/contract-spaces",
+		meta: { violations: [{
+			kind: "integrity",
+			spaceId: error.spaceId,
+			detail: error.detail
+		}] }
+	});
+	if (error.kind === "validationFailure") return new CliStructuredError("5002", `Contract-space contract validation failed for "${error.spaceId}"`, {
+		domain: "MIG",
+		why: error.detail,
+		fix: "Run `prisma-next migrate` to refresh on-disk artefacts, or fix the extension descriptor producing the invalid contract.",
+		meta: { violations: [{
+			kind: "validation",
+			spaceId: error.spaceId,
+			detail: error.detail
+		}] }
+	});
+	return new CliStructuredError("5002", `Contract-space target mismatch for "${error.spaceId}"`, {
+		domain: "MIG",
+		why: `Space "${error.spaceId}" targets "${error.actual}" but the project's adapter targets "${error.expected}".`,
+		fix: "Update the extension descriptor to target the configured database, or change the project adapter.",
+		meta: { violations: [{
+			kind: "targetMismatch",
+			spaceId: error.spaceId,
+			expected: error.expected,
+			actual: error.actual
+		}] }
+	});
+}
+/**
+* Run the aggregate loader at the CLI surface, mapping any
+* {@link LoadAggregateError} into a {@link CliStructuredError} envelope.
+*
+* App-side migration packages are intentionally not threaded through:
+* `db init` / `db update` go through the planner's `synth` strategy for
+* the app member (driven by `callerPolicy.ignoreGraphFor`), so the
+* app's authored `migrations/` graph is not walked.
+*
+* @see specs/contract-space-aggregate-spec.md § Loader.
+*/
+async function buildContractSpaceAggregate(inputs) {
+	const { entries, hashByContractJson } = toDeclaredExtensions(inputs.extensionPacks);
+	const result = await loadContractSpaceAggregate({
+		targetId: inputs.targetId,
+		migrationsDir: inputs.migrationsDir,
+		appContract: inputs.appContract,
+		declaredExtensions: entries,
+		validateContract: inputs.validateContract,
+		hashContract: (contractJson) => {
+			const precomputed = hashByContractJson.get(contractJson);
+			if (precomputed === void 0) throw new Error("CLI aggregate loader: encountered an extension contract without a pre-computed descriptor hash. This is a wiring bug.");
+			return precomputed;
+		},
+		appMigrationPackages: []
+	});
+	if (!result.ok) return notOk(mapLoadAggregateError(result.failure));
+	return ok(result.value.aggregate);
+}
+//#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
+	}));
+}
+//#endregion
+//#region src/control-api/operations/db-apply-aggregate.ts
+/**
+* Span IDs emitted via `onProgress` during the aggregate apply flow.
+* Stable identifiers consumed by the structured-output renderer and by
+* tests asserting on span ids.
+*/
+const SPAN_IDS$1 = {
+	introspect: "introspect",
+	plan: "plan",
+	apply: "apply"
+};
+/**
+* Loader → planner → runner pipeline shared by `db init` and `db update`.
+*
+* The pipeline:
+*
+* 1. **Load**: build a {@link ContractSpaceAggregate} from the descriptor
+*    set + on-disk on-disk artefacts. Any layout / drift / disjointness /
+*    integrity violation short-circuits with a structured error.
+* 2. **Read DB state**: marker rows (`familyInstance.readAllMarkers`)
+*    + introspected schema (`familyInstance.introspect`).
+* 3. **Plan**: {@link planAggregate} chooses graph-walk vs synth per
+*    member according to `callerPolicy.ignoreGraphFor`. The app member
+*    is forced through synth (today's daily-driver behaviour); every
+*    extension member walks its on-disk graph.
+* 4. **Apply** (when `mode === 'apply'`): every per-space `MigrationPlan`
+*    feeds into the runner's `executeAcrossSpaces` — one outer
+*    transaction across every space; failure on any space rolls back
+*    every space's writes.
+*/
+async function executeAggregateApply(options) {
+	const { driver, familyInstance, contract, mode, migrations, frameworkComponents, migrationsDir, extensionPacks, targetId, policy, action, onProgress } = options;
+	const loaded = await buildContractSpaceAggregate({
+		targetId,
+		migrationsDir,
+		appContract: contract,
+		extensionPacks,
+		validateContract: (json) => familyInstance.validateContract(json)
+	});
+	if (!loaded.ok) throw loaded.failure;
+	const aggregate = loaded.value;
+	const markerRows = await familyInstance.readAllMarkers({ driver });
+	const orphanMarkerError = detectOrphanMarkers(aggregate, markerRows);
+	if (orphanMarkerError !== null) throw orphanMarkerError;
+	onProgress?.({
+		action,
+		kind: "spanStart",
+		spanId: SPAN_IDS$1.introspect,
+		label: "Introspecting database schema"
+	});
+	const schemaIR = await familyInstance.introspect({ driver });
+	onProgress?.({
+		action,
+		kind: "spanEnd",
+		spanId: SPAN_IDS$1.introspect,
+		outcome: "ok"
+	});
+	onProgress?.({
+		action,
+		kind: "spanStart",
+		spanId: SPAN_IDS$1.plan,
+		label: "Planning migration"
+	});
+	const planResult = await planAggregate({
+		aggregate,
+		currentDBState: {
+			markersBySpaceId: markerRows,
+			schemaIntrospection: schemaIR
+		},
+		familyInstance,
+		migrations,
+		frameworkComponents,
+		callerPolicy: { ignoreGraphFor: new Set([aggregate.app.spaceId]) },
+		operationPolicy: policy
+	});
+	if (!planResult.ok) {
+		onProgress?.({
+			action,
+			kind: "spanEnd",
+			spanId: SPAN_IDS$1.plan,
+			outcome: "error"
+		});
+		return mapPlannerError(planResult.failure);
+	}
+	onProgress?.({
+		action,
+		kind: "spanEnd",
+		spanId: SPAN_IDS$1.plan,
+		outcome: "ok"
+	});
+	const orderedResolutions = collectOrdered(planResult.value.applyOrder, planResult.value.perSpace);
+	const appResolution = orderedResolutions.find((r) => r.spaceId === aggregate.app.spaceId);
+	if (!appResolution) throw new Error("Aggregate planner returned no plan for the app member — the planner is supposed to always emit one.");
+	const appPlan = appResolution.entry.plan;
+	if (mode === "plan") {
+		const aggregateOps = orderedResolutions.flatMap((r) => r.entry.displayOps);
+		const preview = hasOperationPreview(familyInstance) ? familyInstance.toOperationPreview(aggregateOps) : void 0;
+		const summary = `Planned ${aggregateOps.length} operation(s) across ${orderedResolutions.length} space(s)`;
+		return wrapPlanResult({
+			operations: aggregateOps,
+			destination: appPlan.destination,
+			preview,
+			summary
+		});
+	}
+	const runner = migrations.createRunner(familyInstance);
+	if (!hasMultiSpaceRunner(runner)) throw errorRunnerFailed(`Runner for target "${aggregate.targetId}" does not implement \`executeAcrossSpaces\``, { why: `${action === "dbInit" ? "db init" : "db update"} requires multi-space-capable runners (today: every SQL family runner).` });
+	onProgress?.({
+		action,
+		kind: "spanStart",
+		spanId: SPAN_IDS$1.apply,
+		label: "Applying migration plan across spaces"
+	});
+	const perSpaceOptions = orderedResolutions.map((r) => ({
+		space: r.spaceId,
+		plan: r.entry.plan,
+		driver,
+		destinationContract: r.entry.destinationContract,
+		policy,
+		executionChecks: {
+			prechecks: false,
+			postchecks: false,
+			idempotencyChecks: false
+		},
+		frameworkComponents,
+		strictVerification: false
+	}));
+	const runnerResult = await runner.executeAcrossSpaces({
+		driver,
+		perSpaceOptions
+	});
+	if (!runnerResult.ok) {
+		onProgress?.({
+			action,
+			kind: "spanEnd",
+			spanId: SPAN_IDS$1.apply,
+			outcome: "error"
+		});
+		return buildRunnerFailure({
+			summary: runnerResult.failure.summary,
+			...ifDefined("why", runnerResult.failure.why),
+			meta: {
+				...runnerResult.failure.meta ?? {},
+				failingSpace: runnerResult.failure.failingSpace
+			}
+		});
+	}
+	onProgress?.({
+		action,
+		kind: "spanEnd",
+		spanId: SPAN_IDS$1.apply,
+		outcome: "ok"
+	});
+	const totalOpsPlanned = runnerResult.value.perSpaceResults.reduce((sum, r) => sum + r.value.operationsPlanned, 0);
+	const totalOpsExecuted = runnerResult.value.perSpaceResults.reduce((sum, r) => sum + r.value.operationsExecuted, 0);
+	const aggregateOps = orderedResolutions.flatMap((r) => r.entry.displayOps);
+	const summary = action === "dbInit" ? `Applied ${totalOpsExecuted} operation(s) across ${orderedResolutions.length} space(s), database signed` : totalOpsExecuted === 0 ? `Database already matches contract across ${orderedResolutions.length} space(s), signature updated` : `Applied ${totalOpsExecuted} operation(s) across ${orderedResolutions.length} space(s), signature updated`;
+	return wrapApplyResult({
+		operations: aggregateOps,
+		destination: appPlan.destination,
+		operationsPlanned: totalOpsPlanned,
+		operationsExecuted: totalOpsExecuted,
+		summary
+	});
+}
+/**
+* Compare the live `_prisma_marker` rows against the aggregate's
+* declared members. Any marker row whose `space` is not a member of
+* the aggregate is an "orphan" — typically a marker left behind by
+* an extension that was removed from `extensionPacks` without first
+* cleaning up its on-disk migrations / database tables.
+*
+* Returns a {@link CliStructuredError} envelope (code `5002`,
+* `kind: 'orphanMarker'`) for the first orphan it finds, or `null`
+* when every marker row maps to a declared member. Mirrors the M2
+* `runContractSpaceVerifierMarkerCheck` envelope so downstream
+* tooling (integration tests, JSON consumers) keeps asserting on the
+* same shape.
+*/
+function detectOrphanMarkers(aggregate, markerRows) {
+	const memberSpaceIds = new Set([aggregate.app.spaceId, ...aggregate.extensions.map((m) => m.spaceId)]);
+	const orphans = [];
+	for (const [spaceId, row] of markerRows) if (row !== null && row !== void 0 && !memberSpaceIds.has(spaceId)) orphans.push(spaceId);
+	if (orphans.length === 0) return null;
+	orphans.sort((a, b) => a.localeCompare(b));
+	return new CliStructuredError("5002", orphans.length === 1 ? `Orphan contract-space marker detected for "${orphans[0]}"` : `Orphan contract-space markers detected for ${orphans.length} spaces`, {
+		domain: "MIG",
+		why: `The database has \`_prisma_marker\` rows for spaces (${orphans.map((s) => `"${s}"`).join(", ")}) that are not declared in the project's \`extensionPacks\`. The aggregate pipeline refuses to advance markers it cannot account for.`,
+		fix: "Either re-declare the missing extension(s) in `extensionPacks` (so the aggregate owns them again), or remove the orphan marker row(s) from `_prisma_marker` once you have confirmed the corresponding tables can be safely retired.",
+		docsUrl: "https://pris.ly/contract-spaces",
+		meta: { violations: orphans.map((spaceId) => ({
+			kind: "orphanMarker",
+			spaceId
+		})) }
+	});
+}
+function collectOrdered(applyOrder, perSpace) {
+	return applyOrder.map((spaceId) => {
+		const entry = perSpace.get(spaceId);
+		if (!entry) throw new Error(`Aggregate planner output missing per-space plan for "${spaceId}"`);
+		return {
+			spaceId,
+			entry
+		};
+	});
+}
+function mapPlannerError(error) {
+	if (error.kind === "appSynthFailure") return notOk({
+		code: "PLANNING_FAILED",
+		summary: "Migration planning failed due to conflicts",
+		conflicts: error.conflicts,
+		why: void 0,
+		meta: void 0
+	});
+	if (error.kind === "extensionPathUnreachable") return buildRunnerFailure({
+		summary: `Cannot resolve apply path for extension space "${error.spaceId}"`,
+		why: `No path in the on-disk migration graph for extension space "${error.spaceId}" reaches the on-disk head ref hash "${error.target}".`,
+		meta: {
+			spaceId: error.spaceId,
+			target: error.target
+		}
+	});
+	if (error.kind === "extensionPathUnsatisfiable") return buildRunnerFailure({
+		summary: `Cannot resolve apply path for extension space "${error.spaceId}"`,
+		why: `On-disk migration graph for extension space "${error.spaceId}" reaches the on-disk head ref but does not cover required invariants: ${error.missingInvariants.join(", ")}.`,
+		meta: {
+			spaceId: error.spaceId,
+			missingInvariants: error.missingInvariants
+		}
+	});
+	return buildRunnerFailure({
+		summary: `Aggregate planner policy conflict for space "${error.spaceId}"`,
+		why: error.detail,
+		meta: { spaceId: error.spaceId }
+	});
+}
+function wrapPlanResult(args) {
+	return ok({
+		mode: "plan",
+		plan: {
+			operations: stripOperations(args.operations),
+			...ifDefined("preview", args.preview)
+		},
+		destination: {
+			storageHash: args.destination.storageHash,
+			...ifDefined("profileHash", args.destination.profileHash)
+		},
+		summary: args.summary
+	});
+}
+function wrapApplyResult(args) {
+	return ok({
+		mode: "apply",
+		plan: { operations: stripOperations(args.operations) },
+		destination: {
+			storageHash: args.destination.storageHash,
+			...ifDefined("profileHash", args.destination.profileHash)
+		},
+		execution: {
+			operationsPlanned: args.operationsPlanned,
+			operationsExecuted: args.operationsExecuted
+		},
+		marker: args.destination.profileHash ? {
+			storageHash: args.destination.storageHash,
+			profileHash: args.destination.profileHash
+		} : { storageHash: args.destination.storageHash },
+		summary: args.summary
+	});
+}
+function buildRunnerFailure(args) {
+	return notOk({
+		code: "RUNNER_FAILED",
+		summary: args.summary,
+		why: args.why,
+		meta: args.meta,
+		conflicts: void 0
+	});
+}
+//#endregion
+//#region src/control-api/operations/db-init.ts
+/**
+* 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`.
+*/
+async function executeDbInit(options) {
+	return await executeAggregateApply({
+		driver: options.driver,
+		familyInstance: options.familyInstance,
+		contract: options.contract,
+		mode: options.mode,
+		migrations: options.migrations,
+		frameworkComponents: options.frameworkComponents,
+		migrationsDir: options.migrationsDir,
+		targetId: options.targetId,
+		extensionPacks: options.extensionPacks ?? [],
+		policy: { allowedOperationClasses: ["additive"] },
+		action: "dbInit",
+		...ifDefined("onProgress", options.onProgress)
+	});
+}
+//#endregion
+//#region src/control-api/operations/db-update.ts
+const DB_UPDATE_POLICY = { allowedOperationClasses: [
+	"additive",
+	"widening",
+	"destructive"
+] };
+/**
+* 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.
+*/
+async function executeDbUpdate(options) {
+	const sharedInputs = {
+		driver: options.driver,
+		familyInstance: options.familyInstance,
+		contract: options.contract,
+		migrations: options.migrations,
+		frameworkComponents: options.frameworkComponents,
+		migrationsDir: options.migrationsDir,
+		targetId: options.targetId,
+		extensionPacks: options.extensionPacks ?? [],
+		policy: DB_UPDATE_POLICY,
+		action: "dbUpdate",
+		...ifDefined("onProgress", options.onProgress)
+	};
+	if (options.mode === "apply" && !options.acceptDataLoss) {
+		const gate = await guardDestructiveChanges(sharedInputs);
+		if (gate !== null) return gate;
+	}
+	return await executeAggregateApply({
+		...sharedInputs,
+		mode: options.mode
+	});
+}
+/**
+* Pre-plan once when running `db update apply` without `acceptDataLoss`.
+* Surfaces destructive operations across every space; if any are
+* planned, returns a `DESTRUCTIVE_CHANGES` failure that the CLI shows
+* as a confirmation prompt. Returns `null` when the apply is safe to
+* run.
+*/
+async function guardDestructiveChanges(sharedInputs) {
+	const planResult = await executeAggregateApply({
+		...sharedInputs,
+		mode: "plan"
+	});
+	if (!planResult.ok) return planResult;
+	const destructiveOps = planResult.value.plan.operations.filter((op) => op.operationClass === "destructive").map((op) => ({
+		id: op.id,
+		label: op.label
+	}));
+	if (destructiveOps.length === 0) return null;
+	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 }
+	});
+}
+//#endregion
+//#region src/control-api/operations/db-verify.ts
+/**
+* Span IDs emitted via `onProgress` during the aggregate verify flow.
+* Mirrors the span identifiers used by the legacy precheck / marker-check
+* helpers so structured-output renderers and progress tests keep working.
+*/
+const SPAN_IDS = {
+	introspect: "introspect",
+	verify: "verify"
+};
+/**
+* Loader → verifier pipeline shared by `db verify` modes (`full`,
+* `marker-only`, `schema-only`).
+*
+* 1. **Load**: build a {@link import('@prisma-next/migration-tools/aggregate').ContractSpaceAggregate}
+*    from descriptors + on-disk on-disk artefacts. Layout / drift /
+*    integrity / disjointness violations short-circuit with a
+*    structured CLI error.
+* 2. **Read DB state**: marker rows + (when `skipSchema` is `false`)
+*    schema introspection.
+* 3. **Verify**: {@link verifyAggregate} returns per-space
+*    `markerCheck` + per-space pre-projected `schemaCheck` (closes F23).
+*    Marker mismatches map to `CliStructuredError` (code `5002`) so
+*    callers (CLI command) can render and exit. Schema results are
+*    returned to the caller verbatim.
+*/
+async function executeDbVerify(options) {
+	const { driver, familyInstance, onProgress, skipSchema, skipMarker } = options;
+	const loaded = await buildContractSpaceAggregate(buildLoadInputs(options));
+	if (!loaded.ok) return notOk(loaded.failure);
+	const aggregate = loaded.value;
+	const markersBySpaceId = await familyInstance.readAllMarkers({ driver });
+	const schemaIntrospection = skipSchema ? null : await runIntrospection({
+		driver,
+		familyInstance,
+		onProgress
+	});
+	emitVerifySpan(onProgress, "spanStart");
+	return finaliseVerifyResult({
+		verifyResult: verifyAggregate({
+			aggregate,
+			markersBySpaceId,
+			schemaIntrospection,
+			mode: options.mode,
+			verifySchemaForMember: createPerMemberVerifier(options)
+		}),
+		aggregate,
+		skipMarker,
+		onProgress
+	});
+}
+function buildLoadInputs(options) {
+	return {
+		targetId: options.targetId,
+		migrationsDir: options.migrationsDir,
+		appContract: options.contract,
+		extensionPacks: options.extensionPacks,
+		validateContract: (json) => options.familyInstance.validateContract(json)
+	};
+}
+async function runIntrospection(args) {
+	const { driver, familyInstance, onProgress } = args;
+	onProgress?.({
+		action: "dbVerify",
+		kind: "spanStart",
+		spanId: SPAN_IDS.introspect,
+		label: "Introspecting database schema"
+	});
+	try {
+		const result = await familyInstance.introspect({ driver });
+		onProgress?.({
+			action: "dbVerify",
+			kind: "spanEnd",
+			spanId: SPAN_IDS.introspect,
+			outcome: "ok"
+		});
+		return result;
+	} catch (error) {
+		onProgress?.({
+			action: "dbVerify",
+			kind: "spanEnd",
+			spanId: SPAN_IDS.introspect,
+			outcome: "error"
+		});
+		throw error;
+	}
+}
+/**
+* Build the per-member schema callback handed to the aggregate verifier.
+* When `skipSchema` is true the callback short-circuits with a synthetic
+* `ok` result so the verifier still runs the (cheap) schemaCheck loop
+* without invoking the family's verification path.
+*/
+function createPerMemberVerifier(options) {
+	const { skipSchema, familyInstance, frameworkComponents } = options;
+	return (projectedSchema, member, verifyMode) => {
+		if (skipSchema) return buildSkippedSchemaResult(member);
+		return familyInstance.schemaVerifyAgainstSchema({
+			contract: member.contract,
+			schema: projectedSchema,
+			strict: verifyMode === "strict",
+			frameworkComponents
+		});
+	};
+}
+function emitVerifySpan(onProgress, kind) {
+	if (kind === "spanStart") {
+		onProgress?.({
+			action: "dbVerify",
+			kind: "spanStart",
+			spanId: SPAN_IDS.verify,
+			label: "Verifying contract spaces"
+		});
+		return;
+	}
+	onProgress?.({
+		action: "dbVerify",
+		kind: "spanEnd",
+		spanId: SPAN_IDS.verify,
+		outcome: kind === "spanEndOk" ? "ok" : "error"
+	});
+}
+/**
+* Map an {@link AggregateVerifierOutput} to the operation's
+* {@link ExecuteDbVerifyResult}, applying the `skipMarker` policy used
+* by the CLI's `--schema-only` mode.
+*/
+function finaliseVerifyResult(args) {
+	const { verifyResult, aggregate, skipMarker, onProgress } = args;
+	if (!verifyResult.ok) {
+		emitVerifySpan(onProgress, "spanEndError");
+		return notOk(new CliStructuredError("5002", "Aggregate verifier introspection failed", {
+			domain: "MIG",
+			why: verifyResult.failure.detail,
+			fix: "Check database connectivity and the introspection tooling.",
+			docsUrl: "https://pris.ly/contract-spaces"
+		}));
+	}
+	const markerError = skipMarker ? null : mapMarkerCheckFailures(aggregate.app.spaceId, verifyResult.value.markerCheck);
+	if (markerError !== null) {
+		emitVerifySpan(onProgress, "spanEndError");
+		return notOk(markerError);
+	}
+	emitVerifySpan(onProgress, "spanEndOk");
+	return ok({
+		schemaResults: verifyResult.value.schemaCheck.perSpace,
+		memberOrder: [aggregate.app.spaceId, ...aggregate.extensions.map((e) => e.spaceId)],
+		appSpaceId: aggregate.app.spaceId
+	});
+}
+function buildSkippedSchemaResult(member) {
+	const profileHash = member.contract.profileHash;
+	return {
+		ok: true,
+		summary: "Schema verification skipped",
+		contract: {
+			storageHash: member.headRef.hash,
+			...profileHash ? { profileHash } : {}
+		},
+		target: { expected: member.contract.target },
+		schema: {
+			issues: [],
+			root: {
+				status: "pass",
+				kind: "skipped",
+				name: member.spaceId,
+				contractPath: "",
+				code: "SKIPPED",
+				message: "Schema verification skipped",
+				expected: void 0,
+				actual: void 0,
+				children: []
+			},
+			counts: {
+				pass: 0,
+				warn: 0,
+				fail: 0,
+				totalNodes: 0
+			}
+		},
+		timings: { total: 0 }
+	};
+}
+/**
+* Translate per-space marker check failures and orphan markers into a
+* single CLI structured error envelope. Preserves the legacy code
+* `5002` (was emitted by `runContractSpaceVerifierMarkerCheck`).
+*/
+function mapMarkerCheckFailures(appSpaceId, section) {
+	const violations = [];
+	for (const [spaceId, result] of section.perSpace) {
+		if (result.kind === "ok" || result.kind === "absent") continue;
+		if (result.kind === "hashMismatch") {
+			violations.push({
+				kind: "hashMismatch",
+				spaceId,
+				remediation: spaceId === appSpaceId ? "Run `prisma-next db update` to advance the marker, or roll the database back to the recorded hash." : `Apply on-disk migrations under \`migrations/${spaceId}/\` to advance the marker, or remove the conflicting marker row.`
+			});
+			continue;
+		}
+		if (result.kind === "missingInvariants") violations.push({
+			kind: "invariantsMismatch",
+			spaceId,
+			remediation: `Re-apply the migrations under \`migrations/${spaceId}/\` so the marker carries invariants: ${result.missing.join(", ")}.`
+		});
+	}
+	for (const orphan of section.orphanMarkers) violations.push({
+		kind: "orphanMarker",
+		spaceId: orphan.spaceId,
+		remediation: `Add the corresponding extension to \`extensionPacks\` in \`prisma-next.config.ts\`, or delete the orphan marker row for "${orphan.spaceId}".`
+	});
+	if (violations.length === 0) return null;
+	const lines = violations.map((v) => `- [${v.kind}] ${v.spaceId}: ${v.remediation}`);
+	return new CliStructuredError("5002", violations.length === 1 ? "Contract-space verifier found a violation" : `Contract-space verifier found violations (${violations.length})`, {
+		domain: "MIG",
+		why: `The on-disk \`migrations/\` directory, the \`extensionPacks\` declaration, and the live database marker rows are not in agreement.\n${lines.join("\n")}`,
+		fix: violations[0]?.remediation ?? "Review and reconcile the violations listed above.",
+		docsUrl: "https://pris.ly/contract-spaces",
+		meta: { violations }
+	});
+}
+//#endregion
+//#region src/control-api/operations/migration-apply.ts
+/**
+* Apply a sequence of migration packages against the configured driver.
+*
+* Validates the path's continuity (origin → ... → destination, no gaps),
+* then drives the family/target's migration runner over each package's
+* operations in order, surfacing per-migration progress through `onProgress`.
+*
+* The `pendingMigrations` parameter is trusted input. Callers are responsible
+* for upstream verification of the originating migration packages — typically
+* by loading them via `readMigrationPackage` from
+* `@prisma-next/migration-tools/io`, which performs hash-integrity checks at
+* the load boundary. This operation does not re-verify the packages and
+* assumes the `(metadata, ops)` pairs on disk have not been tampered with
+* since emit.
+*/
+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];
+	const firstFromMarker = firstMigration.from ?? EMPTY_CONTRACT_HASH;
+	if (firstFromMarker !== 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 ${firstFromMarker} -> ${lastMigration.to}, but requested ${originHash} -> ${destinationHash}`,
+		meta: {
+			originHash,
+			destinationHash,
+			pathOrigin: firstFromMarker,
+			pathDestination: lastMigration.to
+		}
+	});
+	for (let i = 1; i < pendingMigrations.length; i++) {
+		const previous = pendingMigrations[i - 1];
+		const current = pendingMigrations[i];
+		const currentFromMarker = current.from ?? EMPTY_CONTRACT_HASH;
+		if (previous.to !== currentFromMarker) 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 ${currentFromMarker}`,
+			meta: {
+				originHash,
+				destinationHash,
+				previousDirName: previous.dirName,
+				previousTo: previous.to,
+				currentDirName: current.dirName,
+				currentFrom: currentFromMarker,
+				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,
+			spaceId: APP_SPACE_ID,
+			origin: migration.from === null ? null : { storageHash: migration.from },
+			destination: { storageHash: migration.to },
+			operations,
+			providedInvariants: migration.providedInvariants
+		};
+		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,
+			migrationsDir: options.migrationsDir,
+			targetId: this.options.target.targetId,
+			extensionPacks: this.options.extensionPacks ?? [],
+			...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,
+			migrationsDir: options.migrationsDir,
+			targetId: this.options.target.targetId,
+			extensionPacks: this.options.extensionPacks ?? [],
+			...ifDefined("acceptDataLoss", options.acceptDataLoss),
+			...ifDefined("onProgress", onProgress)
+		});
+	}
+	async dbVerify(options) {
+		const { onProgress } = options;
+		await this.connectWithProgress(options.connection, "dbVerify", 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);
+		}
+		return executeDbVerify({
+			driver,
+			familyInstance,
+			contract,
+			migrationsDir: options.migrationsDir,
+			targetId: this.options.target.targetId,
+			extensionPacks: this.options.extensionPacks ?? [],
+			frameworkComponents,
+			mode: options.strict ? "strict" : "lenient",
+			skipSchema: options.skipSchema,
+			skipMarker: options.skipMarker,
+			...ifDefined("onProgress", onProgress)
+		});
+	}
+	async readMarker() {
+		const { driver, familyInstance } = await this.ensureConnected();
+		return familyInstance.readMarker({
+			driver,
+			space: APP_SPACE_ID
+		});
+	}
+	async readAllMarkers() {
+		const { driver, familyInstance } = await this.ensureConnected();
+		return familyInstance.readAllMarkers({ 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);
+	}
+	inferPslContract(schemaIR) {
+		this.init();
+		if (this.familyInstance && hasPslContractInfer(this.familyInstance)) return this.familyInstance.inferPslContract(schemaIR);
+	}
+	toOperationPreview(operations) {
+		this.init();
+		if (this.familyInstance && hasOperationPreview(this.familyInstance)) return this.familyInstance.toOperationPreview(operations);
+	}
+	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 a, executeDbInit as i, executeDbVerify as n, executeDbUpdate as r, createControlClient as t };
+
+//# sourceMappingURL=client-0ZX24FXF.mjs.map