@prisma-next/target-mongo 0.7.0 → 0.8.0-dev.1

package/dist/control.mjs

@@ -1,1214 +1,1000 @@
-import { n as contractToMongoSchemaIR, t as verifyMongoSchema } from "./verify-mongo-schema-DlPXaotB.mjs";
-import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-ZBsWqXt-.mjs";
-import { canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
-import { AggregateCommand, MongoAddFieldsStage, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoMergeStage, MongoProjectStage, MongoSortStage, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, RawUpdateManyCommand, RawUpdateOneCommand } from "@prisma-next/mongo-query-ast/execution";
-import { type } from "arktype";
+import { t as mongoTargetDescriptorMeta } from "./descriptor-meta-DdXFJeK1.mjs";
+import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-BRBKKZia.mjs";
+import { createMongoRunnerDeps, extractDb } from "@prisma-next/adapter-mongo/control";
+import { MongoDriverImpl } from "@prisma-next/driver-mongo";
+import { canonicalizeSchemasForVerification, contractToMongoSchemaIR, diffMongoSchemas } from "@prisma-next/family-mongo/control";
+import { projectSchemaToSpace } from "@prisma-next/migration-tools/aggregate";
+import { MongoSchemaIR, canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
+import { notOk, ok } from "@prisma-next/utils/result";
+import { TsExpression, jsonToTsSource, renderImports } from "@prisma-next/ts-render";
 import { CollModCommand, CreateCollectionCommand, CreateIndexCommand, DropCollectionCommand, DropIndexCommand, ListCollectionsCommand, ListIndexesCommand, MongoAndExpr, MongoExistsExpr, MongoFieldFilter, MongoNotExpr, MongoOrExpr } from "@prisma-next/mongo-query-ast/control";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { TsExpression, jsonToTsSource, renderImports } from "@prisma-next/ts-render";
 import { Migration } from "@prisma-next/migration-tools/migration";
 import { detectScaffoldRuntime, shebangLineFor } from "@prisma-next/migration-tools/migration-ts";
 import { errorRunnerFailed } from "@prisma-next/errors/execution";
+import { verifyMongoSchema } from "@prisma-next/family-mongo/schema-verify";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
-import { notOk, ok } from "@prisma-next/utils/result";
-//#region src/core/ddl-formatter.ts
-function formatKeySpec(keys) {
-	return `{ ${keys.map((k) => `${JSON.stringify(k.field)}: ${JSON.stringify(k.direction)}`).join(", ")} }`;
-}
-function formatOptions(cmd) {
-	const parts = [];
-	if (cmd.unique) parts.push("unique: true");
-	if (cmd.sparse) parts.push("sparse: true");
-	if (cmd.expireAfterSeconds !== void 0) parts.push(`expireAfterSeconds: ${cmd.expireAfterSeconds}`);
-	if (cmd.name) parts.push(`name: ${JSON.stringify(cmd.name)}`);
-	if (cmd.collation) parts.push(`collation: ${JSON.stringify(cmd.collation)}`);
-	if (cmd.weights) parts.push(`weights: ${JSON.stringify(cmd.weights)}`);
-	if (cmd.default_language) parts.push(`default_language: ${JSON.stringify(cmd.default_language)}`);
-	if (cmd.language_override) parts.push(`language_override: ${JSON.stringify(cmd.language_override)}`);
-	if (cmd.wildcardProjection) parts.push(`wildcardProjection: ${JSON.stringify(cmd.wildcardProjection)}`);
-	if (cmd.partialFilterExpression) parts.push(`partialFilterExpression: ${JSON.stringify(cmd.partialFilterExpression)}`);
-	if (parts.length === 0) return void 0;
-	return `{ ${parts.join(", ")} }`;
-}
-function formatCreateCollectionOptions(cmd) {
-	const parts = [];
-	if (cmd.capped) parts.push("capped: true");
-	if (cmd.size !== void 0) parts.push(`size: ${cmd.size}`);
-	if (cmd.max !== void 0) parts.push(`max: ${cmd.max}`);
-	if (cmd.timeseries) parts.push(`timeseries: ${JSON.stringify(cmd.timeseries)}`);
-	if (cmd.collation) parts.push(`collation: ${JSON.stringify(cmd.collation)}`);
-	if (cmd.clusteredIndex) parts.push(`clusteredIndex: ${JSON.stringify(cmd.clusteredIndex)}`);
-	if (cmd.validator) parts.push(`validator: ${JSON.stringify(cmd.validator)}`);
-	if (cmd.validationLevel) parts.push(`validationLevel: ${JSON.stringify(cmd.validationLevel)}`);
-	if (cmd.validationAction) parts.push(`validationAction: ${JSON.stringify(cmd.validationAction)}`);
-	if (cmd.changeStreamPreAndPostImages) parts.push(`changeStreamPreAndPostImages: ${JSON.stringify(cmd.changeStreamPreAndPostImages)}`);
-	if (parts.length === 0) return void 0;
-	return `{ ${parts.join(", ")} }`;
-}
-var MongoDdlCommandFormatter = class {
-	createIndex(cmd) {
-		const keySpec = formatKeySpec(cmd.keys);
-		const opts = formatOptions(cmd);
-		return opts ? `db.${cmd.collection}.createIndex(${keySpec}, ${opts})` : `db.${cmd.collection}.createIndex(${keySpec})`;
+import { AggregateCommand, MongoAddFieldsStage, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoMergeStage, MongoProjectStage, MongoSortStage, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, RawUpdateManyCommand, RawUpdateOneCommand } from "@prisma-next/mongo-query-ast/execution";
+import { type } from "arktype";
+import { MongoContractSerializerBase, MongoSchemaVerifierBase } from "@prisma-next/family-mongo/ir";
+import { NamespaceBase, UNSPECIFIED_NAMESPACE_ID, freezeNode } from "@prisma-next/framework-components/ir";
+import { MongoStorage } from "@prisma-next/mongo-contract";
+//#region src/core/op-factory-call.ts
+const TARGET_MIGRATION_MODULE = "@prisma-next/target-mongo/migration";
+var OpFactoryCallNode = class extends TsExpression {
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: this.factoryName
+		}];
 	}
-	dropIndex(cmd) {
-		return `db.${cmd.collection}.dropIndex(${JSON.stringify(cmd.name)})`;
+	freeze() {
+		Object.freeze(this);
 	}
-	createCollection(cmd) {
-		const opts = formatCreateCollectionOptions(cmd);
-		return opts ? `db.createCollection(${JSON.stringify(cmd.collection)}, ${opts})` : `db.createCollection(${JSON.stringify(cmd.collection)})`;
+};
+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();
 	}
-	dropCollection(cmd) {
-		return `db.${cmd.collection}.drop()`;
+	toOp() {
+		return createIndex(this.collection, this.keys, this.options);
 	}
-	collMod(cmd) {
-		const parts = [`collMod: ${JSON.stringify(cmd.collection)}`];
-		if (cmd.validator) parts.push(`validator: ${JSON.stringify(cmd.validator)}`);
-		if (cmd.validationLevel) parts.push(`validationLevel: ${JSON.stringify(cmd.validationLevel)}`);
-		if (cmd.validationAction) parts.push(`validationAction: ${JSON.stringify(cmd.validationAction)}`);
-		if (cmd.changeStreamPreAndPostImages) parts.push(`changeStreamPreAndPostImages: ${JSON.stringify(cmd.changeStreamPreAndPostImages)}`);
-		return `db.runCommand({ ${parts.join(", ")} })`;
+	renderTypeScript() {
+		return this.options ? `createIndex(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.keys)}, ${jsonToTsSource(this.options)})` : `createIndex(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.keys)})`;
 	}
 };
-const formatter = new MongoDdlCommandFormatter();
-function formatMongoOperations(operations) {
-	const statements = [];
-	for (const operation of operations) {
-		const candidate = operation;
-		if (!("execute" in candidate) || !Array.isArray(candidate["execute"])) continue;
-		for (const step of candidate["execute"]) if (step.command && typeof step.command.accept === "function") statements.push(step.command.accept(formatter));
+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();
 	}
-	return statements;
-}
-//#endregion
-//#region src/core/filter-evaluator.ts
-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];
+	toOp() {
+		return dropIndex(this.collection, this.keys);
 	}
-	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 new Error(`Unsupported filter operator in migration check: ${op}`);
+	renderTypeScript() {
+		return `dropIndex(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.keys)})`;
 	}
-}
-var FilterEvaluator = class {
-	doc = {};
-	evaluate(filter, doc) {
-		this.doc = doc;
-		return filter.accept(this);
+};
+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();
 	}
-	field(expr) {
-		const value = getNestedField(this.doc, expr.field);
-		return evaluateFieldOp(expr.op, value, expr.value);
+	toOp() {
+		return createCollection(this.collection, this.options);
 	}
-	and(expr) {
-		return expr.exprs.every((child) => child.accept(this));
+	renderTypeScript() {
+		return this.options ? `createCollection(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.options)})` : `createCollection(${jsonToTsSource(this.collection)})`;
 	}
-	or(expr) {
-		return expr.exprs.some((child) => child.accept(this));
+};
+var DropCollectionCall = class extends OpFactoryCallNode {
+	factoryName = "dropCollection";
+	operationClass = "destructive";
+	collection;
+	label;
+	constructor(collection) {
+		super();
+		this.collection = collection;
+		this.label = `Drop collection ${collection}`;
+		this.freeze();
 	}
-	not(expr) {
-		return !expr.expr.accept(this);
+	toOp() {
+		return dropCollection(this.collection);
 	}
-	exists(expr) {
-		const has = getNestedField(this.doc, expr.field) !== void 0;
-		return expr.exists ? has : !has;
+	renderTypeScript() {
+		return `dropCollection(${jsonToTsSource(this.collection)})`;
 	}
-	expr(_expr) {
-		throw new Error("Aggregation expression filters are not supported in migration checks");
+};
+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)})`;
 	}
 };
-//#endregion
-//#region src/core/marker-ledger.ts
-const COLLECTION = "_prisma_migrations";
-/**
-* Marker doc shape.
-*
-* Same fields as the SQL marker row but camelCase + Mongo-native types:
-* `Date` is BSON-hydrated, `meta` is a native object (not JSON-stringified),
-* `_id` and any extension fields are tolerated. `invariants?` is optional —
-* absent reads as `[]` (schemaless default); present-but-malformed throws.
-*
-* `space` is required: every marker doc is keyed by its space id (`_id`)
-* and stamped with a matching `space` field for partitioned reads.
-*/
-const MongoMarkerDocSchema = type({
-	space: "string",
-	storageHash: "string",
-	profileHash: "string",
-	"contractJson?": "unknown | null",
-	"canonicalVersion?": "number | null",
-	"updatedAt?": "Date",
-	"appTag?": "string | null",
-	"meta?": type({ "[string]": "unknown" }).or("null"),
-	"invariants?": type("string").array(),
-	"+": "delete"
-});
-function parseMongoMarkerDoc(doc) {
-	const result = MongoMarkerDocSchema(doc);
-	if (result instanceof type.errors) throw new Error(`Invalid marker doc on ${COLLECTION}: ${result.summary}`);
+function schemaIndexToCreateIndexOptions(index) {
 	return {
-		storageHash: result.storageHash,
-		profileHash: result.profileHash,
-		contractJson: result.contractJson ?? null,
-		canonicalVersion: result.canonicalVersion ?? null,
-		updatedAt: result.updatedAt ?? /* @__PURE__ */ new Date(),
-		appTag: result.appTag ?? null,
-		meta: result.meta ?? {},
-		invariants: result.invariants ?? []
+		unique: index.unique || void 0,
+		sparse: index.sparse,
+		expireAfterSeconds: index.expireAfterSeconds,
+		partialFilterExpression: index.partialFilterExpression,
+		wildcardProjection: index.wildcardProjection,
+		collation: index.collation,
+		weights: index.weights,
+		default_language: index.default_language,
+		language_override: index.language_override
 	};
 }
-async function executeAggregate(db, cmd) {
-	return db.collection(cmd.collection).aggregate(cmd.pipeline).toArray();
-}
-async function executeInsertOne(db, cmd) {
-	await db.collection(cmd.collection).insertOne(cmd.document);
-}
-async function executeFindOneAndUpdate(db, cmd) {
-	return db.collection(cmd.collection).findOneAndUpdate(cmd.filter, cmd.update, { upsert: cmd.upsert });
-}
-/**
-* Reads the marker document for the given contract space, or returns
-* `null` if no marker has been written for that space yet. Each space
-* owns one row keyed by `_id: <space>` — see ADR 212 for the per-space
-* mechanism this enables.
-*/
-async function readMarker(db, space) {
-	const doc = (await executeAggregate(db, new RawAggregateCommand(COLLECTION, [{ $match: {
-		_id: space,
-		space
-	} }, { $limit: 1 }])))[0];
-	if (!doc) return null;
-	return parseMongoMarkerDoc(doc);
-}
-/**
-* Reads every marker doc in the collection (one per contract space)
-* and returns them keyed by `space`. Used by the per-space verifier
-* to detect marker-vs-on-disk drift and orphan marker rows. Returns
-* an empty map when no marker docs have been written yet.
-*
-* Marker docs are keyed by `_id: <space>` (string); ledger entries
-* live in the same collection but use a driver-generated `ObjectId`
-* `_id` plus `type: 'ledger'`. The filter selects string-keyed docs
-* with a `space` field, which excludes ledger entries by construction.
-*/
-async function readAllMarkers(db) {
-	const docs = await executeAggregate(db, new RawAggregateCommand(COLLECTION, [{ $match: {
-		_id: { $type: "string" },
-		space: { $type: "string" },
-		$expr: { $eq: ["$_id", "$space"] }
-	} }]));
-	const out = /* @__PURE__ */ new Map();
-	for (const doc of docs) {
-		const space = doc["space"];
-		/* v8 ignore next -- @preserve type-narrowing guard: the $match stage above filters on `space: { $type: 'string' }`, so this branch is unreachable at runtime. The check exists so the `out.set(space, ...)` call below can accept `string`. */
-		if (typeof space !== "string") continue;
-		out.set(space, parseMongoMarkerDoc(doc));
-	}
-	return out;
+function schemaCollectionToCreateCollectionOptions(coll) {
+	const opts = coll.options;
+	const validator = coll.validator;
+	if (!opts && !validator) return void 0;
+	return {
+		capped: opts?.capped ? true : void 0,
+		size: opts?.capped?.size,
+		max: opts?.capped?.max,
+		timeseries: opts?.timeseries,
+		collation: opts?.collation,
+		clusteredIndex: opts?.clusteredIndex ? {
+			key: { _id: 1 },
+			unique: true,
+			...opts.clusteredIndex.name != null ? { name: opts.clusteredIndex.name } : {}
+		} : void 0,
+		validator: validator ? { $jsonSchema: validator.jsonSchema } : void 0,
+		validationLevel: validator?.validationLevel,
+		validationAction: validator?.validationAction,
+		changeStreamPreAndPostImages: opts?.changeStreamPreAndPostImages
+	};
 }
-async function initMarker(db, space, destination) {
-	await executeInsertOne(db, new RawInsertOneCommand(COLLECTION, {
-		_id: space,
-		space,
-		storageHash: destination.storageHash,
-		profileHash: destination.profileHash,
-		contractJson: null,
-		canonicalVersion: null,
-		updatedAt: /* @__PURE__ */ new Date(),
-		appTag: null,
-		meta: {},
-		invariants: destination.invariants ?? []
-	}));
+//#endregion
+//#region src/core/render-ops.ts
+function renderOps(calls) {
+	return calls.map((call) => call.toOp());
 }
+//#endregion
+//#region src/core/render-typescript.ts
 /**
-* Updates the marker doc for the given space atomically (CAS on
-* `expectedFrom`).
+* Always-present base imports for the rendered scaffold:
 *
-* `destination.invariants`:
-* - `undefined` → existing field left untouched.
-* - explicit value → merged into the existing field server-side via an
-*   aggregation pipeline (`$setUnion + $sortArray`), atomic at the
-*   document level. `[]` is a no-op merge.
+* - `Migration` from `@prisma-next/family-mongo/migration` — the
+*   user-facing Mongo `Migration` base; subclasses don't need to
+*   redeclare `targetId` or thread family/target generics.
+* - `MigrationCLI` from `@prisma-next/cli/migration-cli` — 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. (Mirrors the postgres facade pattern; pulling `MigrationCLI`
+*   into `@prisma-next/family-mongo/migration` so a Mongo migration only
+*   needs one import is tracked separately as a follow-up.)
 */
-async function updateMarker(db, space, expectedFrom, destination) {
-	const setBase = {
-		storageHash: destination.storageHash,
-		profileHash: destination.profileHash,
-		updatedAt: /* @__PURE__ */ new Date()
-	};
-	const update = destination.invariants === void 0 ? { $set: setBase } : [{ $set: {
-		...setBase,
-		invariants: { $sortArray: {
-			input: { $setUnion: [{ $ifNull: ["$invariants", []] }, destination.invariants] },
-			sortBy: 1
-		} }
-	} }];
-	return await executeFindOneAndUpdate(db, new RawFindOneAndUpdateCommand(COLLECTION, {
-		_id: space,
-		space,
-		storageHash: expectedFrom
-	}, update, false)) !== null;
-}
+const BASE_IMPORTS = [{
+	moduleSpecifier: "@prisma-next/family-mongo/migration",
+	symbol: "Migration"
+}, {
+	moduleSpecifier: "@prisma-next/cli/migration-cli",
+	symbol: "MigrationCLI"
+}];
 /**
-* Appends a ledger entry for the given space. Ledger entries co-exist
-* with marker docs in the same collection; marker docs use `_id: <space>`
-* (string), ledger entries use `type: 'ledger'` plus a driver-generated
-* ObjectId. Reads partition the two by filter shape.
+* Render a list of Mongo `OpFactoryCall`s as a `migration.ts`
+* source string. The result is shebanged, extends the user-facing
+* `Migration` (i.e. `MongoMigration`) from `@prisma-next/family-mongo`, and
+* implements the abstract `operations` and `describe` members. `meta` is
+* always rendered — `describe()` is part of the `Migration` contract, so
+* even an empty stub must satisfy it; callers pass `from: null` for a
+* baseline `migration-new` scaffold (and a real `to` hash either way).
 *
-* The same `edgeId` may legitimately recur across different spaces (e.g.
-* a synthetic ∅→head edge on first apply), so the ledger key is
-* `(space, edgeId)` — the doc carries `space` for partitioned reads.
+* 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` and `MigrationCLI` imports are always emitted — they're
+* structural to the rendered scaffold (extends `Migration`, calls
+* `MigrationCLI.run`), not driven by any node.
 */
-async function writeLedgerEntry(db, space, entry) {
-	await executeInsertOne(db, new RawInsertOneCommand(COLLECTION, {
-		type: "ledger",
-		space,
-		edgeId: entry.edgeId,
-		from: entry.from,
-		to: entry.to,
-		appliedAt: /* @__PURE__ */ new Date()
-	}));
-}
-//#endregion
-//#region src/core/mongo-ops-serializer.ts
-const CreateIndexJson = type({
-	kind: "\"createIndex\"",
-	collection: "string",
-	keys: type({
-		field: "string",
-		direction: type("1 | -1 | \"text\" | \"2dsphere\" | \"2d\" | \"hashed\"")
-	}).array().atLeastLength(1),
-	"unique?": "boolean",
-	"sparse?": "boolean",
-	"expireAfterSeconds?": "number",
-	"partialFilterExpression?": "Record<string, unknown>",
-	"name?": "string",
-	"wildcardProjection?": "Record<string, unknown>",
-	"collation?": "Record<string, unknown>",
-	"weights?": "Record<string, unknown>",
-	"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?": "Record<string, unknown>",
-	"collation?": "Record<string, unknown>",
-	"changeStreamPreAndPostImages?": "Record<string, unknown>",
-	"clusteredIndex?": "Record<string, unknown>"
-});
-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?": "Record<string, unknown>"
-});
-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 start -- assertion libraries always throw Error instances */
-		const message = error instanceof Error ? error.message : String(error);
-		/* v8 ignore stop */
-		throw new Error(`Invalid ${context}: ${message}`);
-	}
+function renderCallsToTypeScript(calls, meta) {
+	const imports = buildImports(calls);
+	const operationsBody = calls.map((c) => c.renderTypeScript()).join(",\n");
+	return [
+		shebangLineFor(detectScaffoldRuntime()),
+		imports,
+		"",
+		"class M extends Migration {",
+		buildDescribeMethod(meta),
+		"  override get operations() {",
+		"    return [",
+		indent(operationsBody, 6),
+		"    ];",
+		"  }",
+		"}",
+		"",
+		"export default M;",
+		"MigrationCLI.run(import.meta.url, M);",
+		""
+	].join("\n");
+}
+function buildImports(calls) {
+	const requirements = [...BASE_IMPORTS];
+	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
+	return renderImports(requirements);
+}
+function buildDescribeMethod(meta) {
+	const lines = [];
+	lines.push("  override describe() {");
+	lines.push("    return {");
+	lines.push(`      from: ${JSON.stringify(meta.from)},`);
+	lines.push(`      to: ${JSON.stringify(meta.to)},`);
+	if (meta.labels && meta.labels.length > 0) lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
+	lines.push("    };");
+	lines.push("  }");
+	lines.push("");
+	return lines.join("\n");
+}
+function indent(text, spaces) {
+	const pad = " ".repeat(spaces);
+	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : line).join("\n");
 }
+//#endregion
+//#region src/core/planner-produced-migration.ts
 /**
-* Strip `undefined`-valued properties before they reach arktype's optional-key
-* assertions.
+* Planner-produced Mongo migration, returned by `MongoMigrationPlanner.plan(...)`
+* and `MongoMigrationPlanner.emptyMigration(...)`.
 *
-* 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.
+* Unlike user-authored migrations (which extend `MongoMigration` from
+* `@prisma-next/family-mongo/migration`), 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`.
 *
-* 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.
+* Extends the framework `Migration` base class directly (not
+* `MongoMigration`) because `MongoMigration` lives in `@prisma-next/family-mongo`,
+* which depends on this package — extending it here would create a dependency
+* cycle.
 */
-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;
+var PlannerProducedMongoMigration = class extends Migration {
+	calls;
+	meta;
+	targetId = "mongo";
+	constructor(calls, meta) {
+		super();
+		this.calls = calls;
+		this.meta = meta;
 	}
-	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 new Error("Invalid and filter: missing exprs array");
-			return MongoAndExpr.of(exprs.map(deserializeFilterExpr));
-		}
-		case "or": {
-			const exprs = record["exprs"];
-			if (!Array.isArray(exprs)) throw new Error("Invalid or filter: missing exprs array");
-			return MongoOrExpr.of(exprs.map(deserializeFilterExpr));
-		}
-		case "not": {
-			const expr = record["expr"];
-			if (!expr || typeof expr !== "object") throw new Error("Invalid not filter: missing expr");
-			return new MongoNotExpr(deserializeFilterExpr(expr));
-		}
-		case "exists": {
-			const data = validate(ExistsFilterJson, json, "exists filter");
-			return new MongoExistsExpr(data.field, data.exists);
-		}
-		default: throw new Error(`Unknown filter expression kind: ${kind}`);
+	get operations() {
+		return renderOps(this.calls);
 	}
-}
-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 new Error(`Unknown pipeline stage kind: ${kind}`);
+	describe() {
+		return this.meta;
 	}
-}
-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 new Error(`Unknown DML command kind: ${kind}`);
+	renderTypeScript() {
+		return renderCallsToTypeScript(this.calls, {
+			from: this.meta.from,
+			to: this.meta.to,
+			...ifDefined("labels", this.meta.labels)
+		});
 	}
+};
+//#endregion
+//#region src/core/mongo-planner.ts
+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 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 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 deserializeDdlCommand(json) {
-	const kind = json["kind"];
-	switch (kind) {
-		case "createIndex": {
-			const data = validate(CreateIndexJson, json, "createIndex command");
-			return new CreateIndexCommand(data.collection, data.keys, {
-				unique: data.unique,
-				sparse: data.sparse,
-				expireAfterSeconds: data.expireAfterSeconds,
-				partialFilterExpression: data.partialFilterExpression,
-				name: data.name,
-				wildcardProjection: data.wildcardProjection,
-				collation: data.collation,
-				weights: data.weights,
-				default_language: data.default_language,
-				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, {
-				validator: data.validator,
-				validationLevel: data.validationLevel,
-				validationAction: data.validationAction,
-				capped: data.capped,
-				size: data.size,
-				max: data.max,
-				timeseries: data.timeseries,
-				collation: data.collation,
-				changeStreamPreAndPostImages: data.changeStreamPreAndPostImages,
-				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, {
-				validator: data.validator,
-				validationLevel: data.validationLevel,
-				validationAction: data.validationAction,
-				changeStreamPreAndPostImages: data.changeStreamPreAndPostImages
-			});
-		}
-		default: throw new Error(`Unknown DDL command kind: ${kind}`);
+function classifyValidatorUpdate(origin, dest) {
+	let hasDestructive = false;
+	if (canonicalize(origin.jsonSchema) !== canonicalize(dest.jsonSchema)) hasDestructive = true;
+	if (origin.validationAction !== dest.validationAction) {
+		if (dest.validationAction === "error") hasDestructive = true;
 	}
-}
-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 new Error(`Unknown inspection command kind: ${kind}`);
+	if (origin.validationLevel !== dest.validationLevel) {
+		if (dest.validationLevel === "strict") hasDestructive = true;
 	}
+	return hasDestructive ? "destructive" : "widening";
 }
-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 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 isDataTransformJson(json) {
-	return typeof json === "object" && json !== null && json["operationClass"] === "data";
+function collectionHasOptions(coll) {
+	return !!(coll.options || coll.validator);
 }
-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)
-	};
+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 = 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
+			})
+		};
+	}
+	/**
+	* 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
+		});
+	}
+};
+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 deserializeMongoOp(json) {
-	if (isDataTransformJson(json)) return deserializeDataTransformOp(json);
-	return deserializeDdlOp(json);
+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 deserializeMongoOps(json) {
-	return json.map(deserializeMongoOp);
+//#endregion
+//#region src/core/filter-evaluator.ts
+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 serializeMongoOps(ops) {
-	return JSON.stringify(ops, null, 2);
+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 new Error(`Unsupported filter operator in migration check: ${op}`);
+	}
 }
-//#endregion
-//#region src/core/op-factory-call.ts
-const TARGET_MIGRATION_MODULE = "@prisma-next/target-mongo/migration";
-var OpFactoryCallNode = class extends TsExpression {
-	importRequirements() {
-		return [{
-			moduleSpecifier: TARGET_MIGRATION_MODULE,
-			symbol: this.factoryName
-		}];
+var FilterEvaluator = class {
+	doc = {};
+	evaluate(filter, doc) {
+		this.doc = doc;
+		return filter.accept(this);
 	}
-	freeze() {
-		Object.freeze(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 new Error("Aggregation expression filters are not supported in migration checks");
+	}
+};
+//#endregion
+//#region src/core/mongo-ops-serializer.ts
+const CreateIndexJson = type({
+	kind: "\"createIndex\"",
+	collection: "string",
+	keys: type({
+		field: "string",
+		direction: type("1 | -1 | \"text\" | \"2dsphere\" | \"2d\" | \"hashed\"")
+	}).array().atLeastLength(1),
+	"unique?": "boolean",
+	"sparse?": "boolean",
+	"expireAfterSeconds?": "number",
+	"partialFilterExpression?": "Record<string, unknown>",
+	"name?": "string",
+	"wildcardProjection?": "Record<string, unknown>",
+	"collation?": "Record<string, unknown>",
+	"weights?": "Record<string, unknown>",
+	"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?": "Record<string, unknown>",
+	"collation?": "Record<string, unknown>",
+	"changeStreamPreAndPostImages?": "Record<string, unknown>",
+	"clusteredIndex?": "Record<string, unknown>"
+});
+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?": "Record<string, unknown>"
+});
+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 start -- assertion libraries always throw Error instances */
+		const message = error instanceof Error ? error.message : String(error);
+		/* v8 ignore stop */
+		throw new Error(`Invalid ${context}: ${message}`);
 	}
-};
-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)})`;
+/**
+* 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;
 	}
-};
-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();
+	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;
 	}
-	toOp() {
-		return collMod(this.collection, this.options, this.meta);
+	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 new Error("Invalid and filter: missing exprs array");
+			return MongoAndExpr.of(exprs.map(deserializeFilterExpr));
+		}
+		case "or": {
+			const exprs = record["exprs"];
+			if (!Array.isArray(exprs)) throw new Error("Invalid or filter: missing exprs array");
+			return MongoOrExpr.of(exprs.map(deserializeFilterExpr));
+		}
+		case "not": {
+			const expr = record["expr"];
+			if (!expr || typeof expr !== "object") throw new Error("Invalid not filter: missing expr");
+			return new MongoNotExpr(deserializeFilterExpr(expr));
+		}
+		case "exists": {
+			const data = validate(ExistsFilterJson, json, "exists filter");
+			return new MongoExistsExpr(data.field, data.exists);
+		}
+		default: throw new Error(`Unknown filter expression kind: ${kind}`);
 	}
-	renderTypeScript() {
-		return this.meta ? `collMod(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.options)}, ${jsonToTsSource(this.meta)})` : `collMod(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.options)})`;
+}
+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 new Error(`Unknown pipeline stage kind: ${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 new Error(`Unknown DML command kind: ${kind}`);
 	}
-};
-function schemaIndexToCreateIndexOptions(index) {
-	return {
-		unique: index.unique || void 0,
-		sparse: index.sparse,
-		expireAfterSeconds: index.expireAfterSeconds,
-		partialFilterExpression: index.partialFilterExpression,
-		wildcardProjection: index.wildcardProjection,
-		collation: index.collation,
-		weights: index.weights,
-		default_language: index.default_language,
-		language_override: index.language_override
-	};
 }
-function schemaCollectionToCreateCollectionOptions(coll) {
-	const opts = coll.options;
-	const validator = coll.validator;
-	if (!opts && !validator) return void 0;
+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 {
-		capped: opts?.capped ? true : void 0,
-		size: opts?.capped?.size,
-		max: opts?.capped?.max,
-		timeseries: opts?.timeseries,
-		collation: opts?.collation,
-		clusteredIndex: opts?.clusteredIndex ? {
-			key: { _id: 1 },
-			unique: true,
-			...opts.clusteredIndex.name != null ? { name: opts.clusteredIndex.name } : {}
-		} : void 0,
-		validator: validator ? { $jsonSchema: validator.jsonSchema } : void 0,
-		validationLevel: validator?.validationLevel,
-		validationAction: validator?.validationAction,
-		changeStreamPreAndPostImages: opts?.changeStreamPreAndPostImages
+		collection: data.collection,
+		command,
+		meta
 	};
 }
-//#endregion
-//#region src/core/render-ops.ts
-function renderOps(calls) {
-	return calls.map((call) => call.toOp());
-}
-//#endregion
-//#region src/core/render-typescript.ts
-/**
-* Always-present base imports for the rendered scaffold:
-*
-* - `Migration` from `@prisma-next/family-mongo/migration` — the
-*   user-facing Mongo `Migration` base; subclasses don't need to
-*   redeclare `targetId` or thread family/target generics.
-* - `MigrationCLI` from `@prisma-next/cli/migration-cli` — 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. (Mirrors the postgres facade pattern; pulling `MigrationCLI`
-*   into `@prisma-next/family-mongo/migration` so a Mongo migration only
-*   needs one import is tracked separately as a follow-up.)
-*/
-const BASE_IMPORTS = [{
-	moduleSpecifier: "@prisma-next/family-mongo/migration",
-	symbol: "Migration"
-}, {
-	moduleSpecifier: "@prisma-next/cli/migration-cli",
-	symbol: "MigrationCLI"
-}];
-/**
-* Render a list of Mongo `OpFactoryCall`s as a `migration.ts`
-* source string. The result is shebanged, extends the user-facing
-* `Migration` (i.e. `MongoMigration`) from `@prisma-next/family-mongo`, and
-* implements the abstract `operations` and `describe` members. `meta` is
-* always rendered — `describe()` is part of the `Migration` contract, so
-* even an empty stub must satisfy it; callers pass `from: null` for a
-* baseline `migration-new` scaffold (and a real `to` hash either way).
-*
-* 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` and `MigrationCLI` imports are always emitted — they're
-* structural to the rendered scaffold (extends `Migration`, calls
-* `MigrationCLI.run`), not driven by any node.
-*/
-function renderCallsToTypeScript(calls, meta) {
-	const imports = buildImports(calls);
-	const operationsBody = calls.map((c) => c.renderTypeScript()).join(",\n");
-	return [
-		shebangLineFor(detectScaffoldRuntime()),
-		imports,
-		"",
-		"class M extends Migration {",
-		buildDescribeMethod(meta),
-		"  override get operations() {",
-		"    return [",
-		indent(operationsBody, 6),
-		"    ];",
-		"  }",
-		"}",
-		"",
-		"export default M;",
-		"MigrationCLI.run(import.meta.url, M);",
-		""
-	].join("\n");
-}
-function buildImports(calls) {
-	const requirements = [...BASE_IMPORTS];
-	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
-	return renderImports(requirements);
+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, {
+				unique: data.unique,
+				sparse: data.sparse,
+				expireAfterSeconds: data.expireAfterSeconds,
+				partialFilterExpression: data.partialFilterExpression,
+				name: data.name,
+				wildcardProjection: data.wildcardProjection,
+				collation: data.collation,
+				weights: data.weights,
+				default_language: data.default_language,
+				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, {
+				validator: data.validator,
+				validationLevel: data.validationLevel,
+				validationAction: data.validationAction,
+				capped: data.capped,
+				size: data.size,
+				max: data.max,
+				timeseries: data.timeseries,
+				collation: data.collation,
+				changeStreamPreAndPostImages: data.changeStreamPreAndPostImages,
+				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, {
+				validator: data.validator,
+				validationLevel: data.validationLevel,
+				validationAction: data.validationAction,
+				changeStreamPreAndPostImages: data.changeStreamPreAndPostImages
+			});
+		}
+		default: throw new Error(`Unknown DDL command kind: ${kind}`);
+	}
 }
-function buildDescribeMethod(meta) {
-	const lines = [];
-	lines.push("  override describe() {");
-	lines.push("    return {");
-	lines.push(`      from: ${JSON.stringify(meta.from)},`);
-	lines.push(`      to: ${JSON.stringify(meta.to)},`);
-	if (meta.labels && meta.labels.length > 0) lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
-	lines.push("    };");
-	lines.push("  }");
-	lines.push("");
-	return lines.join("\n");
+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 new Error(`Unknown inspection command kind: ${kind}`);
+	}
 }
-function indent(text, spaces) {
-	const pad = " ".repeat(spaces);
-	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : line).join("\n");
+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
+	};
 }
-//#endregion
-//#region src/core/planner-produced-migration.ts
-/**
-* Planner-produced Mongo migration, returned by `MongoMigrationPlanner.plan(...)`
-* and `MongoMigrationPlanner.emptyMigration(...)`.
-*
-* Unlike user-authored migrations (which extend `MongoMigration` from
-* `@prisma-next/family-mongo/migration`), 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`.
-*
-* Extends the framework `Migration` base class directly (not
-* `MongoMigration`) because `MongoMigration` lives in `@prisma-next/family-mongo`,
-* which depends on this package — extending it here would create a dependency
-* cycle.
-*/
-var PlannerProducedMongoMigration = class extends Migration {
-	calls;
-	meta;
-	targetId = "mongo";
-	constructor(calls, meta) {
-		super();
-		this.calls = calls;
-		this.meta = meta;
-	}
-	get operations() {
-		return renderOps(this.calls);
-	}
-	describe() {
-		return this.meta;
-	}
-	renderTypeScript() {
-		return renderCallsToTypeScript(this.calls, {
-			from: this.meta.from,
-			to: this.meta.to,
-			...ifDefined("labels", this.meta.labels)
-		});
-	}
-};
-//#endregion
-//#region src/core/mongo-planner.ts
-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 deserializeStep(json) {
+	const data = validate(StepJson, json, "migration step");
+	return {
+		description: data.description,
+		command: deserializeDdlCommand(data.command)
+	};
 }
-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 isDataTransformJson(json) {
+	return typeof json === "object" && json !== null && json["operationClass"] === "data";
 }
-function classifyValidatorUpdate(origin, dest) {
-	let hasDestructive = false;
-	if (canonicalize(origin.jsonSchema) !== canonicalize(dest.jsonSchema)) hasDestructive = true;
-	if (origin.validationAction !== dest.validationAction) {
-		if (dest.validationAction === "error") hasDestructive = true;
-	}
-	if (origin.validationLevel !== dest.validationLevel) {
-		if (dest.validationLevel === "strict") hasDestructive = true;
-	}
-	return hasDestructive ? "destructive" : "widening";
+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 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 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 collectionHasOptions(coll) {
-	return !!(coll.options || coll.validator);
+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)
+	};
 }
-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 = 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
-			})
-		};
-	}
-	/**
-	* 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
-		});
-	}
-};
-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 deserializeMongoOp(json) {
+	if (isDataTransformJson(json)) return deserializeDataTransformOp(json);
+	return deserializeDdlOp(json);
 }
-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 deserializeMongoOps(json) {
+	return json.map(deserializeMongoOp);
+}
+function serializeMongoOps(ops) {
+	return JSON.stringify(ops, null, 2);
 }
 //#endregion
 //#region src/core/mongo-runner.ts
@@ -1394,6 +1180,276 @@ var MongoMigrationRunner = class {
 	}
 };
 //#endregion
-export { CollModCall, CreateCollectionCall, CreateIndexCall, DropCollectionCall, DropIndexCall, FilterEvaluator, MongoMigrationPlanner, MongoMigrationRunner, PlannerProducedMongoMigration, contractToMongoSchemaIR, deserializeMongoOp, deserializeMongoOps, formatMongoOperations, initMarker, readAllMarkers, readMarker, renderCallsToTypeScript, renderOps, schemaCollectionToCreateCollectionOptions, schemaIndexToCreateIndexOptions, serializeMongoOps, updateMarker, writeLedgerEntry };
+//#region src/core/mongo-target-database.ts
+/**
+* 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.
+*
+* 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 unspecified singleton overrides these
+* methods to elide the prefix entirely — call sites stay polymorphic and
+* never branch on `id === UNSPECIFIED_NAMESPACE_ID`.
+*
+* **Freeze-trap warning.** The constructor calls `freezeNode(this)` at
+* the end. Direct subclasses MUST NOT add instance fields — the freeze
+* runs in this base constructor and any subclass field assignment will
+* silently fail in non-strict mode or throw in strict mode. The
+* `MongoTargetUnspecifiedDatabase` singleton below is intentionally
+* field-free for this reason; if a future subclass needs to carry
+* additional fields, lift this `freezeNode` to the leaf-class
+* constructors (or to a `seal()` hook each leaf calls explicitly).
+*/
+var MongoTargetDatabase = class extends NamespaceBase {
+	kind = "database";
+	id;
+	constructor(id) {
+		super();
+		this.id = id;
+		freezeNode(this);
+	}
+	/**
+	* The bare qualifier as it would appear in a rendered string. The
+	* unspecified-database singleton overrides this to return `''`.
+	*/
+	qualifier() {
+		return this.id;
+	}
+	/**
+	* Qualify a collection name with the database prefix. The
+	* unspecified-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
+* (`UNSPECIFIED_NAMESPACE_ID`). 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 no-database-bound means here (the
+* collection name, naked).
+*/
+var MongoTargetUnspecifiedDatabase = class MongoTargetUnspecifiedDatabase extends MongoTargetDatabase {
+	static instance = new MongoTargetUnspecifiedDatabase();
+	constructor() {
+		super(UNSPECIFIED_NAMESPACE_ID);
+	}
+	qualifier() {
+		return "";
+	}
+	qualifyCollection(collectionName) {
+		return collectionName;
+	}
+};
+//#endregion
+//#region src/core/mongo-target-contract-serializer.ts
+/**
+* Mongo target `ContractSerializer` concretion. Plugs into the
+* family-shared deserialization pipeline at `constructTargetContract`,
+* wrapping the validated flat-data shape in a `MongoStorage` class
+* instance and providing the target's default namespace map.
+*
+* Default namespaces is
+* `{ [UNSPECIFIED_NAMESPACE_ID]: MongoTargetUnspecifiedDatabase.instance }`
+* — supplied at this target-layer call site because the family-layer
+* `MongoStorage` class is target-agnostic (it cannot import the
+* Mongo-target's namespace concretion). Contracts authored before
+* multi-namespace support bind to the unspecified singleton without the
+* call site declaring anything.
+*
+* `validated.storage.collections` already carries `MongoCollection` IR
+* class instances by the time this method runs — the family-base
+* `hydrateMongoContract` walks the arktype-validated tree and
+* constructs class instances before validation. The target serializer
+* just wraps the envelope.
+*/
+var MongoTargetContractSerializer = class extends MongoContractSerializerBase {
+	constructTargetContract(validated) {
+		const { storage, ...rest } = validated;
+		const targetStorage = new MongoStorage({
+			storageHash: storage.storageHash,
+			collections: storage.collections,
+			namespaces: { [UNSPECIFIED_NAMESPACE_ID]: MongoTargetUnspecifiedDatabase.instance }
+		});
+		return {
+			...rest,
+			storage: targetStorage
+		};
+	}
+	/**
+	* Produce the canonical on-disk JSON shape from an in-memory Mongo
+	* contract. Strips runtime-only fields the storage class carries
+	* for its live-instance API but that don't belong in the persisted
+	* envelope: `MongoStorage.namespaces` is a Namespace-class map the
+	* verifier and runtime walk; the persisted shape omits it (today's
+	* contracts have a single implicit unspecified namespace; future
+	* explicit per-collection assignment will surface in JSON via a
+	* different field).
+	*
+	* Constructing the JsonObject here — rather than relying on
+	* non-enumerable property tricks at the storage class — keeps the
+	* "what's on disk" decision in the SPI implementer, where it
+	* belongs.
+	*/
+	serializeContract(contract) {
+		const { storage, ...rest } = contract;
+		return {
+			...rest,
+			storage: {
+				storageHash: storage.storageHash,
+				collections: storage.collections
+			}
+		};
+	}
+};
+//#endregion
+//#region src/core/mongo-target-schema-verifier.ts
+/**
+* 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 unspecified singleton, materialised as
+* `MongoTargetUnspecifiedDatabase`), 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 { issues } = diffMongoSchemas(live, expected, false);
+		return issues;
+	}
+	verifyTargetExtensions(_options) {
+		return [];
+	}
+};
+//#endregion
+//#region src/core/control-target.ts
+/**
+* `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(_family) {
+			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: runnerOptions.destinationContract
+				});
+			};
+			return {
+				async execute(options) {
+					const { driver, ...runnerOptions } = options;
+					return runMongo(driver, runnerOptions);
+				},
+				async executeAcrossSpaces({ driver, perSpaceOptions }) {
+					const members = perSpaceOptions.map(toSpaceMember);
+					const perSpaceResults = [];
+					for (let i = 0; i < perSpaceOptions.length; i++) {
+						const spaceOptions = perSpaceOptions[i];
+						if (!spaceOptions) continue;
+						const member = members[i];
+						if (!member) continue;
+						const others = members.filter((_, j) => j !== i);
+						const projectSchema = (schema) => {
+							return new MongoSchemaIR(projectSchemaToSpace(schema, member, others).collections);
+						};
+						const result = await runMongo(driver, {
+							...spaceOptions,
+							projectSchema
+						});
+						if (!result.ok) return notOk({
+							...result.failure,
+							failingSpace: spaceOptions.space
+						});
+						perSpaceResults.push({
+							space: spaceOptions.space,
+							value: result.value
+						});
+					}
+					return ok({ perSpaceResults });
+				}
+			};
+		},
+		contractToSchema(contract) {
+			return contractToMongoSchemaIR(contract);
+		}
+	},
+	create() {
+		return {
+			familyId: "mongo",
+			targetId: "mongo"
+		};
+	}
+};
+/**
+* Synthesise the minimum {@link projectSchemaToSpace}-compatible
+* `ContractSpaceMember` shape from a per-space option entry. The
+* projector only reads `spaceId` and `contract.storage`; the rest of
+* `ContractSpaceMember` (head ref invariants, hydrated migration
+* graph) is irrelevant at runner time and stubbed with sentinels.
+*
+* The `as unknown as ContractSpaceMember` cast is the load-bearing bit
+* — the projector duck-types its members so a sentinel-shaped graph
+* never gets read, but the framework type carries a richer shape.
+*/
+function toSpaceMember(opts) {
+	return {
+		spaceId: opts.space,
+		contract: opts.destinationContract,
+		headRef: {
+			hash: "",
+			invariants: []
+		},
+		migrations: {
+			graph: {
+				nodes: /* @__PURE__ */ new Set(),
+				forwardChain: /* @__PURE__ */ new Map(),
+				reverseChain: /* @__PURE__ */ new Map(),
+				migrationByHash: /* @__PURE__ */ new Map()
+			},
+			packagesByMigrationHash: /* @__PURE__ */ new Map()
+		}
+	};
+}
+//#endregion
+export { CollModCall, CreateCollectionCall, CreateIndexCall, DropCollectionCall, DropIndexCall, FilterEvaluator, MongoMigrationPlanner, MongoMigrationRunner, MongoTargetContractSerializer, MongoTargetDatabase, MongoTargetSchemaVerifier, MongoTargetUnspecifiedDatabase, PlannerProducedMongoMigration, deserializeMongoOp, deserializeMongoOps, mongoTargetDescriptor, renderCallsToTypeScript, renderOps, schemaCollectionToCreateCollectionOptions, schemaIndexToCreateIndexOptions, serializeMongoOps };
 
 //# sourceMappingURL=control.mjs.map