@prisma/orm-target-mongo 8.0.0-rc.18-dev.28 → 8.0.0-rc.18-dev.30

package/dist/{control-CDY-DZw5.mjs → control-lAuWLUE_.mjs}

@@ -1,20 +1,20 @@
 import { t as mongoTargetError } from "./mongo-target-errors-Btf3ML1w-B5EMYbz1.mjs";
-import { t as mongoTargetDescriptorMeta } from "./descriptor-meta-BcqjYuQn-BguYOxpH.mjs";
+import { t as mongoTargetDescriptorMeta } from "./descriptor-meta-BQBreSNF-CZ9uOPwO.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-jwrORVMV-BGqJk_WT.mjs";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { type } from "arktype";
 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, modelDisplayName } from "@prisma/orm-framework/components/control";
 import { MongoSchemaCollection, MongoSchemaIR, canonicalize, deepEqual, indexLookupKey } from "@prisma/orm-family-mongo/schema-ir";
 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 { MongoCollection, MongoStorage, collectionControlPoliciesOf, collectionControlPolicyOf, collectionRootModelsOf, storedFieldNameOf, storesField, validatorFieldNamesOf, validatorRootShapesOf } from "@prisma/orm-family-mongo/contract";
 import { composeMongoEntityKinds } from "@prisma/orm-family-mongo/contract/entity-kinds";
-import { asNamespaceId, effectiveControlPolicy } from "@prisma/orm-framework/contract/types";
+import { asNamespaceId, governingControlPolicy } from "@prisma/orm-framework/contract/types";
+import { APP_SPACE_ID, VERIFY_CODE_SCHEMA_FAILURE, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, describeMigrationStatement, issueOutcome, modelDisplayName } from "@prisma/orm-framework/components/control";
 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";
@@ -399,8 +399,28 @@ function variantFilter(contract, coordinate) {
 	const value = Object.entries(baseModel?.variants ?? {}).find(([, variant]) => variant.namespace === coordinate.namespaceId && variant.model === coordinate.model)?.[0];
 	return field === void 0 || value === void 0 ? void 0 : { [field]: value };
 }
+function declaredCollection(contract, collection) {
+	return Object.values(contract.storage.namespaces).map((namespace) => namespace.entries["collection"]?.[collection]).find((entry) => entry instanceof MongoCollection);
+}
+/**
+* The control policy of `collection`. A collection the contract leaves out keeps the policy `fromContract` gave it, when that was not `managed`, so leaving an `external` collection out of the contract does not drop it.
+*/
+function collectionControlOf(contract, fromContract, collection) {
+	const declared = declaredCollection(contract, collection);
+	const original = declared === void 0 && fromContract !== null ? declaredCollection(fromContract, collection) : void 0;
+	const policy = collectionControlPolicyOf(collection, collectionControlPoliciesOf(contract));
+	if (original === void 0 || fromContract === null) return {
+		policy,
+		declared: declared?.control
+	};
+	const originalPolicy = governingControlPolicy({ explicitNodeControlPolicy: original.control }, fromContract.defaultControlPolicy);
+	return {
+		policy: originalPolicy === "managed" ? policy : originalPolicy,
+		declared: original.control
+	};
+}
 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);
+	return collectionControlOf(contract, null, collection).policy;
 }
 /** Why MongoDB would refuse a collection name, if it would. */
 function invalidCollectionNameReason(name) {
@@ -428,6 +448,65 @@ function refused(statement, label, reason, why) {
 	};
 }
 const LEAVE_OUT = "Leave out this statement.";
+const SEPARATE_THE_MODELS = "move the models to separate collections, or carry out the change in a dataTransform operation of a migration.ts, with a filter that selects only their documents";
+/**
+* The discriminator field and value a variant's filter selects, or `undefined` for a filter that selects by anything else, or no filter.
+*/
+function discriminatorValueOf(filter) {
+	const entries = Object.entries(filter ?? {});
+	if (entries.length !== 1) return void 0;
+	const [entry] = entries;
+	if (entry === void 0) return void 0;
+	const [field, value] = entry;
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? {
+		field,
+		value
+	} : void 0;
+}
+/**
+* The other models stored in `collection`, root models and their variants, whose documents a change of `storedName` with `filter` reaches, and which store the field themselves or through their base. No discriminator tells the documents of several root models apart, so without a filter, or with a base model's filter, every other root model's documents are reached. A variant's filter, one discriminator value, reaches a model only when its documents can hold that value: a variant of another root model with the same discriminator field and value, or a model that declares the discriminator field itself.
+*/
+function otherModelsReached(contract, model, collection, filter, storedName) {
+	const models = contract.domain.namespaces[model.namespaceId]?.models ?? {};
+	const baseOf = (name) => {
+		const base = models[name]?.base;
+		return base === void 0 ? void 0 : models[base.model];
+	};
+	const storesOrInherits = (name, field) => {
+		const each = models[name];
+		const base = baseOf(name);
+		return each !== void 0 && storesField(each, field) || base !== void 0 && storesField(base, field);
+	};
+	const selected = discriminatorValueOf(filter);
+	const canHold = (name) => {
+		if (selected === void 0) return true;
+		const base = baseOf(name);
+		if (base?.discriminator?.field === selected.field) return Object.entries(base.variants ?? {}).some(([value, variant]) => variant.model === name && value === selected.value);
+		return storesOrInherits(name, selected.field);
+	};
+	const subjectRoot = modelAt(contract, model)?.base?.model ?? model.model;
+	return (collectionRootModelsOf(models)[collection] ?? []).filter((name) => name !== subjectRoot).flatMap((name) => [name, ...Object.values(models[name]?.variants ?? {}).map((variant) => variant.model)]).filter((name) => canHold(name) && storesOrInherits(name, storedName));
+}
+function sharedCollectionWhy(collection, others, change) {
+	const names = others.map((name) => JSON.stringify(name)).join(", ");
+	return `Collection ${JSON.stringify(collection)} stores several models and no discriminator tells their documents apart, so ${change} of ${names} too.`;
+}
+/**
+* A removal the plan cannot carry out because another root model stored in the same collection still stores the field, and no discriminator selects the documents of the model that loses it.
+*/
+function sharedCollectionRemovalRefusals(removals, contract) {
+	return removals.flatMap((removal) => {
+		const { subject, call } = removal;
+		if (subject.kind !== "field") return [];
+		const others = otherModelsReached(contract, subject, call.collection, call.filter, call.field);
+		if (others.length === 0) return [];
+		return [{
+			kind: "fieldRemovalRefused",
+			summary: `Cannot remove field ${JSON.stringify(call.field)} of model ${JSON.stringify(subject.model)} from collection ${JSON.stringify(call.collection)}: model ${others.map((name) => JSON.stringify(name)).join(", ")} stores it in the same collection`,
+			why: `${sharedCollectionWhy(call.collection, others, "removing the field would remove it from the documents")} To keep it in ${others.map((name) => JSON.stringify(name)).join(", ")} documents only, ${SEPARATE_THE_MODELS}.`
+		}];
+	});
+}
 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
@@ -465,7 +544,14 @@ function planStatements(input) {
 			renamedCollections.set(outcome.call.from, outcome.call.to);
 			collectionRenames.push(outcome.call);
 		}
-		if (outcome.kind === "renameField") fieldRenames.push(outcome.call);
+		if (outcome.kind === "renameField") {
+			const same = fieldRenames.find((call) => sameFieldRename(call, outcome.call));
+			if (same !== void 0) {
+				callOfStatement.push(same);
+				continue;
+			}
+			fieldRenames.push(outcome.call);
+		}
 		callOfStatement.push(outcome.kind === "unchanged" ? void 0 : outcome.call);
 	}
 	return conflicts.length > 0 ? notOk(conflicts) : ok({
@@ -475,6 +561,10 @@ function planStatements(input) {
 		callOfStatement
 	});
 }
+/** Whether two field renames rewrite the same documents the same way, as when every root model of a shared collection renames a field together. */
+function sameFieldRename(a, b) {
+	return a.collection === b.collection && a.from === b.from && a.to === b.to && JSON.stringify(a.filter) === JSON.stringify(b.filter);
+}
 function renameInSchema(schema, from, to) {
 	return new MongoSchemaIR(schema.collections.map((collection) => collection.name === from ? new MongoSchemaCollection({
 		name: to,
@@ -556,7 +646,12 @@ function planFieldStatement(statement, label, renamedCollections, schema, input)
 	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;
+	const variant = variantFilter(input.fromContract, statement.from);
+	const fromModel = modelAt(input.fromContract, statement.from);
+	const renamedTogether = new Set(input.statements.flatMap((other) => other.entity === "field" && other.from.namespaceId === statement.from.namespaceId && other.from.field === statement.from.field && other.to.field === statement.to.field ? [other.from.model] : []));
+	const others = otherModelsReached(input.fromContract, statement.from, originCollection, variant, fromModel === void 0 ? statement.from.field : storedFieldNameOf(fromModel, statement.from.field)).filter((name) => !renamedTogether.has(name));
+	if (others.length > 0) return refuse(`model ${others.map((name) => JSON.stringify(name)).join(", ")} stores field ${JSON.stringify(statement.from.field)} in the same collection, ${JSON.stringify(collection)}`, `${sharedCollectionWhy(collection, others, "renaming the field would rename it in the documents")} To change it, ${SEPARATE_THE_MODELS}.`);
+	const filter = variant ?? rootDocumentsLosing(input.contract, statement.to, statement.from.field)?.filter;
 	return {
 		kind: "renameField",
 		call: new RenameFieldCall(collection, statement.from.field, statement.to.field, filter)
@@ -664,28 +759,17 @@ function planFieldRemovals(input) {
 		});
 	});
 }
-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.
+* Without an origin contract, a field is known removed when the origin validator declares it for a
+* root model 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) => ({
+		const kept = validatorFieldNamesOf(destination.validator.jsonSchema);
+		return [...new Set(validatorRootShapesOf(originCollection.validator.jsonSchema).flatMap((root) => Object.keys(root.properties)))].filter((field) => unrewritableFieldNameReason(field) === void 0 && !kept.has(field)).sort().map((field) => ({
 			call: new UnsetFieldCall(originCollection.name, field),
 			subject: {
 				kind: "storage",
@@ -852,35 +936,6 @@ 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 validatorsEqual(a, b) {
 	if (!a && !b) return true;
 	if (!a || !b) return false;
@@ -889,8 +944,11 @@ function validatorsEqual(a, b) {
 function isPlainObject(v) {
 	return typeof v === "object" && v !== null && !Array.isArray(v);
 }
+/** Each field a root model of the validator declares, with the distinct schemas the root models give it, in canonical form. */
 function propertiesOf(schema) {
-	return isPlainObject(schema["properties"]) ? schema["properties"] : {};
+	const schemas = /* @__PURE__ */ new Map();
+	for (const root of validatorRootShapesOf(schema)) for (const [field, fieldSchema] of Object.entries(root.properties)) schemas.set(field, (schemas.get(field) ?? /* @__PURE__ */ new Set()).add(canonicalize(fieldSchema)));
+	return Object.fromEntries([...schemas].map(([field, distinct]) => [field, [...distinct].sort().join("|")]));
 }
 /**
 * A label naming the properties whose schema changed, so a dry run shows what a validator update does: `Update validator on items (changed: meta; added: note)`.
@@ -898,7 +956,7 @@ function propertiesOf(schema) {
 function validatorUpdateLabel(collName, origin, dest) {
 	const originProps = propertiesOf(origin.jsonSchema);
 	const destProps = propertiesOf(dest.jsonSchema);
-	const changed = Object.keys(destProps).filter((field) => Object.hasOwn(originProps, field) && canonicalize(originProps[field]) !== canonicalize(destProps[field]));
+	const changed = Object.keys(destProps).filter((field) => Object.hasOwn(originProps, field) && originProps[field] !== destProps[field]);
 	const added = Object.keys(destProps).filter((field) => !Object.hasOwn(originProps, field));
 	const removed = Object.keys(originProps).filter((field) => !Object.hasOwn(destProps, field));
 	const parts = [
@@ -1011,6 +1069,72 @@ 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;
 }
+function callsOf(diff) {
+	return [
+		...diff.collCreates,
+		...diff.drops,
+		...diff.creates,
+		...diff.validatorOps,
+		...diff.mutableOptionOps,
+		...diff.collDrops
+	];
+}
+function planCollectionDiff(collName, originColl, destColl) {
+	const collCreates = [];
+	const drops = [];
+	const creates = [];
+	const validatorOps = [];
+	const mutableOptionOps = [];
+	const collDrops = [];
+	const conflicts = [];
+	if (!originColl) {
+		if (destColl && (collectionHasOptions(destColl) || destColl.indexes.length === 0)) {
+			const opts = collectionHasOptions(destColl) ? schemaCollectionToCreateCollectionOptions(destColl) : void 0;
+			collCreates.push(new CreateCollectionCall(collName, opts));
+		}
+	} else if (!destColl) collDrops.push(new DropCollectionCall(collName));
+	else {
+		const immutableChange = hasImmutableOptionChange(originColl.options, destColl.options);
+		if (immutableChange) conflicts.push({
+			kind: "policy-violation",
+			summary: `Cannot change immutable collection option '${immutableChange}' on ${collName}`,
+			why: `MongoDB does not support modifying the '${immutableChange}' option after collection creation`
+		});
+		const mutableCall = planMutableOptionsDiffCall(collName, originColl.options, destColl.options);
+		if (mutableCall) mutableOptionOps.push(mutableCall);
+		const validatorCall = planValidatorDiffCall(collName, originColl.validator, destColl.validator);
+		if (validatorCall) validatorOps.push(validatorCall);
+	}
+	const originLookup = /* @__PURE__ */ new Map();
+	if (originColl) for (const idx of originColl.indexes) originLookup.set(indexLookupKey(idx), idx);
+	const destLookup = /* @__PURE__ */ new Map();
+	if (destColl) for (const idx of destColl.indexes) destLookup.set(indexLookupKey(idx), idx);
+	for (const [lookupKey, idx] of originLookup) if (!destLookup.has(lookupKey)) drops.push(new DropIndexCall(collName, idx.keys));
+	for (const [lookupKey, idx] of destLookup) if (!originLookup.has(lookupKey)) creates.push(new CreateIndexCall(collName, idx.keys, schemaIndexToCreateIndexOptions(idx)));
+	return {
+		collCreates,
+		drops,
+		creates,
+		validatorOps,
+		mutableOptionOps,
+		collDrops,
+		conflicts
+	};
+}
+/**
+* The warning for a change a collection's control policy left out of the plan, worded as the Postgres planner words a suppressed call.
+*/
+function suppressedCallWarning(call, collection, control) {
+	const declared = control.declared !== void 0 && control.declared !== control.policy ? ` but declared '${control.declared}'` : "";
+	return {
+		kind: "controlPolicySuppressedCall",
+		summary: `control policy suppressed: ${call.label} — collection "${collection}" has effective control '${control.policy}'${declared}`,
+		meta: {
+			controlPolicy: control.policy,
+			...ifDefined("declaredControlPolicy", control.declared)
+		}
+	};
+}
 var MongoMigrationPlanner = class {
 	planCalls(options) {
 		const contract = blindCast(options.contract);
@@ -1023,34 +1147,23 @@ var MongoMigrationPlanner = class {
 		const mutableOptionOps = [];
 		const collDrops = [];
 		const conflicts = [];
+		const warnings = [];
 		const allCollectionNames = /* @__PURE__ */ new Set([...originIR.collectionNames, ...destinationIR.collectionNames]);
 		for (const collName of [...allCollectionNames].sort()) {
 			const originColl = originIR.collection(collName);
-			const destColl = destinationIR.collection(collName);
-			if (!originColl) {
-				if (destColl && (collectionHasOptions(destColl) || destColl.indexes.length === 0)) {
-					const opts = collectionHasOptions(destColl) ? schemaCollectionToCreateCollectionOptions(destColl) : void 0;
-					collCreates.push(new CreateCollectionCall(collName, opts));
-				}
-			} else if (!destColl) collDrops.push(new DropCollectionCall(collName));
-			else {
-				const immutableChange = hasImmutableOptionChange(originColl.options, destColl.options);
-				if (immutableChange) conflicts.push({
-					kind: "policy-violation",
-					summary: `Cannot change immutable collection option '${immutableChange}' on ${collName}`,
-					why: `MongoDB does not support modifying the '${immutableChange}' option after collection creation`
-				});
-				const mutableCall = planMutableOptionsDiffCall(collName, originColl.options, destColl.options);
-				if (mutableCall) mutableOptionOps.push(mutableCall);
-				const validatorCall = planValidatorDiffCall(collName, originColl.validator, destColl.validator);
-				if (validatorCall) validatorOps.push(validatorCall);
+			const planned = planCollectionDiff(collName, originColl, destinationIR.collection(collName));
+			const control = collectionControlOf(contract, options.fromContract, collName);
+			if (!plansChangesTo(control.policy, originColl !== void 0)) {
+				warnings.push(...callsOf(planned).map((call) => suppressedCallWarning(call, collName, control)));
+				continue;
 			}
-			const originLookup = /* @__PURE__ */ new Map();
-			if (originColl) for (const idx of originColl.indexes) originLookup.set(indexLookupKey(idx), idx);
-			const destLookup = /* @__PURE__ */ new Map();
-			if (destColl) for (const idx of destColl.indexes) destLookup.set(indexLookupKey(idx), idx);
-			for (const [lookupKey, idx] of originLookup) if (!destLookup.has(lookupKey)) drops.push(new DropIndexCall(collName, idx.keys));
-			for (const [lookupKey, idx] of destLookup) if (!originLookup.has(lookupKey)) creates.push(new CreateIndexCall(collName, idx.keys, schemaIndexToCreateIndexOptions(idx)));
+			collCreates.push(...planned.collCreates);
+			drops.push(...planned.drops);
+			creates.push(...planned.creates);
+			validatorOps.push(...planned.validatorOps);
+			mutableOptionOps.push(...planned.mutableOptionOps);
+			collDrops.push(...planned.collDrops);
+			conflicts.push(...planned.conflicts);
 		}
 		if (conflicts.length > 0) return {
 			kind: "failure",
@@ -1078,7 +1191,8 @@ var MongoMigrationPlanner = class {
 		};
 		return {
 			kind: "success",
-			calls: allCalls
+			calls: allCalls,
+			warnings
 		};
 	}
 	plan(options) {
@@ -1115,14 +1229,7 @@ var MongoMigrationPlanner = class {
 			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: renames,
-			callOfStatement,
-			removals
-		})];
+		const removalRefusals = [...timeSeriesRemovalRefusals(removals, schema), ...sharedCollectionRemovalRefusals(removals, contract)];
 		if (removalRefusals.length > 0) return {
 			kind: "failure",
 			conflicts: removalRefusals
@@ -1136,7 +1243,7 @@ var MongoMigrationPlanner = class {
 			}
 		});
 		if (result.kind === "failure") return result;
-		const { calls } = result;
+		const { calls, warnings } = result;
 		const fieldLoss = removals.map((removal) => ({
 			operationIndex: calls.indexOf(removal.call),
 			subject: removal.subject,
@@ -1161,7 +1268,8 @@ var MongoMigrationPlanner = class {
 				destination: destinationIR
 			}), ...fieldLoss].sort((a, b) => a.operationIndex - b.operationIndex),
 			accessWidening: [],
-			temporaryValues: []
+			temporaryValues: [],
+			...warnings.length > 0 ? { warnings } : {}
 		};
 	}
 	/**
@@ -1180,6 +1288,14 @@ var MongoMigrationPlanner = class {
 		}, context.snapshotsImportPath);
 	}
 };
+function plansChangesTo(policy, collectionExists) {
+	switch (policy) {
+		case "managed": return true;
+		case "tolerated": return !collectionExists;
+		case "external":
+		case "observed": return false;
+	}
+}
 function planValidatorDiffCall(collName, originValidator, destValidator) {
 	if (validatorsEqual(originValidator, destValidator)) return void 0;
 	if (destValidator) return new CollModCall(collName, {
@@ -2244,4 +2360,4 @@ const mongoTargetDescriptor = {
 //#endregion
 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-CDY-DZw5.mjs.map
+//# sourceMappingURL=control-lAuWLUE_.mjs.map