@prisma/orm-target-mongo 8.0.0-rc.18-dev.16 → 8.0.0-rc.18-dev.18

package/dist/codecs-D6yLMoD2-Bn8-UhA5.mjs

@@ -1,854 +0,0 @@
-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-BkQfspmL.mjs";
-import { t as mongoTargetError } from "./mongo-target-errors-Btf3ML1w-B5EMYbz1.mjs";
-import { a as mongoDate, c as mongoInt32, d as mongoObjectId, f as mongoString, l as mongoInt64, n as mongoBool, o as mongoDecimal128, p as mongoVector, r as mongoBson, s as mongoDouble, t as mongoBinary, u as mongoJson } from "./data-types-D7u1m_Jl-C5XUZspA.mjs";
-import { INT32_RANGE, INT64_RANGE, SAFE_INTEGER_BIGINT_RANGE, SAFE_INTEGER_RANGE, decodeJsonBoolean, decodeJsonFloat, decodeJsonInteger, decodeJsonIntegerText, decodeJsonMatching, decodeJsonString, encodeJsonFloat, isIntegerIn, refuseJsonValue, renderTsLiteral } from "@prisma/orm-framework/components/codec";
-import { mongoCodec, newMongoCodecRegistry } from "@prisma/orm-family-mongo/codec";
-import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { isDeepStrictEqual } from "node:util";
-import { Binary, Code, Decimal128, Double, EJSON, Long, MinKey, ObjectId } from "bson";
-//#region ../../../3-mongo-target/1-mongo-target/dist/codecs-D6yLMoD2.mjs
-function where(path) {
-	return path === "" ? "the root" : path;
-}
-function child(path, key) {
-	return path === "" ? String(key) : `${path}.${key}`;
-}
-function isPlainObject(value) {
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-}
-function isPlainArray(value) {
-	return Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype;
-}
-const BSON_VERSION = Symbol.for("@@mdb.bson.version");
-/** The major version of the `bson` this package loads, which every `bson` class instance it can serialise carries. */
-const BSON_MAJOR = Reflect.get(new MinKey(), BSON_VERSION);
-/** Whether a `bson` class instance comes from the same major version of `bson`, rather than being a look-alike or from another version. */
-function createdByBsonMajor(value) {
-	return Reflect.get(value, BSON_VERSION) === BSON_MAJOR;
-}
-function bsonTypeTag(value) {
-	const tag = Reflect.get(value, "_bsontype");
-	return typeof tag === "string" ? tag : void 0;
-}
-/**
-* The `_bsontype` tag of a `bson` class instance. A stored subdocument is read as a plain object even when it has a `_bsontype` key, so a plain object has no tag.
-*/
-function bsonClassTag(value) {
-	return isPlainObject(value) ? void 0 : bsonTypeTag(value);
-}
-function constructorName(value) {
-	const name = Reflect.get(value, "constructor")?.name;
-	return typeof name === "string" && name !== "" ? name : "object";
-}
-/**
-* The `bson` library reads any subdocument with a string `$ref` and an `$id` as a `DBRef`. It was stored as a plain object; these are its entries in stored order, `$ref`, `$id`, `$db` when present, then the other fields.
-*/
-function dbRefEntries(value) {
-	const ref = blindCast(value);
-	const entries = [["$ref", ref.collection], ["$id", ref.oid]];
-	if (ref.db !== void 0) entries.push(["$db", ref.db]);
-	entries.push(...Object.entries(ref.fields));
-	return entries;
-}
-const BSON_VALUE_TAGS = /* @__PURE__ */ new Set([
-	"ObjectId",
-	"Long",
-	"Decimal128",
-	"Binary",
-	"BSONRegExp",
-	"Timestamp",
-	"Int32",
-	"Double",
-	"Code",
-	"MinKey",
-	"MaxKey",
-	"BSONSymbol"
-]);
-const ENCODE_FIX_BY_RECEIVED$1 = { DBRef: "Write it as a { $ref, $id } document instead." };
-function encodeRefused$1(received, path) {
-	const fix = ENCODE_FIX_BY_RECEIVED$1[received];
-	throw mongoTargetError("RUNTIME.ENCODE_FAILED", `${MONGO_BSON_CODEC_ID} value must be a BSON value; received ${received} at ${where(path)}${fix === void 0 ? "" : `. ${fix}`}`, { meta: {
-		codecId: MONGO_BSON_CODEC_ID,
-		received,
-		valuePath: path
-	} });
-}
-function assertBsonValue(value, path, ancestors) {
-	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number") return;
-	if (typeof value !== "object") {
-		encodeRefused$1(typeof value, path);
-		return;
-	}
-	const tag = bsonTypeTag(value);
-	if (tag !== void 0) {
-		if (!BSON_VALUE_TAGS.has(tag)) encodeRefused$1(tag, path);
-		if (!createdByBsonMajor(value)) encodeRefused$1(`${tag} not created by bson ${String(BSON_MAJOR)}`, path);
-		return;
-	}
-	if (value instanceof Date || value instanceof RegExp || value instanceof Uint8Array) return;
-	if (!isPlainArray(value) && !isPlainObject(value)) {
-		encodeRefused$1(constructorName(value), path);
-		return;
-	}
-	if (ancestors.has(value)) encodeRefused$1("circular reference", path);
-	ancestors.add(value);
-	if (Array.isArray(value)) for (let index = 0; index < value.length; index++) {
-		if (!(index in value)) encodeRefused$1("sparse array hole", child(path, index));
-		assertBsonValue(value[index], child(path, index), ancestors);
-	}
-	else for (const [key, entry] of Object.entries(value)) assertBsonValue(entry, child(path, key), ancestors);
-	ancestors.delete(value);
-}
-/**
-* Returns `value` unchanged when it is a BSON value at every depth, and throws `RUNTIME.ENCODE_FAILED` naming the first value that is not, with its path.
-*/
-function encodeBsonValue(value) {
-	assertBsonValue(value, "", /* @__PURE__ */ new Set());
-	return value;
-}
-/**
-* A `Code` value with a scope, recognised by its tag: the driver reads with its own load of `bson`, so its `Code` is not an instance of the class imported here.
-*/
-function codeWithScope(value) {
-	if (bsonClassTag(value) !== "Code") return void 0;
-	const code = Reflect.get(value, "code");
-	const scope = Reflect.get(value, "scope");
-	return typeof code === "string" && typeof scope === "object" && scope !== null ? {
-		code,
-		scope
-	} : void 0;
-}
-function decodeEntries$1(entries) {
-	return Object.fromEntries(entries.map(([key, entry]) => [key, decodeValue$1(entry)]));
-}
-function decodeValue$1(value) {
-	if (typeof value !== "object" || value === null) return value;
-	if (bsonClassTag(value) === "DBRef") return decodeEntries$1(dbRefEntries(value));
-	if (Array.isArray(value)) {
-		const decoded = value.map(decodeValue$1);
-		return decoded.some((entry, index) => entry !== value[index]) ? decoded : value;
-	}
-	const code = codeWithScope(value);
-	if (code !== void 0) {
-		const scope = decodeValue$1(code.scope);
-		return scope === code.scope ? value : new Code(code.code, blindCast(scope));
-	}
-	if (!isPlainObject(value)) return value;
-	const entries = Object.entries(value);
-	const decoded = decodeEntries$1(entries);
-	return entries.some(([key, entry]) => decoded[key] !== entry) ? decoded : value;
-}
-/**
-* Returns the wire value as the driver produced it, except that a `DBRef` the `bson` library read from a `{ $ref, $id }` subdocument becomes that document again, `{ $ref, $id[, $db], ...fields }`, with its members' BSON types kept, at any depth and inside a `Code` scope. A value holding no `DBRef` is returned as the same object.
-*/
-function decodeBsonValue(wire) {
-	return blindCast(decodeValue$1(wire));
-}
-function asDriverWrites(value) {
-	if (typeof value === "number") return Number.isInteger(value) && (value < INT32_RANGE.min || value > INT32_RANGE.max) ? new Double(value) : value;
-	if (typeof value !== "object" || value === null) return value;
-	if (value instanceof Uint8Array) return new Binary(value);
-	if (Array.isArray(value)) return value.map(asDriverWrites);
-	if (isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, asDriverWrites(entry)]));
-	const code = codeWithScope(value);
-	if (code !== void 0) return new Code(code.code, blindCast(asDriverWrites(code.scope)));
-	return value;
-}
-/**
-* Canonical Extended JSON for a BSON value, recording each JavaScript number and `Uint8Array` as the BSON type the driver writes for it: an integer outside the int32 range as a `double`, and bytes as `binData`.
-*/
-function encodeBsonJson(value) {
-	return blindCast(EJSON.serialize(asDriverWrites(value), { relaxed: false }));
-}
-/**
-* Reads the canonical Extended JSON `encodeBsonJson` writes. The `bson` reader also takes forms that are not canonical, some of them silently wrong (`{ "$numberInt": "abc" }` reads as 0), so a value that does not write back to the same JSON is refused.
-*/
-function decodeBsonJson(json) {
-	let value;
-	try {
-		value = EJSON.deserialize(blindCast(json), { relaxed: false });
-	} catch {
-		return refuseJsonValue(MONGO_BSON_CODEC_ID, "canonical Extended JSON", json);
-	}
-	if (!isDeepStrictEqual(EJSON.serialize(value, { relaxed: false }), json)) return refuseJsonValue(MONGO_BSON_CODEC_ID, "canonical Extended JSON", json);
-	return value;
-}
-const DECIMAL_INTEGER = /^-?\d+$/;
-const CANONICAL_DECIMAL_TEXT = /^(?:-?\d+(?:\.\d+)?|NaN|-?Infinity)$/;
-const DECIMAL128_TEXT = /^(-?)(\d+)(?:\.(\d+))?(?:E([+-]\d+))?$/;
-const BASE64_TEXT = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
-/**
-* Checks the BSON type tag rather than `instanceof`: the driver deserialises with its own load of `bson` (CommonJS, where this module may be loaded as ESM), so a value read from the database need not be an instance of the class imported here.
-*/
-function hasBsonTypeTag(value, tag) {
-	return typeof value === "object" && value !== null && "_bsontype" in value && value._bsontype === tag;
-}
-function isLong(value) {
-	return hasBsonTypeTag(value, "Long");
-}
-function isDecimal128(value) {
-	return hasBsonTypeTag(value, "Decimal128");
-}
-function isBinary(value) {
-	return hasBsonTypeTag(value, "Binary");
-}
-function decodeFailed(codecId, message, received) {
-	throw mongoTargetError("RUNTIME.DECODE_FAILED", `${codecId} ${message}`, { meta: {
-		codecId,
-		received: typeof received
-	} });
-}
-const RECEIVED_PREVIEW_LIMIT = 100;
-function encodeFailed(codecId, message, received) {
-	throw mongoTargetError("RUNTIME.ENCODE_FAILED", `${codecId} ${message}`, { meta: {
-		codecId,
-		received: String(received).slice(0, RECEIVED_PREVIEW_LIMIT)
-	} });
-}
-function describeReceived(value) {
-	if (typeof value === "number") return String(value);
-	if (typeof value === "bigint") return `${value}n`;
-	if (typeof value === "string") return `string ${JSON.stringify(value.slice(0, RECEIVED_PREVIEW_LIMIT))}`;
-	if (value === null) return "null";
-	if (value instanceof Date) return Number.isNaN(value.getTime()) ? "an invalid Date" : "a Date";
-	if (Array.isArray(value)) return "an array";
-	return typeof value;
-}
-function refuseType(codecId, expected, value, received = describeReceived(value)) {
-	return encodeFailed(codecId, `value must be ${expected}; received ${received}`, value);
-}
-function stringEncode(codecId, value) {
-	if (typeof value !== "string") refuseType(codecId, "a string", value);
-	return value;
-}
-function booleanEncode(codecId, value) {
-	if (typeof value !== "boolean") refuseType(codecId, "a boolean", value);
-	return value;
-}
-/**
-* The driver writes an invalid `Date` as the epoch, so one is refused with any other non-`Date` value.
-*/
-function dateEncode(codecId, value) {
-	if (!(value instanceof Date) || Number.isNaN(value.getTime())) refuseType(codecId, "a valid Date", value);
-	return value;
-}
-const OBJECT_ID_TEXT = /^[0-9a-fA-F]{24}$/;
-function hexStringOf(value) {
-	const toHexString = Reflect.get(value, "toHexString");
-	if (typeof toHexString !== "function") return void 0;
-	const hex = Reflect.apply(toHexString, value, []);
-	return typeof hex === "string" && OBJECT_ID_TEXT.test(hex) ? hex : void 0;
-}
-/**
-* `new ObjectId(...)` makes a fresh id from `null` or `undefined` and reads a number as a timestamp, so only a string, which the constructor accepts only as 24 hex digits, or an `ObjectId` is passed to it. An `ObjectId` is rebuilt from its hex string, so one from any major version of `bson` works.
-*/
-function objectIdEncode(codecId, value) {
-	const expected = "a 24-digit hex string or an ObjectId";
-	if (typeof value === "string") try {
-		return new ObjectId(value);
-	} catch {
-		return refuseType(codecId, expected, value);
-	}
-	if (typeof value !== "object" || value === null || !hasBsonTypeTag(value, "ObjectId")) return refuseType(codecId, expected, value);
-	const hex = hexStringOf(value);
-	if (hex === void 0) return refuseType(codecId, expected, value, "an object tagged ObjectId whose toHexString() does not return 24 hex digits");
-	return new ObjectId(hex);
-}
-function vectorEncode(codecId, value) {
-	if (!Array.isArray(value) || !value.every((element) => typeof element === "number")) refuseType(codecId, "an array of numbers", value);
-	return value;
-}
-/**
-* Wraps the number in the driver's `Double`, because the driver writes a whole JavaScript number in the int32 range as a BSON `int`, which a `double` validator refuses.
-*/
-function doubleEncode(codecId, value) {
-	if (typeof value !== "number") encodeFailed(codecId, `value must be a number; received ${describeReceived(value)}`, value);
-	return new Double(value);
-}
-function int32Encode(codecId, value) {
-	if (!isIntegerIn(value, INT32_RANGE)) encodeFailed(codecId, `value must be an integer from ${INT32_RANGE.min} to ${INT32_RANGE.max}; received ${describeReceived(value)}`, value);
-	return value;
-}
-function objectIdEncodeJson(codecId, value) {
-	if (typeof value !== "string" || !OBJECT_ID_TEXT.test(value)) encodeFailed(codecId, "value must be 24 hexadecimal digits", value);
-	return value;
-}
-function objectIdDecodeJson(codecId, json) {
-	return decodeJsonMatching(codecId, json, OBJECT_ID_TEXT, "24 hexadecimal digits");
-}
-function int32EncodeJson(codecId, value) {
-	if (!isIntegerIn(value, INT32_RANGE)) encodeFailed(codecId, `value must be an integer from ${INT32_RANGE.min} to ${INT32_RANGE.max}`, value);
-	return value;
-}
-function int32DecodeJson(codecId, json) {
-	return decodeJsonInteger(codecId, json, INT32_RANGE);
-}
-function dateEncodeJson(codecId, value) {
-	if (!(value instanceof Date) || Number.isNaN(value.getTime())) encodeFailed(codecId, "value must be a valid Date", value);
-	return value.toISOString();
-}
-/**
-* The JSON form is the text `Date.toISOString()` writes, so a string that does not read back to that same text is refused.
-*/
-function dateDecodeJson(codecId, json) {
-	const date = typeof json === "string" ? new Date(json) : void 0;
-	if (date === void 0 || Number.isNaN(date.getTime()) || date.toISOString() !== json) return refuseJsonValue(codecId, "a date and time in UTC as Date.toISOString writes it", json);
-	return date;
-}
-function vectorDecodeJson(codecId, json) {
-	if (!Array.isArray(json)) return refuseJsonValue(codecId, "an array of numbers", json);
-	const numbers = [];
-	for (const element of json) {
-		if (typeof element !== "number") return refuseJsonValue(codecId, "an array of numbers", element);
-		numbers.push(element);
-	}
-	return numbers;
-}
-/**
-* `Long.fromBigInt` keeps the low 64 bits of any bigint, so an out-of-range value would be stored as a different number without error.
-*/
-function isInt64(value) {
-	return value >= INT64_RANGE.min && value <= INT64_RANGE.max;
-}
-function requireInt64(codecId, value) {
-	if (!isInt64(value)) encodeFailed(codecId, "value is outside the signed 64-bit range", value);
-	return value;
-}
-function int64Encode(codecId, value) {
-	if (typeof value !== "bigint") encodeFailed(codecId, "value must be a bigint", value);
-	return Long.fromBigInt(requireInt64(codecId, value));
-}
-/**
-* A stored double with a fraction, which a 64-bit integer codec cannot read. Such values were written through a Prisma 6 `Int` while its contract used the 32-bit codec, which took any number.
-*/
-function refuseFractionalDouble(codecId, wire) {
-	return decodeFailed(codecId, `wire value is the fractional double ${wire}, and a 64-bit integer holds whole numbers only. Rewrite each such stored value as a long, rounded or cut off ({ $toLong: { $round: [<value>, 0] } }, or $trunc in place of $round), mapping over the list when the value sits in one. The upgrade guide step prisma6-int-written-as-long has the queries for a plain field, a list and a list of composite values.`, wire);
-}
-/**
-* The driver promotes a stored `long` that fits in 53 bits to a `number`, and hands larger ones over as `Long`, so both arrive here.
-*/
-function int64Decode(codecId, wire) {
-	if (typeof wire === "bigint") return wire;
-	if (isLong(wire)) return wire.toBigInt();
-	if (typeof wire === "number" && Number.isSafeInteger(wire)) return BigInt(wire);
-	if (typeof wire === "number" && Number.isFinite(wire) && !Number.isInteger(wire)) return refuseFractionalDouble(codecId, wire);
-	return decodeFailed(codecId, "wire value must be a Long or a safe integer", wire);
-}
-/**
-* A schema-written default arrives as a `number`; one that is a safe integer names its value exactly, so it is accepted like `pg/int8@1` accepts it.
-*/
-function int64EncodeJson(codecId, value) {
-	if (typeof value === "bigint") return requireInt64(codecId, value).toString();
-	if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value).toString();
-	return encodeFailed(codecId, "value must be a bigint or a safe integer", value);
-}
-function int64DecodeJson(codecId, json) {
-	return decodeJsonIntegerText(codecId, json, INT64_RANGE);
-}
-const SAFE_INTEGERS = `from ${SAFE_INTEGER_RANGE.min} to ${SAFE_INTEGER_RANGE.max}`;
-function int64NumberEncode(codecId, value) {
-	if (!isIntegerIn(value, SAFE_INTEGER_RANGE)) encodeFailed(codecId, `value must be an integer ${SAFE_INTEGERS}; received ${describeReceived(value)}`, value);
-	return Long.fromNumber(value);
-}
-function safeIntegerOf(codecId, value) {
-	if (value < SAFE_INTEGER_BIGINT_RANGE.min || value > SAFE_INTEGER_BIGINT_RANGE.max) decodeFailed(codecId, `wire value must be a whole number ${SAFE_INTEGERS}; received ${value}`, value);
-	return Number(value);
-}
-/**
-* The driver hands a stored `long` over as a `number` when it fits in 53 bits (the default `promoteLongs`), as a `Long` otherwise or with `promoteLongs: false`, and as a `bigint` with `useBigInt64`.
-*/
-function int64NumberDecode(codecId, wire) {
-	if (typeof wire === "bigint") return safeIntegerOf(codecId, wire);
-	if (isLong(wire)) return safeIntegerOf(codecId, wire.toBigInt());
-	if (isIntegerIn(wire, SAFE_INTEGER_RANGE)) return wire;
-	if (typeof wire === "number" && Number.isFinite(wire) && !Number.isInteger(wire)) return refuseFractionalDouble(codecId, wire);
-	return decodeFailed(codecId, `wire value must be a whole number ${SAFE_INTEGERS}; received ${describeReceived(wire)}`, wire);
-}
-function int64NumberEncodeJson(codecId, value) {
-	return int64NumberEncode(codecId, value).toString();
-}
-function int64NumberDecodeJson(codecId, json) {
-	return Number(decodeJsonIntegerText(codecId, json, SAFE_INTEGER_BIGINT_RANGE));
-}
-function decimalTextNumberLiteral(value) {
-	return typeof value === "string" && DECIMAL_INTEGER.test(value) ? value : void 0;
-}
-function decimalTextBigintLiteral(value) {
-	return typeof value === "string" && DECIMAL_INTEGER.test(value) ? `${value}n` : void 0;
-}
-/**
-* `Decimal128.toString()` writes some values with an exponent (`1E+3`, `1.23E+40`). The application value is decimal text without one, as for Postgres `numeric`: the point moves to where the exponent puts it, trailing zeros stay, and the sign of zero goes.
-*/
-function canonicalDecimalText(text) {
-	if (text === "NaN" || text === "Infinity" || text === "-Infinity") return text;
-	const match = DECIMAL128_TEXT.exec(text);
-	if (match === null) return void 0;
-	const [, sign = "", whole = "", fraction = "", exponent = "0"] = match;
-	const digits = `${whole}${fraction}`;
-	const point = whole.length + Number(exponent);
-	let integerPart;
-	let fractionPart;
-	if (point <= 0) {
-		integerPart = "0";
-		fractionPart = `${"0".repeat(-point)}${digits}`;
-	} else if (point >= digits.length) {
-		integerPart = `${digits}${"0".repeat(point - digits.length)}`;
-		fractionPart = "";
-	} else {
-		integerPart = digits.slice(0, point);
-		fractionPart = digits.slice(point);
-	}
-	const trimmedInteger = integerPart.replace(/^0+(?=\d)/, "");
-	const unsigned = fractionPart === "" ? trimmedInteger : `${trimmedInteger}.${fractionPart}`;
-	return /^[0.]+$/.test(unsigned) ? unsigned : `${sign}${unsigned}`;
-}
-function requireCanonicalDecimalText(codecId, value) {
-	if (typeof value !== "string" || !CANONICAL_DECIMAL_TEXT.test(value)) encodeFailed(codecId, "value must be decimal text without an exponent, or NaN, Infinity or -Infinity", value);
-	return value;
-}
-function decimal128Encode(codecId, value) {
-	requireCanonicalDecimalText(codecId, value);
-	try {
-		return Decimal128.fromString(value);
-	} catch (error) {
-		return encodeFailed(codecId, `value cannot be stored as a Decimal128 exactly: ${error instanceof Error ? error.message : String(error)}`, value);
-	}
-}
-function decimal128Decode(codecId, wire) {
-	if (!isDecimal128(wire)) return decodeFailed(codecId, "wire value must be a Decimal128", wire);
-	const text = canonicalDecimalText(wire.toString());
-	if (text === void 0) return decodeFailed(codecId, "wire value is not decimal text", wire);
-	return text;
-}
-function decimal128EncodeJson(codecId, value) {
-	return requireCanonicalDecimalText(codecId, value);
-}
-/**
-* The JSON form is what `encodeJson` writes, so it follows the encode rule: canonical decimal text (no exponent), or `NaN`, `Infinity` or `-Infinity`, that a Decimal128 holds exactly.
-*/
-function decimal128DecodeJson(codecId, json) {
-	const expected = "decimal text without an exponent that a Decimal128 holds exactly, or NaN, Infinity or -Infinity";
-	const text = decodeJsonMatching(codecId, json, CANONICAL_DECIMAL_TEXT, expected);
-	try {
-		Decimal128.fromString(text);
-	} catch {
-		return refuseJsonValue(codecId, expected, json);
-	}
-	return text;
-}
-function binaryEncode(codecId, value) {
-	if (!(value instanceof Uint8Array)) encodeFailed(codecId, "value must be a Uint8Array", value);
-	return new Binary(value);
-}
-/**
-* The driver reads binData as a `Binary`, or as a `Buffer` with `promoteBuffers: true`; either becomes a plain `Uint8Array` copy of the bytes.
-*/
-function binaryDecode(codecId, wire) {
-	if (wire instanceof Uint8Array) return new Uint8Array(wire);
-	if (!isBinary(wire)) return decodeFailed(codecId, "wire value must be a Binary or a Uint8Array", wire);
-	return new Uint8Array(wire.value());
-}
-function binaryEncodeJson(value) {
-	return Buffer.from(value).toString("base64");
-}
-function binaryDecodeJson(codecId, json) {
-	return new Uint8Array(Buffer.from(decodeJsonMatching(codecId, json, BASE64_TEXT, "base64 text"), "base64"));
-}
-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,
-	decode: (wire) => wire.toHexString(),
-	encode: (value) => objectIdEncode(MONGO_OBJECTID_CODEC_ID, value),
-	encodeJson: (value) => objectIdEncodeJson(MONGO_OBJECTID_CODEC_ID, value),
-	decodeJson: (json) => objectIdDecodeJson(MONGO_OBJECTID_CODEC_ID, json)
-});
-const mongoStringCodec = mongoCodec({
-	typeId: MONGO_STRING_CODEC_ID,
-	decode: (wire) => wire,
-	encode: (value) => stringEncode(MONGO_STRING_CODEC_ID, value),
-	decodeJson: (json) => decodeJsonString(MONGO_STRING_CODEC_ID, json)
-});
-const mongoDoubleCodec = mongoCodec({
-	typeId: MONGO_DOUBLE_CODEC_ID,
-	decode: (wire) => Number(wire),
-	encode: (value) => doubleEncode(MONGO_DOUBLE_CODEC_ID, value),
-	encodeJson: encodeJsonFloat,
-	decodeJson: (json) => decodeJsonFloat(MONGO_DOUBLE_CODEC_ID, json)
-});
-const mongoInt32Codec = mongoCodec({
-	typeId: MONGO_INT32_CODEC_ID,
-	decode: (wire) => wire,
-	encode: (value) => int32Encode(MONGO_INT32_CODEC_ID, value),
-	encodeJson: (value) => int32EncodeJson(MONGO_INT32_CODEC_ID, value),
-	decodeJson: (json) => int32DecodeJson(MONGO_INT32_CODEC_ID, json)
-});
-const mongoBooleanCodec = mongoCodec({
-	typeId: MONGO_BOOLEAN_CODEC_ID,
-	decode: (wire) => wire,
-	encode: (value) => booleanEncode(MONGO_BOOLEAN_CODEC_ID, value),
-	decodeJson: (json) => decodeJsonBoolean(MONGO_BOOLEAN_CODEC_ID, json)
-});
-const mongoDateCodec = mongoCodec({
-	typeId: MONGO_DATE_CODEC_ID,
-	decode: (wire) => wire,
-	encode: (value) => dateEncode(MONGO_DATE_CODEC_ID, value),
-	encodeJson: (value) => dateEncodeJson(MONGO_DATE_CODEC_ID, value),
-	decodeJson: (json) => dateDecodeJson(MONGO_DATE_CODEC_ID, json)
-});
-const mongoVectorCodec = mongoCodec({
-	typeId: MONGO_VECTOR_CODEC_ID,
-	decode: (wire) => wire,
-	encode: (value) => vectorEncode(MONGO_VECTOR_CODEC_ID, value),
-	decodeJson: (json) => vectorDecodeJson(MONGO_VECTOR_CODEC_ID, json)
-});
-/**
-* A BSON `long`. The application value is a `bigint`, because a `number` cannot hold the full 64-bit range; its JSON form is decimal text.
-*/
-const mongoInt64Codec = mongoCodec({
-	typeId: MONGO_INT64_CODEC_ID,
-	decode: (wire) => int64Decode(MONGO_INT64_CODEC_ID, wire),
-	encode: (value) => int64Encode(MONGO_INT64_CODEC_ID, value),
-	encodeJson: (value) => int64EncodeJson(MONGO_INT64_CODEC_ID, value),
-	decodeJson: (json) => int64DecodeJson(MONGO_INT64_CODEC_ID, json)
-});
-/**
-* 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,
-	decode: (wire) => int64NumberDecode(MONGO_INT64_NUMBER_CODEC_ID, wire),
-	encode: (value) => int64NumberEncode(MONGO_INT64_NUMBER_CODEC_ID, value),
-	encodeJson: (value) => int64NumberEncodeJson(MONGO_INT64_NUMBER_CODEC_ID, value),
-	decodeJson: (json) => int64NumberDecodeJson(MONGO_INT64_NUMBER_CODEC_ID, json)
-});
-/**
-* A BSON `decimal`. The application value and its JSON form are the same decimal text, written without an exponent.
-*/
-const mongoDecimal128Codec = mongoCodec({
-	typeId: MONGO_DECIMAL128_CODEC_ID,
-	decode: (wire) => decimal128Decode(MONGO_DECIMAL128_CODEC_ID, wire),
-	encode: (value) => decimal128Encode(MONGO_DECIMAL128_CODEC_ID, value),
-	encodeJson: (value) => decimal128EncodeJson(MONGO_DECIMAL128_CODEC_ID, value),
-	decodeJson: (json) => decimal128DecodeJson(MONGO_DECIMAL128_CODEC_ID, json)
-});
-/**
-* BSON `binData`. The application value is a `Uint8Array`; its JSON form is unwrapped base64.
-*/
-const mongoBinaryCodec = mongoCodec({
-	typeId: MONGO_BINARY_CODEC_ID,
-	decode: (wire) => binaryDecode(MONGO_BINARY_CODEC_ID, wire),
-	encode: (value) => binaryEncode(MONGO_BINARY_CODEC_ID, value),
-	encodeJson: binaryEncodeJson,
-	decodeJson: (json) => binaryDecodeJson(MONGO_BINARY_CODEC_ID, json)
-});
-/**
-* 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,
-	decode: (wire) => decodeJsonValue(wire),
-	encode: (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 JSON 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,
-	decode: (wire) => decodeBsonValue(wire),
-	encode: (value) => encodeBsonValue(value),
-	encodeJson: encodeBsonJson,
-	decodeJson: decodeBsonJson
-});
-/**
-* 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. 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 = blindCast(metadata.renderOutputType);
-	return {
-		codecId: codec.id,
-		dataType: metadata.dataType.id,
-		traits: metadata.traits,
-		paramsSchema: blindCast(metadata.dataType.params),
-		isParameterized: metadata.dataType.params !== void 0,
-		factory: blindCast(() => () => 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 mongoTargetError("RUNTIME.TYPE_PARAMS_INVALID", "renderOutputType: expected positive integer \"length\" for Vector", { meta: {
-		typeName: "Vector",
-		param: "length",
-		received: length
-	} });
-	return `Vector<${length}>`;
-};
-/**
-* Mongo wire-type codec descriptors. Static metadata for `traits` and `renderOutputType` lives here (the descriptor shape) — `MongoCodec` itself is narrow and only carries the four conversion methods (TML-2357).
-*/
-const mongoCodecDescriptors = [
-	descriptorFor(mongoObjectIdCodec, {
-		dataType: mongoObjectId,
-		traits: ["equality"]
-	}),
-	descriptorFor(mongoStringCodec, {
-		dataType: mongoString,
-		traits: [
-			"equality",
-			"order",
-			"textual"
-		],
-		renderValueLiteral: renderTsLiteral
-	}),
-	descriptorFor(mongoDoubleCodec, {
-		dataType: mongoDouble,
-		traits: [
-			"equality",
-			"order",
-			"numeric"
-		],
-		renderValueLiteral: (value) => typeof value === "number" ? String(value) : void 0
-	}),
-	descriptorFor(mongoInt32Codec, {
-		dataType: mongoInt32,
-		traits: [
-			"equality",
-			"order",
-			"numeric"
-		],
-		renderValueLiteral: renderTsLiteral
-	}),
-	descriptorFor(mongoBooleanCodec, {
-		dataType: mongoBool,
-		traits: ["equality", "boolean"],
-		renderValueLiteral: renderTsLiteral
-	}),
-	descriptorFor(mongoDateCodec, {
-		dataType: mongoDate,
-		traits: ["equality", "order"]
-	}),
-	descriptorFor(mongoVectorCodec, {
-		dataType: mongoVector,
-		traits: ["equality"],
-		renderOutputType: renderVectorOutputType
-	}),
-	descriptorFor(mongoInt64Codec, {
-		dataType: mongoInt64,
-		traits: [
-			"equality",
-			"order",
-			"numeric"
-		],
-		renderValueLiteral: decimalTextBigintLiteral
-	}),
-	descriptorFor(mongoInt64NumberCodec, {
-		dataType: mongoInt64,
-		traits: [
-			"equality",
-			"order",
-			"numeric"
-		],
-		renderValueLiteral: decimalTextNumberLiteral
-	}),
-	descriptorFor(mongoDecimal128Codec, {
-		dataType: mongoDecimal128,
-		traits: [
-			"equality",
-			"order",
-			"numeric"
-		]
-	}),
-	descriptorFor(mongoBinaryCodec, {
-		dataType: mongoBinary,
-		traits: ["equality"]
-	}),
-	descriptorFor(mongoJsonCodec, {
-		dataType: mongoJson,
-		traits: []
-	}),
-	descriptorFor(mongoBsonCodec, {
-		dataType: mongoBson,
-		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-D6yLMoD2-Bn8-UhA5.mjs.map