@prisma/orm-target-postgres 8.0.0-rc.5-dev.1 → 8.0.0-rc.5-dev.3

package/dist/{codecs-BmPCJWqb-DveZGJvm.mjs → codecs-CxWg7WrX-DtVAuuXA.mjs}

@@ -1,15 +1,16 @@
-import { C as PG_TIMESTAMP_CODEC_ID, D as PG_UUID_CODEC_ID, E as PG_UNBOUNDED_INT_CODEC_ID, O as PG_VARBIT_CODEC_ID, S as PG_TIMESTAMPTZ_CODEC_ID, T as PG_TIME_CODEC_ID, _ as PG_JSONB_CODEC_ID, a as PG_DATE_CODEC_ID, b as PG_TEXT_ARRAY_CODEC_ID, c as PG_FLOAT8_CODEC_ID, d as PG_INT2_CODEC_ID, f as PG_INT4_CODEC_ID, g as PG_INT_CODEC_ID, h as PG_INTERVAL_CODEC_ID, i as PG_CHAR_CODEC_ID, k as PG_VARCHAR_CODEC_ID, l as PG_FLOAT_CODEC_ID, m as PG_INT8_NUMBER_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_JSON_CODEC_ID, w as PG_TIMETZ_CODEC_ID, x as PG_TEXT_CODEC_ID, y as PG_NUMERIC_CODEC_ID } from "./codec-ids-C5Rkltkw-DMf87l9s.mjs";
+import { A as PG_UNBOUNDED_INT_CODEC_ID, C as PG_TIMESTAMPTZ_STRING_CODEC_ID, D as PG_TIMETZ_CODEC_ID, E as PG_TIMESTAMP_TEMPORAL_CODEC_ID, M as PG_VARBIT_CODEC_ID, N as PG_VARCHAR_CODEC_ID, O as PG_TIME_STRING_CODEC_ID, S as PG_TEXT_CODEC_ID, T as PG_TIMESTAMP_STRING_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_UUID_CODEC_ID, k as PG_TIME_TEMPORAL_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_TEMPORAL_CODEC_ID, x as PG_TEXT_ARRAY_CODEC_ID, y as PG_JSON_CODEC_ID } from "./codec-ids-D3ZEAmt2-DjoKUAas.mjs";
 import { a as postgresCodec, r as definePostgresCodecs, t as PostgresCodecDescriptor } from "./codec-descriptor-LT7BpQta-BaDM8UQQ.mjs";
-import { n as postgresError } from "./errors-DKjQzNaN-DFcF1thx.mjs";
+import { a as errorTemporalUnrepresentable, n as errorTemporalNonIsoCalendar, o as errorTemporalWrongType, r as errorTemporalUnavailable, s as postgresError } from "./errors-DYyzTYzE-39CV_aMo.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 { 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, 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-BmPCJWqb.mjs
+//#region ../../../3-targets/3-targets/postgres/dist/codecs-CxWg7WrX.mjs
+const precisionParamsSchema = type({ "precision?": "number.integer >= 0 & number.integer <= 6" });
 function renderLength(typeName, typeParams) {
-	const length = typeParams["length"];
+	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,
@@ -19,7 +20,7 @@ function renderLength(typeName, typeParams) {
 	return `${typeName}<${length}>`;
 }
 function renderPrecision(typeName, typeParams) {
-	const precision = typeParams["precision"];
+	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,
@@ -163,89 +164,6 @@ const pgNumericRenderOutputType = (typeParams) => {
 	} });
 	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;
 /**
@@ -360,12 +278,345 @@ 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 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 POSTGRES_TEMPORAL_SENTINELS = /* @__PURE__ */ new Set(["infinity", "-infinity"]);
+const EXPANDED_YEAR_DIGITS = 6;
+const ORDINARY_YEAR_DIGITS = 4;
+const BC_SUFFIX = " BC";
+function adaptPostgresEra(text) {
+	const isBc = text.endsWith(BC_SUFFIX);
+	const body = isBc ? text.slice(0, -3) : text;
+	const yearEnd = body.indexOf("-");
+	if (yearEnd <= 0) return text;
+	const yearText = body.slice(0, yearEnd);
+	if (!isBc && yearText.length <= ORDINARY_YEAR_DIGITS) return text;
+	const year = Number(yearText);
+	if (!Number.isInteger(year)) return text;
+	const proleptic = isBc ? 1 - year : year;
+	return `${proleptic < 0 ? "-" : "+"}${String(Math.abs(proleptic)).padStart(EXPANDED_YEAR_DIGITS, "0")}${body.slice(yearEnd)}`;
+}
+function requireTemporal(codecId, operation) {
+	if (typeof Temporal === "undefined") throw errorTemporalUnavailable(codecId, operation);
+}
+function decodeTemporalText(identity, wire, parse, adapt) {
+	requireTemporal(identity.codecId, "decode");
+	if (POSTGRES_TEMPORAL_SENTINELS.has(wire)) throw errorTemporalUnrepresentable({
+		...identity,
+		operation: "decode",
+		value: wire,
+		detail: `PostgreSQL's ${wire} is a sentinel with no position on the timeline, so no Temporal value denotes it`
+	});
+	try {
+		return parse(adapt(wire));
+	} catch (cause) {
+		throw errorTemporalUnrepresentable({
+			...identity,
+			operation: "decode",
+			value: wire,
+			detail: cause instanceof Error ? cause.message : String(cause),
+			cause
+		});
+	}
+}
+function encodeTemporalValue(identity, value) {
+	requireTemporal(identity.codecId, "encode");
+	const tag = typeof value === "object" && value !== null ? Reflect.get(value, Symbol.toStringTag) : void 0;
+	if (tag !== identity.temporalTag) throw errorTemporalWrongType(identity.codecId, identity.temporalTag, identity.stringType, describeEncodeInput(value, tag));
+	if (value.calendarId !== void 0 && value.calendarId !== "iso8601") throw errorTemporalNonIsoCalendar(identity.codecId, value.calendarId);
+	return value.toString();
+}
+function describeEncodeInput(value, tag) {
+	if (typeof tag === "string") return `a ${tag}`;
+	if (value instanceof Date) return "a Date";
+	if (value === null) return "null";
+	return `a ${typeof value}`;
+}
+const DATE_TEMPORAL = {
+	codecId: PG_DATE_TEMPORAL_CODEC_ID,
+	stringType: "DateString",
+	temporalTag: "Temporal.PlainDate"
+};
+const TIMESTAMP_TEMPORAL = {
+	codecId: PG_TIMESTAMP_TEMPORAL_CODEC_ID,
+	stringType: "TimestampString(p)",
+	temporalTag: "Temporal.PlainDateTime"
+};
+const TIMESTAMPTZ_TEMPORAL = {
+	codecId: PG_TIMESTAMPTZ_TEMPORAL_CODEC_ID,
+	stringType: "TimestamptzString(p)",
+	temporalTag: "Temporal.Instant"
+};
+const TIME_TEMPORAL = {
+	codecId: PG_TIME_TEMPORAL_CODEC_ID,
+	stringType: "TimeString(p)",
+	temporalTag: "Temporal.PlainTime"
+};
+const unadapted = (text) => text;
+const pgDateTemporalDecode = (wire) => decodeTemporalText(DATE_TEMPORAL, wire, (t) => Temporal.PlainDate.from(t), adaptPostgresEra);
+const pgDateTemporalEncode = (value) => encodeTemporalValue(DATE_TEMPORAL, value);
+const pgTimestampTemporalDecode = (wire) => decodeTemporalText(TIMESTAMP_TEMPORAL, wire, (t) => Temporal.PlainDateTime.from(t), adaptPostgresEra);
+const pgTimestampTemporalEncode = (value) => encodeTemporalValue(TIMESTAMP_TEMPORAL, value);
+const pgTimestamptzTemporalDecode = (wire) => decodeTemporalText(TIMESTAMPTZ_TEMPORAL, wire, (t) => Temporal.Instant.from(t), adaptPostgresEra);
+const pgTimestamptzTemporalEncode = (value) => encodeTemporalValue(TIMESTAMPTZ_TEMPORAL, value);
+const pgTimeTemporalDecode = (wire) => decodeTemporalText(TIME_TEMPORAL, wire, (t) => Temporal.PlainTime.from(t), unadapted);
+const pgTimeTemporalEncode = (value) => encodeTemporalValue(TIME_TEMPORAL, value);
+var PgDateTemporalCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgDateTemporalEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return pgDateTemporalDecode(wire);
+	}
+	encodeJson(value) {
+		return pgDateTemporalEncode(value);
+	}
+	decodeJson(json) {
+		return pgDateTemporalDecode(blindCast(json));
+	}
+};
+var PgDateTemporalDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_DATE_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return CastExpr.as(expression, "text");
+	}
+	codecId = PG_DATE_TEMPORAL_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["date"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgDateTemporalCodec(this);
+	}
+};
+const pgDateTemporalDescriptor = new PgDateTemporalDescriptor();
+var PgTimestampTemporalCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgTimestampTemporalEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return pgTimestampTemporalDecode(wire);
+	}
+	encodeJson(value) {
+		return pgTimestampTemporalEncode(value);
+	}
+	decodeJson(json) {
+		return pgTimestampTemporalDecode(blindCast(json));
+	}
+};
+var PgTimestampTemporalDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TIMESTAMP_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return CastExpr.as(expression, "text");
+	}
+	codecId = PG_TIMESTAMP_TEMPORAL_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["timestamp"];
+	paramsSchema = precisionParamsSchema;
+	factory(_params) {
+		return () => new PgTimestampTemporalCodec(this);
+	}
+};
+const pgTimestampTemporalDescriptor = new PgTimestampTemporalDescriptor();
+var PgTimestamptzTemporalCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgTimestamptzTemporalEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return pgTimestamptzTemporalDecode(wire);
+	}
+	encodeJson(value) {
+		return pgTimestamptzTemporalEncode(value);
+	}
+	decodeJson(json) {
+		return pgTimestamptzTemporalDecode(blindCast(json));
+	}
+};
+var PgTimestamptzTemporalDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TIMESTAMPTZ_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return CastExpr.as(expression, "text");
+	}
+	codecId = PG_TIMESTAMPTZ_TEMPORAL_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["timestamptz"];
+	paramsSchema = precisionParamsSchema;
+	factory(_params) {
+		return () => new PgTimestamptzTemporalCodec(this);
+	}
+};
+const pgTimestamptzTemporalDescriptor = new PgTimestamptzTemporalDescriptor();
+var PgTimeTemporalCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgTimeTemporalEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return pgTimeTemporalDecode(wire);
+	}
+	encodeJson(value) {
+		return pgTimeTemporalEncode(value);
+	}
+	decodeJson(json) {
+		return pgTimeTemporalDecode(blindCast(json));
+	}
+};
+var PgTimeTemporalDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TIME_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return CastExpr.as(expression, "text");
+	}
+	codecId = PG_TIME_TEMPORAL_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["time"];
+	paramsSchema = precisionParamsSchema;
+	factory(_params) {
+		return () => new PgTimeTemporalCodec(this);
+	}
+};
+const pgTimeTemporalDescriptor = new PgTimeTemporalDescriptor();
+var PgDateStringCodec = 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 PgDateStringDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_DATE_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return CastExpr.as(expression, "text");
+	}
+	codecId = PG_DATE_STRING_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = [];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgDateStringCodec(this);
+	}
+};
+const pgDateStringDescriptor = new PgDateStringDescriptor();
+var PgTimestampStringCodec = 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 PgTimestampStringDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TIMESTAMP_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return CastExpr.as(expression, "text");
+	}
+	codecId = PG_TIMESTAMP_STRING_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = [];
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("TimestampString", params);
+	}
+	factory(_params) {
+		return () => new PgTimestampStringCodec(this);
+	}
+};
+const pgTimestampStringDescriptor = new PgTimestampStringDescriptor();
+var PgTimestamptzStringCodec = 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 PgTimestamptzStringDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TIMESTAMPTZ_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return CastExpr.as(expression, "text");
+	}
+	codecId = PG_TIMESTAMPTZ_STRING_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = [];
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("TimestamptzString", params);
+	}
+	factory(_params) {
+		return () => new PgTimestamptzStringCodec(this);
+	}
+};
+const pgTimestamptzStringDescriptor = new PgTimestamptzStringDescriptor();
+var PgTimeStringCodec = 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 PgTimeStringDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_TIME_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return CastExpr.as(expression, "text");
+	}
+	codecId = PG_TIME_STRING_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = [];
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("TimeString", params);
+	}
+	factory(_params) {
+		return () => new PgTimeStringCodec(this);
+	}
+};
+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"
 });
-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";
@@ -374,10 +625,6 @@ 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";
@@ -444,17 +691,6 @@ const base64JsonProjection = (expression) => FunctionCallExpr.of("translate", [
 	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)),
@@ -523,10 +759,6 @@ 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;
@@ -1099,145 +1331,6 @@ var PgUnboundedIntDescriptor = class extends PostgresCodecDescriptor {
 };
 const pgUnboundedIntDescriptor = new PgUnboundedIntDescriptor();
 const pgUnboundedIntColumn = () => column(pgUnboundedIntDescriptor.factory(), pgUnboundedIntDescriptor.codecId, void 0, "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;
@@ -1643,7 +1736,6 @@ const codecDescriptors = definePostgresCodecs([
 	postgresSqlIntDescriptor,
 	postgresSqlFloatDescriptor,
 	postgresSqlTextDescriptor,
-	postgresSqlTimestampDescriptor,
 	pgTextDescriptor,
 	pgEnumDescriptor,
 	pgCharDescriptor,
@@ -1658,10 +1750,14 @@ const codecDescriptors = definePostgresCodecs([
 	pgFloat8Descriptor,
 	pgNumericDescriptor,
 	pgUnboundedIntDescriptor,
-	pgDateDescriptor,
-	pgTimestampDescriptor,
-	pgTimestamptzDescriptor,
-	pgTimeDescriptor,
+	pgDateTemporalDescriptor,
+	pgTimestampTemporalDescriptor,
+	pgTimestamptzTemporalDescriptor,
+	pgTimeTemporalDescriptor,
+	pgDateStringDescriptor,
+	pgTimestampStringDescriptor,
+	pgTimestamptzStringDescriptor,
+	pgTimeStringDescriptor,
 	pgTimetzDescriptor,
 	pgBoolDescriptor,
 	pgBitDescriptor,
@@ -1675,6 +1771,6 @@ const codecDescriptors = definePostgresCodecs([
 	pgTextArrayDescriptor
 ]);
 //#endregion
-export { postgresQualifyColumnType as A, pgTimestampColumn as C, pgUuidColumn as D, pgUnboundedIntColumn as E, pgVarbitColumn as O, pgTimeColumn as S, pgTimetzColumn as T, pgIntervalColumn as _, pgCharColumn as a, pgNumericColumn as b, pgFloat4Column as c, pgInetColumn as d, pgInt2Column as f, pgIntColumn as g, pgInt8NumberColumn as h, pgBoolColumn as i, pgVarcharColumn as k, 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, pgJsonColumn as v, pgTimestamptzColumn as w, pgTextColumn as x, pgJsonbColumn as y };
+export { pgUuidColumn as C, postgresQualifyColumnType as E, pgUnboundedIntColumn as S, pgVarcharColumn as T, pgJsonColumn as _, pgCharColumn as a, pgTextColumn as b, pgFloat8Column as c, pgInt2Column as d, pgInt4Column as f, pgIntervalColumn as g, pgIntColumn as h, pgBoolColumn as i, pgFloatColumn as l, pgInt8NumberColumn as m, isPgEnumParams as n, pgEnumDescriptor as o, pgInt8Column as p, pgBitColumn as r, pgFloat4Column as s, codecDescriptors as t, pgInetColumn as u, pgJsonbColumn as v, pgVarbitColumn as w, pgTimetzColumn as x, pgNumericColumn as y };
 
-//# sourceMappingURL=codecs-BmPCJWqb-DveZGJvm.mjs.map
+//# sourceMappingURL=codecs-CxWg7WrX-DtVAuuXA.mjs.map