@prisma/orm-target-postgres 8.0.0-rc.14-dev.6 → 8.0.0-rc.14-dev.8

package/dist/{codecs-DQGmsnk3-H6nVRPCC.mjs → codecs-BHNqtI1J-BSS9sL3H.mjs}

@@ -1,14 +1,17 @@
 import { A as PG_TIME_TEMPORAL_CODEC_ID, C as PG_TIMESTAMPTZ_DATE_CODEC_ID, D as PG_TIMESTAMP_TEMPORAL_CODEC_ID, E as PG_TIMESTAMP_STRING_CODEC_ID, F as PG_VARCHAR_CODEC_ID, M as PG_UNBOUNDED_INT_CODEC_ID, N as PG_UUID_CODEC_ID, O as PG_TIMETZ_CODEC_ID, P as PG_VARBIT_CODEC_ID, S as PG_TEXT_CODEC_ID, T as PG_TIMESTAMPTZ_TEMPORAL_CODEC_ID, _ as PG_INT_CODEC_ID, a as PG_DATE_STRING_CODEC_ID, b as PG_NUMERIC_CODEC_ID, c as PG_FLOAT4_CODEC_ID, d as PG_INET_CODEC_ID, f as PG_INT2_CODEC_ID, g as PG_INTERVAL_CODEC_ID, h as PG_INT8_NUMBER_CODEC_ID, i as PG_CHAR_CODEC_ID, j as PG_TSQUERY_CODEC_ID, k as PG_TIME_STRING_CODEC_ID, l as PG_FLOAT8_CODEC_ID, m as PG_INT8_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_DATE_TEMPORAL_CODEC_ID, p as PG_INT4_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_ENUM_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_FLOAT_CODEC_ID, v as PG_JSONB_CODEC_ID, w as PG_TIMESTAMPTZ_STRING_CODEC_ID, x as PG_TEXT_ARRAY_CODEC_ID, y as PG_JSON_CODEC_ID } from "./codec-ids-Cb0yO-IS--e0P2rfI.mjs";
-import { a as postgresCodec, r as definePostgresCodecs, t as PostgresCodecDescriptor } from "./codec-descriptor-BfoHQP3R-CMRVT-F6.mjs";
+import { a as postgresCodec, r as definePostgresCodecs, t as PostgresCodecDescriptor } from "./codec-descriptor-B61d-k4C-BdWVU6Fu.mjs";
 import { a as errorTemporalUnrepresentable, i as errorTemporalUnavailableForDefault, n as errorTemporalNonIsoCalendar, o as errorTemporalWrongType, r as errorTemporalUnavailable, s as postgresError } from "./errors-DYyzTYzE-39CV_aMo.mjs";
-import { $ as pgTsquery, A as pgIntervalDecode, B as pgNumeric, C as pgInt8, D as pgInt8NumberEncode, E as pgInt8NumberDecodeJson, F as pgJsonDecode, G as pgTime, H as pgNumericRenderOutputType, I as pgJsonEncode, J as pgTimestampCanonical, K as pgTimeCanonical, L as pgJsonb, M as pgIntervalEncodeJson, N as pgIntervalToIso, O as pgInt8NumberEncodeJson, P as pgJson, Q as pgTimetzCanonical, R as pgJsonbDecode, S as pgInt4, T as pgInt8NumberDecode, U as pgText, V as pgNumericDecode, W as pgTextArray, X as pgTimestamptzCanonical, Y as pgTimestamptz, Z as pgTimetz, _ as pgFloatDecodeJson, a as pgBit, at as precisionParamsSchema, b as pgInet, c as pgByteaDecodeJson, d as pgChar, et as pgUnboundedIntDecode, f as pgDate, g as pgFloat8, h as pgFloat4, i as pgBigintEncodeJson, j as pgIntervalDecodeJson, k as pgInterval, l as pgByteaDecodeWire, m as pgEnum, n as decimalTextNumberLiteral, nt as pgVarbit, o as pgBool, ot as renderLength, p as pgDateCanonical, q as pgTimestamp, r as pgBigintEncode, rt as pgVarchar, s as pgBytea, st as renderPrecision, t as decimalTextBigintLiteral, tt as pgUuid, u as pgByteaEncodeJson, v as pgFloatEncode, w as pgInt8Decode, x as pgInt2, y as pgFloatEncodeJson, z as pgJsonbEncode } from "./data-types-Cl18KnNY-5I34Vd6Z.mjs";
+import { A as pgUnboundedIntDecode, C as pgIntervalToIso, D as pgJsonbEncode, E as pgJsonbDecode, M as renderLength, N as renderPrecision, O as pgNumericDecode, S as pgIntervalEncodeJson, T as pgJsonEncode, _ as pgInt8NumberEncode, a as decimalTextNumberLiteral, b as pgIntervalDecode, c as pgBigintEncode, d as pgByteaDecodeWire, f as pgByteaEncodeJson, g as pgInt8NumberDecodeJson, h as pgInt8NumberDecode, i as decimalTextBigintLiteral, j as precisionParamsSchema, k as pgNumericRenderOutputType, l as pgBigintEncodeJson, m as pgInt8Decode, n as FLOAT4_MAX, o as fitsCharacterLength, p as pgFloatEncode, r as canonicalUuid, s as fitsFloat4, t as CANONICAL_UUID, u as pgByteaDecodeJson, v as pgInt8NumberEncodeJson, w as pgJsonDecode, x as pgIntervalDecodeJson } from "./codec-helpers-D83-1eDB-nqAEMr7N.mjs";
+import { A as pgVarbit, C as pgTimestampCanonical, D as pgTimetzCanonical, E as pgTimetz, O as pgTsquery, S as pgTimestamp, T as pgTimestamptzCanonical, _ as pgNumeric, a as pgDate, b as pgTime, c as pgFloat4, d as pgInt2, f as pgInt4, g as pgJsonb, h as pgJson, i as pgChar, j as pgVarchar, k as pgUuid, l as pgFloat8, m as pgInterval, n as pgBool, o as pgDateCanonical, p as pgInt8, r as pgBytea, s as pgEnum, t as pgBit, u as pgInet, v as pgText, w as pgTimestamptz, x as pgTimeCanonical, y as pgTextArray } from "./data-types-BqeC7aZP-CwvA08pH.mjs";
 import { t as PostgresNativeEnum } from "./postgres-native-enum-CdP3b_-R-Cgz9KEKx.mjs";
-import { BinaryExpr, CaseExpr, CastExpr, FunctionCallExpr, LiteralExpr, NullCheckExpr, OrExpr, SqlCharCodec, SqlFloatCodec, SqlIntCodec, SqlVarcharCodec, sqlCharDescriptor, sqlFloatDescriptor, sqlIntDescriptor, sqlTextDescriptor, sqlVarcharDescriptor } from "@prisma/orm-family-sql/relational-core/ast";
-import { CodecImpl, column, renderTsLiteral } from "@prisma/orm-framework/components/codec";
+import { BinaryExpr, CaseExpr, CastExpr, FunctionCallExpr, LiteralExpr, NullCheckExpr, OrExpr, SqlCharCodec, SqlFloatCodec, SqlIntCodec, SqlVarcharCodec, canonicalDateTime, sqlCharDescriptor, sqlFloatDescriptor, sqlIntDescriptor, sqlTextDescriptor, sqlVarcharDescriptor } from "@prisma/orm-family-sql/relational-core/ast";
+import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { CodecImpl, INT32_RANGE, INT64_RANGE, column, decodeJsonBoolean, decodeJsonFloat, decodeJsonInteger, decodeJsonIntegerText, decodeJsonMatching, decodeJsonString, encodeJsonFloat, refuseJsonValue, renderTsLiteral } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { counted, withoutTrailing } from "@prisma/orm-framework/utils/text";
 import { type } from "arktype";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
-//#region ../../../3-targets/3-targets/postgres/dist/codecs-DQGmsnk3.mjs
+//#region ../../../3-targets/3-targets/postgres/dist/codecs-BHNqtI1J.mjs
 let fallback;
 /**
 * Sets the implementation `requireTemporal` returns when the runtime has no global `Temporal`.
@@ -115,13 +118,22 @@ const MIN_TIMESTAMPTZ_MILLISECONDS = (/* @__PURE__ */ new Date("-004713-11-24T00
 function invalidDate() {
 	return /* @__PURE__ */ new RangeError(`${PG_TIMESTAMPTZ_DATE_CODEC_ID} requires a valid Date or a representable ISO PostgreSQL timestamp with time zone; use TimestamptzString for unsupported values`);
 }
+function isRepresentable(value) {
+	return value instanceof Date && Number.isFinite(value.getTime()) && value.getTime() >= MIN_TIMESTAMPTZ_MILLISECONDS;
+}
 function validateDate(value) {
-	if (!(value instanceof Date) || !Number.isFinite(value.getTime()) || value.getTime() < MIN_TIMESTAMPTZ_MILLISECONDS) throw invalidDate();
+	if (!isRepresentable(value)) throw invalidDate();
 	return value;
 }
 function decodeDate(wire) {
-	const match = typeof wire === "string" ? TIMESTAMPTZ_TEXT.exec(wire) : null;
-	if (!match) throw invalidDate();
+	const date = typeof wire === "string" ? parseDate(wire) : void 0;
+	if (date === void 0) throw invalidDate();
+	return date;
+}
+/** The instant a timestamp with time zone as PostgreSQL writes it names, or `undefined` when the text is not one. */
+function parseDate(text) {
+	const match = TIMESTAMPTZ_TEXT.exec(text);
+	if (!match) return void 0;
 	const [, yearText = "", monthText, dayText, hourText, minuteText, secondText, fraction = "", sign, offsetHour = "0", offsetMinute = "0", offsetSecond = "0", era] = match;
 	const year = era ? 1 - Number(yearText) : Number(yearText);
 	const month = Number(monthText) - 1;
@@ -135,9 +147,10 @@ function decodeDate(wire) {
 	const local = /* @__PURE__ */ new Date(0);
 	local.setUTCFullYear(safeYear, month, day);
 	local.setUTCHours(hour, minute, second, milliseconds);
-	if (era !== void 0 && (Number(yearText) === 0 || /^[+-]/.test(yearText)) || local.getUTCFullYear() !== safeYear || local.getUTCMonth() !== month || local.getUTCDate() !== day || local.getUTCHours() !== hour || local.getUTCMinutes() !== minute || local.getUTCSeconds() !== second || Number(offsetHour) > 15 || Number(offsetMinute) > 59 || Number(offsetSecond) > 59) throw invalidDate();
+	if (era !== void 0 && (Number(yearText) === 0 || /^[+-]/.test(yearText)) || local.getUTCFullYear() !== safeYear || local.getUTCMonth() !== month || local.getUTCDate() !== day || local.getUTCHours() !== hour || local.getUTCMinutes() !== minute || local.getUTCSeconds() !== second || Number(offsetHour) > 15 || Number(offsetMinute) > 59 || Number(offsetSecond) > 59) return void 0;
 	const offset = (Number(offsetHour) * 3600 + Number(offsetMinute) * 60 + Number(offsetSecond)) * (sign === "-" ? -1 : 1);
-	return validateDate(/* @__PURE__ */ new Date(local.getTime() - offset * 1e3 + cycles * 146097 * 864e5));
+	const value = /* @__PURE__ */ new Date(local.getTime() - offset * 1e3 + cycles * 146097 * 864e5);
+	return isRepresentable(value) ? value : void 0;
 }
 function encodeDate(value) {
 	validateDate(value);
@@ -158,7 +171,7 @@ var PgTimestamptzDateCodec = class extends CodecImpl {
 		return pgTimestamptzCanonical(validateDate(value).toISOString());
 	}
 	decodeJson(json) {
-		return decodeDate(json);
+		return parseDate(decodeJsonString("pg/timestamptz-date@1", json)) ?? refuseJsonValue("pg/timestamptz-date@1", "a timestamp with time zone as PostgreSQL writes it", json);
 	}
 };
 var PgTimestamptzDateDescriptor = class extends PostgresCodecDescriptor {
@@ -182,6 +195,108 @@ var PgTimestamptzDateDescriptor = class extends PostgresCodecDescriptor {
 };
 const pgTimestamptzDateDescriptor = new PgTimestamptzDateDescriptor();
 const pgTimestamptzDateColumn = (params = {}) => column(pgTimestamptzDateDescriptor.factory(params), pgTimestamptzDateDescriptor.codecId, params, "timestamptz");
+const YEAR = String.raw`(?:[+-]\d{6}|\d{4,7})`;
+const DATE = String.raw`${YEAR}-\d{2}-\d{2}`;
+const TIME = String.raw`\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?`;
+const OFFSET = String.raw`(?:Z|[+-]\d{2}(?::\d{2}(?::\d{2})?)?)`;
+const INFINITY = "infinity|-infinity|";
+const BC = "(?: BC)?";
+const FORMS = {
+	date: `${DATE}${BC}`,
+	time: TIME,
+	timeWithOffset: `${TIME}${OFFSET}`,
+	dateTime: `${DATE}[ T]${TIME}${BC}`,
+	instant: `${DATE}[ T]${TIME}${OFFSET}${BC}`
+};
+const DATED = /^([+-]?)(\d{4,7})(-.*?)( BC)?$/;
+const END_OF_DAY = /^24:00:00(?:\.0+)?(?![.\d])/;
+/** PostgreSQL's largest UTC offset, which it writes for no type past 15:59:59. */
+const MAX_OFFSET_HOURS = 15;
+function storedText(options) {
+	return {
+		dataTypeId: options.dataTypeId,
+		shape: options.shape,
+		pattern: new RegExp(`^(?:${options.infinity ? INFINITY : ""}${FORMS[options.shape]})$`),
+		description: `${options.description} in ISO 8601 or as PostgreSQL writes it`,
+		endOfDay: options.endOfDay
+	};
+}
+const pgDateStoredText = storedText({
+	dataTypeId: pgDate.id,
+	shape: "date",
+	description: "a date",
+	infinity: true,
+	endOfDay: false
+});
+const pgTimeStoredText = storedText({
+	dataTypeId: pgTime.id,
+	shape: "time",
+	description: "a time of day",
+	infinity: false,
+	endOfDay: true
+});
+const pgTimetzStoredText = storedText({
+	dataTypeId: pgTimetz.id,
+	shape: "timeWithOffset",
+	description: "a time of day with a UTC offset",
+	infinity: false,
+	endOfDay: true
+});
+const pgTimestampStoredText = storedText({
+	dataTypeId: pgTimestamp.id,
+	shape: "dateTime",
+	description: "a date and time of day",
+	infinity: true,
+	endOfDay: false
+});
+const pgTimestamptzStoredText = storedText({
+	dataTypeId: pgTimestamptz.id,
+	shape: "instant",
+	description: "a date and time of day with a UTC offset",
+	infinity: true,
+	endOfDay: false
+});
+/** The text with its year moved into the 400-year cycle from 2000, or `undefined` for a year no calendar has. */
+function inGregorianCycle(text) {
+	const match = DATED.exec(text);
+	if (match === null) return text;
+	const [, sign = "", digits = "", rest = "", bc] = match;
+	const year = Number(digits);
+	if (bc !== void 0 && (sign !== "" || year === 0) || sign === "-" && year === 0) return;
+	return `${2e3 + ((bc !== void 0 ? 1 - year : sign === "-" ? -year : year) % 400 + 400) % 400}${rest}`;
+}
+function holdsValue(stored, text) {
+	if (text === "infinity" || text === "-infinity") return true;
+	const cycled = inGregorianCycle(text);
+	if (cycled === void 0) return false;
+	const read = stored.endOfDay ? cycled.replace(END_OF_DAY, "00:00:00") : cycled;
+	try {
+		canonicalDateTime(read, {
+			shape: stored.shape,
+			dataTypeId: stored.dataTypeId,
+			maxOffsetHours: MAX_OFFSET_HOURS
+		});
+		return true;
+	} catch (error) {
+		if (isStructuredError(error) && error.code === "CONTRACT.CAST_REFUSED") return false;
+		throw error;
+	}
+}
+/** Reads a stored date or time text, refusing text in another form or naming no real date and time. */
+function decodeJsonDateTimeText(codecId, json, stored) {
+	const text = decodeJsonMatching(codecId, json, stored.pattern, stored.description);
+	return holdsValue(stored, text) ? text : refuseJsonValue(codecId, stored.description, json);
+}
+/** The precision a `numeric` column takes. */
+const NUMERIC_PRECISION_RANGE = {
+	min: 1,
+	max: 1e3
+};
+/** The scale a `numeric` column takes in PostgreSQL 15 and later, including a negative one and one above the precision. */
+const NUMERIC_SCALE_RANGE = {
+	min: -1e3,
+	max: 1e3
+};
 var PgDateTemporalCodec = class extends CodecImpl {
 	async encode(value, _ctx) {
 		return pgDateTemporalEncode(value);
@@ -193,7 +308,7 @@ var PgDateTemporalCodec = class extends CodecImpl {
 		return pgDateCanonical(pgDateTemporalEncode(value));
 	}
 	decodeJson(json) {
-		return pgDateTemporalDecode(blindCast(json));
+		return pgDateTemporalDecode(decodeJsonString(PG_DATE_TEMPORAL_CODEC_ID, json));
 	}
 };
 var PgDateTemporalDescriptor = class extends PostgresCodecDescriptor {
@@ -224,7 +339,7 @@ var PgTimestampTemporalCodec = class extends CodecImpl {
 		return pgTimestampCanonical(pgTimestampTemporalEncode(value));
 	}
 	decodeJson(json) {
-		return pgTimestampTemporalDecode(blindCast(json));
+		return pgTimestampTemporalDecode(decodeJsonString(PG_TIMESTAMP_TEMPORAL_CODEC_ID, json));
 	}
 };
 var PgTimestampTemporalDescriptor = class extends PostgresCodecDescriptor {
@@ -255,7 +370,7 @@ var PgTimestamptzTemporalCodec = class extends CodecImpl {
 		return pgTimestamptzCanonical(pgTimestamptzTemporalEncode(value));
 	}
 	decodeJson(json) {
-		return pgTimestamptzTemporalDecode(blindCast(json));
+		return pgTimestamptzTemporalDecode(decodeJsonString(PG_TIMESTAMPTZ_TEMPORAL_CODEC_ID, json));
 	}
 };
 var PgTimestamptzTemporalDescriptor = class extends PostgresCodecDescriptor {
@@ -286,7 +401,7 @@ var PgTimeTemporalCodec = class extends CodecImpl {
 		return pgTimeCanonical(pgTimeTemporalEncode(value));
 	}
 	decodeJson(json) {
-		return pgTimeTemporalDecode(blindCast(json));
+		return pgTimeTemporalDecode(decodeJsonString(PG_TIME_TEMPORAL_CODEC_ID, json));
 	}
 };
 var PgTimeTemporalDescriptor = class extends PostgresCodecDescriptor {
@@ -317,7 +432,7 @@ var PgDateStringCodec = class extends CodecImpl {
 		return pgDateCanonical(value);
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonDateTimeText(PG_DATE_STRING_CODEC_ID, json, pgDateStoredText);
 	}
 };
 var PgDateStringDescriptor = class extends PostgresCodecDescriptor {
@@ -348,7 +463,7 @@ var PgTimestampStringCodec = class extends CodecImpl {
 		return pgTimestampCanonical(value);
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonDateTimeText(PG_TIMESTAMP_STRING_CODEC_ID, json, pgTimestampStoredText);
 	}
 };
 var PgTimestampStringDescriptor = class extends PostgresCodecDescriptor {
@@ -382,7 +497,7 @@ var PgTimestamptzStringCodec = class extends CodecImpl {
 		return pgTimestamptzCanonical(value);
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonDateTimeText(PG_TIMESTAMPTZ_STRING_CODEC_ID, json, pgTimestamptzStoredText);
 	}
 };
 var PgTimestamptzStringDescriptor = class extends PostgresCodecDescriptor {
@@ -416,7 +531,7 @@ var PgTimeStringCodec = class extends CodecImpl {
 		return pgTimeCanonical(value);
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonDateTimeText(PG_TIME_STRING_CODEC_ID, json, pgTimeStoredText);
 	}
 };
 var PgTimeStringDescriptor = class extends PostgresCodecDescriptor {
@@ -441,8 +556,8 @@ var PgTimeStringDescriptor = class extends PostgresCodecDescriptor {
 const pgTimeStringDescriptor = new PgTimeStringDescriptor();
 const lengthParamsSchema = type({ "length?": "number.integer > 0" });
 const numericParamsSchema = type({
-	"precision?": "number.integer > 0 & number.integer <= 1000",
-	"scale?": "number.integer >= 0"
+	"precision?": type("number.integer").atLeast(NUMERIC_PRECISION_RANGE.min).atMost(NUMERIC_PRECISION_RANGE.max),
+	"scale?": type("number.integer").atLeast(NUMERIC_SCALE_RANGE.min).atMost(NUMERIC_SCALE_RANGE.max)
 });
 const PG_TEXT_NATIVE_TYPE = "text";
 const PG_TEXT_ARRAY_NATIVE_TYPE = "text[]";
@@ -486,7 +601,28 @@ const PG_JSONB_NATIVE_TYPE = "jsonb";
 */
 const CANONICAL_NUMERIC_TEXT = /^(?:-?\d+(?:\.\d+)?|NaN|-?Infinity)$/;
 const isCanonicalNumericText = (value) => CANONICAL_NUMERIC_TEXT.test(value);
+/**
+* Whether canonical numeric text is a value `numeric(precision, scale)` stores without rounding: a whole number of units of 10^-scale, and at most `precision` digits once counted in those units. A negative scale rounds to tens, hundreds and so on, and a scale above the precision allows only values below 1. NaN fits; an infinity does not.
+*/
+function fitsNumeric(text, precision, scale) {
+	if (text === "NaN") return true;
+	if (text.endsWith("Infinity")) return false;
+	const [whole = "", fraction = ""] = text.replace(/^-/, "").split(".");
+	const significantFraction = withoutTrailing(fraction, "0");
+	const digits = `${whole}${significantFraction}`.replace(/^0+/, "");
+	if (digits === "") return true;
+	const shift = scale - significantFraction.length;
+	if (shift >= 0) return digits.length + shift <= precision;
+	const units = withoutTrailing(digits, "0");
+	if (digits.length - units.length < -shift) return false;
+	return digits.length + shift <= precision;
+}
 const identityJsonProjection = (expression) => expression;
+/**
+* Projects a `character` value as text, which drops the trailing spaces that pad it to its length and nothing else, so an include reads the value a flat read's `decode` returns.
+*/
+const unpaddedCharJsonProjection = (expression) => CastExpr.as(expression, "text");
+const BIT_STRING = /^[01]*$/;
 const decodePostgresNumberWire = (wire) => typeof wire === "string" ? Number(wire) : wire;
 const decodePostgresBooleanWire = (wire) => {
 	if (typeof wire === "boolean") return wire;
@@ -579,17 +715,20 @@ const isoDurationJsonProjection = (expression) => {
 const postgresSqlCharDescriptor = postgresCodec(sqlCharDescriptor, {
 	dataType: pgChar.id,
 	nativeType: () => "character",
-	jsonProjection: identityJsonProjection
+	jsonProjection: unpaddedCharJsonProjection,
+	factory: (descriptor, params) => () => new PgCharCodec(descriptor, params.length)
 });
 const postgresSqlVarcharDescriptor = postgresCodec(sqlVarcharDescriptor, {
 	dataType: pgVarchar.id,
 	nativeType: () => "character varying",
-	jsonProjection: identityJsonProjection
+	jsonProjection: identityJsonProjection,
+	factory: (descriptor, params) => () => new PgVarcharCodec(descriptor, params.length)
 });
 const postgresSqlIntDescriptor = postgresCodec(sqlIntDescriptor, {
 	dataType: pgInt4.id,
 	nativeType: () => "int4",
-	jsonProjection: identityJsonProjection
+	jsonProjection: identityJsonProjection,
+	factory: (descriptor) => () => new PgIntCodec(descriptor)
 });
 const postgresSqlFloatDescriptor = postgresCodec(sqlFloatDescriptor, {
 	dataType: pgFloat8.id,
@@ -612,7 +751,7 @@ var PgTextCodec = class extends CodecImpl {
 		return value;
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonString(PG_TEXT_CODEC_ID, json);
 	}
 };
 var PgTextDescriptor = class extends PostgresCodecDescriptor {
@@ -670,7 +809,7 @@ var PgEnumCodec = class extends CodecImpl {
 		return value;
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonString(PG_ENUM_CODEC_ID, json);
 	}
 };
 /**
@@ -779,8 +918,16 @@ var PgTextArrayCodec = class extends CodecImpl {
 	encodeJson(value) {
 		return [...value];
 	}
+	/** A `text[]` may hold NULL elements, which PostgreSQL writes as JSON `null`. */
 	decodeJson(json) {
-		return Array.isArray(json) ? json.map((entry) => String(entry)) : [];
+		const expected = "an array of strings and nulls";
+		if (!Array.isArray(json)) return refuseJsonValue(PG_TEXT_ARRAY_CODEC_ID, expected, json);
+		const elements = [];
+		for (const entry of json) {
+			if (entry !== null && typeof entry !== "string") return refuseJsonValue(PG_TEXT_ARRAY_CODEC_ID, expected, entry);
+			elements.push(entry);
+		}
+		return elements;
 	}
 };
 var PgTextArrayDescriptor = class extends PostgresCodecDescriptor {
@@ -811,7 +958,7 @@ var PgInt4Codec = class extends CodecImpl {
 		return value;
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonInteger(PG_INT4_CODEC_ID, json, INT32_RANGE);
 	}
 };
 var PgInt4Descriptor = class extends PostgresCodecDescriptor {
@@ -850,7 +997,10 @@ var PgInt2Codec = class extends CodecImpl {
 		return value;
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonInteger(PG_INT2_CODEC_ID, json, {
+			min: -32768,
+			max: 32767
+		});
 	}
 };
 var PgInt2Descriptor = class extends PostgresCodecDescriptor {
@@ -895,11 +1045,7 @@ var PgInt8Codec = class extends CodecImpl {
 		return pgBigintEncodeJson(PG_INT8_CODEC_ID, value);
 	}
 	decodeJson(json) {
-		if (typeof json !== "string") throw postgresError("RUNTIME.DECODE_FAILED", "pg/int8@1 database JSON value must be a decimal string", { meta: {
-			codecId: PG_INT8_CODEC_ID,
-			received: typeof json
-		} });
-		return pgInt8Decode(json);
+		return decodeJsonIntegerText(PG_INT8_CODEC_ID, json, INT64_RANGE);
 	}
 };
 var PgInt8Descriptor = class extends PostgresCodecDescriptor {
@@ -982,10 +1128,12 @@ var PgFloat4Codec = class extends CodecImpl {
 		return decodePostgresNumberWire(wire);
 	}
 	encodeJson(value) {
-		return pgFloatEncodeJson(value);
+		return encodeJsonFloat(value);
 	}
 	decodeJson(json) {
-		return pgFloatDecodeJson(PG_FLOAT4_CODEC_ID, json);
+		const value = decodeJsonFloat(PG_FLOAT4_CODEC_ID, json);
+		if (Number.isFinite(value) && !fitsFloat4(value)) return refuseJsonValue(PG_FLOAT4_CODEC_ID, `a number float4 holds, at most ${FLOAT4_MAX} in magnitude and not so small that it becomes 0, or the text NaN, Infinity or -Infinity`, json);
+		return value;
 	}
 };
 var PgFloat4Descriptor = class extends PostgresCodecDescriptor {
@@ -1021,10 +1169,10 @@ var PgFloat8Codec = class extends CodecImpl {
 		return decodePostgresNumberWire(wire);
 	}
 	encodeJson(value) {
-		return pgFloatEncodeJson(value);
+		return encodeJsonFloat(value);
 	}
 	decodeJson(json) {
-		return pgFloatDecodeJson(PG_FLOAT8_CODEC_ID, json);
+		return decodeJsonFloat(PG_FLOAT8_CODEC_ID, json);
 	}
 };
 var PgFloat8Descriptor = class extends PostgresCodecDescriptor {
@@ -1063,7 +1211,7 @@ var PgBoolCodec = class extends CodecImpl {
 		return value;
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonBoolean(PG_BOOL_CODEC_ID, json);
 	}
 };
 var PgBoolDescriptor = class extends PostgresCodecDescriptor {
@@ -1088,6 +1236,7 @@ var PgBoolDescriptor = class extends PostgresCodecDescriptor {
 const pgBoolDescriptor = new PgBoolDescriptor();
 const pgBoolColumn = () => column(pgBoolDescriptor.factory(), pgBoolDescriptor.codecId, void 0, "bool");
 var PgNumericCodec = class extends CodecImpl {
+	params;
 	async encode(value, _ctx) {
 		return value;
 	}
@@ -1101,12 +1250,17 @@ var PgNumericCodec = class extends CodecImpl {
 		} });
 		return value;
 	}
+	constructor(descriptor, params) {
+		super(descriptor);
+		this.params = params;
+	}
 	decodeJson(json) {
-		if (typeof json !== "string") throw postgresError("RUNTIME.DECODE_FAILED", "pg/numeric@1 database JSON value must be a decimal string", { meta: {
-			codecId: PG_NUMERIC_CODEC_ID,
-			received: typeof json
-		} });
-		return json;
+		const text = decodeJsonMatching(PG_NUMERIC_CODEC_ID, json, CANONICAL_NUMERIC_TEXT, "a decimal string");
+		const { precision } = this.params;
+		if (precision === void 0) return text;
+		const scale = this.params.scale ?? 0;
+		if (!fitsNumeric(text, precision, scale)) return refuseJsonValue(PG_NUMERIC_CODEC_ID, `a decimal string that numeric(${precision}, ${scale}) stores without rounding`, json);
+		return text;
 	}
 };
 var PgNumericDescriptor = class extends PostgresCodecDescriptor {
@@ -1128,8 +1282,8 @@ var PgNumericDescriptor = class extends PostgresCodecDescriptor {
 	renderOutputType(params) {
 		return pgNumericRenderOutputType(params);
 	}
-	factory(_params) {
-		return () => new PgNumericCodec(this);
+	factory(params) {
+		return () => new PgNumericCodec(this, params ?? {});
 	}
 };
 const pgNumericDescriptor = new PgNumericDescriptor();
@@ -1151,11 +1305,7 @@ var PgUnboundedIntCodec = class extends CodecImpl {
 		return pgBigintEncodeJson(PG_UNBOUNDED_INT_CODEC_ID, value);
 	}
 	decodeJson(json) {
-		if (typeof json !== "string") throw postgresError("RUNTIME.DECODE_FAILED", "pg/unboundedint@1 database JSON value must be a decimal string", { meta: {
-			codecId: PG_UNBOUNDED_INT_CODEC_ID,
-			received: typeof json
-		} });
-		return pgUnboundedIntDecode(json);
+		return decodeJsonIntegerText(PG_UNBOUNDED_INT_CODEC_ID, json);
 	}
 };
 var PgUnboundedIntDescriptor = class extends PostgresCodecDescriptor {
@@ -1194,7 +1344,7 @@ var PgTimetzCodec = class extends CodecImpl {
 		return pgTimetzCanonical(value);
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonDateTimeText(PG_TIMETZ_CODEC_ID, json, pgTimetzStoredText);
 	}
 };
 var PgTimetzDescriptor = class extends PostgresCodecDescriptor {
@@ -1219,6 +1369,7 @@ var PgTimetzDescriptor = class extends PostgresCodecDescriptor {
 const pgTimetzDescriptor = new PgTimetzDescriptor();
 const pgTimetzColumn = (params = {}) => column(pgTimetzDescriptor.factory(params), pgTimetzDescriptor.codecId, params, "timetz");
 var PgBitCodec = class extends CodecImpl {
+	length;
 	async encode(value, _ctx) {
 		return value;
 	}
@@ -1228,8 +1379,14 @@ var PgBitCodec = class extends CodecImpl {
 	encodeJson(value) {
 		return value;
 	}
+	constructor(descriptor, length) {
+		super(descriptor);
+		this.length = length;
+	}
 	decodeJson(json) {
-		return blindCast(json);
+		const bits = decodeJsonMatching(PG_BIT_CODEC_ID, json, BIT_STRING, "a string of 0 and 1 digits");
+		if (bits.length !== this.length) return refuseJsonValue(PG_BIT_CODEC_ID, `a string of exactly ${counted(this.length, "bit")}`, json);
+		return bits;
 	}
 };
 var PgBitDescriptor = class extends PostgresCodecDescriptor {
@@ -1247,13 +1404,14 @@ var PgBitDescriptor = class extends PostgresCodecDescriptor {
 	renderOutputType(params) {
 		return renderLength("Bit", params);
 	}
-	factory(_params) {
-		return () => new PgBitCodec(this);
+	factory(params) {
+		return () => new PgBitCodec(this, params?.length ?? 1);
 	}
 };
 const pgBitDescriptor = new PgBitDescriptor();
 const pgBitColumn = (params = {}) => column(pgBitDescriptor.factory(params), pgBitDescriptor.codecId, params, "bit");
 var PgVarbitCodec = class extends CodecImpl {
+	length;
 	async encode(value, _ctx) {
 		return value;
 	}
@@ -1263,8 +1421,14 @@ var PgVarbitCodec = class extends CodecImpl {
 	encodeJson(value) {
 		return value;
 	}
+	constructor(descriptor, length) {
+		super(descriptor);
+		this.length = length;
+	}
 	decodeJson(json) {
-		return blindCast(json);
+		const bits = decodeJsonMatching(PG_VARBIT_CODEC_ID, json, BIT_STRING, "a string of 0 and 1 digits");
+		if (this.length !== void 0 && bits.length > this.length) return refuseJsonValue(PG_VARBIT_CODEC_ID, `a string of at most ${counted(this.length, "bit")}`, json);
+		return bits;
 	}
 };
 var PgVarbitDescriptor = class extends PostgresCodecDescriptor {
@@ -1282,8 +1446,8 @@ var PgVarbitDescriptor = class extends PostgresCodecDescriptor {
 	renderOutputType(params) {
 		return renderLength("VarBit", params);
 	}
-	factory(_params) {
-		return () => new PgVarbitCodec(this);
+	factory(params) {
+		return () => new PgVarbitCodec(this, params?.length);
 	}
 };
 const pgVarbitDescriptor = new PgVarbitDescriptor();
@@ -1328,10 +1492,10 @@ var PgUuidCodec = class extends CodecImpl {
 		return wire;
 	}
 	encodeJson(value) {
-		return value;
+		return canonicalUuid(value) ?? value;
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonMatching(PG_UUID_CODEC_ID, json, CANONICAL_UUID, "a UUID as PostgreSQL writes it, in lower case and hyphenated 8-4-4-4-12");
 	}
 };
 var PgUuidDescriptor = class extends PostgresCodecDescriptor {
@@ -1364,7 +1528,7 @@ var PgInetCodec = class extends CodecImpl {
 		return value;
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return decodeJsonString(PG_INET_CODEC_ID, json);
 	}
 };
 var PgInetDescriptor = class extends PostgresCodecDescriptor {
@@ -1397,7 +1561,7 @@ var PgTsqueryCodec = class extends CodecImpl {
 		return value;
 	}
 	decodeJson(json) {
-		return blindCast(json);
+		return blindCast(decodeJsonString(PG_TSQUERY_CODEC_ID, json));
 	}
 };
 /**
@@ -1547,6 +1711,36 @@ var PgIntCodec = class extends SqlIntCodec {
 	async decode(wire, _ctx) {
 		return decodePostgresNumberWire(wire);
 	}
+	decodeJson(json) {
+		return decodeJsonInteger(this.id, json, INT32_RANGE);
+	}
+};
+/**
+* `sql/char@1` as PostgreSQL stores it: a `character` column holds its length in characters, and one with no length is `character(1)`.
+*/
+var PgCharCodec = class extends SqlCharCodec {
+	length;
+	constructor(descriptor, length) {
+		super(descriptor);
+		this.length = length ?? 1;
+	}
+	decodeJson(json) {
+		if (!fitsCharacterLength(decodeJsonString(this.id, json), this.length, true)) return refuseJsonValue(this.id, `a string of at most ${counted(this.length, "character")} before any trailing spaces`, json);
+		return super.decodeJson(json);
+	}
+};
+/** `sql/varchar@1` as PostgreSQL stores it: a `character varying` column with a length holds at most that many characters. */
+var PgVarcharCodec = class extends SqlVarcharCodec {
+	length;
+	constructor(descriptor, length) {
+		super(descriptor);
+		this.length = length;
+	}
+	decodeJson(json) {
+		const text = super.decodeJson(json);
+		if (this.length !== void 0 && !fitsCharacterLength(text, this.length, false)) return refuseJsonValue(this.id, `a string of at most ${counted(this.length, "character")}`, json);
+		return text;
+	}
 };
 var PgFloatCodec = class extends SqlFloatCodec {
 	async decode(wire, _ctx) {
@@ -1558,7 +1752,7 @@ var PgCharDescriptor = class extends PostgresCodecDescriptor {
 		return PG_CHAR_NATIVE_TYPE;
 	}
 	jsonProjection(expression) {
-		return expression;
+		return unpaddedCharJsonProjection(expression);
 	}
 	dataType = pgChar.id;
 	codecId = PG_CHAR_CODEC_ID;
@@ -1571,8 +1765,8 @@ var PgCharDescriptor = class extends PostgresCodecDescriptor {
 	renderValueLiteral(value) {
 		return renderTsLiteral(value);
 	}
-	factory(_params) {
-		return () => new SqlCharCodec(this);
+	factory(params) {
+		return () => new PgCharCodec(this, params?.length);
 	}
 };
 const pgCharDescriptor = new PgCharDescriptor();
@@ -1595,8 +1789,8 @@ var PgVarcharDescriptor = class extends PostgresCodecDescriptor {
 	renderValueLiteral(value) {
 		return renderTsLiteral(value);
 	}
-	factory(_params) {
-		return () => new SqlVarcharCodec(this);
+	factory(params) {
+		return () => new PgVarcharCodec(this, params?.length);
 	}
 };
 const pgVarcharDescriptor = new PgVarcharDescriptor();
@@ -1686,6 +1880,6 @@ const codecDescriptors = definePostgresCodecs([
 	pgTsqueryDescriptor
 ]);
 //#endregion
-export { postgresQualifyColumnType as A, pgTimestamptzDateColumn as C, pgUuidColumn as D, pgUnboundedIntColumn as E, setFallbackTemporal as M, pgVarbitColumn as O, pgTextColumn as S, pgTimetzColumn as T, pgIntColumn as _, pgBitColumn as a, pgJsonbColumn as b, pgEnumDescriptor as c, pgFloatColumn as d, pgInetColumn as f, pgInt8NumberColumn as g, pgInt8Column as h, isPgEnumParams as i, requireTemporal as j, pgVarcharColumn as k, pgFloat4Column as l, pgInt4Column as m, PgTimestamptzDateDescriptor as n, pgBoolColumn as o, pgInt2Column as p, codecDescriptors as r, pgCharColumn as s, PgTimestamptzDateCodec as t, pgFloat8Column as u, pgIntervalColumn as v, pgTimestamptzDateDescriptor as w, pgNumericColumn as x, pgJsonColumn as y };
+export { pgVarbitColumn as A, pgNumericColumn as C, pgTimetzColumn as D, pgTimestamptzDateDescriptor as E, postgresQualifyColumnType as M, requireTemporal as N, pgUnboundedIntColumn as O, setFallbackTemporal as P, pgJsonbColumn as S, pgTimestamptzDateColumn as T, pgInt8Column as _, codecDescriptors as a, pgIntervalColumn as b, pgBoolColumn as c, pgFloat4Column as d, pgFloat8Column as f, pgInt4Column as g, pgInt2Column as h, PgTimestamptzDateDescriptor as i, pgVarcharColumn as j, pgUuidColumn as k, pgCharColumn as l, pgInetColumn as m, NUMERIC_SCALE_RANGE as n, isPgEnumParams as o, pgFloatColumn as p, PgTimestamptzDateCodec as r, pgBitColumn as s, NUMERIC_PRECISION_RANGE as t, pgEnumDescriptor as u, pgInt8NumberColumn as v, pgTextColumn as w, pgJsonColumn as x, pgIntColumn as y };
 
-//# sourceMappingURL=codecs-DQGmsnk3-H6nVRPCC.mjs.map
+//# sourceMappingURL=codecs-BHNqtI1J-BSS9sL3H.mjs.map