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

package/dist/codecs-DLWO-Cjc-CWfQj0bY.mjs

@@ -0,0 +1,170 @@
+import { a as MONGO_OBJECTID_CODEC_ID, i as MONGO_INT32_CODEC_ID, n as MONGO_DATE_CODEC_ID, o as MONGO_STRING_CODEC_ID, r as MONGO_DOUBLE_CODEC_ID, s as MONGO_VECTOR_CODEC_ID, t as MONGO_BOOLEAN_CODEC_ID } from "./codec-ids-BennPcpQ-Btzz3ILV.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { renderTsLiteral, voidParamsSchema } from "@prisma/orm-framework/components/codec";
+import { mongoCodec, newMongoCodecRegistry } from "@prisma/orm-family-mongo/codec";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { ObjectId } from "bson";
+//#region ../../../3-mongo-target/2-mongo-adapter/dist/codecs-DLWO-Cjc.mjs
+function mongoAdapterError(code, message, options) {
+	return structuredError(code, message, options);
+}
+function describeReceivedValue(value) {
+	if (value === null) return "null";
+	if (typeof value !== "object") return typeof value;
+	return `object with keys [${Object.keys(value).join(", ")}]`;
+}
+const mongoObjectIdCodec = mongoCodec({
+	typeId: MONGO_OBJECTID_CODEC_ID,
+	decode: (wire) => wire.toHexString(),
+	encode: (value) => new ObjectId(value)
+});
+const mongoStringCodec = mongoCodec({
+	typeId: MONGO_STRING_CODEC_ID,
+	decode: (wire) => wire,
+	encode: (value) => value
+});
+const mongoDoubleCodec = mongoCodec({
+	typeId: MONGO_DOUBLE_CODEC_ID,
+	decode: (wire) => wire,
+	encode: (value) => value
+});
+const mongoInt32Codec = mongoCodec({
+	typeId: MONGO_INT32_CODEC_ID,
+	decode: (wire) => wire,
+	encode: (value) => value
+});
+const mongoBooleanCodec = mongoCodec({
+	typeId: MONGO_BOOLEAN_CODEC_ID,
+	decode: (wire) => wire,
+	encode: (value) => value
+});
+const mongoDateCodec = mongoCodec({
+	typeId: MONGO_DATE_CODEC_ID,
+	decode: (wire) => wire,
+	encode: (value) => value,
+	encodeJson: (value) => value.toISOString(),
+	decodeJson: (json) => {
+		if (typeof json !== "string") throw mongoAdapterError("RUNTIME.DECODE_FAILED", "expected ISO date string", { meta: {
+			codecId: MONGO_DATE_CODEC_ID,
+			received: typeof json
+		} });
+		return new Date(json);
+	}
+});
+const mongoVectorCodec = mongoCodec({
+	typeId: MONGO_VECTOR_CODEC_ID,
+	decode: (wire) => wire,
+	encode: (value) => value
+});
+/**
+* The canonical set of Mongo wire-type codecs.
+*
+* Single source of truth for both control- and runtime-plane adapter descriptors. Don't duplicate this list — import it.
+*/
+const mongoStandardCodecs = [
+	mongoObjectIdCodec,
+	mongoStringCodec,
+	mongoDoubleCodec,
+	mongoInt32Codec,
+	mongoBooleanCodec,
+	mongoDateCodec,
+	mongoVectorCodec
+];
+/**
+* Build a {@link CodecDescriptor} for a Mongo wire-type codec.
+*
+* Wraps an existing {@link MongoCodec} instance into a descriptor whose factory hands out the same shared codec. Mongo's full migration to descriptor-first authoring is tracked under TML-2324; for now the descriptor view is composed from the existing `mongoCodec()` outputs.
+*/
+function descriptorFor(codec, metadata) {
+	const renderOutputType = metadata.renderOutputType;
+	return {
+		codecId: codec.id,
+		traits: metadata.traits,
+		targetTypes: metadata.targetTypes,
+		paramsSchema: voidParamsSchema,
+		isParameterized: false,
+		factory: (() => () => codec),
+		...ifDefined("renderOutputType", renderOutputType),
+		...ifDefined("renderValueLiteral", metadata.renderValueLiteral)
+	};
+}
+const renderVectorOutputType = (typeParams) => {
+	const length = typeParams["length"];
+	if (length === void 0) return void 0;
+	if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length) || length <= 0) throw mongoAdapterError("RUNTIME.TYPE_PARAMS_INVALID", "renderOutputType: expected positive integer \"length\" for Vector", { meta: {
+		nativeType: "Vector",
+		param: "length",
+		received: length
+	} });
+	return `Vector<${length}>`;
+};
+/**
+* Mongo wire-type codec descriptors. Static metadata for `traits`, `targetTypes`, and `renderOutputType` lives here (the descriptor shape) — `MongoCodec` itself is narrow and only carries the four conversion methods (TML-2357).
+*/
+const mongoCodecDescriptors = [
+	descriptorFor(mongoObjectIdCodec, {
+		traits: ["equality"],
+		targetTypes: ["objectId"]
+	}),
+	descriptorFor(mongoStringCodec, {
+		traits: [
+			"equality",
+			"order",
+			"textual"
+		],
+		targetTypes: ["string"],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoDoubleCodec, {
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		targetTypes: ["double"],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoInt32Codec, {
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		targetTypes: ["int"],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoBooleanCodec, {
+		traits: ["equality", "boolean"],
+		targetTypes: ["bool"],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoDateCodec, {
+		traits: ["equality", "order"],
+		targetTypes: ["date"]
+	}),
+	descriptorFor(mongoVectorCodec, {
+		traits: ["equality"],
+		targetTypes: ["vector"],
+		renderOutputType: renderVectorOutputType
+	})
+];
+/**
+* Lookup descriptor metadata by codec id — used by tests and for descriptor-side reads of static metadata.
+*/
+function mongoDescriptorById(codecId) {
+	return mongoCodecDescriptors.find((d) => d.codecId === codecId);
+}
+/**
+* Build a {@link MongoCodecRegistry} preloaded with the standard Mongo wire-type codecs.
+*
+* Single point of truth for adapter-side codec construction: used by the legacy synchronous `createMongoAdapter()` factory and by the runtime adapter descriptor's `codecs()` getter. Userland code obtains a registry via the framework's execution-stack composition (see `createMongoExecutionContext`) instead of calling this directly.
+*/
+function buildStandardCodecRegistry() {
+	const registry = newMongoCodecRegistry();
+	for (const codec of mongoStandardCodecs) registry.register(codec);
+	return registry;
+}
+//#endregion
+export { mongoDescriptorById as a, mongoCodecDescriptors as i, describeReceivedValue as n, mongoAdapterError as r, buildStandardCodecRegistry as t };
+
+//# sourceMappingURL=codecs-DLWO-Cjc-CWfQj0bY.mjs.map

package/dist/codecs-DLWO-Cjc-CWfQj0bY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-DLWO-Cjc-CWfQj0bY.mjs","names":[],"sources":["../../../../3-mongo-target/2-mongo-adapter/dist/codecs-DLWO-Cjc.mjs"],"sourcesContent":["import { a as MONGO_OBJECTID_CODEC_ID, i as MONGO_INT32_CODEC_ID, n as MONGO_DATE_CODEC_ID, o as MONGO_STRING_CODEC_ID, r as MONGO_DOUBLE_CODEC_ID, s as MONGO_VECTOR_CODEC_ID, t as MONGO_BOOLEAN_CODEC_ID } from \"./codec-ids-BennPcpQ.mjs\";\nimport { structuredError } from \"@internal/utils/structured-error\";\nimport { renderTsLiteral, voidParamsSchema } from \"@internal/framework-components/codec\";\nimport { mongoCodec, newMongoCodecRegistry } from \"@internal/mongo-codec\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { ObjectId } from \"bson\";\n//#region src/core/errors.ts\nfunction mongoAdapterError(code, message, options) {\n\treturn structuredError(code, message, options);\n}\nfunction describeReceivedValue(value) {\n\tif (value === null) return \"null\";\n\tif (typeof value !== \"object\") return typeof value;\n\treturn `object with keys [${Object.keys(value).join(\", \")}]`;\n}\n//#endregion\n//#region src/core/codecs.ts\nconst mongoObjectIdCodec = mongoCodec({\n\ttypeId: MONGO_OBJECTID_CODEC_ID,\n\tdecode: (wire) => wire.toHexString(),\n\tencode: (value) => new ObjectId(value)\n});\nconst mongoStringCodec = mongoCodec({\n\ttypeId: MONGO_STRING_CODEC_ID,\n\tdecode: (wire) => wire,\n\tencode: (value) => value\n});\nconst mongoDoubleCodec = mongoCodec({\n\ttypeId: MONGO_DOUBLE_CODEC_ID,\n\tdecode: (wire) => wire,\n\tencode: (value) => value\n});\nconst mongoInt32Codec = mongoCodec({\n\ttypeId: MONGO_INT32_CODEC_ID,\n\tdecode: (wire) => wire,\n\tencode: (value) => value\n});\nconst mongoBooleanCodec = mongoCodec({\n\ttypeId: MONGO_BOOLEAN_CODEC_ID,\n\tdecode: (wire) => wire,\n\tencode: (value) => value\n});\nconst mongoDateCodec = mongoCodec({\n\ttypeId: MONGO_DATE_CODEC_ID,\n\tdecode: (wire) => wire,\n\tencode: (value) => value,\n\tencodeJson: (value) => value.toISOString(),\n\tdecodeJson: (json) => {\n\t\tif (typeof json !== \"string\") throw mongoAdapterError(\"RUNTIME.DECODE_FAILED\", \"expected ISO date string\", { meta: {\n\t\t\tcodecId: MONGO_DATE_CODEC_ID,\n\t\t\treceived: typeof json\n\t\t} });\n\t\treturn new Date(json);\n\t}\n});\nconst mongoVectorCodec = mongoCodec({\n\ttypeId: MONGO_VECTOR_CODEC_ID,\n\tdecode: (wire) => wire,\n\tencode: (value) => value\n});\n/**\n* The canonical set of Mongo wire-type codecs.\n*\n* Single source of truth for both control- and runtime-plane adapter descriptors. Don't duplicate this list — import it.\n*/\nconst mongoStandardCodecs = [\n\tmongoObjectIdCodec,\n\tmongoStringCodec,\n\tmongoDoubleCodec,\n\tmongoInt32Codec,\n\tmongoBooleanCodec,\n\tmongoDateCodec,\n\tmongoVectorCodec\n];\n/**\n* Build a {@link CodecDescriptor} for a Mongo wire-type codec.\n*\n* Wraps an existing {@link MongoCodec} instance into a descriptor whose factory hands out the same shared codec. Mongo's full migration to descriptor-first authoring is tracked under TML-2324; for now the descriptor view is composed from the existing `mongoCodec()` outputs.\n*/\nfunction descriptorFor(codec, metadata) {\n\tconst renderOutputType = metadata.renderOutputType;\n\treturn {\n\t\tcodecId: codec.id,\n\t\ttraits: metadata.traits,\n\t\ttargetTypes: metadata.targetTypes,\n\t\tparamsSchema: voidParamsSchema,\n\t\tisParameterized: false,\n\t\tfactory: (() => () => codec),\n\t\t...ifDefined(\"renderOutputType\", renderOutputType),\n\t\t...ifDefined(\"renderValueLiteral\", metadata.renderValueLiteral)\n\t};\n}\nconst renderVectorOutputType = (typeParams) => {\n\tconst length = typeParams[\"length\"];\n\tif (length === void 0) return void 0;\n\tif (typeof length !== \"number\" || !Number.isFinite(length) || !Number.isInteger(length) || length <= 0) throw mongoAdapterError(\"RUNTIME.TYPE_PARAMS_INVALID\", \"renderOutputType: expected positive integer \\\"length\\\" for Vector\", { meta: {\n\t\tnativeType: \"Vector\",\n\t\tparam: \"length\",\n\t\treceived: length\n\t} });\n\treturn `Vector<${length}>`;\n};\n/**\n* Mongo wire-type codec descriptors. Static metadata for `traits`, `targetTypes`, and `renderOutputType` lives here (the descriptor shape) — `MongoCodec` itself is narrow and only carries the four conversion methods (TML-2357).\n*/\nconst mongoCodecDescriptors = [\n\tdescriptorFor(mongoObjectIdCodec, {\n\t\ttraits: [\"equality\"],\n\t\ttargetTypes: [\"objectId\"]\n\t}),\n\tdescriptorFor(mongoStringCodec, {\n\t\ttraits: [\n\t\t\t\"equality\",\n\t\t\t\"order\",\n\t\t\t\"textual\"\n\t\t],\n\t\ttargetTypes: [\"string\"],\n\t\trenderValueLiteral: renderTsLiteral\n\t}),\n\tdescriptorFor(mongoDoubleCodec, {\n\t\ttraits: [\n\t\t\t\"equality\",\n\t\t\t\"order\",\n\t\t\t\"numeric\"\n\t\t],\n\t\ttargetTypes: [\"double\"],\n\t\trenderValueLiteral: renderTsLiteral\n\t}),\n\tdescriptorFor(mongoInt32Codec, {\n\t\ttraits: [\n\t\t\t\"equality\",\n\t\t\t\"order\",\n\t\t\t\"numeric\"\n\t\t],\n\t\ttargetTypes: [\"int\"],\n\t\trenderValueLiteral: renderTsLiteral\n\t}),\n\tdescriptorFor(mongoBooleanCodec, {\n\t\ttraits: [\"equality\", \"boolean\"],\n\t\ttargetTypes: [\"bool\"],\n\t\trenderValueLiteral: renderTsLiteral\n\t}),\n\tdescriptorFor(mongoDateCodec, {\n\t\ttraits: [\"equality\", \"order\"],\n\t\ttargetTypes: [\"date\"]\n\t}),\n\tdescriptorFor(mongoVectorCodec, {\n\t\ttraits: [\"equality\"],\n\t\ttargetTypes: [\"vector\"],\n\t\trenderOutputType: renderVectorOutputType\n\t})\n];\n/**\n* Lookup descriptor metadata by codec id — used by tests and for descriptor-side reads of static metadata.\n*/\nfunction mongoDescriptorById(codecId) {\n\treturn mongoCodecDescriptors.find((d) => d.codecId === codecId);\n}\n/**\n* Build a {@link MongoCodecRegistry} preloaded with the standard Mongo wire-type codecs.\n*\n* Single point of truth for adapter-side codec construction: used by the legacy synchronous `createMongoAdapter()` factory and by the runtime adapter descriptor's `codecs()` getter. Userland code obtains a registry via the framework's execution-stack composition (see `createMongoExecutionContext`) instead of calling this directly.\n*/\nfunction buildStandardCodecRegistry() {\n\tconst registry = newMongoCodecRegistry();\n\tfor (const codec of mongoStandardCodecs) registry.register(codec);\n\treturn registry;\n}\n//#endregion\nexport { mongoAdapterError as a, describeReceivedValue as i, mongoCodecDescriptors as n, mongoDescriptorById as r, buildStandardCodecRegistry as t };\n\n//# sourceMappingURL=codecs-DLWO-Cjc.mjs.map"],"mappings":"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"}

package/dist/control-BOc5lrQg.mjs

@@ -0,0 +1,437 @@
+import { n as describeReceivedValue, r as mongoAdapterError } from "./codecs-DLWO-Cjc-CWfQj0bY.mjs";
+import { t as createMongoAdapter } from "./mongo-adapter-BkVYI6jn-ChXldtpg.mjs";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { expr, fn } from "@prisma/orm-family-mongo/query-builder";
+import { collection } from "@prisma/orm-family-mongo/query-builder/contract-free";
+import { MongoAggFieldRef, MongoAggLiteral, MongoAggOperator } from "@prisma/orm-family-mongo/query-ast/execution";
+import { MongoServerError } from "mongodb";
+import { MongoSchemaCollection, MongoSchemaCollectionOptions, MongoSchemaIR, MongoSchemaIndex, MongoSchemaValidator } from "@prisma/orm-family-mongo/schema-ir";
+import { parseMarkerRowSafely, withMarkerReadErrorHandling } from "@prisma/orm-framework/errors/execution";
+import { ledgerOriginFromStored } from "@prisma/orm-toolchain/migration-tools/ledger-origin";
+import { type } from "arktype";
+//#region ../../../3-mongo-target/2-mongo-adapter/dist/control.mjs
+/**
+* Executes the read-only catalog inspections (`listCollections` / `listIndexes`)
+* that migration prechecks/postchecks and operation preview evaluate, directly
+* against `db`. Routing these checks through the adapter's lowering seam is
+* deferred to the `typed-migration-verification-queries` slice.
+*/
+var MongoInspectionExecutor = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async listIndexes(cmd) {
+		try {
+			return await this.db.collection(cmd.collection).listIndexes().toArray();
+		} catch (error) {
+			if (error instanceof MongoServerError && error.code === 26) return [];
+			throw error;
+		}
+	}
+	async listCollections(_cmd) {
+		return this.db.listCollections().toArray();
+	}
+};
+const PRISMA_MIGRATIONS_COLLECTION = "_prisma_migrations";
+function parseIndexKeys(keySpec) {
+	const keys = [];
+	for (const [field, direction] of Object.entries(keySpec)) keys.push({
+		field,
+		direction
+	});
+	return keys;
+}
+/**
+* Exported for unit tests to exercise the defensive `!key` guard; not part of
+* the public API. Callers in this package use it via the `introspectSchema`
+* pipeline only.
+*/
+function isDefaultIdIndex(doc) {
+	const key = doc["key"];
+	if (!key) return false;
+	const entries = Object.entries(key);
+	return entries.length === 1 && entries[0]?.[0] === "_id" && entries[0]?.[1] === 1;
+}
+function parseIndex(doc) {
+	const keySpec = doc["key"];
+	return new MongoSchemaIndex({
+		keys: parseIndexKeys(keySpec),
+		unique: doc["unique"],
+		sparse: doc["sparse"],
+		expireAfterSeconds: doc["expireAfterSeconds"],
+		partialFilterExpression: doc["partialFilterExpression"],
+		wildcardProjection: doc["wildcardProjection"],
+		collation: doc["collation"] ? blindCast(doc["collation"]) : void 0,
+		weights: doc["weights"],
+		default_language: doc["default_language"],
+		language_override: doc["language_override"]
+	});
+}
+function parseValidator(options) {
+	const validator = options["validator"];
+	if (!validator) return void 0;
+	const jsonSchema = validator["$jsonSchema"];
+	if (!jsonSchema) return void 0;
+	return new MongoSchemaValidator({
+		jsonSchema,
+		validationLevel: options["validationLevel"] ?? "strict",
+		validationAction: options["validationAction"] ?? "error"
+	});
+}
+function parseCollectionOptions(info) {
+	const options = info["options"];
+	if (!options) return void 0;
+	const capped = options["capped"];
+	const size = options["size"];
+	const max = options["max"];
+	const timeseries = options["timeseries"];
+	const collation = options["collation"] ? blindCast(options["collation"]) : void 0;
+	const changeStreamPreAndPostImages = options["changeStreamPreAndPostImages"];
+	const clusteredIndex = options["clusteredIndex"];
+	if (!(capped || timeseries || collation || changeStreamPreAndPostImages || clusteredIndex)) return void 0;
+	return new MongoSchemaCollectionOptions({
+		...capped ? { capped: {
+			size: size ?? 0,
+			...max != null ? { max } : {}
+		} } : {},
+		...timeseries ? { timeseries } : {},
+		...collation ? { collation } : {},
+		...changeStreamPreAndPostImages ? { changeStreamPreAndPostImages } : {},
+		...clusteredIndex ? { clusteredIndex } : {}
+	});
+}
+async function introspectSchema(db) {
+	const collectionInfos = await db.listCollections().toArray();
+	const collections = [];
+	for (const info of collectionInfos) {
+		const name = info["name"];
+		const type = info["type"];
+		if (name === PRISMA_MIGRATIONS_COLLECTION) continue;
+		if (name.startsWith("system.")) continue;
+		if (type === "view") continue;
+		const indexes = (await db.collection(name).listIndexes().toArray()).filter((doc) => !isDefaultIdIndex(doc)).map(parseIndex);
+		const validator = parseValidator("options" in info ? info["options"] : {});
+		const options = parseCollectionOptions(info);
+		collections.push(new MongoSchemaCollection({
+			name,
+			indexes,
+			...validator ? { validator } : {},
+			...options ? { options } : {}
+		}));
+	}
+	return new MongoSchemaIR(collections);
+}
+const COLLECTION = "_prisma_migrations";
+const MONGO_MARKER_COLLECTION = `_prisma_migrations marker documents in ${COLLECTION}`;
+const MONGO_LEDGER_COLLECTION = `_prisma_migrations ledger documents in ${COLLECTION}`;
+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 mongoAdapterError("CONTRACT.MARKER_ROW_CORRUPT", `Invalid marker doc on ${COLLECTION}: ${result.summary}`, { meta: {
+		collection: COLLECTION,
+		detail: 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 ?? []
+	};
+}
+function parseMongoMarkerDocSafely(doc, space) {
+	return parseMarkerRowSafely(doc, parseMongoMarkerDoc, {
+		space,
+		markerLocation: MONGO_MARKER_COLLECTION
+	});
+}
+const MARKER_LEDGER_COLLECTION = "_prisma_migrations";
+function isMongoControlDriver(driver) {
+	return driver.familyId === "mongo" && driver.targetId === "mongo" && "execute" in driver && typeof driver.execute === "function";
+}
+function extractDb(driver) {
+	if (!isMongoControlDriver(driver)) throw mongoAdapterError("CONFIG.VALIDATION_FAILED", "Expected a Mongo control driver created by mongoControlDriver.create() from `@internal/driver-mongo/control`.", { meta: { received: describeReceivedValue(driver) } });
+	return driver.db;
+}
+/**
+* Build the runner-dependencies envelope. `controlAdapter` is the
+* dispatch surface for wire-level Mongo CAS operations (marker reads,
+* marker advances, ledger appends, introspection); the envelope's
+* `markerOps` shim simply forwards each call through it. When the
+* caller already has a `MongoControlAdapter` on the control stack it
+* can pass it in; otherwise a default `MongoControlAdapterImpl` is
+* constructed locally.
+*/
+function createMongoRunnerDeps(controlDriver, driver, _family, controlAdapter = new MongoControlAdapterImpl()) {
+	const adapter = createMongoAdapter();
+	return {
+		inspectionExecutor: new MongoInspectionExecutor(extractDb(controlDriver)),
+		adapter,
+		driver,
+		executeDdl: (command) => adapter.lower({ command }, {}).then((wire) => driver.run(wire)),
+		markerOps: {
+			readMarker: (space) => controlAdapter.readMarker(controlDriver, space),
+			initMarker: (space, dest) => controlAdapter.initMarker(controlDriver, space, dest),
+			updateMarker: (space, expectedFrom, dest) => controlAdapter.updateMarker(controlDriver, space, expectedFrom, dest),
+			writeLedgerEntry: (space, entry) => controlAdapter.writeLedgerEntry(controlDriver, space, entry)
+		},
+		introspectSchema: () => controlAdapter.introspectSchema(controlDriver)
+	};
+}
+/**
+* Mongo control adapter for control-plane operations like introspection
+* and marker-ledger CAS. Implements the family-level `MongoControlAdapter`
+* SPI. Every marker/ledger operation builds a canonical command inline via
+* the contract-free fluent builder and dispatches it through the family
+* adapter's lowering path (`createMongoAdapter().lower(plan, {})`) onto the
+* Mongo wire transport (`driver.execute(wireCommand)`) — the same route SQL
+* marker/ledger ops take through `adapter.lower()` → `driver.query()`.
+*/
+var MongoControlAdapterImpl = class {
+	familyId = "mongo";
+	targetId = "mongo";
+	#adapter = createMongoAdapter();
+	#markerLedgerCollection = collection(MARKER_LEDGER_COLLECTION);
+	async #execute(driver, command) {
+		const plan = {
+			collection: MARKER_LEDGER_COLLECTION,
+			command,
+			meta: {
+				target: "mongo",
+				targetFamily: "mongo",
+				storageHash: "",
+				lane: "control"
+			}
+		};
+		const wireCommand = await this.#adapter.lower(plan, {});
+		if (!isMongoControlDriver(driver)) throw mongoAdapterError("CONFIG.VALIDATION_FAILED", "Mongo control adapter requires a Mongo control driver with an execute() transport. Provide a MongoControlDriver from `@internal/driver-mongo/control`.", { meta: { received: describeReceivedValue(driver) } });
+		const rows = [];
+		for await (const row of driver.execute(wireCommand)) rows.push(row);
+		return rows;
+	}
+	async executeDdl(driver, command) {
+		const wire = await this.#adapter.lower({ command }, {});
+		await driver.run(wire);
+	}
+	/**
+	* Server-side invariant-merge aggregation expression:
+	* `$sortArray({ input: $setUnion([$ifNull('$invariants', []), incoming]), sortBy: 1 })`.
+	*
+	* Built through the typed agg-expr layer — `fn.setUnion` plus the generic
+	* `MongoAggOperator` for `$ifNull` / `$sortArray` (neither has a named `fn`
+	* helper). Returns a `MongoAggOperator` that is passed directly to
+	* `f.stage.set({ invariants: ... })` in the update pipeline.
+	*/
+	#invariantMergeExpr(incoming) {
+		const existingOrEmpty = MongoAggOperator.of("$ifNull", [MongoAggFieldRef.of("invariants"), MongoAggLiteral.of([])]);
+		const merged = fn.setUnion({
+			_field: {
+				codecId: "mongo/array@1",
+				nullable: false
+			},
+			node: existingOrEmpty
+		}, {
+			_field: {
+				codecId: "mongo/array@1",
+				nullable: false
+			},
+			node: MongoAggLiteral.of([...incoming])
+		});
+		return MongoAggOperator.of("$sortArray", {
+			input: merged.node,
+			sortBy: MongoAggLiteral.of(1)
+		});
+	}
+	async readMarker(driver, space) {
+		const doc = (await withMarkerReadErrorHandling(() => this.#execute(driver, this.#markerLedgerCollection.aggregate().match((f) => f._id.eq(space)).match((f) => f.space.eq(space)).limit(1).build()), {
+			space,
+			markerLocation: MONGO_MARKER_COLLECTION
+		}))[0];
+		if (!doc) return null;
+		return parseMongoMarkerDocSafely(doc, space);
+	}
+	async readAllMarkers(driver) {
+		const docs = await withMarkerReadErrorHandling(() => this.#execute(driver, this.#markerLedgerCollection.aggregate().match((f) => f._id.type("string")).match((f) => f.space.type("string")).match((f) => expr(fn.eq(f._id, f.space))).build()), {
+			space: "app",
+			markerLocation: MONGO_MARKER_COLLECTION
+		});
+		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, parseMongoMarkerDocSafely(doc, space));
+		}
+		return out;
+	}
+	async initMarker(driver, space, destination) {
+		const document = {
+			_id: space,
+			space,
+			storageHash: destination.storageHash,
+			profileHash: destination.profileHash,
+			contractJson: null,
+			canonicalVersion: null,
+			updatedAt: /* @__PURE__ */ new Date(),
+			appTag: null,
+			meta: {},
+			invariants: [...destination.invariants ?? []]
+		};
+		await this.#execute(driver, this.#markerLedgerCollection.insertOne(document));
+	}
+	async updateMarker(driver, space, expectedFrom, destination) {
+		const { invariants } = destination;
+		return (await this.#execute(driver, this.#markerLedgerCollection.match((f) => f._id.eq(space)).match((f) => f.space.eq(space)).match((f) => f.storageHash.eq(expectedFrom)).findOneAndUpdate((f) => [f.stage.set(invariants === void 0 ? {
+			storageHash: MongoAggLiteral.of(destination.storageHash),
+			profileHash: MongoAggLiteral.of(destination.profileHash),
+			updatedAt: MongoAggLiteral.of(/* @__PURE__ */ new Date())
+		} : {
+			storageHash: MongoAggLiteral.of(destination.storageHash),
+			profileHash: MongoAggLiteral.of(destination.profileHash),
+			updatedAt: MongoAggLiteral.of(/* @__PURE__ */ new Date()),
+			invariants: this.#invariantMergeExpr(invariants)
+		})], { upsert: false }))).length > 0;
+	}
+	async writeLedgerEntry(driver, space, entry) {
+		const document = {
+			type: "ledger",
+			space,
+			edgeId: entry.edgeId,
+			from: entry.from,
+			to: entry.to,
+			migrationName: entry.migrationName,
+			migrationHash: entry.migrationHash,
+			operations: blindCast(entry.operations),
+			appliedAt: /* @__PURE__ */ new Date()
+		};
+		await this.#execute(driver, this.#markerLedgerCollection.insertOne(document));
+	}
+	async readLedger(driver, space) {
+		const ledgerContext = {
+			space: space ?? "*",
+			markerLocation: MONGO_LEDGER_COLLECTION
+		};
+		const chain = this.#markerLedgerCollection.aggregate().match((f) => f.type.eq("ledger"));
+		const command = space === void 0 ? chain.sort({ _id: 1 }).build() : chain.match((f) => f.space.eq(space)).sort({ _id: 1 }).build();
+		const docs = await withMarkerReadErrorHandling(() => this.#execute(driver, command), ledgerContext);
+		const entries = [];
+		for (const doc of docs) {
+			const migrationName = doc["migrationName"];
+			const migrationHash = doc["migrationHash"];
+			const from = doc["from"];
+			const to = doc["to"];
+			const docSpace = doc["space"];
+			if (typeof migrationName !== "string" || typeof migrationHash !== "string") continue;
+			if (typeof from !== "string" || typeof to !== "string") continue;
+			if (typeof docSpace !== "string") continue;
+			const appliedAt = doc["appliedAt"];
+			const appliedAtDate = appliedAt instanceof Date ? appliedAt : appliedAt !== void 0 ? new Date(String(appliedAt)) : /* @__PURE__ */ new Date();
+			const operations = doc["operations"];
+			const opList = Array.isArray(operations) ? operations : [];
+			entries.push({
+				space: docSpace,
+				migrationName,
+				migrationHash,
+				from: ledgerOriginFromStored(from),
+				to,
+				appliedAt: appliedAtDate,
+				operationCount: opList.length
+			});
+		}
+		return entries;
+	}
+	async introspectSchema(driver) {
+		return introspectSchema(extractDb(driver));
+	}
+};
+/**
+* The base PSL scalars as zero-arg type constructors in the unified authoring
+* channel, with explicit `nativeType` values pinned to the codec manifests
+* (`codecLookup.targetTypesFor(codecId)[0]`).
+*/
+const mongoScalarAuthoringTypes = {
+	String: {
+		kind: "typeConstructor",
+		output: {
+			codecId: "mongo/string@1",
+			nativeType: "string"
+		}
+	},
+	Int: {
+		kind: "typeConstructor",
+		output: {
+			codecId: "mongo/int32@1",
+			nativeType: "int"
+		}
+	},
+	Boolean: {
+		kind: "typeConstructor",
+		output: {
+			codecId: "mongo/bool@1",
+			nativeType: "bool"
+		}
+	},
+	DateTime: {
+		kind: "typeConstructor",
+		output: {
+			codecId: "mongo/date@1",
+			nativeType: "date"
+		}
+	},
+	ObjectId: {
+		kind: "typeConstructor",
+		output: {
+			codecId: "mongo/objectId@1",
+			nativeType: "objectId"
+		}
+	},
+	Float: {
+		kind: "typeConstructor",
+		output: {
+			codecId: "mongo/double@1",
+			nativeType: "double"
+		}
+	}
+};
+const mongoAdapterDescriptor = {
+	kind: "adapter",
+	id: "mongo",
+	familyId: "mongo",
+	targetId: "mongo",
+	version: "0.0.1",
+	authoring: { type: mongoScalarAuthoringTypes },
+	types: { codecTypes: {
+		import: {
+			package: "@internal/adapter-mongo/codec-types",
+			named: "CodecTypes",
+			alias: "MongoCodecTypes"
+		},
+		typeImports: [{
+			package: "@internal/adapter-mongo/codec-types",
+			named: "Vector",
+			alias: "Vector"
+		}]
+	} },
+	create(_stack) {
+		return new MongoControlAdapterImpl();
+	}
+};
+//#endregion
+export { introspectSchema as a, mongoScalarAuthoringTypes as c, extractDb as i, MongoInspectionExecutor as n, isMongoControlDriver as o, createMongoRunnerDeps as r, mongoAdapterDescriptor as s, MongoControlAdapterImpl as t };
+
+//# sourceMappingURL=control-BOc5lrQg.mjs.map