@prisma-next/target-mongo 0.4.1 → 0.4.3

package/README.md

@@ -14,6 +14,8 @@ MongoDB target pack for Prisma Next.
 - `./pack`: pure target pack ref used by `@prisma-next/family-mongo` and `@prisma-next/mongo-contract-ts`
 - `./codec-types`: base Mongo codec type map
 - `./migration`: factory functions (the `Migration` base class is in `@prisma-next/family-mongo/migration`)
+- `./control`: `MongoMigrationRunner` and `createMongoRunnerDeps` for runtime migration execution
+- `./schema-verify`: pure `verifyMongoSchema(...)` (no DB I/O); composes `contractToMongoSchemaIR` and `diffMongoSchemas` so the runner's post-apply verify step and `MongoFamilyInstance.schemaVerify` agree on "matches the contract" by construction
 
 ## Usage
 
@@ -33,6 +35,7 @@ const contract = defineContract({
 ### Migration authoring
 
 ```typescript
+import { MigrationCLI } from '@prisma-next/cli/migration-cli';
 import { Migration } from '@prisma-next/family-mongo/migration';
 import { createIndex, createCollection } from '@prisma-next/target-mongo/migration';
 
@@ -49,7 +52,7 @@ class UsersMigration extends Migration {
 }
 
 export default UsersMigration;
-Migration.run(import.meta.url, UsersMigration)
+MigrationCLI.run(import.meta.url, UsersMigration);
 ```
 
 Run `tsx migration.ts` to produce `ops.json` and `migration.json` (when `describe()` is implemented). Use `--dry-run` to preview without writing.

package/dist/control.d.mts

@@ -1,11 +1,11 @@
-import { a as DropCollectionCall, c as schemaCollectionToCreateCollectionOptions, i as CreateIndexCall, l as schemaIndexToCreateIndexOptions, n as CollModMeta, o as DropIndexCall, r as CreateCollectionCall, s as OpFactoryCall, t as CollModCall } from "./op-factory-call-BjNAcPSF.mjs";
+import { a as DropCollectionCall, c as schemaCollectionToCreateCollectionOptions, i as CreateIndexCall, l as schemaIndexToCreateIndexOptions, n as CollModMeta, o as DropIndexCall, r as CreateCollectionCall, s as OpFactoryCall, t as CollModCall } from "./op-factory-call--nK5dk8n.mjs";
 import { MongoSchemaIR } from "@prisma-next/mongo-schema-ir";
 import { MongoQueryPlan } from "@prisma-next/mongo-query-ast/execution";
 import { AnyMongoMigrationOperation, MongoAndExpr, MongoDdlCommandVisitor, MongoExistsExpr, MongoExprFilter, MongoFieldFilter, MongoFilterExpr, MongoFilterVisitor, MongoInspectionCommandVisitor, MongoMigrationPlanOperation, MongoNotExpr, MongoOrExpr } from "@prisma-next/mongo-query-ast/control";
 import { Migration, MigrationMeta } from "@prisma-next/migration-tools/migration";
+import { MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerResult, MigrationRunnerExecutionChecks, MigrationRunnerResult, MigrationScaffoldContext, OperationContext } from "@prisma-next/framework-components/control";
 import { MongoContract } from "@prisma-next/mongo-contract";
-import { MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerResult, MigrationRunnerExecutionChecks, MigrationRunnerResult, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
-import { ContractMarkerRecord } from "@prisma-next/contract/types";
+import { Contract, ContractMarkerRecord } from "@prisma-next/contract/types";
 import { Db } from "mongodb";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
 import { MongoAdapter, MongoDriver } from "@prisma-next/mongo-lowering";
@@ -33,10 +33,21 @@ declare function readMarker(db: Db): Promise<ContractMarkerRecord | null>;
 declare function initMarker(db: Db, destination: {
   readonly storageHash: string;
   readonly profileHash: string;
+  readonly invariants?: readonly string[];
 }): Promise<void>;
+/**
+ * Updates the marker doc atomically (CAS on `expectedFrom`).
+ *
+ * `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.
+ */
 declare function updateMarker(db: Db, expectedFrom: string, destination: {
   readonly storageHash: string;
   readonly profileHash: string;
+  readonly invariants?: readonly string[];
 }): Promise<boolean>;
 declare function writeLedgerEntry(db: Db, entry: {
   readonly edgeId: string;
@@ -68,7 +79,12 @@ declare class MongoMigrationPlanner implements MigrationPlanner<'mongo', 'mongo'
     readonly contract: unknown;
     readonly schema: unknown;
     readonly policy: MigrationOperationPolicy;
-    readonly fromHash: string;
+    /**
+     * The "from" contract (state the planner assumes the database starts at),
+     * or `null` for reconciliation flows. Used to populate `describe().from`
+     * on the produced plan as `fromContract?.storage.storageHash ?? null`.
+     */
+    readonly fromContract: Contract | null;
     readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
   }): MigrationPlannerResult;
   /**
@@ -89,10 +105,12 @@ interface MarkerOperations {
   initMarker(destination: {
     readonly storageHash: string;
     readonly profileHash: string;
+    readonly invariants?: readonly string[];
   }): Promise<void>;
   updateMarker(expectedFrom: string, destination: {
     readonly storageHash: string;
     readonly profileHash: string;
+    readonly invariants?: readonly string[];
   }): Promise<boolean>;
   writeLedgerEntry(entry: {
     readonly edgeId: string;
@@ -106,21 +124,25 @@ interface MongoRunnerDependencies {
   readonly adapter: MongoAdapter;
   readonly driver: MongoDriver;
   readonly markerOps: MarkerOperations;
+  readonly introspectSchema: () => Promise<MongoSchemaIR>;
+}
+interface MongoMigrationRunnerExecuteOptions {
+  readonly plan: MigrationPlan;
+  readonly destinationContract: MongoContract;
+  readonly policy: MigrationOperationPolicy;
+  readonly callbacks?: {
+    onOperationStart?(op: MigrationPlanOperation): void;
+    onOperationComplete?(op: MigrationPlanOperation): void;
+  };
+  readonly executionChecks?: MigrationRunnerExecutionChecks;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
+  readonly strictVerification?: boolean;
+  readonly context?: OperationContext;
 }
 declare class MongoMigrationRunner {
   private readonly deps;
   constructor(deps: MongoRunnerDependencies);
-  execute(options: {
-    readonly plan: MigrationPlan;
-    readonly destinationContract: unknown;
-    readonly policy: MigrationOperationPolicy;
-    readonly callbacks?: {
-      onOperationStart?(op: MigrationPlanOperation): void;
-      onOperationComplete?(op: MigrationPlanOperation): void;
-    };
-    readonly executionChecks?: MigrationRunnerExecutionChecks;
-    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
-  }): Promise<MigrationRunnerResult>;
+  execute(options: MongoMigrationRunnerExecuteOptions): Promise<MigrationRunnerResult>;
   private executeDataTransform;
   private evaluateDataTransformChecks;
   private evaluateChecks;
@@ -161,9 +183,8 @@ declare function renderOps(calls: ReadonlyArray<OpFactoryCall>): MongoMigrationP
 //#endregion
 //#region src/core/render-typescript.d.ts
 interface RenderMigrationMeta {
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
-  readonly kind?: string;
   readonly labels?: readonly string[];
 }
 /**
@@ -172,16 +193,16 @@ interface RenderMigrationMeta {
  * `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 empty strings for a
- * migration-new scaffold.
+ * 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` import from `@prisma-next/family-mongo/migration` is
- * always emitted — it's driven by `meta` (the rendered scaffold always
- * extends `Migration`), not by any node.
+ * 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.
  */
 declare function renderCallsToTypeScript(calls: ReadonlyArray<OpFactoryCall>, meta: RenderMigrationMeta): string;
 //#endregion

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/contract-to-schema.ts","../src/core/ddl-formatter.ts","../src/core/filter-evaluator.ts","../src/core/marker-ledger.ts","../src/core/mongo-ops-serializer.ts","../src/core/mongo-planner.ts","../src/core/mongo-runner.ts","../src/core/planner-produced-migration.ts","../src/core/render-ops.ts","../src/core/render-typescript.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;iBAoDgB,uBAAA,WAAkC,uBAAuB;;;iBC6CzD,qBAAA,sBAA2C;;;cC/C9C,eAAA,YAA2B;;mBAGrB,sBAAsB;cAK3B;YAKF;WAID;YAIC;eAIG;cAKD;;;;iBCjDQ,UAAA,KAAe,KAAK,QAAQ;iBAgB5B,UAAA,KAChB;;;IAEH;iBAcmB,YAAA,KAChB;;;IAGH;iBAiBmB,gBAAA,KAChB;;EHlCU,SAAA,IAAA,EAAA,MAAA;;IGoCb;;;iBC8ea,kBAAA,iBAAmC;iBAOnC,mBAAA,4BAA+C;iBAI/C,iBAAA,eAAgC;;;KC7epC,eAAA;;kBACoC;;;sBACI;;cAEvC,qBAAA,YAAiC;;;ILpD9B,SAAA,MAAA,EAAA,OAAuB;qBKwDlB;kCACa,cAAc;MAC1C;EJbU,IAAA,CAAA,OAAA,EAAA;;;qBIiIK;IHhLR,SAAA,QAAgB,EAAA,MAAA;IAGV,SAAA,mBAAA,EG+Ke,aH/Kf,CG+K6B,8BH/K7B,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA;EAAsB,CAAA,CAAA,EGgLnC,sBHhLmC;EAK3B;;;;;;;;;0BGiMY,2BAA2B;;;;UCtNpC,gBAAA;gBACD,QAAQ;;;;MAIlB;;;INUU,SAAA,WAAA,EAAuB,MAAA;MMNlC;;;ILmDW,SAAA,IAAA,EAAA,MAAqB;;MK9C/B;;AJDO,UIII,uBAAA,CJJY;EAGV,SAAA,eAAA,EIES,sBJFT,CIEgC,OJFhC,CAAA,IAAA,CAAA,CAAA;EAAsB,SAAA,kBAAA,EIGV,6BJHU,CIGoB,OJHpB,CIG4B,MJH5B,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,CAAA,CAAA;EAK3B,SAAA,OAAA,EIDM,YJCN;EAKF,SAAA,MAAA,EILO,WJKP;EAID,SAAA,SAAA,EIRW,gBJQX;;AAQI,cIDF,oBAAA,CJCE;EAKD,iBAAA,IAAA;EA9B0B,WAAA,CAAA,IAAA,EIyBH,uBJzBG;EAAkB,OAAA,CAAA,OAAA,EAAA;mBI4BvC;;qBAEE;IHjDC,SAAU,SAAA,CAAA,EAAA;MAAK,gBAAA,EAAA,EAAA,EGmDT,sBHnDS,CAAA,EAAA,IAAA;MAAa,mBAAA,EAAA,EAAA,EGoDnB,sBHpDmB,CAAA,EAAA,IAAA;IAAR,CAAA;IAAO,SAAA,eAAA,CAAA,EGsDlB,8BHtDkB;IAgB3B,SAAU,mBAG7B,EGoC+B,aHpCxB,CGoCsC,8BHpCtC,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA;EAcY,CAAA,CAAA,EGuBhB,OHvBgB,CGuBR,qBHnBX,CAAA;EAiBmB,QAAA,oBAAgB;;;;ECiftB,QAAA,0BAAmC;EAOnC,QAAA,yBAAmB;AAInC;;;;;;;;;;;;AJ7hBA;;;;AC6CA;;;cMzEa,6BAAA,SACH,UAAU,uCACP;ELwBA,iBAAA,KAAgB;EAGV,iBAAA,IAAA;EAAsB,SAAA,QAAA,EAAA,OAAA;EAK3B,WAAA,CAAA,KAAA,EAAA,SK3BuB,aL2BvB,EAAA,EAAA,IAAA,EK1Ba,aL0Bb;EAKF,IAAA,UAAA,CAAA,CAAA,EAAA,SK1B0B,0BL0B1B,EAAA;EAID,QAAA,CAAA,CAAA,EK1BY,aL0BZ;EAIC,gBAAA,CAAA,CAAA,EAAA,MAAA;;;;iBMpEI,SAAA,QAAiB,cAAc,iBAAiB;;;UCC/C,mBAAA;;;;;;;;;;;;ATgDjB;;;;AC6CA;;;;AC/CA;;;AAQc,iBOzBE,uBAAA,CPyBF,KAAA,EOxBL,aPwBK,COxBS,aPwBT,CAAA,EAAA,IAAA,EOvBN,mBPuBM,CAAA,EAAA,MAAA"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/contract-to-schema.ts","../src/core/ddl-formatter.ts","../src/core/filter-evaluator.ts","../src/core/marker-ledger.ts","../src/core/mongo-ops-serializer.ts","../src/core/mongo-planner.ts","../src/core/mongo-runner.ts","../src/core/planner-produced-migration.ts","../src/core/render-ops.ts","../src/core/render-typescript.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/control.mjs

@@ -1,54 +1,16 @@
-import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-gwi81C8u.mjs";
-import { MongoSchemaCollection, MongoSchemaCollectionOptions, MongoSchemaIR, MongoSchemaIndex, MongoSchemaValidator, canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
+import { n as contractToMongoSchemaIR, t as verifyMongoSchema } from "./verify-mongo-schema-Daa7BMJY.mjs";
+import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-CoNYWrd1.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 { 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 { type } from "arktype";
 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 { notOk, ok } from "@prisma-next/utils/result";
 
-//#region src/core/contract-to-schema.ts
-function convertIndex(index) {
-	return new MongoSchemaIndex({
-		keys: index.keys,
-		unique: index.unique,
-		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 convertValidator(v) {
-	return new MongoSchemaValidator({
-		jsonSchema: v.jsonSchema,
-		validationLevel: v.validationLevel,
-		validationAction: v.validationAction
-	});
-}
-function convertOptions(o) {
-	return new MongoSchemaCollectionOptions(o);
-}
-function convertCollection(name, def) {
-	return new MongoSchemaCollection({
-		name,
-		indexes: (def.indexes ?? []).map(convertIndex),
-		...def.validator != null && { validator: convertValidator(def.validator) },
-		...def.options != null && { options: convertOptions(def.options) }
-	});
-}
-function contractToMongoSchemaIR(contract) {
-	if (!contract) return new MongoSchemaIR([]);
-	return new MongoSchemaIR(Object.entries(contract.storage.collections).map(([name, def]) => convertCollection(name, def)));
-}
-
-//#endregion
 //#region src/core/ddl-formatter.ts
 function formatKeySpec(keys) {
 	return `{ ${keys.map((k) => `${JSON.stringify(k.field)}: ${JSON.stringify(k.direction)}`).join(", ")} }`;
@@ -176,6 +138,31 @@ var FilterEvaluator = class {
 //#region src/core/marker-ledger.ts
 const COLLECTION = "_prisma_migrations";
 const MARKER_ID = "marker";
+const MongoMarkerDocSchema = type({
+	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}`);
+	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 ?? []
+	};
+}
 async function executeAggregate(db, cmd) {
 	return db.collection(cmd.collection).aggregate(cmd.pipeline).toArray();
 }
@@ -188,15 +175,7 @@ async function executeFindOneAndUpdate(db, cmd) {
 async function readMarker(db) {
 	const doc = (await executeAggregate(db, new RawAggregateCommand(COLLECTION, [{ $match: { _id: MARKER_ID } }, { $limit: 1 }])))[0];
 	if (!doc) return null;
-	return {
-		storageHash: doc["storageHash"],
-		profileHash: doc["profileHash"],
-		contractJson: doc["contractJson"] ?? null,
-		canonicalVersion: doc["canonicalVersion"] ?? null,
-		updatedAt: doc["updatedAt"],
-		appTag: doc["appTag"] ?? null,
-		meta: doc["meta"] ?? {}
-	};
+	return parseMongoMarkerDoc(doc);
 }
 async function initMarker(db, destination) {
 	await executeInsertOne(db, new RawInsertOneCommand(COLLECTION, {
@@ -207,18 +186,36 @@ async function initMarker(db, destination) {
 		canonicalVersion: null,
 		updatedAt: /* @__PURE__ */ new Date(),
 		appTag: null,
-		meta: {}
+		meta: {},
+		invariants: destination.invariants ?? []
 	}));
 }
+/**
+* Updates the marker doc atomically (CAS on `expectedFrom`).
+*
+* `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.
+*/
 async function updateMarker(db, expectedFrom, destination) {
-	return await executeFindOneAndUpdate(db, new RawFindOneAndUpdateCommand(COLLECTION, {
-		_id: MARKER_ID,
-		storageHash: expectedFrom
-	}, { $set: {
+	const setBase = {
 		storageHash: destination.storageHash,
 		profileHash: destination.profileHash,
 		updatedAt: /* @__PURE__ */ new Date()
-	} }, false)) !== null;
+	};
+	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: MARKER_ID,
+		storageHash: expectedFrom
+	}, update, false)) !== null;
 }
 async function writeLedgerEntry(db, entry) {
 	await executeInsertOne(db, new RawInsertOneCommand(COLLECTION, {
@@ -358,13 +355,9 @@ const QueryPlanJson = type({
 		target: "string",
 		storageHash: "string",
 		lane: "string",
-		paramDescriptors: "unknown[]",
 		"targetFamily?": "string",
 		"profileHash?": "string",
-		"annotations?": "Record<string, unknown>",
-		"refs?": "Record<string, unknown>",
-		"projection?": "Record<string, string> | string[]",
-		"projectionTypes?": "Record<string, string>"
+		"annotations?": "Record<string, unknown>"
 	})
 });
 const CheckJson = type({
@@ -528,13 +521,9 @@ function deserializeMongoQueryPlan(json) {
 		target: m.target,
 		storageHash: m.storageHash,
 		lane: m.lane,
-		paramDescriptors: m.paramDescriptors,
 		...ifDefined("targetFamily", m.targetFamily),
 		...ifDefined("profileHash", m.profileHash),
-		...ifDefined("annotations", m.annotations),
-		...ifDefined("refs", m.refs),
-		...ifDefined("projection", m.projection),
-		...ifDefined("projectionTypes", m.projectionTypes)
+		...ifDefined("annotations", m.annotations)
 	};
 	return {
 		collection: data.collection,
@@ -827,26 +816,45 @@ function renderOps(calls) {
 
 //#endregion
 //#region src/core/render-typescript.ts
-const BASE_IMPORT = {
+/**
+* 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 empty strings for a
-* migration-new scaffold.
+* 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` import from `@prisma-next/family-mongo/migration` is
-* always emitted — it's driven by `meta` (the rendered scaffold always
-* extends `Migration`), not by any node.
+* 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);
@@ -865,12 +873,12 @@ function renderCallsToTypeScript(calls, meta) {
 		"}",
 		"",
 		"export default M;",
-		"Migration.run(import.meta.url, M);",
+		"MigrationCLI.run(import.meta.url, M);",
 		""
 	].join("\n");
 }
 function buildImports(calls) {
-	const requirements = [BASE_IMPORT];
+	const requirements = [...BASE_IMPORTS];
 	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
 	return renderImports(requirements);
 }
@@ -880,7 +888,6 @@ function buildDescribeMethod(meta) {
 	lines.push("    return {");
 	lines.push(`      from: ${JSON.stringify(meta.from)},`);
 	lines.push(`      to: ${JSON.stringify(meta.to)},`);
-	if (meta.kind) lines.push(`      kind: ${JSON.stringify(meta.kind)},`);
 	if (meta.labels && meta.labels.length > 0) lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
 	lines.push("    };");
 	lines.push("  }");
@@ -927,7 +934,6 @@ var PlannerProducedMongoMigration = class extends Migration {
 		return renderCallsToTypeScript(this.calls, {
 			from: this.meta.from,
 			to: this.meta.to,
-			...ifDefined("kind", this.meta.kind),
 			...ifDefined("labels", this.meta.labels)
 		});
 	}
@@ -1049,7 +1055,7 @@ var MongoMigrationPlanner = class {
 		return {
 			kind: "success",
 			plan: new PlannerProducedMongoMigration(result.calls, {
-				from: options.fromHash,
+				from: options.fromContract?.storage.storageHash ?? null,
 				to: contract.storage.storageHash
 			})
 		};
@@ -1109,9 +1115,6 @@ function planMutableOptionsDiffCall(collName, origin, dest) {
 //#endregion
 //#region src/core/mongo-runner.ts
 const READ_ONLY_CHECK_COMMAND_KINDS = new Set(["aggregate", "rawAggregate"]);
-function hasProfileHash(value) {
-	return typeof value === "object" && value !== null && Object.hasOwn(value, "profileHash") && typeof value.profileHash === "string";
-}
 function runnerFailure(code, summary, opts) {
 	return notOk({
 		code,
@@ -1163,29 +1166,45 @@ var MongoMigrationRunner = class {
 			}
 		}
 		const destination = options.plan.destination;
-		const profileHash = hasProfileHash(options.destinationContract) ? options.destinationContract.profileHash : destination.storageHash;
-		if (operationsExecuted === 0 && existingMarker?.storageHash === destination.storageHash && existingMarker.profileHash === profileHash) return ok({
-			operationsPlanned: operations.length,
-			operationsExecuted
-		});
-		if (existingMarker) {
-			if (!await markerOps.updateMarker(existingMarker.storageHash, {
+		const profileHash = options.destinationContract.profileHash ?? destination.storageHash;
+		const incomingInvariants = options.plan.providedInvariants ?? [];
+		const existingInvariantSet = new Set(existingMarker?.invariants ?? []);
+		const incomingIsSubsetOfExisting = incomingInvariants.every((id) => existingInvariantSet.has(id));
+		const markerAlreadyAtDestination = existingMarker !== null && existingMarker.storageHash === destination.storageHash && existingMarker.profileHash === profileHash;
+		if (!(operationsExecuted === 0 && markerAlreadyAtDestination && incomingIsSubsetOfExisting)) {
+			const liveSchema = await this.deps.introspectSchema();
+			const verifyResult = verifyMongoSchema({
+				contract: options.destinationContract,
+				schema: liveSchema,
+				strict: options.strictVerification ?? true,
+				frameworkComponents: options.frameworkComponents,
+				...options.context ? { context: options.context } : {}
+			});
+			if (!verifyResult.ok) return runnerFailure("SCHEMA_VERIFY_FAILED", verifyResult.summary, {
+				why: "The resulting database schema does not satisfy the destination contract.",
+				meta: { issues: verifyResult.schema.issues }
+			});
+			if (existingMarker) {
+				if (!await markerOps.updateMarker(existingMarker.storageHash, {
+					storageHash: destination.storageHash,
+					profileHash,
+					invariants: incomingInvariants
+				})) return runnerFailure("MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
+					expectedStorageHash: existingMarker.storageHash,
+					destinationStorageHash: destination.storageHash
+				} });
+			} else await markerOps.initMarker({
 				storageHash: destination.storageHash,
-				profileHash
-			})) return runnerFailure("MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
-				expectedStorageHash: existingMarker.storageHash,
-				destinationStorageHash: destination.storageHash
-			} });
-		} else await markerOps.initMarker({
-			storageHash: destination.storageHash,
-			profileHash
-		});
-		const originHash = existingMarker?.storageHash ?? "";
-		await markerOps.writeLedgerEntry({
-			edgeId: `${originHash}->${destination.storageHash}`,
-			from: originHash,
-			to: destination.storageHash
-		});
+				profileHash,
+				invariants: incomingInvariants
+			});
+			const originHash = existingMarker?.storageHash ?? "";
+			await markerOps.writeLedgerEntry({
+				edgeId: `${originHash}->${destination.storageHash}`,
+				from: originHash,
+				to: destination.storageHash
+			});
+		}
 		return ok({
 			operationsPlanned: operations.length,
 			operationsExecuted
@@ -1205,7 +1224,7 @@ var MongoMigrationRunner = class {
 			};
 		}
 		for (const plan of op.run) {
-			const wireCommand = adapter.lower(plan);
+			const wireCommand = await adapter.lower(plan, {});
 			for await (const _ of driver.execute(wireCommand));
 		}
 		if (runPostchecks && op.postcheck.length > 0) {
@@ -1231,7 +1250,7 @@ var MongoMigrationRunner = class {
 					collection: check.source.collection
 				}
 			});
-			const wireCommand = adapter.lower(check.source);
+			const wireCommand = await adapter.lower(check.source, {});
 			let matchFound = false;
 			for await (const row of driver.execute(wireCommand)) if (filterEvaluator.evaluate(check.filter, row)) {
 				matchFound = true;
@@ -1264,10 +1283,7 @@ var MongoMigrationRunner = class {
 	}
 	ensureMarkerCompatibility(marker, plan) {
 		const origin = plan.origin ?? null;
-		if (!origin) {
-			if (marker) return runnerFailure("MARKER_ORIGIN_MISMATCH", "Database already has a contract marker but the plan has no origin. This would silently overwrite the existing marker.", { meta: { markerStorageHash: marker.storageHash } });
-			return;
-		}
+		if (!origin) return;
 		if (!marker) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
 		if (marker.storageHash !== origin.storageHash) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
 			markerStorageHash: marker.storageHash,