@prisma-next/target-postgres 0.14.0-dev.51 → 0.14.0-dev.53

package/dist/codecs.mjs

@@ -1,882 +1,13 @@
-import { C as PG_UUID_CODEC_ID, S as PG_TIME_CODEC_ID, T as PG_VARCHAR_CODEC_ID, _ as PG_TEXT_ARRAY_CODEC_ID, a as PG_ENUM_CODEC_ID, b as PG_TIMESTAMP_CODEC_ID, c as PG_FLOAT_CODEC_ID, d as PG_INT8_CODEC_ID, f as PG_INTERVAL_CODEC_ID, g as PG_NUMERIC_CODEC_ID, h as PG_JSON_CODEC_ID, i as PG_CHAR_CODEC_ID, l as PG_INT2_CODEC_ID, m as PG_JSONB_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT4_CODEC_ID, p as PG_INT_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_FLOAT8_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT4_CODEC_ID, v as PG_TEXT_CODEC_ID, w as PG_VARBIT_CODEC_ID, x as PG_TIMETZ_CODEC_ID, y as PG_TIMESTAMPTZ_CODEC_ID } from "./codec-ids-C_-Hj6bL.mjs";
-import "./namespace-ids-xtp_ZY86.mjs";
-import { t as PostgresNativeEnum } from "./postgres-native-enum-xdiqmBf_.mjs";
-import { SqlCharCodec, SqlFloatCodec, SqlIntCodec, SqlVarcharCodec, sqlCharDescriptor, sqlFloatDescriptor, sqlIntDescriptor, sqlTextDescriptor, sqlTimestampDescriptor, sqlVarcharDescriptor } from "@prisma-next/sql-relational-core/ast";
-import { CodecDescriptorImpl, CodecImpl, column, renderTsLiteral, voidParamsSchema } from "@prisma-next/framework-components/codec";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { blindCast } from "@prisma-next/utils/casts";
-import { type } from "arktype";
+import { C as pgVarbitColumn, S as pgUuidColumn, _ as pgTextColumn, a as pgEnumDescriptor, b as pgTimestamptzColumn, c as pgFloatColumn, d as pgInt8Column, f as pgIntColumn, g as pgNumericColumn, h as pgJsonbColumn, i as pgCharColumn, l as pgInt2Column, m as pgJsonColumn, n as pgBitColumn, o as pgFloat4Column, p as pgIntervalColumn, r as pgBoolColumn, s as pgFloat8Column, t as codecDescriptors, u as pgInt4Column, v as pgTimeColumn, w as pgVarcharColumn, x as pgTimetzColumn, y as pgTimestampColumn } from "./codecs-CkVQrZ4G.mjs";
 import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
-//#region src/core/codec-helpers.ts
-function renderLength(typeName, typeParams) {
-	const length = typeParams["length"];
-	if (length === void 0) return;
-	if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected integer "length" in typeParams for ${typeName}, got ${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 new Error(`renderOutputType: expected integer "precision" in typeParams for ${typeName}, got ${String(precision)}`);
-	return `${typeName}<${precision}>`;
-}
-const pgNumericDecode = (wire) => {
-	if (typeof wire === "number") return String(wire);
-	return wire;
-};
-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 new Error(`renderOutputType: expected integer "precision" in typeParams for Numeric, got ${String(precision)}`);
-	const scale = typeParams.scale;
-	if (scale === void 0) return `Numeric<${precision}>`;
-	if (typeof scale !== "number" || !Number.isFinite(scale) || !Number.isInteger(scale)) throw new Error(`renderOutputType: expected integer "scale" in typeParams for Numeric, got ${String(scale)}`);
-	return `Numeric<${precision}, ${scale}>`;
-};
-const ISO_8601_UTC = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/;
-const pgTimestampEncodeJson = (value) => value.toISOString();
-const pgTimestampDecodeJson = (json) => {
-	if (typeof json !== "string") throw new Error(`Expected ISO date string for pg/timestamp@1, got ${typeof json}`);
-	if (!ISO_8601_UTC.test(json)) throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);
-	const date = new Date(json);
-	if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);
-	return date;
-};
-const pgTimestamptzEncodeJson = (value) => value.toISOString();
-const pgTimestamptzDecodeJson = (json) => {
-	if (typeof json !== "string") throw new Error(`Expected ISO date string for pg/timestamptz@1, got ${typeof json}`);
-	if (!ISO_8601_UTC.test(json)) throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);
-	const date = new Date(json);
-	if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);
-	return date;
-};
-const pgIntervalDecode = (wire) => {
-	if (typeof wire === "string") return wire;
-	return JSON.stringify(wire);
-};
-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;
-//#endregion
-//#region src/core/codecs.ts
-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_META = { db: { sql: { postgres: { nativeType: "text" } } } };
-const PG_TEXT_ARRAY_META = { db: { sql: { postgres: { nativeType: "text[]" } } } };
-const PG_INT4_META = { db: { sql: { postgres: { nativeType: "integer" } } } };
-const PG_INT2_META = { db: { sql: { postgres: { nativeType: "smallint" } } } };
-const PG_INT8_META = { db: { sql: { postgres: { nativeType: "bigint" } } } };
-const PG_FLOAT4_META = { db: { sql: { postgres: { nativeType: "real" } } } };
-const PG_FLOAT8_META = { db: { sql: { postgres: { nativeType: "double precision" } } } };
-const PG_NUMERIC_META = { db: { sql: { postgres: { nativeType: "numeric" } } } };
-const PG_TIMESTAMP_META = { db: { sql: { postgres: { nativeType: "timestamp without time zone" } } } };
-const PG_TIMESTAMPTZ_META = { db: { sql: { postgres: { nativeType: "timestamp with time zone" } } } };
-const PG_TIME_META = { db: { sql: { postgres: { nativeType: "time" } } } };
-const PG_TIMETZ_META = { db: { sql: { postgres: { nativeType: "timetz" } } } };
-const PG_BOOL_META = { db: { sql: { postgres: { nativeType: "boolean" } } } };
-const PG_BIT_META = { db: { sql: { postgres: { nativeType: "bit" } } } };
-const PG_VARBIT_META = { db: { sql: { postgres: { nativeType: "bit varying" } } } };
-const PG_BYTEA_META = { db: { sql: { postgres: { nativeType: "bytea" } } } };
-const PG_INTERVAL_META = { db: { sql: { postgres: { nativeType: "interval" } } } };
-const PG_JSON_META = { db: { sql: { postgres: { nativeType: "json" } } } };
-const PG_JSONB_META = { db: { sql: { postgres: { nativeType: "jsonb" } } } };
-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 CodecDescriptorImpl {
-	codecId = PG_TEXT_CODEC_ID;
-	traits = [
-		"equality",
-		"order",
-		"textual"
-	];
-	targetTypes = ["text"];
-	meta = PG_TEXT_META;
-	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);
-	}
-};
-const pgEnumParamsSchema = type({ typeName: "string" });
-function isJsonObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var PgEnumDescriptor = class extends CodecDescriptorImpl {
-	codecId = PG_ENUM_CODEC_ID;
-	traits = [
-		"equality",
-		"order",
-		"textual"
-	];
-	targetTypes = ["text"];
-	meta = PG_TEXT_META;
-	paramsSchema = pgEnumParamsSchema;
-	renderValueLiteral(value) {
-		return renderTsLiteral(value);
-	}
-	metaFor(typeParams) {
-		if (!isJsonObject(typeParams)) return this.meta;
-		const typeName = typeParams["typeName"];
-		return typeof typeName === "string" ? { db: { sql: { postgres: { nativeType: typeName } } } } : this.meta;
-	}
-	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: given
-	* that entity and the field's namespace id, produces this codec's
-	* per-column `typeParams` and native type. The type name is schema-qualified
-	* for a named non-default schema (matching `format_type()`); `public` and
-	* the unbound namespace stay bare (`search_path`). `nativeType` mirrors
-	* `typeParams.typeName` — the same value {@link metaFor} 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, namespaceId) {
-		if (!PostgresNativeEnum.is(entity)) return void 0;
-		const typeName = namespaceId !== void 0 && namespaceId !== "public" && namespaceId !== UNBOUND_NAMESPACE_ID ? `${namespaceId}.${entity.typeName}` : entity.typeName;
-		return {
-			typeParams: { typeName },
-			nativeType: typeName
-		};
-	}
-};
-const pgEnumDescriptor = new PgEnumDescriptor();
-/**
-* 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 CodecDescriptorImpl {
-	codecId = PG_TEXT_ARRAY_CODEC_ID;
-	traits = ["equality"];
-	targetTypes = ["text[]"];
-	meta = PG_TEXT_ARRAY_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_INT4_CODEC_ID;
-	traits = [
-		"equality",
-		"order",
-		"numeric"
-	];
-	targetTypes = ["int4"];
-	meta = PG_INT4_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_INT2_CODEC_ID;
-	traits = [
-		"equality",
-		"order",
-		"numeric"
-	];
-	targetTypes = ["int2"];
-	meta = PG_INT2_META;
-	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");
-var PgInt8Codec = class extends CodecImpl {
-	async encode(value, _ctx) {
-		return value;
-	}
-	async decode(wire, _ctx) {
-		return wire;
-	}
-	encodeJson(value) {
-		return value;
-	}
-	decodeJson(json) {
-		return json;
-	}
-};
-var PgInt8Descriptor = class extends CodecDescriptorImpl {
-	codecId = PG_INT8_CODEC_ID;
-	traits = [
-		"equality",
-		"order",
-		"numeric"
-	];
-	targetTypes = ["int8"];
-	meta = PG_INT8_META;
-	paramsSchema = voidParamsSchema;
-	renderValueLiteral(value) {
-		return renderTsLiteral(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 CodecDescriptorImpl {
-	codecId = PG_FLOAT4_CODEC_ID;
-	traits = [
-		"equality",
-		"order",
-		"numeric"
-	];
-	targetTypes = ["float4"];
-	meta = PG_FLOAT4_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_FLOAT8_CODEC_ID;
-	traits = [
-		"equality",
-		"order",
-		"numeric"
-	];
-	targetTypes = ["float8"];
-	meta = PG_FLOAT8_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_BOOL_CODEC_ID;
-	traits = ["equality", "boolean"];
-	targetTypes = ["bool"];
-	meta = PG_BOOL_META;
-	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) {
-		return value;
-	}
-	decodeJson(json) {
-		return json;
-	}
-};
-var PgNumericDescriptor = class extends CodecDescriptorImpl {
-	codecId = PG_NUMERIC_CODEC_ID;
-	traits = [
-		"equality",
-		"order",
-		"numeric"
-	];
-	targetTypes = ["numeric", "decimal"];
-	meta = PG_NUMERIC_META;
-	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");
-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 CodecDescriptorImpl {
-	codecId = PG_TIMESTAMP_CODEC_ID;
-	traits = ["equality", "order"];
-	targetTypes = ["timestamp"];
-	meta = PG_TIMESTAMP_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_TIMESTAMPTZ_CODEC_ID;
-	traits = ["equality", "order"];
-	targetTypes = ["timestamptz"];
-	meta = PG_TIMESTAMPTZ_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_TIME_CODEC_ID;
-	traits = ["equality", "order"];
-	targetTypes = ["time"];
-	meta = PG_TIME_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_TIMETZ_CODEC_ID;
-	traits = ["equality", "order"];
-	targetTypes = ["timetz"];
-	meta = PG_TIMETZ_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_BIT_CODEC_ID;
-	traits = ["equality", "order"];
-	targetTypes = ["bit"];
-	meta = PG_BIT_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_VARBIT_CODEC_ID;
-	traits = ["equality", "order"];
-	targetTypes = ["bit varying"];
-	meta = PG_VARBIT_META;
-	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 Buffer.from(value).toString("base64");
-	}
-	decodeJson(json) {
-		if (typeof json !== "string") throw new Error(`Expected base64 string for pg/bytea@1, got ${typeof json}`);
-		const decoded = Buffer.from(json, "base64");
-		if (decoded.toString("base64") !== json) throw new Error(`Invalid base64 string for pg/bytea@1 (length: ${json.length})`);
-		return new Uint8Array(decoded);
-	}
-};
-var PgByteaDescriptor = class extends CodecDescriptorImpl {
-	codecId = PG_BYTEA_CODEC_ID;
-	traits = ["equality"];
-	targetTypes = ["bytea"];
-	meta = PG_BYTEA_META;
-	paramsSchema = voidParamsSchema;
-	factory() {
-		return () => new PgByteaCodec(this);
-	}
-};
-const pgByteaDescriptor = new PgByteaDescriptor();
-const PG_UUID_META = { db: { sql: { postgres: { nativeType: "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 CodecDescriptorImpl {
-	codecId = PG_UUID_CODEC_ID;
-	traits = ["equality", "order"];
-	targetTypes = ["uuid"];
-	meta = PG_UUID_META;
-	paramsSchema = voidParamsSchema;
-	factory() {
-		return () => new PgUuidCodec(this);
-	}
-};
-const pgUuidDescriptor = new PgUuidDescriptor();
-const pgUuidColumn = () => column(pgUuidDescriptor.factory(), pgUuidDescriptor.codecId, void 0, "uuid");
-var PgIntervalCodec = class extends CodecImpl {
-	async encode(value, _ctx) {
-		return value;
-	}
-	async decode(wire, _ctx) {
-		return pgIntervalDecode(wire);
-	}
-	encodeJson(value) {
-		return value;
-	}
-	decodeJson(json) {
-		return json;
-	}
-};
-var PgIntervalDescriptor = class extends CodecDescriptorImpl {
-	codecId = PG_INTERVAL_CODEC_ID;
-	traits = ["equality", "order"];
-	targetTypes = ["interval"];
-	meta = PG_INTERVAL_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_JSON_CODEC_ID;
-	traits = [];
-	targetTypes = ["json"];
-	meta = PG_JSON_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_JSONB_CODEC_ID;
-	traits = ["equality"];
-	targetTypes = ["jsonb"];
-	meta = PG_JSONB_META;
-	paramsSchema = voidParamsSchema;
-	factory() {
-		return () => new PgJsonbCodec(this);
-	}
-};
-const pgJsonbDescriptor = new PgJsonbDescriptor();
-const pgJsonbColumn = () => column(pgJsonbDescriptor.factory(), pgJsonbDescriptor.codecId, void 0, "jsonb");
-const PG_CHAR_META = { db: { sql: { postgres: { nativeType: "character" } } } };
-const PG_VARCHAR_META = { db: { sql: { postgres: { nativeType: "character varying" } } } };
-const PG_INT_META = { db: { sql: { postgres: { nativeType: "integer" } } } };
-const PG_FLOAT_META = { db: { sql: { postgres: { nativeType: "double precision" } } } };
-var PgCharDescriptor = class extends CodecDescriptorImpl {
-	codecId = PG_CHAR_CODEC_ID;
-	targetTypes = ["character"];
-	meta = PG_CHAR_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_VARCHAR_CODEC_ID;
-	targetTypes = ["character varying"];
-	meta = PG_VARCHAR_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_INT_CODEC_ID;
-	targetTypes = ["int4"];
-	meta = PG_INT_META;
-	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 CodecDescriptorImpl {
-	codecId = PG_FLOAT_CODEC_ID;
-	targetTypes = ["float8"];
-	meta = PG_FLOAT_META;
-	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");
-//#endregion
 //#region src/core/registry.ts
 /**
 * Registry of every codec descriptor shipped by `@prisma-next/target-postgres`.
 *
 * Public consumer surface for the postgres codec set: the postgres adapter and any other consumer that needs to enumerate or look up a postgres codec by id consumes this rather than the raw descriptor array. See ADR 208.
 */
-const postgresCodecRegistry = buildCodecDescriptorRegistry([
-	sqlCharDescriptor,
-	sqlVarcharDescriptor,
-	sqlIntDescriptor,
-	sqlFloatDescriptor,
-	sqlTextDescriptor,
-	sqlTimestampDescriptor,
-	pgTextDescriptor,
-	pgEnumDescriptor,
-	pgCharDescriptor,
-	pgVarcharDescriptor,
-	pgIntDescriptor,
-	pgFloatDescriptor,
-	pgInt4Descriptor,
-	pgInt2Descriptor,
-	pgInt8Descriptor,
-	pgFloat4Descriptor,
-	pgFloat8Descriptor,
-	pgNumericDescriptor,
-	pgTimestampDescriptor,
-	pgTimestamptzDescriptor,
-	pgTimeDescriptor,
-	pgTimetzDescriptor,
-	pgBoolDescriptor,
-	pgBitDescriptor,
-	pgVarbitDescriptor,
-	pgByteaDescriptor,
-	pgUuidDescriptor,
-	pgIntervalDescriptor,
-	pgJsonDescriptor,
-	pgJsonbDescriptor,
-	pgTextArrayDescriptor
-]);
+const postgresCodecRegistry = buildCodecDescriptorRegistry(codecDescriptors);
 //#endregion
-export { pgBitColumn, pgBoolColumn, pgCharColumn, pgFloat4Column, pgFloat8Column, pgFloatColumn, pgInt2Column, pgInt4Column, pgInt8Column, pgIntColumn, pgIntervalColumn, pgJsonColumn, pgJsonbColumn, pgNumericColumn, pgTextColumn, pgTimeColumn, pgTimestampColumn, pgTimestamptzColumn, pgTimetzColumn, pgUuidColumn, pgVarbitColumn, pgVarcharColumn, postgresCodecRegistry };
+export { pgBitColumn, pgBoolColumn, pgCharColumn, pgEnumDescriptor, pgFloat4Column, pgFloat8Column, pgFloatColumn, pgInt2Column, pgInt4Column, pgInt8Column, pgIntColumn, pgIntervalColumn, pgJsonColumn, pgJsonbColumn, pgNumericColumn, pgTextColumn, pgTimeColumn, pgTimestampColumn, pgTimestamptzColumn, pgTimetzColumn, pgUuidColumn, pgVarbitColumn, pgVarcharColumn, postgresCodecRegistry };
 
 //# sourceMappingURL=codecs.mjs.map