@prisma-next/family-mongo 0.4.0-dev.9 → 0.4.2

package/README.md

@@ -23,6 +23,7 @@ This package is the Mongo family integration point for both control-plane assemb
 - `./control`: control-plane entrypoint exporting `mongoFamilyDescriptor`, `mongoTargetDescriptor`, `createMongoFamilyInstance`, and `MongoControlFamilyInstance`
 - `./migration`: migration authoring — `Migration` class, factory functions, and strategies (re-exported from `@prisma-next/target-mongo/migration`)
 - `./pack`: pure pack ref for TypeScript authoring flows such as `@prisma-next/mongo-contract-ts/contract-builder`
+- `./schema-verify`: re-exports the pure `verifyMongoSchema(...)` from `@prisma-next/target-mongo/schema-verify`. `MongoFamilyInstance.schemaVerify` (i.e. `db verify --schema-only`) and the `MongoMigrationRunner` post-apply verify step both call into this shared verifier, so both surfaces agree on "matches the contract" by construction
 
 ## Usage
 
@@ -99,15 +100,16 @@ The current `contract.ts` slice supports roots and collections, typed reference
 ### Migration authoring
 
 ```typescript
+import { MigrationCLI } from "@prisma-next/cli/migration-cli"
 import { Migration, createIndex, createCollection }
   from "@prisma-next/family-mongo/migration"
 
 class AddUsersCollection extends Migration {
-  describe() {
+  override describe() {
     return { from: "abc123", to: "def456", labels: ["add-users"] }
   }
 
-  plan() {
+  override get operations() {
     return [
       createCollection("users", {
         validator: { $jsonSchema: { required: ["email"] } },
@@ -119,7 +121,7 @@ class AddUsersCollection extends Migration {
 }
 
 export default AddUsersCollection;
-Migration.run(import.meta.url, AddUsersCollection)
+MigrationCLI.run(import.meta.url, AddUsersCollection);
 ```
 
 Run `node migration.ts` to produce `ops.json` and `migration.json`. Use `--dry-run` to preview without writing.
@@ -133,6 +135,7 @@ Run `node migration.ts` to produce `ops.json` and `migration.json`. Use `--dry-r
 - `src/exports/control.ts`: control-plane entrypoint
 - `src/exports/migration.ts`: migration authoring entrypoint
 - `src/exports/pack.ts`: authoring-time family pack ref
+- `src/exports/schema-verify.ts`: schema-verify entrypoint that re-exports from `@prisma-next/target-mongo/schema-verify`
 
 ## Dependencies
 

package/dist/control.d.mts

@@ -1,6 +1,6 @@
 import { ControlFamilyDescriptor, ControlFamilyInstance, ControlStack, MigratableTargetDescriptor, SchemaViewCapable } from "@prisma-next/framework-components/control";
-import { MongoSchemaIR } from "@prisma-next/mongo-schema-ir";
 import { Contract } from "@prisma-next/contract/types";
+import { MongoSchemaIR } from "@prisma-next/mongo-schema-ir";
 
 //#region src/core/control-instance.d.ts
 interface MongoControlFamilyInstance extends ControlFamilyInstance<'mongo', MongoSchemaIR>, SchemaViewCapable<MongoSchemaIR> {
@@ -13,20 +13,14 @@ declare const mongoFamilyDescriptor: ControlFamilyDescriptor<'mongo', MongoContr
 //#endregion
 //#region src/core/mongo-target-descriptor.d.ts
 /**
- * The Mongo target uses the **class-flow** migration authoring strategy.
- *
  * `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`. `migration emit` dispatches
- * to `mongoEmit`, which dynamic-imports the class and writes `ops.json`.
- *
- * The descriptor-flow hooks (`planWithDescriptors`, `resolveDescriptors`,
- * `renderDescriptorTypeScript`) are intentionally omitted — the CLI's
- * `migrationStrategy` selector routes Mongo down the class-flow path by
- * observing their absence.
+ * 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 `migrationId`.
  */
 declare const mongoTargetDescriptor: MigratableTargetDescriptor<'mongo', 'mongo', MongoControlFamilyInstance>;
 //#endregion

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-instance.ts","../src/core/control-descriptor.ts","../src/core/mongo-target-descriptor.ts"],"sourcesContent":[],"mappings":";;;;;UAgCiB,0BAAA,SACP,+BAA+B,gBACrC,kBAAkB;2CACqB;AAH3C;AACyC,iBAkSzB,yBAAA,CAlSyB,aAAA,EAkSgB,YAlShB,CAAA,EAkS+B,0BAlS/B;;;cCV5B,uBAAuB,iCAAiC;;;;;;ADSrE;;;;;;;AAmSA;;;;AC5SA;;cCQa,uBAAuB,6CAGlC"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-instance.ts","../src/core/control-descriptor.ts","../src/core/mongo-target-descriptor.ts"],"sourcesContent":[],"mappings":";;;;;UA2BiB,0BAAA,SACP,+BAA+B,gBACrC,kBAAkB;2CACqB;AAH3C;AACyC,iBAqRzB,yBAAA,CArRyB,aAAA,EAqRgB,YArRhB,CAAA,EAqR+B,0BArR/B;;;cCL5B,uBAAuB,iCAAiC;;;;;;ADIrE;;;;;;;AAsRgB,cEtRH,qBFsR4B,EEtRL,0BFsRoC,CAAA,OAAA,EAAA,OAA0B,EEnRhG,0BFmRgG,CAAA"}

package/dist/control.mjs

@@ -1,335 +1,13 @@
 import { mongoEmission } from "@prisma-next/mongo-emitter";
 import { createMongoRunnerDeps, extractDb, introspectSchema } from "@prisma-next/adapter-mongo/control";
-import { SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_SCHEMA_FAILURE, VERIFY_CODE_TARGET_MISMATCH } from "@prisma-next/framework-components/control";
+import { SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH } from "@prisma-next/framework-components/control";
 import { validateMongoContract } from "@prisma-next/mongo-contract";
 import { MongoMigrationPlanner, MongoMigrationRunner, contractToMongoSchemaIR, initMarker, readMarker, updateMarker } from "@prisma-next/target-mongo/control";
+import { verifyMongoSchema } from "@prisma-next/target-mongo/schema-verify";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
 import { MongoDriverImpl } from "@prisma-next/driver-mongo";
 import mongoTargetDescriptorMeta from "@prisma-next/target-mongo/pack";
-import { stat } from "node:fs/promises";
-import { pathToFileURL } from "node:url";
-import { errorMigrationFileMissing, errorMigrationInvalidDefaultExport, errorMigrationPlanNotArray } from "@prisma-next/errors/migration";
-import { writeMigrationOps } from "@prisma-next/migration-tools/io";
-import { Migration } from "@prisma-next/migration-tools/migration";
-import { join } from "pathe";
 
-//#region src/core/schema-diff.ts
-function diffMongoSchemas(live, expected, strict) {
-	const issues = [];
-	const collectionChildren = [];
-	let pass = 0;
-	let warn = 0;
-	let fail = 0;
-	const allNames = new Set([...live.collectionNames, ...expected.collectionNames]);
-	for (const name of [...allNames].sort()) {
-		const liveColl = live.collection(name);
-		const expectedColl = expected.collection(name);
-		if (!liveColl && expectedColl) {
-			issues.push({
-				kind: "missing_table",
-				table: name,
-				message: `Collection "${name}" is missing from the database`
-			});
-			collectionChildren.push({
-				status: "fail",
-				kind: "collection",
-				name,
-				contractPath: `storage.collections.${name}`,
-				code: "MISSING_COLLECTION",
-				message: `Collection "${name}" is missing`,
-				expected: name,
-				actual: null,
-				children: []
-			});
-			fail++;
-			continue;
-		}
-		if (liveColl && !expectedColl) {
-			const status = strict ? "fail" : "warn";
-			issues.push({
-				kind: "extra_table",
-				table: name,
-				message: `Extra collection "${name}" exists in the database but not in the contract`
-			});
-			collectionChildren.push({
-				status,
-				kind: "collection",
-				name,
-				contractPath: `storage.collections.${name}`,
-				code: "EXTRA_COLLECTION",
-				message: `Extra collection "${name}" found`,
-				expected: null,
-				actual: name,
-				children: []
-			});
-			if (status === "fail") fail++;
-			else warn++;
-			continue;
-		}
-		const lc = liveColl;
-		const ec = expectedColl;
-		const indexChildren = diffIndexes(name, lc, ec, strict, issues);
-		const validatorChildren = diffValidator(name, lc, ec, strict, issues);
-		const optionsChildren = diffOptions(name, lc, ec, strict, issues);
-		const children = [
-			...indexChildren,
-			...validatorChildren,
-			...optionsChildren
-		];
-		const worstStatus = children.reduce((s, c) => c.status === "fail" ? "fail" : c.status === "warn" && s !== "fail" ? "warn" : s, "pass");
-		for (const c of children) if (c.status === "pass") pass++;
-		else if (c.status === "warn") warn++;
-		else fail++;
-		if (children.length === 0) pass++;
-		collectionChildren.push({
-			status: worstStatus,
-			kind: "collection",
-			name,
-			contractPath: `storage.collections.${name}`,
-			code: worstStatus === "pass" ? "MATCH" : "DRIFT",
-			message: worstStatus === "pass" ? `Collection "${name}" matches` : `Collection "${name}" has drift`,
-			expected: name,
-			actual: name,
-			children
-		});
-	}
-	const rootStatus = fail > 0 ? "fail" : warn > 0 ? "warn" : "pass";
-	const totalNodes = pass + warn + fail + collectionChildren.length;
-	return {
-		root: {
-			status: rootStatus,
-			kind: "root",
-			name: "mongo-schema",
-			contractPath: "storage",
-			code: rootStatus === "pass" ? "MATCH" : "DRIFT",
-			message: rootStatus === "pass" ? "Schema matches" : "Schema has drift",
-			expected: null,
-			actual: null,
-			children: collectionChildren
-		},
-		issues,
-		counts: {
-			pass,
-			warn,
-			fail,
-			totalNodes
-		}
-	};
-}
-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 formatIndexName(index) {
-	return index.keys.map((k) => `${k.field}:${k.direction}`).join(", ");
-}
-function diffIndexes(collName, live, expected, strict, issues) {
-	const nodes = [];
-	const liveLookup = /* @__PURE__ */ new Map();
-	for (const idx of live.indexes) liveLookup.set(buildIndexLookupKey(idx), idx);
-	const expectedLookup = /* @__PURE__ */ new Map();
-	for (const idx of expected.indexes) expectedLookup.set(buildIndexLookupKey(idx), idx);
-	for (const [key, idx] of expectedLookup) if (liveLookup.has(key)) nodes.push({
-		status: "pass",
-		kind: "index",
-		name: formatIndexName(idx),
-		contractPath: `storage.collections.${collName}.indexes`,
-		code: "MATCH",
-		message: `Index ${formatIndexName(idx)} matches`,
-		expected: key,
-		actual: key,
-		children: []
-	});
-	else {
-		issues.push({
-			kind: "index_mismatch",
-			table: collName,
-			indexOrConstraint: formatIndexName(idx),
-			message: `Index ${formatIndexName(idx)} missing on collection "${collName}"`
-		});
-		nodes.push({
-			status: "fail",
-			kind: "index",
-			name: formatIndexName(idx),
-			contractPath: `storage.collections.${collName}.indexes`,
-			code: "MISSING_INDEX",
-			message: `Index ${formatIndexName(idx)} missing`,
-			expected: key,
-			actual: null,
-			children: []
-		});
-	}
-	for (const [key, idx] of liveLookup) if (!expectedLookup.has(key)) {
-		const status = strict ? "fail" : "warn";
-		issues.push({
-			kind: "extra_index",
-			table: collName,
-			indexOrConstraint: formatIndexName(idx),
-			message: `Extra index ${formatIndexName(idx)} on collection "${collName}"`
-		});
-		nodes.push({
-			status,
-			kind: "index",
-			name: formatIndexName(idx),
-			contractPath: `storage.collections.${collName}.indexes`,
-			code: "EXTRA_INDEX",
-			message: `Extra index ${formatIndexName(idx)}`,
-			expected: null,
-			actual: key,
-			children: []
-		});
-	}
-	return nodes;
-}
-function diffValidator(collName, live, expected, strict, issues) {
-	if (!live.validator && !expected.validator) return [];
-	if (expected.validator && !live.validator) {
-		issues.push({
-			kind: "type_missing",
-			table: collName,
-			message: `Validator missing on collection "${collName}"`
-		});
-		return [{
-			status: "fail",
-			kind: "validator",
-			name: "validator",
-			contractPath: `storage.collections.${collName}.validator`,
-			code: "MISSING_VALIDATOR",
-			message: "Validator missing",
-			expected: canonicalize(expected.validator.jsonSchema),
-			actual: null,
-			children: []
-		}];
-	}
-	if (!expected.validator && live.validator) {
-		const status = strict ? "fail" : "warn";
-		issues.push({
-			kind: "extra_validator",
-			table: collName,
-			message: `Extra validator on collection "${collName}"`
-		});
-		return [{
-			status,
-			kind: "validator",
-			name: "validator",
-			contractPath: `storage.collections.${collName}.validator`,
-			code: "EXTRA_VALIDATOR",
-			message: "Extra validator found",
-			expected: null,
-			actual: canonicalize(live.validator.jsonSchema),
-			children: []
-		}];
-	}
-	const liveVal = live.validator;
-	const expectedVal = expected.validator;
-	const liveSchema = canonicalize(liveVal.jsonSchema);
-	const expectedSchema = canonicalize(expectedVal.jsonSchema);
-	if (liveSchema !== expectedSchema || liveVal.validationLevel !== expectedVal.validationLevel || liveVal.validationAction !== expectedVal.validationAction) {
-		issues.push({
-			kind: "type_mismatch",
-			table: collName,
-			expected: expectedSchema,
-			actual: liveSchema,
-			message: `Validator mismatch on collection "${collName}"`
-		});
-		return [{
-			status: "fail",
-			kind: "validator",
-			name: "validator",
-			contractPath: `storage.collections.${collName}.validator`,
-			code: "VALIDATOR_MISMATCH",
-			message: "Validator mismatch",
-			expected: {
-				jsonSchema: expectedVal.jsonSchema,
-				validationLevel: expectedVal.validationLevel,
-				validationAction: expectedVal.validationAction
-			},
-			actual: {
-				jsonSchema: liveVal.jsonSchema,
-				validationLevel: liveVal.validationLevel,
-				validationAction: liveVal.validationAction
-			},
-			children: []
-		}];
-	}
-	return [{
-		status: "pass",
-		kind: "validator",
-		name: "validator",
-		contractPath: `storage.collections.${collName}.validator`,
-		code: "MATCH",
-		message: "Validator matches",
-		expected: expectedSchema,
-		actual: liveSchema,
-		children: []
-	}];
-}
-function diffOptions(collName, live, expected, strict, issues) {
-	if (!live.options && !expected.options) return [];
-	if (!expected.options && live.options) {
-		const status = strict ? "fail" : "warn";
-		issues.push({
-			kind: "type_mismatch",
-			table: collName,
-			actual: canonicalize(live.options),
-			message: `Extra collection options on "${collName}"`
-		});
-		return [{
-			status,
-			kind: "options",
-			name: "options",
-			contractPath: `storage.collections.${collName}.options`,
-			code: "EXTRA_OPTIONS",
-			message: "Extra collection options found",
-			expected: null,
-			actual: live.options,
-			children: []
-		}];
-	}
-	if (deepEqual(live.options, expected.options)) return [{
-		status: "pass",
-		kind: "options",
-		name: "options",
-		contractPath: `storage.collections.${collName}.options`,
-		code: "MATCH",
-		message: "Collection options match",
-		expected: canonicalize(expected.options),
-		actual: canonicalize(live.options),
-		children: []
-	}];
-	issues.push({
-		kind: "type_mismatch",
-		table: collName,
-		expected: canonicalize(expected.options),
-		actual: canonicalize(live.options),
-		message: `Collection options mismatch on "${collName}"`
-	});
-	return [{
-		status: "fail",
-		kind: "options",
-		name: "options",
-		contractPath: `storage.collections.${collName}.options`,
-		code: "OPTIONS_MISMATCH",
-		message: "Collection options mismatch",
-		expected: expected.options,
-		actual: live.options,
-		children: []
-	}];
-}
-
-//#endregion
 //#region src/core/schema-to-view.ts
 function mongoSchemaToView(schema) {
 	const collectionNodes = schema.collections.map((collection) => collectionToSchemaNode(collection.name, collection));
@@ -490,31 +168,17 @@ var MongoFamilyInstance = class {
 	}
 	async schemaVerify(options) {
 		const { driver, contract: rawContract, strict, contractPath, configPath } = options;
-		const startTime = Date.now();
 		const contract = validateMongoContract(rawContract).contract;
-		const { root, issues, counts } = diffMongoSchemas(await introspectSchema(extractDb$1(driver)), contractToMongoSchemaIR(contract), strict);
-		const ok = counts.fail === 0;
-		return {
-			ok,
-			...ifDefined("code", ok ? void 0 : VERIFY_CODE_SCHEMA_FAILURE),
-			summary: ok ? "Schema matches contract" : `Schema verification found ${counts.fail} issue(s)`,
-			contract: {
-				storageHash: contract.storage.storageHash,
-				...ifDefined("profileHash", contract.profileHash)
-			},
-			target: { expected: contract.target },
-			schema: {
-				issues,
-				root,
-				counts
-			},
-			meta: {
-				...ifDefined("contractPath", contractPath),
-				...ifDefined("configPath", configPath),
-				strict
-			},
-			timings: { total: Date.now() - startTime }
-		};
+		return verifyMongoSchema({
+			contract,
+			schema: await introspectSchema(extractDb$1(driver)),
+			strict,
+			frameworkComponents: options.frameworkComponents,
+			context: {
+				contractPath,
+				...ifDefined("configPath", configPath)
+			}
+		});
 	}
 	async sign(options) {
 		const { driver, contract: rawContract, contractPath, configPath } = options;
@@ -627,109 +291,17 @@ var MongoFamilyDescriptor = class {
 };
 const mongoFamilyDescriptor = new MongoFamilyDescriptor();
 
-//#endregion
-//#region src/core/mongo-emit.ts
-/**
-* Mongo's in-process implementation of the `emit` capability on
-* `TargetMigrationsCapability`. Invoked by the framework's class-flow emit
-* dispatcher in `@prisma-next/cli/lib/migration-emit` — see that module's
-* preamble for the cross-cutting story (when the CLI dispatches here, who
-* attests `migration.json`, why both flows produce byte-identical artifacts,
-* and the relationship to the self-emitting `Migration.run` shebang path).
-*
-* Mongo-specific responsibilities of this helper:
-*
-*  - Accept two authoring shapes for `migration.ts`'s default export, both
-*    adhering to the `MigrationPlan` interface:
-*
-*      1. Class subclass (canonical, scaffolded form):
-*           class M extends Migration {
-*             override get operations() { return [...]; }
-*             override describe() { return { from, to }; }
-*           }
-*           export default M;
-*           Migration.run(import.meta.url, M);
-*
-*      2. Factory function returning a MigrationPlan-shaped object:
-*           export default () => ({
-*             targetId: 'mongo',
-*             destination: { storageHash: '...' },
-*             operations: [createCollection("users")],
-*           });
-*
-*    Only the class form is scaffolded; the factory form is supported for
-*    authors who prefer it.
-*  - Dynamic-import the file so structured errors thrown during evaluation
-*    (notably `placeholder(...)`) surface to the CLI as real exceptions.
-*  - Dispatch on the default export's shape and validate the factory return
-*    is `MigrationPlan`-shaped.
-*  - Persist `ops.json` via the framework I/O helper and return the
-*    operations to the caller (which performs attestation).
-*/
-const MIGRATION_TS_FILE = "migration.ts";
-/**
-* Implementation of `TargetMigrationsCapability.emit` for Mongo.
-*
-* Loads `<dir>/migration.ts` and dispatches on the default export's shape:
-* if it is a `Migration` subclass, instantiates it; otherwise invokes it as a
-* factory function (sync or async) and validates the returned value is
-* `MigrationPlan`-shaped. In both cases reads `.operations` to produce the
-* operations list, writes `ops.json`, and returns the operations for the
-* framework helper to render. Attestation of `migration.json` is the
-* caller's responsibility: the framework's `emitMigration` helper calls
-* `attestMigration` after this function returns. This capability MUST NOT
-* call `attestMigration` itself, to avoid double-attestation when the helper
-* drives emit.
-*/
-async function mongoEmit(options) {
-	const filePath = join(options.dir, MIGRATION_TS_FILE);
-	try {
-		await stat(filePath);
-	} catch {
-		throw errorMigrationFileMissing(options.dir);
-	}
-	const MigrationExport = (await import(pathToFileURL(filePath).href)).default;
-	if (typeof MigrationExport !== "function") throw errorMigrationInvalidDefaultExport(options.dir, `default export of type ${typeof MigrationExport}`);
-	let plan;
-	if (MigrationExport.prototype instanceof Migration) plan = new MigrationExport();
-	else {
-		let factoryResult;
-		try {
-			factoryResult = await MigrationExport();
-		} catch (error) {
-			if (error instanceof TypeError && /cannot be invoked without 'new'/i.test(error.message)) throw errorMigrationInvalidDefaultExport(options.dir, "a default export that does not extend Migration (from @prisma-next/migration-tools/migration)");
-			throw error;
-		}
-		if (typeof factoryResult !== "object" || factoryResult === null || !("operations" in factoryResult)) throw errorMigrationInvalidDefaultExport(options.dir, `factory must return a MigrationPlan-shaped object; got ${describeValue(factoryResult)}`);
-		plan = factoryResult;
-	}
-	const operations = plan.operations;
-	if (!Array.isArray(operations)) throw errorMigrationPlanNotArray(options.dir, describeValue(operations));
-	await writeMigrationOps(options.dir, operations);
-	return operations;
-}
-function describeValue(value) {
-	if (value === null) return "null";
-	return `a value of type ${typeof value}`;
-}
-
 //#endregion
 //#region src/core/mongo-target-descriptor.ts
 /**
-* The Mongo target uses the **class-flow** migration authoring strategy.
-*
 * `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`. `migration emit` dispatches
-* to `mongoEmit`, which dynamic-imports the class and writes `ops.json`.
-*
-* The descriptor-flow hooks (`planWithDescriptors`, `resolveDescriptors`,
-* `renderDescriptorTypeScript`) are intentionally omitted — the CLI's
-* `migrationStrategy` selector routes Mongo down the class-flow path by
-* observing their absence.
+* 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 `migrationId`.
 */
 const mongoTargetDescriptor = {
 	...mongoTargetDescriptorMeta,
@@ -737,18 +309,20 @@ const mongoTargetDescriptor = {
 		createPlanner(_family) {
 			return new MongoMigrationPlanner();
 		},
-		createRunner(_family) {
+		createRunner(family) {
 			let cachedDeps;
 			return { async execute(options) {
-				cachedDeps ??= createMongoRunnerDeps(options.driver, MongoDriverImpl.fromDb(extractDb(options.driver)));
+				cachedDeps ??= createMongoRunnerDeps(options.driver, MongoDriverImpl.fromDb(extractDb(options.driver)), family);
 				const { driver: _, ...runnerOptions } = options;
-				return new MongoMigrationRunner(cachedDeps).execute(runnerOptions);
+				return new MongoMigrationRunner(cachedDeps).execute({
+					...runnerOptions,
+					destinationContract: runnerOptions.destinationContract
+				});
 			} };
 		},
 		contractToSchema(contract) {
 			return contractToMongoSchemaIR(contract);
-		},
-		emit: mongoEmit
+		}
 	},
 	create() {
 		return {