@prisma/orm-target-mongo 8.0.0-rc.2-dev.2 → 8.0.0-rc.20

package/dist/codec-ids-WdrumsYA-CZVjuKW8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-ids-WdrumsYA-CZVjuKW8.mjs","names":[],"sources":["../../../../3-targets/mongo/1-target/dist/codec-ids-WdrumsYA.mjs"],"sourcesContent":["//#region src/core/codec-ids.ts\nconst MONGO_OBJECTID_CODEC_ID = \"mongo/objectId@1\";\nconst MONGO_STRING_CODEC_ID = \"mongo/string@1\";\nconst MONGO_DOUBLE_CODEC_ID = \"mongo/double@1\";\nconst MONGO_INT32_CODEC_ID = \"mongo/int32@1\";\nconst MONGO_BOOLEAN_CODEC_ID = \"mongo/bool@1\";\nconst MONGO_DATE_CODEC_ID = \"mongo/date@1\";\nconst MONGO_VECTOR_CODEC_ID = \"mongo/vector@1\";\nconst MONGO_INT64_CODEC_ID = \"mongo/int64@1\";\nconst MONGO_INT64_NUMBER_CODEC_ID = \"mongo/int64Number@1\";\nconst MONGO_DECIMAL128_CODEC_ID = \"mongo/decimal128@1\";\nconst MONGO_BINARY_CODEC_ID = \"mongo/binary@1\";\nconst MONGO_JSON_CODEC_ID = \"mongo/json@1\";\nconst MONGO_BSON_CODEC_ID = \"mongo/bson@1\";\n//#endregion\nexport { MONGO_DECIMAL128_CODEC_ID as a, MONGO_INT64_CODEC_ID as c, MONGO_OBJECTID_CODEC_ID as d, MONGO_STRING_CODEC_ID as f, MONGO_DATE_CODEC_ID as i, MONGO_INT64_NUMBER_CODEC_ID as l, MONGO_BOOLEAN_CODEC_ID as n, MONGO_DOUBLE_CODEC_ID as o, MONGO_VECTOR_CODEC_ID as p, MONGO_BSON_CODEC_ID as r, MONGO_INT32_CODEC_ID as s, MONGO_BINARY_CODEC_ID as t, MONGO_JSON_CODEC_ID as u };\n\n//# sourceMappingURL=codec-ids-WdrumsYA.mjs.map"],"mappings":";AACA,MAAM,0BAA0B;AAChC,MAAM,wBAAwB;AAC9B,MAAM,wBAAwB;AAC9B,MAAM,uBAAuB;AAC7B,MAAM,yBAAyB;AAC/B,MAAM,sBAAsB;AAC5B,MAAM,wBAAwB;AAC9B,MAAM,uBAAuB;AAC7B,MAAM,8BAA8B;AACpC,MAAM,4BAA4B;AAClC,MAAM,wBAAwB;AAC9B,MAAM,sBAAsB;AAC5B,MAAM,sBAAsB"}

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

@@ -0,0 +1,89 @@
+import { JsonValue, ParameterizedOutputTypesFunction } from "@prisma/orm-framework/contract/types";
+import { BsonInputValue, BsonInputValue as BsonInputValue$1, BsonScalar, BsonValue, BsonValue as BsonValue$1 } from "@prisma/orm-family-mongo/value";
+//#region ../../../3-targets/mongo/1-target/dist/codec-types.d.mts
+//#region src/exports/codec-types.d.ts
+type Vector<N extends number = number> = readonly number[] & {
+  readonly __vectorLength?: N;
+};
+type CodecTypes = {
+  readonly 'mongo/objectId@1': {
+    readonly input: string;
+    readonly output: string;
+    readonly traits: 'equality';
+  };
+  readonly 'mongo/string@1': {
+    readonly input: string;
+    readonly output: string;
+    readonly traits: 'equality' | 'order' | 'textual';
+  };
+  readonly 'mongo/double@1': {
+    readonly input: number;
+    readonly output: number;
+    readonly traits: 'equality' | 'order' | 'numeric';
+  };
+  readonly 'mongo/int32@1': {
+    readonly input: number;
+    readonly output: number;
+    readonly traits: 'equality' | 'order' | 'numeric';
+  };
+  readonly 'mongo/bool@1': {
+    readonly input: boolean;
+    readonly output: boolean;
+    readonly traits: 'equality' | 'boolean';
+  };
+  readonly 'mongo/date@1': {
+    readonly input: Date;
+    readonly output: Date;
+    readonly traits: 'equality' | 'order';
+  };
+  readonly 'mongo/vector@1': {
+    readonly input: readonly number[];
+    readonly output: readonly number[];
+    readonly traits: 'equality';
+  };
+  readonly 'mongo/int64@1': {
+    readonly input: bigint;
+    readonly output: bigint;
+    readonly traits: 'equality' | 'order' | 'numeric';
+  };
+  readonly 'mongo/int64Number@1': {
+    readonly input: number;
+    readonly output: number;
+    readonly traits: 'equality' | 'order' | 'numeric';
+  };
+  readonly 'mongo/decimal128@1': {
+    readonly input: string;
+    readonly output: string;
+    readonly traits: 'equality' | 'order' | 'numeric';
+    readonly keepsWrittenForm: true;
+  };
+  readonly 'mongo/binary@1': {
+    readonly input: Uint8Array;
+    readonly output: Uint8Array;
+    readonly traits: 'equality';
+  };
+  readonly 'mongo/json@1': {
+    readonly input: JsonValue;
+    readonly output: JsonValue;
+    readonly traits: never;
+  };
+  readonly 'mongo/bson@1': {
+    readonly input: BsonInputValue;
+    readonly output: BsonValue;
+    readonly traits: never;
+  };
+};
+type OutputTypeMap<TypeParams> = {
+  readonly 'mongo/vector@1': TypeParams extends {
+    readonly length: infer N extends number;
+  } ? Vector<N> : never;
+};
+/**
+ * The output type of a vector field with a `length` type parameter, `Vector<N>`: the only declaration of it, which a contract written with `defineContract` and the `contract.d.ts` that `prisma contract emit` writes both apply.
+ */
+interface ParameterizedOutputTypesForTypeParams extends ParameterizedOutputTypesFunction {
+  readonly outputTypes: OutputTypeMap<this['typeParams']>;
+}
+//#endregion
+export { ParameterizedOutputTypesForTypeParams as a, CodecTypes as i, BsonScalar as n, Vector as o, BsonValue$1 as r, BsonInputValue$1 as t };
+//# sourceMappingURL=codec-types-oKxM85p-.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-oKxM85p-.d.mts","names":[],"sources":["../../../../3-targets/mongo/1-target/dist/codec-types.d.mts"],"mappings":";;;;KAGK,OAAO;WACD,iBAAiB;;KAEvB;WACM;aACE;aACA;aACA;;WAEF;aACE;aACA;aACA;;WAEF;aACE;aACA;aACA;;WAEF;aACE;aACA;aACA;;WAEF;aACE;aACA;aACA;;WAEF;aACE,OAAO;aACP,QAAQ;aACR;;WAEF;aACE;aACA;aACA;;WAEF;aACE;aACA;aACA;;WAEF;aACE;aACA;aACA;;WAEF;aACE;aACA;aACA;aACA;;WAEF;aACE,OAAO;aACP,QAAQ;aACR;;WAEF;aACE,OAAO;aACP,QAAQ;aACR;;WAEF;aACE,OAAO;aACP,QAAQ;aACR;;;KAGR,cAAc;WACR,kBAAkB;aAChB,cAAc;MACrB,OAAO;;;;;UAKH,8CAA8C;WAC7C,aAAa"}

package/dist/codecs-B1ab7vfj-QL33tkm2.mjs

@@ -0,0 +1,392 @@
+import { a as MONGO_DECIMAL128_CODEC_ID, c as MONGO_INT64_CODEC_ID, d as MONGO_OBJECTID_CODEC_ID, f as MONGO_STRING_CODEC_ID, i as MONGO_DATE_CODEC_ID, l as MONGO_INT64_NUMBER_CODEC_ID, n as MONGO_BOOLEAN_CODEC_ID, o as MONGO_DOUBLE_CODEC_ID, p as MONGO_VECTOR_CODEC_ID, r as MONGO_BSON_CODEC_ID, s as MONGO_INT32_CODEC_ID, t as MONGO_BINARY_CODEC_ID, u as MONGO_JSON_CODEC_ID } from "./codec-ids-WdrumsYA-CZVjuKW8.mjs";
+import { t as mongoTargetError } from "./mongo-target-errors-Btf3ML1w-QOtEG7EX.mjs";
+import { $ as where, B as mongoInt32, C as int64Decode, D as int64NumberFromDigits, E as int64NumberEncode, F as mongoBson, H as mongoJson, J as objectIdEncode, K as mongoVector, L as mongoDate, M as isPlainObject, N as mongoBinary, O as int64NumberToJson, P as mongoBool, Q as vectorEncode, R as mongoDecimal128, S as int32ToJson, T as int64NumberDecode, U as mongoObjectId, V as mongoInt64, W as mongoString, X as readBsonJson, Y as objectIdToJson, Z as stringEncode, _ as decimal128ToJson, a as booleanEncode, b as encodeBsonValue, c as bsonTypeTag, d as dateEncode, f as dateToJson, h as decimal128Encode, i as binaryToBase64, j as isPlainArray, k as int64ToJson, l as child, m as decimal128Decode, n as binaryEncode, o as bsonClassTag, p as dbRefEntries, r as binaryFromBase64, s as bsonToJson, t as binaryDecode, u as constructorName, v as decodeBsonValue, w as int64Encode, x as int32Encode, y as doubleEncode, z as mongoDouble } from "./data-types-hoKLBrYZ-h9cAgbOy.mjs";
+import { decimalTextBigintLiteral, decimalTextNumberLiteral, floatNumberLiteral, floatToJson, readJsonFloat, renderTsLiteral } from "@prisma/orm-framework/components/codec";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { mongoCodec, newMongoCodecRegistry } from "@prisma/orm-family-mongo/codec";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+//#region ../../../3-targets/mongo/1-target/dist/codecs-B1ab7vfj.mjs
+const BSON_TYPE_BY_TAG = {
+	ObjectId: "objectId",
+	Decimal128: "decimal",
+	Binary: "binData",
+	BSONRegExp: "regex",
+	Timestamp: "timestamp",
+	BSONSymbol: "symbol",
+	Code: "javascript",
+	MinKey: "minKey",
+	MaxKey: "maxKey"
+};
+const NOT_FINITE_FIX = "JSON has no NaN or Infinity; store null or a string, or declare the field Bson.";
+const BSON_FIX = "Declare the field Bson to store BSON values.";
+const PLAIN_VALUE_FIX = "Convert it to a plain object or array.";
+const ENCODE_FIX_BY_RECEIVED = {
+	Date: "Store the date as an ISO 8601 string, or declare the field Bson.",
+	bigint: "Store it as a number in the safe-integer range or as decimal text, or declare the field Int64 or Bson.",
+	NaN: NOT_FINITE_FIX,
+	Infinity: NOT_FINITE_FIX,
+	"-Infinity": NOT_FINITE_FIX,
+	undefined: "Leave the key out, or store null.",
+	Uint8Array: "Store the bytes as a base64 string, or declare the field Binary or Bson.",
+	Buffer: "Store the bytes as a base64 string, or declare the field Binary or Bson.",
+	Binary: "Store the bytes as a base64 string, or declare the field Binary or Bson.",
+	ObjectId: "Store its hex string, or declare the field ObjectId or Bson.",
+	Long: "Store a number in the safe-integer range or decimal text, or declare the field Int64 or Bson.",
+	Decimal128: "Store the decimal text, or declare the field Decimal128 or Bson.",
+	Int32: "Pass a plain number.",
+	Double: "Pass a plain number.",
+	RegExp: "Store the pattern as a string, or declare the field Bson.",
+	BSONRegExp: "Store the pattern as a string, or declare the field Bson.",
+	symbol: "Store a string instead.",
+	function: "Store data, not a function.",
+	"circular reference": "Remove the cycle; a JSON value is a tree.",
+	"sparse array hole": "Fill the hole with null.",
+	DBRef: "Write it as a { $ref, $id } document instead."
+};
+function encodeFix(received) {
+	return ENCODE_FIX_BY_RECEIVED[received] ?? (Object.hasOwn(BSON_TYPE_BY_TAG, received) ? BSON_FIX : PLAIN_VALUE_FIX);
+}
+function encodeRefused(received, path) {
+	throw mongoTargetError("RUNTIME.ENCODE_FAILED", `${MONGO_JSON_CODEC_ID} value must be a JSON value; received ${received} at ${where(path)}. ${encodeFix(received)}`, { meta: {
+		codecId: MONGO_JSON_CODEC_ID,
+		received,
+		valuePath: path
+	} });
+}
+function describeNonJson(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return void 0;
+	if (typeof value === "number") return Number.isFinite(value) ? void 0 : String(value);
+	if (typeof value !== "object") return typeof value;
+	const tag = bsonTypeTag(value);
+	if (tag !== void 0) return tag;
+	if (value instanceof Date) return "Date";
+	if (isPlainArray(value)) return void 0;
+	return isPlainObject(value) ? void 0 : constructorName(value);
+}
+function assertJsonValue(value, path, ancestors) {
+	const received = describeNonJson(value);
+	if (received !== void 0) encodeRefused(received, path);
+	if (typeof value !== "object" || value === null) return;
+	if (ancestors.has(value)) encodeRefused("circular reference", path);
+	ancestors.add(value);
+	if (Array.isArray(value)) for (let index = 0; index < value.length; index++) {
+		if (!(index in value)) encodeRefused("sparse array hole", child(path, index));
+		assertJsonValue(value[index], child(path, index), ancestors);
+	}
+	else for (const [key, entry] of Object.entries(value)) assertJsonValue(entry, child(path, key), ancestors);
+	ancestors.delete(value);
+}
+/**
+* Returns `value` unchanged when it is a plain JSON value at every depth, and throws `RUNTIME.ENCODE_FAILED` naming the first value that is not, with its path.
+*/
+function encodeJsonValue(value) {
+	assertJsonValue(value, "", /* @__PURE__ */ new Set());
+	return value;
+}
+function decodeRefused(bsonType, path) {
+	throw mongoTargetError("RUNTIME.DECODE_FAILED", `${MONGO_JSON_CODEC_ID} wire value contains a non-JSON BSON ${bsonType} at ${where(path)}`, { meta: {
+		codecId: MONGO_JSON_CODEC_ID,
+		received: bsonType,
+		valuePath: path
+	} });
+}
+function safeLong(value, path) {
+	const number = Number(value);
+	return Number.isSafeInteger(number) && BigInt(number) === value ? number : decodeRefused("long", path);
+}
+function finiteDouble(value, path) {
+	if (Number.isFinite(value)) return value;
+	const received = String(value);
+	throw mongoTargetError("RUNTIME.DECODE_FAILED", `${MONGO_JSON_CODEC_ID} wire value contains ${received} at ${where(path)}; a JSON number cannot be NaN or Infinity`, { meta: {
+		codecId: MONGO_JSON_CODEC_ID,
+		received,
+		valuePath: path
+	} });
+}
+function decodeEntries(entries, path) {
+	return Object.fromEntries(entries.map(([key, entry]) => [key, decodeValue(entry, child(path, key))]));
+}
+function decodeTagged(value, tag, path) {
+	switch (tag) {
+		case "DBRef": return decodeEntries(dbRefEntries(value), path);
+		case "Long": return safeLong(blindCast(value).toBigInt(), path);
+		case "Int32":
+		case "Double": return finiteDouble(Number(value.valueOf()), path);
+	}
+	return decodeRefused(BSON_TYPE_BY_TAG[tag] ?? tag, path);
+}
+function decodeValue(value, path) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") return finiteDouble(value, path);
+	if (typeof value === "bigint") return safeLong(value, path);
+	if (typeof value === "undefined") return decodeRefused("undefined", path);
+	if (typeof value === "symbol") return decodeRefused("symbol", path);
+	if (typeof value === "function") return decodeRefused("javascript", path);
+	const tag = bsonClassTag(value);
+	if (tag !== void 0) return decodeTagged(value, tag, path);
+	if (value instanceof Date) return decodeRefused("date", path);
+	if (value instanceof RegExp) return decodeRefused("regex", path);
+	if (value instanceof Uint8Array) return decodeRefused("binData", path);
+	if (Array.isArray(value)) {
+		const decoded = value.map((entry, index) => decodeValue(entry, child(path, index)));
+		return decoded.some((entry, index) => entry !== value[index]) ? decoded : value;
+	}
+	if (!isPlainObject(value)) return decodeRefused(constructorName(value), path);
+	const entries = Object.entries(value);
+	const decoded = decodeEntries(entries, path);
+	return entries.some(([key, entry]) => decoded[key] !== entry) ? decoded : blindCast(value);
+}
+/**
+* Decodes a wire value to the JSON value it holds: a `long` in the safe-integer range and the driver's `Int32` and `Double` wrappers become numbers. Only the objects and arrays around a converted value are copied; a wire value that is already JSON is returned as the same object. Throws `RUNTIME.DECODE_FAILED` naming the BSON type and path of the first value that is not JSON.
+*/
+function decodeJsonValue(wire) {
+	return decodeValue(wire, "");
+}
+const mongoObjectIdCodec = mongoCodec({
+	typeId: MONGO_OBJECTID_CODEC_ID,
+	dataType: mongoObjectId,
+	fromWire: (wire) => wire.toHexString(),
+	toWire: (value) => objectIdEncode(MONGO_OBJECTID_CODEC_ID, value),
+	toDataTypeValue: (value) => mongoObjectId.valueFrom(objectIdToJson(MONGO_OBJECTID_CODEC_ID, value), {}),
+	fromDataTypeValue: (value) => value.value
+});
+const mongoStringCodec = mongoCodec({
+	typeId: MONGO_STRING_CODEC_ID,
+	dataType: mongoString,
+	fromWire: (wire) => wire,
+	toWire: (value) => stringEncode(MONGO_STRING_CODEC_ID, value),
+	fromDataTypeValue: (value) => value.value
+});
+const mongoDoubleCodec = mongoCodec({
+	typeId: MONGO_DOUBLE_CODEC_ID,
+	dataType: mongoDouble,
+	fromWire: (wire) => Number(wire),
+	toWire: (value) => doubleEncode(MONGO_DOUBLE_CODEC_ID, value),
+	toDataTypeValue: (value) => mongoDouble.valueFrom(floatToJson(value), {}),
+	fromDataTypeValue: (value) => readJsonFloat(MONGO_DOUBLE_CODEC_ID, value.value)
+});
+const mongoInt32Codec = mongoCodec({
+	typeId: MONGO_INT32_CODEC_ID,
+	dataType: mongoInt32,
+	fromWire: (wire) => wire,
+	toWire: (value) => int32Encode(MONGO_INT32_CODEC_ID, value),
+	toDataTypeValue: (value) => mongoInt32.valueFrom(int32ToJson(MONGO_INT32_CODEC_ID, value), {}),
+	fromDataTypeValue: (value) => value.value
+});
+const mongoBooleanCodec = mongoCodec({
+	typeId: MONGO_BOOLEAN_CODEC_ID,
+	dataType: mongoBool,
+	fromWire: (wire) => wire,
+	toWire: (value) => booleanEncode(MONGO_BOOLEAN_CODEC_ID, value),
+	fromDataTypeValue: (value) => value.value
+});
+const mongoDateCodec = mongoCodec({
+	typeId: MONGO_DATE_CODEC_ID,
+	dataType: mongoDate,
+	fromWire: (wire) => wire,
+	toWire: (value) => dateEncode(MONGO_DATE_CODEC_ID, value),
+	toDataTypeValue: (value) => mongoDate.valueFrom(dateToJson(MONGO_DATE_CODEC_ID, value), {}),
+	fromDataTypeValue: (value) => new Date(value.value)
+});
+/** The vector codec for a column of `mongo/vector` with `params`. The dimension reaches only the TypeScript type `Vector<n>`. */
+function vectorCodec(params) {
+	return mongoCodec({
+		typeId: MONGO_VECTOR_CODEC_ID,
+		dataType: mongoVector,
+		...ifDefined("params", params),
+		fromWire: (wire) => wire,
+		toWire: (value) => vectorEncode(MONGO_VECTOR_CODEC_ID, value),
+		fromDataTypeValue: (value) => value.value
+	});
+}
+const mongoVectorCodec = vectorCodec();
+/**
+* A BSON `long`. The application value is a `bigint`, because a `number` cannot hold the full 64-bit range; its stored form is decimal text.
+*/
+const mongoInt64Codec = mongoCodec({
+	typeId: MONGO_INT64_CODEC_ID,
+	dataType: mongoInt64,
+	fromWire: (wire) => int64Decode(MONGO_INT64_CODEC_ID, wire),
+	toWire: (value) => int64Encode(MONGO_INT64_CODEC_ID, value),
+	toDataTypeValue: (value) => mongoInt64.valueFrom(int64ToJson(MONGO_INT64_CODEC_ID, value), {}),
+	fromDataTypeValue: (value) => BigInt(value.value)
+});
+/**
+* A BSON `long` read and written as a `number` from -(2^53 - 1) to 2^53 - 1, the value a Prisma 6 `Int` presents. A value outside that range, or with a fraction, is refused rather than rounded.
+*/
+const mongoInt64NumberCodec = mongoCodec({
+	typeId: MONGO_INT64_NUMBER_CODEC_ID,
+	dataType: mongoInt64,
+	fromWire: (wire) => int64NumberDecode(MONGO_INT64_NUMBER_CODEC_ID, wire),
+	toWire: (value) => int64NumberEncode(MONGO_INT64_NUMBER_CODEC_ID, value),
+	toDataTypeValue: (value) => mongoInt64.valueFrom(int64NumberToJson(MONGO_INT64_NUMBER_CODEC_ID, value), {}),
+	fromDataTypeValue: (value) => int64NumberFromDigits(MONGO_INT64_NUMBER_CODEC_ID, value.value)
+});
+/**
+* A BSON `decimal`. The application value and its stored form are the same decimal text, written without an exponent.
+*/
+const mongoDecimal128Codec = mongoCodec({
+	typeId: MONGO_DECIMAL128_CODEC_ID,
+	dataType: mongoDecimal128,
+	fromWire: (wire) => decimal128Decode(MONGO_DECIMAL128_CODEC_ID, wire),
+	toWire: (value) => decimal128Encode(MONGO_DECIMAL128_CODEC_ID, value),
+	toDataTypeValue: (value) => mongoDecimal128.valueFrom(decimal128ToJson(MONGO_DECIMAL128_CODEC_ID, value), {}),
+	fromDataTypeValue: (value) => value.value
+});
+/**
+* BSON `binData`. The application value is a `Uint8Array`; its stored form is unwrapped base64.
+*/
+const mongoBinaryCodec = mongoCodec({
+	typeId: MONGO_BINARY_CODEC_ID,
+	dataType: mongoBinary,
+	fromWire: (wire) => binaryDecode(MONGO_BINARY_CODEC_ID, wire),
+	toWire: (value) => binaryEncode(MONGO_BINARY_CODEC_ID, value),
+	toDataTypeValue: (value) => mongoBinary.valueFrom(binaryToBase64(value), {}),
+	fromDataTypeValue: (value) => binaryFromBase64(value.value)
+});
+/**
+* A JSON value, stored as the BSON object, array, string, number, boolean or null it maps to. Encode and decode refuse any other value at any depth, naming its path.
+*/
+const mongoJsonCodec = mongoCodec({
+	typeId: MONGO_JSON_CODEC_ID,
+	dataType: mongoJson,
+	fromWire: (wire) => decodeJsonValue(wire),
+	toWire: (value) => encodeJsonValue(value)
+});
+/**
+* Any BSON value, passed through unchanged except that decode turns a `DBRef` back into the `{ $ref, $id }` document it was stored as. Encode takes a `BsonInputValue` and decode returns a `BsonValue`. Its stored form is canonical MongoDB Extended JSON v2, written with each number and `Uint8Array` as the BSON type the driver stores, so a round trip keeps the BSON bytes but may return wrapper classes such as `Int32` and `Double`.
+*/
+const mongoBsonCodec = mongoCodec({
+	typeId: MONGO_BSON_CODEC_ID,
+	dataType: mongoBson,
+	fromWire: (wire) => decodeBsonValue(wire),
+	toWire: (value) => encodeBsonValue(value),
+	toDataTypeValue: (value) => mongoBson.valueFrom(bsonToJson(value), {}),
+	fromDataTypeValue: (value) => readBsonJson(MONGO_BSON_CODEC_ID, 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,
+	mongoInt64Codec,
+	mongoInt64NumberCodec,
+	mongoDecimal128Codec,
+	mongoBinaryCodec,
+	mongoJsonCodec,
+	mongoBsonCodec
+];
+/**
+* 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, or, for a codec whose data type has parameters, one built for the column's parameters. 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) {
+	return {
+		codecId: codec.id,
+		dataType: codec.dataType.id,
+		traits: metadata.traits,
+		paramsSchema: blindCast(codec.dataType.params),
+		isParameterized: codec.dataType.params !== void 0,
+		factory: blindCast((params) => {
+			const built = metadata.withParams === void 0 || params === void 0 ? codec : metadata.withParams(params);
+			return () => built;
+		}),
+		...ifDefined("renderValueLiteral", metadata.renderValueLiteral),
+		...ifDefined("keepsWrittenForm", metadata.keepsWrittenForm)
+	};
+}
+/**
+* Mongo wire-type codec descriptors. Static metadata such as `traits` lives here (the descriptor shape) — `MongoCodec` itself carries its data type and the four conversion methods (TML-2357).
+*/
+const mongoCodecDescriptors = [
+	descriptorFor(mongoObjectIdCodec, { traits: ["equality"] }),
+	descriptorFor(mongoStringCodec, {
+		traits: [
+			"equality",
+			"order",
+			"textual"
+		],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoDoubleCodec, {
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		renderValueLiteral: floatNumberLiteral
+	}),
+	descriptorFor(mongoInt32Codec, {
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoBooleanCodec, {
+		traits: ["equality", "boolean"],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoDateCodec, { traits: ["equality", "order"] }),
+	descriptorFor(mongoVectorCodec, {
+		traits: ["equality"],
+		withParams: vectorCodec
+	}),
+	descriptorFor(mongoInt64Codec, {
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		renderValueLiteral: decimalTextBigintLiteral
+	}),
+	descriptorFor(mongoInt64NumberCodec, {
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		renderValueLiteral: decimalTextNumberLiteral
+	}),
+	descriptorFor(mongoDecimal128Codec, {
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		keepsWrittenForm: true
+	}),
+	descriptorFor(mongoBinaryCodec, { traits: ["equality"] }),
+	descriptorFor(mongoJsonCodec, { traits: [] }),
+	descriptorFor(mongoBsonCodec, { traits: [] })
+];
+/**
+* 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 { mongoStandardCodecs as i, mongoCodecDescriptors as n, mongoDescriptorById as r, buildStandardCodecRegistry as t };
+
+//# sourceMappingURL=codecs-B1ab7vfj-QL33tkm2.mjs.map

package/dist/codecs-B1ab7vfj-QL33tkm2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-B1ab7vfj-QL33tkm2.mjs","names":[],"sources":["../../../../3-targets/mongo/1-target/dist/codecs-B1ab7vfj.mjs"],"sourcesContent":["import { a as MONGO_DECIMAL128_CODEC_ID, c as MONGO_INT64_CODEC_ID, d as MONGO_OBJECTID_CODEC_ID, f as MONGO_STRING_CODEC_ID, i as MONGO_DATE_CODEC_ID, l as MONGO_INT64_NUMBER_CODEC_ID, n as MONGO_BOOLEAN_CODEC_ID, o as MONGO_DOUBLE_CODEC_ID, p as MONGO_VECTOR_CODEC_ID, r as MONGO_BSON_CODEC_ID, s as MONGO_INT32_CODEC_ID, t as MONGO_BINARY_CODEC_ID, u as MONGO_JSON_CODEC_ID } from \"./codec-ids-WdrumsYA.mjs\";\nimport { t as mongoTargetError } from \"./mongo-target-errors-Btf3ML1w.mjs\";\nimport { $ as vectorEncode, A as binaryFromBase64, B as int32Encode, C as constructorName, D as where, E as isPlainObject, F as decimal128Decode, G as int64NumberEncode, H as int64Decode, I as decimal128Encode, J as int64ToJson, K as int64NumberFromDigits, M as booleanEncode, N as dateEncode, O as binaryDecode, P as dateToJson, Q as stringEncode, R as decimal128ToJson, S as child, T as isPlainArray, U as int64Encode, V as int32ToJson, W as int64NumberDecode, X as objectIdEncode, Z as objectIdToJson, _ as decodeBsonValue, a as mongoDate, b as bsonClassTag, c as mongoInt32, d as mongoObjectId, f as mongoString, g as bsonToJson, j as binaryToBase64, k as binaryEncode, l as mongoInt64, m as mongoVector, n as mongoBool, o as mongoDecimal128, q as int64NumberToJson, r as mongoBson, s as mongoDouble, t as mongoBinary, u as mongoJson, v as encodeBsonValue, w as dbRefEntries, x as bsonTypeTag, y as readBsonJson, z as doubleEncode } from \"./data-types-hoKLBrYZ.mjs\";\nimport { decimalTextBigintLiteral, decimalTextNumberLiteral, floatNumberLiteral, floatToJson, readJsonFloat, renderTsLiteral } from \"@internal/framework-components/codec\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { mongoCodec, newMongoCodecRegistry } from \"@internal/mongo-codec\";\nimport { ifDefined } from \"@internal/utils/defined\";\n//#region src/core/json-codec-helpers.ts\nconst BSON_TYPE_BY_TAG = {\n\tObjectId: \"objectId\",\n\tDecimal128: \"decimal\",\n\tBinary: \"binData\",\n\tBSONRegExp: \"regex\",\n\tTimestamp: \"timestamp\",\n\tBSONSymbol: \"symbol\",\n\tCode: \"javascript\",\n\tMinKey: \"minKey\",\n\tMaxKey: \"maxKey\"\n};\nconst NOT_FINITE_FIX = \"JSON has no NaN or Infinity; store null or a string, or declare the field Bson.\";\nconst BSON_FIX = \"Declare the field Bson to store BSON values.\";\nconst PLAIN_VALUE_FIX = \"Convert it to a plain object or array.\";\nconst ENCODE_FIX_BY_RECEIVED = {\n\tDate: \"Store the date as an ISO 8601 string, or declare the field Bson.\",\n\tbigint: \"Store it as a number in the safe-integer range or as decimal text, or declare the field Int64 or Bson.\",\n\tNaN: NOT_FINITE_FIX,\n\tInfinity: NOT_FINITE_FIX,\n\t\"-Infinity\": NOT_FINITE_FIX,\n\tundefined: \"Leave the key out, or store null.\",\n\tUint8Array: \"Store the bytes as a base64 string, or declare the field Binary or Bson.\",\n\tBuffer: \"Store the bytes as a base64 string, or declare the field Binary or Bson.\",\n\tBinary: \"Store the bytes as a base64 string, or declare the field Binary or Bson.\",\n\tObjectId: \"Store its hex string, or declare the field ObjectId or Bson.\",\n\tLong: \"Store a number in the safe-integer range or decimal text, or declare the field Int64 or Bson.\",\n\tDecimal128: \"Store the decimal text, or declare the field Decimal128 or Bson.\",\n\tInt32: \"Pass a plain number.\",\n\tDouble: \"Pass a plain number.\",\n\tRegExp: \"Store the pattern as a string, or declare the field Bson.\",\n\tBSONRegExp: \"Store the pattern as a string, or declare the field Bson.\",\n\tsymbol: \"Store a string instead.\",\n\tfunction: \"Store data, not a function.\",\n\t\"circular reference\": \"Remove the cycle; a JSON value is a tree.\",\n\t\"sparse array hole\": \"Fill the hole with null.\",\n\tDBRef: \"Write it as a { $ref, $id } document instead.\"\n};\nfunction encodeFix(received) {\n\treturn ENCODE_FIX_BY_RECEIVED[received] ?? (Object.hasOwn(BSON_TYPE_BY_TAG, received) ? BSON_FIX : PLAIN_VALUE_FIX);\n}\nfunction encodeRefused(received, path) {\n\tthrow mongoTargetError(\"RUNTIME.ENCODE_FAILED\", `${MONGO_JSON_CODEC_ID} value must be a JSON value; received ${received} at ${where(path)}. ${encodeFix(received)}`, { meta: {\n\t\tcodecId: MONGO_JSON_CODEC_ID,\n\t\treceived,\n\t\tvaluePath: path\n\t} });\n}\nfunction describeNonJson(value) {\n\tif (value === null || typeof value === \"string\" || typeof value === \"boolean\") return void 0;\n\tif (typeof value === \"number\") return Number.isFinite(value) ? void 0 : String(value);\n\tif (typeof value !== \"object\") return typeof value;\n\tconst tag = bsonTypeTag(value);\n\tif (tag !== void 0) return tag;\n\tif (value instanceof Date) return \"Date\";\n\tif (isPlainArray(value)) return void 0;\n\treturn isPlainObject(value) ? void 0 : constructorName(value);\n}\nfunction assertJsonValue(value, path, ancestors) {\n\tconst received = describeNonJson(value);\n\tif (received !== void 0) encodeRefused(received, path);\n\tif (typeof value !== \"object\" || value === null) return;\n\tif (ancestors.has(value)) encodeRefused(\"circular reference\", path);\n\tancestors.add(value);\n\tif (Array.isArray(value)) for (let index = 0; index < value.length; index++) {\n\t\tif (!(index in value)) encodeRefused(\"sparse array hole\", child(path, index));\n\t\tassertJsonValue(value[index], child(path, index), ancestors);\n\t}\n\telse for (const [key, entry] of Object.entries(value)) assertJsonValue(entry, child(path, key), ancestors);\n\tancestors.delete(value);\n}\n/**\n* Returns `value` unchanged when it is a plain JSON value at every depth, and throws `RUNTIME.ENCODE_FAILED` naming the first value that is not, with its path.\n*/\nfunction encodeJsonValue(value) {\n\tassertJsonValue(value, \"\", /* @__PURE__ */ new Set());\n\treturn value;\n}\nfunction decodeRefused(bsonType, path) {\n\tthrow mongoTargetError(\"RUNTIME.DECODE_FAILED\", `${MONGO_JSON_CODEC_ID} wire value contains a non-JSON BSON ${bsonType} at ${where(path)}`, { meta: {\n\t\tcodecId: MONGO_JSON_CODEC_ID,\n\t\treceived: bsonType,\n\t\tvaluePath: path\n\t} });\n}\nfunction safeLong(value, path) {\n\tconst number = Number(value);\n\treturn Number.isSafeInteger(number) && BigInt(number) === value ? number : decodeRefused(\"long\", path);\n}\nfunction finiteDouble(value, path) {\n\tif (Number.isFinite(value)) return value;\n\tconst received = String(value);\n\tthrow mongoTargetError(\"RUNTIME.DECODE_FAILED\", `${MONGO_JSON_CODEC_ID} wire value contains ${received} at ${where(path)}; a JSON number cannot be NaN or Infinity`, { meta: {\n\t\tcodecId: MONGO_JSON_CODEC_ID,\n\t\treceived,\n\t\tvaluePath: path\n\t} });\n}\nfunction decodeEntries(entries, path) {\n\treturn Object.fromEntries(entries.map(([key, entry]) => [key, decodeValue(entry, child(path, key))]));\n}\nfunction decodeTagged(value, tag, path) {\n\tswitch (tag) {\n\t\tcase \"DBRef\": return decodeEntries(dbRefEntries(value), path);\n\t\tcase \"Long\": return safeLong(blindCast(value).toBigInt(), path);\n\t\tcase \"Int32\":\n\t\tcase \"Double\": return finiteDouble(Number(value.valueOf()), path);\n\t}\n\treturn decodeRefused(BSON_TYPE_BY_TAG[tag] ?? tag, path);\n}\nfunction decodeValue(value, path) {\n\tif (value === null || typeof value === \"string\" || typeof value === \"boolean\") return value;\n\tif (typeof value === \"number\") return finiteDouble(value, path);\n\tif (typeof value === \"bigint\") return safeLong(value, path);\n\tif (typeof value === \"undefined\") return decodeRefused(\"undefined\", path);\n\tif (typeof value === \"symbol\") return decodeRefused(\"symbol\", path);\n\tif (typeof value === \"function\") return decodeRefused(\"javascript\", path);\n\tconst tag = bsonClassTag(value);\n\tif (tag !== void 0) return decodeTagged(value, tag, path);\n\tif (value instanceof Date) return decodeRefused(\"date\", path);\n\tif (value instanceof RegExp) return decodeRefused(\"regex\", path);\n\tif (value instanceof Uint8Array) return decodeRefused(\"binData\", path);\n\tif (Array.isArray(value)) {\n\t\tconst decoded = value.map((entry, index) => decodeValue(entry, child(path, index)));\n\t\treturn decoded.some((entry, index) => entry !== value[index]) ? decoded : value;\n\t}\n\tif (!isPlainObject(value)) return decodeRefused(constructorName(value), path);\n\tconst entries = Object.entries(value);\n\tconst decoded = decodeEntries(entries, path);\n\treturn entries.some(([key, entry]) => decoded[key] !== entry) ? decoded : blindCast(value);\n}\n/**\n* Decodes a wire value to the JSON value it holds: a `long` in the safe-integer range and the driver's `Int32` and `Double` wrappers become numbers. Only the objects and arrays around a converted value are copied; a wire value that is already JSON is returned as the same object. Throws `RUNTIME.DECODE_FAILED` naming the BSON type and path of the first value that is not JSON.\n*/\nfunction decodeJsonValue(wire) {\n\treturn decodeValue(wire, \"\");\n}\n//#endregion\n//#region src/core/codecs.ts\nconst mongoObjectIdCodec = mongoCodec({\n\ttypeId: MONGO_OBJECTID_CODEC_ID,\n\tdataType: mongoObjectId,\n\tfromWire: (wire) => wire.toHexString(),\n\ttoWire: (value) => objectIdEncode(MONGO_OBJECTID_CODEC_ID, value),\n\ttoDataTypeValue: (value) => mongoObjectId.valueFrom(objectIdToJson(MONGO_OBJECTID_CODEC_ID, value), {}),\n\tfromDataTypeValue: (value) => value.value\n});\nconst mongoStringCodec = mongoCodec({\n\ttypeId: MONGO_STRING_CODEC_ID,\n\tdataType: mongoString,\n\tfromWire: (wire) => wire,\n\ttoWire: (value) => stringEncode(MONGO_STRING_CODEC_ID, value),\n\tfromDataTypeValue: (value) => value.value\n});\nconst mongoDoubleCodec = mongoCodec({\n\ttypeId: MONGO_DOUBLE_CODEC_ID,\n\tdataType: mongoDouble,\n\tfromWire: (wire) => Number(wire),\n\ttoWire: (value) => doubleEncode(MONGO_DOUBLE_CODEC_ID, value),\n\ttoDataTypeValue: (value) => mongoDouble.valueFrom(floatToJson(value), {}),\n\tfromDataTypeValue: (value) => readJsonFloat(MONGO_DOUBLE_CODEC_ID, value.value)\n});\nconst mongoInt32Codec = mongoCodec({\n\ttypeId: MONGO_INT32_CODEC_ID,\n\tdataType: mongoInt32,\n\tfromWire: (wire) => wire,\n\ttoWire: (value) => int32Encode(MONGO_INT32_CODEC_ID, value),\n\ttoDataTypeValue: (value) => mongoInt32.valueFrom(int32ToJson(MONGO_INT32_CODEC_ID, value), {}),\n\tfromDataTypeValue: (value) => value.value\n});\nconst mongoBooleanCodec = mongoCodec({\n\ttypeId: MONGO_BOOLEAN_CODEC_ID,\n\tdataType: mongoBool,\n\tfromWire: (wire) => wire,\n\ttoWire: (value) => booleanEncode(MONGO_BOOLEAN_CODEC_ID, value),\n\tfromDataTypeValue: (value) => value.value\n});\nconst mongoDateCodec = mongoCodec({\n\ttypeId: MONGO_DATE_CODEC_ID,\n\tdataType: mongoDate,\n\tfromWire: (wire) => wire,\n\ttoWire: (value) => dateEncode(MONGO_DATE_CODEC_ID, value),\n\ttoDataTypeValue: (value) => mongoDate.valueFrom(dateToJson(MONGO_DATE_CODEC_ID, value), {}),\n\tfromDataTypeValue: (value) => new Date(value.value)\n});\n/** The vector codec for a column of `mongo/vector` with `params`. The dimension reaches only the TypeScript type `Vector<n>`. */\nfunction vectorCodec(params) {\n\treturn mongoCodec({\n\t\ttypeId: MONGO_VECTOR_CODEC_ID,\n\t\tdataType: mongoVector,\n\t\t...ifDefined(\"params\", params),\n\t\tfromWire: (wire) => wire,\n\t\ttoWire: (value) => vectorEncode(MONGO_VECTOR_CODEC_ID, value),\n\t\tfromDataTypeValue: (value) => value.value\n\t});\n}\nconst mongoVectorCodec = vectorCodec();\n/**\n* A BSON `long`. The application value is a `bigint`, because a `number` cannot hold the full 64-bit range; its stored form is decimal text.\n*/\nconst mongoInt64Codec = mongoCodec({\n\ttypeId: MONGO_INT64_CODEC_ID,\n\tdataType: mongoInt64,\n\tfromWire: (wire) => int64Decode(MONGO_INT64_CODEC_ID, wire),\n\ttoWire: (value) => int64Encode(MONGO_INT64_CODEC_ID, value),\n\ttoDataTypeValue: (value) => mongoInt64.valueFrom(int64ToJson(MONGO_INT64_CODEC_ID, value), {}),\n\tfromDataTypeValue: (value) => BigInt(value.value)\n});\n/**\n* A BSON `long` read and written as a `number` from -(2^53 - 1) to 2^53 - 1, the value a Prisma 6 `Int` presents. A value outside that range, or with a fraction, is refused rather than rounded.\n*/\nconst mongoInt64NumberCodec = mongoCodec({\n\ttypeId: MONGO_INT64_NUMBER_CODEC_ID,\n\tdataType: mongoInt64,\n\tfromWire: (wire) => int64NumberDecode(MONGO_INT64_NUMBER_CODEC_ID, wire),\n\ttoWire: (value) => int64NumberEncode(MONGO_INT64_NUMBER_CODEC_ID, value),\n\ttoDataTypeValue: (value) => mongoInt64.valueFrom(int64NumberToJson(MONGO_INT64_NUMBER_CODEC_ID, value), {}),\n\tfromDataTypeValue: (value) => int64NumberFromDigits(MONGO_INT64_NUMBER_CODEC_ID, value.value)\n});\n/**\n* A BSON `decimal`. The application value and its stored form are the same decimal text, written without an exponent.\n*/\nconst mongoDecimal128Codec = mongoCodec({\n\ttypeId: MONGO_DECIMAL128_CODEC_ID,\n\tdataType: mongoDecimal128,\n\tfromWire: (wire) => decimal128Decode(MONGO_DECIMAL128_CODEC_ID, wire),\n\ttoWire: (value) => decimal128Encode(MONGO_DECIMAL128_CODEC_ID, value),\n\ttoDataTypeValue: (value) => mongoDecimal128.valueFrom(decimal128ToJson(MONGO_DECIMAL128_CODEC_ID, value), {}),\n\tfromDataTypeValue: (value) => value.value\n});\n/**\n* BSON `binData`. The application value is a `Uint8Array`; its stored form is unwrapped base64.\n*/\nconst mongoBinaryCodec = mongoCodec({\n\ttypeId: MONGO_BINARY_CODEC_ID,\n\tdataType: mongoBinary,\n\tfromWire: (wire) => binaryDecode(MONGO_BINARY_CODEC_ID, wire),\n\ttoWire: (value) => binaryEncode(MONGO_BINARY_CODEC_ID, value),\n\ttoDataTypeValue: (value) => mongoBinary.valueFrom(binaryToBase64(value), {}),\n\tfromDataTypeValue: (value) => binaryFromBase64(value.value)\n});\n/**\n* A JSON value, stored as the BSON object, array, string, number, boolean or null it maps to. Encode and decode refuse any other value at any depth, naming its path.\n*/\nconst mongoJsonCodec = mongoCodec({\n\ttypeId: MONGO_JSON_CODEC_ID,\n\tdataType: mongoJson,\n\tfromWire: (wire) => decodeJsonValue(wire),\n\ttoWire: (value) => encodeJsonValue(value)\n});\n/**\n* Any BSON value, passed through unchanged except that decode turns a `DBRef` back into the `{ $ref, $id }` document it was stored as. Encode takes a `BsonInputValue` and decode returns a `BsonValue`. Its stored form is canonical MongoDB Extended JSON v2, written with each number and `Uint8Array` as the BSON type the driver stores, so a round trip keeps the BSON bytes but may return wrapper classes such as `Int32` and `Double`.\n*/\nconst mongoBsonCodec = mongoCodec({\n\ttypeId: MONGO_BSON_CODEC_ID,\n\tdataType: mongoBson,\n\tfromWire: (wire) => decodeBsonValue(wire),\n\ttoWire: (value) => encodeBsonValue(value),\n\ttoDataTypeValue: (value) => mongoBson.valueFrom(bsonToJson(value), {}),\n\tfromDataTypeValue: (value) => readBsonJson(MONGO_BSON_CODEC_ID, 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\tmongoInt64Codec,\n\tmongoInt64NumberCodec,\n\tmongoDecimal128Codec,\n\tmongoBinaryCodec,\n\tmongoJsonCodec,\n\tmongoBsonCodec\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, or, for a codec whose data type has parameters, one built for the column's parameters. 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\treturn {\n\t\tcodecId: codec.id,\n\t\tdataType: codec.dataType.id,\n\t\ttraits: metadata.traits,\n\t\tparamsSchema: blindCast(codec.dataType.params),\n\t\tisParameterized: codec.dataType.params !== void 0,\n\t\tfactory: blindCast((params) => {\n\t\t\tconst built = metadata.withParams === void 0 || params === void 0 ? codec : metadata.withParams(params);\n\t\t\treturn () => built;\n\t\t}),\n\t\t...ifDefined(\"renderValueLiteral\", metadata.renderValueLiteral),\n\t\t...ifDefined(\"keepsWrittenForm\", metadata.keepsWrittenForm)\n\t};\n}\n/**\n* Mongo wire-type codec descriptors. Static metadata such as `traits` lives here (the descriptor shape) — `MongoCodec` itself carries its data type and the four conversion methods (TML-2357).\n*/\nconst mongoCodecDescriptors = [\n\tdescriptorFor(mongoObjectIdCodec, { traits: [\"equality\"] }),\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\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\trenderValueLiteral: floatNumberLiteral\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\trenderValueLiteral: renderTsLiteral\n\t}),\n\tdescriptorFor(mongoBooleanCodec, {\n\t\ttraits: [\"equality\", \"boolean\"],\n\t\trenderValueLiteral: renderTsLiteral\n\t}),\n\tdescriptorFor(mongoDateCodec, { traits: [\"equality\", \"order\"] }),\n\tdescriptorFor(mongoVectorCodec, {\n\t\ttraits: [\"equality\"],\n\t\twithParams: vectorCodec\n\t}),\n\tdescriptorFor(mongoInt64Codec, {\n\t\ttraits: [\n\t\t\t\"equality\",\n\t\t\t\"order\",\n\t\t\t\"numeric\"\n\t\t],\n\t\trenderValueLiteral: decimalTextBigintLiteral\n\t}),\n\tdescriptorFor(mongoInt64NumberCodec, {\n\t\ttraits: [\n\t\t\t\"equality\",\n\t\t\t\"order\",\n\t\t\t\"numeric\"\n\t\t],\n\t\trenderValueLiteral: decimalTextNumberLiteral\n\t}),\n\tdescriptorFor(mongoDecimal128Codec, {\n\t\ttraits: [\n\t\t\t\"equality\",\n\t\t\t\"order\",\n\t\t\t\"numeric\"\n\t\t],\n\t\tkeepsWrittenForm: true\n\t}),\n\tdescriptorFor(mongoBinaryCodec, { traits: [\"equality\"] }),\n\tdescriptorFor(mongoJsonCodec, { traits: [] }),\n\tdescriptorFor(mongoBsonCodec, { traits: [] })\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 { mongoStandardCodecs as i, mongoCodecDescriptors as n, mongoDescriptorById as r, buildStandardCodecRegistry as t };\n\n//# sourceMappingURL=codecs-B1ab7vfj.mjs.map"],"mappings":"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"}

package/dist/codecs-Y5GYsLPj.d.mts

@@ -0,0 +1,36 @@
+import { CodecDescriptor } from "@prisma/orm-framework/components/codec";
+import { Binary, Decimal128, Double, Long, ObjectId } from "bson";
+import { MongoCodec, MongoCodecRegistry } from "@prisma/orm-family-mongo/codec";
+import { JsonValue } from "@prisma/orm-framework/contract/types";
+import { BsonInputValue, BsonValue } from "@prisma/orm-family-mongo/value";
+//#region ../../../3-targets/mongo/1-target/dist/codecs.d.mts
+//#region src/core/codecs.d.ts
+/**
+ * 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.
+ */
+declare const mongoStandardCodecs: readonly [MongoCodec<"mongo/objectId@1", readonly [], ObjectId, string, string>, MongoCodec<"mongo/string@1", readonly [], string, string, string>, MongoCodec<"mongo/double@1", readonly [], number | Double, number, number>, MongoCodec<"mongo/int32@1", readonly [], number, number, number>, MongoCodec<"mongo/bool@1", readonly [], boolean, boolean, boolean>, MongoCodec<"mongo/date@1", readonly [], Date, Date, Date>, MongoCodec<"mongo/vector@1", readonly [], readonly number[], readonly number[], readonly number[]>, MongoCodec<"mongo/int64@1", readonly [], number | bigint | Long, bigint, bigint>, MongoCodec<"mongo/int64Number@1", readonly [], number | bigint | Long, number, number>, MongoCodec<"mongo/decimal128@1", readonly [], Decimal128, string, string>, MongoCodec<"mongo/binary@1", readonly [], Binary | Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, MongoCodec<"mongo/json@1", readonly [], string | number | boolean | {
+  readonly [key: string]: JsonValue;
+} | readonly JsonValue[] | null, string | number | boolean | {
+  readonly [key: string]: JsonValue;
+} | readonly JsonValue[] | null, string | number | boolean | {
+  readonly [key: string]: JsonValue;
+} | readonly JsonValue[] | null>, MongoCodec<"mongo/bson@1", readonly [], BsonInputValue, BsonInputValue, BsonValue>];
+/**
+ * Mongo wire-type codec descriptors. Static metadata such as `traits` lives here (the descriptor shape) — `MongoCodec` itself carries its data type and the four conversion methods (TML-2357).
+ */
+declare const mongoCodecDescriptors: ReadonlyArray<CodecDescriptor>;
+/**
+ * Lookup descriptor metadata by codec id — used by tests and for descriptor-side reads of static metadata.
+ */
+declare function mongoDescriptorById(codecId: string): CodecDescriptor | undefined;
+/**
+ * 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.
+ */
+declare function buildStandardCodecRegistry(): MongoCodecRegistry;
+//#endregion
+export { mongoStandardCodecs as i, mongoCodecDescriptors as n, mongoDescriptorById as r, buildStandardCodecRegistry as t };
+//# sourceMappingURL=codecs-Y5GYsLPj.d.mts.map

package/dist/codecs-Y5GYsLPj.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-Y5GYsLPj.d.mts","names":[],"sources":["../../../../3-targets/mongo/1-target/dist/codecs.d.mts"],"mappings":";;;;;;;;;;;;cAWc,+BAA+B,4CAA4C,2BAA2B,mEAAmE,mDAAmD,yBAAyB,kEAAkE,oEAAoE,wCAAwC,MAAM,MAAM,OAAO,oGAAoG,2DAA2D,uBAAuB,iEAAiE,uBAAuB,8CAA8C,6BAA6B,0CAA0C,SAAS,WAAW,kBAAkB,WAAW,kBAAkB,WAAW,mBAAmB;YAC55B,cAAc;aACb;YACD,cAAc;aACb;YACD,cAAc;aACb,qBAAqB,wCAAwC,gBAAgB,gBAAgB;;;;cAI5F,uBAAuB,cAAc;;;;iBAIlC,oBAAoB,kBAAkB;;;;;;iBAMtC,8BAA8B"}