@prisma/orm-target-mongo 0.16.0-dev.36

package/dist/control-CEXmcht7.mjs

@@ -0,0 +1,1563 @@
+import { t as mongoTargetDescriptorMeta } from "./descriptor-meta-CBiaTwe5-HX742pZh.mjs";
+import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-CCJFG_3e-75oJ8xn2.mjs";
+import { i as extractDb, r as createMongoRunnerDeps } from "./control-BOc5lrQg.mjs";
+import { n as MongoDriverImpl } from "./mongo-driver-C7zThOjZ-BcMrlirh.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { NamespaceBase, UNBOUND_NAMESPACE_ID, elementCoordinates, freezeNode, hydrateNamespaceEntities } from "@prisma/orm-framework/components/ir";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { CollModCommand, CreateCollectionCommand, CreateIndexCommand, DropCollectionCommand, DropIndexCommand, ListCollectionsCommand, ListIndexesCommand, MongoAndExpr, MongoExistsExpr, MongoFieldFilter, MongoNotExpr, MongoOrExpr } 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 { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { canonicalize, deepEqual } from "@prisma/orm-family-mongo/schema-ir";
+import { errorRunnerFailed } from "@prisma/orm-framework/errors/execution";
+import { type } from "arktype";
+import { canonicalizeSchemasForVerification, contractToMongoSchemaIR, diffMongoSchemas } from "@prisma/orm-family-mongo/family/control";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { TsExpression, jsonToTsSource, renderImports } from "@prisma/orm-framework/ts-render";
+import { Migration } from "@prisma/orm-toolchain/migration-tools/migration";
+import { APP_SPACE_ID, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, issueOutcome } from "@prisma/orm-framework/components/control";
+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";
+import { MongoContractSerializerBase, MongoSchemaVerifierBase } from "@prisma/orm-family-mongo/family/ir";
+import { MongoStorage } from "@prisma/orm-family-mongo/contract";
+import { composeMongoEntityKinds } from "@prisma/orm-family-mongo/contract/entity-kinds";
+//#region ../../../3-mongo-target/1-mongo-target/dist/control.mjs
+/**
+* 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 = "destructive";
+	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 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 ?? "destructive";
+		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)
+	};
+}
+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-next.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 buildIndexLookupKey(index) {
+	const keys = index.keys.map((k) => `${k.field}:${k.direction}`).join(",");
+	const opts = [
+		index.unique ? "unique" : "",
+		index.sparse ? "sparse" : "",
+		index.expireAfterSeconds != null ? `ttl:${index.expireAfterSeconds}` : "",
+		index.partialFilterExpression ? `pfe:${canonicalize(index.partialFilterExpression)}` : "",
+		index.wildcardProjection ? `wp:${canonicalize(index.wildcardProjection)}` : "",
+		index.collation ? `col:${canonicalize(index.collation)}` : "",
+		index.weights ? `wt:${canonicalize(index.weights)}` : "",
+		index.default_language ? `dl:${index.default_language}` : "",
+		index.language_override ? `lo:${index.language_override}` : ""
+	].filter(Boolean).join(";");
+	return opts ? `${keys}|${opts}` : keys;
+}
+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 classifyValidatorUpdate(origin, dest) {
+	if (origin.validationAction !== dest.validationAction && dest.validationAction === "error") return "destructive";
+	if (origin.validationLevel !== dest.validationLevel && dest.validationLevel === "strict") return "destructive";
+	if (canonicalize(origin.jsonSchema) === canonicalize(dest.jsonSchema)) return "widening";
+	return isWideningSchemaChange(origin.jsonSchema, dest.jsonSchema) ? "widening" : "destructive";
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+* Returns true when `dest` is a structural superset of `origin` for the common
+* additive case: adding non-required properties to a top-level object schema.
+* Anything uncertain falls through to the safe `destructive` default.
+*/
+function isWideningSchemaChange(origin, dest) {
+	if (origin["bsonType"] !== "object" || dest["bsonType"] !== "object") return false;
+	const allKeys = /* @__PURE__ */ new Set([...Object.keys(origin), ...Object.keys(dest)]);
+	for (const key of allKeys) {
+		if (key === "required" || key === "properties") continue;
+		if (canonicalize(origin[key]) !== canonicalize(dest[key])) return false;
+	}
+	const originRequired = new Set(Array.isArray(origin["required"]) ? origin["required"] : []);
+	const destRequired = Array.isArray(dest["required"]) ? dest["required"] : [];
+	for (const field of destRequired) if (!originRequired.has(field)) return false;
+	const originProps = isPlainObject(origin["properties"]) ? origin["properties"] : {};
+	const destProps = isPlainObject(dest["properties"]) ? dest["properties"] : {};
+	for (const field of Object.keys(originProps)) {
+		if (!Object.hasOwn(destProps, field)) return false;
+		if (canonicalize(originProps[field]) !== canonicalize(destProps[field])) return false;
+	}
+	return true;
+}
+function hasImmutableOptionChange(origin, dest) {
+	if (canonicalize(origin?.capped) !== canonicalize(dest?.capped)) return "capped";
+	if (canonicalize(origin?.timeseries) !== canonicalize(dest?.timeseries)) return "timeseries";
+	if (canonicalize(origin?.collation) !== canonicalize(dest?.collation)) return "collation";
+	if (canonicalize(origin?.clusteredIndex) !== canonicalize(dest?.clusteredIndex)) return "clusteredIndex";
+}
+function collectionHasOptions(coll) {
+	return !!(coll.options || coll.validator);
+}
+var MongoMigrationPlanner = class {
+	planCalls(options) {
+		const contract = options.contract;
+		const originIR = options.schema;
+		const destinationIR = contractToMongoSchemaIR(contract);
+		const collCreates = [];
+		const drops = [];
+		const creates = [];
+		const validatorOps = [];
+		const mutableOptionOps = [];
+		const collDrops = [];
+		const conflicts = [];
+		const allCollectionNames = /* @__PURE__ */ new Set([...originIR.collectionNames, ...destinationIR.collectionNames]);
+		for (const collName of [...allCollectionNames].sort()) {
+			const originColl = originIR.collection(collName);
+			const destColl = destinationIR.collection(collName);
+			if (!originColl) {
+				if (destColl && (collectionHasOptions(destColl) || destColl.indexes.length === 0)) {
+					const opts = collectionHasOptions(destColl) ? schemaCollectionToCreateCollectionOptions(destColl) : void 0;
+					collCreates.push(new CreateCollectionCall(collName, opts));
+				}
+			} else if (!destColl) collDrops.push(new DropCollectionCall(collName));
+			else {
+				const immutableChange = hasImmutableOptionChange(originColl.options, destColl.options);
+				if (immutableChange) conflicts.push({
+					kind: "policy-violation",
+					summary: `Cannot change immutable collection option '${immutableChange}' on ${collName}`,
+					why: `MongoDB does not support modifying the '${immutableChange}' option after collection creation`
+				});
+				const mutableCall = planMutableOptionsDiffCall(collName, originColl.options, destColl.options);
+				if (mutableCall) mutableOptionOps.push(mutableCall);
+				const validatorCall = planValidatorDiffCall(collName, originColl.validator, destColl.validator);
+				if (validatorCall) validatorOps.push(validatorCall);
+			}
+			const originLookup = /* @__PURE__ */ new Map();
+			if (originColl) for (const idx of originColl.indexes) originLookup.set(buildIndexLookupKey(idx), idx);
+			const destLookup = /* @__PURE__ */ new Map();
+			if (destColl) for (const idx of destColl.indexes) destLookup.set(buildIndexLookupKey(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)));
+		}
+		if (conflicts.length > 0) return {
+			kind: "failure",
+			conflicts
+		};
+		const allCalls = [
+			...collCreates,
+			...drops,
+			...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`
+		});
+		if (conflicts.length > 0) return {
+			kind: "failure",
+			conflicts
+		};
+		return {
+			kind: "success",
+			calls: allCalls
+		};
+	}
+	plan(options) {
+		const contract = options.contract;
+		const result = this.planCalls(options);
+		if (result.kind === "failure") return result;
+		return {
+			kind: "success",
+			plan: new PlannerProducedMongoMigration(result.calls, {
+				from: options.fromContract?.storage.storageHash ?? null,
+				to: contract.storage.storageHash
+			}, options.snapshotsImportPath)
+		};
+	}
+	/**
+	* 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 planValidatorDiffCall(collName, originValidator, destValidator) {
+	if (validatorsEqual(originValidator, destValidator)) return void 0;
+	if (destValidator) {
+		const operationClass = originValidator ? classifyValidatorUpdate(originValidator, destValidator) : "destructive";
+		return new CollModCall(collName, {
+			validator: { $jsonSchema: destValidator.jsonSchema },
+			validationLevel: destValidator.validationLevel,
+			validationAction: destValidator.validationAction
+		}, {
+			id: `validator.${collName}.${originValidator ? "update" : "add"}`,
+			label: `${originValidator ? "Update" : "Add"} validator on ${collName}`,
+			operationClass
+		});
+	}
+	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;
+	const desiredCSPPI = destCSPPI ?? { enabled: false };
+	return new CollModCall(collName, { changeStreamPreAndPostImages: desiredCSPPI }, {
+		id: `options.${collName}.update`,
+		label: `Update mutable options on ${collName}`,
+		operationClass: desiredCSPPI.enabled ? "widening" : "destructive"
+	});
+}
+function mongoTargetError(code, message, options) {
+	return structuredError(code, message, options);
+}
+function getNestedField(doc, path) {
+	const parts = path.split(".");
+	let current = doc;
+	for (const part of parts) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		const record = current;
+		if (!Object.hasOwn(record, part)) return;
+		current = record[part];
+	}
+	return 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 && actual > expected;
+		case "$gte": return typeof actual === typeof expected && actual >= expected;
+		case "$lt": return typeof actual === typeof expected && actual < expected;
+		case "$lte": return typeof actual === typeof expected && actual <= 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 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 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>[]"
+});
+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 CheckJson = type({
+	description: "string",
+	source: "Record<string, unknown>",
+	filter: "Record<string, unknown>",
+	expect: "\"exists\" | \"notExists\""
+});
+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 DataTransformCheckJson = type({
+	description: "string",
+	source: "Record<string, unknown>",
+	filter: "Record<string, unknown>",
+	expect: "\"exists\" | \"notExists\""
+});
+const DataTransformOperationJson = type({
+	id: "string",
+	label: "string",
+	operationClass: "\"data\"",
+	name: "string",
+	precheck: "Record<string, unknown>[]",
+	run: "Record<string, unknown>[]",
+	postcheck: "Record<string, unknown>[]"
+});
+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 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 : value;
+}
+function deserializeFilterExpr(json) {
+	const record = json;
+	const kind = record["kind"];
+	switch (kind) {
+		case "field": {
+			const data = validate(FieldFilterJson, json, "field filter");
+			return MongoFieldFilter.of(data.field, data.op, data.value);
+		}
+		case "and": {
+			const exprs = record["exprs"];
+			if (!Array.isArray(exprs)) throw mongoTargetError("MIGRATION.INVALID_OPERATION_ENTRY", "Invalid and filter: missing exprs array", { meta: { context: "and filter" } });
+			return MongoAndExpr.of(exprs.map(deserializeFilterExpr));
+		}
+		case "or": {
+			const exprs = record["exprs"];
+			if (!Array.isArray(exprs)) throw mongoTargetError("MIGRATION.INVALID_OPERATION_ENTRY", "Invalid or filter: missing exprs array", { meta: { context: "or filter" } });
+			return MongoOrExpr.of(exprs.map(deserializeFilterExpr));
+		}
+		case "not": {
+			const expr = record["expr"];
+			if (!expr || typeof expr !== "object") throw mongoTargetError("MIGRATION.INVALID_OPERATION_ENTRY", "Invalid not filter: missing expr", { meta: { context: "not filter" } });
+			return new MongoNotExpr(deserializeFilterExpr(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 record = json;
+	const kind = record["kind"];
+	switch (kind) {
+		case "match": return new MongoMatchStage(deserializeFilterExpr(record["filter"]));
+		case "limit": return new MongoLimitStage(record["limit"]);
+		case "sort": return new MongoSortStage(record["sort"]);
+		case "project": return new MongoProjectStage(record["projection"]);
+		case "addFields": return new MongoAddFieldsStage(record["fields"]);
+		case "lookup": {
+			const opts = {
+				from: record["from"],
+				as: record["as"]
+			};
+			if (record["localField"] !== void 0) opts.localField = record["localField"];
+			if (record["foreignField"] !== void 0) opts.foreignField = record["foreignField"];
+			if (record["pipeline"] !== void 0) opts.pipeline = record["pipeline"].map(deserializePipelineStage);
+			if (record["let_"] !== void 0) opts.let_ = record["let_"];
+			return new MongoLookupStage(opts);
+		}
+		case "merge": {
+			const opts = { into: record["into"] };
+			if (record["on"] !== void 0) opts.on = record["on"];
+			if (record["whenMatched"] !== void 0) {
+				const wm = record["whenMatched"];
+				opts.whenMatched = typeof wm === "string" ? wm : wm.map(deserializePipelineStage);
+			}
+			if (record["whenNotMatched"] !== void 0) opts.whenNotMatched = record["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 = json["kind"];
+	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);
+		}
+		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 = json["kind"];
+	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 "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 = json["kind"];
+	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
+	};
+}
+function deserializeStep(json) {
+	const data = validate(StepJson, json, "migration step");
+	return {
+		description: data.description,
+		command: deserializeDdlCommand(data.command)
+	};
+}
+function isDataTransformJson(json) {
+	return typeof json === "object" && json !== null && json["operationClass"] === "data";
+}
+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 deserializeDataTransformCheck(json) {
+	const data = validate(DataTransformCheckJson, json, "data transform check");
+	return {
+		description: data.description,
+		source: deserializeMongoQueryPlan(data.source),
+		filter: deserializeFilterExpr(data.filter),
+		expect: data.expect
+	};
+}
+function deserializeDataTransformOp(json) {
+	const data = validate(DataTransformOperationJson, json, "data transform operation");
+	return {
+		id: data.id,
+		label: data.label,
+		operationClass: "data",
+		name: data.name,
+		precheck: data.precheck.map(deserializeDataTransformCheck),
+		run: data.run.map(deserializeMongoQueryPlan),
+		postcheck: data.postcheck.map(deserializeDataTransformCheck)
+	};
+}
+function deserializeMongoOp(json) {
+	if (isDataTransformJson(json)) return deserializeDataTransformOp(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"]);
+function runnerFailure(code, summary, opts) {
+	return notOk({
+		code,
+		summary,
+		...opts
+	});
+}
+var MongoMigrationRunner = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async execute(options) {
+		const { inspectionExecutor, adapter, driver, executeDdl, markerOps } = this.deps;
+		const operations = deserializeMongoOps(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 (operation.operationClass === "data") {
+					const result = await this.executeDataTransform(operation, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks);
+					if (result.failure) return result.failure;
+					if (result.executed) operationsExecuted += 1;
+					continue;
+				}
+				const ddlOp = operation;
+				if (runPostchecks && runIdempotency) {
+					if (await this.allChecksSatisfied(ddlOp.postcheck, inspectionExecutor, filterEvaluator)) continue;
+				}
+				if (runPrechecks) {
+					if (!await this.evaluateChecks(ddlOp.precheck, inspectionExecutor, filterEvaluator)) return runnerFailure("MIGRATION.PRECHECK_FAILED", `Operation ${operation.id} failed during precheck`, { meta: { operationId: operation.id } });
+				}
+				for (const step of ddlOp.execute) await executeDdl(step.command);
+				if (runPostchecks) {
+					if (!await this.evaluateChecks(ddlOp.postcheck, inspectionExecutor, filterEvaluator)) return runnerFailure("MIGRATION.POSTCHECK_FAILED", `Operation ${operation.id} failed during postcheck`, { meta: { operationId: operation.id } });
+				}
+				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: "The resulting database schema does not satisfy the destination contract.",
+				meta: { issues: verifyResult.schema.issues }
+			});
+			if (existingMarker) {
+				if (!await markerOps.updateMarker(space, existingMarker.storageHash, {
+					storageHash: destination.storageHash,
+					profileHash,
+					invariants: incomingInvariants
+				})) return runnerFailure("MIGRATION.MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
+					space,
+					expectedStorageHash: existingMarker.storageHash,
+					destinationStorageHash: destination.storageHash
+				} });
+			} else await markerOps.initMarker(space, {
+				storageHash: destination.storageHash,
+				profileHash,
+				invariants: incomingInvariants
+			});
+			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 executeDataTransform(op, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks) {
+		if (runPostchecks && runIdempotency && op.postcheck.length > 0) {
+			if (await this.evaluateDataTransformChecks(op.postcheck, adapter, driver, filterEvaluator)) return { executed: false };
+		}
+		if (runPrechecks && op.precheck.length > 0) {
+			if (!await this.evaluateDataTransformChecks(op.precheck, adapter, driver, filterEvaluator)) return {
+				executed: false,
+				failure: 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, {});
+			for await (const _ of driver.execute(wireCommand));
+		}
+		if (runPostchecks && op.postcheck.length > 0) {
+			if (!await this.evaluateDataTransformChecks(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 evaluateDataTransformChecks(checks, adapter, driver, filterEvaluator) {
+		for (const check of checks) {
+			const commandKind = check.source.command.kind;
+			if (!READ_ONLY_CHECK_COMMAND_KINDS.has(commandKind)) throw errorRunnerFailed(`Data-transform check rejected: command kind "${commandKind}" is not read-only`, {
+				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) {
+		for (const check of checks) {
+			const matchFound = (await check.source.accept(inspectionExecutor)).some((doc) => filterEvaluator.evaluate(check.filter, doc));
+			if (!(check.expect === "exists" ? matchFound : !matchFound)) return false;
+		}
+		return true;
+	}
+	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 `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] = 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
+			}
+		});
+	}
+};
+/**
+* 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 ?? "CONTRACT.MARKER_REQUIRED" },
+		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 ??= createMongoRunnerDeps(driver, MongoDriverImpl.fromDb(extractDb(driver)), family);
+				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 = [];
+				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
+					});
+					if (!result.ok) return notOk({
+						...result.failure,
+						failingSpace: space
+					});
+					perSpaceResults.push({
+						space,
+						value: result.value
+					});
+				}
+				return ok({ perSpaceResults });
+			} };
+		},
+		contractToSchema(contract) {
+			return contractToMongoSchemaIR(blindCast(contract));
+		}
+	},
+	create() {
+		return {
+			familyId: "mongo",
+			targetId: "mongo"
+		};
+	}
+};
+//#endregion
+export { renderCallsToTypeScript as _, DropIndexCall as a, schemaIndexToCreateIndexOptions as b, MongoMigrationRunner as c, MongoTargetSchemaVerifier as d, MongoTargetUnboundDatabase as f, mongoTargetDescriptor as g, deserializeMongoOps as h, DropCollectionCall as i, MongoTargetContractSerializer as l, deserializeMongoOp as m, CreateCollectionCall as n, FilterEvaluator as o, PlannerProducedMongoMigration as p, CreateIndexCall as r, MongoMigrationPlanner as s, CollModCall as t, MongoTargetDatabase as u, renderOps as v, serializeMongoOps as x, schemaCollectionToCreateCollectionOptions as y };
+
+//# sourceMappingURL=control-CEXmcht7.mjs.map