@prisma/orm-family-sql 8.0.0-rc.18-dev.16 → 8.0.0-rc.18-dev.17

package/dist/{control-DXqMl_gd.mjs → control-ClahTAD-.mjs}

@@ -1,27 +1,27 @@
-import { u as namingOf } from "./naming-CT8tRisJ-DLHKo0Hm.mjs";
+import { u as namingOf } from "./naming-bM5qm5PY-DdginUhA.mjs";
 import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-dmXkOR4a.mjs";
-import { a as renderSqlTypeName, d as unquotedSqlBaseName, t as dataTypeParams, u as sqlDataTypeOfCodec } from "./data-type-DU0mtme5.mjs";
-import { c as StorageTable } from "./storage-table-DN36E2yE-Bm5eKeGw.mjs";
-import { c as SqlSchemaIR, n as RelationalSchemaNodeKind, u as SqlTableIR } from "./types-DvhckjSz-Cm0Oodhr.mjs";
-import { p as sqlExpressionRegistration } from "./sql-expression-DSRILiU2.mjs";
-import { u as isStorageTypeInstance } from "./types-GS3fwvoX.mjs";
-import { g as valueObjectStorageTypeMissingMessage } from "./validators-DlpO67uZ.mjs";
-import { a as describeUnsupportedSqlAttribute, v as sqlAttributeSpecs } from "./psl-field-resolution-SPNDr-jr-CH_gs3Oy.mjs";
+import { d as sqlStorageTypeId, h as validateSqlTypeParams, i as renderSqlTypeName, l as sqlDataTypeOfCodec, n as isSqlDataType, p as unquotedSqlBaseName, u as sqlStorageType } from "./sql-data-type-Dabuwxet-BljsNjBu.mjs";
+import { c as StorageTable } from "./storage-table-DN36E2yE-0ncS821l.mjs";
+import { c as SqlSchemaIR, n as RelationalSchemaNodeKind, u as SqlTableIR } from "./types-CaVn_xxe-D9WdU3Iy.mjs";
+import { f as sqlExpressionRegistration } from "./sql-expression-BJCuy-WI.mjs";
+import { d as resolvedTypeParams, u as isStorageTypeInstance } from "./types-M_FeBD9w.mjs";
+import { g as valueObjectStorageTypeMissingMessage } from "./validators-Bvfk0aN7.mjs";
+import { a as describeUnsupportedSqlAttribute, v as sqlAttributeSpecs } from "./psl-field-resolution-o9sXqIlE-BJnlxQ4z.mjs";
 import { t as describeUnresolvedSqlType } from "./diagnostics-C8YevjSU.mjs";
-import { t as sqlEmission } from "./dist-Cg2lL1hR.mjs";
-import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringTypes, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringFieldPresets } from "./authoring-type-constructors-0Iv2zdwS-yMnSyGBK.mjs";
-import { c as verifySqlSchemaByDiff, n as classifyDiffSubjectGranularity, o as enforceSqlDataTypeInvariants, t as classifyDiffEntityKind } from "./schema-verify-DIfHSB4I-wt28gB9e.mjs";
+import { t as sqlEmission } from "./dist-DAHIT4AS.mjs";
+import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringTypes, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringFieldPresets } from "./authoring-type-constructors-0Iv2zdwS-MFIpJ4fA.mjs";
+import { c as verifySqlSchemaByDiff, n as classifyDiffSubjectGranularity, o as enforceSqlDataTypeInvariants, t as classifyDiffEntityKind } from "./schema-verify-BwRdzbHb-B9vFrm3T.mjs";
 import { t as sqlFamilyError } from "./errors-B5g0xWro-mWH2C07F.mjs";
-import { t as SqlContractSerializer } from "./sql-contract-serializer-DDaAVCQr-Ba3XOCG6.mjs";
+import { t as SqlContractSerializer } from "./sql-contract-serializer-sMY3prTx-C8IEwSsf.mjs";
 import { t as collectSupportedCodecTypeIds } from "./verify-BVk5bjdH-dq5M4iIh.mjs";
 import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG, TIMESTAMP_NOW_GENERATOR_ID, collectScalarTypeConstructors, temporalAuthoringPresets, temporalPhaseTemplate, 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, canonicalFormOf } from "@prisma/orm-framework/components/codec";
+import { assembleDataTypes, codecForRef, dataTypeParams } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
 import { type } from "arktype";
 import { asNamespaceId, effectiveControlPolicy } from "@prisma/orm-framework/contract/types";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
@@ -52,6 +52,75 @@ function dataTypeProblems(storage, codecLookup) {
 		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, resolvedTypeParams(column, storage.types));
+		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;
@@ -73,11 +142,16 @@ function valueObjectProblems(contract, authoring) {
 	}));
 }
 /**
-* Checks a deserialized contract against the stack that loads it: each column's codec represents the data type the column names, and each value-object column uses the codec of the stack's value-object storage type.
+* 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 problems = [...dataTypeProblems(contract.storage, stack.codecLookup), ...valueObjectProblems(contract, stack.authoringContributions)];
-	if (problems.length > 0) throw new ContractValidationError(problems.join("; "), "storage");
+	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;
@@ -542,7 +616,7 @@ function createSqlFamilyInstance(stack) {
 		async introspect(options) {
 			return getControlAdapter().introspect(options.driver, options.contract);
 		},
-		inferPslContract(schemaIR) {
+		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.",
@@ -694,37 +768,67 @@ var SqlFamilyDescriptor = class {
 		return createSqlFamilyInstance(stack);
 	}
 };
-function convertColumn(name, column, storageTypes, types, renderDefault, resolveDefault) {
+function convertColumn(name, column, storageTypes, types, hooks) {
 	const resolved = resolveColumnTypeMetadata(column, storageTypes);
 	const dataType = sqlDataTypeOfCodec(resolved.codecId, types);
-	const codec = types.codecLookup.descriptorFor(resolved.codecId);
-	const baseTypeName = unquotedSqlBaseName(dataType, dataTypeParams(dataType, resolved.typeParams));
-	const baseNativeType = schemaTypeText(dataType, resolved.typeParams);
+	const storage = sqlStorageType(dataType, types.dataTypeLookup);
+	const baseTypeName = unquotedSqlBaseName(storage, dataTypeParams(storage, resolved.typeParams));
+	const baseNativeType = schemaTypeText(storage, resolved.typeParams);
 	const nativeType = baseNativeType;
 	const many = column.many !== void 0 && column.many !== false;
 	const resolvedNativeType = many ? `${baseNativeType}[]` : baseNativeType;
 	const rawColumnDefault = column.default ?? void 0;
-	const resolvedColumnDefault = rawColumnDefault !== void 0 && resolveDefault ? resolveDefault(rawColumnDefault, resolvedNativeType) : rawColumnDefault;
+	const resolvedColumnDefault = rawColumnDefault !== void 0 && hooks.resolveDefault ? hooks.resolveDefault(rawColumnDefault, resolvedNativeType) : rawColumnDefault;
 	return {
 		name,
 		nativeType,
 		nullable: column.nullable,
 		...ifDefined("many", many ? true : void 0),
-		...ifDefined("default", column.default != null && renderDefault ? renderDefault(column.default, column, {
-			dataType: dataType.id,
-			baseTypeName
-		}) : void 0),
 		resolvedNativeType,
 		...ifDefined("resolvedDefault", resolvedColumnDefault),
 		...ifDefined("authoredDefault", rawColumnDefault),
 		codecRef: buildColumnCodecRef(resolved, many ? true : void 0),
 		codecBaseNativeType: baseTypeName,
 		dataType,
-		...ifDefined("toCanonicalForm", codec && canonicalFormOf(codec, types.dataTypeLookup))
+		...ifDefined("defaultValue", rawColumnDefault?.kind === "literal" && rawColumnDefault.value instanceof Date ? dateDefaultValue(rawColumnDefault.value, codecForRef(types.codecLookup, buildColumnCodecRef(resolved, void 0))) : contractDefaultValue(rawColumnDefault, dataType, dataTypeParams(dataType, resolved.typeParams), many))
 	};
 }
 /**
-* The column's type as the database reports it: the written name with its normal-form parameters (`character(1)` for a bare `character`), or for a
+* 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) {
@@ -874,9 +978,9 @@ function withColumnInErrors(table, column, build) {
 		});
 	}
 }
-function convertTable(name, table, storageTypes, types, renderDefault, resolveDefault, storage) {
+function convertTable(name, table, storageTypes, types, hooks, storage) {
 	const columns = {};
-	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = withColumnInErrors(name, colName, () => convertColumn(colName, colDef, storageTypes, types, renderDefault, resolveDefault));
+	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = withColumnInErrors(name, colName, () => convertColumn(colName, colDef, storageTypes, 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,
@@ -958,7 +1062,7 @@ function contractNamespaceToSchemaIR(storage, namespaceId, options) {
 	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, storageTypes, options, options.renderDefault, options.resolveDefault, storage);
+		tables[tableName] = convertTable(tableName, tableDefRaw, storageTypes, options, options, storage);
 	}
 	return new SqlSchemaIR({ tables });
 }
@@ -993,7 +1097,7 @@ function contractToSchemaIR(contract, options) {
 			fix: "Rename one of the tables so every table name is unique across namespaces.",
 			meta: { table: tableName }
 		});
-		tables[tableName] = convertTable(tableName, tableDef, storageTypes, options, options.renderDefault, options.resolveDefault, storage);
+		tables[tableName] = convertTable(tableName, tableDef, storageTypes, options, options, storage);
 	}
 	return new SqlSchemaIR({ tables });
 }
@@ -1176,7 +1280,7 @@ function planFieldEventCalls(options) {
 				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)) altered.push(entry);
+					if (isAlteration(priorField, newField, options.dataTypes)) altered.push(entry);
 				}
 			}
 		}
@@ -1252,13 +1356,13 @@ function buildContext(event, entry) {
 * For non-`codecId` diffs, returns `true` iff any other column property
 * differs.
 */
-function isAlteration(prior, current) {
+function isAlteration(prior, current, dataTypes) {
 	if (prior.codecId !== current.codecId) return false;
-	return !sameStorageColumn(prior, current);
+	return !sameStorageColumn(prior, current, dataTypes);
 }
-function sameStorageColumn(a, b) {
+function sameStorageColumn(a, b, dataTypes) {
 	if (a === b) return true;
-	if (a.dataType !== b.dataType) return false;
+	if (sqlStorageTypeId(a.dataType, dataTypes) !== sqlStorageTypeId(b.dataType, dataTypes)) return false;
 	if (a.nullable !== b.nullable) return false;
 	if (a.typeRef !== b.typeRef) return false;
 	if (!sameJson(a.typeParams, b.typeParams)) return false;
@@ -2378,6 +2482,108 @@ 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; a table's named types are then those of the space that declares it.
+*/
+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 storage = child(space, "storage");
+			const namespaces = child(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, child(storage, "types")),
+					defaultExpression: columnDefault?.["kind"] === "function" && typeof expression === "string" ? expression : void 0
+				};
+			}
+		}
+	} };
+}
+function columnCodecRef(codecId, column, namedTypes) {
+	const typeRef = column["typeRef"];
+	const typeParams = column["typeParams"];
+	const params = resolvedTypeParams({
+		typeParams: isLoose(typeParams) ? typeParams : void 0,
+		typeRef: typeof typeRef === "string" ? typeRef : void 0
+	}, namedTypesOf(namedTypes));
+	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)
+	};
+}
+function namedTypesOf(namedTypes) {
+	const result = {};
+	for (const [name, entry] of Object.entries(namedTypes ?? {})) {
+		const typeParams = child(entry, "typeParams");
+		result[name] = typeParams === void 0 ? {} : { typeParams };
+	}
+	return result;
+}
 function temporalStringAuthoringPresets(input) {
 	const presets = temporalAuthoringPresets(input);
 	return {
@@ -2425,6 +2631,6 @@ function temporalCodecPresetWithPrecision(input) {
 }
 var control_default = new SqlFamilyDescriptor();
 //#endregion
-export { plannerFailure as A, runnerSuccess as B, isUnfilledSlot as C, planFieldEventCalls as D, partitionIssuesByControlPolicy as E, resolveColumnRenameAgainst as F, subjectsOfCalls as G, sqlOfSlot as H, resolveTableRenameAgainst as I, unconvertedFieldOf as J, temporalCodecPresetWithPrecision as K, rowsWithoutValueFailure as L, requiredColumnMeta as M, requiredColumnOf as N, planFieldEventOperations as O, requiredColumnsOfMigration as P, rowsWithoutValueSummary as R, fieldStatementColumns as S, partitionCallsByControlPolicy as T, sqlTypeLookupsOf as U, slotSource as V, storageNameOfOperation as W, unmatchedColumnRename as X, unknownCallNames as Y, unmatchedTableRename as Z, detectDestructiveChanges as _, assembleAuthoringContributions as a, fieldOfColumn as b, columnTakesTemporaryValue as c, controlPolicyForCall as d, control_default as f, createSqlTextSources as g, createMigrationPlan as h, appliedStatementsInOrder as i, plannerSuccess as j, planStatements as k, contractNamespaceToSchemaIR as l, convertedColumnOf as m, INIT_ADDITIVE_POLICY as n, backfillOfDefaultedField as o, convertedColumnMeta as p, temporalStringAuthoringPresets as q, TABLE_NAME_CASE_CHANGED_CODE as r, checkSqlExpressionText as s, COLUMN_RENAME_UNMATCHED_CODE as t, contractToSchemaIR as u, detectTableNameCaseChanges as v, modelRenameStorageEffect as w, fieldRenameStorageEffect as x, fieldEventStorage as y, runnerFailure as z };
+export { unmatchedColumnRename as $, planStatements as A, rowsWithoutValueFailure as B, fieldStatementColumns as C, partitionIssuesByControlPolicy as D, partitionCallsByControlPolicy as E, requiredColumnMeta as F, sqlOfSlot as G, runnerFailure as H, requiredColumnOf as I, subjectsOfCalls as J, sqlTypeLookupsOf as K, requiredColumnsOfMigration as L, plannerSuccess as M, readColumnDefault as N, planFieldEventCalls as O, readReportedDefault as P, unknownCallNames as Q, resolveColumnRenameAgainst as R, fieldRenameStorageEffect as S, modelRenameStorageEffect as T, runnerSuccess as U, rowsWithoutValueSummary as V, slotSource as W, temporalStringAuthoringPresets as X, temporalCodecPresetWithPrecision as Y, unconvertedFieldOf as Z, createSqlTextSources as _, assembleAuthoringContributions as a, fieldEventStorage as b, columnTakesTemporaryValue as c, contractToSchemaIR as d, unmatchedTableRename as et, controlPolicyForCall as f, createMigrationPlan as g, convertedColumnOf as h, appliedStatementsInOrder as i, plannerFailure as j, planFieldEventOperations as k, contractColumns as l, convertedColumnMeta as m, INIT_ADDITIVE_POLICY as n, backfillOfDefaultedField as o, control_default as p, storageNameOfOperation as q, TABLE_NAME_CASE_CHANGED_CODE as r, checkSqlExpressionText as s, COLUMN_RENAME_UNMATCHED_CODE as t, contractNamespaceToSchemaIR as u, detectDestructiveChanges as v, isUnfilledSlot as w, fieldOfColumn as x, detectTableNameCaseChanges as y, resolveTableRenameAgainst as z };
 
-//# sourceMappingURL=control-DXqMl_gd.mjs.map
+//# sourceMappingURL=control-ClahTAD-.mjs.map