@prisma/orm-family-sql 8.0.0-rc.20-dev.8 → 8.0.0-rc.20-dev.10

package/dist/{control-DQzNuCAM.mjs → control-D7N_L18S.mjs}

@@ -19,14 +19,14 @@ 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 { assembleDataTypes, codecForRef, dataTypeParams, objectSchemaKeys, readContractValue } 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 { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions as assembleAuthoringContributions$1, describeMigrationStatement, enumValueStatementText, 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
@@ -1319,152 +1319,6 @@ function partitionIssuesByControlPolicy(options) {
 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}`;
@@ -1797,6 +1651,7 @@ var StatementPlanner = class {
 			case "namespace": return this.#planNamespace(statement);
 			case "model": return this.#planModel(statement);
 			case "field": return this.#planField(statement);
+			case "enumValue": return ok([]);
 		}
 	}
 	/** Where a table of the origin is in the working schema, after the renames planned so far. */
@@ -2108,6 +1963,459 @@ function appliedStatementsInOrder(statements, renames) {
 		operationIndexes: []
 	});
 }
+function sameValue(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+function enumOf(contract, namespaceId, name) {
+	return contract.domain.namespaces[namespaceId]?.enum?.[name];
+}
+/** The columns of the destination whose fields the enum types, in managed tables. */
+function columnsTypedBy(contract, namespaceId, enumName) {
+	const found = /* @__PURE__ */ new Map();
+	for (const namespace of Object.values(contract.domain.namespaces)) for (const model of Object.values(namespace.models)) {
+		const { storage } = model;
+		if (!isSqlModelStorage(storage)) continue;
+		for (const [fieldName, field] of Object.entries(model.fields)) {
+			const ref = field.valueSet;
+			if (ref === void 0 || ref.plane !== "domain" || ref.entityKind !== "enum" || ref.spaceId !== void 0 || ref.namespaceId !== namespaceId || ref.entityName !== enumName) continue;
+			const column = storage.fields[fieldName]?.column;
+			if (column === void 0) continue;
+			const stored = contract.storage.namespaces[storage.namespaceId]?.entries.table?.[storage.table]?.columns[column];
+			if (stored === void 0) continue;
+			const location = {
+				namespaceId: storage.namespaceId,
+				table: storage.table
+			};
+			if (tableControlPolicy(contract, location) !== "managed") continue;
+			found.set(JSON.stringify([
+				storage.namespaceId,
+				storage.table,
+				column
+			]), {
+				...location,
+				column,
+				codecRef: buildColumnCodecRef(stored, void 0),
+				many: stored.many !== false && stored.many !== void 0
+			});
+		}
+	}
+	return [...found.values()];
+}
+function isStoredEnumValue(value) {
+	return typeof value === "string" || typeof value === "number";
+}
+/** A stored value as messages write it: a number without quotes, as the enum's codec reads it. */
+function valueText(value, codec) {
+	const built = codecForRef(codec.codecs, codec.codecRef);
+	if (built === void 0) return JSON.stringify(value);
+	try {
+		const read = readContractValue(built, value, codec.codecRef.typeParams);
+		return typeof read === "number" || typeof read === "bigint" ? String(read) : JSON.stringify(value);
+	} catch {
+		return JSON.stringify(value);
+	}
+}
+function unsupportedValue(contract, value, stored) {
+	const text = enumValueStatementText(contract, value);
+	return {
+		kind: "unsupportedOperation",
+		summary: `Cannot rewrite enum value "${text}": its stored value ${JSON.stringify(stored)} is not a string or a number`,
+		why: `The plan rewrites the rows that hold a removed or renamed enum value, and it compares only string and number values. Rewrite the rows that hold enum value "${text}" yourself, then plan again.`
+	};
+}
+function stillStoredRefusal(statement, enums, stored, holder) {
+	const holderText = enumValueStatementText(enums.contract, {
+		...statement.to,
+		member: holder
+	});
+	const value = enums.text(stored);
+	return {
+		kind: "statementRefused",
+		summary: `Cannot rename enum value "${enumValueStatementText(enums.fromContract, statement.from)}" to "${enumValueStatementText(enums.contract, statement.to)}": the destination enum still stores ${value}, as enum value "${holderText}"`,
+		why: `A rename changes the stored value in every row that holds it, so the rows that hold ${value} for "${holderText}" would change too. Leave out this statement.`,
+		refusedStatement: statement
+	};
+}
+function mergingRefusal(statement, enums, from, to, holder) {
+	const holderText = enumValueStatementText(enums.fromContract, {
+		...statement.from,
+		member: holder
+	});
+	return {
+		kind: "statementRefused",
+		summary: `Cannot rename enum value "${enumValueStatementText(enums.fromContract, statement.from)}" to "${enumValueStatementText(enums.contract, statement.to)}": the origin enum already stores ${enums.text(to)}, as enum value "${holderText}"`,
+		why: `A rename changes ${enums.text(from)} to ${enums.text(to)} in every row that holds it, which merges its data with the data of "${holderText}". Leave out this statement. To merge them on purpose, plan the change with migration plan and write this.replaceStoredValue(...) in the migration.ts it writes.`,
+		refusedStatement: statement
+	};
+}
+function cycleRefusal(statement, cycle, enums) {
+	const moves = cycle.map(({ from, to }) => `${enums.text(from)} to ${enums.text(to ?? null)}`);
+	const listed = `${moves.slice(0, -1).join(", ")} and ${moves.at(-1)}`;
+	return {
+		kind: "statementRefused",
+		summary: `Cannot rename enum value "${enumValueStatementText(enums.fromContract, statement.from)}" to "${enumValueStatementText(enums.contract, statement.to)}": the renames move stored values in a cycle, ${listed}, and a rewrite of one would overwrite the other before it is read`,
+		why: "Leave out the renames in the cycle, and write the rewrites by hand in the migration.ts a plan without them writes: rewrite the first value to a value no member stores, then each other value, then that value to its new value, with this.replaceStoredValue({ table, column, from, to }) for each.",
+		refusedStatement: statement,
+		leaveOut: cycle.flatMap((change) => change.statement === void 0 ? [] : [change.statement])
+	};
+}
+/**
+* What changes for each member of the origin enum. A rename statement gives a member the stored
+* value of the member it names. A member the destination has under the same name takes that
+* member's stored value, even when another member had it before. A member the destination lacks is
+* kept when the destination still stores its value, under another name; otherwise its value is
+* removed.
+*/
+function valueChanges(enums, enumValueOf, statementOf) {
+	const changes = [];
+	for (const member of enums.originEnum.members) {
+		const enumValue = enumValueOf(member.name);
+		const statement = statementOf(member.name);
+		const named = statement?.to.member ?? member.name;
+		const target = enums.destinationEnum.members.find(({ name }) => name === named);
+		if (target !== void 0) {
+			if (!sameValue(target.value, member.value)) changes.push({
+				enumValue,
+				from: member.value,
+				to: target.value,
+				statement
+			});
+			continue;
+		}
+		if (statement !== void 0) continue;
+		if (enums.destinationEnum.members.some(({ value }) => sameValue(value, member.value))) continue;
+		changes.push({
+			enumValue,
+			from: member.value,
+			to: void 0,
+			statement: void 0
+		});
+	}
+	return changes;
+}
+/**
+* Orders the changes so each runs before the change that writes its old value: in a chain, the
+* last value moves first. A cycle has no such order; it comes out as the changes in it, from the
+* first change of the origin enum's order around.
+*/
+function orderChanges(changes) {
+	const bySource = new Map(changes.map((change) => [JSON.stringify(change.from), change]));
+	const placed = /* @__PURE__ */ new Set();
+	const groups = [];
+	for (const start of changes) {
+		if (placed.has(start)) continue;
+		const path = [];
+		let cycle = false;
+		for (let change = start; change !== void 0 && !placed.has(change); change = change.to === void 0 ? void 0 : bySource.get(JSON.stringify(change.to))) {
+			if (path.includes(change)) {
+				cycle = true;
+				break;
+			}
+			path.push(change);
+		}
+		for (const change of path) placed.add(change);
+		groups.push(cycle ? {
+			changes: path,
+			cycle
+		} : {
+			changes: [...path].reverse(),
+			cycle
+		});
+	}
+	return groups;
+}
+/** A value no member of either enum stores, of the kind of `value`: the next whole number, or a marked string. */
+function temporaryValue(value, taken) {
+	const numbers = taken.flatMap((stored) => {
+		const number = typeof stored === "string" ? Number(stored) : stored;
+		return typeof number === "number" && Number.isFinite(number) ? [number] : [];
+	});
+	const nextWholeNumber = numbers.length === 0 ? 0 : Math.floor(Math.max(...numbers)) + 1;
+	if (typeof value === "number") return nextWholeNumber;
+	if (/^-?\d+$/.test(value)) return String(nextWholeNumber);
+	let candidate = "prisma_swap";
+	while (taken.some((stored) => sameValue(stored, candidate))) candidate = `${candidate}_`;
+	return candidate;
+}
+/**
+* The rewrites of stored enum values a plan makes. Enums are compared by the stored value of each
+* member (see `valueChanges`). A changed value is rewritten in every column, in the working schema,
+* whose field the destination enum types: a rename statement replaces it, and any other change
+* removes it, which the plan asks about, with the replacements that would keep its data. Changes
+* that shift values along are ordered so none overwrites a value another still has to read; rename
+* statements that move values in a cycle are refused, and other changes in a cycle keep their data
+* through a temporary value. With no origin contract, nothing is known to have changed.
+*/
+function planEnumValueRewrites(input) {
+	const { fromContract, contract } = input;
+	if (fromContract === null) return ok([]);
+	const renamedNamespaces = /* @__PURE__ */ new Map();
+	const valueRenames = [];
+	for (const statement of input.statements) {
+		if (statement.kind !== "rename") continue;
+		if (statement.entity === "namespace") renamedNamespaces.set(statement.from, statement.to);
+		if (statement.entity === "enumValue") valueRenames.push(statement);
+	}
+	const rewrites = [];
+	for (const [originNamespace, namespace] of Object.entries(fromContract.domain.namespaces)) for (const [enumName, originEnum] of Object.entries(namespace.enum ?? {})) {
+		const namespaceId = renamedNamespaces.get(originNamespace) ?? originNamespace;
+		const destinationEnum = enumOf(contract, namespaceId, enumName);
+		if (destinationEnum === void 0) continue;
+		const codec = {
+			codecRef: { codecId: destinationEnum.codecId },
+			codecs: input.codecs
+		};
+		const enums = {
+			fromContract,
+			contract,
+			originEnum,
+			destinationEnum,
+			text: (value) => valueText(value, codec)
+		};
+		const changes = valueChanges(enums, (member) => ({
+			namespaceId: asNamespaceId(originNamespace),
+			enum: enumName,
+			member
+		}), (member) => valueRenames.find((rename) => rename.from.namespaceId === originNamespace && rename.from.enum === enumName && rename.from.member === member));
+		const checked = [];
+		for (const change of changes) {
+			const { from, to } = change;
+			if (!isStoredEnumValue(from)) return notOk(unsupportedValue(fromContract, change.enumValue, from));
+			if (to !== void 0 && !isStoredEnumValue(to)) return notOk(unsupportedValue(fromContract, change.enumValue, to));
+			checked.push({
+				...change,
+				from,
+				to
+			});
+		}
+		const changedFrom = (value) => checked.some(({ from }) => sameValue(from, value));
+		const changedTo = (value) => checked.some(({ to }) => to !== void 0 && sameValue(to, value));
+		const merging = (to) => originEnum.members.find(({ value }) => sameValue(value, to) && !changedFrom(value));
+		for (const { statement, from, to } of checked) {
+			if (statement === void 0 || to === void 0) continue;
+			const holder = destinationEnum.members.find(({ value }) => sameValue(value, from));
+			if (holder !== void 0 && !changedTo(from)) return notOk(stillStoredRefusal(statement, enums, from, holder.name));
+			const merged = merging(to);
+			if (merged !== void 0) return notOk(mergingRefusal(statement, enums, from, to, merged.name));
+		}
+		const columns = columnsTypedBy(contract, namespaceId, enumName).filter((column) => input.tables.hasColumn(column.namespaceId, column.table, column.column));
+		if (columns.length === 0) continue;
+		const taken = [...originEnum.members.map(({ value }) => value), ...destinationEnum.members.map(({ value }) => value)];
+		for (const group of orderChanges(checked)) {
+			const refused = group.cycle ? group.changes.find(({ statement }) => statement !== void 0)?.statement : void 0;
+			if (refused !== void 0) return notOk(cycleRefusal(refused, group.changes, enums));
+			for (const [change, keepData] of keptData(group, taken, merging)) for (const column of columns) rewrites.push({
+				enumValue: change.enumValue,
+				...column,
+				from: change.from,
+				to: change.statement === void 0 ? void 0 : change.to,
+				statement: change.statement,
+				keepData,
+				swapsValues: group.cycle
+			});
+		}
+	}
+	return ok(rewrites);
+}
+/**
+* Each change of a group, in the order it runs, with the replacements that keep the data of a
+* change the plan removes: its value replaced by its new value, unless another member of the
+* origin enum keeps that value, which would merge their data. In a cycle, the first value moves to
+* a temporary value, the rest move around, and the temporary value moves last.
+*/
+function keptData(group, taken, merging) {
+	const moved = ({ from, to }) => to === void 0 ? [] : [{
+		from,
+		to
+	}];
+	const [first, ...rest] = group.changes;
+	if (!group.cycle || first === void 0) return group.changes.map((change) => [change, change.statement === void 0 && change.to !== void 0 && merging(change.to) === void 0 ? moved(change) : void 0]);
+	const swap = temporaryValue(first.from, taken);
+	const reversed = [...rest].reverse();
+	return [[first, [{
+		from: first.from,
+		to: swap
+	}]], ...reversed.map((change, index) => [change, index === reversed.length - 1 ? [...moved(change), ...moved({
+		...first,
+		from: swap
+	})] : moved(change)])];
+}
+/**
+* The applied statements with each enum value rename given the operations its rewrites lowered
+* to, at their positions in the plan: the rewrites are ordered with the diff, not with the renames.
+*/
+function withEnumValueOperations(applied, operationIndexesOf) {
+	return applied.map(({ statement, operationIndexes }) => statement.kind === "rename" && statement.entity === "enumValue" ? {
+		statement,
+		operationIndexes: operationIndexesOf(statement)
+	} : {
+		statement,
+		operationIndexes
+	});
+}
+/**
+* The value the database stores for `value`, a stored value as the contract writes it: the column's
+* codec reads it as a value of its data type and writes it with `toWire`, as a literal default is
+* written. With no codec, or one the stack does not have, the value is used as written.
+*/
+async function encodeStoredValue(value, codec) {
+	if (codec === void 0) return value;
+	const built = codecForRef(codec.codecs, codec.codecRef);
+	if (built === void 0) return value;
+	const wire = await built.toWire(readContractValue(built, value, codec.codecRef.typeParams), {});
+	if (typeof wire === "string" || typeof wire === "number") return wire;
+	if (typeof wire === "bigint") return wire.toString();
+	throw structuredError("CONTRACT.ARGUMENT_INVALID", `Codec ${codec.codecRef.codecId} writes the stored value ${JSON.stringify(value)} as neither a string nor a number, which a migration cannot compare`, { meta: {
+		what: "stored value",
+		codecId: codec.codecRef.codecId
+	} });
+}
+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);
+}
 /**
 * 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.
@@ -2178,6 +2486,10 @@ function modelsStoring(contract, namespaceId, table) {
 	}));
 }
 function subjectOf(target, context) {
+	if (target.enumValue !== void 0) return {
+		kind: "enumValue",
+		...target.enumValue
+	};
 	const storage = {
 		kind: "storage",
 		name: target.storageName
@@ -2252,7 +2564,8 @@ function subjectsOfCalls(calls, context) {
 				subject,
 				loss: target.loss,
 				label: call.label,
-				...ifDefined("keepDataAdvice", keepTableAdvice(target, subject, context))
+				...ifDefined("keepDataAdvice", keepTableAdvice(target, subject, context)),
+				...ifDefined("keepDataEdit", target.keepDataEdit)
 			});
 		}
 		for (const target of call.accessChanges) accessChanges.push({
@@ -2352,6 +2665,7 @@ function plannerFailure(conflicts) {
 			...conflict.why ? { why: conflict.why } : {},
 			...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
 			...conflict.refusedStatement ? { refusedStatement: conflict.refusedStatement } : {},
+			...conflict.leaveOut ? { leaveOut: Object.freeze([...conflict.leaveOut]) } : {},
 			...conflict.refusedOperationClass ? { refusedOperationClass: conflict.refusedOperationClass } : {},
 			...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
 		})))
@@ -2474,6 +2788,50 @@ async function rowsWithoutValueFailure(input) {
 		};
 	}
 }
+const RowsHoldingValueMeta = type({ rowsHoldingValue: {
+	enumValue: {
+		"namespaceId?": "string",
+		enum: "string",
+		member: "string"
+	},
+	value: "string | number",
+	"codecRef?": {
+		codecId: "string",
+		"typeParams?": "unknown"
+	}
+} });
+/**
+* The meta of the check before a stored enum value is removed from a column: it fails while rows
+* hold the value in a column that takes no NULL, and the runner then counts those rows.
+*/
+function rowsHoldingValueMeta(mark) {
+	return { rowsHoldingValue: mark };
+}
+/** The enum value a check guards, as {@link rowsHoldingValueMeta} marks it. */
+function rowsHoldingValueOf(step) {
+	const meta = RowsHoldingValueMeta(step.meta ?? {});
+	if (meta instanceof type.errors) return void 0;
+	const { enumValue, value, codecRef } = meta.rowsHoldingValue;
+	return {
+		enumValue: {
+			...enumValue.namespaceId === void 0 ? {} : { namespaceId: asNamespaceId(enumValue.namespaceId) },
+			enum: enumValue.enum,
+			member: enumValue.member
+		},
+		value,
+		...codecRef === void 0 ? {} : { codecRef: codecRefOf(codecRef) }
+	};
+}
+function codecRefOf(codecRef) {
+	return codecRef.typeParams === void 0 ? { codecId: codecRef.codecId } : {
+		codecId: codecRef.codecId,
+		typeParams: blindCast(codecRef.typeParams)
+	};
+}
+/** What a runner failure says of the rows that hold a stored value a column cannot lose: the value as the database stores it. */
+function rowsHoldingValueSummary(table, column, storedValue, rows) {
+	return `${`${rows} ${rows === 1 ? "row" : "rows"} of "${table}"`} ${rows === 1 ? "holds" : "hold"} ${JSON.stringify(storedValue)} in column "${column}", which takes no NULL, so the value cannot be removed.`;
+}
 /** Keywords that end an expression and continue the statement around it. */
 const STATEMENT_KEYWORDS = /* @__PURE__ */ new Set([
 	"FROM",
@@ -2786,6 +3144,6 @@ function columnCodecRef(codecId, column) {
 }
 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 };
+export { sqlTypeLookupsOf as $, planEnumValueRewrites as A, requiredColumnsOfMigration as B, fieldRenameStorageEffect as C, otherSpaceDeclaring as D, modelRenameStorageEffect as E, plannerSuccess as F, rowsHoldingValueSummary as G, resolveTableRenameAgainst as H, readColumnDefault as I, runnerFailure as J, rowsWithoutValueFailure as K, readReportedDefault as L, planFieldEventOperations as M, planStatements as N, partitionCallsByControlPolicy as O, plannerFailure as P, sqlOfSlot as Q, requiredColumnMeta as R, fieldOfColumn as S, isUnfilledSlot as T, rowsHoldingValueMeta as U, resolveColumnRenameAgainst as V, rowsHoldingValueOf as W, slotSource as X, runnerSuccess as Y, sqlDefaultFunctions as Z, createSqlTextSources as _, appliedStatementsInOrder as a, unmatchedTableRename as at, encodeStoredValue as b, checkSqlExpressionText as c, contractNamespaceToSchemaIR as d, storageNameOfOperation as et, contractToSchemaIR as f, createMigrationPlan as g, convertedColumnOf as h, TABLE_NAME_CASE_CHANGED_CODE as i, unmatchedColumnRename as it, planFieldEventCalls as j, partitionIssuesByControlPolicy as k, columnTakesTemporaryValue as l, convertedColumnMeta as m, INIT_ADDITIVE_POLICY as n, unconvertedFieldOf as nt, assembleAuthoringContributions$1 as o, withEnumValueOperations as ot, control_default as p, rowsWithoutValueSummary as q, NO_RENAMED_ORIGINS as r, unknownCallNames as rt, backfillOfDefaultedField as s, COLUMN_RENAME_UNMATCHED_CODE as t, subjectsOfCalls as tt, contractColumns as u, detectDestructiveChanges as v, fieldStatementColumns as w, fieldEventStorage as x, detectTableNameCaseChanges as y, requiredColumnOf as z };
 
-//# sourceMappingURL=control-DQzNuCAM.mjs.map
+//# sourceMappingURL=control-D7N_L18S.mjs.map