@prisma-next/target-mongo 0.5.0-dev.9 → 0.5.1

package/dist/codec-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"codec-types.d.mts","names":[],"sources":["../src/exports/codec-types.ts"],"sourcesContent":[],"mappings":";KAAY,UAAA;EAAA,SAAA,kBAMiC,EAAA;;;;;;;;;;;;;;;;;;;;;oBAAA;qBAAuB"}
+{"version":3,"file":"codec-types.d.mts","names":[],"sources":["../src/exports/codec-types.ts"],"mappings":";KAAY,UAAA;EAAA,SACD,kBAAA;IAAA,SAA+B,KAAA;IAAA,SAAwB,MAAA;EAAA;EAAA,SACvD,gBAAA;IAAA,SAA6B,KAAA;IAAA,SAAwB,MAAA;EAAA;EAAA,SACrD,gBAAA;IAAA,SAA6B,KAAA;IAAA,SAAwB,MAAA;EAAA;EAAA,SACrD,eAAA;IAAA,SAA4B,KAAA;IAAA,SAAwB,MAAA;EAAA;EAAA,SACpD,cAAA;IAAA,SAA2B,KAAA;IAAA,SAAyB,MAAA;EAAA;EAAA,SACpD,cAAA;IAAA,SAA2B,KAAA,EAAO,IAAA;IAAA,SAAe,MAAA,EAAQ,IAAA;EAAA;EAAA,SACzD,gBAAA;IAAA,SACE,KAAA;IAAA,SACA,MAAA;EAAA;AAAA"}

package/dist/codec-types.mjs

@@ -1 +1 @@
-export {  };
+export {};

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-CVgzmLJh.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-9z5D19cP.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 { 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;
@@ -165,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[];
 }
 /**
@@ -176,8 +193,8 @@ 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

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":"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"}
+{"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"],"mappings":"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"}

package/dist/control.mjs

@@ -1,16 +1,15 @@
-import { n as contractToMongoSchemaIR, t as verifyMongoSchema } from "./verify-mongo-schema-P0TRBJNs.mjs";
-import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-Dbk5afMU.mjs";
+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 { 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/ddl-formatter.ts
 function formatKeySpec(keys) {
 	return `{ ${keys.map((k) => `${JSON.stringify(k.field)}: ${JSON.stringify(k.direction)}`).join(", ")} }`;
@@ -80,7 +79,6 @@ function formatMongoOperations(operations) {
 	}
 	return statements;
 }
-
 //#endregion
 //#region src/core/filter-evaluator.ts
 function getNestedField(doc, path) {
@@ -133,11 +131,35 @@ var FilterEvaluator = class {
 		throw new Error("Aggregation expression filters are not supported in migration checks");
 	}
 };
-
 //#endregion
 //#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();
 }
@@ -150,15 +172,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, {
@@ -169,18 +183,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, {
@@ -191,7 +223,6 @@ async function writeLedgerEntry(db, entry) {
 		appliedAt: /* @__PURE__ */ new Date()
 	}));
 }
-
 //#endregion
 //#region src/core/mongo-ops-serializer.ts
 const CreateIndexJson = type({
@@ -320,13 +351,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({
@@ -364,7 +391,7 @@ const DataTransformOperationJson = type({
 });
 function validate(schema, data, context) {
 	try {
-		return schema.assert(data);
+		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);
@@ -372,6 +399,51 @@ function validate(schema, data, context) {
 		throw new Error(`Invalid ${context}: ${message}`);
 	}
 }
+/**
+* Strip `undefined`-valued properties before they reach arktype's optional-key
+* assertions.
+*
+* Op IRs (e.g. `CreateCollectionCommand`) assign every optional field on
+* every instance — fields the caller did not provide land as
+* `undefined`-valued properties. arktype treats `{ foo?: 'boolean' }` as
+* "key may be absent, but if present must be boolean", so the bare instance
+* fails validation when it crosses the deserialize boundary in-process
+* (no JSON round-trip happens between planner → runner). This helper
+* recovers the JSON-round-tripped shape (undefined keys absent) without
+* forcing every caller to round-trip.
+*
+* Returns the original value reference whenever no change is needed.
+* That preserves prototype-bound payload values such as BSON wrappers
+* (`ObjectId`, `Decimal128`, `Binary`, …) which embed no `undefined`
+* own-enumerable properties and therefore never trigger a rebuild.
+* Top-level op IRs (class instances with `undefined` optional fields)
+* still get flattened to plain records as required by arktype.
+*/
+function stripUndefinedDeep(value) {
+	if (Array.isArray(value)) {
+		let changed = false;
+		const next = value.map((item) => {
+			const stripped = stripUndefinedDeep(item);
+			if (stripped !== item) changed = true;
+			return stripped;
+		});
+		return changed ? next : value;
+	}
+	if (value === null || typeof value !== "object") return value;
+	const entries = Object.entries(value);
+	const out = {};
+	let changed = false;
+	for (const [key, val] of entries) {
+		if (val === void 0) {
+			changed = true;
+			continue;
+		}
+		const stripped = stripUndefinedDeep(val);
+		if (stripped !== val) changed = true;
+		out[key] = stripped;
+	}
+	return changed ? out : value;
+}
 function deserializeFilterExpr(json) {
 	const record = json;
 	const kind = record["kind"];
@@ -490,13 +562,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,
@@ -625,7 +693,6 @@ function deserializeMongoOps(json) {
 function serializeMongoOps(ops) {
 	return JSON.stringify(ops, null, 2);
 }
-
 //#endregion
 //#region src/core/op-factory-call.ts
 const TARGET_MIGRATION_MODULE = "@prisma-next/target-mongo/migration";
@@ -780,13 +847,11 @@ function schemaCollectionToCreateCollectionOptions(coll) {
 		changeStreamPreAndPostImages: opts?.changeStreamPreAndPostImages
 	};
 }
-
 //#endregion
 //#region src/core/render-ops.ts
 function renderOps(calls) {
 	return calls.map((call) => call.toOp());
 }
-
 //#endregion
 //#region src/core/render-typescript.ts
 /**
@@ -818,8 +883,8 @@ const BASE_IMPORTS = [{
 * `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
@@ -861,7 +926,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("  }");
@@ -872,7 +936,6 @@ 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
 /**
@@ -892,6 +955,8 @@ function indent(text, spaces) {
 * cycle.
 */
 var PlannerProducedMongoMigration = class extends Migration {
+	calls;
+	meta;
 	targetId = "mongo";
 	constructor(calls, meta) {
 		super();
@@ -908,12 +973,10 @@ 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)
 		});
 	}
 };
-
 //#endregion
 //#region src/core/mongo-planner.ts
 function buildIndexLookupKey(index) {
@@ -973,8 +1036,8 @@ var MongoMigrationPlanner = class {
 			const originColl = originIR.collection(collName);
 			const destColl = destinationIR.collection(collName);
 			if (!originColl) {
-				if (destColl && collectionHasOptions(destColl)) {
-					const opts = schemaCollectionToCreateCollectionOptions(destColl);
+				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));
@@ -1030,7 +1093,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
 			})
 		};
@@ -1086,7 +1149,6 @@ function planMutableOptionsDiffCall(collName, origin, dest) {
 		operationClass: desiredCSPPI.enabled ? "widening" : "destructive"
 	});
 }
-
 //#endregion
 //#region src/core/mongo-runner.ts
 const READ_ONLY_CHECK_COMMAND_KINDS = new Set(["aggregate", "rawAggregate"]);
@@ -1098,6 +1160,7 @@ function runnerFailure(code, summary, opts) {
 	});
 }
 var MongoMigrationRunner = class {
+	deps;
 	constructor(deps) {
 		this.deps = deps;
 	}
@@ -1142,40 +1205,44 @@ var MongoMigrationRunner = class {
 		}
 		const destination = options.plan.destination;
 		const profileHash = options.destinationContract.profileHash ?? destination.storageHash;
-		if (operationsExecuted === 0 && existingMarker?.storageHash === destination.storageHash && existingMarker.profileHash === profileHash) return ok({
-			operationsPlanned: operations.length,
-			operationsExecuted
-		});
-		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, {
+		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
@@ -1195,7 +1262,7 @@ var MongoMigrationRunner = class {
 			};
 		}
 		for (const plan of op.run) {
-			const wireCommand = await adapter.lower(plan);
+			const wireCommand = await adapter.lower(plan, {});
 			for await (const _ of driver.execute(wireCommand));
 		}
 		if (runPostchecks && op.postcheck.length > 0) {
@@ -1221,7 +1288,7 @@ var MongoMigrationRunner = class {
 					collection: check.source.collection
 				}
 			});
-			const wireCommand = await 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;
@@ -1254,10 +1321,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,
@@ -1265,7 +1329,7 @@ var MongoMigrationRunner = class {
 		} });
 	}
 };
-
 //#endregion
 export { CollModCall, CreateCollectionCall, CreateIndexCall, DropCollectionCall, DropIndexCall, FilterEvaluator, MongoMigrationPlanner, MongoMigrationRunner, PlannerProducedMongoMigration, contractToMongoSchemaIR, deserializeMongoOp, deserializeMongoOps, formatMongoOperations, initMarker, readMarker, renderCallsToTypeScript, renderOps, schemaCollectionToCreateCollectionOptions, schemaIndexToCreateIndexOptions, serializeMongoOps, updateMarker, writeLedgerEntry };
+
 //# sourceMappingURL=control.mjs.map