@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/control-BK50zF6c.mjs

@@ -0,0 +1,2721 @@
+import { u as namingOf } from "./naming-bM5qm5PY-jOg3JFMb.mjs";
+import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-Ce1v_TDl.mjs";
+import { _ as unquotedSqlBaseName, a as renderSqlTypeName, c as sameSqlColumnType, m as sqlStorageType, n as isSqlDataType, p as sqlDataTypeOfCodec, r as nameIsCatalogText, u as sqlCodecColumnLength, y as validateSqlTypeParams } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
+import { c as StorageTable } from "./storage-table-DDvN83mw-DkbBFmK9.mjs";
+import { c as SqlSchemaIR, n as RelationalSchemaNodeKind, u as SqlTableIR } from "./types-DoyiTsjg-2YMhMJDA.mjs";
+import { f as sqlExpressionRegistration, m as sqlTextsReadBack, o as printSqlExpressionLiteral } from "./sql-expression-CKgKznXS.mjs";
+import { d as nonEmptyTypeParams, u as isStorageTypeInstance } from "./types-CTdSkl0s.mjs";
+import { g as valueObjectStorageTypeMissingMessage } from "./validators-BwA7ttZM.mjs";
+import { a as describeUnsupportedSqlAttribute, b as sqlAttributeSpecs } from "./psl-field-resolution-C5KQ7kzP-B0NwuRWV.mjs";
+import { t as describeUnresolvedSqlType } from "./diagnostics-RHJxoiIk.mjs";
+import { t as sqlEmission } from "./dist-C8Y-PPuE.mjs";
+import { a as sqlFamilyGeneratorDescriptors, i as sqlFamilyEntityTypes, n as sqlFamilyAuthoringFieldPresets, o as sqlFamilyGeneratorFunctions, r as sqlFamilyAuthoringTypes, s as sqlFamilyPslBlockDescriptors } from "./generator-functions-D_qdqBV--Bq296cED.mjs";
+import { c as verifySqlSchemaByDiff, n as classifyDiffSubjectGranularity, o as enforceSqlDataTypeInvariants, t as classifyDiffEntityKind } from "./schema-verify-C3wbdviw-DMjIubOr.mjs";
+import { t as sqlFamilyError } from "./errors-B5g0xWro-C8plbqga.mjs";
+import { t as SqlContractSerializer } from "./sql-contract-serializer-sMY3prTx-D2BfrNxs.mjs";
+import { t as collectSupportedCodecTypeIds } from "./verify-BVk5bjdH-DhKm6hB3.mjs";
+import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { collectScalarTypeConstructors, tsTaggedTemplateSource } from "@prisma/orm-framework/components/authoring";
+import { ContractValidationError } from "@prisma/orm-framework/contract/contract-validation-error";
+import { UNBOUND_NAMESPACE_ID, isPlainRecord } from "@prisma/orm-framework/components/ir";
+import { assembleDataTypes, codecForRef, dataTypeParams, objectSchemaKeys } from "@prisma/orm-framework/components/codec";
+import { canonicalizeJson } from "@prisma/orm-framework/components/utils";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
+import { type } from "arktype";
+import { asNamespaceId, governingControlPolicy } from "@prisma/orm-framework/contract/types";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions as assembleAuthoringContributions$1, describeMigrationStatement, extractCodecLookup, fieldStatementText, issueOutcome, migrationRunnerFailure, modelDisplayName, sameMarkerHashes } from "@prisma/orm-framework/components/control";
+import { assertDescriptorSelfConsistency } from "@prisma/orm-toolchain/migration-tools/spaces";
+import { jsonToTsSource } from "@prisma/orm-framework/ts-render";
+//#region ../../../2-sql-family/9-family/dist/control.mjs
+function tablesOf(storage) {
+	return Object.entries(storage.namespaces).flatMap(([namespaceId, namespace]) => Object.entries(namespace.entries["table"] ?? {}).map(([tableName, table]) => ({
+		path: `storage.namespaces.${namespaceId}.entries.table.${tableName}`,
+		namespaceId,
+		tableName,
+		table: blindCast(table)
+	})));
+}
+function dataTypeProblems(storage, codecLookup) {
+	return [...tablesOf(storage).flatMap(({ path, table }) => Object.entries(table.columns).map(([columnName, column]) => ({
+		path: `${path}.columns.${columnName}`,
+		codecId: column.codecId,
+		dataType: column.dataType
+	}))), ...Object.entries(storage.types ?? {}).flatMap(([typeName, entry]) => isStorageTypeInstance(entry) ? [{
+		path: `storage.types.${typeName}`,
+		codecId: entry.codecId,
+		dataType: entry.dataType
+	}] : [])].flatMap(({ path, codecId, dataType }) => {
+		const represented = codecLookup.descriptorFor(codecId)?.dataType;
+		if (represented === void 0 || represented === dataType) return [];
+		return [`${path}: codec ${codecId} represents ${represented}, not ${dataType}`];
+	});
+}
+/** Whether `type` refuses `params`. The check of the column's parameters reports that, so its default is not read under them. */
+function refusesParams(type, params) {
+	if (!isSqlDataType(type)) return false;
+	try {
+		validateSqlTypeParams(type, params);
+		return false;
+	} catch (error) {
+		if (isStructuredError(error) && error.code === "CONTRACT.TYPE_PARAMS_INVALID") return true;
+		throw error;
+	}
+}
+/** Names the namespace, unless the contract has only the unbound one, as a SQLite contract does. */
+function columnPlace(refused) {
+	return refused.namespaceId === UNBOUND_NAMESPACE_ID ? `Table "${refused.table}", column "${refused.column}"` : `Namespace "${refused.namespaceId}", table "${refused.table}", column "${refused.column}"`;
+}
+function notAValue(refused) {
+	return {
+		refused,
+		text: `${columnPlace(refused)}: the default ${JSON.stringify(refused.value)}${refused.elementIndex === void 0 ? "" : ` at element ${refused.elementIndex + 1}`} is not a value of ${refused.dataType}: ${refused.message}`
+	};
+}
+function notAList(refused) {
+	return {
+		refused,
+		text: `${columnPlace(refused)}: the default ${JSON.stringify(refused.value)} is not a list, and the column holds a list of ${refused.dataType}`
+	};
+}
+/** Each literal default the column's type does not hold, under the column's parameters, element by element on a list column. A `null` is SQL NULL, which every column takes. */
+function refusedDefaults(storage, dataTypes) {
+	return tablesOf(storage).flatMap(({ namespaceId, tableName, table }) => Object.entries(table.columns).flatMap(([columnName, column]) => {
+		const columnDefault = column.default;
+		if (columnDefault?.kind !== "literal") return [];
+		const type = dataTypes.get(column.dataType);
+		if (type === void 0) return [];
+		const params = dataTypeParams(type, nonEmptyTypeParams(column.typeParams));
+		if (refusesParams(type, params)) return [];
+		const place = {
+			namespaceId,
+			table: tableName,
+			column: columnName,
+			dataType: type.id
+		};
+		const isList = column.many !== void 0 && column.many !== false;
+		if (isList && columnDefault.value !== null && !Array.isArray(columnDefault.value)) return [notAList({
+			...place,
+			value: columnDefault.value,
+			message: "The column holds a list, and the default is not one.",
+			reason: "type-refused-default"
+		})];
+		const listed = isList && Array.isArray(columnDefault.value);
+		const values = isList && Array.isArray(columnDefault.value) ? columnDefault.value : [columnDefault.value];
+		for (const [index, value] of values.entries()) {
+			if (value === null) continue;
+			try {
+				type.fromContract(value, params);
+			} catch (error) {
+				if (isInternalError(error)) throw error;
+				return [notAValue({
+					...place,
+					value,
+					...listed ? { elementIndex: index } : {},
+					message: error instanceof Error ? error.message : String(error),
+					reason: "type-refused-default"
+				})];
+			}
+		}
+		return [];
+	}));
+}
+function valueObjectProblems(contract, authoring) {
+	const storageTypeName = authoring.valueObjectStorageType;
+	const expectedCodecId = storageTypeName === void 0 ? void 0 : collectScalarTypeConstructors(authoring.type).get(storageTypeName)?.codecId;
+	const tables = new Map(tablesOf(contract.storage).map((entry) => [`${entry.namespaceId}\0${entry.tableName}`, entry]));
+	return Object.values(contract.domain.namespaces).flatMap((namespace) => Object.values(namespace.models).flatMap((model) => {
+		const storage = blindCast(model.storage);
+		const table = tables.get(`${storage.namespaceId}\0${storage.table}`);
+		if (table === void 0) return [];
+		return Object.entries(model.fields).flatMap(([fieldName, field]) => {
+			if (field.type.kind !== "valueObject") return [];
+			const columnName = storage.fields[fieldName]?.column;
+			const column = columnName === void 0 ? void 0 : table.table.columns[columnName];
+			if (columnName === void 0 || column === void 0) return [];
+			const path = `${table.path}.columns.${columnName}`;
+			if (expectedCodecId === void 0) return [valueObjectStorageTypeMissingMessage(path)];
+			if (column.codecId === expectedCodecId) return [];
+			return [`${path}: a value-object column uses codec ${expectedCodecId}, the codec of the stack's value-object storage type ${storageTypeName}, not ${column.codecId}`];
+		});
+	}));
+}
+/**
+* Checks a deserialized contract against the stack that loads it: each column's codec represents the data type the column names, each value-object column uses the codec of the stack's value-object storage type, and each literal default is a value of its column's type under the column's parameters.
+*/
+function assertContractMatchesStack(contract, stack) {
+	const defaults = refusedDefaults(contract.storage, stack.dataTypes.lookup);
+	const problems = [
+		...dataTypeProblems(contract.storage, stack.codecLookup),
+		...valueObjectProblems(contract, stack.authoringContributions),
+		...defaults.map(({ text }) => text)
+	];
+	if (problems.length > 0) throw new ContractValidationError(problems.join("; "), "storage", defaults.length > 0 ? { refusedDefaults: defaults.map(({ refused }) => refused) } : void 0);
+}
+function isStorageDetails(details) {
+	if (typeof details !== "object" || details === null) return false;
+	const [objectType, name, schema, table] = [
+		"objectType",
+		"name",
+		"schema",
+		"table"
+	].map((key) => Reflect.get(details, key));
+	return typeof objectType === "string" && typeof name === "string" && (schema === void 0 || typeof schema === "string") && (table === void 0 || typeof table === "string");
+}
+function storageDetailsOf(operation) {
+	const target = Reflect.get(operation, "target");
+	if (typeof target !== "object" || target === null) return void 0;
+	const details = Reflect.get(target, "details");
+	return isStorageDetails(details) ? details : void 0;
+}
+/**
+* The name the database knows an operation's object by, read from the operation's target
+* details: `schema.table.column` for a column, `schema.name` for anything else, without the
+* schema in the unbound namespace. An operation without details is named by its id.
+*/
+function storageNameOfOperation(operation) {
+	const details = storageDetailsOf(operation);
+	if (details === void 0) return operation.id;
+	const schema = details.schema === void 0 || details.schema === UNBOUND_NAMESPACE_ID ? [] : [details.schema];
+	const table = details.objectType === "column" && details.table !== void 0 ? [details.table] : [];
+	return [
+		...schema,
+		...table,
+		details.name
+	].join(".");
+}
+function isDdlStatement(sqlStatement) {
+	const trimmed = sqlStatement.trim().toLowerCase();
+	return trimmed.startsWith("create ") || trimmed.startsWith("alter ") || trimmed.startsWith("drop ");
+}
+function hasExecuteSteps(operation) {
+	const execute = Reflect.get(operation, "execute");
+	if (!Array.isArray(execute)) return false;
+	return execute.every((step) => typeof step === "object" && step !== null && "sql" in step);
+}
+/**
+* Extracts a best-effort SQL DDL preview for CLI plan output.
+* Presentation-only: never used to decide migration correctness.
+*/
+function extractSqlDdl(operations) {
+	const statements = [];
+	for (const operation of operations) {
+		if (!hasExecuteSteps(operation)) continue;
+		for (const step of operation.execute) if (typeof step.sql === "string" && isDdlStatement(step.sql)) statements.push(step.sql.trim());
+	}
+	return statements;
+}
+/**
+* Wraps `extractSqlDdl` into the family-agnostic `OperationPreview` shape.
+* Each statement carries `language: 'sql'`.
+*/
+function sqlOperationsToPreview(operations) {
+	return { statements: extractSqlDdl(operations).map((text) => ({
+		text,
+		language: "sql"
+	})) };
+}
+function missingDescriptorOperationError(targetId, operation) {
+	return sqlFamilyError("CONTRACT.PACK_CONTRIBUTION_INVALID", `SQL target "${targetId}" is missing the required ${operation} descriptor operation`, {
+		why: `The target descriptor does not contribute the ${operation} operation the SQL family requires for this call.`,
+		fix: `Use a target package whose control descriptor implements ${operation}.`,
+		meta: {
+			targetId,
+			operation
+		}
+	});
+}
+function extractCodecTypeIdsFromContract(contract) {
+	const typeIds = /* @__PURE__ */ new Set();
+	if (typeof contract === "object" && contract !== null && "storage" in contract && typeof contract.storage === "object" && contract.storage !== null && "namespaces" in contract.storage && typeof contract.storage.namespaces === "object" && contract.storage.namespaces !== null) {
+		const namespaces = blindCast(contract.storage.namespaces);
+		for (const ns of Object.values(namespaces)) {
+			const tbls = ns.entries["table"];
+			if (typeof tbls !== "object" || tbls === null) continue;
+			for (const table of Object.values(tbls)) if (typeof table === "object" && table !== null && "columns" in table && typeof table.columns === "object" && table.columns !== null) {
+				const columns = blindCast(table.columns);
+				for (const column of Object.values(columns)) if (column && typeof column === "object" && "codecId" in column && typeof column.codecId === "string") typeIds.add(column.codecId);
+			}
+		}
+	}
+	return Array.from(typeIds).sort();
+}
+function createVerifyResult(options) {
+	const contract = { storageHash: options.contractStorageHash };
+	if (options.contractProfileHash) contract.profileHash = options.contractProfileHash;
+	const target = { expected: options.expectedTargetId };
+	if (options.actualTargetId) target.actual = options.actualTargetId;
+	const meta = { contractPath: options.contractPath };
+	if (options.configPath) meta.configPath = options.configPath;
+	return {
+		ok: options.ok,
+		summary: options.summary,
+		contract,
+		target,
+		meta,
+		timings: { total: options.totalTime },
+		...ifDefined("code", options.code),
+		...options.marker ? { marker: {
+			storageHash: options.marker.storageHash,
+			profileHash: options.marker.profileHash
+		} } : {},
+		...ifDefined("missingCodecs", options.missingCodecs),
+		...ifDefined("codecCoverageSkipped", options.codecCoverageSkipped)
+	};
+}
+/**
+* Builds a map from each extension id to the set of extension ids it
+* transitively depends on. Uses the same declared-dependency data that
+* `buildExtensionLoadOrder` in control-stack uses.
+*/
+function buildTransitiveDependsOnMap(extensions) {
+	const directDeps = /* @__PURE__ */ new Map();
+	for (const ext of extensions) {
+		const packs = ext.contractSpace?.contractJson?.extensions;
+		const deps = packs !== null && typeof packs === "object" ? Object.keys(packs) : [];
+		directDeps.set(ext.id, deps);
+	}
+	const result = /* @__PURE__ */ new Map();
+	const resolve = (id, visiting) => {
+		const cached = result.get(id);
+		if (cached !== void 0) return cached;
+		const set = /* @__PURE__ */ new Set();
+		result.set(id, set);
+		for (const depId of directDeps.get(id) ?? []) {
+			set.add(depId);
+			if (!visiting.has(depId)) {
+				visiting.add(depId);
+				for (const transitive of resolve(depId, visiting)) set.add(transitive);
+				visiting.delete(depId);
+			}
+		}
+		return set;
+	};
+	for (const ext of extensions) resolve(ext.id, /* @__PURE__ */ new Set([ext.id]));
+	return result;
+}
+/**
+* Asserts that no cross-space FK in any extension points against the
+* dependency direction.
+*
+* A cross-space FK (target.spaceId present) from extension A pointing at
+* space B is a violation when B depends on A (directly or transitively),
+* because that means A is pointing "upward" against the dependency arrows
+* established by the extension load order.
+*
+* Throws with a diagnostic naming the violating extension (source), the
+* target space, and the direction violation.
+*/
+function isObjectRecord(v) {
+	return typeof v === "object" && v !== null;
+}
+function assertNoCrossSpaceFkReverseReferences(extensions) {
+	const dependsOnMap = buildTransitiveDependsOnMap(extensions);
+	for (const ext of extensions) {
+		const namespaces = ext.contractSpace?.contractJson?.storage?.namespaces;
+		if (!isObjectRecord(namespaces)) continue;
+		for (const ns of Object.values(namespaces)) {
+			if (!isObjectRecord(ns)) continue;
+			const entries = ns["entries"];
+			if (!isObjectRecord(entries)) continue;
+			for (const slot of Object.values(entries)) {
+				if (!isObjectRecord(slot)) continue;
+				for (const table of Object.values(slot)) {
+					if (!isObjectRecord(table)) continue;
+					const foreignKeys = table["foreignKeys"];
+					if (!Array.isArray(foreignKeys)) continue;
+					for (const fk of foreignKeys) {
+						if (!isObjectRecord(fk)) continue;
+						const target = fk["target"];
+						if (!isObjectRecord(target)) continue;
+						if (target["spaceId"] === void 0) continue;
+						const targetSpaceId = target["spaceId"];
+						if (typeof targetSpaceId !== "string") continue;
+						if (dependsOnMap.get(targetSpaceId)?.has(ext.id)) throw sqlFamilyError("CONTRACT.FOREIGN_KEY_INVALID", `Cross-space FK reverse-reference detected: extension "${ext.id}" has a cross-space FK targeting space "${targetSpaceId}", but "${targetSpaceId}" depends on "${ext.id}". Cross-space FKs must follow the dependency direction (a space can only reference spaces it depends on, not spaces that depend on it).`, {
+							why: "The foreign key points against the contract-space dependency direction.",
+							fix: "Move the foreign key to the depending space, or restructure the extension dependencies so the referencing space depends on the referenced one.",
+							meta: {
+								extensionId: ext.id,
+								targetSpaceId
+							}
+						});
+					}
+				}
+			}
+		}
+	}
+}
+function createSqlFamilyInstance(stack) {
+	enforceSqlDataTypeInvariants(stack.declaredDataTypes, stack.codecDescriptors);
+	if (!stack.adapter) throw new InternalError("SQL family requires an adapter descriptor in ControlStack");
+	const target = blindCast(stack.target);
+	const adapter = blindCast(stack.adapter);
+	const extensions = blindCast(stack.extensions);
+	for (const extension of extensions) if (extension.contractSpace) {
+		const { contractJson, headRef } = extension.contractSpace;
+		assertDescriptorSelfConsistency({
+			extensionId: extension.id,
+			target: contractJson.target,
+			targetFamily: contractJson.targetFamily,
+			storage: contractJson.storage,
+			headRefHash: headRef.hash,
+			...sqlContractCanonicalizationHooks
+		});
+	}
+	assertNoCrossSpaceFkReverseReferences(extensions);
+	const { codecTypeImports, extensionIds } = stack;
+	let controlAdapter;
+	const getControlAdapter = () => controlAdapter ??= adapter.create(stack);
+	const targetSerializer = blindCast(target).contractSerializer;
+	const targetInferPslContract = blindCast(target).inferPslContract;
+	const pslBuildContext = {
+		authoringContributions: stack.authoringContributions,
+		codecLookup: stack.codecLookup,
+		dataTypes: stack.dataTypes,
+		generatorFunctions: stack.generatorFunctions,
+		componentIdsByGenerator: stack.controlMutationDefaults.componentIdsByGenerator
+	};
+	const targetBuildPslContract = blindCast(target).buildPslContract;
+	const diffSchema = blindCast(target).diffSchema;
+	const targetGranularityOf = blindCast(target).classifySubjectGranularity;
+	const targetEntityKindOf = blindCast(target).classifyEntityKind;
+	const describedContracts = extensions.flatMap((extension) => extension.contractSpace ? [{
+		spaceId: extension.id,
+		contract: extension.contractSpace.contractJson
+	}] : []);
+	const loadContract = (contractOrJson) => {
+		const serializer = targetSerializer ?? new SqlContractSerializer();
+		const json = targetSerializer !== void 0 && !isPlainRecord(contractOrJson) ? targetSerializer.serializeContract(blindCast(contractOrJson)) : contractOrJson;
+		const contract = serializer.deserializeContract(json);
+		assertContractMatchesStack(contract, stack);
+		return contract;
+	};
+	const signSpaceMarker = async (controlAdapter, driver, { space, contract, expected }) => {
+		const storageHash = contract.storage.storageHash;
+		const profileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : storageHash;
+		const signed = {
+			space,
+			contract: {
+				storageHash,
+				profileHash
+			}
+		};
+		const readHashes = async () => {
+			const marker = await controlAdapter.readMarker(driver, space);
+			return marker === null ? null : {
+				storageHash: marker.storageHash,
+				profileHash: marker.profileHash
+			};
+		};
+		const existing = await readHashes();
+		if (!sameMarkerHashes(existing, expected)) return {
+			...signed,
+			status: "conflict",
+			expected,
+			found: existing
+		};
+		if (existing === null) {
+			await controlAdapter.insertMarker(driver, space, {
+				storageHash,
+				profileHash
+			});
+			return {
+				...signed,
+				status: "created"
+			};
+		}
+		if (existing.storageHash === storageHash && existing.profileHash === profileHash) return {
+			...signed,
+			status: "unchanged"
+		};
+		if (!await controlAdapter.updateMarker(driver, space, existing.storageHash, {
+			storageHash,
+			profileHash
+		})) return {
+			...signed,
+			status: "conflict",
+			expected,
+			found: await readHashes()
+		};
+		return {
+			...signed,
+			status: "updated",
+			previous: existing
+		};
+	};
+	const signSpaces = async (driver, spaces) => {
+		const [first] = spaces;
+		if (first === void 0) return [];
+		const controlAdapter = getControlAdapter();
+		return controlAdapter.withTransaction(driver, async () => {
+			await controlAdapter.lockMarker(driver);
+			for (const query of controlAdapter.bootstrapSignMarkerQueries()) {
+				const lowered = await controlAdapter.lowerToExecuteRequest(query, { contract: first.contract });
+				await driver.query(lowered.sql, lowered.params);
+			}
+			const signatures = [];
+			for (const space of spaces) signatures.push(await signSpaceMarker(controlAdapter, driver, space));
+			return signatures;
+		});
+	};
+	return {
+		familyId: "sql",
+		codecTypeImports,
+		extensionIds,
+		deserializeContract(contractJson) {
+			return loadContract(contractJson);
+		},
+		async verify(verifyOptions) {
+			const { driver, contract: rawContract, expectedTargetId, contractPath, configPath } = verifyOptions;
+			const startTime = Date.now();
+			const contract = loadContract(rawContract);
+			const contractStorageHash = contract.storage.storageHash;
+			const contractProfileHash = contract.profileHash;
+			const contractTarget = contract.target;
+			const marker = await getControlAdapter().readMarker(driver, APP_SPACE_ID);
+			let missingCodecs;
+			let codecCoverageSkipped = false;
+			const supportedTypeIds = collectSupportedCodecTypeIds([
+				adapter,
+				target,
+				...extensions
+			]);
+			if (supportedTypeIds.length === 0) codecCoverageSkipped = true;
+			else {
+				const supportedSet = new Set(supportedTypeIds);
+				const missing = extractCodecTypeIdsFromContract(contract).filter((id) => !supportedSet.has(id));
+				if (missing.length > 0) missingCodecs = missing;
+			}
+			if (!marker) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_MARKER_MISSING,
+				summary: "Marker missing",
+				contractStorageHash,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			if (contractTarget !== expectedTargetId) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_TARGET_MISMATCH,
+				summary: "Target mismatch",
+				contractStorageHash,
+				marker,
+				expectedTargetId,
+				actualTargetId: contractTarget,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			if (marker.storageHash !== contractStorageHash) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_HASH_MISMATCH,
+				summary: "Hash mismatch",
+				contractStorageHash,
+				marker,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			if (contractProfileHash && marker.profileHash !== contractProfileHash) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_HASH_MISMATCH,
+				summary: "Hash mismatch",
+				contractStorageHash,
+				contractProfileHash,
+				marker,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			return createVerifyResult({
+				ok: true,
+				summary: "Database matches contract",
+				contractStorageHash,
+				marker,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+		},
+		verifySchema(options) {
+			const contract = loadContract(options.contract);
+			if (!diffSchema) throw missingDescriptorOperationError(target.targetId, "diffSchema");
+			if (!targetGranularityOf) throw missingDescriptorOperationError(target.targetId, "classifySubjectGranularity");
+			return verifySqlSchemaByDiff({
+				contract,
+				schema: options.schema,
+				strict: options.strict,
+				frameworkComponents: options.frameworkComponents,
+				diffSchema,
+				granularityOf: targetGranularityOf
+			});
+		},
+		/**
+		* Classifies a diff issue's subject granularity on demand, by resolving
+		* its node's `nodeKind` through the target's classifier — the
+		* {@link import('@internal/framework-components/control').SchemaSubjectClassifierCapable}
+		* capability. Framework consumers spanning contract spaces (the
+		* migration aggregate's unclaimed-elements sweep) detect and call this
+		* instead of reaching into the concrete schema-IR node, which they
+		* cannot read; nothing is stamped on the issue or the node.
+		*/
+		classifySubjectGranularity(issue) {
+			if (!targetGranularityOf) throw missingDescriptorOperationError(target.targetId, "classifySubjectGranularity");
+			return classifyDiffSubjectGranularity(issue, targetGranularityOf);
+		},
+		/**
+		* Classifies a diff issue's subject storage `entityKind` on demand, by
+		* resolving its node's `nodeKind` through the target's classifier —
+		* the sibling of `classifySubjectGranularity` above, and part of the
+		* same {@link import('@internal/framework-components/control').SchemaSubjectClassifierCapable}
+		* capability.
+		*/
+		classifyEntityKind(issue) {
+			if (!targetEntityKindOf) throw missingDescriptorOperationError(target.targetId, "classifyEntityKind");
+			return classifyDiffEntityKind(issue, targetEntityKindOf);
+		},
+		async signSpaces(options) {
+			return signSpaces(options.driver, options.spaces);
+		},
+		async readMarker(options) {
+			return getControlAdapter().readMarker(options.driver, options.space);
+		},
+		async readAllMarkers(options) {
+			return getControlAdapter().readAllMarkers(options.driver);
+		},
+		async readLedger(options) {
+			return getControlAdapter().readLedger(options.driver, options.space);
+		},
+		async initMarker(options) {
+			return getControlAdapter().initMarker(options.driver, options.space, options.destination);
+		},
+		async updateMarker(options) {
+			return getControlAdapter().updateMarker(options.driver, options.space, options.expectedFrom, options.destination);
+		},
+		async writeLedgerEntry(options) {
+			return getControlAdapter().writeLedgerEntry(options.driver, options.space, options.entry);
+		},
+		async introspect(options) {
+			return getControlAdapter().introspect(options.driver, options.contract);
+		},
+		async inferPslContract(schemaIR) {
+			if (!targetInferPslContract) throw sqlFamilyError("CONTRACT.INFER_UNSUPPORTED", `Target "${target.targetId}" does not support contract infer (no inferPslContract on its descriptor).`, {
+				why: "The target descriptor does not provide the inferPslContract hook, so a PSL contract cannot be inferred from the database schema.",
+				fix: "Use a target package that supports contract infer, or author the contract instead of inferring it.",
+				meta: { targetId: target.targetId }
+			});
+			return targetInferPslContract(schemaIR, pslBuildContext, describedContracts);
+		},
+		buildPslContract(contract) {
+			if (!targetBuildPslContract) throw sqlFamilyError("CONTRACT.PRINT_UNSUPPORTED", `Target "${target.targetId}" does not support contract print (no buildPslContract on its descriptor).`, {
+				why: "The target descriptor does not provide the buildPslContract hook, so the contract cannot be printed as a Prisma 8 PSL file.",
+				fix: "Use a target whose descriptor provides buildPslContract, or write the Prisma 8 PSL file by hand.",
+				meta: { targetId: target.targetId }
+			});
+			return {
+				document: targetBuildPslContract(contract, pslBuildContext),
+				sourceSettings: ifDefined("defaultControlPolicy", contract.defaultControlPolicy)
+			};
+		},
+		lowerAst(ast, context) {
+			return getControlAdapter().lowerToExecuteRequest(ast, context);
+		},
+		bootstrapControlTableQueries() {
+			return getControlAdapter().bootstrapControlTableQueries();
+		},
+		toOperationPreview(operations) {
+			return sqlOperationsToPreview(operations);
+		},
+		storageNameOf(operation) {
+			return storageNameOfOperation(operation);
+		},
+		toSchemaView(schema) {
+			const root = blindCast(schema);
+			const namespaceEntries = root.namespaces !== void 0 ? Object.entries(root.namespaces).map(([namespaceKey, namespace]) => [namespaceKey, namespace.tables]) : [[void 0, root.tables ?? {}]];
+			const qualify = namespaceEntries.length > 1;
+			const tableNodes = namespaceEntries.flatMap(([namespaceKey, tables]) => Object.entries(tables).map(([tableName, table]) => [
+				qualify && namespaceKey !== void 0 ? `${namespaceKey}.${tableName}` : tableName,
+				tableName,
+				table
+			])).map(([displayName, tableName, table]) => {
+				const children = [];
+				const columnNodes = [];
+				for (const [columnName, column] of Object.entries(table.columns)) {
+					const label = `${columnName}: ${column.typeText} (${column.nullable ? "nullable" : "not nullable"})`;
+					columnNodes.push(new SchemaTreeNode({
+						kind: "field",
+						id: `column-${displayName}-${columnName}`,
+						label,
+						meta: {
+							typeText: column.typeText,
+							nullable: column.nullable,
+							...ifDefined("default", column.default)
+						}
+					}));
+				}
+				if (columnNodes.length > 0) children.push(new SchemaTreeNode({
+					kind: "collection",
+					id: `columns-${displayName}`,
+					label: "columns",
+					children: columnNodes
+				}));
+				if (table.primaryKey) {
+					const pkColumns = table.primaryKey.columns.join(", ");
+					children.push(new SchemaTreeNode({
+						kind: "index",
+						id: `primary-key-${displayName}`,
+						label: `primary key: ${pkColumns}`,
+						meta: {
+							columns: table.primaryKey.columns,
+							...table.primaryKey.name ? { name: table.primaryKey.name } : {}
+						}
+					}));
+				}
+				for (const unique of table.uniques) {
+					const name = unique.name ?? `${tableName}_${unique.columns.join("_")}_unique`;
+					const label = `unique ${name}`;
+					children.push(new SchemaTreeNode({
+						kind: "index",
+						id: `unique-${displayName}-${name}`,
+						label,
+						meta: {
+							columns: unique.columns,
+							unique: true
+						}
+					}));
+				}
+				for (const index of table.indexes) {
+					const name = index.name;
+					const label = index.unique ? `unique index ${name}` : `index ${name}`;
+					children.push(new SchemaTreeNode({
+						kind: "index",
+						id: `index-${displayName}-${name}`,
+						label,
+						meta: {
+							columns: index.columns,
+							unique: index.unique
+						}
+					}));
+				}
+				const tableMeta = {};
+				if (table.primaryKey) {
+					tableMeta["primaryKey"] = table.primaryKey.columns;
+					if (table.primaryKey.name) tableMeta["primaryKeyName"] = table.primaryKey.name;
+				}
+				if (table.foreignKeys.length > 0) tableMeta["foreignKeys"] = table.foreignKeys.map((fk) => ({
+					columns: fk.columns,
+					referencedTable: fk.referencedTable,
+					referencedColumns: fk.referencedColumns,
+					...fk.name ? { name: fk.name } : {}
+				}));
+				return new SchemaTreeNode({
+					kind: "entity",
+					id: `table-${displayName}`,
+					label: `table ${displayName}`,
+					...Object.keys(tableMeta).length > 0 ? { meta: tableMeta } : {},
+					...children.length > 0 ? { children } : {}
+				});
+			});
+			return { root: new SchemaTreeNode({
+				kind: "root",
+				id: "sql-schema",
+				label: "database",
+				...tableNodes.length > 0 ? { children: tableNodes } : {}
+			}) };
+		}
+	};
+}
+const sqlFamilyDescribeUnsupportedAttribute = describeUnsupportedSqlAttribute;
+const sqlFamilyDescribeUnresolvedType = describeUnresolvedSqlType;
+var SqlFamilyDescriptor = class {
+	kind = "family";
+	id = "sql";
+	familyId = "sql";
+	version = "0.0.1";
+	emission = sqlEmission;
+	dataTypes = sqlExpressionRegistration.dataTypes;
+	authoring = {
+		field: sqlFamilyAuthoringFieldPresets,
+		type: sqlFamilyAuthoringTypes,
+		entityTypes: sqlFamilyEntityTypes,
+		pslBlockDescriptors: sqlFamilyPslBlockDescriptors,
+		attributeSpecs: sqlAttributeSpecs,
+		dataTypes: sqlExpressionRegistration.authoring.dataTypes
+	};
+	generatorFunctions = sqlFamilyGeneratorFunctions;
+	controlMutationDefaults = {
+		defaultFunctionRegistry: /* @__PURE__ */ new Map(),
+		generatorDescriptors: sqlFamilyGeneratorDescriptors
+	};
+	fieldLength = ({ codecId, typeParams }, dataTypes) => sqlCodecColumnLength(dataTypes, codecId, typeParams);
+	pslDiagnostics = {
+		describeUnsupportedAttribute: sqlFamilyDescribeUnsupportedAttribute,
+		describeUnresolvedType: sqlFamilyDescribeUnresolvedType
+	};
+	create(stack) {
+		return createSqlFamilyInstance(stack);
+	}
+};
+/**
+* The SQL family's default functions, each a database default: `autoincrement()` and `now()`. A value the client generates is a generator function, written `@onCreate(...)`.
+*/
+function sqlDefaultFunctions() {
+	return {
+		autoincrement: {
+			signature: { documentation: "Generates an increasing integer value in the database." },
+			usageSignatures: ["autoincrement()"],
+			lower: () => databaseFunction("autoincrement()")
+		},
+		now: {
+			signature: { documentation: "Uses the current database timestamp as the default value." },
+			usageSignatures: ["now()"],
+			lower: () => databaseFunction("now()")
+		}
+	};
+}
+function databaseFunction(expression) {
+	return {
+		ok: true,
+		value: {
+			kind: "storage",
+			defaultValue: {
+				kind: "function",
+				expression
+			}
+		}
+	};
+}
+function convertColumn(name, column, types, hooks) {
+	const dataType = sqlDataTypeOfCodec(column.codecId, types);
+	const storage = sqlStorageType(dataType, types.dataTypeLookup);
+	const typeText = schemaTypeText(storage, column.typeParams);
+	const many = column.many !== void 0 && column.many !== false;
+	const rawColumnDefault = column.default ?? void 0;
+	const resolvedColumnDefault = rawColumnDefault !== void 0 && hooks.resolveDefault ? hooks.resolveDefault(rawColumnDefault, {
+		typeText,
+		many
+	}) : rawColumnDefault;
+	return {
+		name,
+		typeText,
+		nullable: column.nullable,
+		...ifDefined("many", many ? true : void 0),
+		...ifDefined("resolvedDefault", resolvedColumnDefault),
+		...ifDefined("authoredDefault", rawColumnDefault),
+		codecRef: buildColumnCodecRef(column, many ? true : void 0),
+		storedType: storage,
+		storedTypeParams: storage.sql.normalize(dataTypeParams(storage, column.typeParams)),
+		...ifDefined("catalogText", nameIsCatalogText(storage) ? typeText : void 0),
+		...ifDefined("defaultValue", rawColumnDefault?.kind === "literal" && rawColumnDefault.value instanceof Date ? dateDefaultValue(rawColumnDefault.value, codecForRef(types.codecLookup, buildColumnCodecRef(column, void 0))) : contractDefaultValue(rawColumnDefault, dataType, dataTypeParams(dataType, column.typeParams), many)),
+		sqlExpressionLiteralFor
+	};
+}
+function sqlExpressionLiteralFor(text) {
+	return sqlTextsReadBack([text]) ? printSqlExpressionLiteral(text) : void 0;
+}
+/**
+* A `Date` default, which an in-memory contract can hold, as the value of the column's type the column's codec reads it as. `undefined` when the codec refuses it or no codec is registered, and the default then compares unequal to any other.
+*/
+function dateDefaultValue(value, codec) {
+	if (codec === void 0) return void 0;
+	try {
+		return codec.toDataTypeValue(value);
+	} catch (error) {
+		if (isInternalError(error)) throw error;
+		return;
+	}
+}
+/**
+* A literal default as a value of the column's type, read from the JSON the contract stores, element by element for a list column. A `null` is a value of a type that stores one, such as a JSON type, and SQL NULL otherwise, as DDL writes it. Loading a contract refuses a value its type does not hold, so a refusal here only means no value, and the comparison falls back to the stored JSON.
+*/
+function contractDefaultValue(columnDefault, type, params, many) {
+	if (columnDefault?.kind !== "literal" || columnDefault.value instanceof Date) return void 0;
+	const stored = columnDefault.value;
+	const read = (json) => {
+		try {
+			return type.fromContract(json, params);
+		} catch (error) {
+			if (isStructuredError(error) && json === null) return null;
+			throw error;
+		}
+	};
+	try {
+		if (many && Array.isArray(stored)) return stored.map(read);
+		return read(stored) ?? void 0;
+	} catch (error) {
+		if (isStructuredError(error)) return void 0;
+		throw error;
+	}
+}
+/**
+* The column's type as the database reports it, from the type it is stored as: the written name with its normal-form parameters (`character(1)` for a bare `character`), or for a
+* type that claims a kind (an enum), its type name as stored.
+*/
+function schemaTypeText(type, typeParams) {
+	const params = dataTypeParams(type, typeParams);
+	return type.sql.claimsKind === void 0 ? renderSqlTypeName(type, type.sql.normalize(params)) : unquotedSqlBaseName(type, params);
+}
+/**
+* Builds the column's `CodecRef` from its codec identity — the same construction the query AST and the migration DDL renderer already use (TML-2456, TML-2918).
+*/
+function buildColumnCodecRef(column, many) {
+	return {
+		codecId: column.codecId,
+		...ifDefined("typeParams", column.typeParams !== void 0 ? blindCast(column.typeParams) : void 0),
+		...ifDefined("many", many)
+	};
+}
+function convertCheck(check, tableName, tableColumns) {
+	return {
+		naming: namingOf(check.name, check.prefix),
+		expression: check.expression,
+		dependsOn: flatColumnDependsOn(tableName, tableColumns)
+	};
+}
+function convertUnique(unique, tableName) {
+	return {
+		columns: unique.columns,
+		...ifDefined("name", unique.name),
+		dependsOn: flatColumnDependsOn(tableName, unique.columns)
+	};
+}
+function convertIndex(index, tableName, tableColumns) {
+	const base = {
+		naming: namingOf(index.name, index.prefix),
+		where: index.where,
+		unique: index.unique,
+		partial: index.where !== void 0,
+		type: index.type,
+		options: index.options,
+		annotations: void 0,
+		dependsOn: flatColumnDependsOn(tableName, index.columns ?? tableColumns)
+	};
+	return index.expression !== void 0 ? {
+		...base,
+		expression: index.expression
+	} : {
+		...base,
+		columns: index.columns ?? []
+	};
+}
+/**
+* The referenced table's chain in the flat (single-schema) tree
+* `contractToSchemaIR`/`contractNamespaceToSchemaIR` build: the root
+* (`SqlSchemaIR`, fixed `'database'` id) followed by the table's own id.
+* Postgres discards this when it re-derives the FK against its own
+* multi-schema tree shape (`contractToPostgresDatabaseSchemaNode`); SQLite's
+* flat tree uses it as-is.
+*/
+function flatSchemaDependsOn(tableName) {
+	return [{
+		nodeKind: RelationalSchemaNodeKind.schema,
+		id: "database"
+	}, {
+		nodeKind: RelationalSchemaNodeKind.table,
+		id: tableName
+	}];
+}
+/**
+* The chains from a table-child object (foreign key, index, unique, primary
+* key) to each of the own columns it is built on, in the flat tree. Dropping
+* a covered column auto-drops the object, so the object's drop must precede
+* the column's; the graph derives that direction from these edges.
+*/
+function flatColumnDependsOn(tableName, columns) {
+	return columns.map((column) => [
+		{
+			nodeKind: RelationalSchemaNodeKind.schema,
+			id: "database"
+		},
+		{
+			nodeKind: RelationalSchemaNodeKind.table,
+			id: tableName
+		},
+		{
+			nodeKind: RelationalSchemaNodeKind.column,
+			id: `column:${column}`
+		}
+	]);
+}
+/**
+* The FK's referenced-namespace identity comes from the target's namespace
+* node, not the raw namespace-id string. An unbound target namespace stamps
+* no `referencedSchema` at all — the FK node's id renders the absence as the
+* empty segment, which is what flat (single-schema) introspection produces,
+* so both diff sides' FK ids meet by construction. A bound namespace (or a
+* cross-space target whose namespace lives in another contract's storage)
+* stamps its coordinate verbatim; namespaced targets (Postgres) resolve the
+* real DDL schema downstream.
+*
+* `dependsOn` carries the referenced table (created before the FK, dropped
+* after it) plus the FK's own columns (dropped after the FK, since dropping a
+* column auto-drops the FK built on it).
+*/
+function convertForeignKey(fk, storage) {
+	const targetIsUnbound = storage.namespaces[fk.target.namespaceId]?.isUnbound === true;
+	return {
+		columns: fk.source.columns,
+		referencedTable: fk.target.tableName,
+		...targetIsUnbound ? {} : { referencedSchema: fk.target.namespaceId },
+		referencedColumns: fk.target.columns,
+		...ifDefined("name", fk.name),
+		...ifDefined("onDelete", fk.onDelete),
+		...ifDefined("onUpdate", fk.onUpdate),
+		dependsOn: [flatSchemaDependsOn(fk.target.tableName), ...flatColumnDependsOn(fk.source.tableName, fk.source.columns)]
+	};
+}
+const COLUMN_TYPE_ERROR_CODES = /* @__PURE__ */ new Set(["CONTRACT.CODEC_DESCRIPTOR_MISSING", "CONTRACT.DATA_TYPE_UNREGISTERED"]);
+function withColumnInErrors(table, column, build) {
+	try {
+		return build();
+	} catch (cause) {
+		if (!isStructuredError(cause) || !COLUMN_TYPE_ERROR_CODES.has(cause.code)) throw cause;
+		throw structuredError(cause.code, cause.message, {
+			cause,
+			...ifDefined("why", cause.why),
+			...ifDefined("fix", cause.fix),
+			meta: {
+				...cause.meta,
+				table,
+				column
+			}
+		});
+	}
+}
+function convertTable(name, table, types, hooks, storage) {
+	const columns = {};
+	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = withColumnInErrors(name, colName, () => convertColumn(colName, colDef, types, hooks));
+	const checks = table.checks && table.checks.length > 0 ? table.checks.map((c) => convertCheck(c, name, Object.keys(table.columns))) : void 0;
+	return new SqlTableIR({
+		name,
+		columns,
+		...ifDefined("primaryKey", table.primaryKey !== void 0 ? {
+			columns: table.primaryKey.columns,
+			...ifDefined("name", table.primaryKey.name),
+			dependsOn: flatColumnDependsOn(name, table.primaryKey.columns)
+		} : void 0),
+		foreignKeys: table.foreignKeys.map((fk) => convertForeignKey(fk, storage)),
+		uniques: table.uniques.map((u) => convertUnique(u, name)),
+		indexes: table.indexes.map((i) => convertIndex(i, name, Object.keys(table.columns))),
+		...ifDefined("checks", checks)
+	});
+}
+/**
+* Detects destructive changes between two contract storages.
+*
+* The additive-only planner silently ignores removals (tables, columns).
+* This function detects those removals so callers can report them as conflicts
+* rather than silently producing an empty plan.
+*
+* Returns an empty array if no destructive changes are found.
+*/
+function detectDestructiveChanges(from, to) {
+	if (!from) return [];
+	const hasOwn = (value, key) => Object.hasOwn(value, key);
+	const conflicts = [];
+	const namespaceIds = [.../* @__PURE__ */ new Set([...Object.keys(from.namespaces), ...Object.keys(to.namespaces)])].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	for (const namespaceId of namespaceIds) {
+		const fromNs = from.namespaces[namespaceId];
+		const toNs = to.namespaces[namespaceId];
+		const fromTables = fromNs?.entries.table;
+		if (!fromTables) continue;
+		for (const tableName of Object.keys(fromTables)) {
+			const toTableRaw = toNs?.entries.table?.[tableName];
+			if (!StorageTable.is(toTableRaw)) {
+				conflicts.push({
+					kind: "tableRemoved",
+					summary: `Table "${tableName}" was removed`
+				});
+				continue;
+			}
+			const toTable = toTableRaw;
+			const fromTableRaw = fromTables[tableName];
+			if (!StorageTable.is(fromTableRaw)) continue;
+			const fromTable = fromTableRaw;
+			for (const columnName of Object.keys(fromTable.columns)) if (!hasOwn(toTable.columns, columnName)) conflicts.push({
+				kind: "columnRemoved",
+				summary: `Column "${tableName}"."${columnName}" was removed`
+			});
+		}
+	}
+	return conflicts;
+}
+/**
+* Converts the tables of a single namespace into a `SqlSchemaIR`, keyed by
+* table name within that namespace. Unlike {@link contractToSchemaIR}, which
+* flattens every namespace's tables into one bare-keyed record (and throws on a
+* cross-namespace name collision), this scopes the table iteration to one
+* namespace so the same table name can exist in two schemas.
+*
+* The full `storage` is still passed to `convertTable`, so value-set / enum /
+* type resolution that legitimately spans namespaces is unaffected. Foreign
+* keys are built purely from the FK descriptor (`fk.target`), so cross-namespace
+* FKs survive per-namespace conversion. The `annotations` block (storage-type
+* derived) is omitted here — the per-namespace tree consumer reads only the
+* per-table fields.
+*/
+function contractNamespaceToSchemaIR(storage, namespaceId, options) {
+	if (options.annotationNamespace.length === 0) throw sqlFamilyError("CONTRACT.PACK_CONTRIBUTION_INVALID", "annotationNamespace must be a non-empty string", {
+		why: "The calling target pack passed an empty annotationNamespace to the contract-to-schema-IR projection.",
+		fix: "Fix the target pack to pass its non-empty annotation namespace (e.g. \"pg\").",
+		meta: { option: "annotationNamespace" }
+	});
+	const namespace = storage.namespaces[namespaceId];
+	if (!namespace) return new SqlSchemaIR({ tables: {} });
+	const tables = {};
+	for (const [tableName, tableDefRaw] of Object.entries(namespace.entries.table ?? {})) {
+		StorageTable.assert(tableDefRaw, `namespaces.${namespaceId}.entries.table.${tableName}`);
+		tables[tableName] = convertTable(tableName, tableDefRaw, options, options, storage);
+	}
+	return new SqlSchemaIR({ tables });
+}
+/**
+* Converts a `Contract` to `SqlSchemaIR`.
+*
+* Reads `contract.storage` for tables.
+*
+* Drops codec metadata (`codecId`) since the schema IR only represents
+* structural information. Each column's type is written from the data type its codec
+* represents, with its parameters (e.g. `character` + `{ length: 36 }` → `character(36)`),
+* so the resulting IR compares correctly against the "to" contract during planning.
+*
+* Returns an empty schema IR when `contract` is `null` (new project).
+*/
+function contractToSchemaIR(contract, options) {
+	if (options.annotationNamespace.length === 0) throw sqlFamilyError("CONTRACT.PACK_CONTRIBUTION_INVALID", "annotationNamespace must be a non-empty string", {
+		why: "The calling target pack passed an empty annotationNamespace to the contract-to-schema-IR projection.",
+		fix: "Fix the target pack to pass its non-empty annotation namespace (e.g. \"pg\").",
+		meta: { option: "annotationNamespace" }
+	});
+	if (!contract) return new SqlSchemaIR({ tables: {} });
+	const storage = contract.storage;
+	const tables = {};
+	for (const ns of Object.values(storage.namespaces)) for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {
+		StorageTable.assert(tableDefRaw, `namespaces.${ns.id}.entries.table.${tableName}`);
+		const tableDef = tableDefRaw;
+		if (tables[tableName] !== void 0) throw sqlFamilyError("CONTRACT.TABLE_AMBIGUOUS", `contractToSchemaIR: duplicate SQL table name "${tableName}" across namespaces (ambiguous for flat SqlSchemaIR.tables).`, {
+			why: "Two namespaces declare a table with the same name, which is ambiguous for the flat schema-IR table map.",
+			fix: "Rename one of the tables so every table name is unique across namespaces.",
+			meta: { table: tableName }
+		});
+		tables[tableName] = convertTable(tableName, tableDef, options, options, storage);
+	}
+	return new SqlSchemaIR({ tables });
+}
+/**
+* Whether a call is allowed to emit under a given control policy.
+*
+* - `managed` — full lifecycle, every op allowed.
+* - `tolerated` — create-if-absent only: allowed iff the call creates a whole
+*   new top-level object (and its subject was positively resolved). Anything
+*   that modifies an existing object, and anything whose subject could not be
+*   resolved, is suppressed.
+* - `external` / `observed` — no DDL at all.
+*/
+function callAllowedUnderControlPolicy(policy, subject) {
+	switch (policy) {
+		case "managed": return true;
+		case "tolerated": return subject?.createsNewObject === true;
+		case "external":
+		case "observed": return false;
+	}
+}
+/**
+* Partition the calls produced for a single set of subjects into those the
+* effective control policy permits (`kept`) and a list of
+* {@link SuppressionRecord}s describing the suppressed calls.
+*
+* **Prefer {@link partitionIssuesByControlPolicy}** for the schema-issue
+* pipeline: it filters subjects out of the planner's *input* so the planner
+* never has to reason about un-modeled state on `external`/`observed`
+* subjects. This call-level helper remains for paths that bypass the issue
+* pipeline — currently the codec-emitted field-event ops, which originate
+* from declared contract fields rather than from introspected schema state
+* and therefore cannot trip the diff engine.
+*/
+function partitionCallsByControlPolicy(options) {
+	const defaultControlPolicy = options.contract.defaultControlPolicy;
+	const kept = [];
+	const suppressions = [];
+	for (const call of options.calls) {
+		const subject = options.resolveControlPolicySubject(call);
+		const policy = governingControlPolicy(subject, defaultControlPolicy);
+		if (callAllowedUnderControlPolicy(policy, subject)) kept.push(call);
+		else suppressions.push({
+			subject,
+			policy,
+			factoryName: options.resolveFactoryName(call),
+			createsNewObject: subject?.createsNewObject ?? false
+		});
+	}
+	return Object.freeze({
+		kept: Object.freeze(kept),
+		suppressions: Object.freeze(suppressions)
+	});
+}
+/**
+* Partition a list of schema-issue-shaped inputs by the effective control
+* policy of each issue's subject *before* the planner is invoked.
+*
+* `plannable` is the list of issues whose subject's effective policy permits
+* the planner to act on them (`managed`, or `tolerated` for whole-object
+* creation issues only). Issues for `external`/`observed` subjects, and
+* non-creation issues for `tolerated` subjects, are dropped from the planner's
+* input entirely — they never enter introspection-driven planning, never feed
+* the diff engine, and never produce DDL calls that would have to be
+* post-filtered. This sidesteps a class of failure where the diff engine
+* cannot reason about the live shape of a subject the user marked as
+* out-of-scope (`external`).
+*
+* `suppressions` is one {@link SuppressionRecord} per suppressed subject (not
+* per suppressed issue). Its `factoryName` is the creation factory name when any
+* of the subject's issues is whole-object creation (e.g. `createTable`), else
+* `undefined` — the family never invents a modification verb for an op that
+* produced no call; the target renders the message.
+*
+* Unresolved-subject issues (`resolveControlPolicySubject` returns
+* `undefined`) emit one record each; they cannot be deduplicated because they
+* carry no subject coordinate.
+*/
+function partitionIssuesByControlPolicy(options) {
+	const defaultControlPolicy = options.contract.defaultControlPolicy;
+	const plannable = [];
+	const suppressedSubjects = /* @__PURE__ */ new Map();
+	const unresolvedSuppressions = [];
+	for (const issue of options.issues) {
+		const subject = options.resolveControlPolicySubject(issue);
+		const policy = governingControlPolicy(subject, defaultControlPolicy);
+		const creationFactoryName = options.resolveCreationFactoryName(issue);
+		if (policy === "managed") {
+			plannable.push(issue);
+			continue;
+		}
+		if (policy === "tolerated" && subject !== void 0 && creationFactoryName !== void 0 && subject.createsNewObject) {
+			plannable.push(issue);
+			continue;
+		}
+		if (subject === void 0) {
+			unresolvedSuppressions.push({
+				subject: void 0,
+				policy,
+				factoryName: creationFactoryName,
+				createsNewObject: false
+			});
+			continue;
+		}
+		const key = subjectKey(subject);
+		const existing = suppressedSubjects.get(key);
+		if (existing) {
+			if (existing.creationFactoryName === void 0 && creationFactoryName !== void 0) existing.creationFactoryName = creationFactoryName;
+		} else suppressedSubjects.set(key, {
+			subject,
+			policy,
+			...ifDefined("creationFactoryName", creationFactoryName)
+		});
+	}
+	const suppressions = [...unresolvedSuppressions];
+	for (const entry of suppressedSubjects.values()) suppressions.push({
+		subject: entry.subject,
+		policy: entry.policy,
+		factoryName: entry.creationFactoryName,
+		createsNewObject: entry.subject.createsNewObject
+	});
+	return Object.freeze({
+		plannable: Object.freeze(plannable),
+		suppressions: Object.freeze(suppressions)
+	});
+}
+function subjectKey(subject) {
+	return `${subject.namespaceId}\u0000${subject.entityKind ?? ""}\u0000${subject.entityName ?? ""}\u0000${subject.rlsPolicy ?? ""}`;
+}
+function planFieldEventOperations(options) {
+	return planFieldEventCalls(options).map(({ call }) => call);
+}
+/** The calls the codec hooks return, each with the field event's column. */
+function planFieldEventCalls(options) {
+	const priorContract = options.priorContract;
+	const newContract = options.newContract;
+	const renamedTo = new Map(options.tableRenames.map((rename) => [renameKey(rename.namespaceId, rename.from), rename.to]));
+	const newNameOf = (namespaceId, tableName) => renamedTo.get(renameKey(namespaceId, tableName));
+	const columnRenamedTo = new Map(options.columnRenames.map((rename) => [renameKey(rename.namespaceId, rename.table, rename.from), rename.to]));
+	const added = [];
+	const dropped = [];
+	const altered = [];
+	const namespaceIds = unionSorted(priorContract ? Object.keys(priorContract.storage.namespaces) : [], Object.keys(newContract.storage.namespaces));
+	for (const namespaceId of namespaceIds) {
+		const priorNs = priorContract?.storage.namespaces[namespaceId];
+		const newNs = newContract.storage.namespaces[namespaceId];
+		const priorTables = underNewNames(priorNs?.entries.table, (tableName) => newNameOf(namespaceId, tableName));
+		const newTables = newNs?.entries.table;
+		const tableNames = unionSorted(priorTables ? Object.keys(priorTables) : [], newTables ? Object.keys(newTables) : []);
+		for (const tableName of tableNames) {
+			const priorTableRaw = priorTables?.[tableName];
+			const newTableRaw = newTables?.[tableName];
+			const priorTable = StorageTable.is(priorTableRaw) ? priorTableRaw : void 0;
+			const newTable = StorageTable.is(newTableRaw) ? newTableRaw : void 0;
+			const priorColumns = underNewNames(priorTable?.columns, (columnName) => columnRenamedTo.get(renameKey(namespaceId, tableName, columnName)));
+			const fieldNames = unionSorted(priorColumns ? Object.keys(priorColumns) : [], newTable ? Object.keys(newTable.columns) : []);
+			for (const fieldName of fieldNames) {
+				const priorField = priorColumns?.[fieldName];
+				const newField = newTable?.columns[fieldName];
+				const entry = {
+					namespaceId,
+					tableName,
+					fieldName,
+					priorTable,
+					newTable,
+					priorField,
+					newField
+				};
+				if (priorField === void 0 && newField !== void 0) added.push(entry);
+				else if (priorField !== void 0 && newField === void 0) dropped.push(entry);
+				else if (priorField !== void 0 && newField !== void 0) {
+					if (isAlteration(priorField, newField, options.dataTypes)) altered.push(entry);
+				}
+			}
+		}
+	}
+	const calls = [];
+	appendCalls("added", added, options.codecHooks, calls, (e) => e.newField?.codecId);
+	appendCalls("dropped", dropped, options.codecHooks, calls, (e) => e.priorField?.codecId);
+	appendCalls("altered", altered, options.codecHooks, calls, (e) => e.newField?.codecId);
+	return calls;
+}
+function renameKey(...parts) {
+	return JSON.stringify(parts);
+}
+function underNewNames(tables, newNameOf) {
+	if (tables === void 0) return void 0;
+	return Object.fromEntries(Object.entries(tables).map(([tableName, table]) => [newNameOf(tableName) ?? tableName, table]));
+}
+function appendCalls(event, entries, codecHooks, calls, pickCodecId) {
+	for (const entry of entries) {
+		const codecId = pickCodecId(entry);
+		if (codecId === void 0) continue;
+		const hook = codecHooks.get(codecId);
+		if (!hook?.onFieldEvent) continue;
+		const ctx = buildContext(event, entry);
+		const emitted = hook.onFieldEvent(event, ctx);
+		for (const call of emitted) calls.push({
+			call,
+			namespaceId: entry.namespaceId,
+			tableName: entry.tableName,
+			columnName: entry.fieldName
+		});
+	}
+}
+/**
+* The context's prior/new sides are scoped to the event:
+*
+* - `'added'`   — only `newTable` / `newField` populated.
+* - `'dropped'` — only `priorTable` / `priorField` populated.
+* - `'altered'` — both sides populated.
+*/
+function buildContext(event, entry) {
+	const base = {
+		namespaceId: entry.namespaceId,
+		tableName: entry.tableName,
+		fieldName: entry.fieldName
+	};
+	if (event === "added") return {
+		...base,
+		...entry.newTable !== void 0 ? { newTable: entry.newTable } : {},
+		...entry.newField !== void 0 ? { newField: entry.newField } : {}
+	};
+	if (event === "dropped") return {
+		...base,
+		...entry.priorTable !== void 0 ? { priorTable: entry.priorTable } : {},
+		...entry.priorField !== void 0 ? { priorField: entry.priorField } : {}
+	};
+	return {
+		...base,
+		...entry.priorTable !== void 0 ? { priorTable: entry.priorTable } : {},
+		...entry.newTable !== void 0 ? { newTable: entry.newTable } : {},
+		...entry.priorField !== void 0 ? { priorField: entry.priorField } : {},
+		...entry.newField !== void 0 ? { newField: entry.newField } : {}
+	};
+}
+/**
+* `'altered'` predicate. Returns `false` whenever `codecId` differs —
+* any codec change suppresses the `altered` event entirely, including
+* cases where another property also differs in the same diff. Codec
+* rotation is a v1 non-goal; avoiding the mixed event keeps the
+* migration semantics for codec changes explicit rather than smuggling
+* them through as `altered`.
+*
+* For non-`codecId` diffs, returns `true` iff any other column property
+* differs.
+*/
+function isAlteration(prior, current, dataTypes) {
+	if (prior.codecId !== current.codecId) return false;
+	return !sameStorageColumn(prior, current, dataTypes);
+}
+function sameStorageColumn(a, b, dataTypes) {
+	if (a === b) return true;
+	if (!sameSqlColumnType(a, b, dataTypes)) return false;
+	if (a.nullable !== b.nullable) return false;
+	if (canonicalizeJson(codecOwnParams(a, dataTypes)) !== canonicalizeJson(codecOwnParams(b, dataTypes))) return false;
+	if (!sameJson(a.default, b.default)) return false;
+	return true;
+}
+/** The parameters a column's codec keeps for itself: every key its data type does not declare. */
+function codecOwnParams(column, dataTypes) {
+	const declared = new Set(objectSchemaKeys(dataTypes.get(column.dataType)?.params) ?? []);
+	return Object.fromEntries(Object.entries(column.typeParams ?? {}).filter(([key]) => !declared.has(key)));
+}
+function sameJson(a, b) {
+	if (a === b) return true;
+	if (a === void 0 || b === void 0) return false;
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function unionSorted(a, b) {
+	const set = /* @__PURE__ */ new Set();
+	for (const name of a) set.add(name);
+	for (const name of b) set.add(name);
+	return [...set].sort((x, y) => x < y ? -1 : x > y ? 1 : 0);
+}
+const COLUMN_RENAME_UNMATCHED_CODE = "MIGRATION.COLUMN_RENAME_UNMATCHED";
+function tableLabel$1(namespaceId, table) {
+	return namespaceId === void 0 || namespaceId === UNBOUND_NAMESPACE_ID ? table : `${namespaceId}.${table}`;
+}
+function columnLabel(namespaceId, table, column) {
+	return `"${tableLabel$1(namespaceId, table)}"."${column}"`;
+}
+function declaresColumn(contract, namespaceId, table, column) {
+	const columns = contract.storage.namespaces[namespaceId]?.entries.table?.[table]?.columns;
+	return columns !== void 0 && Object.hasOwn(columns, column);
+}
+/**
+* Refuses a `renameColumn` call that does not match the migration's contracts, with
+* `MIGRATION.COLUMN_RENAME_UNMATCHED`.
+*/
+function unmatchedColumnRename(rename, reason) {
+	return sqlFamilyError(COLUMN_RENAME_UNMATCHED_CODE, `renameColumn ${columnLabel(rename.namespaceId, rename.table, rename.from)} to "${rename.to}" does not match the migration's contracts: ${reason}.`, {
+		why: "renameColumn must name a table and a column as the migration's earlier rename operations leave them, and a new column name that the end contract has on that table and that the table does not have yet. Order the rename calls in the sequence the renames happen, and check the names of the table, the column and the namespace.",
+		meta: {
+			table: rename.table,
+			from: rename.from,
+			to: rename.to
+		}
+	});
+}
+/**
+* Checks a column rename: the table must exist in `previous` (in exactly one namespace when the
+* namespace is not given) with the old column and without the new one, and the end contract must
+* have the new column on that table.
+*/
+function checkColumnRename(previous, endContract, rename) {
+	const namespaceIds = rename.namespaceId === void 0 ? previous.namespacesWithTable(rename.table) : previous.hasTable(rename.namespaceId, rename.table) ? [rename.namespaceId] : [];
+	const [namespaceId, ...others] = namespaceIds;
+	if (namespaceId === void 0) return notOk({ kind: "tableMissing" });
+	if (others.length > 0) return notOk({
+		kind: "tableInManyNamespaces",
+		namespaceIds
+	});
+	if (!previous.hasColumn(namespaceId, rename.table, rename.from)) return notOk({
+		kind: "columnMissing",
+		namespaceId
+	});
+	const [taken] = previous.columnsNamed(namespaceId, rename.table, rename.to).filter((column) => column !== rename.from);
+	if (taken !== void 0) return notOk({
+		kind: "nameTaken",
+		namespaceId,
+		taken
+	});
+	if (!declaresColumn(endContract, namespaceId, rename.table, rename.to)) return notOk({
+		kind: "notInEndContract",
+		namespaceId
+	});
+	return ok({
+		namespaceId,
+		table: rename.table,
+		from: rename.from,
+		to: rename.to
+	});
+}
+/** The reason `MIGRATION.COLUMN_RENAME_UNMATCHED` gives for a mismatch. */
+function columnRenameMismatchReason(rename, mismatch) {
+	switch (mismatch.kind) {
+		case "tableMissing": return `table "${tableLabel$1(rename.namespaceId, rename.table)}" does not exist at this point of the migration`;
+		case "tableInManyNamespaces": return `table "${rename.table}" is declared in more than one namespace (${mismatch.namespaceIds.join(", ")}); name its namespace`;
+		case "columnMissing": return `column ${columnLabel(mismatch.namespaceId, rename.table, rename.from)} does not exist at this point of the migration`;
+		case "nameTaken": return `column ${columnLabel(mismatch.namespaceId, rename.table, rename.to)} already exists at this point of the migration${mismatch.taken === rename.to ? "" : ` as "${mismatch.taken}"`}`;
+		case "notInEndContract": return `column ${columnLabel(mismatch.namespaceId, rename.table, rename.to)} does not exist in the end contract`;
+	}
+}
+/**
+* Resolves a column a migration renames with {@link checkColumnRename}, refusing a mismatch with
+* `MIGRATION.COLUMN_RENAME_UNMATCHED`.
+*/
+function resolveColumnRenameAgainst(previous, endContract, rename) {
+	const checked = checkColumnRename(previous, endContract, rename);
+	if (!checked.ok) return notOk(unmatchedColumnRename(rename, columnRenameMismatchReason(rename, checked.failure)));
+	return ok(checked.value);
+}
+const TABLE_RENAME_UNMATCHED_CODE = "MIGRATION.TABLE_RENAME_UNMATCHED";
+function tableLabel(namespaceId, tableName) {
+	return namespaceId === void 0 || namespaceId === UNBOUND_NAMESPACE_ID ? tableName : `${namespaceId}.${tableName}`;
+}
+function declares(contract, namespaceId, tableName) {
+	return Object.hasOwn(contract.storage.namespaces[namespaceId]?.entries.table ?? {}, tableName);
+}
+/**
+* Refuses a `renameTable` call that does not match the migration's contracts, with
+* `MIGRATION.TABLE_RENAME_UNMATCHED`.
+*/
+function unmatchedTableRename(rename, reason) {
+	return sqlFamilyError(TABLE_RENAME_UNMATCHED_CODE, `renameTable "${tableLabel(rename.namespaceId, rename.from)}" to "${rename.to}" does not match the migration's contracts: ${reason}.`, {
+		why: "renameTable must name a table as the migration's earlier rename operations leave it, and a new name that the end contract has and that no earlier rename operation has already produced. Order the renameTable calls in the sequence the renames happen, make the rename its own schema change, and check the spelling, the table and the namespace.",
+		meta: {
+			from: rename.from,
+			to: rename.to
+		}
+	});
+}
+/**
+* Checks a table rename: the table must exist in `previous` (in exactly one namespace when the
+* namespace is not given), and the new name must exist in the end contract and not in `previous`.
+*/
+function checkTableRename(previous, endContract, rename) {
+	const namespaceIds = rename.namespaceId === void 0 ? previous.namespacesWithTable(rename.from) : previous.hasTable(rename.namespaceId, rename.from) ? [rename.namespaceId] : [];
+	const [namespaceId, ...others] = namespaceIds;
+	if (namespaceId === void 0) return notOk({ kind: "tableMissing" });
+	if (others.length > 0) return notOk({
+		kind: "tableInManyNamespaces",
+		namespaceIds
+	});
+	const [taken] = previous.tablesNamed(namespaceId, rename.to).filter((table) => table !== rename.from);
+	if (taken !== void 0) return notOk({
+		kind: "nameTaken",
+		namespaceId,
+		taken
+	});
+	if (!declares(endContract, namespaceId, rename.to)) return notOk({
+		kind: "notInEndContract",
+		namespaceId
+	});
+	return ok({
+		namespaceId,
+		from: rename.from,
+		to: rename.to
+	});
+}
+/** The reason `MIGRATION.TABLE_RENAME_UNMATCHED` gives for a mismatch. */
+function tableRenameMismatchReason(rename, mismatch) {
+	switch (mismatch.kind) {
+		case "tableMissing": return `table "${tableLabel(rename.namespaceId, rename.from)}" does not exist at this point of the migration`;
+		case "tableInManyNamespaces": return `table "${rename.from}" is declared in more than one namespace (${mismatch.namespaceIds.join(", ")}); name its namespace`;
+		case "nameTaken": return `table "${tableLabel(mismatch.namespaceId, rename.to)}" already exists at this point of the migration${mismatch.taken === rename.to ? "" : ` as "${mismatch.taken}"`}`;
+		case "notInEndContract": return `table "${tableLabel(mismatch.namespaceId, rename.to)}" does not exist in the end contract`;
+	}
+}
+/**
+* Resolves a table a migration renames with {@link checkTableRename}, refusing a mismatch with
+* `MIGRATION.TABLE_RENAME_UNMATCHED`.
+*/
+function resolveTableRenameAgainst(previous, endContract, rename) {
+	const checked = checkTableRename(previous, endContract, rename);
+	if (!checked.ok) return notOk(unmatchedTableRename(rename, tableRenameMismatchReason(rename, checked.failure)));
+	return ok(checked.value);
+}
+/** Whether a model's storage names a table, as a model a SQL contract stores in a table does. */
+function isSqlModelStorage(storage) {
+	return typeof storage["table"] === "string" && typeof storage["namespaceId"] === "string" && typeof storage["fields"] === "object" && storage["fields"] !== null;
+}
+/** The storage of a model the contract stores in a table, or `undefined` for any other model. */
+function sqlModelStorage(contract, coordinate) {
+	const storage = contract.domain.namespaces[coordinate.namespaceId]?.models[coordinate.model]?.storage;
+	return storage !== void 0 && isSqlModelStorage(storage) ? storage : void 0;
+}
+function modelTable(contract, coordinate) {
+	const storage = sqlModelStorage(contract, coordinate);
+	return storage === void 0 ? void 0 : {
+		namespaceId: storage.namespaceId,
+		table: storage.table
+	};
+}
+/**
+* The storage effect of a model rename: the origin model's table compared with the destination
+* model's. Equal tables mean the rename needs no storage change.
+*/
+function modelRenameStorageEffect(statement, fromContract, contract) {
+	const from = modelTable(fromContract, statement.from);
+	if (from === void 0) return notOk({
+		kind: "noTable",
+		model: statement.from
+	});
+	const to = modelTable(contract, statement.to);
+	if (to === void 0) return notOk({
+		kind: "noTable",
+		model: statement.to
+	});
+	if (from.namespaceId !== to.namespaceId) return ok({
+		kind: "moveNamespace",
+		from,
+		to
+	});
+	if (from.table === to.table) return ok({ kind: "unchanged" });
+	return ok({
+		kind: "renameTable",
+		rename: {
+			namespaceId: from.namespaceId,
+			from: from.table,
+			to: to.table
+		}
+	});
+}
+function fieldColumn(contract, coordinate) {
+	const fields = sqlModelStorage(contract, coordinate)?.fields;
+	return fields !== void 0 && Object.hasOwn(fields, coordinate.field) ? fields[coordinate.field]?.column : void 0;
+}
+/**
+* The storage effect of a field rename: the origin field's column compared with the destination
+* field's. A relation field has no column on either side, and equal columns need no change.
+*/
+function fieldRenameStorageEffect(statement, fromContract, contract) {
+	const table = modelTable(fromContract, statement.from);
+	if (table === void 0) return notOk({
+		kind: "noTable",
+		model: statement.from
+	});
+	const from = fieldColumn(fromContract, statement.from);
+	const to = fieldColumn(contract, statement.to);
+	if (from === void 0 && to === void 0) return ok({ kind: "unchanged" });
+	if (from === void 0 || to === void 0) return notOk({ kind: "columnOnOneSide" });
+	if (from === to) return ok({ kind: "unchanged" });
+	return ok({
+		kind: "renameColumn",
+		table,
+		from,
+		to
+	});
+}
+function operationsOf(call) {
+	return [call, ...call.companions];
+}
+/** The origins of a plan whose statements renamed and moved nothing. */
+const NO_RENAMED_ORIGINS = {
+	originTable: (current) => current,
+	originColumn: (_origin, column) => column
+};
+const DRIFTED = "so the database has drifted from that contract. Inspect it with prisma db schema, or leave out this statement.";
+const UNMATCHED = "A statement plans the rename a hand-written rename call makes, and that call does not match the contracts. Leave out this statement.";
+function statementRefused(statement, summary, why, location, refusedOperationClass) {
+	return {
+		kind: "statementRefused",
+		summary,
+		why,
+		refusedStatement: statement,
+		...refusedOperationClass === void 0 ? {} : { refusedOperationClass },
+		...location === void 0 ? {} : { location: {
+			namespaceId: location.namespaceId,
+			entityKind: "table",
+			entityName: location.table,
+			...location.column === void 0 ? {} : { column: location.column }
+		} }
+	};
+}
+function tableControlPolicy(contract, table) {
+	const node = contract.storage.namespaces[table.namespaceId]?.entries.table?.[table.table];
+	return governingControlPolicy({ explicitNodeControlPolicy: StorageTable.is(node) ? node.control : void 0 }, contract.defaultControlPolicy);
+}
+function tableKey(table) {
+	return JSON.stringify([table.namespaceId, table.table]);
+}
+/** A contract space other than the one planned that declares the namespace, if any. */
+function otherSpaceDeclaring(ownership, namespaceId) {
+	return (ownership.oracle?.namespaceDeclaringSpaces(namespaceId) ?? []).find((spaceId) => spaceId !== ownership.spaceId);
+}
+function withoutNamespacesRefused(statement, label) {
+	return statementRefused(statement, `${label}: the database target keeps every table in one namespace`, "This database target has no namespaces, so a statement cannot rename a namespace or move a model to another one. Leave out this statement.", void 0);
+}
+function namespaceText(namespaceId) {
+	return namespaceId === UNBOUND_NAMESPACE_ID ? "the unbound namespace" : `namespace "${namespaceId}"`;
+}
+function qualifiedTable(table) {
+	return table.namespaceId === UNBOUND_NAMESPACE_ID ? table.table : `${table.namespaceId}.${table.table}`;
+}
+function tableRenameRefused(statement, label, rename, mismatch) {
+	switch (mismatch.kind) {
+		case "tableMissing": return statementRefused(statement, `${label}: the schema being planned from has no table "${rename.from}"`, `The database has no table "${rename.from}", although the contract it was last updated to names it, ${DRIFTED}`, {
+			namespaceId: rename.namespaceId,
+			table: rename.from
+		});
+		case "nameTaken": return statementRefused(statement, `${label}: the schema being planned from already has a table "${rename.to}"${mismatch.taken === rename.to ? "" : `, as "${mismatch.taken}"`}`, `A rename cannot replace a table that already exists. Rename or drop table "${mismatch.taken}" first, or leave out this statement.`, {
+			namespaceId: rename.namespaceId,
+			table: rename.to
+		});
+		case "tableInManyNamespaces":
+		case "notInEndContract": return statementRefused(statement, `${label}: ${tableRenameMismatchReason(rename, mismatch)}`, UNMATCHED, {
+			namespaceId: rename.namespaceId,
+			table: rename.from
+		});
+	}
+}
+function columnRenameRefused(statement, label, rename, mismatch) {
+	const table = {
+		namespaceId: rename.namespaceId,
+		table: rename.table
+	};
+	switch (mismatch.kind) {
+		case "tableMissing": return statementRefused(statement, `${label}: the schema being planned from has no table "${rename.table}"`, `The database has no table "${rename.table}", although the contract it was last updated to names it, ${DRIFTED}`, table);
+		case "columnMissing": return statementRefused(statement, `${label}: the schema being planned from has no column "${rename.from}" on table "${rename.table}"`, `The database has no column "${rename.from}" on table "${rename.table}", although the contract it was last updated to names it, ${DRIFTED}`, {
+			...table,
+			column: rename.from
+		});
+		case "nameTaken": return statementRefused(statement, `${label}: the schema being planned from already has a column "${mismatch.taken}" on table "${rename.table}"`, `A rename cannot replace a column that already exists. Rename or drop column "${mismatch.taken}" of table "${rename.table}" first, or leave out this statement.`, {
+			...table,
+			column: rename.to
+		});
+		case "tableInManyNamespaces":
+		case "notInEndContract": return statementRefused(statement, `${label}: ${columnRenameMismatchReason(rename, mismatch)}`, UNMATCHED, {
+			...table,
+			column: rename.from
+		});
+	}
+}
+var StatementPlanner = class {
+	#fromContract;
+	#contract;
+	#policy;
+	#target;
+	/** Where each table renamed or moved so far is in the working schema, keyed by its origin place. */
+	#renamedTables = /* @__PURE__ */ new Map();
+	/** The origin place of each table renamed or moved so far, keyed as `#renamedTables`. */
+	#originTables = /* @__PURE__ */ new Map();
+	/** Each column renamed so far: its origin table, and its name before and after. */
+	#renamedColumns = [];
+	/** The name each namespace renamed so far has in the working schema, keyed by its origin name. */
+	#renamedNamespaces = /* @__PURE__ */ new Map();
+	#ownership;
+	calls = [];
+	/** How many operations the calls planned so far lower to. */
+	#operationCount = 0;
+	tableRenames = [];
+	columnRenames = [];
+	constructor(input) {
+		this.#fromContract = input.fromContract;
+		this.#contract = input.contract;
+		this.#policy = input.policy;
+		this.#target = input.target;
+		this.#ownership = input.ownership;
+	}
+	/** Plans one statement; the result is the positions of the operations it accounts for. */
+	plan(statement) {
+		switch (statement.entity) {
+			case "namespace": return this.#planNamespace(statement);
+			case "model": return this.#planModel(statement);
+			case "field": return this.#planField(statement);
+		}
+	}
+	/** Where a table of the origin is in the working schema, after the renames planned so far. */
+	#current(origin) {
+		const table = this.#renamedTables.get(tableKey(origin)) ?? origin;
+		return {
+			namespaceId: this.#renamedNamespaces.get(table.namespaceId) ?? table.namespaceId,
+			table: table.table
+		};
+	}
+	#planNamespace(statement) {
+		const rename = {
+			from: statement.from,
+			to: statement.to
+		};
+		const label = `Cannot rename namespace "${rename.from}" to "${rename.to}"`;
+		const namespaces = this.#target.namespaces;
+		if (namespaces === void 0) return notOk(withoutNamespacesRefused(statement, label));
+		const movePerModel = `--rename ${rename.from}.<Model>:${rename.to}.<Model>`;
+		const refusal = namespaces.namespaceRenameRefusal(rename);
+		if (refusal !== void 0) return notOk(statementRefused(statement, `${label}: ${refusal.reason}`, refusal.fix, void 0));
+		const otherSpace = this.#ownership === void 0 ? void 0 : otherSpaceDeclaring(this.#ownership, rename.from);
+		if (otherSpace !== void 0) return notOk(statementRefused(statement, `${label}: contract space "${otherSpace}" also declares it`, `Renaming the namespace would rename it under contract space "${otherSpace}" too, whose contract still names it "${rename.from}". Leave out this statement, or move each model with ${movePerModel} instead.`, void 0));
+		const tables = Object.keys(this.#contract.storage.namespaces[rename.to]?.entries.table ?? {});
+		for (const table of tables) {
+			const controlPolicy = tableControlPolicy(this.#contract, {
+				namespaceId: rename.to,
+				table
+			});
+			if (controlPolicy === "managed") continue;
+			return notOk(statementRefused(statement, `${label}: table "${table}" has control policy "${controlPolicy}"`, `Statements rename only namespaces whose tables all have control policy "managed"; table "${table}" is "${controlPolicy}". Make the change in the database yourself and leave out this statement.`, {
+				namespaceId: rename.to,
+				table
+			}));
+		}
+		const schemaTables = this.#target.tables();
+		if (!schemaTables.hasNamespace(rename.from)) return notOk(statementRefused(statement, `${label}: the schema being planned from has no namespace "${rename.from}"`, `The database has no namespace "${rename.from}", although the contract it was last updated to names it, ${DRIFTED}`, void 0));
+		if (schemaTables.hasNamespace(rename.to)) return notOk(statementRefused(statement, `${label}: the database already has a namespace "${rename.to}"`, `The database already has a namespace "${rename.to}", which the contract it was last updated to does not declare. If it holds nothing, drop or rename it in the database yourself; otherwise move each model with ${movePerModel} instead of this statement.`, void 0));
+		const planned = this.#emit(statement, label, void 0, namespaces.renameNamespaceCall(rename));
+		if (planned.ok) this.#renamedNamespaces.set(rename.from, rename.to);
+		return planned;
+	}
+	#controlPolicyRefusal(statement, label, destinationTable) {
+		const controlPolicy = tableControlPolicy(this.#contract, destinationTable);
+		if (controlPolicy === "managed") return void 0;
+		return statementRefused(statement, `${label}: the table's control policy is "${controlPolicy}"`, `Statements rename only tables, and columns of tables, whose control policy is "managed"; table "${destinationTable.table}" is "${controlPolicy}". Make the change in the database yourself and leave out this statement.`, destinationTable);
+	}
+	#emit(statement, label, location, call) {
+		const refused = operationsOf(call).map((operation) => operation.operationClass).find((operationClass) => !this.#policy.allowedOperationClasses.includes(operationClass));
+		if (refused !== void 0) return notOk(statementRefused(statement, `${label}: the plan does not allow "${refused}" operations`, `The rename produces a "${refused}" operation, and this command plans only ${this.#policy.allowedOperationClasses.map((c) => `"${c}"`).join(", ")} operations. Leave out this statement, or make the change with a command that allows "${refused}" operations, such as migration plan.`, location, refused));
+		this.#target.apply(call);
+		this.calls.push(call);
+		const first = this.#operationCount;
+		this.#operationCount += operationsOf(call).length;
+		return ok(operationsOf(call).map((_, offset) => first + offset));
+	}
+	#planModel(statement) {
+		const worked = modelRenameStorageEffect(statement, this.#fromContract, this.#contract);
+		if (!worked.ok) return notOk(statementRefused(statement, `Model "${modelDisplayName(worked.failure.model)}" has no table in its contract`, `A model rename renames the model's table, and model "${modelDisplayName(worked.failure.model)}" has none in its contract. Leave out this statement.`, void 0));
+		const effect = worked.value;
+		if (effect.kind === "unchanged") return ok([]);
+		const [origin, destination] = effect.kind === "moveNamespace" ? [effect.from, effect.to] : [{
+			namespaceId: effect.rename.namespaceId,
+			table: effect.rename.from
+		}, {
+			namespaceId: effect.rename.namespaceId,
+			table: effect.rename.to
+		}];
+		const current = this.#current(origin);
+		if (current.namespaceId === destination.namespaceId) {
+			if (current.table === destination.table) return ok([]);
+			return this.#planTableRename(statement, origin, {
+				namespaceId: destination.namespaceId,
+				from: current.table,
+				to: destination.table
+			});
+		}
+		return this.#planMove(statement, origin, current, destination);
+	}
+	#planTableRename(statement, origin, rename) {
+		const destinationTable = {
+			namespaceId: rename.namespaceId,
+			table: rename.to
+		};
+		const label = `Cannot rename table "${rename.from}" to "${rename.to}"`;
+		const policyRefusal = this.#controlPolicyRefusal(statement, label, destinationTable);
+		if (policyRefusal !== void 0) return notOk(policyRefusal);
+		const checked = checkTableRename(this.#target.tables(), this.#contract, rename);
+		if (!checked.ok) return notOk(tableRenameRefused(statement, label, rename, checked.failure));
+		const planned = this.#emit(statement, label, destinationTable, this.#target.renameTableCall(rename));
+		if (planned.ok) {
+			this.tableRenames.push(rename);
+			this.#renamedTables.set(tableKey(origin), destinationTable);
+			this.#originTables.set(tableKey(origin), origin);
+		}
+		return planned;
+	}
+	/**
+	* Moves the table to the destination namespace under its own name, creating the namespace first
+	* when the working schema lacks it, then renames it there when the destination names it
+	* differently. The statement accounts for the move and the rename, not the namespace's creation.
+	*/
+	#planMove(statement, origin, from, to) {
+		const label = `Cannot move table "${from.table}" from ${namespaceText(from.namespaceId)} to ${namespaceText(to.namespaceId)}`;
+		const namespaces = this.#target.namespaces;
+		if (namespaces === void 0) return notOk(withoutNamespacesRefused(statement, label));
+		if (to.namespaceId === UNBOUND_NAMESPACE_ID) return notOk(statementRefused(statement, `Cannot move table "${from.table}" from ${namespaceText(from.namespaceId)} to the unbound namespace: the unbound namespace has no fixed place in the database`, `A table of the unbound namespace lives wherever the connection that uses it looks, so a migration cannot move a table there. Move the table yourself and leave out this statement, or keep the model in ${namespaceText(from.namespaceId)}.`, from));
+		const moved = {
+			namespaceId: to.namespaceId,
+			table: from.table
+		};
+		const policyRefusal = this.#controlPolicyRefusal(statement, label, to);
+		if (policyRefusal !== void 0) return notOk(policyRefusal);
+		const tables = this.#target.tables();
+		if (!tables.hasTable(from.namespaceId, from.table)) return notOk(statementRefused(statement, `${label}: the schema being planned from has no table "${qualifiedTable(from)}"`, `The database has no table "${qualifiedTable(from)}", although the contract it was last updated to names it, ${DRIFTED}`, from));
+		const [taken] = [...tables.tablesNamed(to.namespaceId, from.table), ...tables.tablesNamed(to.namespaceId, to.table)];
+		if (taken !== void 0) {
+			const takenTable = qualifiedTable({
+				namespaceId: to.namespaceId,
+				table: taken
+			});
+			return notOk(statementRefused(statement, `${label}: the schema being planned from already has a table "${takenTable}"`, `A move cannot replace a table that already exists. Rename, move or drop table "${takenTable}" first, or leave out this statement.`, {
+				namespaceId: to.namespaceId,
+				table: taken
+			}));
+		}
+		for (const call of namespaces.createNamespaceCalls(to.namespaceId)) {
+			const created = this.#emit(statement, label, moved, call);
+			if (!created.ok) return created;
+		}
+		const planned = this.#emit(statement, label, moved, namespaces.moveTableCall({
+			table: from.table,
+			from: from.namespaceId,
+			to: to.namespaceId
+		}));
+		if (!planned.ok) return planned;
+		this.#renamedTables.set(tableKey(origin), moved);
+		this.#originTables.set(tableKey(origin), origin);
+		if (to.table === from.table) return planned;
+		const renamed = this.#planTableRename(statement, origin, {
+			namespaceId: to.namespaceId,
+			from: from.table,
+			to: to.table
+		});
+		if (!renamed.ok) return renamed;
+		return ok([...planned.value, ...renamed.value]);
+	}
+	#planField(statement) {
+		const worked = fieldRenameStorageEffect(statement, this.#fromContract, this.#contract);
+		if (!worked.ok && worked.failure.kind === "noTable") return notOk(statementRefused(statement, `Model "${modelDisplayName(worked.failure.model)}" has no table in its contract`, `A field rename renames the field's column, and model "${modelDisplayName(worked.failure.model)}" has no table in its contract. Leave out this statement.`, void 0));
+		if (!worked.ok) return notOk(statementRefused(statement, `Field "${modelDisplayName(statement.from)}.${statement.from.field}" has a column on one side only of ${describeMigrationStatement(statement, this.#fromContract, this.#contract)}`, "A field rename renames a column or changes nothing in storage, and this field gains or loses its column. Leave out this statement and plan the change without it.", void 0));
+		const effect = worked.value;
+		if (effect.kind === "unchanged") return ok([]);
+		const current = this.#current(effect.table);
+		const table = current.table;
+		const destinationTable = modelTable(this.#contract, statement.to);
+		if (destinationTable !== void 0 && (destinationTable.namespaceId !== current.namespaceId || destinationTable.table !== table)) {
+			const tableRename = {
+				namespaceId: current.namespaceId,
+				from: table,
+				to: destinationTable.table
+			};
+			const model = modelDisplayName(statement.to);
+			const fieldText = `${model}.${statement.from.field}:${model}.${statement.to.field}`;
+			return notOk(statementRefused(statement, `Cannot rename column "${table}"."${effect.from}": the model's table changes from "${table}" to "${destinationTable.table}", and no statement renames the table`, `The column would be renamed on a table the plan then drops and creates under the new name, and a migration that only changes the table name is planned the same way. With migration plan, rename the table by hand in its own migration first. Change the contract so that only the table name changes, and run prisma contract emit. Run prisma migration new --name <name> --from <hash of the migration the database is at>, add ${this.#target.renderTableRename(tableRename)} to the operations of its migration.ts, and run node on that migration.ts to write its ops.json. Then change the contract to its final form, emit it, and plan the field rename with --from that migration. With db update, change the contract so that only the table name changes, and run prisma contract emit. Rename the table in the database yourself with ${this.#target.tableRenameByHand(tableRename).join("; ")}, check that prisma db update --dry-run plans no drop of a table or column, and run prisma db update to store that contract. Then emit the final contract and run prisma db update --rename ${fieldText}.`, {
+				namespaceId: current.namespaceId,
+				table,
+				column: effect.from
+			}));
+		}
+		const rename = {
+			namespaceId: current.namespaceId,
+			table,
+			from: effect.from,
+			to: effect.to
+		};
+		const tableLocation = {
+			namespaceId: rename.namespaceId,
+			table
+		};
+		const label = `Cannot rename column "${table}"."${rename.from}" to "${rename.to}"`;
+		const policyRefusal = this.#controlPolicyRefusal(statement, label, tableLocation);
+		if (policyRefusal !== void 0) return notOk(policyRefusal);
+		const checked = checkColumnRename(this.#target.tables(), this.#contract, rename);
+		if (!checked.ok) return notOk(columnRenameRefused(statement, label, rename, checked.failure));
+		const planned = this.#emit(statement, label, {
+			...tableLocation,
+			column: rename.from
+		}, this.#target.renameColumnCall(rename));
+		if (planned.ok) {
+			this.columnRenames.push(rename);
+			this.#renamedColumns.push({
+				origin: effect.table,
+				from: effect.from,
+				to: effect.to
+			});
+		}
+		return planned;
+	}
+	/** The origins of the working schema's tables and columns, as the statements left them. */
+	origins() {
+		const sameTable = (left, right) => left.namespaceId === right.namespaceId && left.table === right.table;
+		return {
+			originTable: (current) => {
+				for (const origin of this.#originTables.values()) if (sameTable(this.#current(origin), current)) return origin;
+				for (const [origin, renamed] of this.#renamedNamespaces) if (renamed === current.namespaceId) return {
+					namespaceId: origin,
+					table: current.table
+				};
+				return current;
+			},
+			originColumn: (origin, column) => this.#renamedColumns.find((renamed) => sameTable(renamed.origin, origin) && renamed.to === column)?.from ?? column
+		};
+	}
+};
+/**
+* Plans the statements against a target's working schema, namespace renames first and the rest in
+* the order given: model and field statements name the origin and destination contracts, so the
+* namespace renames' place among them does not matter. Each model rename becomes a table rename
+* and each field rename a column rename, computed against the schema earlier statements left, then
+* applied to it. The first statement that cannot be planned fails the whole
+* plan with a `statementRefused` conflict that carries the statement.
+*/
+function planStatements(input) {
+	const { fromContract } = input;
+	const [first] = input.statements;
+	if (first === void 0) return ok({
+		calls: [],
+		tableRenames: [],
+		columnRenames: [],
+		appliedStatements: [],
+		origins: NO_RENAMED_ORIGINS
+	});
+	if (fromContract === null) return notOk(statementRefused(first, "Statements need an origin contract, and this plan has none", "A statement names models and fields of the origin contract, and this plan has none. Plan from a contract that has the old names, or leave out the statement.", void 0));
+	const planner = new StatementPlanner({
+		...input,
+		fromContract,
+		ownership: input.ownership
+	});
+	const appliedStatements = [];
+	const namespacesFirst = [...input.statements.filter((statement) => statement.entity === "namespace"), ...input.statements.filter((statement) => statement.entity !== "namespace")];
+	for (const statement of namespacesFirst) {
+		const operationIndexes = planner.plan(statement);
+		if (!operationIndexes.ok) return operationIndexes;
+		appliedStatements.push({
+			statement,
+			operationIndexes: operationIndexes.value
+		});
+	}
+	return ok({
+		calls: planner.calls,
+		tableRenames: planner.tableRenames,
+		columnRenames: planner.columnRenames,
+		appliedStatements,
+		origins: planner.origins()
+	});
+}
+/**
+* The column of each field a convert or backfill statement names, as the destination contract
+* stores it. These statements rename nothing, so the strategies that plan a field's change read
+* them instead of the working schema. A field with no column has none to list.
+*/
+function fieldStatementColumns(statements, contract) {
+	const columnsOf = (kind) => statements.flatMap((statement) => {
+		if (statement.kind !== kind) return [];
+		const table = modelTable(contract, statement.field);
+		const column = fieldColumn(contract, statement.field);
+		return table === void 0 || column === void 0 ? [] : [{
+			...table,
+			column,
+			field: statement.field,
+			text: fieldStatementText(contract, statement.field)
+		}];
+	});
+	return {
+		convert: columnsOf("convert"),
+		backfill: columnsOf("backfill")
+	};
+}
+/**
+* A conflict for the first backfill statement that names a field the origin model does not have and
+* whose column has a default: the default fills the existing rows when the column is added, so the
+* statement has nothing to fill. A field already in the origin keeps its backfill, since a default
+* does not fill the rows that hold NULL when the column becomes required.
+*/
+function backfillOfDefaultedField(statements, fromContract, contract) {
+	for (const statement of statements) {
+		if (statement.kind !== "backfill" || fromContract === null) continue;
+		const originModel = sqlModelStorage(fromContract, statement.field);
+		if (originModel === void 0 || Object.hasOwn(originModel.fields, statement.field.field)) continue;
+		const table = modelTable(contract, statement.field);
+		const column = fieldColumn(contract, statement.field);
+		if (table === void 0 || column === void 0) continue;
+		if ((contract.storage.namespaces[table.namespaceId]?.entries.table?.[table.table]?.columns[column])?.default === void 0) continue;
+		return statementRefused(statement, `${describeMigrationStatement(statement, fromContract, contract)}: the field is new and has a default`, "The default fills the existing rows when the column is added, so there is nothing to backfill. Leave out the --backfill statement.", {
+			namespaceId: table.namespaceId,
+			table: table.table,
+			column
+		});
+	}
+}
+/**
+* Every statement of a plan in the order given, with the operations it accounts for: a rename's
+* from `renames`, and none yet for any other statement.
+*/
+function appliedStatementsInOrder(statements, renames) {
+	return statements.map((statement) => renames.find((applied) => applied.statement === statement) ?? {
+		statement,
+		operationIndexes: []
+	});
+}
+/**
+* The field of `contract` that stores `column` of `table`, or undefined when no field stores it or
+* tables of two storage namespaces share the table's name.
+*/
+function fieldOfColumn(contract, table, column) {
+	const fields = Object.entries(contract.domain.namespaces).flatMap(([namespaceId, namespace]) => Object.entries(namespace.models).flatMap(([model, definition]) => {
+		const { storage } = definition;
+		if (!isSqlModelStorage(storage) || storage.table !== table) return [];
+		const field = Object.entries(storage.fields).find(([, stored]) => stored.column === column);
+		if (field === void 0) return [];
+		return [{
+			storageNamespace: storage.namespaceId,
+			isRoot: definition.base === void 0,
+			subject: {
+				kind: "field",
+				namespaceId: asNamespaceId(namespaceId),
+				model,
+				field: field[0]
+			}
+		}];
+	}));
+	if (new Set(fields.map(({ storageNamespace }) => storageNamespace)).size !== 1) return void 0;
+	return (fields.find(({ isRoot }) => isRoot) ?? fields[0])?.subject;
+}
+/** What a codec hook's call is about: the column of the field event it was returned for. */
+function fieldEventStorage(field) {
+	return {
+		storageName: [
+			...field.namespaceId === UNBOUND_NAMESPACE_ID ? [] : [field.namespaceId],
+			field.tableName,
+			field.columnName
+		].join("."),
+		table: {
+			namespaceId: field.namespaceId,
+			table: field.tableName,
+			column: field.columnName
+		}
+	};
+}
+/**
+* Names for destructive calls a target cannot map to storage: each call's factory name, with a
+* `#n` ordinal when several calls of the plan share it, so each name picks out one call.
+*/
+function unknownCallNames(calls) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const call of calls) counts.set(call.factoryName, (counts.get(call.factoryName) ?? 0) + 1);
+	const seen = /* @__PURE__ */ new Map();
+	return new Map(calls.map((call) => {
+		const ordinal = (seen.get(call.factoryName) ?? 0) + 1;
+		seen.set(call.factoryName, ordinal);
+		return [call, (counts.get(call.factoryName) ?? 0) > 1 ? `${call.factoryName}#${ordinal}` : call.factoryName];
+	}));
+}
+/** The models of `contract` that store `table`: a model and its variants share one. */
+function modelsStoring(contract, namespaceId, table) {
+	return Object.entries(contract.domain.namespaces).flatMap(([modelNamespace, namespace]) => Object.entries(namespace.models).flatMap(([model, definition]) => {
+		const { storage } = definition;
+		if (!isSqlModelStorage(storage)) return [];
+		if (storage.namespaceId !== namespaceId || storage.table !== table) return [];
+		return [{
+			coordinate: {
+				namespaceId: asNamespaceId(modelNamespace),
+				model
+			},
+			isRoot: definition.base === void 0,
+			fields: storage.fields
+		}];
+	}));
+}
+function subjectOf(target, context) {
+	const storage = {
+		kind: "storage",
+		name: target.storageName
+	};
+	const { fromContract } = context;
+	if (target.table === void 0 || fromContract === null) return storage;
+	const origin = context.origins.originTable({
+		namespaceId: target.table.namespaceId,
+		table: target.table.table
+	});
+	const models = modelsStoring(fromContract, origin.namespaceId, origin.table);
+	if (target.table.column === void 0) {
+		const model = models.find(({ isRoot }) => isRoot) ?? models[0];
+		return model === void 0 ? storage : {
+			kind: "model",
+			...model.coordinate
+		};
+	}
+	const column = context.origins.originColumn(origin, target.table.column);
+	for (const model of [...models].sort((a, b) => Number(b.isRoot) - Number(a.isRoot))) {
+		const field = Object.entries(model.fields).find(([, stored]) => stored.column === column)?.[0];
+		if (field !== void 0) return {
+			kind: "field",
+			...model.coordinate,
+			field
+		};
+	}
+	return storage;
+}
+/**
+* How to keep the rows of a dropped table whose model the destination keeps under the same name in
+* another table of the same namespace: no statement can rename that table, so the user renames it
+* by hand. None when the origin contract already stores a model in that table.
+*/
+function keepTableAdvice(target, subject, context) {
+	if (subject.kind !== "model" || target.table === void 0 || context.fromContract === null) return;
+	const storage = context.contract.domain.namespaces[subject.namespaceId]?.models[subject.model]?.storage;
+	if (storage === void 0 || !isSqlModelStorage(storage)) return void 0;
+	const { namespaceId, table: from } = target.table;
+	if (storage.namespaceId !== namespaceId || storage.table === from) return void 0;
+	if (modelsStoring(context.fromContract, namespaceId, storage.table).length > 0) return void 0;
+	const rename = {
+		namespaceId,
+		from,
+		to: storage.table
+	};
+	return `To keep its rows, rename table "${from}" to "${storage.table}" instead; a statement cannot rename the table of a model that keeps its name. With db update, rename the table in the database yourself with ${context.byHand.tableRenameByHand(rename).join("; ")}, then run prisma db update. With migration plan, write the rename as a migration of its own instead: run prisma migration new --name <name> --from <hash of the migration the database is at>, add ${context.byHand.renderTableRename(rename)} to the operations of its migration.ts, run node on that migration.ts so it writes ops.json, then run prisma db migrate.`;
+}
+/**
+* The subject of each operation that loses data and each that changes access, at its position in
+* the plan. A subject is a model or a field of the origin contract when one stores it, found under
+* its origin name when a rename statement renamed its table or column earlier in the plan.
+*/
+function subjectsOfCalls(calls, context) {
+	const dataLoss = [];
+	const accessChanges = [];
+	const temporaryValues = [];
+	let operationIndex = 0;
+	for (const call of calls) {
+		for (const { table, column, value } of call.temporaryValues) temporaryValues.push({
+			operationIndex,
+			subject: fieldOfColumn(context.contract, table, column) ?? {
+				kind: "storage",
+				name: `${table}.${column}`
+			},
+			value
+		});
+		for (const target of call.dataLoss) {
+			const subject = subjectOf(target, context);
+			dataLoss.push({
+				operationIndex,
+				subject,
+				loss: target.loss,
+				label: call.label,
+				...ifDefined("keepDataAdvice", keepTableAdvice(target, subject, context))
+			});
+		}
+		for (const target of call.accessChanges) accessChanges.push({
+			operationIndex,
+			subject: subjectOf(target, context),
+			widens: target.widens
+		});
+		operationIndex += call.operationCount;
+	}
+	return {
+		dataLoss,
+		accessChanges,
+		temporaryValues
+	};
+}
+const readOnlyEmptyObject = Object.freeze({});
+function cloneRecord(value) {
+	if (value === readOnlyEmptyObject) return value;
+	return blindCast(Object.freeze({ ...value }));
+}
+function freezeSteps(steps) {
+	if (steps.length === 0) return Object.freeze([]);
+	return Object.freeze(steps.map((step) => Object.freeze({
+		description: step.description,
+		sql: step.sql,
+		...step.params ? { params: Object.freeze([...step.params]) } : {},
+		...step.meta ? { meta: cloneRecord(step.meta) } : {},
+		...step.expectation ? { expectation: Object.freeze({ ...step.expectation }) } : {}
+	})));
+}
+function freezeDetailsValue(value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value !== "object") return value;
+	if (Array.isArray(value)) return blindCast(Object.freeze([...value]));
+	return blindCast(Object.freeze({ ...value }));
+}
+function freezeTargetDetails(target) {
+	return Object.freeze({
+		id: target.id,
+		...target.details !== void 0 ? { details: freezeDetailsValue(target.details) } : {}
+	});
+}
+function freezeOperation(operation) {
+	return Object.freeze({
+		id: operation.id,
+		label: operation.label,
+		...operation.summary ? { summary: operation.summary } : {},
+		operationClass: operation.operationClass,
+		...operation.invariantId ? { invariantId: operation.invariantId } : {},
+		target: freezeTargetDetails(operation.target),
+		precheck: freezeSteps(operation.precheck),
+		execute: freezeSteps(operation.execute),
+		postcheck: freezeSteps(operation.postcheck),
+		...operation.meta ? { meta: cloneRecord(operation.meta) } : {}
+	});
+}
+function freezeOperations(operations) {
+	if (operations.length === 0) return Object.freeze([]);
+	return Object.freeze(operations.map((operation) => freezeOperation(operation)));
+}
+function createMigrationPlan(options) {
+	return Object.freeze({
+		targetId: options.targetId,
+		spaceId: options.spaceId,
+		...options.origin !== void 0 ? { origin: options.origin ? Object.freeze({ ...options.origin }) : null } : {},
+		destination: Object.freeze({ ...options.destination }),
+		operations: freezeOperations(options.operations),
+		providedInvariants: Object.freeze([...options.providedInvariants]),
+		...options.meta ? { meta: cloneRecord(options.meta) } : {}
+	});
+}
+function plannerSuccess(plan, appliedStatements, subjects, warnings) {
+	return Object.freeze({
+		kind: "success",
+		plan,
+		appliedStatements: Object.freeze([...appliedStatements]),
+		dataLoss: Object.freeze([...subjects.dataLoss]),
+		accessChanges: Object.freeze([...subjects.accessChanges]),
+		temporaryValues: Object.freeze([...subjects.temporaryValues]),
+		...warnings && warnings.length > 0 ? { warnings: Object.freeze(warnings.map((conflict) => Object.freeze({
+			kind: conflict.kind,
+			summary: conflict.summary,
+			...conflict.why ? { why: conflict.why } : {},
+			...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
+			...conflict.refusedStatement ? { refusedStatement: conflict.refusedStatement } : {},
+			...conflict.refusedOperationClass ? { refusedOperationClass: conflict.refusedOperationClass } : {},
+			...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
+		}))) } : {}
+	});
+}
+function plannerFailure(conflicts) {
+	return Object.freeze({
+		kind: "failure",
+		conflicts: Object.freeze(conflicts.map((conflict) => Object.freeze({
+			kind: conflict.kind,
+			summary: conflict.summary,
+			...conflict.why ? { why: conflict.why } : {},
+			...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
+			...conflict.refusedStatement ? { refusedStatement: conflict.refusedStatement } : {},
+			...conflict.refusedOperationClass ? { refusedOperationClass: conflict.refusedOperationClass } : {},
+			...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
+		})))
+	});
+}
+/**
+* Creates a successful migration runner result.
+*/
+function runnerSuccess(value) {
+	return ok(Object.freeze({
+		operationsPlanned: value.operationsPlanned,
+		operationsExecuted: value.operationsExecuted
+	}));
+}
+/**
+* Creates a failed migration runner result.
+*/
+function runnerFailure(code, summary, options) {
+	return notOk(migrationRunnerFailure(code, summary, options));
+}
+/**
+* Policy used by `db init`: additive-only operations, no widening/destructive steps.
+*/
+const INIT_ADDITIVE_POLICY = Object.freeze({ allowedOperationClasses: Object.freeze(["additive"]) });
+const RequiredColumnMeta = type({ requiredColumn: {
+	table: "string",
+	column: "string",
+	reason: "'nullValues' | 'newField' | 'backfillMissedRows'"
+} });
+/**
+* The meta of a step that fails when rows have no value for a column that is to become required:
+* rows hold NULL in it, or, for a new column that can be added to an empty table only, the table
+* has rows. When the step fails, the runner counts those rows.
+*/
+function requiredColumnMeta(table, column, reason) {
+	return { requiredColumn: {
+		table,
+		column,
+		reason
+	} };
+}
+/** The column a step checks before it becomes required, as {@link requiredColumnMeta} marks it. */
+function requiredColumnOf(step) {
+	const meta = RequiredColumnMeta(step.meta ?? {});
+	return meta instanceof type.errors ? void 0 : meta.requiredColumn;
+}
+/** What a runner failure says of the rows a column that is to become required has no value in. */
+function rowsWithoutValueSummary(required, rows) {
+	const { table, column } = required;
+	if (required.reason === "newField") return `"${table}" has ${rows} ${rows === 1 ? "row" : "rows"}, so the new required column "${column}" cannot be added: it can be added to an empty table only.`;
+	const counted = `${rows} ${rows === 1 ? "row" : "rows"} of "${table}"`;
+	if (required.reason === "backfillMissedRows") return `${counted} still ${rows === 1 ? "holds" : "hold"} NULL in "${column}" after its backfill step, so it cannot become required.`;
+	return `${counted} ${rows === 1 ? "holds" : "hold"} NULL in "${column}", so it cannot become required.`;
+}
+function migrationRange(edges, operationIndex, operationCount) {
+	let start = 0;
+	for (const edge of edges) {
+		const end = start + edge.operationCount;
+		if (operationIndex < end) return {
+			start,
+			end
+		};
+		start = end;
+	}
+	return {
+		start: 0,
+		end: operationCount
+	};
+}
+/**
+* The marks of the steps of `operations` that belong to the same migration as the operation at
+* `operationIndex`, in plan order: `edges` say how many operations each migration of the plan has.
+*/
+function requiredColumnsOfMigration(operations, edges, operationIndex) {
+	const { start, end } = migrationRange(edges, operationIndex, operations.length);
+	return operations.slice(start, end).flatMap((operation, offset) => [
+		...operation.precheck,
+		...operation.execute,
+		...operation.postcheck
+	].flatMap((step) => {
+		const required = requiredColumnOf(step);
+		return required === void 0 ? [] : [{
+			operation,
+			operationIndex: start + offset,
+			required
+		}];
+	}));
+}
+/**
+* A runner failure's summary and reports for the rows that columns becoming required have no value
+* in. The failed operation's marks are counted first, and the first of them with such rows is the
+* one the summary names; undefined when none has any. The other marks of the same migration are
+* counted after it, until a count fails, such as for a column an earlier operation adds, so that
+* the advice can name every field that needs a value.
+*/
+async function rowsWithoutValueFailure(input) {
+	const report = (mark, rows) => ({
+		field: fieldOfColumn(input.contract, mark.required.table, mark.required.column),
+		reason: mark.required.reason,
+		rows,
+		operationIndex: mark.operationIndex
+	});
+	for (const mark of input.failed) {
+		const rows = await input.count(mark);
+		if (rows === 0) continue;
+		const reports = [report(mark, rows)];
+		for (const other of input.others) {
+			if (other.required.table === mark.required.table && other.required.column === mark.required.column) continue;
+			let otherRows;
+			try {
+				otherRows = await input.count(other);
+			} catch {
+				break;
+			}
+			if (otherRows > 0) reports.push(report(other, otherRows));
+		}
+		return {
+			summary: rowsWithoutValueSummary(mark.required, rows),
+			reports
+		};
+	}
+}
+/** Keywords that end an expression and continue the statement around it. */
+const STATEMENT_KEYWORDS = /* @__PURE__ */ new Set([
+	"FROM",
+	"WHERE",
+	"UNION",
+	"INTERSECT",
+	"EXCEPT",
+	"GROUP",
+	"ORDER",
+	"HAVING",
+	"LIMIT",
+	"RETURNING",
+	"WINDOW"
+]);
+const WORD = /[A-Za-z_][A-Za-z0-9_$]*/y;
+const DOLLAR_QUOTE = /\$[A-Za-z_]*\$/y;
+function quoteAt(text, index, quoting) {
+	return quoting.find((quote) => text.slice(index, index + quote.open.length).toUpperCase() === quote.open.toUpperCase());
+}
+function endOfQuote(text, start, quote) {
+	let index = start + quote.open.length;
+	while (index < text.length) {
+		if (quote.backslashEscapes && text[index] === "\\") {
+			index += 2;
+			continue;
+		}
+		if (text.startsWith(quote.close, index)) {
+			const after = index + quote.close.length;
+			if (!quote.doubledCloseEscapes || !text.startsWith(quote.close, after)) return after;
+			index = after + quote.close.length;
+			continue;
+		}
+		index += 1;
+	}
+}
+/**
+* Returns what in `text` could end or extend the statement a migration writes it into, such as the
+* conversion of an `ALTER COLUMN … USING` clause or a column of an `INSERT … SELECT` list, or
+* undefined when it finds nothing. Text inside the quotes of `quoting` may hold anything; outside
+* them the text may not hold a semicolon, a SQL comment, dollar quoting, or, outside parentheses
+* and brackets, a comma or a keyword that would end the expression. `FROM` directly after
+* `DISTINCT`, as in `IS DISTINCT FROM`, belongs to the expression. It checks for these mistakes
+* only; it does not parse the SQL.
+*/
+function checkSqlExpressionText(text, quoting) {
+	let depth = 0;
+	let index = 0;
+	let previousWord;
+	while (index < text.length) {
+		const character = text[index] ?? "";
+		const quote = quoteAt(text, index, quoting);
+		if (quote !== void 0) {
+			const end = endOfQuote(text, index, quote);
+			if (end === void 0) return "a quote that is not closed";
+			index = end;
+			previousWord = void 0;
+			continue;
+		}
+		if (character === ";") return "a semicolon outside a quoted literal";
+		if (text.startsWith("--", index) || text.startsWith("/*", index)) return "a SQL comment";
+		DOLLAR_QUOTE.lastIndex = index;
+		if (character === "$" && DOLLAR_QUOTE.test(text)) return "dollar quoting";
+		if (character === "," && depth === 0) return "a comma outside parentheses";
+		if (character === "(" || character === "[") depth += 1;
+		if (character === ")" || character === "]") {
+			depth -= 1;
+			if (depth < 0) return "parentheses that do not match";
+		}
+		WORD.lastIndex = index;
+		const word = /[A-Za-z_]/.test(character) ? WORD.exec(text)?.[0].toUpperCase() : void 0;
+		if (word !== void 0) {
+			if (depth === 0 && STATEMENT_KEYWORDS.has(word) && !(word === "FROM" && previousWord === "DISTINCT")) return `the keyword ${word} outside parentheses`;
+			previousWord = word;
+			index += word.length;
+			continue;
+		}
+		if (!/\s/.test(character)) previousWord = void 0;
+		index += 1;
+	}
+	return depth === 0 ? void 0 : "parentheses that do not match";
+}
+/** Whether `slot` is a placeholder the user has not filled yet. */
+function isUnfilledSlot(slot) {
+	return slot?.kind === "placeholder";
+}
+/** The SQL of a written slot; undefined for an unfilled one or none. */
+function sqlOfSlot(slot) {
+	return slot?.kind === "sql" ? slot.sql : void 0;
+}
+/** The slot as `migration.ts` writes it: SQL text written through `sql`, or a `placeholder(...)` call. */
+function slotSource(slot, sql) {
+	return slot.kind === "placeholder" ? `placeholder(${jsonToTsSource(slot.slot)})` : sql.source(slot.sql);
+}
+/** `moduleSpecifier` is the module the generated file imports `sql` from. */
+function createSqlTextSources(moduleSpecifier) {
+	let usesTag = false;
+	return {
+		source(text) {
+			const written = tsTaggedTemplateSource("sql", text);
+			usesTag ||= written.usesTag;
+			return written.source;
+		},
+		imports() {
+			return usesTag ? [{
+				moduleSpecifier,
+				symbol: "sql"
+			}] : [];
+		}
+	};
+}
+/** The codecs and data types a set of composed components registers. */
+function sqlTypeLookupsOf(frameworkComponents) {
+	return {
+		codecLookup: extractCodecLookup(frameworkComponents),
+		dataTypeLookup: assembleDataTypes(frameworkComponents).lookup
+	};
+}
+const TABLE_NAME_CASE_CHANGED_CODE = "MIGRATION.TABLE_NAME_CASE_CHANGED";
+function lowerFirst(value) {
+	return value.charAt(0).toLowerCase() + value.slice(1);
+}
+function plannedTable(node, namespaceId) {
+	return {
+		namespaceId,
+		tableName: node.name
+	};
+}
+function renameNeedsNamespace(drop, dropped, contract, defaultNamespaceId) {
+	if (drop.namespaceId !== UNBOUND_NAMESPACE_ID && drop.namespaceId !== defaultNamespaceId) return true;
+	const declaredElsewhere = (namespaceId, tableName) => namespaceId !== drop.namespaceId && tableName === drop.tableName;
+	return dropped.some((other) => declaredElsewhere(other.namespaceId, other.tableName)) || Object.values(contract.storage.namespaces).some((namespace) => Object.keys(namespace.entries.table ?? {}).some((tableName) => declaredElsewhere(namespace.id, tableName)));
+}
+/**
+* Finds every (drop `X`, create `Y`) pair in the same namespace where `X` is
+* `Y` with its first letter lowered. That shape is the signature of a schema
+* upgraded across the release in which a model with no `@@map` stopped
+* lowering the first letter of its table name: planning it would drop the
+* user's table and recreate it empty. Columns are deliberately not compared,
+* so a user who also changed a field in the same upgrade is still protected.
+*
+* Returns one conflict per pair, carrying `MIGRATION.TABLE_NAME_CASE_CHANGED`
+* in `meta.code`, or an empty array when the plan has no such pair.
+*/
+function detectTableNameCaseChanges(input) {
+	const dropped = [];
+	const created = [];
+	for (const issue of input.issues) {
+		const outcome = issueOutcome(issue);
+		if (outcome === "not-equal") continue;
+		const table = input.tableOf(issue);
+		if (table === void 0) continue;
+		(outcome === "not-expected" ? dropped : created).push(plannedTable(table, input.namespaceIdOf(issue)));
+	}
+	const conflicts = [];
+	for (const create of created) {
+		const drop = dropped.find((candidate) => candidate.namespaceId === create.namespaceId && candidate.tableName === lowerFirst(create.tableName));
+		if (drop === void 0) continue;
+		const renameCall = input.renameTableCall({
+			namespaceId: renameNeedsNamespace(drop, dropped, input.contract, input.defaultNamespaceId) ? drop.namespaceId : void 0,
+			from: drop.tableName,
+			to: create.tableName
+		});
+		conflicts.push({
+			kind: "tableNameCaseChanged",
+			summary: `${TABLE_NAME_CASE_CHANGED_CODE}: table "${create.tableName}" would be created and table "${drop.tableName}" dropped. Prisma 8 changed the default table name: a model with no @@map now names its table verbatim, so model ${create.tableName} points at "${create.tableName}" instead of "${drop.tableName}".`,
+			why: `To keep table "${drop.tableName}" and its rows, add @@map("${drop.tableName}") to model ${create.tableName} (or run the add-model-map codemod over the schema) and plan again. To rename the table and keep its rows instead: in a project with migration history, make the rename its own schema change, create its migration with prisma migration new --from <hash of the migration the database is at>, and add ${renameCall} to the migration's operations, which renames the table and the objects named after it; in a project that uses db update, rename it by hand with ${input.renameByHandStatements({
+				namespaceId: create.namespaceId,
+				from: drop.tableName,
+				to: create.tableName
+			}).join("; ")}, then run db update again.`,
+			location: {
+				namespaceId: create.namespaceId,
+				entityKind: "table",
+				entityName: create.tableName
+			},
+			meta: {
+				code: TABLE_NAME_CASE_CHANGED_CODE,
+				droppedTable: drop.tableName,
+				createdTable: create.tableName
+			}
+		});
+	}
+	return conflicts;
+}
+/**
+* Whether a required column the plan adds to a table with rows may take one temporary value in
+* every row. Not when it is in the primary key, a unique constraint or a foreign key, which one
+* value in every row would break, and not when its values come from a value set, since no one value
+* stands for every member. Such a column is added for an empty table only.
+*/
+function columnTakesTemporaryValue(table, column) {
+	return table.columns[column]?.valueSet === void 0 && !(table.primaryKey?.columns.includes(column) ?? false) && !table.uniques.some(({ columns }) => columns.includes(column)) && !table.foreignKeys.some(({ source }) => source.columns.includes(column));
+}
+const ConvertedColumnMeta = type({ convertedColumn: {
+	table: "string",
+	column: "string",
+	by: "'cast' | 'conversion'"
+} });
+/**
+* The meta of a step that converts the values of `column` in `table` to the column's new type, or
+* checks that it did. When the step fails, the runner names the field that stores the column.
+*/
+function convertedColumnMeta(table, column, by) {
+	return { convertedColumn: {
+		table,
+		column,
+		by
+	} };
+}
+/** The column a step converts to its new type, as {@link convertedColumnMeta} marks it. */
+function convertedColumnOf(step) {
+	const meta = ConvertedColumnMeta(step.meta ?? {});
+	return meta instanceof type.errors ? void 0 : meta.convertedColumn;
+}
+/**
+* The field of `contract` whose column a failed step converts, or undefined when the step
+* converts no column, no field stores the column, or tables of two storage namespaces share its name.
+*/
+function unconvertedFieldOf(step, contract) {
+	const converted = convertedColumnOf(step);
+	return converted === void 0 ? void 0 : fieldOfColumn(contract, converted.table, converted.column);
+}
+/** Reads a reported literal default with the column's codec. `raw` is the reported text, which a refusal quotes. */
+async function readReportedDefault(codec, literal, raw) {
+	const unreadable = (error, element) => {
+		if (isInternalError(error)) throw error;
+		const reason = error instanceof Error ? error.message : String(error);
+		return { defaultUnreadable: `The column codec ${codec.id} cannot read ${element}the default the database reports, ${raw}: ${reason}` };
+	};
+	if (literal.kind === "value") try {
+		const value = await readBody(codec, literal.body);
+		return {
+			resolvedDefault: {
+				kind: "literal",
+				value: codec.dataType.toContract(value)
+			},
+			defaultValue: value
+		};
+	} catch (error) {
+		return unreadable(error, "");
+	}
+	const values = [];
+	for (const [index, body] of literal.elements.entries()) try {
+		values.push(body === null ? null : await readBody(codec, body));
+	} catch (error) {
+		return unreadable(error, `element ${index + 1} of `);
+	}
+	return {
+		resolvedDefault: {
+			kind: "literal",
+			value: values.map((value) => value === null ? null : codec.dataType.toContract(value))
+		},
+		defaultValue: values
+	};
+}
+/**
+* Reads a reported literal default with the column's codec, and, when the contract's default is an expression that writes a literal, that literal too, so the diff compares the two as values.
+*/
+async function readColumnDefault(codec, reported, written) {
+	const read = await readReportedDefault(codec, reported.literal, reported.raw);
+	if (written === void 0 || !("defaultValue" in read)) return read;
+	const writtenRead = await readReportedDefault(codec, written.literal, written.expression);
+	return "defaultValue" in writtenRead ? {
+		...read,
+		defaultExpressionValue: writtenRead.defaultValue
+	} : read;
+}
+async function readBody(codec, body) {
+	return codec.toDataTypeValue(await codec.fromWire(body, {}));
+}
+function isLoose(value) {
+	return typeof value === "object" && value !== null;
+}
+function child(value, key) {
+	if (!isLoose(value)) return void 0;
+	const found = value[key];
+	return isLoose(found) ? found : void 0;
+}
+/**
+* The columns `contract` declares. `contract` is a contract, or the namespaces of several contract spaces merged with each space's contract under `contracts`, as multi-space introspection receives them.
+*/
+function contractColumns(contract) {
+	const contracts = isLoose(contract) && Array.isArray(contract["contracts"]) ? contract["contracts"] : [contract];
+	return { columnOf(namespaceIds, table, column) {
+		for (const space of contracts) {
+			const namespaces = child(child(space, "storage"), "namespaces");
+			if (namespaces === void 0) continue;
+			for (const id of namespaceIds ?? Object.keys(namespaces)) {
+				const found = child(child(child(child(child(child(namespaces, id), "entries"), "table"), table), "columns"), column);
+				const codecId = found?.["codecId"];
+				if (found === void 0 || typeof codecId !== "string") continue;
+				const columnDefault = child(found, "default");
+				const expression = columnDefault?.["expression"];
+				return {
+					codecRef: columnCodecRef(codecId, found),
+					defaultExpression: columnDefault?.["kind"] === "function" && typeof expression === "string" ? expression : void 0
+				};
+			}
+		}
+	} };
+}
+function columnCodecRef(codecId, column) {
+	const params = nonEmptyTypeParams(child(column, "typeParams"));
+	const many = column["many"];
+	return {
+		codecId,
+		...ifDefined("typeParams", params === void 0 ? void 0 : blindCast(params)),
+		...ifDefined("many", many !== void 0 && many !== false ? true : void 0)
+	};
+}
+var control_default = new SqlFamilyDescriptor();
+//#endregion
+export { unmatchedColumnRename as $, planFieldEventOperations as A, resolveTableRenameAgainst as B, fieldStatementColumns as C, partitionCallsByControlPolicy as D, otherSpaceDeclaring as E, readReportedDefault as F, slotSource as G, rowsWithoutValueSummary as H, requiredColumnMeta as I, sqlTypeLookupsOf as J, sqlDefaultFunctions as K, requiredColumnOf as L, plannerFailure as M, plannerSuccess as N, partitionIssuesByControlPolicy as O, readColumnDefault as P, unknownCallNames as Q, requiredColumnsOfMigration as R, fieldRenameStorageEffect as S, modelRenameStorageEffect as T, runnerFailure as U, rowsWithoutValueFailure as V, runnerSuccess as W, subjectsOfCalls as X, storageNameOfOperation as Y, unconvertedFieldOf as Z, createSqlTextSources as _, appliedStatementsInOrder as a, fieldEventStorage as b, checkSqlExpressionText as c, contractNamespaceToSchemaIR as d, unmatchedTableRename as et, contractToSchemaIR as f, createMigrationPlan as g, convertedColumnOf as h, TABLE_NAME_CASE_CHANGED_CODE as i, planStatements as j, planFieldEventCalls as k, columnTakesTemporaryValue as l, convertedColumnMeta as m, INIT_ADDITIVE_POLICY as n, assembleAuthoringContributions$1 as o, control_default as p, sqlOfSlot as q, NO_RENAMED_ORIGINS as r, backfillOfDefaultedField as s, COLUMN_RENAME_UNMATCHED_CODE as t, contractColumns as u, detectDestructiveChanges as v, isUnfilledSlot as w, fieldOfColumn as x, detectTableNameCaseChanges as y, resolveColumnRenameAgainst as z };
+
+//# sourceMappingURL=control-BK50zF6c.mjs.map