@prisma/orm-target-postgres 0.16.0-dev.36

package/dist/codecs-CBl0nD44-CaWPc1bd.mjs

@@ -0,0 +1,1486 @@
+import { a as postgresCodec, r as definePostgresCodecs, t as PostgresCodecDescriptor } from "./codec-descriptor-CB6x0xEu-C-Zn2IEz.mjs";
+import { C as PG_TIMETZ_CODEC_ID, D as PG_VARCHAR_CODEC_ID, E as PG_VARBIT_CODEC_ID, S as PG_TIMESTAMP_CODEC_ID, T as PG_UUID_CODEC_ID, _ as PG_JSON_CODEC_ID, a as PG_DATE_CODEC_ID, b as PG_TEXT_CODEC_ID, c as PG_FLOAT8_CODEC_ID, d as PG_INT2_CODEC_ID, f as PG_INT4_CODEC_ID, g as PG_JSONB_CODEC_ID, h as PG_INT_CODEC_ID, i as PG_CHAR_CODEC_ID, l as PG_FLOAT_CODEC_ID, m as PG_INTERVAL_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_ENUM_CODEC_ID, p as PG_INT8_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_FLOAT4_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INET_CODEC_ID, v as PG_NUMERIC_CODEC_ID, w as PG_TIME_CODEC_ID, x as PG_TIMESTAMPTZ_CODEC_ID, y as PG_TEXT_ARRAY_CODEC_ID } from "./codec-ids-tX7Svtz--BuOfRaVU.mjs";
+import { n as postgresError } from "./errors-kYxOQjdD-D4T3rbVp.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, sqlTimestampDescriptor, sqlVarcharDescriptor } from "@prisma/orm-family-sql/relational-core/ast";
+import { CodecImpl, column, renderTsLiteral, voidParamsSchema } from "@prisma/orm-framework/components/codec";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { type } from "arktype";
+//#region ../../../3-targets/3-targets/postgres/dist/codecs-CBl0nD44.mjs
+function renderLength(typeName, typeParams) {
+	const length = typeParams["length"];
+	if (length === void 0) return;
+	if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw postgresError("RUNTIME.TYPE_PARAMS_INVALID", `renderOutputType: expected integer "length" in typeParams for ${typeName}, got ${String(length)}`, { meta: {
+		nativeType: typeName,
+		param: "length",
+		received: String(length)
+	} });
+	return `${typeName}<${length}>`;
+}
+function renderPrecision(typeName, typeParams) {
+	const precision = typeParams["precision"];
+	if (precision === void 0) return typeName;
+	if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw postgresError("RUNTIME.TYPE_PARAMS_INVALID", `renderOutputType: expected integer "precision" in typeParams for ${typeName}, got ${String(precision)}`, { meta: {
+		nativeType: typeName,
+		param: "precision",
+		received: String(precision)
+	} });
+	return `${typeName}<${precision}>`;
+}
+const pgNumericDecode = (wire) => {
+	if (typeof wire === "number") return String(wire);
+	return wire;
+};
+const DECIMAL_INTEGER = /^-?\d+$/;
+/** Reads an `int8` wire or JSON value as a `bigint`, rejecting anything `BigInt()` would misread. */
+const pgInt8Decode = (wire) => {
+	if (typeof wire === "bigint") return wire;
+	const text = String(wire);
+	if (!DECIMAL_INTEGER.test(text)) throw postgresError("RUNTIME.DECODE_FAILED", "pg/int8@1 value must be a decimal integer", { meta: {
+		codecId: "pg/int8@1",
+		received: text
+	} });
+	return BigInt(text);
+};
+/**
+* Renders an `int8` default as a `bigint` literal. The canonical JSON is decimal
+* text but the application type is `bigint`, so a plain string literal would not
+* typecheck against the emitted column type.
+*/
+const pgInt8RenderValueLiteral = (value) => typeof value === "string" && DECIMAL_INTEGER.test(value) ? `${value}n` : void 0;
+const pgNumericRenderOutputType = (typeParams) => {
+	const precision = typeParams.precision;
+	if (precision === void 0) return void 0;
+	if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw postgresError("RUNTIME.TYPE_PARAMS_INVALID", `renderOutputType: expected integer "precision" in typeParams for Numeric, got ${String(precision)}`, { meta: {
+		nativeType: "Numeric",
+		param: "precision",
+		received: String(precision)
+	} });
+	const scale = typeParams.scale;
+	if (scale === void 0) return `Numeric<${precision}>`;
+	if (typeof scale !== "number" || !Number.isFinite(scale) || !Number.isInteger(scale)) throw postgresError("RUNTIME.TYPE_PARAMS_INVALID", `renderOutputType: expected integer "scale" in typeParams for Numeric, got ${String(scale)}`, { meta: {
+		nativeType: "Numeric",
+		param: "scale",
+		received: String(scale)
+	} });
+	return `Numeric<${precision}, ${scale}>`;
+};
+const ISO_8601_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?$/;
+const ISO_8601_TIMESTAMPTZ = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
+const pgTimestampEncodeJson = (value) => value.toISOString().slice(0, -1);
+const pgTimestampDecodeJson = (json) => {
+	if (typeof json !== "string") throw postgresError("RUNTIME.DECODE_FAILED", `Expected ISO date string for pg/timestamp@1, got ${typeof json}`, { meta: {
+		codecId: "pg/timestamp@1",
+		received: typeof json
+	} });
+	if (!ISO_8601_TIMESTAMP.test(json)) throw postgresError("RUNTIME.DECODE_FAILED", `Invalid ISO date string for pg/timestamp@1: ${json}`, { meta: {
+		codecId: "pg/timestamp@1",
+		received: json
+	} });
+	const date = /* @__PURE__ */ new Date(`${json}Z`);
+	if (Number.isNaN(date.getTime())) throw postgresError("RUNTIME.DECODE_FAILED", `Invalid ISO date string for pg/timestamp@1: ${json}`, { meta: {
+		codecId: "pg/timestamp@1",
+		received: json
+	} });
+	return date;
+};
+const pgTimestamptzEncodeJson = (value) => value.toISOString().replace(/Z$/, "+00:00");
+const pgTimestamptzDecodeJson = (json) => {
+	if (typeof json !== "string") throw postgresError("RUNTIME.DECODE_FAILED", `Expected ISO date string for pg/timestamptz@1, got ${typeof json}`, { meta: {
+		codecId: "pg/timestamptz@1",
+		received: typeof json
+	} });
+	if (!ISO_8601_TIMESTAMPTZ.test(json)) throw postgresError("RUNTIME.DECODE_FAILED", `Invalid ISO date string for pg/timestamptz@1: ${json}`, { meta: {
+		codecId: "pg/timestamptz@1",
+		received: json
+	} });
+	const date = new Date(json);
+	if (Number.isNaN(date.getTime())) throw postgresError("RUNTIME.DECODE_FAILED", `Invalid ISO date string for pg/timestamptz@1: ${json}`, { meta: {
+		codecId: "pg/timestamptz@1",
+		received: json
+	} });
+	return date;
+};
+const ISO_8601_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function formatDateOnly(year, month, day) {
+	return `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+/**
+* A Postgres `date` has no time-of-day or timezone component, so `pg/date@1`
+* canonicalizes its JS-level value as a `Date` at UTC midnight
+* (`Date.UTC(y, m, d)`), independent of the process's local timezone.
+*
+* `pgDateEncode` reads the calendar date via UTC getters (matching that
+* canonical form) and formats it as `YYYY-MM-DD` directly, bypassing the pg
+* driver's own `Date` serialization (`dateToString`), which reads *local*
+* getters and would shift the calendar day near midnight in negative-UTC-offset
+* environments.
+*/
+const pgDateEncode = (value) => formatDateOnly(value.getUTCFullYear(), value.getUTCMonth() + 1, value.getUTCDate());
+/**
+* Normalizes the pg driver's already-parsed `Date` for a `date` column into
+* the canonical UTC-midnight form. The driver (via `postgres-date`) builds
+* that `Date` at *local* midnight from the wire text; reading it back with the
+* same (local) getters recovers the exact calendar date the driver parsed,
+* and reconstructing via `Date.UTC` makes the result's instant independent of
+* the process's timezone.
+*/
+const pgDateDecode = (wire) => new Date(Date.UTC(wire.getFullYear(), wire.getMonth(), wire.getDate()));
+const pgDateEncodeJson = (value) => pgDateEncode(value);
+const pgDateDecodeJson = (json) => {
+	if (typeof json !== "string") throw postgresError("RUNTIME.DECODE_FAILED", `Expected date string for pg/date@1, got ${typeof json}`, { meta: {
+		codecId: "pg/date@1",
+		received: typeof json
+	} });
+	const match = ISO_8601_DATE.exec(json);
+	if (!match) throw postgresError("RUNTIME.DECODE_FAILED", `Invalid date string for pg/date@1: ${json}`, { meta: {
+		codecId: "pg/date@1",
+		received: json
+	} });
+	const [, yearText, monthText, dayText] = match;
+	const year = Number(yearText);
+	const month = Number(monthText) - 1;
+	const day = Number(dayText);
+	const date = new Date(Date.UTC(year, month, day));
+	if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day) throw postgresError("RUNTIME.DECODE_FAILED", `Invalid date string for pg/date@1: ${json}`, { meta: {
+		codecId: "pg/date@1",
+		received: json
+	} });
+	return date;
+};
+const ISO_DURATION = /^P(?!$)(-?\d+Y)?(-?\d+M)?(-?\d+D)?(?:T(?!$)(-?\d+H)?(-?\d+M)?(-?\d+(?:\.\d+)?S)?)?$/;
+const MICROS_PER_SECOND = 1000000n;
+/**
+* Converts a fractional-seconds digit string to microseconds, rounding rather
+* than truncating past the sixth digit.
+*
+* PostgreSQL rounds: `INTERVAL '1.1234567 seconds'` is `1.123457`, and
+* `'1.9999999 seconds'` carries into `2`. Truncating here made the parsed value
+* disagree with the database for any input past microsecond resolution.
+*
+* Ties round toward positive infinity, matching `Math.round` on the sibling path
+* that reads the driver's component object — so the two agree. PostgreSQL's own
+* tie behaviour is unobservable, because it parses the literal into a double
+* first and an exact half never survives that.
+*/
+const microsFromFraction = (fraction, negative) => {
+	if (fraction === "") return 0n;
+	const kept = BigInt(fraction.slice(0, 6).padEnd(6, "0"));
+	const rest = fraction.slice(6).replace(/0+$/, "");
+	if (rest === "") return kept;
+	const half = rest[0] === "5" && rest.length === 1;
+	return rest > "5" || half && !negative ? kept + 1n : kept;
+};
+const intervalFieldsOf = (text) => {
+	const match = ISO_DURATION.exec(text);
+	if (match === null) throw postgresError("RUNTIME.DECODE_FAILED", `pg/interval@1 value must be an ISO-8601 duration, got ${text}`, { meta: {
+		codecId: "pg/interval@1",
+		received: text
+	} });
+	const [, years, months, days, hours, minutes, seconds] = match;
+	const wholeNumber = (part) => part === void 0 ? 0 : Number(part.slice(0, -1));
+	const secondsLiteral = seconds === void 0 ? "0" : seconds.slice(0, -1);
+	const negative = secondsLiteral.startsWith("-");
+	const [whole = "0", fraction = ""] = secondsLiteral.replace("-", "").split(".");
+	const magnitude = BigInt(whole) * MICROS_PER_SECOND + microsFromFraction(fraction, negative);
+	return {
+		months: wholeNumber(years) * 12 + wholeNumber(months),
+		days: wholeNumber(days),
+		micros: BigInt(wholeNumber(hours)) * 3600n * MICROS_PER_SECOND + BigInt(wholeNumber(minutes)) * 60n * MICROS_PER_SECOND + (negative ? -magnitude : magnitude)
+	};
+};
+const secondsText = (micros) => {
+	const sign = micros < 0n ? "-" : "";
+	const magnitude = micros < 0n ? -micros : micros;
+	const whole = magnitude / MICROS_PER_SECOND % 60n;
+	const fraction = magnitude % MICROS_PER_SECOND;
+	return `${sign}${whole}${fraction === 0n ? "" : `.${fraction.toString().padStart(6, "0").replace(/0+$/, "")}`}`;
+};
+/**
+* Renders {@link PgInterval} the way PostgreSQL spells an interval under
+* `IntervalStyle = 'iso_8601'`: zero components omitted, `T` present only when a
+* time component is, each component carrying its own sign, and an all-zero
+* interval written `PT0S`.
+*/
+const formatIsoDuration = ({ months, days, micros }) => {
+	const years = Math.trunc(months / 12);
+	const restMonths = months % 12;
+	const sign = micros < 0n ? "-" : "";
+	const magnitude = micros < 0n ? -micros : micros;
+	const hours = magnitude / (3600n * MICROS_PER_SECOND);
+	const minutes = magnitude / (60n * MICROS_PER_SECOND) % 60n;
+	const hasSeconds = magnitude % (60n * MICROS_PER_SECOND) !== 0n;
+	const parts = [
+		years === 0 ? "" : `${years}Y`,
+		restMonths === 0 ? "" : `${restMonths}M`,
+		days === 0 ? "" : `${days}D`
+	];
+	const time = [
+		hours === 0n ? "" : `${sign}${hours}H`,
+		minutes === 0n ? "" : `${sign}${minutes}M`,
+		hasSeconds ? `${secondsText(micros)}S` : ""
+	].join("");
+	const rendered = `P${parts.join("")}${time === "" ? "" : `T${time}`}`;
+	return rendered === "P" ? "PT0S" : rendered;
+};
+/** Renders the application value as its canonical ISO-8601 duration. */
+const pgIntervalToIso = (value) => formatIsoDuration(value);
+const pgIntervalEncodeJson = (value) => formatIsoDuration(value);
+const pgIntervalDecodeJson = (json) => {
+	if (typeof json !== "string") throw postgresError("RUNTIME.DECODE_FAILED", "pg/interval@1 database JSON value must be an ISO-8601 duration string", { meta: {
+		codecId: "pg/interval@1",
+		received: typeof json
+	} });
+	return intervalFieldsOf(json);
+};
+/**
+* Reads the driver's wire value into the application value. `pg` parses an
+* interval into a component object, which is the same three fields under other
+* names; a text wire value is an ISO-8601 duration, because that is what the
+* codec writes.
+*/
+const pgIntervalDecode = (wire) => {
+	if (typeof wire === "string") return intervalFieldsOf(wire);
+	const part = (name) => {
+		const raw = wire[name];
+		return typeof raw === "number" ? raw : 0;
+	};
+	const seconds = part("seconds") + part("milliseconds") / 1e3;
+	return {
+		months: part("years") * 12 + part("months"),
+		days: part("days"),
+		micros: BigInt(part("hours")) * 3600n * MICROS_PER_SECOND + BigInt(part("minutes")) * 60n * MICROS_PER_SECOND + BigInt(Math.round(seconds * 1e6))
+	};
+};
+const BASE64_TEXT = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const pgByteaEncodeJson = (value) => Buffer.from(value).toString("base64");
+const pgByteaDecodeJson = (value) => {
+	if (typeof value !== "string" || !BASE64_TEXT.test(value)) throw postgresError("RUNTIME.DECODE_FAILED", "pg/bytea@1 database JSON value must be a base64 string", { meta: { codecId: "pg/bytea@1" } });
+	return new Uint8Array(Buffer.from(value, "base64"));
+};
+const pgJsonEncode = (value) => JSON.stringify(value);
+const pgJsonDecode = (wire) => typeof wire === "string" ? JSON.parse(wire) : wire;
+const pgJsonbEncode = (value) => JSON.stringify(value);
+const pgJsonbDecode = (wire) => typeof wire === "string" ? JSON.parse(wire) : wire;
+const lengthParamsSchema = type({ "length?": "number.integer > 0" });
+const numericParamsSchema = type({
+	"precision?": "number.integer > 0 & number.integer <= 1000",
+	"scale?": "number.integer >= 0"
+});
+const precisionParamsSchema = type({ "precision?": "number.integer >= 0 & number.integer <= 6" });
+const PG_TEXT_NATIVE_TYPE = "text";
+const PG_TEXT_ARRAY_NATIVE_TYPE = "text[]";
+const PG_INT4_NATIVE_TYPE = "integer";
+const PG_INT2_NATIVE_TYPE = "smallint";
+const PG_INT8_NATIVE_TYPE = "bigint";
+const PG_FLOAT4_NATIVE_TYPE = "real";
+const PG_FLOAT8_NATIVE_TYPE = "double precision";
+const PG_NUMERIC_NATIVE_TYPE = "numeric";
+const PG_DATE_NATIVE_TYPE = "date";
+const PG_TIMESTAMP_NATIVE_TYPE = "timestamp without time zone";
+const PG_TIMESTAMPTZ_NATIVE_TYPE = "timestamp with time zone";
+const PG_TIME_NATIVE_TYPE = "time";
+const PG_TIMETZ_NATIVE_TYPE = "timetz";
+const PG_BOOL_NATIVE_TYPE = "boolean";
+const PG_BIT_NATIVE_TYPE = "bit";
+const PG_VARBIT_NATIVE_TYPE = "bit varying";
+const PG_BYTEA_NATIVE_TYPE = "bytea";
+const PG_INTERVAL_NATIVE_TYPE = "interval";
+const PG_JSON_NATIVE_TYPE = "json";
+const PG_JSONB_NATIVE_TYPE = "jsonb";
+/**
+* Projects the expression unchanged, for codecs whose canonical JSON is what
+* PostgreSQL's own JSON conversion already produces.
+*
+* Identity here is a claim about the target's behaviour, not an absence of one:
+* the codec's conformance cases are what test it, including at the boundaries
+* of the representation — escaping, sign, and range — where a native conversion
+* would be most likely to diverge.
+*/
+/**
+* Whether a string is numeric text in the form PostgreSQL *prints*, which is
+* narrower than the form it accepts.
+*
+* `numeric` reads `+123`, `.5`, `1.`, `1e5`, `0x1f`, `1_000` and whitespace-padded
+* input, but prints every one of them in a single normalised form — `123`,
+* `0.5`, `1`, `100000`, `31`, `1000`, `12`. The projection reads the column back
+* through that printing, so accepting an input spelling here would produce an
+* application value the projection can never return: `encodeJson('1e5')` would
+* claim `1e5` where the database yields `100000`.
+*
+* `NaN`, `Infinity` and `-Infinity` are genuine `numeric` values, not error
+* states, and PostgreSQL emits them into JSON as strings — so they belong to the
+* canonical form and round-trip like any other value.
+*/
+const CANONICAL_NUMERIC_TEXT = /^(?:-?\d+(?:\.\d+)?|NaN|-?Infinity)$/;
+const isCanonicalNumericText = (value) => CANONICAL_NUMERIC_TEXT.test(value);
+const identityJsonProjection = (expression) => expression;
+/**
+* Projects a numeric-valued expression as decimal text.
+*
+* The cast is part of the projected expression, which is what makes it correct:
+* whatever `jsonProjection` returns is the argument the JSON constructor
+* receives, so casting here happens *before* PostgreSQL builds the JSON value.
+* Handed a `numeric` or `int8` directly, the constructor emits a JSON **number**,
+* and every digit past IEEE-754's 53 bits of significand is gone by the time the
+* driver has parsed it — before any codec can intervene. A cast applied to the
+* constructor's result instead of its argument would be too late to matter.
+*/
+const decimalTextJsonProjection = (expression) => CastExpr.as(expression, "text");
+/**
+* Projects a `bytea` as base64 text.
+*
+* Like the decimal-text cast, the encoding is part of the projected expression:
+* PostgreSQL's own JSON conversion of a `bytea` emits its `\x`-prefixed hex
+* output form, so the base64 encoding has to replace that conversion rather
+* than post-process it.
+*
+* `encode` emits RFC 2045 base64, which carries a line break every 76
+* characters — so any value over 56 bytes arrives wrapped. The breaks are
+* removed here, because the canonical form is unwrapped base64 and
+* `decodeJson` rejects anything else. `chr(10)` rather than a newline literal
+* keeps the rendered SQL on one line.
+*/
+const base64JsonProjection = (expression) => FunctionCallExpr.of("translate", [
+	FunctionCallExpr.of("encode", [expression, LiteralExpr.of("base64")]),
+	FunctionCallExpr.of("chr", [LiteralExpr.of(10)]),
+	LiteralExpr.of("")
+]);
+/**
+* Projects a `timestamptz` as a UTC ISO-8601 string that no session setting can
+* move.
+*
+* A `timestamptz` handed straight to a JSON constructor is rendered in the
+* session's `TimeZone`, so the same stored instant reads as `+00:00`, `-05:00`
+* or `+05:30` depending on who is connected. `timezone('UTC', …)` resolves the
+* instant to UTC wall-clock independently of the session, and the explicit
+* `to_char` format pins the rendering rather than inheriting `DateStyle`.
+*/
+const utcIsoJsonProjection = (expression) => FunctionCallExpr.of("to_char", [FunctionCallExpr.of("timezone", [LiteralExpr.of("UTC"), expression]), LiteralExpr.of("YYYY-MM-DD\"T\"HH24:MI:SS.MS\"+00:00\"")]);
+const datePart = (field, expression) => FunctionCallExpr.of("date_part", [LiteralExpr.of(field), expression]);
+const whenNonZero = (value, rendered) => CaseExpr.of([{
+	condition: BinaryExpr.neq(value, LiteralExpr.of(0)),
+	value: rendered
+}], LiteralExpr.of(null));
+/**
+* Projects an `interval` as an ISO-8601 duration.
+*
+* An interval carries months, days and microseconds independently — `P1M` and
+* `P30D` are different intervals — so the projection reads each field with
+* `date_part` and assembles them rather than reducing the value to an epoch,
+* which would have to choose a length for a month. `IntervalStyle` decides how
+* PostgreSQL spells an interval and cannot be bound per expression, so the
+* spelling is constructed here instead of inherited.
+*
+* `concat` drops NULL arguments, so a zero component is omitted by rendering as
+* NULL; the seconds field is taken through `numeric` because a `double
+* precision` microsecond renders in scientific notation.
+*
+* That same NULL-dropping is why the whole assembly sits under an explicit NULL
+* check: for a NULL interval every field is NULL, `concat` yields `'P'`, and the
+* zero-duration fallback below would report an absent value as a zero one.
+*/
+const isoDurationJsonProjection = (expression) => {
+	const field = (name) => datePart(name, expression);
+	const seconds = CastExpr.as(field("second"), "numeric");
+	const assembled = FunctionCallExpr.of("concat", [
+		LiteralExpr.of("P"),
+		whenNonZero(field("year"), FunctionCallExpr.of("concat", [field("year"), LiteralExpr.of("Y")])),
+		whenNonZero(field("month"), FunctionCallExpr.of("concat", [field("month"), LiteralExpr.of("M")])),
+		whenNonZero(field("day"), FunctionCallExpr.of("concat", [field("day"), LiteralExpr.of("D")])),
+		CaseExpr.of([{
+			condition: OrExpr.of([
+				BinaryExpr.neq(field("hour"), LiteralExpr.of(0)),
+				BinaryExpr.neq(field("minute"), LiteralExpr.of(0)),
+				BinaryExpr.neq(field("second"), LiteralExpr.of(0))
+			]),
+			value: LiteralExpr.of("T")
+		}], LiteralExpr.of(null)),
+		whenNonZero(field("hour"), FunctionCallExpr.of("concat", [field("hour"), LiteralExpr.of("H")])),
+		whenNonZero(field("minute"), FunctionCallExpr.of("concat", [field("minute"), LiteralExpr.of("M")])),
+		whenNonZero(field("second"), FunctionCallExpr.of("concat", [seconds, LiteralExpr.of("S")]))
+	]);
+	return CaseExpr.of([{
+		condition: NullCheckExpr.isNull(expression),
+		value: LiteralExpr.of(null)
+	}], FunctionCallExpr.of("coalesce", [FunctionCallExpr.of("nullif", [assembled, LiteralExpr.of("P")]), LiteralExpr.of("PT0S")]));
+};
+const postgresSqlCharDescriptor = postgresCodec(sqlCharDescriptor, {
+	nativeType: () => "character",
+	jsonProjection: identityJsonProjection
+});
+const postgresSqlVarcharDescriptor = postgresCodec(sqlVarcharDescriptor, {
+	nativeType: () => "character varying",
+	jsonProjection: identityJsonProjection
+});
+const postgresSqlIntDescriptor = postgresCodec(sqlIntDescriptor, {
+	nativeType: () => "int4",
+	jsonProjection: identityJsonProjection
+});
+const postgresSqlFloatDescriptor = postgresCodec(sqlFloatDescriptor, {
+	nativeType: () => "float8",
+	jsonProjection: identityJsonProjection
+});
+const postgresSqlTextDescriptor = postgresCodec(sqlTextDescriptor, {
+	nativeType: () => "text",
+	jsonProjection: identityJsonProjection
+});
+const postgresSqlTimestampDescriptor = postgresCodec(sqlTimestampDescriptor, {
+	nativeType: () => "timestamp",
+	jsonProjection: identityJsonProjection
+});
+var PgTextCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgTextDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TEXT_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_TEXT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"textual"
+	];
+	targetTypes = ["text"];
+	paramsSchema = voidParamsSchema;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory() {
+		return () => new PgTextCodec(this);
+	}
+};
+const pgTextDescriptor = new PgTextDescriptor();
+const pgTextColumn = () => column(pgTextDescriptor.factory(), pgTextDescriptor.codecId, void 0, "text");
+/**
+* Codec for a `pg.enum(Ref)` column bound to a native Postgres enum type.
+* Text passthrough, identical to `pg/text@1` — encode/decode do not carry the
+* enum's member values; membership is enforced by the native type itself, not
+* by this codec. `renderValueLiteral` renders a member value as its TS
+* literal, which is what drives the column's typed value-union (via
+* `renderValueSetType` reading the column's `valueSet` ref) — the codec
+* itself carries no params of its own; typing comes entirely from the
+* column's value-set, not from `pg/enum@1`.
+*
+* A distinct codec id (rather than reusing `pg/text@1` on a plain text
+* column) keeps native-enum columns independently identifiable — from a
+* column's `codecId` alone, without also inspecting `nativeType` — which
+* the managed (DDL) phase needs to target `CREATE TYPE`/`ALTER TYPE`
+* operations at exactly the columns that use one.
+*/
+var PgEnumCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return blindCast(json);
+	}
+};
+/**
+* Narrows codec `typeParams` to {@link PgEnumParams} — the shape that binds a
+* column to a named database type (a native enum's `CREATE TYPE` name).
+*/
+function isPgEnumParams(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "typeName" in value && typeof value.typeName === "string";
+}
+const pgEnumParamsSchema = type({ typeName: "string" });
+var PgEnumDescriptor = class extends PostgresCodecDescriptor {
+	nativeType(params) {
+		return params.typeName;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_ENUM_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"textual"
+	];
+	targetTypes = ["text"];
+	paramsSchema = pgEnumParamsSchema;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory(_params) {
+		return () => new PgEnumCodec(this);
+	}
+	/**
+	* Authoring-time hook a `pg.enum(<ref>)` type constructor calls once it has
+	* resolved its ref argument to the referenced `native_enum` entity:
+	* produces this codec's per-column `typeParams` and native type from the
+	* entity's bare type name. Schema-qualification (`auth.aal_level` for a
+	* named non-default schema) is not this hook's concern — the field's
+	* namespace isn't known at this call site for every authoring path (the TS
+	* builder resolves a column before it knows its model's namespace), so it is
+	* applied later, at contract construction, by {@link qualifyNativeType} via
+	* the target's `authoring.qualifyColumnType` hook. `nativeType` mirrors
+	* `typeParams.typeName` — the same value `nativeTypeFor` derives at render
+	* time — so the column's declared native type and the render-time cast
+	* agree. Returns `undefined` if `entity` is not a `PostgresNativeEnum` (a
+	* contributor bug, not a user-schema error — the caller decides how to
+	* report it).
+	*/
+	columnFromEntity(entity) {
+		if (!PostgresNativeEnum.is(entity)) return void 0;
+		return {
+			typeParams: { typeName: entity.typeName },
+			nativeType: entity.typeName
+		};
+	}
+	/**
+	* Schema-qualifies this native enum type's name for the namespace the
+	* consuming column lives in: `${namespaceId}.${typeName}` for a named
+	* non-default schema, bare for the target's default schema (`public`) or
+	* the late-bound unbound sentinel (whose schema `search_path` resolves at
+	* runtime). Postgres's `format_type()` reports the bare name for a
+	* public-schema type, so a public column's declared native type must stay
+	* bare to match. Owned here because the codec owns its native type.
+	*/
+	qualifyNativeType(typeName, namespaceId) {
+		return namespaceId === "public" || namespaceId === UNBOUND_NAMESPACE_ID ? typeName : `${namespaceId}.${typeName}`;
+	}
+};
+const pgEnumDescriptor = new PgEnumDescriptor();
+/**
+* Contract-construction-time column-type qualifier the Postgres target
+* contributes through `authoring.qualifyColumnType`.
+* `buildSqlContractFromDefinition` calls this for every column as it is
+* constructed, passing the column's bare type info and its owning
+* `namespaceId`; a native-enum column (`pg/enum@1`) gets its type name
+* schema-qualified for that namespace (via
+* {@link PgEnumDescriptor.qualifyNativeType}), keeping `nativeType` and
+* `typeParams.typeName` in sync. Every other codec passes through unchanged.
+* Both the PSL `pg.enum(Ref)` path and the TS `pg.enum(handle)` path route
+* through here — the dispatch keys off the codec id, not authoring surface.
+*/
+function postgresQualifyColumnType(input, namespaceId) {
+	if (input.codecId !== "pg/enum@1") return input;
+	const bareTypeName = input.typeParams?.["typeName"];
+	if (typeof bareTypeName !== "string") return input;
+	const qualified = pgEnumDescriptor.qualifyNativeType(bareTypeName, namespaceId);
+	return {
+		nativeType: qualified,
+		typeParams: {
+			...input.typeParams,
+			typeName: qualified
+		}
+	};
+}
+/**
+* Postgres `text[]` codec. Encode is an identity pass-through: the pg wire
+* driver serialises a JS `string[]` to a Postgres array literal under the
+* `$N::text[]` cast the renderer emits from this codec's `text[]` native type,
+* and decode reads it back as a JS array. Used by the control plane to write
+* the marker's `invariants` column. Not a user-facing scalar — it is not part
+* of the authorable `CodecTypes` surface, only the runtime codec registry.
+*/
+var PgTextArrayCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return [...value];
+	}
+	decodeJson(json) {
+		return Array.isArray(json) ? json.map((entry) => String(entry)) : [];
+	}
+};
+var PgTextArrayDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TEXT_ARRAY_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_TEXT_ARRAY_CODEC_ID;
+	traits = ["equality"];
+	targetTypes = ["text[]"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgTextArrayCodec(this);
+	}
+};
+const pgTextArrayDescriptor = new PgTextArrayDescriptor();
+var PgInt4Codec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgInt4Descriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_INT4_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_INT4_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["int4"];
+	paramsSchema = voidParamsSchema;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory() {
+		return () => new PgInt4Codec(this);
+	}
+};
+const pgInt4Descriptor = new PgInt4Descriptor();
+const pgInt4Column = () => column(pgInt4Descriptor.factory(), pgInt4Descriptor.codecId, void 0, "int4");
+var PgInt2Codec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgInt2Descriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_INT2_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_INT2_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["int2"];
+	paramsSchema = voidParamsSchema;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory() {
+		return () => new PgInt2Codec(this);
+	}
+};
+const pgInt2Descriptor = new PgInt2Descriptor();
+const pgInt2Column = () => column(pgInt2Descriptor.factory(), pgInt2Descriptor.codecId, void 0, "int2");
+/**
+* A Postgres `int8` spans the full signed 64-bit range, which a JS `number`
+* cannot hold past 2^53. Application values are `bigint` and the canonical JSON
+* is decimal text; the wire form is the decimal string `pg` reads and writes for
+* this type.
+*/
+var PgInt8Codec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value.toString();
+	}
+	async decode(wire, _ctx) {
+		return pgInt8Decode(wire);
+	}
+	encodeJson(value) {
+		return value.toString();
+	}
+	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);
+	}
+};
+var PgInt8Descriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_INT8_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return decimalTextJsonProjection(expression);
+	}
+	codecId = PG_INT8_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["int8"];
+	paramsSchema = voidParamsSchema;
+	renderValueLiteral(value) {
+		return pgInt8RenderValueLiteral(value);
+	}
+	factory() {
+		return () => new PgInt8Codec(this);
+	}
+};
+const pgInt8Descriptor = new PgInt8Descriptor();
+const pgInt8Column = () => column(pgInt8Descriptor.factory(), pgInt8Descriptor.codecId, void 0, "int8");
+var PgFloat4Codec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgFloat4Descriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_FLOAT4_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_FLOAT4_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["float4"];
+	paramsSchema = voidParamsSchema;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory() {
+		return () => new PgFloat4Codec(this);
+	}
+};
+const pgFloat4Descriptor = new PgFloat4Descriptor();
+const pgFloat4Column = () => column(pgFloat4Descriptor.factory(), pgFloat4Descriptor.codecId, void 0, "float4");
+var PgFloat8Codec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgFloat8Descriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_FLOAT8_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_FLOAT8_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["float8"];
+	paramsSchema = voidParamsSchema;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory() {
+		return () => new PgFloat8Codec(this);
+	}
+};
+const pgFloat8Descriptor = new PgFloat8Descriptor();
+const pgFloat8Column = () => column(pgFloat8Descriptor.factory(), pgFloat8Descriptor.codecId, void 0, "float8");
+var PgBoolCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgBoolDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_BOOL_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_BOOL_CODEC_ID;
+	traits = ["equality", "boolean"];
+	targetTypes = ["bool"];
+	paramsSchema = voidParamsSchema;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory() {
+		return () => new PgBoolCodec(this);
+	}
+};
+const pgBoolDescriptor = new PgBoolDescriptor();
+const pgBoolColumn = () => column(pgBoolDescriptor.factory(), pgBoolDescriptor.codecId, void 0, "bool");
+var PgNumericCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return pgNumericDecode(wire);
+	}
+	encodeJson(value) {
+		if (!isCanonicalNumericText(value)) throw postgresError("RUNTIME.ENCODE_FAILED", "pg/numeric@1 application value must be canonical numeric text: an optionally negated decimal numeral, or NaN, Infinity or -Infinity", { meta: {
+			codecId: PG_NUMERIC_CODEC_ID,
+			received: value
+		} });
+		return value;
+	}
+	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;
+	}
+};
+var PgNumericDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_NUMERIC_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return decimalTextJsonProjection(expression);
+	}
+	codecId = PG_NUMERIC_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["numeric", "decimal"];
+	paramsSchema = numericParamsSchema;
+	renderOutputType(params) {
+		return pgNumericRenderOutputType(params);
+	}
+	factory(_params) {
+		return () => new PgNumericCodec(this);
+	}
+};
+const pgNumericDescriptor = new PgNumericDescriptor();
+const pgNumericColumn = (params = {}) => column(pgNumericDescriptor.factory(params), pgNumericDescriptor.codecId, params, "numeric");
+/**
+* A Postgres `date` has no time-of-day or timezone component. This codec
+* canonicalizes its JS-level value as a `Date` at UTC midnight, so its
+* round-trip is independent of the process's local timezone — see
+* `pgDateEncode`/`pgDateDecode` in `codec-helpers.ts`.
+*/
+var PgDateCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgDateEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return pgDateDecode(wire);
+	}
+	encodeJson(value) {
+		return pgDateEncodeJson(value);
+	}
+	decodeJson(json) {
+		return pgDateDecodeJson(json);
+	}
+};
+var PgDateDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_DATE_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_DATE_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["date"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgDateCodec(this);
+	}
+};
+const pgDateDescriptor = new PgDateDescriptor();
+const pgDateColumn = () => column(pgDateDescriptor.factory(), pgDateDescriptor.codecId, void 0, "date");
+var PgTimestampCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return pgTimestampEncodeJson(value);
+	}
+	decodeJson(json) {
+		return pgTimestampDecodeJson(json);
+	}
+};
+var PgTimestampDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TIMESTAMP_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_TIMESTAMP_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["timestamp"];
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("Timestamp", params);
+	}
+	factory(_params) {
+		return () => new PgTimestampCodec(this);
+	}
+};
+const pgTimestampDescriptor = new PgTimestampDescriptor();
+const pgTimestampColumn = (params = {}) => column(pgTimestampDescriptor.factory(params), pgTimestampDescriptor.codecId, params, "timestamp");
+var PgTimestamptzCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return pgTimestamptzEncodeJson(value);
+	}
+	decodeJson(json) {
+		return pgTimestamptzDecodeJson(json);
+	}
+};
+var PgTimestamptzDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TIMESTAMPTZ_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return utcIsoJsonProjection(expression);
+	}
+	codecId = PG_TIMESTAMPTZ_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["timestamptz"];
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("Timestamptz", params);
+	}
+	factory(_params) {
+		return () => new PgTimestamptzCodec(this);
+	}
+};
+const pgTimestamptzDescriptor = new PgTimestamptzDescriptor();
+const pgTimestamptzColumn = (params = {}) => column(pgTimestamptzDescriptor.factory(params), pgTimestamptzDescriptor.codecId, params, "timestamptz");
+var PgTimeCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgTimeDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TIME_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_TIME_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["time"];
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("Time", params);
+	}
+	factory(_params) {
+		return () => new PgTimeCodec(this);
+	}
+};
+const pgTimeDescriptor = new PgTimeDescriptor();
+const pgTimeColumn = (params = {}) => column(pgTimeDescriptor.factory(params), pgTimeDescriptor.codecId, params, "time");
+var PgTimetzCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgTimetzDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TIMETZ_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_TIMETZ_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["timetz"];
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("Timetz", params);
+	}
+	factory(_params) {
+		return () => new PgTimetzCodec(this);
+	}
+};
+const pgTimetzDescriptor = new PgTimetzDescriptor();
+const pgTimetzColumn = (params = {}) => column(pgTimetzDescriptor.factory(params), pgTimetzDescriptor.codecId, params, "timetz");
+var PgBitCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgBitDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_BIT_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_BIT_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["bit"];
+	paramsSchema = lengthParamsSchema;
+	renderOutputType(params) {
+		return renderLength("Bit", params);
+	}
+	factory(_params) {
+		return () => new PgBitCodec(this);
+	}
+};
+const pgBitDescriptor = new PgBitDescriptor();
+const pgBitColumn = (params = {}) => column(pgBitDescriptor.factory(params), pgBitDescriptor.codecId, params, "bit");
+var PgVarbitCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgVarbitDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_VARBIT_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_VARBIT_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["bit varying"];
+	paramsSchema = lengthParamsSchema;
+	renderOutputType(params) {
+		return renderLength("VarBit", params);
+	}
+	factory(_params) {
+		return () => new PgVarbitCodec(this);
+	}
+};
+const pgVarbitDescriptor = new PgVarbitDescriptor();
+const pgVarbitColumn = (params = {}) => column(pgVarbitDescriptor.factory(params), pgVarbitDescriptor.codecId, params, "bit varying");
+var PgByteaCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire instanceof Uint8Array && wire.constructor === Uint8Array ? wire : new Uint8Array(wire.buffer, wire.byteOffset, wire.byteLength);
+	}
+	encodeJson(value) {
+		return pgByteaEncodeJson(value);
+	}
+	decodeJson(json) {
+		return pgByteaDecodeJson(json);
+	}
+};
+var PgByteaDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_BYTEA_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return base64JsonProjection(expression);
+	}
+	codecId = PG_BYTEA_CODEC_ID;
+	traits = ["equality"];
+	targetTypes = ["bytea"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgByteaCodec(this);
+	}
+};
+const pgByteaDescriptor = new PgByteaDescriptor();
+const PG_UUID_NATIVE_TYPE = "uuid";
+var PgUuidCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return blindCast(json);
+	}
+};
+var PgUuidDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_UUID_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_UUID_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["uuid"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgUuidCodec(this);
+	}
+};
+const pgUuidDescriptor = new PgUuidDescriptor();
+const pgUuidColumn = () => column(pgUuidDescriptor.factory(), pgUuidDescriptor.codecId, void 0, "uuid");
+const PG_INET_NATIVE_TYPE = "inet";
+var PgInetCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return blindCast(json);
+	}
+};
+var PgInetDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_INET_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_INET_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["inet"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgInetCodec(this);
+	}
+};
+const pgInetDescriptor = new PgInetDescriptor();
+const pgInetColumn = () => column(pgInetDescriptor.factory(), pgInetDescriptor.codecId, void 0, "inet");
+/**
+* An application value is a {@link PgInterval} — the three fields PostgreSQL
+* actually stores, `{ months, days, micros }` — and its canonical JSON is the
+* ISO-8601 duration string PostgreSQL spells under
+* `IntervalStyle = 'iso_8601'`: `P1M`, `P30D`, `P1Y2M3DT4H5M6S`, `PT0S` for
+* zero, each component carrying its own sign.
+*
+* Value and representation are independent here, as they are for `pg/bytea@1`
+* (`Uint8Array` carried as base64) and `pg/int8@1` (`bigint` carried as decimal
+* text). Reading an interval hands back numbers to compute with rather than a
+* string to parse; writing one takes the same numbers.
+*
+* The fields stay independent because a month has no fixed length: `{months: 1}`
+* and `{days: 30}` are different values and neither converts to the other. The
+* ISO rendering normalises only in its own spelling — twelve months render as a
+* year — so `{months: 13}` renders `P1Y1M` and reads back as `{months: 13}`.
+*/
+var PgIntervalCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgIntervalToIso(value);
+	}
+	async decode(wire, _ctx) {
+		return pgIntervalDecode(wire);
+	}
+	encodeJson(value) {
+		return pgIntervalEncodeJson(value);
+	}
+	decodeJson(json) {
+		return pgIntervalDecodeJson(json);
+	}
+};
+var PgIntervalDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_INTERVAL_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return isoDurationJsonProjection(expression);
+	}
+	codecId = PG_INTERVAL_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["interval"];
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("Interval", params);
+	}
+	factory(_params) {
+		return () => new PgIntervalCodec(this);
+	}
+};
+const pgIntervalDescriptor = new PgIntervalDescriptor();
+const pgIntervalColumn = (params = {}) => column(pgIntervalDescriptor.factory(params), pgIntervalDescriptor.codecId, params, "interval");
+var PgJsonCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgJsonEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return pgJsonDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgJsonDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_JSON_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_JSON_CODEC_ID;
+	traits = [];
+	targetTypes = ["json"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgJsonCodec(this);
+	}
+};
+const pgJsonDescriptor = new PgJsonDescriptor();
+const pgJsonColumn = () => column(pgJsonDescriptor.factory(), pgJsonDescriptor.codecId, void 0, "json");
+var PgJsonbCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgJsonbEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return pgJsonbDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgJsonbDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_JSONB_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_JSONB_CODEC_ID;
+	traits = ["equality"];
+	targetTypes = ["jsonb"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgJsonbCodec(this);
+	}
+};
+const pgJsonbDescriptor = new PgJsonbDescriptor();
+const pgJsonbColumn = () => column(pgJsonbDescriptor.factory(), pgJsonbDescriptor.codecId, void 0, "jsonb");
+const PG_CHAR_NATIVE_TYPE = "character";
+const PG_VARCHAR_NATIVE_TYPE = "character varying";
+const PG_INT_NATIVE_TYPE = "integer";
+const PG_FLOAT_NATIVE_TYPE = "double precision";
+var PgCharDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_CHAR_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_CHAR_CODEC_ID;
+	targetTypes = ["character"];
+	traits = sqlCharDescriptor.traits;
+	paramsSchema = sqlCharDescriptor.paramsSchema;
+	renderOutputType(params) {
+		return sqlCharDescriptor.renderOutputType(params);
+	}
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory(_params) {
+		return () => new SqlCharCodec(this);
+	}
+};
+const pgCharDescriptor = new PgCharDescriptor();
+const pgCharColumn = (params = {}) => column(pgCharDescriptor.factory(params), pgCharDescriptor.codecId, params, "character");
+var PgVarcharDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_VARCHAR_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_VARCHAR_CODEC_ID;
+	targetTypes = ["character varying"];
+	traits = sqlVarcharDescriptor.traits;
+	paramsSchema = sqlVarcharDescriptor.paramsSchema;
+	renderOutputType(params) {
+		return sqlVarcharDescriptor.renderOutputType(params);
+	}
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory(_params) {
+		return () => new SqlVarcharCodec(this);
+	}
+};
+const pgVarcharDescriptor = new PgVarcharDescriptor();
+const pgVarcharColumn = (params = {}) => column(pgVarcharDescriptor.factory(params), pgVarcharDescriptor.codecId, params, "character varying");
+var PgIntDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_INT_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_INT_CODEC_ID;
+	targetTypes = ["int4"];
+	traits = sqlIntDescriptor.traits;
+	paramsSchema = sqlIntDescriptor.paramsSchema;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory() {
+		return () => new SqlIntCodec(this);
+	}
+};
+const pgIntDescriptor = new PgIntDescriptor();
+const pgIntColumn = () => column(pgIntDescriptor.factory(), pgIntDescriptor.codecId, void 0, "int4");
+var PgFloatDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_FLOAT_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_FLOAT_CODEC_ID;
+	targetTypes = ["float8"];
+	traits = sqlFloatDescriptor.traits;
+	paramsSchema = sqlFloatDescriptor.paramsSchema;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory() {
+		return () => new SqlFloatCodec(this);
+	}
+};
+const pgFloatDescriptor = new PgFloatDescriptor();
+const pgFloatColumn = () => column(pgFloatDescriptor.factory(), pgFloatDescriptor.codecId, void 0, "float8");
+const codecDescriptors = definePostgresCodecs([
+	postgresSqlCharDescriptor,
+	postgresSqlVarcharDescriptor,
+	postgresSqlIntDescriptor,
+	postgresSqlFloatDescriptor,
+	postgresSqlTextDescriptor,
+	postgresSqlTimestampDescriptor,
+	pgTextDescriptor,
+	pgEnumDescriptor,
+	pgCharDescriptor,
+	pgVarcharDescriptor,
+	pgIntDescriptor,
+	pgFloatDescriptor,
+	pgInt4Descriptor,
+	pgInt2Descriptor,
+	pgInt8Descriptor,
+	pgFloat4Descriptor,
+	pgFloat8Descriptor,
+	pgNumericDescriptor,
+	pgDateDescriptor,
+	pgTimestampDescriptor,
+	pgTimestamptzDescriptor,
+	pgTimeDescriptor,
+	pgTimetzDescriptor,
+	pgBoolDescriptor,
+	pgBitDescriptor,
+	pgVarbitDescriptor,
+	pgByteaDescriptor,
+	pgUuidDescriptor,
+	pgInetDescriptor,
+	pgIntervalDescriptor,
+	pgJsonDescriptor,
+	pgJsonbDescriptor,
+	pgTextArrayDescriptor
+]);
+//#endregion
+export { pgTimestamptzColumn as C, pgVarcharColumn as D, pgVarbitColumn as E, postgresQualifyColumnType as O, pgTimestampColumn as S, pgUuidColumn as T, pgJsonColumn as _, pgCharColumn as a, pgTextColumn as b, pgFloat4Column as c, pgInetColumn as d, pgInt2Column as f, pgIntervalColumn as g, pgIntColumn as h, pgBoolColumn as i, pgFloat8Column as l, pgInt8Column as m, isPgEnumParams as n, pgDateColumn as o, pgInt4Column as p, pgBitColumn as r, pgEnumDescriptor as s, codecDescriptors as t, pgFloatColumn as u, pgJsonbColumn as v, pgTimetzColumn as w, pgTimeColumn as x, pgNumericColumn as y };
+
+//# sourceMappingURL=codecs-CBl0nD44-CaWPc1bd.mjs.map