@prisma/orm-target-mongo 8.0.0-rc.2-dev.3 → 8.0.0-rc.20

package/dist/control-Cq6qWohQ.mjs

@@ -0,0 +1,2421 @@
+import { t as mongoTargetError } from "./mongo-target-errors-Btf3ML1w-QOtEG7EX.mjs";
+import { t as mongoTargetDescriptorMeta } from "./descriptor-meta-DTj807jv-CjvK2XDD.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-BqROEHRs-CfExMr9r.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 { 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 { APP_SPACE_ID, VERIFY_CODE_SCHEMA_FAILURE, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, describeMigrationStatement, expectAbsent, expectPresent, failedPostcheckWhy, failedPrecheckWhy, issueOutcome, migrationRunnerFailure, modelDisplayName, schemaCheckWhy, withDatabaseUnchanged, withFailingSpace } from "@prisma/orm-framework/components/control";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { MongoContractSerializerBase, MongoSchemaVerifierBase } from "@prisma/orm-family-mongo/family/ir";
+import { MongoCollection, MongoStorage, collectionControlPoliciesOf, collectionControlPolicyOf, collectionRootModelsOf, hasOwnFieldStoredAs, modelAndBasesOf, mongoModelsOf, ownEmbedStoredNamesOf, ownStoredNameOf, ownStoredNamesOf, validatorFieldNamesOf, validatorRootShapesOf } from "@prisma/orm-family-mongo/contract";
+import { composeMongoEntityKinds } from "@prisma/orm-family-mongo/contract/entity-kinds";
+import { asNamespaceId, governingControlPolicy } from "@prisma/orm-framework/contract/types";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+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";
+import { detectScaffoldRuntime, shebangLineFor } from "@prisma/orm-toolchain/migration-tools/migration-ts";
+import { verifyMongoSchema } from "@prisma/orm-family-mongo/family/schema-verify";
+//#region ../../../3-targets/mongo/1-target/dist/control.mjs
+/**
+* Mongo target `Namespace` concretion. In Mongo the "namespace" concept
+* binds to the connection's `db` field — a `MongoTargetDatabase` instance
+* names the database the collections live under. `entries['collection']`
+* holds collection IR. The unbound singleton (below) is the late-bound
+* namespace whose binding the connection's `db` resolves at runtime rather
+* than at authoring time.
+*
+* Qualifier emission is the rendering seam: query / DDL emission asks the
+* namespace for its qualifier (e.g. `"<db>.<collection>"`) and consumes
+* the result polymorphically. The unbound singleton overrides these
+* methods to elide the prefix entirely — call sites stay polymorphic and
+* never branch on `id === UNBOUND_NAMESPACE_ID`.
+*/
+var MongoTargetDatabase = class extends NamespaceBase {
+	id;
+	entries;
+	constructor(input) {
+		super();
+		this.id = input.id;
+		const rawEntries = {
+			collection: {},
+			...input.entries
+		};
+		this.entries = Object.freeze(blindCast(hydrateNamespaceEntities(rawEntries, composeMongoEntityKinds(), "carry")));
+		Object.defineProperty(this, "kind", {
+			value: "database",
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+		freezeNode(this);
+	}
+	get collection() {
+		return this.entries.collection ?? Object.freeze({});
+	}
+	/**
+	* The bare qualifier as it would appear in a rendered string. The
+	* unbound-database singleton overrides this to return `''`.
+	*/
+	qualifier() {
+		return this.id;
+	}
+	/**
+	* Qualify a collection name with the database prefix. The
+	* unbound-database singleton overrides this to emit just the
+	* collection name. Used by emission/introspection paths that need a
+	* fully-qualified reference.
+	*/
+	qualifyCollection(collectionName) {
+		return `${this.id}.${collectionName}`;
+	}
+};
+/**
+* Singleton subclass for the reserved sentinel namespace id
+* (`UNBOUND_NAMESPACE_ID`) — the late-bound namespace whose binding the
+* connection's `db` resolves at runtime. Overrides qualifier emission
+* to elide the database prefix; call sites that consume `qualifier()`
+* / `qualifyCollection()` get unqualified output without branching on
+* the namespace id.
+*
+* This is the target-side materialization of "the framework provides
+* affordances; targets implement specifics": the framework names the
+* sentinel; Mongo decides what late-bound means here (the collection
+* name, naked — the database is supplied by the live connection).
+*/
+var MongoTargetUnboundDatabase = class MongoTargetUnboundDatabase extends MongoTargetDatabase {
+	static instance = new MongoTargetUnboundDatabase();
+	constructor() {
+		super({ id: UNBOUND_NAMESPACE_ID });
+	}
+	qualifier() {
+		return "";
+	}
+	qualifyCollection(collectionName) {
+		return collectionName;
+	}
+};
+var MongoTargetContractSerializer = class extends MongoContractSerializerBase {
+	constructTargetContract(validated) {
+		const { storage, ...rest } = validated;
+		const namespaces = Object.fromEntries(Object.entries(storage.namespaces).map(([nsId, nsData]) => {
+			const collectionCount = Object.keys(nsData.entries.collection ?? {}).length;
+			const valueSetCount = Object.keys(nsData.entries["valueSet"] ?? {}).length;
+			if (nsId === UNBOUND_NAMESPACE_ID && collectionCount === 0 && valueSetCount === 0) return [nsId, MongoTargetUnboundDatabase.instance];
+			const dbInput = { id: nsData.id };
+			if (nsData.entries["collection"] !== void 0 || nsData.entries["valueSet"] !== void 0) dbInput.entries = {
+				collection: blindCast(nsData.entries["collection"] ?? {}),
+				...ifDefined("valueSet", blindCast(nsData.entries["valueSet"]))
+			};
+			return [nsId, new MongoTargetDatabase(dbInput)];
+		}));
+		const targetStorage = new MongoStorage({
+			storageHash: storage.storageHash,
+			namespaces
+		});
+		return {
+			...rest,
+			storage: targetStorage
+		};
+	}
+	serializeContract(contract) {
+		const { storage, ...rest } = contract;
+		const namespacesJson = {};
+		for (const [nsId, ns] of Object.entries(storage.namespaces)) {
+			const collectionsOut = {};
+			for (const [collName, coll] of Object.entries(ns.entries.collection ?? {})) collectionsOut[collName] = blindCast(JSON.parse(JSON.stringify(coll)));
+			const valueSetOut = {};
+			for (const [vsName, vs] of Object.entries(ns.entries.valueSet ?? {})) valueSetOut[vsName] = blindCast(JSON.parse(JSON.stringify(vs)));
+			namespacesJson[nsId] = {
+				id: ns.id,
+				kind: "mongo-database",
+				entries: {
+					collection: collectionsOut,
+					...ifDefined("valueSet", Object.keys(valueSetOut).length > 0 ? valueSetOut : void 0)
+				}
+			};
+		}
+		return blindCast({
+			...rest,
+			storage: {
+				storageHash: String(storage.storageHash),
+				namespaces: namespacesJson
+			}
+		});
+	}
+};
+/**
+* The single module a scaffolded Mongo `migration.ts` imports from: the
+* operation factories below, plus the `Migration` base and `MigrationCLI`
+* that `render-typescript.ts` adds. The authored name; `render-typescript.ts`
+* maps it to whatever the consuming application's import root calls it,
+* once over the whole assembled import list.
+*/
+const TARGET_MIGRATION_MODULE = "@internal/target-mongo/migration";
+var OpFactoryCallNode = class extends TsExpression {
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: this.factoryName
+		}];
+	}
+	freeze() {
+		Object.freeze(this);
+	}
+};
+function formatKeys(keys) {
+	return keys.map((k) => `${k.field}:${k.direction}`).join(", ");
+}
+var CreateIndexCall = class extends OpFactoryCallNode {
+	factoryName = "createIndex";
+	operationClass = "additive";
+	collection;
+	keys;
+	options;
+	label;
+	constructor(collection, keys, options) {
+		super();
+		this.collection = collection;
+		this.keys = keys;
+		this.options = options;
+		this.label = `Create index on ${collection} (${formatKeys(keys)})`;
+		this.freeze();
+	}
+	toOp() {
+		return createIndex(this.collection, this.keys, this.options);
+	}
+	renderTypeScript() {
+		return this.options ? `createIndex(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.keys)}, ${jsonToTsSource(this.options)})` : `createIndex(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.keys)})`;
+	}
+};
+var DropIndexCall = class extends OpFactoryCallNode {
+	factoryName = "dropIndex";
+	operationClass = "widening";
+	collection;
+	keys;
+	label;
+	constructor(collection, keys) {
+		super();
+		this.collection = collection;
+		this.keys = keys;
+		this.label = `Drop index on ${collection} (${formatKeys(keys)})`;
+		this.freeze();
+	}
+	toOp() {
+		return dropIndex(this.collection, this.keys);
+	}
+	renderTypeScript() {
+		return `dropIndex(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.keys)})`;
+	}
+};
+var CreateCollectionCall = class extends OpFactoryCallNode {
+	factoryName = "createCollection";
+	operationClass = "additive";
+	collection;
+	options;
+	label;
+	constructor(collection, options) {
+		super();
+		this.collection = collection;
+		this.options = options;
+		this.label = `Create collection ${collection}`;
+		this.freeze();
+	}
+	toOp() {
+		return createCollection(this.collection, this.options);
+	}
+	renderTypeScript() {
+		return this.options ? `createCollection(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.options)})` : `createCollection(${jsonToTsSource(this.collection)})`;
+	}
+};
+var DropCollectionCall = class extends OpFactoryCallNode {
+	factoryName = "dropCollection";
+	operationClass = "destructive";
+	collection;
+	label;
+	constructor(collection) {
+		super();
+		this.collection = collection;
+		this.label = `Drop collection ${collection}`;
+		this.freeze();
+	}
+	toOp() {
+		return dropCollection(this.collection);
+	}
+	renderTypeScript() {
+		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;
+	options;
+	meta;
+	operationClass;
+	label;
+	constructor(collection, options, meta) {
+		super();
+		this.collection = collection;
+		this.options = options;
+		this.meta = meta;
+		this.operationClass = meta?.operationClass ?? "widening";
+		this.label = meta?.label ?? `Modify collection ${collection}`;
+		this.freeze();
+	}
+	toOp() {
+		return collMod(this.collection, this.options, this.meta);
+	}
+	renderTypeScript() {
+		return this.meta ? `collMod(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.options)}, ${jsonToTsSource(this.meta)})` : `collMod(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.options)})`;
+	}
+};
+function schemaIndexToCreateIndexOptions(index) {
+	return {
+		...index.unique ? { unique: true } : {},
+		...ifDefined("sparse", index.sparse),
+		...ifDefined("expireAfterSeconds", index.expireAfterSeconds),
+		...ifDefined("partialFilterExpression", index.partialFilterExpression),
+		...ifDefined("wildcardProjection", index.wildcardProjection),
+		...ifDefined("collation", index.collation),
+		...ifDefined("weights", index.weights),
+		...ifDefined("default_language", index.default_language),
+		...ifDefined("language_override", index.language_override)
+	};
+}
+function schemaCollectionToCreateCollectionOptions(coll) {
+	const opts = coll.options;
+	const validator = coll.validator;
+	if (!opts && !validator) return void 0;
+	return {
+		...opts?.capped ? { capped: true } : {},
+		...ifDefined("size", opts?.capped?.size),
+		...ifDefined("max", opts?.capped?.max),
+		...ifDefined("timeseries", opts?.timeseries),
+		...ifDefined("collation", opts?.collation),
+		...opts?.clusteredIndex ? { clusteredIndex: {
+			key: { _id: 1 },
+			unique: true,
+			...opts.clusteredIndex.name != null ? { name: opts.clusteredIndex.name } : {}
+		} } : {},
+		...validator ? { validator: { $jsonSchema: validator.jsonSchema } } : {},
+		...ifDefined("validationLevel", validator?.validationLevel),
+		...ifDefined("validationAction", validator?.validationAction),
+		...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 models = mongoModelsOf(contract.domain, coordinate.namespaceId);
+	return Object.hasOwn(models, coordinate.model) ? models[coordinate.model] : void 0;
+}
+/** The stored name of `field` of the model at `coordinate`, or undefined when the model does not declare it. */
+function storedFieldNameAt(contract, coordinate) {
+	const model = modelAt(contract, coordinate);
+	return model === void 0 || !Object.hasOwn(model.fields, coordinate.field) ? void 0 : ownStoredNameOf(model, coordinate.field);
+}
+/** The stored name of a field the statement's resolution found on the model at `coordinate`. */
+function resolvedStoredNameAt(contract, coordinate) {
+	const storedName = storedFieldNameAt(contract, coordinate);
+	if (storedName === void 0) throw new InternalError(`Field "${coordinate.model}.${coordinate.field}" a statement names has no stored name`);
+	return storedName;
+}
+/**
+* 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 = modelAt(contract, {
+		namespaceId: asNamespaceId(base.namespace),
+		model: base.model
+	});
+	const field = baseModel?.discriminator?.field;
+	const value = Object.entries(baseModel?.variants ?? {}).find(([, variant]) => variant.namespace === coordinate.namespaceId && variant.model === coordinate.model)?.[0];
+	return baseModel === void 0 || field === void 0 || value === void 0 ? void 0 : { [ownStoredNameOf(baseModel, 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 collectionControlOf(contract, null, collection).policy;
+}
+/** 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 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 = mongoModelsOf(contract.domain, model.namespaceId);
+	const baseOf = (name) => {
+		const base = models[name]?.base;
+		return base === void 0 ? void 0 : models[base.model];
+	};
+	const storesOrInherits = (name, storedName) => modelAndBasesOf(models, name).some((each) => ownStores(each, storedName));
+	const selected = discriminatorValueOf(filter);
+	const canHold = (name) => {
+		if (selected === void 0) return true;
+		const base = baseOf(name);
+		const discriminator = base?.discriminator?.field;
+		if (base !== void 0 && discriminator !== void 0 && ownStoredNameOf(base, discriminator) === 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
+* 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 === "namespace" ? {
+			kind: "refused",
+			conflict: refused(statement, label, "MongoDB does not rename namespaces in this release", LEAVE_OUT)
+		} : 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") {
+			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({
+		schema,
+		collectionRenames,
+		fieldRenames,
+		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,
+		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}`);
+	const fromStored = resolvedStoredNameAt(input.fromContract, statement.from);
+	const toStored = resolvedStoredNameAt(input.contract, statement.to);
+	const originCollection = collectionOf(input.fromContract, statement.from);
+	const collection = renamedCollections.get(originCollection) ?? originCollection;
+	const destinationCollection = collectionOf(input.contract, statement.to);
+	if (fromStored === toStored && collection === destinationCollection) return { kind: "unchanged" };
+	if (fromStored === "_id" || toStored === "_id") return refuse("it renames _id", `MongoDB does not let a document change its _id. ${LEAVE_OUT}`);
+	const unsafeFrom = unrewritableFieldNameReason(fromStored);
+	if (unsafeFrom !== void 0) return refuse(`the stored name "${fromStored}" cannot be rewritten`, `${unsafeFrom}, so a statement cannot move its values. Rename it in the database yourself, or ${LEAVE_OUT.toLowerCase()}`);
+	const unsafeTo = unrewritableFieldNameReason(toStored);
+	if (unsafeTo !== void 0) return refuse(`the stored name "${toStored}" cannot be written`, `${unsafeTo}. Give the field a stored name without "." that does not start with "$" (with @map), or ${LEAVE_OUT.toLowerCase()}`);
+	if (collection !== destinationCollection) return refuse(`the model's collection changes from "${originCollection}" to "${destinationCollection}", and no statement renames it`, collectionChangeAdvice(statement, originCollection, destinationCollection));
+	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: store the field as ${JSON.stringify(fromStored)} (with @map(${JSON.stringify(fromStored)}) 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 variant = variantFilter(input.fromContract, statement.from);
+	const renamedTogether = new Set(input.statements.flatMap((other) => other.entity === "field" && other.from.namespaceId === statement.from.namespaceId && storedFieldNameAt(input.fromContract, other.from) === fromStored && storedFieldNameAt(input.contract, other.to) === toStored ? [other.from.model] : []));
+	const others = otherModelsReached(input.fromContract, statement.from, originCollection, variant, fromStored).filter((name) => !renamedTogether.has(name));
+	if (others.length > 0) return refuse(`model ${others.map((name) => JSON.stringify(name)).join(", ")} stores field ${JSON.stringify(fromStored)} 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}.`);
+	return {
+		kind: "renameField",
+		call: new RenameFieldCall(collection, fromStored, toStored, variant ?? rootDocumentsLosing(input.contract, statement.to, fromStored)?.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);
+}
+/** Whether one of `model`'s own fields or embed relations is stored under `storedName`. */
+function ownStores(model, storedName) {
+	return hasOwnFieldStoredAs(model, storedName) || Object.values(ownEmbedStoredNamesOf(model)).includes(storedName);
+}
+/** The stored names of the documents of the model at `coordinate`: its fields and embed relations, its own and those it inherits. */
+function storedFieldsOf(contract, coordinate) {
+	const models = mongoModelsOf(contract.domain, coordinate.namespaceId);
+	return new Set(modelAndBasesOf(models, coordinate.model).flatMap((model) => [...Object.values(ownStoredNamesOf(model)), ...Object.values(ownEmbedStoredNamesOf(model))]));
+}
+/**
+* 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, storedName) {
+	const model = modelAt(contract, root);
+	if (model === void 0 || ownStores(model, storedName)) return void 0;
+	const discriminator = model.discriminator?.field;
+	const keeping = Object.entries(model.variants ?? {}).filter(([, variant]) => {
+		const variantModel = modelAt(contract, {
+			namespaceId: variant.namespace,
+			model: variant.model
+		});
+		return variantModel !== void 0 && ownStores(variantModel, storedName);
+	}).map(([value]) => value).sort();
+	if (discriminator === void 0 || keeping.length === 0) return { filter: void 0 };
+	return { filter: { [ownStoredNameOf(model, 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 = (storedName) => {
+			if (variant !== void 0) return storedFieldsOf(input.contract, destination).has(storedName) ? void 0 : { filter: variant };
+			return rootDocumentsLosing(input.contract, destination, storedName);
+		};
+		return Object.entries(ownStoredNamesOf(model)).filter(([field, storedName]) => unrewritableFieldNameReason(storedName) === void 0 && !renamedByStatement(input, {
+			...origin,
+			field
+		})).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).flatMap(([field, storedName]) => {
+			const lost = losing(storedName);
+			return lost === void 0 ? [] : [{
+				call: new UnsetFieldCall(collection, storedName, lost.filter),
+				subject: {
+					kind: "field",
+					...origin,
+					field
+				}
+			}];
+		});
+	});
+}
+/**
+* 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 = 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",
+				name: `${originCollection.name}.${field}`
+			}
+		}));
+	});
+}
+function renderOps(calls) {
+	return calls.map((call) => call.toOp());
+}
+/**
+* Always-present base imports for the rendered scaffold, both from the
+* target's own `migration` entry:
+*
+* - `Migration` — the user-facing Mongo `Migration` base, forwarded from
+*   `@internal/family-mongo`; subclasses don't need to redeclare
+*   `targetId` or thread family/target generics.
+* - `MigrationCLI` — the migration-file CLI entrypoint that loads
+*   `prisma.config.ts`, assembles a `ControlStack`, and instantiates
+*   the migration class. The migration file owns this dependency directly:
+*   pulling CLI machinery in at script run time is acceptable because the
+*   script's whole purpose is to be invoked from the project that owns the
+*   config.
+*
+* Naming one package rather than three is what lets an application that
+* installed only `@prisma/orm-mongo` run a scaffolded migration: emitted
+* code may name only a direct dependency (ADR 242), and the facade carries
+* the target's `migration` entry but neither the family base nor the CLI.
+*/
+const BASE_IMPORTS = [{
+	moduleSpecifier: TARGET_MIGRATION_MODULE,
+	symbol: "Migration"
+}, {
+	moduleSpecifier: TARGET_MIGRATION_MODULE,
+	symbol: "MigrationCLI"
+}];
+/**
+* Render a list of Mongo `OpFactoryCall`s as a `migration.ts` source string.
+* The result is shebanged, imports the contract JSON from the shared
+* snapshot store (the destination contract, plus the source contract for a
+* non-baseline migration), extends `Migration<Start, End>` (or
+* `Migration<never, End>` for a baseline) from
+* `@internal/target-mongo/migration`,
+* assigns the JSON to `endContractJson` / `startContractJson`, and implements
+* `operations`. The `Migration` base derives `describe()` from those fields.
+*
+* The walk is polymorphic: each call node contributes its own
+* `renderTypeScript()` expression and declares its own `importRequirements()`.
+* The top-level renderer aggregates imports across all nodes and emits one
+* `import { … } from "…"` line per module. The `Migration` / `MigrationCLI`
+* base imports and the contract-JSON imports are always emitted, independent
+* of the call nodes.
+*/
+function renderCallsToTypeScript(calls, meta) {
+	const imports = buildImports(calls, meta);
+	const operationsBody = calls.map((c) => c.renderTypeScript()).join(",\n");
+	const hasStart = meta.from !== null;
+	const startField = hasStart ? ["  override readonly startContractJson = startContract;"] : [];
+	return [
+		shebangLineFor(detectScaffoldRuntime()),
+		imports,
+		"",
+		`class M extends Migration<${hasStart ? "Start" : "never"}, End> {`,
+		...startField,
+		"  override readonly endContractJson = endContract;",
+		"",
+		"  override get operations() {",
+		"    return [",
+		indent(operationsBody, 6),
+		"    ];",
+		"  }",
+		"}",
+		"",
+		"export default M;",
+		"MigrationCLI.run(import.meta.url, M);",
+		""
+	].join("\n");
+}
+function buildImports(calls, meta) {
+	const requirements = [...BASE_IMPORTS, ...contractImports(meta)];
+	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
+	return renderImports(resolveRequirementSpecifiers(requirements, meta.resolveImportSpecifier));
+}
+/**
+* The committed contract-JSON imports the scaffold reads its from/to identity
+* from, resolved to the deduplicated snapshot store under
+* `meta.snapshotsImportPath`. The end snapshot is always present; the start
+* snapshot is added only for a non-baseline migration (`meta.from !== null`).
+* The matching `Contract` type imports (aliased `Start`/`End`) feed the
+* `Migration<Start, End>` generics. Baseline emits `Migration<never, End>` with
+* no start imports — `never` is the honest "no prior contract" Start.
+*/
+function contractImports(meta) {
+	const reqs = [{
+		moduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.to),
+		symbol: "endContract",
+		kind: "default",
+		attributes: { type: "json" }
+	}, {
+		moduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.to),
+		symbol: "Contract",
+		alias: "End",
+		typeOnly: true
+	}];
+	if (meta.from !== null) {
+		reqs.push({
+			moduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.from),
+			symbol: "startContract",
+			kind: "default",
+			attributes: { type: "json" }
+		});
+		reqs.push({
+			moduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.from),
+			symbol: "Contract",
+			alias: "Start",
+			typeOnly: true
+		});
+	}
+	return reqs;
+}
+function indent(text, spaces) {
+	const pad = " ".repeat(spaces);
+	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : line).join("\n");
+}
+/**
+* Planner-produced Mongo migration, returned by `MongoMigrationPlanner.plan(...)`
+* and `MongoMigrationPlanner.emptyMigration(...)`.
+*
+* Unlike user-authored migrations (which extend `MongoMigration` from
+* `@internal/family-mongo`), this class lives inside the target and holds
+* the richer authoring IR (`OpFactoryCall[]`) needed to render itself back to
+* TypeScript source. It implements `MigrationPlanWithAuthoringSurface` so
+* that the CLI can uniformly ask any planner result to serialize itself to a
+* `migration.ts`.
+*
+* It extends the framework `Migration` base directly and declares its own
+* `targetId` rather than inheriting `MongoMigration`, whose added value is
+* the lazily-built contract views a planner result never reads.
+*/
+var PlannerProducedMongoMigration = class extends Migration {
+	calls;
+	meta;
+	snapshotsImportPath;
+	targetId = "mongo";
+	constructor(calls, meta, snapshotsImportPath) {
+		super();
+		this.calls = calls;
+		this.meta = meta;
+		this.snapshotsImportPath = snapshotsImportPath;
+	}
+	get operations() {
+		return renderOps(this.calls);
+	}
+	describe() {
+		return this.meta;
+	}
+	renderTypeScript(resolveImportSpecifier) {
+		return renderCallsToTypeScript(this.calls, {
+			from: this.meta.from,
+			to: this.meta.to,
+			snapshotsImportPath: this.snapshotsImportPath,
+			resolveImportSpecifier
+		});
+	}
+};
+function validatorsEqual(a, b) {
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	return a.validationLevel === b.validationLevel && a.validationAction === b.validationAction && canonicalize(a.jsonSchema) === canonicalize(b.jsonSchema);
+}
+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) {
+	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)`.
+*/
+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) && 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 = [
+		...changed.length > 0 ? [`changed: ${changed.join(", ")}`] : [],
+		...added.length > 0 ? [`added: ${added.join(", ")}`] : [],
+		...removed.length > 0 ? [`removed: ${removed.join(", ")}`] : []
+	];
+	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(withoutServerFilled("timeseries", origin?.timeseries, dest?.timeseries)) !== canonicalize(dest?.timeseries)) return "timeseries";
+	if (canonicalize(origin?.collation) !== canonicalize(dest?.collation)) return "collation";
+	if (canonicalize(withoutServerFilled("clusteredIndex", origin?.clusteredIndex, dest?.clusteredIndex)) !== canonicalize(dest?.clusteredIndex)) return "clusteredIndex";
+}
+function collectionHasOptions(coll) {
+	return !!(coll.options || coll.validator);
+}
+/**
+* The model of `fromContract` that stores its documents in `collection`, if any: the root model
+* when variants share the collection with it.
+*/
+function modelStoredIn(fromContract, collection) {
+	const storing = Object.entries(fromContract.domain.namespaces).flatMap(([namespaceId, namespace]) => Object.entries(namespace.models).flatMap(([model, definition]) => {
+		const coordinate = {
+			namespaceId: asNamespaceId(namespaceId),
+			model
+		};
+		return collectionOf(fromContract, coordinate) === collection ? [{
+			coordinate,
+			isRoot: definition.base === void 0
+		}] : [];
+	}));
+	return (storing.find(({ isRoot }) => isRoot) ?? storing[0])?.coordinate;
+}
+/** A convert or backfill statement, which this release cannot carry out on MongoDB. */
+function unsupportedStatementConflict(statement, fromContract, contract) {
+	return {
+		kind: "statementRefused",
+		summary: `MongoDB does not apply ${statement.kind} statements in this release, so nothing was planned: ${describeMigrationStatement(statement, fromContract, contract)}`,
+		why: `MongoDB cannot carry out ${statement.kind} statements in this release. Leave out the statement.`,
+		refusedStatement: statement
+	};
+}
+/**
+* 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);
+		const lost = {
+			operationIndex,
+			loss: "drop",
+			label: call.label
+		};
+		if (model === void 0) return [{
+			...lost,
+			subject: {
+				kind: "storage",
+				name: call.collection
+			}
+		}];
+		const subject = {
+			kind: "model",
+			...model
+		};
+		const destinationCollection = modelStoredInDestination(contract, model);
+		return [destinationCollection !== void 0 && created(destinationCollection) ? {
+			...lost,
+			subject,
+			keepDataAdvice: keepCollectionByHandAdvice(model, call.collection, destinationCollection)
+		} : {
+			...lost,
+			subject
+		}];
+	});
+}
+/** 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;
+}
+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);
+		const originIR = options.statementCalls?.schema ?? blindCast(options.schema);
+		const destinationIR = contractToMongoSchemaIR(contract);
+		const collCreates = [];
+		const drops = [];
+		const creates = [];
+		const validatorOps = [];
+		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 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;
+			}
+			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",
+			conflicts
+		};
+		const allCalls = [
+			...options.statementCalls?.collectionRenames ?? [],
+			...collCreates,
+			...drops,
+			...options.statementCalls?.rewrites ?? [],
+			...creates,
+			...validatorOps,
+			...mutableOptionOps,
+			...collDrops
+		];
+		for (const call of allCalls) if (!options.policy.allowedOperationClasses.includes(call.operationClass)) conflicts.push({
+			kind: "policy-violation",
+			summary: `${call.operationClass} operation disallowed: ${call.label}`,
+			why: `Policy does not allow '${call.operationClass}' operations`,
+			refusedOperationClass: call.operationClass
+		});
+		if (conflicts.length > 0) return {
+			kind: "failure",
+			conflicts
+		};
+		return {
+			kind: "success",
+			calls: allCalls,
+			warnings
+		};
+	}
+	plan(options) {
+		const contract = blindCast(options.contract);
+		const originIR = blindCast(options.schema);
+		const fromContract = options.fromContract;
+		const unsupported = options.statements.find((statement) => statement.kind !== "rename");
+		if (unsupported !== void 0) return {
+			kind: "failure",
+			conflicts: [unsupportedStatementConflict(unsupported, fromContract ?? contract, contract)]
+		};
+		const renames = options.statements.filter((statement) => statement.kind === "rename");
+		const statementPlan = planStatements({
+			statements: renames,
+			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: renames,
+			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), ...sharedCollectionRemovalRefusals(removals, contract)];
+		if (removalRefusals.length > 0) return {
+			kind: "failure",
+			conflicts: removalRefusals
+		};
+		const result = this.planCalls({
+			...options,
+			statementCalls: {
+				schema,
+				collectionRenames,
+				rewrites: [...fieldRenames, ...removals.map((removal) => removal.call)]
+			}
+		});
+		if (result.kind === "failure") return result;
+		const { calls, warnings } = result;
+		const fieldLoss = removals.map((removal) => ({
+			operationIndex: calls.indexOf(removal.call),
+			subject: removal.subject,
+			loss: "drop",
+			label: removal.call.label
+		}));
+		return {
+			kind: "success",
+			plan: new PlannerProducedMongoMigration(calls, {
+				from: options.origin?.storageHash ?? null,
+				to: contract.storage.storageHash
+			}, options.snapshotsImportPath),
+			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),
+			accessChanges: [],
+			temporaryValues: [],
+			...warnings.length > 0 ? { warnings } : {}
+		};
+	}
+	/**
+	* Produce an empty `migration.ts` authoring surface for `migration new`.
+	*
+	* The "empty migration" is a `PlannerProducedMongoMigration` with no
+	* operations; `renderTypeScript()` emits a stub class with the correct
+	* `from`/`to` metadata that the user then fills in with operations. The
+	* contract path on the context is unused — Mongo's emitted source does
+	* not import from the generated contract `.d.ts`.
+	*/
+	emptyMigration(context) {
+		return new PlannerProducedMongoMigration([], {
+			from: context.fromHash,
+			to: context.toHash
+		}, 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, {
+		validator: { $jsonSchema: destValidator.jsonSchema },
+		validationLevel: destValidator.validationLevel,
+		validationAction: destValidator.validationAction
+	}, {
+		id: `validator.${collName}.${originValidator ? "update" : "add"}`,
+		label: originValidator ? validatorUpdateLabel(collName, originValidator, destValidator) : `Add validator on ${collName}`,
+		operationClass: "widening"
+	});
+	return new CollModCall(collName, {
+		validator: {},
+		validationLevel: "strict",
+		validationAction: "error"
+	}, {
+		id: `validator.${collName}.remove`,
+		label: `Remove validator on ${collName}`,
+		operationClass: "widening"
+	});
+}
+function planMutableOptionsDiffCall(collName, origin, dest) {
+	const originCSPPI = origin?.changeStreamPreAndPostImages;
+	const destCSPPI = dest?.changeStreamPreAndPostImages;
+	if (deepEqual(originCSPPI, destCSPPI)) return void 0;
+	return new CollModCall(collName, { changeStreamPreAndPostImages: destCSPPI ?? { enabled: false } }, {
+		id: `options.${collName}.update`,
+		label: `Update mutable options on ${collName}`,
+		operationClass: "widening"
+	});
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object";
+}
+function getNestedField(doc, path) {
+	const parts = path.split(".");
+	let current = doc;
+	for (const part of parts) {
+		if (!isRecord(current)) return;
+		const record = current;
+		if (!Object.hasOwn(record, part)) return;
+		current = record[part];
+	}
+	return blindCast(current);
+}
+function evaluateFieldOp(op, actual, expected) {
+	switch (op) {
+		case "$eq": return deepEqual(actual, expected);
+		case "$ne": return !deepEqual(actual, expected);
+		case "$gt": return typeof actual === typeof expected && blindCast(actual) > blindCast(expected);
+		case "$gte": return typeof actual === typeof expected && blindCast(actual) >= blindCast(expected);
+		case "$lt": return typeof actual === typeof expected && blindCast(actual) < blindCast(expected);
+		case "$lte": return typeof actual === typeof expected && blindCast(actual) <= blindCast(expected);
+		case "$in": return Array.isArray(expected) && expected.some((v) => deepEqual(actual, v));
+		default: throw mongoTargetError("MIGRATION.OPERATION_UNSUPPORTED", `Unsupported filter operator in migration check: ${op}`, { meta: { operator: op } });
+	}
+}
+var FilterEvaluator = class {
+	doc = {};
+	evaluate(filter, doc) {
+		this.doc = doc;
+		return filter.accept(this);
+	}
+	field(expr) {
+		const value = getNestedField(this.doc, expr.field);
+		return evaluateFieldOp(expr.op, value, expr.value);
+	}
+	and(expr) {
+		return expr.exprs.every((child) => child.accept(this));
+	}
+	or(expr) {
+		return expr.exprs.some((child) => child.accept(this));
+	}
+	not(expr) {
+		return !expr.expr.accept(this);
+	}
+	exists(expr) {
+		const has = getNestedField(this.doc, expr.field) !== void 0;
+		return expr.exists ? has : !has;
+	}
+	expr(_expr) {
+		throw mongoTargetError("MIGRATION.OPERATION_UNSUPPORTED", "Aggregation expression filters are not supported in migration checks", { meta: { operator: "$expr" } });
+	}
+};
+const IndexKeyJson = type({
+	field: "string",
+	direction: type("1 | -1 | \"text\" | \"2dsphere\" | \"2d\" | \"hashed\"")
+});
+const CollationJson = type({
+	locale: "string",
+	"caseLevel?": "boolean",
+	"caseFirst?": "string",
+	"strength?": "number",
+	"numericOrdering?": "boolean",
+	"alternate?": "string",
+	"maxVariable?": "string",
+	"backwards?": "boolean",
+	"normalization?": "boolean"
+});
+const CreateIndexJson = type({
+	kind: "\"createIndex\"",
+	collection: "string",
+	keys: IndexKeyJson.array().atLeastLength(1),
+	"unique?": "boolean",
+	"sparse?": "boolean",
+	"expireAfterSeconds?": "number",
+	"partialFilterExpression?": "Record<string, unknown>",
+	"name?": "string",
+	"wildcardProjection?": "Record<string, 0 | 1>",
+	"collation?": CollationJson,
+	"weights?": "Record<string, number>",
+	"default_language?": "string",
+	"language_override?": "string"
+});
+const DropIndexJson = type({
+	kind: "\"dropIndex\"",
+	collection: "string",
+	name: "string"
+});
+const CreateCollectionJson = type({
+	kind: "\"createCollection\"",
+	collection: "string",
+	"validator?": "Record<string, unknown>",
+	"validationLevel?": "\"strict\" | \"moderate\"",
+	"validationAction?": "\"error\" | \"warn\"",
+	"capped?": "boolean",
+	"size?": "number",
+	"max?": "number",
+	"timeseries?": {
+		timeField: "string",
+		"metaField?": "string",
+		"granularity?": "\"seconds\" | \"minutes\" | \"hours\""
+	},
+	"collation?": CollationJson,
+	"changeStreamPreAndPostImages?": { enabled: "boolean" },
+	"clusteredIndex?": {
+		key: "Record<string, number>",
+		unique: "boolean",
+		"name?": "string"
+	}
+});
+const DropCollectionJson = type({
+	kind: "\"dropCollection\"",
+	collection: "string"
+});
+const RenameCollectionJson = type({
+	kind: "\"renameCollection\"",
+	collection: "string",
+	to: "string"
+});
+const CollModJson = type({
+	kind: "\"collMod\"",
+	collection: "string",
+	"validator?": "Record<string, unknown>",
+	"validationLevel?": "\"strict\" | \"moderate\"",
+	"validationAction?": "\"error\" | \"warn\"",
+	"changeStreamPreAndPostImages?": { enabled: "boolean" }
+});
+const ListIndexesJson = type({
+	kind: "\"listIndexes\"",
+	collection: "string"
+});
+const ListCollectionsJson = type({ kind: "\"listCollections\"" });
+const FieldFilterJson = type({
+	kind: "\"field\"",
+	field: "string",
+	op: "string",
+	value: "unknown"
+});
+const AndFilterJson = type({
+	kind: "\"and\"",
+	exprs: "Record<string, unknown>[]"
+});
+const OrFilterJson = type({
+	kind: "\"or\"",
+	exprs: "Record<string, unknown>[]"
+});
+const NotFilterJson = type({
+	kind: "\"not\"",
+	expr: "Record<string, unknown>"
+});
+const ExistsFilterJson = type({
+	kind: "\"exists\"",
+	field: "string",
+	exists: "boolean"
+});
+const RawInsertOneJson = type({
+	kind: "\"rawInsertOne\"",
+	collection: "string",
+	document: "Record<string, unknown>"
+});
+const RawInsertManyJson = type({
+	kind: "\"rawInsertMany\"",
+	collection: "string",
+	documents: "Record<string, unknown>[]"
+});
+const RawUpdateOneJson = type({
+	kind: "\"rawUpdateOne\"",
+	collection: "string",
+	filter: "Record<string, unknown>",
+	update: "Record<string, unknown> | Record<string, unknown>[]"
+});
+const RawUpdateManyJson = type({
+	kind: "\"rawUpdateMany\"",
+	collection: "string",
+	filter: "Record<string, unknown>",
+	update: "Record<string, unknown> | Record<string, unknown>[]",
+	"bypassDocumentValidation?": "boolean"
+});
+const RawDeleteOneJson = type({
+	kind: "\"rawDeleteOne\"",
+	collection: "string",
+	filter: "Record<string, unknown>"
+});
+const RawDeleteManyJson = type({
+	kind: "\"rawDeleteMany\"",
+	collection: "string",
+	filter: "Record<string, unknown>"
+});
+const RawAggregateJson = type({
+	kind: "\"rawAggregate\"",
+	collection: "string",
+	pipeline: "Record<string, unknown>[]"
+});
+const RawFindOneAndUpdateJson = type({
+	kind: "\"rawFindOneAndUpdate\"",
+	collection: "string",
+	filter: "Record<string, unknown>",
+	update: "Record<string, unknown> | Record<string, unknown>[]",
+	upsert: "boolean"
+});
+const RawFindOneAndDeleteJson = type({
+	kind: "\"rawFindOneAndDelete\"",
+	collection: "string",
+	filter: "Record<string, unknown>"
+});
+const TypedAggregateJson = type({
+	kind: "\"aggregate\"",
+	collection: "string",
+	pipeline: "Record<string, unknown>[]"
+});
+const QueryPlanJson = type({
+	collection: "string",
+	command: "Record<string, unknown>",
+	meta: type({
+		target: "string",
+		storageHash: "string",
+		lane: "string",
+		"targetFamily?": "string",
+		"profileHash?": "string",
+		"annotations?": "Record<string, unknown>"
+	})
+});
+const MatchStageJson = type({
+	kind: "\"match\"",
+	filter: "Record<string, unknown>"
+});
+const LimitStageJson = type({
+	kind: "\"limit\"",
+	limit: "number"
+});
+const SortStageJson = type({
+	kind: "\"sort\"",
+	sort: "Record<string, 1 | -1>"
+});
+const ProjectStageJson = type({
+	kind: "\"project\"",
+	projection: "Record<string, 0 | 1>"
+});
+const AddFieldsStageJson = type({
+	kind: "\"addFields\"",
+	fields: "Record<string, unknown>"
+});
+const LookupStageJson = type({
+	kind: "\"lookup\"",
+	from: "string",
+	as: "string",
+	"localField?": "string",
+	"foreignField?": "string",
+	"pipeline?": "Record<string, unknown>[]",
+	"let_?": "Record<string, unknown>"
+});
+const CheckJson = type({
+	description: "string",
+	source: "Record<string, unknown>",
+	filter: "Record<string, unknown>",
+	expect: "\"exists\" | \"notExists\"",
+	"object?": "string > 0"
+});
+const StepJson = type({
+	description: "string",
+	command: "Record<string, unknown>"
+});
+const DdlOperationJson = type({
+	id: "string",
+	label: "string",
+	operationClass: "\"additive\" | \"widening\" | \"destructive\"",
+	precheck: "Record<string, unknown>[]",
+	execute: "Record<string, unknown>[]",
+	postcheck: "Record<string, unknown>[]"
+});
+const DmlCheckJson = type({
+	description: "string",
+	source: "Record<string, unknown>",
+	filter: "Record<string, unknown>",
+	expect: "\"exists\" | \"notExists\""
+});
+const DmlOperationJson = type({
+	id: "string",
+	label: "string",
+	operationClass: "\"additive\" | \"widening\" | \"destructive\" | \"data\"",
+	name: "string",
+	precheck: "Record<string, unknown>[]",
+	run: "Record<string, unknown>[]",
+	postcheck: "Record<string, unknown>[]"
+});
+function recordValue(json, key, context) {
+	if (json === null || typeof json !== "object") throw mongoTargetError("MIGRATION.INVALID_OPERATION_ENTRY", `Invalid ${context}: expected object`, { meta: { context } });
+	return blindCast(Reflect.get(json, key));
+}
+function recordKind(json, context) {
+	const kind = recordValue(json, "kind", context);
+	return typeof kind === "string" ? kind : "";
+}
+function validate(schema, data, context) {
+	try {
+		return schema.assert(stripUndefinedDeep(data));
+	} catch (error) {
+		/* v8 ignore stop */
+		throw mongoTargetError("MIGRATION.INVALID_OPERATION_ENTRY", `Invalid ${context}: ${error instanceof Error ? error.message : String(error)}`, {
+			meta: { context },
+			cause: error
+		});
+	}
+}
+/**
+* Strip `undefined`-valued properties before they reach arktype's optional-key
+* assertions.
+*
+* Op IRs (e.g. `CreateCollectionCommand`) assign every optional field on
+* every instance — fields the caller did not provide land as
+* `undefined`-valued properties. arktype treats `{ foo?: 'boolean' }` as
+* "key may be absent, but if present must be boolean", so the bare instance
+* fails validation when it crosses the deserialize boundary in-process
+* (no JSON round-trip happens between planner → runner). This helper
+* recovers the JSON-round-tripped shape (undefined keys absent) without
+* forcing every caller to round-trip.
+*
+* Returns the original value reference whenever no change is needed.
+* That preserves prototype-bound payload values such as BSON wrappers
+* (`ObjectId`, `Decimal128`, `Binary`, …) which embed no `undefined`
+* own-enumerable properties and therefore never trigger a rebuild.
+* Top-level op IRs (class instances with `undefined` optional fields)
+* still get flattened to plain records as required by arktype.
+*/
+function stripUndefinedDeep(value) {
+	if (Array.isArray(value)) {
+		let changed = false;
+		const next = value.map((item) => {
+			const stripped = stripUndefinedDeep(item);
+			if (stripped !== item) changed = true;
+			return stripped;
+		});
+		return changed ? next : value;
+	}
+	if (value === null || typeof value !== "object") return blindCast(value);
+	const entries = Object.entries(value);
+	const out = {};
+	let changed = false;
+	for (const [key, val] of entries) {
+		if (val === void 0) {
+			changed = true;
+			continue;
+		}
+		const stripped = stripUndefinedDeep(val);
+		if (stripped !== val) changed = true;
+		out[key] = stripped;
+	}
+	return changed ? out : blindCast(value);
+}
+function deserializeFilterExpr(json) {
+	const kind = recordKind(json, "filter expression");
+	switch (kind) {
+		case "field": {
+			const data = validate(FieldFilterJson, json, "field filter");
+			return MongoFieldFilter.of(data.field, data.op, blindCast(data.value));
+		}
+		case "and": {
+			const data = validate(AndFilterJson, json, "and filter");
+			return MongoAndExpr.of(data.exprs.map(deserializeFilterExpr));
+		}
+		case "or": {
+			const data = validate(OrFilterJson, json, "or filter");
+			return MongoOrExpr.of(data.exprs.map(deserializeFilterExpr));
+		}
+		case "not": return new MongoNotExpr(deserializeFilterExpr(validate(NotFilterJson, json, "not filter").expr));
+		case "exists": {
+			const data = validate(ExistsFilterJson, json, "exists filter");
+			return new MongoExistsExpr(data.field, data.exists);
+		}
+		default: throw mongoTargetError("MIGRATION.INVALID_OPERATION_ENTRY", `Unknown filter expression kind: ${kind}`, { meta: {
+			context: "filter expression",
+			kind
+		} });
+	}
+}
+function deserializePipelineStage(json) {
+	const kind = recordKind(json, "pipeline stage");
+	switch (kind) {
+		case "match": return new MongoMatchStage(deserializeFilterExpr(validate(MatchStageJson, json, "match stage").filter));
+		case "limit": return new MongoLimitStage(validate(LimitStageJson, json, "limit stage").limit);
+		case "sort": return new MongoSortStage(validate(SortStageJson, json, "sort stage").sort);
+		case "project": return new MongoProjectStage(validate(ProjectStageJson, json, "project stage").projection);
+		case "addFields": return new MongoAddFieldsStage(blindCast(validate(AddFieldsStageJson, json, "addFields stage").fields));
+		case "lookup": {
+			const data = validate(LookupStageJson, json, "lookup stage");
+			const opts = {
+				from: data.from,
+				as: data.as
+			};
+			if (data.localField !== void 0) opts.localField = data.localField;
+			if (data.foreignField !== void 0) opts.foreignField = data.foreignField;
+			if (data.pipeline !== void 0) opts.pipeline = data.pipeline.map(deserializePipelineStage);
+			if (data.let_ !== void 0) opts.let_ = blindCast(data.let_);
+			return new MongoLookupStage(opts);
+		}
+		case "merge": {
+			const whenMatched = recordValue(json, "whenMatched", "merge stage");
+			const opts = { into: blindCast(recordValue(json, "into", "merge stage")) };
+			const on = recordValue(json, "on", "merge stage");
+			if (on !== void 0) opts.on = blindCast(on);
+			if (whenMatched !== void 0) opts.whenMatched = typeof whenMatched === "string" ? whenMatched : blindCast(blindCast(whenMatched).map(deserializePipelineStage));
+			const whenNotMatched = recordValue(json, "whenNotMatched", "merge stage");
+			if (whenNotMatched !== void 0) opts.whenNotMatched = blindCast(whenNotMatched);
+			return new MongoMergeStage(opts);
+		}
+		default: throw mongoTargetError("MIGRATION.INVALID_OPERATION_ENTRY", `Unknown pipeline stage kind: ${kind}`, { meta: {
+			context: "pipeline stage",
+			kind
+		} });
+	}
+}
+function deserializeDmlCommand(json) {
+	const kind = recordKind(json, "DML command");
+	switch (kind) {
+		case "rawInsertOne": {
+			const data = validate(RawInsertOneJson, json, "rawInsertOne command");
+			return new RawInsertOneCommand(data.collection, data.document);
+		}
+		case "rawInsertMany": {
+			const data = validate(RawInsertManyJson, json, "rawInsertMany command");
+			return new RawInsertManyCommand(data.collection, data.documents);
+		}
+		case "rawUpdateOne": {
+			const data = validate(RawUpdateOneJson, json, "rawUpdateOne command");
+			return new RawUpdateOneCommand(data.collection, data.filter, data.update);
+		}
+		case "rawUpdateMany": {
+			const data = validate(RawUpdateManyJson, json, "rawUpdateMany command");
+			return new RawUpdateManyCommand(data.collection, data.filter, data.update, ifDefined("bypassDocumentValidation", data.bypassDocumentValidation));
+		}
+		case "rawDeleteOne": {
+			const data = validate(RawDeleteOneJson, json, "rawDeleteOne command");
+			return new RawDeleteOneCommand(data.collection, data.filter);
+		}
+		case "rawDeleteMany": {
+			const data = validate(RawDeleteManyJson, json, "rawDeleteMany command");
+			return new RawDeleteManyCommand(data.collection, data.filter);
+		}
+		case "rawAggregate": {
+			const data = validate(RawAggregateJson, json, "rawAggregate command");
+			return new RawAggregateCommand(data.collection, data.pipeline);
+		}
+		case "rawFindOneAndUpdate": {
+			const data = validate(RawFindOneAndUpdateJson, json, "rawFindOneAndUpdate command");
+			return new RawFindOneAndUpdateCommand(data.collection, data.filter, data.update, data.upsert);
+		}
+		case "rawFindOneAndDelete": {
+			const data = validate(RawFindOneAndDeleteJson, json, "rawFindOneAndDelete command");
+			return new RawFindOneAndDeleteCommand(data.collection, data.filter);
+		}
+		case "aggregate": {
+			const data = validate(TypedAggregateJson, json, "aggregate command");
+			const pipeline = data.pipeline.map(deserializePipelineStage);
+			return new AggregateCommand(data.collection, pipeline);
+		}
+		default: throw mongoTargetError("MIGRATION.INVALID_OPERATION_ENTRY", `Unknown DML command kind: ${kind}`, { meta: {
+			context: "DML command",
+			kind
+		} });
+	}
+}
+function deserializeMongoQueryPlan(json) {
+	const data = validate(QueryPlanJson, json, "Mongo query plan");
+	const command = deserializeDmlCommand(data.command);
+	const m = data.meta;
+	const meta = {
+		target: m.target,
+		storageHash: m.storageHash,
+		lane: m.lane,
+		...ifDefined("targetFamily", m.targetFamily),
+		...ifDefined("profileHash", m.profileHash),
+		...ifDefined("annotations", m.annotations)
+	};
+	return {
+		collection: data.collection,
+		command,
+		meta
+	};
+}
+function deserializeDdlCommand(json) {
+	const kind = recordKind(json, "DDL command");
+	switch (kind) {
+		case "createIndex": {
+			const data = validate(CreateIndexJson, json, "createIndex command");
+			return new CreateIndexCommand(data.collection, data.keys, {
+				...ifDefined("unique", data.unique),
+				...ifDefined("sparse", data.sparse),
+				...ifDefined("expireAfterSeconds", data.expireAfterSeconds),
+				...ifDefined("partialFilterExpression", data.partialFilterExpression),
+				...ifDefined("name", data.name),
+				...ifDefined("wildcardProjection", data.wildcardProjection),
+				...ifDefined("collation", data.collation),
+				...ifDefined("weights", data.weights),
+				...ifDefined("default_language", data.default_language),
+				...ifDefined("language_override", data.language_override)
+			});
+		}
+		case "dropIndex": {
+			const data = validate(DropIndexJson, json, "dropIndex command");
+			return new DropIndexCommand(data.collection, data.name);
+		}
+		case "createCollection": {
+			const data = validate(CreateCollectionJson, json, "createCollection command");
+			return new CreateCollectionCommand(data.collection, {
+				...ifDefined("validator", data.validator),
+				...ifDefined("validationLevel", data.validationLevel),
+				...ifDefined("validationAction", data.validationAction),
+				...ifDefined("capped", data.capped),
+				...ifDefined("size", data.size),
+				...ifDefined("max", data.max),
+				...ifDefined("timeseries", data.timeseries),
+				...ifDefined("collation", data.collation),
+				...ifDefined("changeStreamPreAndPostImages", data.changeStreamPreAndPostImages),
+				...ifDefined("clusteredIndex", data.clusteredIndex)
+			});
+		}
+		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, {
+				...ifDefined("validator", data.validator),
+				...ifDefined("validationLevel", data.validationLevel),
+				...ifDefined("validationAction", data.validationAction),
+				...ifDefined("changeStreamPreAndPostImages", data.changeStreamPreAndPostImages)
+			});
+		}
+		default: throw mongoTargetError("MIGRATION.INVALID_OPERATION_ENTRY", `Unknown DDL command kind: ${kind}`, { meta: {
+			context: "DDL command",
+			kind
+		} });
+	}
+}
+function deserializeInspectionCommand(json) {
+	const kind = recordKind(json, "inspection command");
+	switch (kind) {
+		case "listIndexes": return new ListIndexesCommand(validate(ListIndexesJson, json, "listIndexes command").collection);
+		case "listCollections":
+			validate(ListCollectionsJson, json, "listCollections command");
+			return new ListCollectionsCommand();
+		default: throw mongoTargetError("MIGRATION.INVALID_OPERATION_ENTRY", `Unknown inspection command kind: ${kind}`, { meta: {
+			context: "inspection command",
+			kind
+		} });
+	}
+}
+function deserializeCheck(json) {
+	const data = validate(CheckJson, json, "migration check");
+	return {
+		description: data.description,
+		source: deserializeInspectionCommand(data.source),
+		filter: deserializeFilterExpr(data.filter),
+		expect: data.expect,
+		...ifDefined("object", data.object)
+	};
+}
+function deserializeStep(json) {
+	const data = validate(StepJson, json, "migration step");
+	return {
+		description: data.description,
+		command: deserializeDdlCommand(data.command)
+	};
+}
+function isDmlOperationJson(json) {
+	return Array.isArray(recordValue(json, "run", "migration operation"));
+}
+function deserializeDdlOp(json) {
+	const data = validate(DdlOperationJson, json, "migration operation");
+	return {
+		id: data.id,
+		label: data.label,
+		operationClass: data.operationClass,
+		precheck: data.precheck.map(deserializeCheck),
+		execute: data.execute.map(deserializeStep),
+		postcheck: data.postcheck.map(deserializeCheck)
+	};
+}
+function deserializeDmlCheck(json) {
+	const data = validate(DmlCheckJson, json, "DML operation check");
+	return {
+		description: data.description,
+		source: deserializeMongoQueryPlan(data.source),
+		filter: deserializeFilterExpr(data.filter),
+		expect: data.expect
+	};
+}
+function deserializeDmlOp(json) {
+	const data = validate(DmlOperationJson, json, "DML operation");
+	return {
+		id: data.id,
+		label: data.label,
+		operationClass: data.operationClass,
+		name: data.name,
+		precheck: data.precheck.map(deserializeDmlCheck),
+		run: data.run.map(deserializeMongoQueryPlan),
+		postcheck: data.postcheck.map(deserializeDmlCheck)
+	};
+}
+function deserializeMongoOp(json) {
+	if (isDmlOperationJson(json)) return deserializeDmlOp(json);
+	return deserializeDdlOp(json);
+}
+function deserializeMongoOps(json) {
+	return json.map(deserializeMongoOp);
+}
+function serializeMongoOps(ops) {
+	return JSON.stringify(ops, null, 2);
+}
+const READ_ONLY_CHECK_COMMAND_KINDS = /* @__PURE__ */ new Set(["aggregate", "rawAggregate"]);
+const CHANGED_DOCUMENT_COUNTS = [
+	"insertedCount",
+	"modifiedCount",
+	"upsertedCount",
+	"deletedCount"
+];
+/** Whether a write command's result row says it changed no document: every count it carries is zero. */
+function reportsNoChangedDocuments(row) {
+	if (typeof row !== "object" || row === null) return false;
+	const counts = CHANGED_DOCUMENT_COUNTS.map((field) => Reflect.get(row, field)).filter((count) => count !== void 0);
+	return counts.length > 0 && counts.every((count) => count === 0);
+}
+function failedCheckOf(operationId, phase, check) {
+	return {
+		operationId,
+		phase,
+		description: check.description,
+		...ifDefined("expectation", check.object === void 0 ? void 0 : check.expect === "exists" ? expectPresent(check.object) : expectAbsent(check.object))
+	};
+}
+function runnerFailure(code, summary, options) {
+	return notOk(migrationRunnerFailure(code, summary, options));
+}
+/**
+* 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. Once the documents are fixed, run the command again; operations that already ran are skipped.`,
+		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) {
+		this.deps = deps;
+	}
+	async execute(options) {
+		let changedDatabase = false;
+		const result = await this.apply(options, () => {
+			changedDatabase = true;
+		});
+		return result.ok ? ok({
+			...result.value,
+			changedDatabase
+		}) : notOk(withDatabaseUnchanged(result.failure, options.databaseChangedBefore !== true && !changedDatabase));
+	}
+	/** Applies the plan, calling `wrote` after each command that changes the database. */
+	async apply(options, wrote) {
+		const { inspectionExecutor, adapter, driver, executeDdl, markerOps } = this.deps;
+		const operations = deserializeMongoOps(blindCast(options.plan.operations));
+		const space = options.plan.spaceId ?? APP_SPACE_ID;
+		const policyCheck = this.enforcePolicyCompatibility(options.policy, operations);
+		if (policyCheck) return policyCheck;
+		const existingMarker = await markerOps.readMarker(space);
+		const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
+		if (markerCheck) return markerCheck;
+		const checks = options.executionChecks;
+		const runPrechecks = checks?.prechecks !== false;
+		const runPostchecks = checks?.postchecks !== false;
+		const runIdempotency = checks?.idempotencyChecks !== false;
+		const filterEvaluator = new FilterEvaluator();
+		let operationsExecuted = 0;
+		for (const operation of operations) {
+			options.callbacks?.onOperationStart?.(operation);
+			try {
+				if (isMongoDmlOperation(operation)) {
+					const result = await this.executeDmlOperation(operation, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks, wrote);
+					if (result.failure) return result.failure;
+					if (result.executed) operationsExecuted += 1;
+					continue;
+				}
+				if (runPostchecks && runIdempotency) {
+					if (await this.allChecksSatisfied(operation.postcheck, inspectionExecutor, filterEvaluator)) continue;
+				}
+				if (runPrechecks) {
+					const failing = await this.firstFailingCheck(operation.precheck, inspectionExecutor, filterEvaluator);
+					if (failing !== void 0) {
+						const failedCheck = failedCheckOf(operation.id, "precheck", failing);
+						return renameTargetExistsRefusal(operation, failing) ?? runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${operation.id} failed during precheck: ${failing.description}`, {
+							why: failedPrecheckWhy(failedCheck),
+							meta: { failedCheck }
+						});
+					}
+				}
+				for (const step of operation.execute) {
+					await executeDdl(step.command);
+					wrote();
+				}
+				if (runPostchecks) {
+					const failing = await this.firstFailingCheck(operation.postcheck, inspectionExecutor, filterEvaluator);
+					if (failing !== void 0) {
+						const failedCheck = failedCheckOf(operation.id, "postcheck", failing);
+						return runnerFailure("MIGRATION.POSTCHECK_FAILED", `Operation ${operation.id} failed during postcheck: ${failing.description}`, {
+							why: failedPostcheckWhy(failedCheck),
+							meta: {
+								operationId: operation.id,
+								failedCheck
+							}
+						});
+					}
+				}
+				operationsExecuted += 1;
+			} finally {
+				options.callbacks?.onOperationComplete?.(operation);
+			}
+		}
+		const destination = options.plan.destination;
+		const profileHash = options.destinationContract.profileHash ?? destination.storageHash;
+		const incomingInvariants = options.plan.providedInvariants ?? [];
+		const existingInvariantSet = new Set(existingMarker?.invariants ?? []);
+		const incomingIsSubsetOfExisting = incomingInvariants.every((id) => existingInvariantSet.has(id));
+		const markerAlreadyAtDestination = existingMarker !== null && existingMarker.storageHash === destination.storageHash && existingMarker.profileHash === profileHash;
+		if (!(operationsExecuted === 0 && markerAlreadyAtDestination && incomingIsSubsetOfExisting)) {
+			const liveSchema = await this.deps.introspectSchema();
+			const rawVerifyResult = verifyMongoSchema({
+				contract: options.destinationContract,
+				schema: liveSchema,
+				strict: options.strictVerification ?? true,
+				frameworkComponents: options.frameworkComponents,
+				...options.context ? { context: options.context } : {}
+			});
+			const verifyResult = options.scopeVerifyResult ? options.scopeVerifyResult(rawVerifyResult) : rawVerifyResult;
+			if (!verifyResult.ok) return runnerFailure("MIGRATION.SCHEMA_VERIFY_FAILED", verifyResult.summary, {
+				why: schemaCheckWhy(verifyResult.schema.issues),
+				meta: { schemaIssues: verifyResult.schema.issues }
+			});
+			if (existingMarker) {
+				if (!await markerOps.updateMarker(space, existingMarker.storageHash, {
+					storageHash: destination.storageHash,
+					profileHash,
+					invariants: incomingInvariants
+				})) {
+					const found = await markerOps.readMarker(space);
+					return runnerFailure("MIGRATION.MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
+						space,
+						expectedStorageHash: existingMarker.storageHash,
+						foundStorageHash: found?.storageHash ?? null,
+						destinationStorageHash: destination.storageHash
+					} });
+				}
+			} else await markerOps.initMarker(space, {
+				storageHash: destination.storageHash,
+				profileHash,
+				invariants: incomingInvariants
+			});
+			wrote();
+			await this.recordLedgerEntries(markerOps, space, options);
+		}
+		return ok({
+			operationsPlanned: operations.length,
+			operationsExecuted
+		});
+	}
+	async recordLedgerEntries(markerOps, space, options) {
+		const plan = options.plan;
+		const edges = options.migrationEdges;
+		const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
+		if (totalEdgeOps !== plan.operations.length) throw new InternalError(`Ledger write: plan.operations length (${plan.operations.length}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`);
+		let offset = 0;
+		for (const edge of edges) {
+			const edgeOps = plan.operations.slice(offset, offset + edge.operationCount);
+			offset += edge.operationCount;
+			await markerOps.writeLedgerEntry(space, {
+				edgeId: `${edge.from}->${edge.to}`,
+				from: edge.from,
+				to: edge.to,
+				migrationName: edge.dirName,
+				migrationHash: edge.migrationHash,
+				operations: edgeOps
+			});
+		}
+	}
+	async executeDmlOperation(op, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks, wrote) {
+		if (runPostchecks && runIdempotency && op.postcheck.length > 0) {
+			if (await this.evaluateDmlChecks(op.postcheck, adapter, driver, filterEvaluator)) return { executed: false };
+		}
+		if (runPrechecks && op.precheck.length > 0) {
+			if (!await this.evaluateDmlChecks(op.precheck, adapter, driver, filterEvaluator)) return {
+				executed: false,
+				failure: renameOverwriteRefusal(op) ?? runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${op.id} failed during precheck`, { meta: {
+					operationId: op.id,
+					name: op.name
+				} })
+			};
+		}
+		for (const plan of op.run) {
+			const wireCommand = await adapter.lower(plan, {});
+			try {
+				let reportedNoChange = false;
+				let reportedChange = false;
+				for await (const row of driver.execute(wireCommand)) if (reportsNoChangedDocuments(row)) reportedNoChange = true;
+				else reportedChange = true;
+				if (reportedChange || !reportedNoChange) wrote();
+			} 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.evaluateDmlChecks(op.postcheck, adapter, driver, filterEvaluator)) return {
+				executed: false,
+				failure: runnerFailure("MIGRATION.POSTCHECK_FAILED", `Operation ${op.id} failed during postcheck`, { meta: {
+					operationId: op.id,
+					name: op.name
+				} })
+			};
+		}
+		return { executed: true };
+	}
+	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 mongoTargetError("MIGRATION.DATA_TRANSFORM_CHECK_NOT_READ_ONLY", `Data-transform check rejected: command kind "${commandKind}" is not read-only`, {
+				why: "Data-transform checks must use aggregate or rawAggregate commands so the pre/postcheck path cannot mutate the database.",
+				fix: "Author the check.source as an aggregate pipeline (or rawAggregate) rather than a DML write command.",
+				meta: {
+					checkDescription: check.description,
+					commandKind,
+					collection: check.source.collection
+				}
+			});
+			const wireCommand = await adapter.lower(check.source, {});
+			let matchFound = false;
+			for await (const row of driver.execute(wireCommand)) if (filterEvaluator.evaluate(check.filter, row)) {
+				matchFound = true;
+				break;
+			}
+			if (!(check.expect === "exists" ? matchFound : !matchFound)) return false;
+		}
+		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 check;
+		}
+	}
+	async allChecksSatisfied(checks, inspectionExecutor, filterEvaluator) {
+		if (checks.length === 0) return false;
+		return this.evaluateChecks(checks, inspectionExecutor, filterEvaluator);
+	}
+	enforcePolicyCompatibility(policy, operations) {
+		const allowedClasses = new Set(policy.allowedOperationClasses);
+		for (const operation of operations) if (!allowedClasses.has(operation.operationClass)) return runnerFailure("MIGRATION.POLICY_VIOLATION", `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`, {
+			why: `Policy only allows: ${[...allowedClasses].join(", ")}.`,
+			meta: {
+				operationId: operation.id,
+				operationClass: operation.operationClass
+			}
+		});
+	}
+	ensureMarkerCompatibility(marker, plan) {
+		const origin = plan.origin ?? null;
+		if (!origin) return;
+		if (!marker) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
+		if (marker.storageHash !== origin.storageHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
+			markerStorageHash: marker.storageHash,
+			expectedOriginStorageHash: origin.storageHash
+		} });
+	}
+};
+/**
+* Mongo target `SchemaVerifier` concretion. Extends the family base's
+* namespace-walk scaffolding and contributes the per-namespace diff via
+* `verifyNamespace`; the diff body reuses the existing target-side
+* helpers (`contractToMongoSchemaIR`, `canonicalizeSchemasForVerification`,
+* `diffMongoSchemas`) so production verification behaviour is unchanged.
+*
+* Today's invariant: every Mongo contract carries exactly one
+* namespace (the unbound singleton, materialised as
+* `MongoTargetUnboundDatabase`), so the family-base namespace walk
+* dispatches exactly once and the per-namespace body runs the existing
+* whole-schema diff. Future per-collection namespace assignment will
+* have this hook project the diff to the namespace's owned collections.
+*
+* `verifyTargetExtensions` returns the empty list — Mongo has no
+* target-only kinds today.
+*
+* Strict diff mode is `false` for SPI-routed calls; production
+* verification today still goes through `verifyMongoSchema` which
+* receives strict from the CLI.
+*/
+var MongoTargetSchemaVerifier = class extends MongoSchemaVerifierBase {
+	verifyNamespace(options) {
+		const expectedIR = contractToMongoSchemaIR(options.contract);
+		const { live, expected } = canonicalizeSchemasForVerification(options.schema, expectedIR);
+		const collectionControlPolicy = (name) => this.collectionControlPolicyForName(options.contract, name);
+		const { failures, warnings } = diffMongoSchemas(live, expected, false, collectionControlPolicy);
+		return [...failures, ...warnings];
+	}
+	verifyTargetExtensions(_options) {
+		return [];
+	}
+};
+/**
+* The bare entity names the given contracts declare, unioned. The Mongo runner
+* asks this of every OTHER contract space in a multi-space apply, so each
+* space's post-apply verify can drop the extras those siblings claim.
+*/
+function entityNamesDeclaredBy(contracts) {
+	const owned = /* @__PURE__ */ new Set();
+	for (const contract of contracts) for (const { entityName } of elementCoordinates(contract.storage)) owned.add(entityName);
+	return owned;
+}
+/**
+* True when an issue reports a whole collection present in the database but
+* declared by no contract (an extra) — its path is exactly the collection
+* name, never a deeper index/validator/options auxiliary.
+*/
+function extraCollectionName(issue) {
+	if (issueOutcome(issue) !== "not-expected" || issue.path.length !== 1) return void 0;
+	return issue.path[0];
+}
+/**
+* Scope a per-space post-apply verify result to the contract space's own
+* elements: drop the `extra` findings for collections another contract space
+* claims. The runner verifies the destination contract against the full live
+* database, which holds sibling spaces' collections — without the scoping a
+* multi-space apply could never pass strict verify. Extras claimed by NO space
+* survive, so genuine drift still fails the runner's verdict.
+*
+* The result is issue-based, so the verdict recomputes directly from the
+* surviving list: `ok` holds exactly when it is empty.
+*/
+function scopeVerifyResultToSpace(result, ownedByOtherSpaces) {
+	if (ownedByOtherSpaces.size === 0) return result;
+	const issues = result.schema.issues.filter((issue) => {
+		const name = extraCollectionName(issue);
+		return name === void 0 || !ownedByOtherSpaces.has(name);
+	});
+	if (issues.length === result.schema.issues.length) return result;
+	const ok = issues.length === 0;
+	const { code: staleCode, ...envelope } = result;
+	return {
+		...envelope,
+		ok,
+		...ok ? {} : { code: result.code ?? VERIFY_CODE_SCHEMA_FAILURE },
+		summary: ok ? "Database schema satisfies contract" : result.summary,
+		schema: {
+			...result.schema,
+			issues
+		}
+	};
+}
+/**
+* `migration.ts` default-exports a `Migration` subclass whose `operations`
+* getter returns the ordered list of operations and whose `describe()`
+* returns the manifest identity metadata. `MongoMigrationPlanner.plan()`
+* returns a `MigrationPlanWithAuthoringSurface` that knows how to render
+* itself back to such a file; `MongoMigrationPlanner.emptyMigration()`
+* returns the same shape for `migration new`. Users run the scaffolded
+* `migration.ts` directly (via `node migration.ts`) to self-emit
+* `ops.json` and attest the `migrationHash`.
+*/
+const mongoTargetDescriptor = {
+	...mongoTargetDescriptorMeta,
+	contractSerializer: new MongoTargetContractSerializer(),
+	schemaVerifier: new MongoTargetSchemaVerifier(),
+	migrations: {
+		createPlanner(_adapter) {
+			return new MongoMigrationPlanner();
+		},
+		createRunner(family) {
+			let cachedDeps;
+			const runMongo = async (driver, runnerOptions) => {
+				cachedDeps ??= family.createRunnerDependencies({ driver });
+				return new MongoMigrationRunner(cachedDeps).execute({
+					...runnerOptions,
+					destinationContract: blindCast(runnerOptions.destinationContract)
+				});
+			};
+			return { async execute({ driver, perSpaceOptions }) {
+				const contracts = perSpaceOptions.map((opts) => blindCast(opts.destinationContract));
+				const perSpaceResults = [];
+				let changedDatabase = false;
+				for (let i = 0; i < perSpaceOptions.length; i++) {
+					const spaceOptions = perSpaceOptions[i];
+					if (!spaceOptions) continue;
+					const ownedByOtherSpaces = entityNamesDeclaredBy(contracts.filter((_, j) => j !== i));
+					const scopeVerifyResult = (result) => scopeVerifyResultToSpace(result, ownedByOtherSpaces);
+					const { space, ...runnerOptions } = spaceOptions;
+					const result = await runMongo(driver, {
+						...runnerOptions,
+						scopeVerifyResult,
+						databaseChangedBefore: changedDatabase
+					});
+					if (!result.ok) return notOk(withFailingSpace(result.failure, space));
+					const { changedDatabase: spaceChanged, ...value } = result.value;
+					changedDatabase ||= spaceChanged;
+					perSpaceResults.push({
+						space,
+						value
+					});
+				}
+				return ok({ perSpaceResults });
+			} };
+		},
+		contractToSchema(contract) {
+			return contractToMongoSchemaIR(blindCast(contract));
+		}
+	},
+	create() {
+		return {
+			familyId: "mongo",
+			targetId: "mongo"
+		};
+	}
+};
+//#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-Cq6qWohQ.mjs.map