@prisma/orm-family-sql 8.0.0-rc.19-dev.3 → 8.0.0-rc.19-dev.5

package/dist/{control-B_FwQQXi.mjs → control-Cih61sJa.mjs}

@@ -1614,6 +1614,11 @@ function fieldRenameStorageEffect(statement, fromContract, contract) {
 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) {
@@ -1638,6 +1643,19 @@ function tableControlPolicy(contract, table) {
 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}`, {
@@ -1682,8 +1700,15 @@ var StatementPlanner = class {
 	#contract;
 	#policy;
 	#target;
-	/** The name each table renamed so far has in the working schema, keyed by its origin name. */
+	/** 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;
@@ -1694,10 +1719,55 @@ var StatementPlanner = class {
 		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) {
-		return statement.entity === "model" ? this.#planModel(statement) : this.#planField(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);
@@ -1718,8 +1788,25 @@ var StatementPlanner = class {
 		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([]);
-		if (effect.kind === "moveNamespace") return notOk(statementRefused(statement, `Moving a model to another namespace is not supported in this release: "${modelDisplayName(statement.from)}" to "${modelDisplayName(statement.to)}"`, `The model's table would move from namespace "${effect.from.namespaceId}" to namespace "${effect.to.namespaceId}". Leave out this statement and move the table yourself in a hand-written migration, or keep the model in namespace "${effect.from.namespaceId}".`, effect.from));
-		const { rename } = effect;
+		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
@@ -1732,37 +1819,86 @@ var StatementPlanner = class {
 		const planned = this.#emit(statement, label, destinationTable, this.#target.renameTableCall(rename));
 		if (planned.ok) {
 			this.tableRenames.push(rename);
-			this.#renamedTables.set(tableKey({
-				namespaceId: rename.namespaceId,
-				table: rename.from
-			}), rename.to);
+			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 table = this.#renamedTables.get(tableKey(effect.table)) ?? effect.table.table;
+		const current = this.#current(effect.table);
+		const table = current.table;
 		const destinationTable = modelTable(this.#contract, statement.to);
-		if (destinationTable !== void 0 && (destinationTable.namespaceId !== effect.table.namespaceId || destinationTable.table !== table)) {
+		if (destinationTable !== void 0 && (destinationTable.namespaceId !== current.namespaceId || destinationTable.table !== table)) {
 			const tableRename = {
-				namespaceId: effect.table.namespaceId,
+				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: effect.table.namespaceId,
+				namespaceId: current.namespaceId,
 				table,
 				column: effect.from
 			}));
 		}
 		const rename = {
-			namespaceId: effect.table.namespaceId,
+			namespaceId: current.namespaceId,
 			table,
 			from: effect.from,
 			to: effect.to
@@ -1780,14 +1916,38 @@ var StatementPlanner = class {
 			...tableLocation,
 			column: rename.from
 		}, this.#target.renameColumnCall(rename));
-		if (planned.ok) this.columnRenames.push(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 in order against a target's working schema: 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
+* 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) {
@@ -1797,15 +1957,18 @@ function planStatements(input) {
 		calls: [],
 		tableRenames: [],
 		columnRenames: [],
-		appliedStatements: []
+		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
+		fromContract,
+		ownership: input.ownership
 	});
 	const appliedStatements = [];
-	for (const statement of input.statements) {
+	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({
@@ -1817,7 +1980,8 @@ function planStatements(input) {
 		calls: planner.calls,
 		tableRenames: planner.tableRenames,
 		columnRenames: planner.columnRenames,
-		appliedStatements
+		appliedStatements,
+		origins: planner.origins()
 	});
 }
 /**
@@ -1927,26 +2091,6 @@ function unknownCallNames(calls) {
 		return [call, (counts.get(call.factoryName) ?? 0) > 1 ? `${call.factoryName}#${ordinal}` : call.factoryName];
 	}));
 }
-function originTable(context, namespaceId, table) {
-	for (const statement of context.statements) {
-		if (statement.kind !== "rename" || statement.entity !== "model") continue;
-		const effect = modelRenameStorageEffect(statement, context.fromContract, context.contract);
-		if (!effect.ok || effect.value.kind !== "renameTable") continue;
-		const { rename } = effect.value;
-		if (rename.namespaceId === namespaceId && rename.to === table) return rename.from;
-	}
-	return table;
-}
-function originColumn(context, namespaceId, table, column) {
-	for (const statement of context.statements) {
-		if (statement.kind !== "rename" || statement.entity !== "field") continue;
-		const effect = fieldRenameStorageEffect(statement, context.fromContract, context.contract);
-		if (!effect.ok || effect.value.kind !== "renameColumn") continue;
-		const rename = effect.value;
-		if (rename.table.namespaceId === namespaceId && rename.table.table === table && rename.to === column) return rename.from;
-	}
-	return column;
-}
 /** 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]) => {
@@ -1970,13 +2114,11 @@ function subjectOf(target, context) {
 	};
 	const { fromContract } = context;
 	if (target.table === void 0 || fromContract === null) return storage;
-	const withOrigin = {
-		...context,
-		fromContract
-	};
-	const { namespaceId } = target.table;
-	const table = originTable(withOrigin, namespaceId, target.table.table);
-	const models = modelsStoring(fromContract, namespaceId, table);
+	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 : {
@@ -1984,7 +2126,7 @@ function subjectOf(target, context) {
 			...model.coordinate
 		};
 	}
-	const column = originColumn(withOrigin, namespaceId, table, target.table.column);
+	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 {
@@ -2015,13 +2157,13 @@ function keepTableAdvice(target, subject, context) {
 	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 widens access, at its position in
+* 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 accessWidening = [];
+	const accessChanges = [];
 	const temporaryValues = [];
 	let operationIndex = 0;
 	for (const call of calls) {
@@ -2043,7 +2185,7 @@ function subjectsOfCalls(calls, context) {
 				...ifDefined("keepDataAdvice", keepTableAdvice(target, subject, context))
 			});
 		}
-		for (const target of call.accessWidening) accessWidening.push({
+		for (const target of call.accessChanges) accessChanges.push({
 			operationIndex,
 			subject: subjectOf(target, context),
 			widens: target.widens
@@ -2052,7 +2194,7 @@ function subjectsOfCalls(calls, context) {
 	}
 	return {
 		dataLoss,
-		accessWidening,
+		accessChanges,
 		temporaryValues
 	};
 }
@@ -2118,7 +2260,7 @@ function plannerSuccess(plan, appliedStatements, subjects, warnings) {
 		plan,
 		appliedStatements: Object.freeze([...appliedStatements]),
 		dataLoss: Object.freeze([...subjects.dataLoss]),
-		accessWidening: Object.freeze([...subjects.accessWidening]),
+		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,
@@ -2574,6 +2716,6 @@ function columnCodecRef(codecId, column) {
 }
 var control_default = new SqlFamilyDescriptor();
 //#endregion
-export { plannerFailure as A, rowsWithoutValueSummary as B, isUnfilledSlot as C, planFieldEventCalls as D, partitionIssuesByControlPolicy as E, requiredColumnOf as F, sqlOfSlot as G, runnerSuccess as H, requiredColumnsOfMigration as I, subjectsOfCalls as J, sqlTypeLookupsOf as K, resolveColumnRenameAgainst as L, readColumnDefault as M, readReportedDefault as N, planFieldEventOperations as O, requiredColumnMeta as P, unmatchedTableRename as Q, resolveTableRenameAgainst as R, fieldStatementColumns as S, partitionCallsByControlPolicy as T, slotSource as U, runnerFailure as V, sqlDefaultFunctions as W, unknownCallNames as X, unconvertedFieldOf as Y, unmatchedColumnRename as Z, detectDestructiveChanges as _, assembleAuthoringContributions$1 as a, fieldOfColumn as b, columnTakesTemporaryValue as c, contractToSchemaIR as d, control_default as f, createSqlTextSources as g, createMigrationPlan as h, appliedStatementsInOrder as i, plannerSuccess as j, planStatements as k, contractColumns as l, convertedColumnOf as m, INIT_ADDITIVE_POLICY as n, backfillOfDefaultedField as o, convertedColumnMeta as p, storageNameOfOperation as q, TABLE_NAME_CASE_CHANGED_CODE as r, checkSqlExpressionText as s, COLUMN_RENAME_UNMATCHED_CODE as t, contractNamespaceToSchemaIR as u, detectTableNameCaseChanges as v, modelRenameStorageEffect as w, fieldRenameStorageEffect as x, fieldEventStorage as y, rowsWithoutValueFailure as z };
+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-B_FwQQXi.mjs.map
+//# sourceMappingURL=control-Cih61sJa.mjs.map