@prisma/orm-target-mongo 8.0.0-rc.17-dev.27 → 8.0.0-rc.17-dev.29

package/dist/{control-B0JolOVp.mjs → control-BcqDWXwi.mjs}

@@ -1,19 +1,20 @@
-import { a as mongoTargetError } from "./codecs-I_SlLNTn-BsshuqIx.mjs";
-import { t as mongoTargetDescriptorMeta } from "./descriptor-meta-BtMd3yW0--oRvmHvL.mjs";
-import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-CgyFxFZT-D4wek2HG.mjs";
+import { t as mongoTargetError } from "./mongo-target-errors-Btf3ML1w-B5EMYbz1.mjs";
+import { t as mongoTargetDescriptorMeta } from "./descriptor-meta-BtglG_aY-DhbxL8Gw.mjs";
+import { a as dropCollection, c as renameField, d as unsetField, n as createCollection, o as dropIndex, r as createIndex, s as renameCollection, t as collMod, u as unrewritableFieldNameReason } from "./migration-factories-BmDfC5c5-BI-Wusuk.mjs";
 import { type } from "arktype";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { NamespaceBase, UNBOUND_NAMESPACE_ID, elementCoordinates, freezeNode, hydrateNamespaceEntities } from "@prisma/orm-framework/components/ir";
-import { APP_SPACE_ID, VERIFY_CODE_SCHEMA_FAILURE, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, describeMigrationStatement, issueOutcome } from "@prisma/orm-framework/components/control";
-import { CollModCommand, CreateCollectionCommand, CreateIndexCommand, DropCollectionCommand, DropIndexCommand, ListCollectionsCommand, ListIndexesCommand, MongoAndExpr, MongoExistsExpr, MongoFieldFilter, MongoNotExpr, MongoOrExpr } from "@prisma/orm-family-mongo/query-ast/control";
-import { canonicalizeSchemasForVerification, contractToMongoSchemaIR, diffMongoSchemas } from "@prisma/orm-family-mongo/family/control";
+import { APP_SPACE_ID, VERIFY_CODE_SCHEMA_FAILURE, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, describeMigrationStatement, issueOutcome, modelDisplayName } from "@prisma/orm-framework/components/control";
+import { CollModCommand, CreateCollectionCommand, CreateIndexCommand, DropCollectionCommand, DropIndexCommand, ListCollectionsCommand, ListIndexesCommand, MongoAndExpr, MongoExistsExpr, MongoFieldFilter, MongoNotExpr, MongoOrExpr, RenameCollectionCommand, isMongoDmlOperation } from "@prisma/orm-family-mongo/query-ast/control";
+import { AggregateCommand, MongoAddFieldsStage, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoMergeStage, MongoProjectStage, MongoSortStage, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, RawUpdateManyCommand, RawUpdateOneCommand } from "@prisma/orm-family-mongo/query-ast/execution";
+import { canonicalizeSchemasForVerification, contractToMongoSchemaIR, diffMongoSchemas, fieldRewriteOf } from "@prisma/orm-family-mongo/family/control";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
 import { MongoContractSerializerBase, MongoSchemaVerifierBase } from "@prisma/orm-family-mongo/family/ir";
 import { MongoStorage } from "@prisma/orm-family-mongo/contract";
 import { composeMongoEntityKinds } from "@prisma/orm-family-mongo/contract/entity-kinds";
-import { asNamespaceId } from "@prisma/orm-framework/contract/types";
-import { canonicalize, deepEqual } from "@prisma/orm-family-mongo/schema-ir";
+import { asNamespaceId, effectiveControlPolicy } from "@prisma/orm-framework/contract/types";
+import { MongoSchemaCollection, MongoSchemaIR, canonicalize, deepEqual } from "@prisma/orm-family-mongo/schema-ir";
 import { TsExpression, jsonToTsSource, renderImports } from "@prisma/orm-framework/ts-render";
 import { Migration } from "@prisma/orm-toolchain/migration-tools/migration";
 import { resolveRequirementSpecifiers } from "@prisma/orm-framework/components/emission";
@@ -21,7 +22,6 @@ import { detectScaffoldRuntime, shebangLineFor } from "@prisma/orm-toolchain/mig
 import { errorRunnerFailed } from "@prisma/orm-framework/errors/execution";
 import { verifyMongoSchema } from "@prisma/orm-family-mongo/family/schema-verify";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { AggregateCommand, MongoAddFieldsStage, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoMergeStage, MongoProjectStage, MongoSortStage, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, RawUpdateManyCommand, RawUpdateOneCommand } from "@prisma/orm-family-mongo/query-ast/execution";
 //#region ../../../3-mongo-target/1-mongo-target/dist/control.mjs
 /**
 * Mongo target `Namespace` concretion. In Mongo the "namespace" concept
@@ -252,6 +252,75 @@ var DropCollectionCall = class extends OpFactoryCallNode {
 		return `dropCollection(${jsonToTsSource(this.collection)})`;
 	}
 };
+var RenameCollectionCall = class extends OpFactoryCallNode {
+	factoryName = "renameCollection";
+	operationClass = "widening";
+	from;
+	to;
+	label;
+	constructor(from, to) {
+		super();
+		this.from = from;
+		this.to = to;
+		this.label = `Rename collection ${from} to ${to}`;
+		this.freeze();
+	}
+	toOp() {
+		return renameCollection(this.from, this.to);
+	}
+	renderTypeScript() {
+		return `renameCollection(${jsonToTsSource(this.from)}, ${jsonToTsSource(this.to)})`;
+	}
+};
+function renderFilterOption(filter) {
+	return filter === void 0 ? "" : `, ${jsonToTsSource({ filter })}`;
+}
+var RenameFieldCall = class extends OpFactoryCallNode {
+	factoryName = "renameField";
+	operationClass = "widening";
+	collection;
+	from;
+	to;
+	filter;
+	label;
+	constructor(collection, from, to, filter) {
+		super();
+		this.collection = collection;
+		this.from = from;
+		this.to = to;
+		this.filter = filter;
+		this.label = this.toOp().label;
+		this.freeze();
+	}
+	toOp() {
+		return renameField(this.collection, this.from, this.to, ifDefined("filter", this.filter));
+	}
+	renderTypeScript() {
+		return `renameField(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.from)}, ${jsonToTsSource(this.to)}${renderFilterOption(this.filter)})`;
+	}
+};
+var UnsetFieldCall = class extends OpFactoryCallNode {
+	factoryName = "unsetField";
+	operationClass = "destructive";
+	collection;
+	field;
+	filter;
+	label;
+	constructor(collection, field, filter) {
+		super();
+		this.collection = collection;
+		this.field = field;
+		this.filter = filter;
+		this.label = this.toOp().label;
+		this.freeze();
+	}
+	toOp() {
+		return unsetField(this.collection, this.field, ifDefined("filter", this.filter));
+	}
+	renderTypeScript() {
+		return `unsetField(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.field)}${renderFilterOption(this.filter)})`;
+	}
+};
 var CollModCall = class extends OpFactoryCallNode {
 	factoryName = "collMod";
 	collection;
@@ -309,6 +378,322 @@ function schemaCollectionToCreateCollectionOptions(coll) {
 		...ifDefined("changeStreamPreAndPostImages", opts?.changeStreamPreAndPostImages)
 	};
 }
+/** The collection a model stores its documents in; a model without `@@map` names it verbatim. */
+function collectionOf(contract, coordinate) {
+	const collection = contract?.domain.namespaces[coordinate.namespaceId]?.models[coordinate.model]?.storage["collection"];
+	return typeof collection === "string" ? collection : coordinate.model;
+}
+function modelAt(contract, coordinate) {
+	const namespace = contract.domain.namespaces[coordinate.namespaceId];
+	return namespace !== void 0 && Object.hasOwn(namespace.models, coordinate.model) ? namespace.models[coordinate.model] : void 0;
+}
+/**
+* The condition that selects a variant's documents in the collection it shares with its base: the
+* base's discriminator field holding the variant's value. A model that is not a variant has none.
+*/
+function variantFilter(contract, coordinate) {
+	const base = modelAt(contract, coordinate)?.base;
+	if (base === void 0) return void 0;
+	const baseModel = contract.domain.namespaces[base.namespace]?.models[base.model];
+	const field = baseModel?.discriminator?.field;
+	const value = baseModel?.variants?.[coordinate.model]?.value;
+	return field === void 0 || value === void 0 ? void 0 : { [field]: value };
+}
+function collectionControlPolicy(contract, collection) {
+	return effectiveControlPolicy(Object.values(contract.storage.namespaces).map((namespace) => namespace?.entries.collection?.[collection]).find((entry) => entry !== void 0)?.control, contract.defaultControlPolicy);
+}
+/** Why MongoDB would refuse a collection name, if it would. */
+function invalidCollectionNameReason(name) {
+	if (name === "") return "it is empty";
+	if (name.includes("$")) return "it contains \"$\"";
+	if (name.includes("\0")) return "it contains a null character";
+	if (name.startsWith("system.")) return "it starts with \"system.\", which MongoDB reserves";
+}
+function isEmbedRelation(relation) {
+	return !("on" in relation) && !("through" in relation);
+}
+function storedField(model, field) {
+	if (model === void 0) return { kind: "absent" };
+	if (Object.hasOwn(model.fields, field)) return { kind: "field" };
+	const relation = Object.hasOwn(model.relations, field) ? model.relations[field] : void 0;
+	if (relation === void 0) return { kind: "absent" };
+	return isEmbedRelation(relation) ? { kind: "embed" } : { kind: "reference" };
+}
+function refused(statement, label, reason, why) {
+	return {
+		kind: "statementRefused",
+		summary: `${label}: ${reason}`,
+		why,
+		refusedStatement: statement
+	};
+}
+const LEAVE_OUT = "Leave out this statement.";
+const TIME_SERIES_UPDATES = "MongoDB updates the documents of a time-series collection only through its metaField";
+/**
+* A removal the plan cannot carry out because its collection is a time-series collection, whose
+* documents MongoDB does not let an update change except through the metaField.
+*/
+function timeSeriesRemovalRefusals(removals, schema) {
+	return removals.filter((removal) => schema.collection(removal.call.collection)?.options?.timeseries !== void 0).map((removal) => ({
+		kind: "fieldRemovalRefused",
+		summary: `Cannot remove field ${JSON.stringify(removal.call.field)} from collection ${JSON.stringify(removal.call.collection)}: it is a time-series collection`,
+		why: `${TIME_SERIES_UPDATES}, so the field cannot be removed from the documents that hold it. Keep the field in the contract, as an optional field if new documents leave it out, then run this command again.`
+	}));
+}
+/**
+* Plans the rename each statement states, in order: a model statement whose collection changes renames the
+* collection in the schema the diff then starts from, and a field statement whose stored name
+* changes renames the field in the documents that hold it.
+*/
+function planStatements(input) {
+	let schema = input.schema;
+	const collectionRenames = [];
+	const fieldRenames = [];
+	const callOfStatement = [];
+	const conflicts = [];
+	const renamedCollections = /* @__PURE__ */ new Map();
+	for (const statement of input.statements) {
+		const label = `Cannot ${describeMigrationStatement(statement, input.fromContract, input.contract)}`;
+		const outcome = statement.entity === "model" ? planModelStatement(statement, label, schema, input) : planFieldStatement(statement, label, renamedCollections, schema, input);
+		if (outcome.kind === "refused") {
+			conflicts.push(outcome.conflict);
+			callOfStatement.push(void 0);
+			continue;
+		}
+		if (outcome.kind === "renameCollection") {
+			schema = renameInSchema(schema, outcome.call.from, outcome.call.to);
+			renamedCollections.set(outcome.call.from, outcome.call.to);
+			collectionRenames.push(outcome.call);
+		}
+		if (outcome.kind === "renameField") fieldRenames.push(outcome.call);
+		callOfStatement.push(outcome.kind === "unchanged" ? void 0 : outcome.call);
+	}
+	return conflicts.length > 0 ? notOk(conflicts) : ok({
+		schema,
+		collectionRenames,
+		fieldRenames,
+		callOfStatement
+	});
+}
+function renameInSchema(schema, from, to) {
+	return new MongoSchemaIR(schema.collections.map((collection) => collection.name === from ? new MongoSchemaCollection({
+		name: to,
+		indexes: collection.indexes,
+		...collection.validator === void 0 ? {} : { validator: collection.validator },
+		...collection.options === void 0 ? {} : { options: collection.options }
+	}) : collection));
+}
+function controlPolicyRefusal(statement, label, contract, collection) {
+	const policy = collectionControlPolicy(contract, collection);
+	if (policy === "managed") return void 0;
+	return {
+		kind: "refused",
+		conflict: refused(statement, label, `collection "${collection}" has control policy "${policy}"`, `Statements rename only collections, and fields of collections, whose control policy is "managed". Make the change in the database yourself and leave out this statement.`)
+	};
+}
+/**
+* The reason and advice when a statement renames a variant whose discriminator value changes: its
+* documents keep the old value, which the new validator does not accept.
+*/
+function discriminatorValueChange(statement, input) {
+	const before = variantFilter(input.fromContract, statement.from);
+	const after = variantFilter(input.contract, statement.to);
+	const base = modelAt(input.contract, statement.to)?.base;
+	if (before === void 0 || after === void 0 || base === void 0) return void 0;
+	const [field, oldValue] = Object.entries(before)[0] ?? [];
+	const newValue = Object.values(after)[0];
+	if (field === void 0 || oldValue === newValue) return void 0;
+	const fromName = modelDisplayName(statement.from);
+	const toName = modelDisplayName(statement.to);
+	return [`its discriminator value changes from ${JSON.stringify(oldValue)} to ${JSON.stringify(newValue)}`, `The documents of "${fromName}" hold ${field} ${JSON.stringify(oldValue)}, and this release does not rewrite a discriminator value, so they would no longer match "${toName}" and would fail validation. Keep the value: declare "${toName}" with @@base(${base.model}, ${JSON.stringify(oldValue)}). A later release changes a stored value with --convert.`];
+}
+function planModelStatement(statement, label, schema, input) {
+	const discriminatorChange = discriminatorValueChange(statement, input);
+	if (discriminatorChange !== void 0) return {
+		kind: "refused",
+		conflict: refused(statement, label, ...discriminatorChange)
+	};
+	const from = collectionOf(input.fromContract, statement.from);
+	const to = collectionOf(input.contract, statement.to);
+	if (from === to) return { kind: "unchanged" };
+	const policyRefusal = controlPolicyRefusal(statement, label, input.contract, to);
+	if (policyRefusal !== void 0) return policyRefusal;
+	const refuse = (reason, why) => ({
+		kind: "refused",
+		conflict: refused(statement, label, reason, why)
+	});
+	const source = schema.collection(from);
+	if (source === void 0) return refuse(`the schema being planned from has no collection "${from}"`, `The database has no collection "${from}", or "${from}" is a view, which MongoDB cannot rename. Inspect it with prisma db schema, or ${LEAVE_OUT.toLowerCase()}`);
+	if (source.options?.timeseries !== void 0) return refuse(`collection "${from}" is a time-series collection`, `MongoDB cannot rename a time-series collection. Leave out this statement. To keep the documents, first create collection "${to}" yourself with the same time-series options and copy them into it; the plan then drops "${from}" once --delete names the model.`);
+	const invalid = invalidCollectionNameReason(to);
+	if (invalid !== void 0) return refuse(`MongoDB does not accept the collection name "${to}": ${invalid}`, "Give the model a collection name MongoDB accepts with @@map, then run this command again.");
+	if (schema.collection(to) !== void 0) return refuse(`the schema being planned from already has a collection "${to}"`, `A rename cannot replace a collection that already exists. Rename or drop collection "${to}" first, or ${LEAVE_OUT.toLowerCase()}`);
+	return {
+		kind: "renameCollection",
+		call: new RenameCollectionCall(from, to)
+	};
+}
+function planFieldStatement(statement, label, renamedCollections, schema, input) {
+	const refuse = (reason, why) => ({
+		kind: "refused",
+		conflict: refused(statement, label, reason, why)
+	});
+	const fromField = storedField(modelAt(input.fromContract, statement.from), statement.from.field);
+	const toField = storedField(modelAt(input.contract, statement.to), statement.to.field);
+	if (fromField.kind === "embed" || toField.kind === "embed") return refuse("the field is an embedded relation", `Renaming an embedded relation is not supported in this release. ${LEAVE_OUT}`);
+	if (fromField.kind !== "field" && toField.kind !== "field") return { kind: "unchanged" };
+	if (fromField.kind !== "field" || toField.kind !== "field") return refuse("the field is stored in documents on one side of the statement only", `A relation is not stored in documents, so a statement cannot rename a field to or from one. ${LEAVE_OUT}`);
+	if (statement.from.field === "_id" || statement.to.field === "_id") return refuse("it renames _id", `MongoDB does not let a document change its _id. ${LEAVE_OUT}`);
+	const unsafeFrom = unrewritableFieldNameReason(statement.from.field);
+	if (unsafeFrom !== void 0) return refuse(`the stored field name "${statement.from.field}" cannot be rewritten`, `${unsafeFrom}, so a statement cannot move its values. Rename it in the database yourself, or ${LEAVE_OUT.toLowerCase()}`);
+	const unsafeTo = unrewritableFieldNameReason(statement.to.field);
+	if (unsafeTo !== void 0) return refuse(`the stored field name "${statement.to.field}" cannot be written`, `${unsafeTo}. Give the field a stored name without "." that does not start with "$" (with @map), or ${LEAVE_OUT.toLowerCase()}`);
+	const originCollection = collectionOf(input.fromContract, statement.from);
+	const collection = renamedCollections.get(originCollection) ?? originCollection;
+	const destinationCollection = collectionOf(input.contract, statement.to);
+	if (collection !== destinationCollection) return refuse(`the model's collection changes from "${originCollection}" to "${destinationCollection}", and no statement renames it`, collectionChangeAdvice(statement, originCollection, destinationCollection));
+	if (statement.from.field === statement.to.field) return { kind: "unchanged" };
+	if (schema.collection(collection)?.options?.timeseries !== void 0) return refuse(`collection "${collection}" is a time-series collection`, `${TIME_SERIES_UPDATES}, so a statement cannot move the values of a field in them. Keep the stored name: name the field ${JSON.stringify(statement.from.field)} in the contract (with @map(${JSON.stringify(statement.from.field)}) in PSL), then run this command again without this statement.`);
+	const policyRefusal = controlPolicyRefusal(statement, label, input.contract, collection);
+	if (policyRefusal !== void 0) return policyRefusal;
+	const filter = variantFilter(input.fromContract, statement.from) ?? rootDocumentsLosing(input.contract, statement.to, statement.from.field)?.filter;
+	return {
+		kind: "renameField",
+		call: new RenameFieldCall(collection, statement.from.field, statement.to.field, filter)
+	};
+}
+function collectionChangeAdvice(statement, from, to) {
+	if (!sameModel(statement.from, statement.to)) return `Add --rename ${modelDisplayName(statement.from)}:${modelDisplayName(statement.to)} before this statement, so the collection is renamed with its documents.`;
+	return `A statement cannot rename the collection of a model that keeps its name. Rename the collection in a step of its own first: change only @@map and emit the contract. ${renameCollectionByHandSteps(statement.from, from, to)} Then change the field and run this statement again.`;
+}
+function renameCollectionByHandSteps(model, from, to) {
+	return `With db update, rename the collection in the database yourself, for example db.getCollection(${JSON.stringify(from)}).renameCollection(${JSON.stringify(to)}) in mongosh, then run db update. With migration plan, plan it, passing --delete ${modelDisplayName(model)} to answer its question; in its migration.ts make renameCollection(${JSON.stringify(from)}, ${JSON.stringify(to)}) the first operation, imported with the other operations, delete the drop of "${from}", and delete the create of "${to}" if there is one; run node on that migration.ts so it writes ops.json again; then apply it with prisma db migrate.`;
+}
+/**
+* How to keep the documents of a model that keeps its name while its collection changes from
+* `from` to `to`: no statement can rename that collection, so the user renames it by hand.
+*/
+function keepCollectionByHandAdvice(model, from, to) {
+	return `To keep its documents, rename collection "${from}" to "${to}" instead; a statement cannot rename the collection of a model that keeps its name. ${renameCollectionByHandSteps(model, from, to)}`;
+}
+function modelCoordinates(contract) {
+	return Object.entries(contract.domain?.namespaces ?? {}).flatMap(([namespaceId, namespace]) => Object.keys(namespace.models).map((model) => ({
+		namespaceId: asNamespaceId(namespaceId),
+		model
+	})));
+}
+function sameModel(a, b) {
+	return a.namespaceId === b.namespaceId && a.model === b.model;
+}
+/**
+* The destination model an origin model became: the one a statement renamed it to, else the one of
+* the same name, else the only one stored the same way (same collection, same variant value).
+*/
+function destinationModelOf(origin, input) {
+	const renamed = input.statements.find((statement) => statement.entity === "model" && sameModel(statement.from, origin));
+	if (renamed !== void 0) return renamed.to;
+	if (modelAt(input.contract, origin) !== void 0) return origin;
+	const collection = input.collectionAfterRenames(collectionOf(input.fromContract, origin));
+	const filter = JSON.stringify(variantFilter(input.fromContract, origin) ?? null);
+	const stored = modelCoordinates(input.contract).filter((candidate) => collectionOf(input.contract, candidate) === collection && JSON.stringify(variantFilter(input.contract, candidate) ?? null) === filter);
+	const [only] = stored;
+	return stored.length === 1 ? only : void 0;
+}
+function renamedByStatement(input, field) {
+	return input.statements.some((statement) => statement.entity === "field" && sameModel(statement.from, field) && statement.from.field === field.field);
+}
+function storedFieldsOf(contract, coordinate) {
+	const model = modelAt(contract, coordinate);
+	if (model === void 0) return /* @__PURE__ */ new Set();
+	const base = model.base === void 0 ? void 0 : modelAt(contract, {
+		namespaceId: asNamespaceId(model.base.namespace),
+		model: model.base.model
+	});
+	return /* @__PURE__ */ new Set([...Object.keys(model.fields), ...Object.keys(base?.fields ?? {})]);
+}
+/**
+* The documents of a root model that lose `field`: all of them, or, when some of its destination
+* variants now store the field themselves, those whose discriminator value is none of theirs.
+* `undefined` when the root model itself still stores it.
+*/
+function rootDocumentsLosing(contract, root, field) {
+	const model = modelAt(contract, root);
+	if (model === void 0 || Object.hasOwn(model.fields, field)) return void 0;
+	const discriminator = model.discriminator?.field;
+	const keeping = Object.entries(model.variants ?? {}).filter(([variant]) => Object.hasOwn(modelAt(contract, {
+		...root,
+		model: variant
+	})?.fields ?? {}, field)).map(([, entry]) => entry.value).sort();
+	if (discriminator === void 0 || keeping.length === 0) return { filter: void 0 };
+	return { filter: { [discriminator]: { $nin: keeping } } };
+}
+/**
+* Each field an origin model stores that its destination model no longer stores, in a collection
+* the plan keeps: removing it is data loss, carried out by unsetting it from the documents that
+* hold it, in a collection whose control policy is `managed`. A variant's field is unset only from that variant's documents, unless its destination
+* base now stores it. A base field is unset from the documents of every variant that does not now
+* store it itself.
+*/
+function planFieldRemovals(input) {
+	return modelCoordinates(input.fromContract).flatMap((origin) => {
+		const collection = input.collectionAfterRenames(collectionOf(input.fromContract, origin));
+		if (!input.keptCollections.has(collection)) return [];
+		if (collectionControlPolicy(input.contract, collection) !== "managed") return [];
+		const destination = destinationModelOf(origin, input);
+		if (destination === void 0) return [];
+		const model = modelAt(input.fromContract, origin);
+		if (model === void 0) return [];
+		const variant = variantFilter(input.fromContract, origin);
+		const losing = (field) => {
+			if (variant !== void 0) return storedFieldsOf(input.contract, destination).has(field) ? void 0 : { filter: variant };
+			return rootDocumentsLosing(input.contract, destination, field);
+		};
+		return Object.keys(model.fields).filter((field) => unrewritableFieldNameReason(field) === void 0 && !renamedByStatement(input, {
+			...origin,
+			field
+		})).sort().flatMap((field) => {
+			const lost = losing(field);
+			return lost === void 0 ? [] : [{
+				call: new UnsetFieldCall(collection, field, lost.filter),
+				subject: {
+					kind: "field",
+					...origin,
+					field
+				}
+			}];
+		});
+	});
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function propertyNames(schema) {
+	const properties = isRecord$1(schema) ? schema["properties"] : void 0;
+	return isRecord$1(properties) ? Object.keys(properties) : [];
+}
+function branchPropertyNames(schema) {
+	const branches = isRecord$1(schema) ? schema["oneOf"] : void 0;
+	return Array.isArray(branches) ? branches.flatMap(propertyNames) : [];
+}
+/**
+* Without an origin contract, a field is known removed when the origin validator declares it at the
+* top level and the destination validator declares it nowhere. It is named by its storage name.
+*/
+function planValidatorFieldRemovals(input) {
+	return input.origin.collections.flatMap((originCollection) => {
+		if (collectionControlPolicy(input.contract, originCollection.name) !== "managed") return [];
+		const destination = input.destination.collection(originCollection.name);
+		if (destination?.validator === void 0 || originCollection.validator === void 0) return [];
+		const kept = /* @__PURE__ */ new Set([...propertyNames(destination.validator?.jsonSchema), ...branchPropertyNames(destination.validator?.jsonSchema)]);
+		return propertyNames(originCollection.validator.jsonSchema).filter((field) => unrewritableFieldNameReason(field) === void 0 && !kept.has(field)).sort().map((field) => ({
+			call: new UnsetFieldCall(originCollection.name, field),
+			subject: {
+				kind: "storage",
+				name: `${originCollection.name}.${field}`
+			}
+		}));
+	});
+}
 function renderOps(calls) {
 	return calls.map((call) => call.toOp());
 }
@@ -467,6 +852,35 @@ var PlannerProducedMongoMigration = class extends Migration {
 		});
 	}
 };
+const SAME_HASH = "the migration would start and end at the same contract hash";
+function why(collection) {
+	return `The contract gives collection ${JSON.stringify(collection)} no validator, so the names of its fields are not part of the contract's storage hash; a contract written in TypeScript has none yet. A migration that only renames or removes a field would start and end at the same hash, and db migrate refuses such a migration. Use prisma db update for this change instead: it carries the change out with the same --rename or --delete and writes no migration. Or write the migration by hand: run prisma migration new --from <hash of the migration the database is at>, and carry the change out in a dataTransform operation of its migration.ts, since db migrate accepts a migration that starts and ends at the same hash when it runs a dataTransform.`;
+}
+/**
+* Refuses, for a migration package, each field rename and field removal of a plan whose contract
+* storage hash does not change: the collection has no validator in the contract, so its field
+* names are not in the hash, and `db migrate` refuses a migration that starts and ends at the same
+* hash. `db update` writes no migration and plans without an origin, so it is not refused.
+*/
+function sameHashFieldChangeRefusals(input) {
+	if (input.origin === null || input.origin.storageHash !== input.contract.storage.storageHash) return [];
+	const renames = input.statements.flatMap((statement, index) => {
+		const call = input.callOfStatement[index];
+		if (!(call instanceof RenameFieldCall)) return [];
+		return [{
+			kind: "statementRefused",
+			summary: `Cannot ${describeMigrationStatement(statement, input.fromContract, input.contract)}: ${SAME_HASH}`,
+			why: why(call.collection),
+			refusedStatement: statement
+		}];
+	});
+	const removals = input.removals.map(({ call }) => ({
+		kind: "fieldRemovalRefused",
+		summary: `Cannot remove field ${JSON.stringify(call.field)} from collection ${JSON.stringify(call.collection)}: ${SAME_HASH}`,
+		why: why(call.collection)
+	}));
+	return [...renames, ...removals];
+}
 function buildIndexLookupKey(index) {
 	const keys = index.keys.map((k) => `${k.field}:${k.direction}`).join(",");
 	const opts = [
@@ -509,20 +923,41 @@ function validatorUpdateLabel(collName, origin, dest) {
 	];
 	return parts.length === 0 ? `Update validator on ${collName}` : `Update validator on ${collName} (${parts.join("; ")})`;
 }
+/**
+* The keys of an option MongoDB fills in when a collection is created without them, each with a
+* test for the value it fills in. `listCollections` reports a time-series collection's granularity
+* as "seconds" and its bucketMaxSpanSeconds when they were not given, and bucketRoundingSeconds only
+* for custom bucketing, which a contract cannot state; and a clustered index's v, key and unique, and
+* its name as "_id_".
+*/
+const SERVER_FILLED = {
+	timeseries: {
+		granularity: (value) => value === "seconds",
+		bucketMaxSpanSeconds: () => true,
+		bucketRoundingSeconds: () => true
+	},
+	clusteredIndex: {
+		v: () => true,
+		key: () => true,
+		unique: () => true,
+		name: (value) => value === "_id_"
+	}
+};
+/** The origin's value of an option without the keys the server filled in and the destination leaves out. */
+function withoutServerFilled(option, origin, dest) {
+	if (!isPlainObject(origin)) return origin;
+	const filled = SERVER_FILLED[option];
+	return Object.fromEntries(Object.entries(origin).filter(([key, value]) => isPlainObject(dest) && Object.hasOwn(dest, key) || !filled[key]?.(value)));
+}
 function hasImmutableOptionChange(origin, dest) {
 	if (canonicalize(origin?.capped) !== canonicalize(dest?.capped)) return "capped";
-	if (canonicalize(origin?.timeseries) !== canonicalize(dest?.timeseries)) return "timeseries";
+	if (canonicalize(withoutServerFilled("timeseries", origin?.timeseries, dest?.timeseries)) !== canonicalize(dest?.timeseries)) return "timeseries";
 	if (canonicalize(origin?.collation) !== canonicalize(dest?.collation)) return "collation";
-	if (canonicalize(origin?.clusteredIndex) !== canonicalize(dest?.clusteredIndex)) return "clusteredIndex";
+	if (canonicalize(withoutServerFilled("clusteredIndex", origin?.clusteredIndex, dest?.clusteredIndex)) !== canonicalize(dest?.clusteredIndex)) return "clusteredIndex";
 }
 function collectionHasOptions(coll) {
 	return !!(coll.options || coll.validator);
 }
-/** The collection a model stores its documents in; a model without `@@map` names it verbatim. */
-function collectionOf(contract, coordinate) {
-	const collection = contract?.domain.namespaces[coordinate.namespaceId]?.models[coordinate.model]?.storage["collection"];
-	return typeof collection === "string" ? collection : coordinate.model;
-}
 /**
 * The model of `fromContract` that stores its documents in `collection`, if any: the root model
 * when variants share the collection with it.
@@ -540,67 +975,47 @@ function modelStoredIn(fromContract, collection) {
 	}));
 	return (storing.find(({ isRoot }) => isRoot) ?? storing[0])?.coordinate;
 }
-/** Each collection drop of the plan, with the model whose documents it loses. */
-function collectionDrops(calls, fromContract) {
+/**
+* Each collection drop of the plan, with the model whose documents it loses. When that model keeps
+* its name and the plan brings its new collection into existence, the drop says how to rename the
+* collection by hand instead.
+*/
+function collectionDrops(calls, fromContract, contract, collections) {
+	const created = (collection) => collections.origin.collection(collection) === void 0 && collections.destination.collection(collection) !== void 0;
 	return calls.flatMap((call, operationIndex) => {
 		if (!(call instanceof DropCollectionCall)) return [];
 		const model = fromContract === null ? void 0 : modelStoredIn(fromContract, call.collection);
-		return [{
+		if (model === void 0) return [{
 			operationIndex,
-			subject: model === void 0 ? {
+			subject: {
 				kind: "storage",
 				name: call.collection
-			} : {
-				kind: "model",
-				...model
 			}
 		}];
+		const subject = {
+			kind: "model",
+			...model
+		};
+		const destinationCollection = modelStoredInDestination(contract, model);
+		return [destinationCollection !== void 0 && created(destinationCollection) ? {
+			operationIndex,
+			subject,
+			keepDataAdvice: keepCollectionByHandAdvice(model, call.collection, destinationCollection)
+		} : {
+			operationIndex,
+			subject
+		}];
 	});
 }
-const NOT_IN_THIS_RELEASE = "MongoDB cannot carry out rename statements in this release.";
-function shellString(name) {
-	return JSON.stringify(name);
-}
-/**
-* How to keep the documents of a subject a plan would drop, since the planner carries out no
-* rename: rename the collection by hand before a plan that drops it is applied. Right for both
-* `db update`, which then finds nothing to drop, and `migration plan`, whose written migration
-* still drops it.
-*/
-function keepDataByHand(subject, fromContract) {
-	const collection = subject.kind === "storage" ? subject.name : collectionOf(fromContract, subject);
-	return `If it was renamed, keep its documents instead: rename collection "${collection}" by hand on each database before a plan that drops it is applied there, for example with db.getCollection(${shellString(collection)}).renameCollection("<new collection>") in mongosh. db update then drops nothing; a migration written by migration plan still drops "${collection}", so remove that operation from its migration.ts, or do not apply it where the collection was renamed.`;
-}
-/**
-* What a plan made without the statement does to the data, and how to keep it. Right for both
-* `db update` and `migration plan`, since the planner does not know which command it serves.
-* Mongo contracts key a model's fields by their stored names, so the statement's field names are
-* the names a `$rename` needs.
-*/
-function keepTheData(statement, fromContract, contract) {
-	const from = collectionOf(fromContract, statement.from);
-	if (statement.entity === "field") {
-		const { field } = statement.from;
-		const newField = statement.to.field;
-		const collection = `db.getCollection(${shellString(from)})`;
-		return `${NOT_IN_THIS_RELEASE} Without the statement, the documents in collection "${from}" keep their values under "${field}", and nothing moves them to "${newField}". To move them, run these in mongosh on each database before a plan made without the statement is applied there, using the field names as they are stored. First turn off the collection's validator, which still requires "${field}": db.runCommand({ collMod: ${shellString(from)}, validationLevel: "off" }). Then drop each unique index that includes "${field}", or the move fails once two documents have lost it, for example ${collection}.dropIndex(${shellString(`${field}_1`)}). Then move the values: ${collection}.updateMany({}, { $rename: { ${shellString(field)}: ${shellString(newField)} } }). Applying the plan then creates the indexes on "${newField}" and turns the validator back on.`;
-	}
-	const to = collectionOf(contract, statement.to);
-	if (from === to) return `${NOT_IN_THIS_RELEASE} Both models store their documents in collection "${from}", so a plan made without the statement keeps them.`;
-	return `${NOT_IN_THIS_RELEASE} Without the statement, a plan drops collection "${from}" with its documents and creates collection "${to}". To keep the documents, rename the collection by hand on each database before a plan made without the statement is applied there, for example with db.getCollection(${shellString(from)}).renameCollection(${shellString(to)}) in mongosh. A migration written by migration plan without the statement still drops "${from}" wherever it is applied, so check its operations first.`;
-}
-function statementNotApplied(statement, fromContract, contract) {
-	return {
-		kind: "statementRefused",
-		summary: `MongoDB does not apply rename statements in this release, so nothing was planned: ${describeMigrationStatement(statement, fromContract ?? contract, contract)}`,
-		why: keepTheData(statement, fromContract, contract),
-		refusedStatement: statement
-	};
+/** The collection the destination stores `model` in, when the destination still has that model. */
+function modelStoredInDestination(contract, model) {
+	const namespace = contract.domain.namespaces[model.namespaceId];
+	return namespace !== void 0 && Object.hasOwn(namespace.models, model.model) ? collectionOf(contract, model) : void 0;
 }
 var MongoMigrationPlanner = class {
 	planCalls(options) {
 		const contract = blindCast(options.contract);
-		const originIR = blindCast(options.schema);
+		const originIR = options.statementCalls?.schema ?? blindCast(options.schema);
 		const destinationIR = contractToMongoSchemaIR(contract);
 		const collCreates = [];
 		const drops = [];
@@ -643,8 +1058,10 @@ var MongoMigrationPlanner = class {
 			conflicts
 		};
 		const allCalls = [
+			...options.statementCalls?.collectionRenames ?? [],
 			...collCreates,
 			...drops,
+			...options.statementCalls?.rewrites ?? [],
 			...creates,
 			...validatorOps,
 			...mutableOptionOps,
@@ -667,21 +1084,75 @@ var MongoMigrationPlanner = class {
 	}
 	plan(options) {
 		const contract = blindCast(options.contract);
-		const [statement] = options.statements;
-		if (statement !== void 0) return {
+		const originIR = blindCast(options.schema);
+		const fromContract = options.fromContract;
+		const statementPlan = planStatements({
+			statements: options.statements,
+			fromContract: fromContract ?? contract,
+			contract,
+			schema: originIR
+		});
+		if (!statementPlan.ok) return {
+			kind: "failure",
+			conflicts: statementPlan.failure
+		};
+		const { schema, collectionRenames, fieldRenames, callOfStatement } = statementPlan.value;
+		const destinationIR = contractToMongoSchemaIR(contract);
+		const renamedTo = new Map(collectionRenames.map((call) => [call.from, call.to]));
+		const removals = fromContract === null ? planValidatorFieldRemovals({
+			origin: schema,
+			destination: destinationIR,
+			contract
+		}) : planFieldRemovals({
+			statements: options.statements,
+			fromContract,
+			contract,
+			collectionAfterRenames: (collection) => renamedTo.get(collection) ?? collection,
+			keptCollections: new Set(schema.collectionNames.filter((name) => destinationIR.collection(name) !== void 0))
+		});
+		const removalRefusals = [...timeSeriesRemovalRefusals(removals, schema), ...sameHashFieldChangeRefusals({
+			origin: options.origin,
+			fromContract: fromContract ?? contract,
+			contract,
+			statements: options.statements,
+			callOfStatement,
+			removals
+		})];
+		if (removalRefusals.length > 0) return {
 			kind: "failure",
-			conflicts: [statementNotApplied(statement, options.fromContract, contract)]
+			conflicts: removalRefusals
 		};
-		const result = this.planCalls(options);
+		const result = this.planCalls({
+			...options,
+			statementCalls: {
+				schema,
+				collectionRenames,
+				rewrites: [...fieldRenames, ...removals.map((removal) => removal.call)]
+			}
+		});
 		if (result.kind === "failure") return result;
+		const { calls } = result;
+		const fieldLoss = removals.map((removal) => ({
+			operationIndex: calls.indexOf(removal.call),
+			subject: removal.subject
+		}));
 		return {
 			kind: "success",
-			plan: new PlannerProducedMongoMigration(result.calls, {
+			plan: new PlannerProducedMongoMigration(calls, {
 				from: options.origin?.storageHash ?? null,
 				to: contract.storage.storageHash
 			}, options.snapshotsImportPath),
-			appliedStatements: [],
-			dataLoss: collectionDrops(result.calls, options.fromContract),
+			appliedStatements: options.statements.map((statement, index) => {
+				const call = callOfStatement[index];
+				return {
+					statement,
+					operationIndexes: call === void 0 ? [] : [calls.indexOf(call)]
+				};
+			}),
+			dataLoss: [...collectionDrops(calls, fromContract, contract, {
+				origin: schema,
+				destination: destinationIR
+			}), ...fieldLoss].sort((a, b) => a.operationIndex - b.operationIndex),
 			accessWidening: []
 		};
 	}
@@ -846,6 +1317,11 @@ const DropCollectionJson = type({
 	kind: "\"dropCollection\"",
 	collection: "string"
 });
+const RenameCollectionJson = type({
+	kind: "\"renameCollection\"",
+	collection: "string",
+	to: "string"
+});
 const CollModJson = type({
 	kind: "\"collMod\"",
 	collection: "string",
@@ -902,7 +1378,8 @@ const RawUpdateManyJson = type({
 	kind: "\"rawUpdateMany\"",
 	collection: "string",
 	filter: "Record<string, unknown>",
-	update: "Record<string, unknown> | Record<string, unknown>[]"
+	update: "Record<string, unknown> | Record<string, unknown>[]",
+	"bypassDocumentValidation?": "boolean"
 });
 const RawDeleteOneJson = type({
 	kind: "\"rawDeleteOne\"",
@@ -995,16 +1472,16 @@ const DdlOperationJson = type({
 	execute: "Record<string, unknown>[]",
 	postcheck: "Record<string, unknown>[]"
 });
-const DataTransformCheckJson = type({
+const DmlCheckJson = type({
 	description: "string",
 	source: "Record<string, unknown>",
 	filter: "Record<string, unknown>",
 	expect: "\"exists\" | \"notExists\""
 });
-const DataTransformOperationJson = type({
+const DmlOperationJson = type({
 	id: "string",
 	label: "string",
-	operationClass: "\"data\"",
+	operationClass: "\"additive\" | \"widening\" | \"destructive\" | \"data\"",
 	name: "string",
 	precheck: "Record<string, unknown>[]",
 	run: "Record<string, unknown>[]",
@@ -1153,7 +1630,7 @@ function deserializeDmlCommand(json) {
 		}
 		case "rawUpdateMany": {
 			const data = validate(RawUpdateManyJson, json, "rawUpdateMany command");
-			return new RawUpdateManyCommand(data.collection, data.filter, data.update);
+			return new RawUpdateManyCommand(data.collection, data.filter, data.update, ifDefined("bypassDocumentValidation", data.bypassDocumentValidation));
 		}
 		case "rawDeleteOne": {
 			const data = validate(RawDeleteOneJson, json, "rawDeleteOne command");
@@ -1242,6 +1719,10 @@ function deserializeDdlCommand(json) {
 			});
 		}
 		case "dropCollection": return new DropCollectionCommand(validate(DropCollectionJson, json, "dropCollection command").collection);
+		case "renameCollection": {
+			const data = validate(RenameCollectionJson, json, "renameCollection command");
+			return new RenameCollectionCommand(data.collection, data.to);
+		}
 		case "collMod": {
 			const data = validate(CollModJson, json, "collMod command");
 			return new CollModCommand(data.collection, {
@@ -1286,8 +1767,8 @@ function deserializeStep(json) {
 		command: deserializeDdlCommand(data.command)
 	};
 }
-function isDataTransformJson(json) {
-	return recordValue(json, "operationClass", "migration operation") === "data";
+function isDmlOperationJson(json) {
+	return Array.isArray(recordValue(json, "run", "migration operation"));
 }
 function deserializeDdlOp(json) {
 	const data = validate(DdlOperationJson, json, "migration operation");
@@ -1300,8 +1781,8 @@ function deserializeDdlOp(json) {
 		postcheck: data.postcheck.map(deserializeCheck)
 	};
 }
-function deserializeDataTransformCheck(json) {
-	const data = validate(DataTransformCheckJson, json, "data transform check");
+function deserializeDmlCheck(json) {
+	const data = validate(DmlCheckJson, json, "DML operation check");
 	return {
 		description: data.description,
 		source: deserializeMongoQueryPlan(data.source),
@@ -1309,20 +1790,20 @@ function deserializeDataTransformCheck(json) {
 		expect: data.expect
 	};
 }
-function deserializeDataTransformOp(json) {
-	const data = validate(DataTransformOperationJson, json, "data transform operation");
+function deserializeDmlOp(json) {
+	const data = validate(DmlOperationJson, json, "DML operation");
 	return {
 		id: data.id,
 		label: data.label,
-		operationClass: "data",
+		operationClass: data.operationClass,
 		name: data.name,
-		precheck: data.precheck.map(deserializeDataTransformCheck),
+		precheck: data.precheck.map(deserializeDmlCheck),
 		run: data.run.map(deserializeMongoQueryPlan),
-		postcheck: data.postcheck.map(deserializeDataTransformCheck)
+		postcheck: data.postcheck.map(deserializeDmlCheck)
 	};
 }
 function deserializeMongoOp(json) {
-	if (isDataTransformJson(json)) return deserializeDataTransformOp(json);
+	if (isDmlOperationJson(json)) return deserializeDmlOp(json);
 	return deserializeDdlOp(json);
 }
 function deserializeMongoOps(json) {
@@ -1339,6 +1820,59 @@ function runnerFailure(code, summary, opts) {
 		...opts
 	});
 }
+/**
+* The failure when a field rename's before-check finds documents that already hold the new name,
+* which `$rename` would overwrite: what to look for and fix, and that the plan resumes.
+*/
+function renameOverwriteRefusal(op) {
+	const rewrite = fieldRewriteOf(op);
+	if (rewrite === void 0) return void 0;
+	const renames = Reflect.get(rewrite.command.update, "$rename");
+	const to = typeof renames === "object" && renames !== null ? Reflect.get(renames, rewrite.field) : void 0;
+	if (typeof to !== "string") return void 0;
+	const [check] = op.precheck;
+	const source = check?.source.command;
+	const match = source instanceof RawAggregateCommand ? Reflect.get(source.pipeline[0] ?? {}, "$match") : void 0;
+	const find = `db.getCollection(${JSON.stringify(rewrite.collection)}).find(${JSON.stringify(match ?? {})})`;
+	return runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${op.id} stopped: some documents in collection ${rewrite.collection} already hold ${to} as well as ${rewrite.field}`, {
+		why: `Renaming ${rewrite.field} to ${to} would overwrite their ${to}. Find them with ${find} in mongosh, and move or remove one of the two values in each. Nothing was renamed. The operations before this one in the plan already ran, such as dropping an index on ${rewrite.field}; once the documents are fixed, run the command again and the plan finishes from here.`,
+		meta: {
+			operationId: op.id,
+			name: op.name
+		}
+	});
+}
+/**
+* The failure when a collection rename's before-check finds that the new collection already exists.
+*/
+function renameTargetExistsRefusal(op, failed) {
+	const rename = op.execute.find((step) => step.command instanceof RenameCollectionCommand)?.command;
+	if (!(rename instanceof RenameCollectionCommand) || failed.expect !== "notExists") return;
+	const { collection: from, to } = rename;
+	return runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${op.id} stopped: collection ${to} already exists, so collection ${from} cannot be renamed to it`, {
+		why: `Nothing was renamed. If ${to} holds nothing you need, drop it, then run the command again; operations that already ran are skipped. If an earlier operation of the same migration created ${to}, as a createIndex on ${to} does, make renameCollection(${JSON.stringify(from)}, ${JSON.stringify(to)}) the first operation of its migration.ts, run node on that migration.ts, and then drop ${to} and run the command again.`,
+		meta: { operationId: op.id }
+	});
+}
+const MONGO_UNAUTHORIZED = 13;
+/**
+* The failure for a rewrite that skips validation when the database user lacks the
+* `bypassDocumentValidation` action, as a `readWrite` user on a hosted cluster does.
+*/
+function bypassValidationRefusal(op, plan, error) {
+	if (!(plan.command instanceof RawUpdateManyCommand) || !plan.command.bypassDocumentValidation) return;
+	if (typeof error !== "object" || error === null) return void 0;
+	if (Reflect.get(error, "code") !== MONGO_UNAUTHORIZED) return void 0;
+	const codeName = Reflect.get(error, "codeName");
+	return runnerFailure("MIGRATION.EXECUTION_FAILED", `Operation ${op.id} failed: the database user may not skip document validation`, {
+		why: `Renaming or removing a field rewrites documents with bypassDocumentValidation, because the old validator requires the old field. MongoDB refused it with error ${MONGO_UNAUTHORIZED} (${String(codeName)}). Grant the user the bypassDocumentValidation action on the database, for example with the dbAdmin or restore role, then run the command again; operations that already ran are skipped.`,
+		meta: {
+			operationId: op.id,
+			mongoCode: MONGO_UNAUTHORIZED,
+			codeName
+		}
+	});
+}
 var MongoMigrationRunner = class {
 	deps;
 	constructor(deps) {
@@ -1362,22 +1896,22 @@ var MongoMigrationRunner = class {
 		for (const operation of operations) {
 			options.callbacks?.onOperationStart?.(operation);
 			try {
-				if (operation.operationClass === "data") {
-					const result = await this.executeDataTransform(blindCast(operation), adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks);
+				if (isMongoDmlOperation(operation)) {
+					const result = await this.executeDmlOperation(operation, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks);
 					if (result.failure) return result.failure;
 					if (result.executed) operationsExecuted += 1;
 					continue;
 				}
-				const ddlOp = blindCast(operation);
 				if (runPostchecks && runIdempotency) {
-					if (await this.allChecksSatisfied(ddlOp.postcheck, inspectionExecutor, filterEvaluator)) continue;
+					if (await this.allChecksSatisfied(operation.postcheck, inspectionExecutor, filterEvaluator)) continue;
 				}
 				if (runPrechecks) {
-					if (!await this.evaluateChecks(ddlOp.precheck, inspectionExecutor, filterEvaluator)) return runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${operation.id} failed during precheck`, { meta: { operationId: operation.id } });
+					const failed = await this.firstFailingCheck(operation.precheck, inspectionExecutor, filterEvaluator);
+					if (failed !== void 0) return renameTargetExistsRefusal(operation, failed) ?? runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${operation.id} failed during precheck`, { meta: { operationId: operation.id } });
 				}
-				for (const step of ddlOp.execute) await executeDdl(step.command);
+				for (const step of operation.execute) await executeDdl(step.command);
 				if (runPostchecks) {
-					if (!await this.evaluateChecks(ddlOp.postcheck, inspectionExecutor, filterEvaluator)) return runnerFailure("MIGRATION.POSTCHECK_FAILED", `Operation ${operation.id} failed during postcheck`, { meta: { operationId: operation.id } });
+					if (!await this.evaluateChecks(operation.postcheck, inspectionExecutor, filterEvaluator)) return runnerFailure("MIGRATION.POSTCHECK_FAILED", `Operation ${operation.id} failed during postcheck`, { meta: { operationId: operation.id } });
 				}
 				operationsExecuted += 1;
 			} finally {
@@ -1449,14 +1983,14 @@ var MongoMigrationRunner = class {
 			});
 		}
 	}
-	async executeDataTransform(op, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks) {
+	async executeDmlOperation(op, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks) {
 		if (runPostchecks && runIdempotency && op.postcheck.length > 0) {
-			if (await this.evaluateDataTransformChecks(op.postcheck, adapter, driver, filterEvaluator)) return { executed: false };
+			if (await this.evaluateDmlChecks(op.postcheck, adapter, driver, filterEvaluator)) return { executed: false };
 		}
 		if (runPrechecks && op.precheck.length > 0) {
-			if (!await this.evaluateDataTransformChecks(op.precheck, adapter, driver, filterEvaluator)) return {
+			if (!await this.evaluateDmlChecks(op.precheck, adapter, driver, filterEvaluator)) return {
 				executed: false,
-				failure: runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${op.id} failed during precheck`, { meta: {
+				failure: renameOverwriteRefusal(op) ?? runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${op.id} failed during precheck`, { meta: {
 					operationId: op.id,
 					name: op.name
 				} })
@@ -1464,10 +1998,19 @@ var MongoMigrationRunner = class {
 		}
 		for (const plan of op.run) {
 			const wireCommand = await adapter.lower(plan, {});
-			for await (const _ of driver.execute(wireCommand));
+			try {
+				for await (const _ of driver.execute(wireCommand));
+			} catch (error) {
+				const refusal = bypassValidationRefusal(op, plan, error);
+				if (refusal === void 0) throw error;
+				return {
+					executed: false,
+					failure: refusal
+				};
+			}
 		}
 		if (runPostchecks && op.postcheck.length > 0) {
-			if (!await this.evaluateDataTransformChecks(op.postcheck, adapter, driver, filterEvaluator)) return {
+			if (!await this.evaluateDmlChecks(op.postcheck, adapter, driver, filterEvaluator)) return {
 				executed: false,
 				failure: runnerFailure("MIGRATION.POSTCHECK_FAILED", `Operation ${op.id} failed during postcheck`, { meta: {
 					operationId: op.id,
@@ -1477,7 +2020,7 @@ var MongoMigrationRunner = class {
 		}
 		return { executed: true };
 	}
-	async evaluateDataTransformChecks(checks, adapter, driver, filterEvaluator) {
+	async evaluateDmlChecks(checks, adapter, driver, filterEvaluator) {
 		for (const check of checks) {
 			const commandKind = check.source.command.kind;
 			if (!READ_ONLY_CHECK_COMMAND_KINDS.has(commandKind)) throw errorRunnerFailed(`Data-transform check rejected: command kind "${commandKind}" is not read-only`, {
@@ -1500,11 +2043,13 @@ var MongoMigrationRunner = class {
 		return true;
 	}
 	async evaluateChecks(checks, inspectionExecutor, filterEvaluator) {
+		return await this.firstFailingCheck(checks, inspectionExecutor, filterEvaluator) === void 0;
+	}
+	async firstFailingCheck(checks, inspectionExecutor, filterEvaluator) {
 		for (const check of checks) {
 			const matchFound = (await check.source.accept(inspectionExecutor)).some((doc) => filterEvaluator.evaluate(check.filter, doc));
-			if (!(check.expect === "exists" ? matchFound : !matchFound)) return false;
+			if (!(check.expect === "exists" ? matchFound : !matchFound)) return check;
 		}
-		return true;
 	}
 	async allChecksSatisfied(checks, inspectionExecutor, filterEvaluator) {
 		if (checks.length === 0) return false;
@@ -1628,10 +2173,6 @@ const mongoTargetDescriptor = {
 	contractSerializer: new MongoTargetContractSerializer(),
 	schemaVerifier: new MongoTargetSchemaVerifier(),
 	migrations: {
-		renameStatements: {
-			refused: true,
-			keepDataByHand
-		},
 		createPlanner(_adapter) {
 			return new MongoMigrationPlanner();
 		},
@@ -1681,6 +2222,6 @@ const mongoTargetDescriptor = {
 	}
 };
 //#endregion
-export { renderCallsToTypeScript as _, DropIndexCall as a, schemaIndexToCreateIndexOptions as b, MongoMigrationRunner as c, MongoTargetSchemaVerifier as d, MongoTargetUnboundDatabase as f, mongoTargetDescriptor as g, deserializeMongoOps as h, DropCollectionCall as i, MongoTargetContractSerializer as l, deserializeMongoOp as m, CreateCollectionCall as n, FilterEvaluator as o, PlannerProducedMongoMigration as p, CreateIndexCall as r, MongoMigrationPlanner as s, CollModCall as t, MongoTargetDatabase as u, renderOps as v, serializeMongoOps as x, schemaCollectionToCreateCollectionOptions as y };
+export { schemaIndexToCreateIndexOptions as C, schemaCollectionToCreateCollectionOptions as S, deserializeMongoOp as _, DropIndexCall as a, renderCallsToTypeScript as b, MongoMigrationRunner as c, MongoTargetSchemaVerifier as d, MongoTargetUnboundDatabase as f, UnsetFieldCall as g, RenameFieldCall as h, DropCollectionCall as i, MongoTargetContractSerializer as l, RenameCollectionCall as m, CreateCollectionCall as n, FilterEvaluator as o, PlannerProducedMongoMigration as p, CreateIndexCall as r, MongoMigrationPlanner as s, CollModCall as t, MongoTargetDatabase as u, deserializeMongoOps as v, serializeMongoOps as w, renderOps as x, mongoTargetDescriptor as y };
 
-//# sourceMappingURL=control-B0JolOVp.mjs.map
+//# sourceMappingURL=control-BcqDWXwi.mjs.map