@prisma/orm-target-mongo 8.0.0-rc.12-dev.9 → 8.0.0-rc.12-dev.10

package/dist/{adapter__codec-types.d.mts → codec-types-KM2ikqd7.d.mts}

@@ -1,4 +1,5 @@
-//#region ../../../3-mongo-target/2-mongo-adapter/dist/codec-types.d.mts
+import { JsonValue } from "@prisma/orm-framework/contract/types";
+//#region ../../../3-mongo-target/1-mongo-target/dist/codec-types.d.mts
 //#region src/exports/codec-types.d.ts
 type Vector<N extends number = number> = readonly number[] & {
   readonly __vectorLength?: N;
@@ -32,7 +33,23 @@ type CodecTypes = {
     readonly input: readonly number[];
     readonly output: readonly number[];
   };
+  readonly 'mongo/int64@1': {
+    readonly input: bigint;
+    readonly output: bigint;
+  };
+  readonly 'mongo/decimal128@1': {
+    readonly input: string;
+    readonly output: string;
+  };
+  readonly 'mongo/binary@1': {
+    readonly input: Uint8Array;
+    readonly output: Uint8Array;
+  };
+  readonly 'mongo/json@1': {
+    readonly input: JsonValue;
+    readonly output: JsonValue;
+  };
 };
 //#endregion
-export { CodecTypes, Vector };
-//# sourceMappingURL=adapter__codec-types.d.mts.map
+export { Vector as n, CodecTypes as t };
+//# sourceMappingURL=codec-types-KM2ikqd7.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-KM2ikqd7.d.mts","names":[],"sources":["../../../../3-mongo-target/1-mongo-target/dist/codec-types.d.mts"],"mappings":";;;KAEK,OAAO;WACD,iBAAiB;;KAEvB;WACM;aACE;aACA;;WAEF;aACE;aACA;;WAEF;aACE;aACA;;WAEF;aACE;aACA;;WAEF;aACE;aACA;;WAEF;aACE,OAAO;aACP,QAAQ;;WAEV;aACE;aACA;;WAEF;aACE;aACA;;WAEF;aACE;aACA;;WAEF;aACE,OAAO;aACP,QAAQ;;WAEV;aACE,OAAO;aACP,QAAQ"}

package/dist/codecs-ChbLv6Rd-BmoC4ktF.mjs

@@ -0,0 +1,393 @@
+import { a as MONGO_DOUBLE_CODEC_ID, c as MONGO_JSON_CODEC_ID, d as MONGO_VECTOR_CODEC_ID, i as MONGO_DECIMAL128_CODEC_ID, l as MONGO_OBJECTID_CODEC_ID, n as MONGO_BOOLEAN_CODEC_ID, o as MONGO_INT32_CODEC_ID, r as MONGO_DATE_CODEC_ID, s as MONGO_INT64_CODEC_ID, t as MONGO_BINARY_CODEC_ID, u as MONGO_STRING_CODEC_ID } from "./codec-ids-Bz230VLx-Dbi_KV7J.mjs";
+import { a as mongoDecimal128, c as mongoInt64, d as mongoString, f as mongoVector, i as mongoDate, l as mongoJson, n as mongoBool, o as mongoDouble, s as mongoInt32, t as mongoBinary, u as mongoObjectId } from "./data-types-B2WnpO9e-D97kwz96.mjs";
+import { renderTsLiteral } from "@prisma/orm-framework/components/codec";
+import { mongoCodec, newMongoCodecRegistry } from "@prisma/orm-family-mongo/codec";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { Binary, Decimal128, Long, ObjectId } from "bson";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+//#region ../../../3-mongo-target/1-mongo-target/dist/codecs-ChbLv6Rd.mjs
+function mongoTargetError(code, message, options) {
+	return structuredError(code, message, options);
+}
+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)
+	} });
+}
+const INT64_MIN = -(2n ** 63n);
+const INT64_MAX = 2n ** 63n - 1n;
+/**
+* `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_MIN && value <= INT64_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));
+}
+/**
+* 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);
+	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) {
+	if (typeof json !== "string" || !DECIMAL_INTEGER.test(json)) return decodeFailed(codecId, "JSON value must be decimal integer text", json);
+	const value = BigInt(json);
+	if (!isInt64(value)) return decodeFailed(codecId, "JSON value is outside the signed 64-bit range", json);
+	return value;
+}
+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) {
+	if (typeof json !== "string" || !CANONICAL_DECIMAL_TEXT.test(json)) return decodeFailed(codecId, "JSON value must be decimal text without an exponent, or NaN, Infinity or -Infinity", json);
+	try {
+		Decimal128.fromString(json);
+	} catch {
+		return decodeFailed(codecId, "JSON value cannot be stored as a Decimal128 exactly", json);
+	}
+	return json;
+}
+function binaryEncode(codecId, value) {
+	if (!(value instanceof Uint8Array)) encodeFailed(codecId, "value must be a Uint8Array", value);
+	return new Binary(value);
+}
+function binaryDecode(codecId, wire) {
+	if (!isBinary(wire)) return decodeFailed(codecId, "wire value must be a Binary", wire);
+	return new Uint8Array(wire.value());
+}
+function binaryEncodeJson(value) {
+	return Buffer.from(value).toString("base64");
+}
+function binaryDecodeJson(codecId, json) {
+	if (typeof json !== "string" || !BASE64_TEXT.test(json)) return decodeFailed(codecId, "JSON value must be base64 text", json);
+	return new Uint8Array(Buffer.from(json, "base64"));
+}
+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 mongoTargetError("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
+});
+/**
+* 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 `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)
+});
+/**
+* Any JSON value, stored as the BSON document, array or scalar it maps to.
+*/
+const mongoJsonCodec = mongoCodec({
+	typeId: MONGO_JSON_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,
+	mongoInt64Codec,
+	mongoDecimal128Codec,
+	mongoBinaryCodec,
+	mongoJsonCodec
+];
+/**
+* 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,
+		dataType: metadata.dataType,
+		traits: metadata.traits,
+		targetTypes: metadata.targetTypes,
+		paramsSchema: void 0,
+		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 mongoTargetError("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, {
+		dataType: mongoObjectId.id,
+		traits: ["equality"],
+		targetTypes: ["objectId"]
+	}),
+	descriptorFor(mongoStringCodec, {
+		dataType: mongoString.id,
+		traits: [
+			"equality",
+			"order",
+			"textual"
+		],
+		targetTypes: ["string"],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoDoubleCodec, {
+		dataType: mongoDouble.id,
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		targetTypes: ["double"],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoInt32Codec, {
+		dataType: mongoInt32.id,
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		targetTypes: ["int"],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoBooleanCodec, {
+		dataType: mongoBool.id,
+		traits: ["equality", "boolean"],
+		targetTypes: ["bool"],
+		renderValueLiteral: renderTsLiteral
+	}),
+	descriptorFor(mongoDateCodec, {
+		dataType: mongoDate.id,
+		traits: ["equality", "order"],
+		targetTypes: ["date"]
+	}),
+	descriptorFor(mongoVectorCodec, {
+		dataType: mongoVector.id,
+		traits: ["equality"],
+		targetTypes: ["vector"],
+		renderOutputType: renderVectorOutputType
+	}),
+	descriptorFor(mongoInt64Codec, {
+		dataType: mongoInt64.id,
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		targetTypes: ["long"],
+		renderValueLiteral: decimalTextBigintLiteral
+	}),
+	descriptorFor(mongoDecimal128Codec, {
+		dataType: mongoDecimal128.id,
+		traits: [
+			"equality",
+			"order",
+			"numeric"
+		],
+		targetTypes: ["decimal"]
+	}),
+	descriptorFor(mongoBinaryCodec, {
+		dataType: mongoBinary.id,
+		traits: ["equality"],
+		targetTypes: ["binData"]
+	}),
+	descriptorFor(mongoJsonCodec, {
+		dataType: mongoJson.id,
+		traits: [],
+		targetTypes: []
+	})
+];
+/**
+* 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 { mongoTargetError as a, mongoStandardCodecs as i, mongoCodecDescriptors as n, mongoDescriptorById as r, buildStandardCodecRegistry as t };
+
+//# sourceMappingURL=codecs-ChbLv6Rd-BmoC4ktF.mjs.map

package/dist/codecs-ChbLv6Rd-BmoC4ktF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-ChbLv6Rd-BmoC4ktF.mjs","names":[],"sources":["../../../../3-mongo-target/1-mongo-target/dist/codecs-ChbLv6Rd.mjs"],"sourcesContent":["import { a as MONGO_DOUBLE_CODEC_ID, c as MONGO_JSON_CODEC_ID, d as MONGO_VECTOR_CODEC_ID, i as MONGO_DECIMAL128_CODEC_ID, l as MONGO_OBJECTID_CODEC_ID, n as MONGO_BOOLEAN_CODEC_ID, o as MONGO_INT32_CODEC_ID, r as MONGO_DATE_CODEC_ID, s as MONGO_INT64_CODEC_ID, t as MONGO_BINARY_CODEC_ID, u as MONGO_STRING_CODEC_ID } from \"./codec-ids-Bz230VLx.mjs\";\nimport { a as mongoDecimal128, c as mongoInt64, d as mongoString, f as mongoVector, i as mongoDate, l as mongoJson, n as mongoBool, o as mongoDouble, s as mongoInt32, t as mongoBinary, u as mongoObjectId } from \"./data-types-B2WnpO9e.mjs\";\nimport { renderTsLiteral } from \"@internal/framework-components/codec\";\nimport { mongoCodec, newMongoCodecRegistry } from \"@internal/mongo-codec\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { Binary, Decimal128, Long, ObjectId } from \"bson\";\nimport { structuredError } from \"@internal/utils/structured-error\";\n//#region src/core/mongo-target-errors.ts\nfunction mongoTargetError(code, message, options) {\n\treturn structuredError(code, message, options);\n}\n//#endregion\n//#region src/core/bson-scalar-helpers.ts\nconst DECIMAL_INTEGER = /^-?\\d+$/;\nconst CANONICAL_DECIMAL_TEXT = /^(?:-?\\d+(?:\\.\\d+)?|NaN|-?Infinity)$/;\nconst DECIMAL128_TEXT = /^(-?)(\\d+)(?:\\.(\\d+))?(?:E([+-]\\d+))?$/;\nconst BASE64_TEXT = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;\n/**\n* 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.\n*/\nfunction hasBsonTypeTag(value, tag) {\n\treturn typeof value === \"object\" && value !== null && \"_bsontype\" in value && value._bsontype === tag;\n}\nfunction isLong(value) {\n\treturn hasBsonTypeTag(value, \"Long\");\n}\nfunction isDecimal128(value) {\n\treturn hasBsonTypeTag(value, \"Decimal128\");\n}\nfunction isBinary(value) {\n\treturn hasBsonTypeTag(value, \"Binary\");\n}\nfunction decodeFailed(codecId, message, received) {\n\tthrow mongoTargetError(\"RUNTIME.DECODE_FAILED\", `${codecId} ${message}`, { meta: {\n\t\tcodecId,\n\t\treceived: typeof received\n\t} });\n}\nconst RECEIVED_PREVIEW_LIMIT = 100;\nfunction encodeFailed(codecId, message, received) {\n\tthrow mongoTargetError(\"RUNTIME.ENCODE_FAILED\", `${codecId} ${message}`, { meta: {\n\t\tcodecId,\n\t\treceived: String(received).slice(0, RECEIVED_PREVIEW_LIMIT)\n\t} });\n}\nconst INT64_MIN = -(2n ** 63n);\nconst INT64_MAX = 2n ** 63n - 1n;\n/**\n* `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.\n*/\nfunction isInt64(value) {\n\treturn value >= INT64_MIN && value <= INT64_MAX;\n}\nfunction requireInt64(codecId, value) {\n\tif (!isInt64(value)) encodeFailed(codecId, \"value is outside the signed 64-bit range\", value);\n\treturn value;\n}\nfunction int64Encode(codecId, value) {\n\tif (typeof value !== \"bigint\") encodeFailed(codecId, \"value must be a bigint\", value);\n\treturn Long.fromBigInt(requireInt64(codecId, value));\n}\n/**\n* 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.\n*/\nfunction int64Decode(codecId, wire) {\n\tif (typeof wire === \"bigint\") return wire;\n\tif (isLong(wire)) return wire.toBigInt();\n\tif (typeof wire === \"number\" && Number.isSafeInteger(wire)) return BigInt(wire);\n\treturn decodeFailed(codecId, \"wire value must be a Long or a safe integer\", wire);\n}\n/**\n* 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.\n*/\nfunction int64EncodeJson(codecId, value) {\n\tif (typeof value === \"bigint\") return requireInt64(codecId, value).toString();\n\tif (typeof value === \"number\" && Number.isSafeInteger(value)) return BigInt(value).toString();\n\treturn encodeFailed(codecId, \"value must be a bigint or a safe integer\", value);\n}\nfunction int64DecodeJson(codecId, json) {\n\tif (typeof json !== \"string\" || !DECIMAL_INTEGER.test(json)) return decodeFailed(codecId, \"JSON value must be decimal integer text\", json);\n\tconst value = BigInt(json);\n\tif (!isInt64(value)) return decodeFailed(codecId, \"JSON value is outside the signed 64-bit range\", json);\n\treturn value;\n}\nfunction decimalTextBigintLiteral(value) {\n\treturn typeof value === \"string\" && DECIMAL_INTEGER.test(value) ? `${value}n` : void 0;\n}\n/**\n* `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.\n*/\nfunction canonicalDecimalText(text) {\n\tif (text === \"NaN\" || text === \"Infinity\" || text === \"-Infinity\") return text;\n\tconst match = DECIMAL128_TEXT.exec(text);\n\tif (match === null) return void 0;\n\tconst [, sign = \"\", whole = \"\", fraction = \"\", exponent = \"0\"] = match;\n\tconst digits = `${whole}${fraction}`;\n\tconst point = whole.length + Number(exponent);\n\tlet integerPart;\n\tlet fractionPart;\n\tif (point <= 0) {\n\t\tintegerPart = \"0\";\n\t\tfractionPart = `${\"0\".repeat(-point)}${digits}`;\n\t} else if (point >= digits.length) {\n\t\tintegerPart = `${digits}${\"0\".repeat(point - digits.length)}`;\n\t\tfractionPart = \"\";\n\t} else {\n\t\tintegerPart = digits.slice(0, point);\n\t\tfractionPart = digits.slice(point);\n\t}\n\tconst trimmedInteger = integerPart.replace(/^0+(?=\\d)/, \"\");\n\tconst unsigned = fractionPart === \"\" ? trimmedInteger : `${trimmedInteger}.${fractionPart}`;\n\treturn /^[0.]+$/.test(unsigned) ? unsigned : `${sign}${unsigned}`;\n}\nfunction requireCanonicalDecimalText(codecId, value) {\n\tif (typeof value !== \"string\" || !CANONICAL_DECIMAL_TEXT.test(value)) encodeFailed(codecId, \"value must be decimal text without an exponent, or NaN, Infinity or -Infinity\", value);\n\treturn value;\n}\nfunction decimal128Encode(codecId, value) {\n\trequireCanonicalDecimalText(codecId, value);\n\ttry {\n\t\treturn Decimal128.fromString(value);\n\t} catch (error) {\n\t\treturn encodeFailed(codecId, `value cannot be stored as a Decimal128 exactly: ${error instanceof Error ? error.message : String(error)}`, value);\n\t}\n}\nfunction decimal128Decode(codecId, wire) {\n\tif (!isDecimal128(wire)) return decodeFailed(codecId, \"wire value must be a Decimal128\", wire);\n\tconst text = canonicalDecimalText(wire.toString());\n\tif (text === void 0) return decodeFailed(codecId, \"wire value is not decimal text\", wire);\n\treturn text;\n}\nfunction decimal128EncodeJson(codecId, value) {\n\treturn requireCanonicalDecimalText(codecId, value);\n}\n/**\n* 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.\n*/\nfunction decimal128DecodeJson(codecId, json) {\n\tif (typeof json !== \"string\" || !CANONICAL_DECIMAL_TEXT.test(json)) return decodeFailed(codecId, \"JSON value must be decimal text without an exponent, or NaN, Infinity or -Infinity\", json);\n\ttry {\n\t\tDecimal128.fromString(json);\n\t} catch {\n\t\treturn decodeFailed(codecId, \"JSON value cannot be stored as a Decimal128 exactly\", json);\n\t}\n\treturn json;\n}\nfunction binaryEncode(codecId, value) {\n\tif (!(value instanceof Uint8Array)) encodeFailed(codecId, \"value must be a Uint8Array\", value);\n\treturn new Binary(value);\n}\nfunction binaryDecode(codecId, wire) {\n\tif (!isBinary(wire)) return decodeFailed(codecId, \"wire value must be a Binary\", wire);\n\treturn new Uint8Array(wire.value());\n}\nfunction binaryEncodeJson(value) {\n\treturn Buffer.from(value).toString(\"base64\");\n}\nfunction binaryDecodeJson(codecId, json) {\n\tif (typeof json !== \"string\" || !BASE64_TEXT.test(json)) return decodeFailed(codecId, \"JSON value must be base64 text\", json);\n\treturn new Uint8Array(Buffer.from(json, \"base64\"));\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 mongoTargetError(\"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* 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.\n*/\nconst mongoInt64Codec = mongoCodec({\n\ttypeId: MONGO_INT64_CODEC_ID,\n\tdecode: (wire) => int64Decode(MONGO_INT64_CODEC_ID, wire),\n\tencode: (value) => int64Encode(MONGO_INT64_CODEC_ID, value),\n\tencodeJson: (value) => int64EncodeJson(MONGO_INT64_CODEC_ID, value),\n\tdecodeJson: (json) => int64DecodeJson(MONGO_INT64_CODEC_ID, json)\n});\n/**\n* A BSON `decimal`. The application value and its JSON form are the same decimal text, written without an exponent.\n*/\nconst mongoDecimal128Codec = mongoCodec({\n\ttypeId: MONGO_DECIMAL128_CODEC_ID,\n\tdecode: (wire) => decimal128Decode(MONGO_DECIMAL128_CODEC_ID, wire),\n\tencode: (value) => decimal128Encode(MONGO_DECIMAL128_CODEC_ID, value),\n\tencodeJson: (value) => decimal128EncodeJson(MONGO_DECIMAL128_CODEC_ID, value),\n\tdecodeJson: (json) => decimal128DecodeJson(MONGO_DECIMAL128_CODEC_ID, json)\n});\n/**\n* BSON `binData`. The application value is a `Uint8Array`; its JSON form is unwrapped base64.\n*/\nconst mongoBinaryCodec = mongoCodec({\n\ttypeId: MONGO_BINARY_CODEC_ID,\n\tdecode: (wire) => binaryDecode(MONGO_BINARY_CODEC_ID, wire),\n\tencode: (value) => binaryEncode(MONGO_BINARY_CODEC_ID, value),\n\tencodeJson: binaryEncodeJson,\n\tdecodeJson: (json) => binaryDecodeJson(MONGO_BINARY_CODEC_ID, json)\n});\n/**\n* Any JSON value, stored as the BSON document, array or scalar it maps to.\n*/\nconst mongoJsonCodec = mongoCodec({\n\ttypeId: MONGO_JSON_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\tmongoInt64Codec,\n\tmongoDecimal128Codec,\n\tmongoBinaryCodec,\n\tmongoJsonCodec\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\tdataType: metadata.dataType,\n\t\ttraits: metadata.traits,\n\t\ttargetTypes: metadata.targetTypes,\n\t\tparamsSchema: void 0,\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 mongoTargetError(\"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\tdataType: mongoObjectId.id,\n\t\ttraits: [\"equality\"],\n\t\ttargetTypes: [\"objectId\"]\n\t}),\n\tdescriptorFor(mongoStringCodec, {\n\t\tdataType: mongoString.id,\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\tdataType: mongoDouble.id,\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\tdataType: mongoInt32.id,\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\tdataType: mongoBool.id,\n\t\ttraits: [\"equality\", \"boolean\"],\n\t\ttargetTypes: [\"bool\"],\n\t\trenderValueLiteral: renderTsLiteral\n\t}),\n\tdescriptorFor(mongoDateCodec, {\n\t\tdataType: mongoDate.id,\n\t\ttraits: [\"equality\", \"order\"],\n\t\ttargetTypes: [\"date\"]\n\t}),\n\tdescriptorFor(mongoVectorCodec, {\n\t\tdataType: mongoVector.id,\n\t\ttraits: [\"equality\"],\n\t\ttargetTypes: [\"vector\"],\n\t\trenderOutputType: renderVectorOutputType\n\t}),\n\tdescriptorFor(mongoInt64Codec, {\n\t\tdataType: mongoInt64.id,\n\t\ttraits: [\n\t\t\t\"equality\",\n\t\t\t\"order\",\n\t\t\t\"numeric\"\n\t\t],\n\t\ttargetTypes: [\"long\"],\n\t\trenderValueLiteral: decimalTextBigintLiteral\n\t}),\n\tdescriptorFor(mongoDecimal128Codec, {\n\t\tdataType: mongoDecimal128.id,\n\t\ttraits: [\n\t\t\t\"equality\",\n\t\t\t\"order\",\n\t\t\t\"numeric\"\n\t\t],\n\t\ttargetTypes: [\"decimal\"]\n\t}),\n\tdescriptorFor(mongoBinaryCodec, {\n\t\tdataType: mongoBinary.id,\n\t\ttraits: [\"equality\"],\n\t\ttargetTypes: [\"binData\"]\n\t}),\n\tdescriptorFor(mongoJsonCodec, {\n\t\tdataType: mongoJson.id,\n\t\ttraits: [],\n\t\ttargetTypes: []\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 { mongoTargetError as a, mongoStandardCodecs as i, mongoCodecDescriptors as n, mongoDescriptorById as r, buildStandardCodecRegistry as t };\n\n//# sourceMappingURL=codecs-ChbLv6Rd.mjs.map"],"mappings":"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"}

package/dist/codecs-DsyGq31F.d.mts

@@ -0,0 +1,33 @@
+import { CodecDescriptor } from "@prisma/orm-framework/components/codec";
+import { MongoCodec, MongoCodecRegistry } from "@prisma/orm-family-mongo/codec";
+import { Binary, Decimal128, Long, ObjectId } from "bson";
+import { JsonValue } from "@prisma/orm-framework/contract/types";
+//#region ../../../3-mongo-target/1-mongo-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>, MongoCodec<"mongo/string@1", readonly [], string, string>, MongoCodec<"mongo/double@1", readonly [], number, number>, MongoCodec<"mongo/int32@1", readonly [], number, number>, MongoCodec<"mongo/bool@1", readonly [], boolean, boolean>, MongoCodec<"mongo/date@1", readonly [], Date, Date>, MongoCodec<"mongo/vector@1", readonly [], readonly number[], readonly number[]>, MongoCodec<"mongo/int64@1", readonly [], number | bigint | Long, bigint>, MongoCodec<"mongo/decimal128@1", readonly [], Decimal128, string>, MongoCodec<"mongo/binary@1", readonly [], Binary, 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>];
+/**
+ * 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).
+ */
+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-DsyGq31F.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-DsyGq31F.d.mts","names":[],"sources":["../../../../3-mongo-target/1-mongo-target/dist/codecs.d.mts"],"mappings":";;;;;;;;;;;cAUc,+BAA+B,4CAA4C,mBAAmB,2DAA2D,2DAA2D,0DAA0D,2DAA2D,wCAAwC,MAAM,OAAO,iFAAiF,2DAA2D,eAAe,8CAA8C,qBAAqB,0CAA0C,QAAQ,WAAW,mBAAmB;YAC9qB,cAAc;aACb;YACD,cAAc;aACb;;;;cAIC,uBAAuB,cAAc;;;;iBAIlC,oBAAoB,kBAAkB;;;;;;iBAMtC,8BAA8B"}