@prisma/orm-target-mongo 8.0.0-rc.19-dev.7 → 8.0.0-rc.19-dev.9

package/dist/{data-types-BS2Wy4k-.d.mts → data-types-BUXk_WEa.d.mts}

@@ -1,23 +1,25 @@
-import { DataType } from "@prisma/orm-framework/components/codec";
+import { DataType, DataTypeId } from "@prisma/orm-framework/components/codec";
 //#region ../../../3-mongo-target/1-mongo-target/dist/data-types.d.mts
 //#region src/core/data-types.d.ts
 /** The vector's dimension: the TypeScript type `Vector<n>` and the type's reader read it. */
 declare const mongoVectorParams: import("arktype/internal/variants/object.ts").ObjectType<{
   length?: number;
 }, {}>;
-declare const mongoObjectId: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
 declare const mongoString: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
-declare const mongoDouble: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
 declare const mongoInt32: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoInt64: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoDecimal128: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoDouble: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoObjectId: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
 declare const mongoBool: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
 declare const mongoDate: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
 declare const mongoVector: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
-declare const mongoInt64: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
-declare const mongoDecimal128: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
 declare const mongoBinary: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
 declare const mongoJson: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
 declare const mongoBson: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
 declare const mongoDataTypes: readonly DataType[];
+/** MongoDB's text data type: `string`. */
+declare const mongoTextDataTypes: readonly DataTypeId[];
 //#endregion
-export { mongoDate as a, mongoInt32 as c, mongoObjectId as d, mongoString as f, mongoDataTypes as i, mongoInt64 as l, mongoVectorParams as m, mongoBool as n, mongoDecimal128 as o, mongoVector as p, mongoBson as r, mongoDouble as s, mongoBinary as t, mongoJson as u };
-//# sourceMappingURL=data-types-BS2Wy4k-.d.mts.map
+export { mongoDate as a, mongoInt32 as c, mongoObjectId as d, mongoString as f, mongoVectorParams as h, mongoDataTypes as i, mongoInt64 as l, mongoVector as m, mongoBool as n, mongoDecimal128 as o, mongoTextDataTypes as p, mongoBson as r, mongoDouble as s, mongoBinary as t, mongoJson as u };
+//# sourceMappingURL=data-types-BUXk_WEa.d.mts.map

package/dist/data-types-BUXk_WEa.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-types-BUXk_WEa.d.mts","names":[],"sources":["../../../../3-mongo-target/1-mongo-target/dist/data-types.d.mts"],"mappings":";;;;cAGc,iEAAiE;EAC7E;;cAEY,0DAA0D;cAC1D,yDAAyD;cACzD,yDAAyD;cACzD,8DAA8D;cAC9D,0DAA0D;cAC1D,4DAA4D;cAC5D,wDAAwD;cACxD,wDAAwD;cACxD,0DAA0D;cAC1D,0DAA0D;cAC1D,wDAAwD;cACxD,wDAAwD;cACxD,yBAAyB;;cAEzB,6BAA6B"}

package/dist/{data-types-BUNJnoE9-S7P2K-7r.mjs → data-types-hoKLBrYZ-CkFtgHfm.mjs}

@@ -1,180 +1,14 @@
 import { r as MONGO_BSON_CODEC_ID } from "./codec-ids-WdrumsYA-BkQfspmL.mjs";
 import { t as mongoTargetError } from "./mongo-target-errors-Btf3ML1w-B5EMYbz1.mjs";
-import { INT32_RANGE, INT64_RANGE, SAFE_INTEGER_BIGINT_RANGE, SAFE_INTEGER_RANGE, decimalTextEqualityKey, isIntegerIn, readJsonBoolean, readJsonFloat, readJsonInteger, readJsonIntegerText, readJsonMatching, readJsonString, refuseJsonValue } from "@prisma/orm-framework/components/codec";
-import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { isDeepStrictEqual } from "node:util";
-import { Binary, Code, Decimal128, Double, EJSON, Long, MinKey, ObjectId } from "bson";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { INT32_RANGE, INT64_RANGE, SAFE_INTEGER_BIGINT_RANGE, SAFE_INTEGER_RANGE, asFloat, asNumeralText, castUnchanged, decimalTextEqualityKey, isIntegerIn, readJsonBoolean, readJsonFloat, readJsonInteger, readJsonIntegerText, readJsonMatching, readJsonString, refuseJsonValue, refuseWrongShape } from "@prisma/orm-framework/components/codec";
 import { counted } from "@prisma/orm-framework/utils/text";
+import { Binary, Code, Decimal128, Double, EJSON, Long, MinKey, ObjectId } from "bson";
 import { mongoDataType } from "@prisma/orm-family-mongo/contract/data-type";
 import { type } from "arktype";
-//#region ../../../3-mongo-target/1-mongo-target/dist/data-types-BUNJnoE9.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 = { DBRef: "Write it as a { $ref, $id } document instead." };
-function encodeRefused(received, path) {
-	const fix = ENCODE_FIX_BY_RECEIVED[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(typeof value, path);
-		return;
-	}
-	const tag = bsonTypeTag(value);
-	if (tag !== void 0) {
-		if (!BSON_VALUE_TAGS.has(tag)) encodeRefused(tag, path);
-		if (!createdByBsonMajor(value)) encodeRefused(`${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(constructorName(value), path);
-		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));
-		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(entries) {
-	return Object.fromEntries(entries.map(([key, entry]) => [key, decodeValue(entry)]));
-}
-function decodeValue(value) {
-	if (typeof value !== "object" || value === null) return value;
-	if (bsonClassTag(value) === "DBRef") return decodeEntries(dbRefEntries(value));
-	if (Array.isArray(value)) {
-		const decoded = value.map(decodeValue);
-		return decoded.some((entry, index) => entry !== value[index]) ? decoded : value;
-	}
-	const code = codeWithScope(value);
-	if (code !== void 0) {
-		const scope = decodeValue(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(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(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 bsonToJson(value) {
-	return blindCast(EJSON.serialize(asDriverWrites(value), { relaxed: false }));
-}
-/**
-* Reads the canonical Extended JSON `bsonToJson` 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, naming `owner`.
-*/
-function readBsonJson(owner, json) {
-	let value;
-	try {
-		value = EJSON.deserialize(blindCast(json), { relaxed: false });
-	} catch {
-		return refuseJsonValue(owner, "canonical Extended JSON", json);
-	}
-	if (!isDeepStrictEqual(EJSON.serialize(value, { relaxed: false }), json)) return refuseJsonValue(owner, "canonical Extended JSON", json);
-	return value;
-}
+import { isDeepStrictEqual } from "node:util";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+//#region ../../../3-mongo-target/1-mongo-target/dist/data-types-hoKLBrYZ.mjs
 const STORED_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}=)?$/;
@@ -274,6 +108,10 @@ function objectIdToJson(codecId, value) {
 	if (typeof value !== "string" || !OBJECT_ID_TEXT.test(value)) encodeFailed(codecId, "value must be 24 hexadecimal digits", value);
 	return value;
 }
+/** Whether `text` is an ObjectId's 24 hexadecimal digits, in either case. */
+function isObjectIdText(text) {
+	return OBJECT_ID_TEXT.test(text);
+}
 /** Reads ObjectId hex in either case; {@link spellObjectIdJson} writes the lower case the type stores. */
 function readObjectIdJson(owner, json) {
 	return readJsonMatching(owner, json, OBJECT_ID_TEXT, "24 hexadecimal digits");
@@ -308,6 +146,7 @@ function readVectorJson(owner, json, length) {
 	const numbers = [];
 	for (const element of json) {
 		if (typeof element !== "number") return refuseJsonValue(owner, expected, element);
+		if (!Number.isFinite(element)) return refuseJsonValue(owner, "an array of finite numbers", json);
 		numbers.push(element);
 	}
 	return numbers;
@@ -427,18 +266,34 @@ function decimal128Decode(codecId, wire) {
 function decimal128ToJson(codecId, value) {
 	return requireStoredDecimalText(codecId, value);
 }
+/** Decimal text without its leading zeros, as MongoDB writes it; the sign of zero and trailing zeros stay. */
+function decimalTextWithoutLeadingZeros(text) {
+	return text.replace(/^(-?)0+(?=\d)/, "$1");
+}
+function withoutSignOfZero(text) {
+	return /^-[0.]+$/.test(text) ? text.slice(1) : text;
+}
+/** Whether a Decimal128 holds the decimal text exactly: the text it writes back is the same number, digit for digit. */
+function decimal128HoldsExactly(text) {
+	let written;
+	try {
+		written = Decimal128.fromString(text).toString();
+	} catch {
+		return false;
+	}
+	return decimalTextWithoutExponent(written) === withoutSignOfZero(decimalTextWithoutLeadingZeros(text));
+}
 /**
-* The stored form is what the codec writes, so it follows the encode rule: decimal text without an exponent, or `NaN`, `Infinity` or `-Infinity`, that a Decimal128 holds exactly.
+* The stored form is what the codec writes, so it follows the encode rule: decimal text without an exponent, or `NaN`, `Infinity` or `-Infinity`, that a Decimal128 holds exactly. A value a Decimal128 would round is refused.
 */
 function readDecimal128Json(owner, json) {
 	const expected = "decimal text without an exponent that a Decimal128 holds exactly, or NaN, Infinity or -Infinity";
 	const text = readJsonMatching(owner, json, STORED_DECIMAL_TEXT, expected);
-	try {
-		Decimal128.fromString(text);
-	} catch {
-		return refuseJsonValue(owner, expected, json);
-	}
-	return text;
+	return decimal128HoldsExactly(text) ? text : refuseJsonValue(owner, expected, json);
+}
+/** The decimal text without leading zeros, as MongoDB writes it, keeping negative zero. */
+function spellDecimal128Json(json) {
+	return typeof json === "string" ? decimalTextWithoutLeadingZeros(json) : json;
 }
 function binaryEncode(codecId, value) {
 	if (!(value instanceof Uint8Array)) encodeFailed(codecId, "value must be a Uint8Array", value);
@@ -455,6 +310,10 @@ function binaryDecode(codecId, wire) {
 function binaryToBase64(value) {
 	return Buffer.from(value).toString("base64");
 }
+/** Whether `text` is base64, with or without padding bits set. */
+function isBase64Text(text) {
+	return BASE64_TEXT.test(text);
+}
 /** Reads base64 with or without padding bits set; {@link spellBase64Json} writes the base64 the type stores. */
 function readBinaryJson(owner, json) {
 	return readJsonMatching(owner, json, BASE64_TEXT, "base64 text");
@@ -466,27 +325,235 @@ function spellBase64Json(json) {
 function binaryFromBase64(base64) {
 	return new Uint8Array(Buffer.from(base64, "base64"));
 }
+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 = { DBRef: "Write it as a { $ref, $id } document instead." };
+function encodeRefused(received, path) {
+	const fix = ENCODE_FIX_BY_RECEIVED[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(typeof value, path);
+		return;
+	}
+	const tag = bsonTypeTag(value);
+	if (tag !== void 0) {
+		if (!BSON_VALUE_TAGS.has(tag)) encodeRefused(tag, path);
+		if (!createdByBsonMajor(value)) encodeRefused(`${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(constructorName(value), path);
+		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));
+		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(entries) {
+	return Object.fromEntries(entries.map(([key, entry]) => [key, decodeValue(entry)]));
+}
+function decodeValue(value) {
+	if (typeof value !== "object" || value === null) return value;
+	if (bsonClassTag(value) === "DBRef") return decodeEntries(dbRefEntries(value));
+	if (Array.isArray(value)) {
+		const decoded = value.map(decodeValue);
+		return decoded.some((entry, index) => entry !== value[index]) ? decoded : value;
+	}
+	const code = codeWithScope(value);
+	if (code !== void 0) {
+		const scope = decodeValue(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(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(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 bsonToJson(value) {
+	return blindCast(EJSON.serialize(asDriverWrites(value), { relaxed: false }));
+}
+/**
+* Reads the canonical Extended JSON `bsonToJson` 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, naming `owner`.
+*/
+function readBsonJson(owner, json) {
+	let value;
+	try {
+		value = EJSON.deserialize(blindCast(json), { relaxed: false });
+	} catch {
+		return refuseJsonValue(owner, "canonical Extended JSON", json);
+	}
+	if (!isDeepStrictEqual(EJSON.serialize(value, { relaxed: false }), json)) return refuseJsonValue(owner, "canonical Extended JSON", json);
+	return value;
+}
 /** The vector's dimension: the TypeScript type `Vector<n>` and the type's reader read it. */
 const mongoVectorParams = type({ "length?": "number.integer >= 1" });
-const mongoObjectId = mongoDataType("mongo/objectid", {
-	read: (json) => readObjectIdJson("mongo/objectid", json),
-	spell: spellObjectIdJson,
-	bsonTypes: ["objectId"]
-});
+/** Text as the ObjectId it names; {@link spellObjectIdJson} gives it the lower case the type stores. */
+const asObjectId = (value) => {
+	if (typeof value !== "string") return refuseWrongShape(value, "text");
+	if (isObjectIdText(value)) return value;
+	throw structuredError("CONTRACT.CAST_REFUSED", `"${value}" is not an ObjectId: write 24 hexadecimal digits.`, {
+		why: "An ObjectId is 12 bytes, written as 24 hexadecimal digits.",
+		fix: "Write the ObjectId as 24 hexadecimal digits, as in \"507f1f77bcf86cd799439011\"."
+	});
+};
+/** The numbers of a written list as a vector stores them, each finite. */
+function vectorElements(elements) {
+	return elements.map((element, index) => {
+		const number = Number(element);
+		if (Number.isFinite(number)) return number;
+		throw structuredError("CONTRACT.CAST_REFUSED", `a vector element is a finite number, and element ${index + 1} is ${String(element)}.`, {
+			why: "A vector holds finite numbers, as a vector search index reads them.",
+			fix: "Write each element as a finite number."
+		});
+	});
+}
 const mongoString = mongoDataType("mongo/string", {
 	read: (json) => readJsonString("mongo/string", json),
 	bsonTypes: ["string"]
 });
+const mongoInt32 = mongoDataType("mongo/int32", {
+	read: (json) => readInt32Json("mongo/int32", json),
+	bsonTypes: ["int"]
+});
+const mongoInt64 = mongoDataType("mongo/int64", {
+	read: (json) => readInt64Json("mongo/int64", json),
+	bsonTypes: ["long"],
+	casts: { [mongoInt32.id]: asNumeralText }
+});
+const mongoDecimal128 = mongoDataType("mongo/decimal128", {
+	read: (json) => readDecimal128Json("mongo/decimal128", json),
+	spell: spellDecimal128Json,
+	equalityKey: decimalTextEqualityKey,
+	bsonTypes: ["decimal"],
+	casts: {
+		[mongoInt32.id]: asNumeralText,
+		[mongoInt64.id]: castUnchanged
+	}
+});
 const mongoDouble = mongoDataType("mongo/double", {
 	read: (json) => {
 		readJsonFloat("mongo/double", json);
 		return json;
 	},
-	bsonTypes: ["double"]
+	bsonTypes: ["double"],
+	casts: {
+		[mongoInt32.id]: asFloat,
+		[mongoInt64.id]: asFloat,
+		[mongoDecimal128.id]: asFloat
+	}
 });
-const mongoInt32 = mongoDataType("mongo/int32", {
-	read: (json) => readInt32Json("mongo/int32", json),
-	bsonTypes: ["int"]
+const mongoObjectId = mongoDataType("mongo/objectid", {
+	read: (json) => readObjectIdJson("mongo/objectid", json),
+	spell: spellObjectIdJson,
+	bsonTypes: ["objectId"],
+	casts: { [mongoString.id]: asObjectId }
 });
 const mongoBool = mongoDataType("mongo/bool", {
 	read: (json) => readJsonBoolean("mongo/bool", json),
@@ -499,16 +566,16 @@ const mongoDate = mongoDataType("mongo/date", {
 const mongoVector = mongoDataType("mongo/vector", {
 	read: (json, params) => readVectorJson("mongo/vector", json, typeof params["length"] === "number" ? params["length"] : void 0),
 	bsonTypes: ["array"],
-	params: mongoVectorParams
-});
-const mongoInt64 = mongoDataType("mongo/int64", {
-	read: (json) => readInt64Json("mongo/int64", json),
-	bsonTypes: ["long"]
-});
-const mongoDecimal128 = mongoDataType("mongo/decimal128", {
-	read: (json) => readDecimal128Json("mongo/decimal128", json),
-	equalityKey: decimalTextEqualityKey,
-	bsonTypes: ["decimal"]
+	params: mongoVectorParams,
+	listCast: {
+		of: [
+			mongoInt32.id,
+			mongoInt64.id,
+			mongoDecimal128.id,
+			mongoDouble.id
+		],
+		cast: vectorElements
+	}
 });
 const mongoBinary = mongoDataType("mongo/binary", {
 	read: (json) => readBinaryJson("mongo/binary", json),
@@ -549,7 +616,9 @@ const mongoDataTypes = [
 	mongoJson,
 	mongoBson
 ];
+/** MongoDB's text data type: `string`. */
+const mongoTextDataTypes = [mongoString.id];
 //#endregion
-export { isPlainObject as A, mongoJson as B, int64Encode as C, int64NumberToJson as D, int64NumberFromDigits as E, mongoDate as F, objectIdEncode as G, mongoString as H, mongoDecimal128 as I, stringEncode as J, objectIdToJson as K, mongoDouble as L, mongoBool as M, mongoBson as N, int64ToJson as O, mongoDataTypes as P, mongoInt32 as R, int64Decode as S, int64NumberEncode as T, mongoVector as U, mongoObjectId as V, mongoVectorParams as W, where as X, vectorEncode as Y, decodeBsonValue as _, booleanEncode as a, int32Encode as b, bsonTypeTag as c, dateEncode as d, dateToJson as f, decimal128ToJson as g, decimal128Encode as h, binaryToBase64 as i, mongoBinary as j, isPlainArray as k, child as l, decimal128Decode as m, binaryEncode as n, bsonClassTag as o, dbRefEntries as p, readBsonJson as q, binaryFromBase64 as r, bsonToJson as s, binaryDecode as t, constructorName as u, doubleEncode as v, int64NumberDecode as w, int32ToJson as x, encodeBsonValue as y, mongoInt64 as z };
+export { where as $, isBase64Text as A, mongoInt32 as B, int64Decode as C, int64NumberFromDigits as D, int64NumberEncode as E, mongoBson as F, mongoTextDataTypes as G, mongoJson as H, mongoDataTypes as I, objectIdEncode as J, mongoVector as K, mongoDate as L, isPlainObject as M, mongoBinary as N, int64NumberToJson as O, mongoBool as P, vectorEncode as Q, mongoDecimal128 as R, int32ToJson as S, int64NumberDecode as T, mongoObjectId as U, mongoInt64 as V, mongoString as W, readBsonJson as X, objectIdToJson as Y, stringEncode as Z, decimal128ToJson as _, booleanEncode as a, encodeBsonValue as b, bsonTypeTag as c, dateEncode as d, dateToJson as f, decimal128HoldsExactly as g, decimal128Encode as h, binaryToBase64 as i, isPlainArray as j, int64ToJson as k, child as l, decimal128Decode as m, binaryEncode as n, bsonClassTag as o, dbRefEntries as p, mongoVectorParams as q, binaryFromBase64 as r, bsonToJson as s, binaryDecode as t, constructorName as u, decodeBsonValue as v, int64Encode as w, int32Encode as x, doubleEncode as y, mongoDouble as z };
 
-//# sourceMappingURL=data-types-BUNJnoE9-S7P2K-7r.mjs.map
+//# sourceMappingURL=data-types-hoKLBrYZ-CkFtgHfm.mjs.map