@prisma/orm-target-postgres 8.0.0-rc.14-dev.5 → 8.0.0-rc.14-dev.7

package/dist/{control-w3p4NYNx.mjs → control-CYQReJto.mjs}

@@ -1,31 +1,31 @@
 import { C as PG_TIMESTAMPTZ_DATE_CODEC_ID, D as PG_TIMESTAMP_TEMPORAL_CODEC_ID, E as PG_TIMESTAMP_STRING_CODEC_ID, S as PG_TEXT_CODEC_ID, T as PG_TIMESTAMPTZ_TEMPORAL_CODEC_ID, s as PG_ENUM_CODEC_ID, w as PG_TIMESTAMPTZ_STRING_CODEC_ID } from "./codec-ids-Cb0yO-IS--e0P2rfI.mjs";
-import { i as isPostgresCodecDescriptor } from "./codec-descriptor-BfoHQP3R-CMRVT-F6.mjs";
+import { i as isPostgresCodecDescriptor } from "./codec-descriptor-B61d-k4C-BdWVU6Fu.mjs";
 import { s as postgresError } from "./errors-DYyzTYzE-39CV_aMo.mjs";
 import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86-Cpp8PTxD.mjs";
 import { t as PostgresNativeEnum } from "./postgres-native-enum-CdP3b_-R-Cgz9KEKx.mjs";
-import { M as setFallbackTemporal } from "./codecs-DQGmsnk3-H6nVRPCC.mjs";
+import { P as setFallbackTemporal, n as NUMERIC_SCALE_RANGE, t as NUMERIC_PRECISION_RANGE } from "./codecs-BHNqtI1J-BSS9sL3H.mjs";
 import { i as PostgresRlsPolicy, n as PostgresRlsEnablement, o as PostgresRole } from "./postgres-schema-yugFGBdS-5cY1PCmb.mjs";
-import { n as postgresResolveDefault } from "./default-normalizer-Bp3IhMR9-D0uYVRLZ.mjs";
+import { n as postgresResolveDefault } from "./default-normalizer-Cb7nWBUa-DXchlOUk.mjs";
 import { n as computeContentHash } from "./canonicalize-CrN3u_xM-D4MrOqcB.mjs";
-import { m as postgresNowGeneratorIdFor, r as POLICY_BLOCK_KEYWORDS } from "./authoring-BmQxOggr-CK871YR4.mjs";
+import { m as postgresNowGeneratorIdFor, r as POLICY_BLOCK_KEYWORDS } from "./authoring-DKN1ccEX-DgmJWx1r.mjs";
 import { t as postgresRenderCheckExpressions } from "./check-expressions-DLCs-SXx-itMQrUsX.mjs";
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-BOx9pvBv-C4TEXck8.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DF0hODA0-DnO80XvH.mjs";
 import { a as postgresDiffSubjectGranularity, i as postgresDiffSubjectEntityKind } from "./postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs";
 import { t as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-B8Z5i5D--PObwlU2Z.mjs";
-import { a as renderDefaultLiteral } from "./planner-ddl-builders-GTcVPpwb-ClvrXb26.mjs";
-import { n as contractToPostgresDatabaseSchemaNode, r as diffPostgresSchema } from "./diff-database-schema-BP4uAPZZ-8ljuCPav.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-view-DxcRT-qe-LQBHHgaS.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-Brs7-1mt-BFtbE0Tl.mjs";
-import { a as buildMapAttribute, d as inferPostgresPslContract, f as namedArg, i as buildIndexAttribute, m as positionalArg, n as buildAttribute, o as buildModelConstraintAttribute, p as parseDefaultAttributeString, r as buildCheckAttribute, s as buildNativeEnumBlock, t as SYNTHETIC_SPAN, u as createPostgresTypeMap } from "./infer-psl-contract-MVBnqkl3-Bffp5RpV.mjs";
+import { i as renderDefaultLiteral } from "./planner-ddl-builders-iE35pyxA-g7b_clbn.mjs";
+import { i as diffPostgresSchema, r as contractToPostgresDatabaseSchemaNode, t as buildPostgresNativeTypeExpander } from "./diff-database-schema-MYPfxeRf-DdgnOIIl.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-view-BBMpf_qi-8V4vTm9U.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-DMVaXRSK-DCAGfALs.mjs";
+import { a as buildMapAttribute, d as inferPostgresPslContract, f as namedArg, h as positionalArg, i as buildIndexAttribute, m as parseDefaultAttributeString, n as buildAttribute, o as buildModelConstraintAttribute, r as buildCheckAttribute, s as buildNativeEnumBlock, t as SYNTHETIC_SPAN, u as createPostgresTypeMap } from "./infer-psl-contract-D7XJnfJv-Cd_Mf0UH.mjs";
 import { escapePslString } from "@prisma/orm-family-sql/relational-core/ast";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
-import { StorageColumn } from "@prisma/orm-family-sql/contract/types";
+import { StorageColumn, resolvedTypeParams } from "@prisma/orm-family-sql/contract/types";
 import { APP_SPACE_ID } from "@prisma/orm-framework/components/control";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { composeCheckWirePrefix, computeCheckContentHash, computeIndexContentHash, formatWireName } from "@prisma/orm-family-sql/schema-ir/naming";
 import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
-import { buildDataTypeResolver, buildNativeTypeExpander, runnerFailure, runnerSuccess } from "@prisma/orm-family-sql/family/control";
+import { buildDataTypeResolver, runnerFailure, runnerSuccess } from "@prisma/orm-family-sql/family/control";
 import { findAuthoringTypeConstructorCall } from "@prisma/orm-framework/components/authoring";
 import { NAME_THE_PSL_SOURCE_LOSES, isPslIdentifier } from "@prisma/orm-framework/psl-parser";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
@@ -580,26 +580,26 @@ function refuseUnwrittenExecutionDefaults(contract, written) {
 	}
 }
 /**
-* The value-set references the PSL source gives a field typed by a domain enum and its column: the
-* column names the enum's value set, and a field that is not a list names the enum, both in the
-* default namespace. A field with no domain enum has neither.
+* The value-set references the PSL source gives a field typed by a domain enum, one per plane: the
+* domain names the enum and the storage column names the enum's value set, both in the default
+* namespace. A field with no domain enum has neither.
 */
-function derivedValueSetRefs(enumName, list) {
+function derivedValueSetRefs(enumName) {
 	if (enumName === void 0) return {
-		field: void 0,
-		column: void 0
+		domain: void 0,
+		storage: void 0
 	};
 	const common = {
 		namespaceId: DEFAULT_NAMESPACE_ID,
 		entityName: enumName
 	};
 	return {
-		field: list ? void 0 : {
+		domain: {
 			plane: "domain",
 			entityKind: "enum",
 			...common
 		},
-		column: {
+		storage: {
 			plane: "storage",
 			entityKind: "valueSet",
 			...common
@@ -614,18 +614,19 @@ function derivedValueSetRefs(enumName, list) {
 function refuseFieldColumnMismatch(input) {
 	const { field, column, coordinate } = input;
 	const fix = "Make the field and its column agree, or keep authoring this contract in its current source.";
+	const fixForEarlierRelease = `If an earlier release emitted this contract, emit it again. ${fix}`;
 	if (input.singleTableVariant && !column.nullable) throw unsupported(`column ${coordinate} of single-table variant "${input.modelName}" is not nullable, which cannot be written in Prisma 8 PSL.`, "The PSL source makes every column of a single-table variant nullable, because the base's other rows leave it empty.", fix, { coordinate });
 	if (!input.singleTableVariant && field.nullable !== column.nullable) throw unsupported(`field ${coordinate} is ${field.nullable ? "optional" : "required"} but its column is ${column.nullable ? "nullable" : "not nullable"}, which cannot be written in Prisma 8 PSL.`, "PSL writes `?` once, and the PSL source derives the column from the field.", fix, { coordinate });
 	if ((field.type.kind === "scalar" && field.many === true) !== (column.many === true)) throw unsupported(`field ${coordinate} is ${field.many === true ? "a list" : "not a list"} but its column is ${column.many === true ? "a list" : "not a list"}, which cannot be written in Prisma 8 PSL.`, "PSL writes `[]` once: the PSL source stores a list of scalars in a list column, and a list of value objects in one JSON column.", fix, { coordinate });
-	if (field.type.kind === "scalar" && (field.type.codecId !== column.codecId || !sameJson(field.type.typeParams, column.typeParams))) throw unsupported(`field ${coordinate} has a different codec or type parameters from its column, which cannot be written in Prisma 8 PSL.`, "The PSL source derives a scalar field's codec and type parameters from its column.", fix, { coordinate });
+	if (field.type.kind === "scalar" && (field.type.codecId !== column.codecId || !sameJson(resolvedTypeParams(field.type, void 0), resolvedTypeParams(column, input.namedTypes)))) throw unsupported(`field ${coordinate} has a different codec or type parameters from its column, which cannot be written in Prisma 8 PSL.`, "The PSL source derives a scalar field's codec and type parameters from its column.", fixForEarlierRelease, { coordinate });
 	if (field.type.kind !== "scalar" || column.codecId === "pg/enum@1") return;
 	const enumName = column.valueSet?.entityName;
-	const derived = derivedValueSetRefs(enumName, field.many === true);
-	if (!sameJson(field.valueSet, derived.field) || !sameJson(column.valueSet, derived.column) || enumName !== void 0 && !input.domainEnumNames.has(enumName)) throw unsupported(`field ${coordinate} and its column do not name the enum of the default namespace and its value set that the PSL source derives for a field typed by an enum, which cannot be written in Prisma 8 PSL.`, "PSL types the field by the enum name, and the PSL source then points the column at the value set of that enum in the default namespace, and a field that is not a list at the enum.", fix, { coordinate });
+	const derived = derivedValueSetRefs(enumName);
+	if (!sameJson(field.valueSet, derived.domain) || !sameJson(column.valueSet, derived.storage) || enumName !== void 0 && !input.domainEnumNames.has(enumName)) throw unsupported(`field ${coordinate} and its column do not name the enum of the default namespace and its value set that the PSL source derives for a field typed by an enum, which cannot be written in Prisma 8 PSL.`, "PSL types the field by the enum name, and the PSL source then points the column at the value set of that enum in the default namespace, and the field at the enum.", fixForEarlierRelease, { coordinate });
 }
 /**
 * Refuses a field PSL has no form for: one whose type is a union of types, or one that is a
-* dictionary. Runs for model fields and value-object fields alike.
+* dictionary. Runs for model fields and value-object members alike.
 */
 function refuseUnwritableFieldShape(field, coordinate) {
 	if (field.type.kind === "union") throw unsupported(`field ${coordinate} has a ${field.type.kind} type, which cannot be written in Prisma 8 PSL.`, "A PSL field names one scalar, enum, or value-object type; a union of types has no PSL form.", "Give the field a single type, or keep authoring this contract in its current source.", {
@@ -636,21 +637,24 @@ function refuseUnwritableFieldShape(field, coordinate) {
 	throw unsupported(`field ${coordinate} is a dictionary, which cannot be written in Prisma 8 PSL.`, "PSL writes a field as one value or a list; it has no form for a keyed dictionary.", KEEP_SOURCE, { coordinate });
 }
 /**
-* Refuses a value-object field with type parameters or a value set: the PSL source keeps only the
-* codec of a value-object field's type, so either would be lost.
+* Refuses a value-object member with a value set other than the one the PSL source derives for a member typed by an enum: the enum of the default namespace, with the enum's codec and no type parameters.
 */
-function refuseValueObjectFieldPartsTheSourceDrops(field, coordinate) {
-	if (Object.keys(field.type.typeParams ?? {}).length === 0 && field.valueSet === void 0) return;
-	throw unsupported(`value-object field ${coordinate} carries type parameters or a value set, which cannot be written in Prisma 8 PSL.`, "The PSL source keeps only the codec of a value-object field's type, so its type parameters and value set would be lost.", KEEP_SOURCE, { coordinate });
-}
-function refuseValueObjectFieldCodecWithoutNativeType(codecId, coordinate) {
-	throw unsupported(`field ${coordinate} uses codec "${codecId}", which no Postgres codec in the configured stack names a native type for.`, "A value-object field has no storage column, so its PSL type is derived from the native type its codec names.", KEEP_SOURCE, {
+function refuseUnderivedMemberValueSet(input) {
+	const { field, type, coordinate } = input;
+	const { valueSet } = field;
+	if (valueSet === void 0) return;
+	const domainEnum = input.domainEnums[valueSet.entityName];
+	if (sameJson(valueSet, derivedValueSetRefs(valueSet.entityName).domain) && domainEnum?.codecId === type.codecId && type.typeParams === void 0) return;
+	throw unsupported(`value-object member ${coordinate} carries a value set other than an enum of the default namespace with that enum's codec and no type parameters, which cannot be written in Prisma 8 PSL.`, "PSL types the member by the enum name, and the PSL source then points the member at that enum in the default namespace and gives it the enum's codec.", KEEP_SOURCE, { coordinate });
+}
+function refuseMemberCodecWithoutNativeType(codecId, coordinate) {
+	throw unsupported(`value-object member ${coordinate} uses codec "${codecId}", which no Postgres codec in the configured stack names a native type for.`, "A value-object member has no storage column, so its PSL type is derived from the native type its codec names.", KEEP_SOURCE, {
 		coordinate,
 		codecId
 	});
 }
-function refuseValueObjectFieldCodecNeedingTypeParameters(codecId, coordinate) {
-	throw unsupported(`field ${coordinate} uses codec "${codecId}", which names a native type only from type parameters, and the PSL source keeps none on a value-object field.`, "The PSL source keeps only the codec of a value-object field's type, so a codec that needs type parameters cannot be written there.", KEEP_SOURCE, {
+function refuseMemberCodecNeedingTypeParameters(codecId, coordinate) {
+	throw unsupported(`value-object member ${coordinate} uses codec "${codecId}", which names a native type only from type parameters the member does not carry.`, "A value-object member has no storage column, so its PSL type is derived from the native type its codec names for its type parameters.", KEEP_SOURCE, {
 		coordinate,
 		codecId
 	});
@@ -1186,39 +1190,42 @@ function buildColumnType(input) {
 	if (call !== void 0) return typeCall(call.path, call.args.map((value) => typeArgumentText(value, coordinate)));
 	refuseColumnWithoutPslType(column, coordinate);
 }
-/**
-* The native type the stack's codec names for a value-object field. The field has no column of its
-* own, and no type parameters, which the PSL source would not keep.
-*/
-function nativeTypeOfValueObjectField(field, coordinate, context) {
-	const { codecId } = field.type;
-	const descriptor = context.codecLookup.descriptorFor?.(codecId);
-	if (!isPostgresCodecDescriptor(descriptor)) refuseValueObjectFieldCodecWithoutNativeType(codecId, coordinate);
+/** The native type the stack's codec names for a value-object member, which has no column of its own. */
+function nativeTypeOfMember(type, coordinate, context) {
+	const { codecId } = type;
+	const descriptor = context.codecLookup.descriptorFor(codecId);
+	if (!isPostgresCodecDescriptor(descriptor)) refuseMemberCodecWithoutNativeType(codecId, coordinate);
+	const typeParams = resolvedTypeParams(type, void 0);
+	if (typeParams !== void 0) return descriptor.nativeTypeFor({
+		codecId,
+		typeParams: blindCast(typeParams)
+	});
 	try {
 		return descriptor.nativeTypeFor({ codecId });
 	} catch {
-		refuseValueObjectFieldCodecNeedingTypeParameters(codecId, coordinate);
+		refuseMemberCodecNeedingTypeParameters(codecId, coordinate);
 	}
 }
-/** The PSL type position of a domain field: a value object by name, or a scalar as a column would print. */
-function buildDomainFieldType(input) {
+/** The PSL type position of a value-object member: a value object or an enum by name, or a scalar as a column would print. */
+function buildMemberType(input) {
 	const { field, coordinate } = input;
 	refuseUnwritableFieldShape(field, coordinate);
 	const { type } = field;
 	if (type.kind === "valueObject") return { typeName: type.name };
-	refuseValueObjectFieldPartsTheSourceDrops({
-		...field,
-		type
-	}, coordinate);
+	refuseUnderivedMemberValueSet({
+		field,
+		type,
+		coordinate,
+		domainEnums: input.domainEnums
+	});
+	if (field.valueSet !== void 0) return { typeName: field.valueSet.entityName };
 	return buildColumnType({
 		column: new StorageColumn({
-			nativeType: nativeTypeOfValueObjectField({
-				...field,
-				type
-			}, coordinate, input.context),
+			nativeType: nativeTypeOfMember(type, coordinate, input.context),
 			codecId: type.codecId,
 			nullable: field.nullable,
-			...ifDefined("many", field.many)
+			...ifDefined("many", field.many),
+			...ifDefined("typeParams", type.typeParams)
 		}),
 		typeMap: input.typeMap,
 		authoringTypes: input.context.authoringContributions.type,
@@ -1237,12 +1244,13 @@ function buildCompositeTypes(input) {
 			name,
 			fields: Object.entries(valueObject.fields).map(([fieldName, field]) => {
 				refuseUnwritableName("field", fieldName);
-				const { typeName, typeConstructor } = buildDomainFieldType({
+				const { typeName, typeConstructor } = buildMemberType({
 					field,
 					coordinate: `"${input.namespaceId}".${name}.${fieldName}`,
 					typeMap: input.typeMap,
 					context: input.context,
-					enumBlockNames: input.enumBlockNames
+					enumBlockNames: input.enumBlockNames,
+					domainEnums: input.domainEnums
 				});
 				return {
 					kind: "field",
@@ -1858,7 +1866,7 @@ function buildColumnDefault(input) {
 	const result = mapDefault(columnDefault, {
 		dataTypeEntries: context.authoringContributions.dataTypes,
 		dataTypes: context.dataTypeLookup,
-		columnDataType: context.codecLookup.descriptorFor?.(input.isEnum ? PG_TEXT_CODEC_ID : input.column.codecId)?.dataType,
+		columnDataType: context.codecLookup.descriptorFor(input.isEnum ? PG_TEXT_CODEC_ID : input.column.codecId)?.dataType,
 		list: input.column.many === true
 	});
 	if (result === void 0) refuseUnwritableLiteralDefault({
@@ -1998,7 +2006,8 @@ function buildScalarFields(input) {
 			coordinate,
 			modelName: entry.name,
 			singleTableVariant: variant?.singleTable === true,
-			domainEnumNames: input.defaultDomainEnumNames
+			domainEnumNames: input.defaultDomainEnumNames,
+			namedTypes: input.namedTypes
 		});
 		if (column.typeRef !== void 0) refuseColumnDifferingFromNamedType({
 			column,
@@ -2006,13 +2015,7 @@ function buildScalarFields(input) {
 			namedType: input.namedTypes[column.typeRef],
 			coordinate
 		});
-		const columnType = column.typeRef !== void 0 ? { typeName: column.typeRef } : field.type.kind === "valueObject" ? buildDomainFieldType({
-			field,
-			coordinate,
-			typeMap,
-			context,
-			enumBlockNames: enums.blockNamesByTypeName
-		}) : buildColumnType({
+		const columnType = column.typeRef !== void 0 ? { typeName: column.typeRef } : field.type.kind === "valueObject" ? { typeName: field.type.name } : buildColumnType({
 			column,
 			typeMap,
 			authoringTypes: context.authoringContributions.type,
@@ -2177,7 +2180,8 @@ function buildNamespace(all, namespaceId, namespace) {
 		namespaceId,
 		typeMap: all.typeMap,
 		context: all.context,
-		enumBlockNames: enums.blockNamesByTypeName
+		enumBlockNames: enums.blockNamesByTypeName,
+		domainEnums: all.defaultDomainEnums
 	});
 	const modelNameForTable = (tableName) => models.find((entry) => entry.namespaceId === namespaceId && entry.tableName === tableName && variants.get(entry)?.singleTable !== true)?.name;
 	for (const tableName of rlsTables) if (modelNameForTable(tableName) === void 0) refuseRlsWithoutModel(namespaceId, tableName);
@@ -2269,6 +2273,371 @@ function buildPostgresPslContract(contract, context) {
 		span: SYNTHETIC_SPAN
 	};
 }
+/**
+* The base PSL scalars as zero-arg type constructors in the unified authoring
+* channel, with explicit `nativeType` values pinned to the codec manifests
+* (`codecLookup.targetTypesFor(codecId)[0]`).
+*
+* The type position is the only storage decider: a mutation-default generator
+* (`@default(uuid())`) never re-picks a column's storage.
+*
+* These and `postgresNativeAuthoringTypes` are defined here, next to the codecs they name, but the adapter contributes them: the TypeScript contract builder builds its `type.*` helpers from the target, so a target contribution would add `type.String()` and the like there.
+*/
+const postgresScalarAuthoringTypes = {
+	String: {
+		kind: "typeConstructor",
+		documentation: "Variable-length text stored as PostgreSQL text.",
+		output: {
+			codecId: "pg/text@1",
+			nativeType: "text"
+		}
+	},
+	Boolean: {
+		kind: "typeConstructor",
+		documentation: "A true or false value stored as PostgreSQL boolean.",
+		output: {
+			codecId: "pg/bool@1",
+			nativeType: "bool"
+		}
+	},
+	Int: {
+		kind: "typeConstructor",
+		documentation: "A signed 32-bit integer represented as a JavaScript number.",
+		output: {
+			codecId: "pg/int4@1",
+			nativeType: "int4"
+		}
+	},
+	BigInt: {
+		kind: "typeConstructor",
+		documentation: "A signed 64-bit integer represented as a JavaScript bigint.",
+		output: {
+			codecId: "pg/int8@1",
+			nativeType: "int8"
+		}
+	},
+	Float: {
+		kind: "typeConstructor",
+		documentation: "A double-precision floating-point number.",
+		output: {
+			codecId: "pg/float8@1",
+			nativeType: "float8"
+		}
+	},
+	Decimal: {
+		kind: "typeConstructor",
+		documentation: "An exact decimal value stored as PostgreSQL numeric.",
+		output: {
+			codecId: "pg/numeric@1",
+			nativeType: "numeric"
+		}
+	},
+	DateTime: {
+		kind: "typeConstructor",
+		documentation: "An instant stored as PostgreSQL timestamptz and represented as Temporal.Instant.",
+		output: {
+			codecId: "pg/timestamptz-temporal@1",
+			nativeType: "timestamptz"
+		}
+	},
+	Json: {
+		kind: "typeConstructor",
+		documentation: "A JSON value stored as PostgreSQL json.",
+		output: {
+			codecId: "pg/json@1",
+			nativeType: "json"
+		}
+	},
+	Jsonb: {
+		kind: "typeConstructor",
+		documentation: "A JSON value stored in PostgreSQL binary jsonb format.",
+		output: {
+			codecId: "pg/jsonb@1",
+			nativeType: "jsonb"
+		}
+	},
+	Bytes: {
+		kind: "typeConstructor",
+		documentation: "Binary data stored as PostgreSQL bytea.",
+		output: {
+			codecId: "pg/bytea@1",
+			nativeType: "bytea"
+		}
+	}
+};
+const postgresNativeAuthoringTypes = {
+	VarChar: {
+		kind: "typeConstructor",
+		documentation: "Variable-length text with an optional maximum character length.",
+		args: [{
+			kind: "number",
+			name: "length",
+			integer: true,
+			minimum: 1,
+			optional: true
+		}],
+		output: {
+			codecId: "sql/varchar@1",
+			nativeType: "character varying",
+			typeParams: { length: {
+				kind: "arg",
+				index: 0
+			} }
+		}
+	},
+	Char: {
+		kind: "typeConstructor",
+		documentation: "Fixed-length, blank-padded text with an optional character length.",
+		args: [{
+			kind: "number",
+			name: "length",
+			integer: true,
+			minimum: 1,
+			optional: true
+		}],
+		output: {
+			codecId: "sql/char@1",
+			nativeType: "character",
+			typeParams: { length: {
+				kind: "arg",
+				index: 0
+			} }
+		}
+	},
+	Numeric: {
+		kind: "typeConstructor",
+		documentation: "An exact decimal value with optional precision and scale.",
+		args: [{
+			kind: "number",
+			name: "precision",
+			integer: true,
+			minimum: NUMERIC_PRECISION_RANGE.min,
+			maximum: NUMERIC_PRECISION_RANGE.max,
+			optional: true
+		}, {
+			kind: "number",
+			name: "scale",
+			integer: true,
+			minimum: NUMERIC_SCALE_RANGE.min,
+			maximum: NUMERIC_SCALE_RANGE.max,
+			optional: true
+		}],
+		output: {
+			codecId: "pg/numeric@1",
+			nativeType: "numeric",
+			typeParams: {
+				precision: {
+					kind: "arg",
+					index: 0
+				},
+				scale: {
+					kind: "arg",
+					index: 1
+				}
+			}
+		}
+	},
+	Timestamp: {
+		kind: "typeConstructor",
+		documentation: "A date and time without a time zone, represented as Temporal.PlainDateTime.",
+		args: [{
+			kind: "number",
+			name: "precision",
+			integer: true,
+			minimum: 0,
+			optional: true
+		}],
+		output: {
+			codecId: "pg/timestamp-temporal@1",
+			nativeType: "timestamp",
+			typeParams: { precision: {
+				kind: "arg",
+				index: 0
+			} }
+		}
+	},
+	Timestamptz: {
+		kind: "typeConstructor",
+		documentation: "An instant represented as Temporal.Instant, with optional fractional-second precision.",
+		args: [{
+			kind: "number",
+			name: "precision",
+			integer: true,
+			minimum: 0,
+			optional: true
+		}],
+		output: {
+			codecId: "pg/timestamptz-temporal@1",
+			nativeType: "timestamptz",
+			typeParams: { precision: {
+				kind: "arg",
+				index: 0
+			} }
+		}
+	},
+	Time: {
+		kind: "typeConstructor",
+		documentation: "A time of day without a time zone, represented as Temporal.PlainTime.",
+		args: [{
+			kind: "number",
+			name: "precision",
+			integer: true,
+			minimum: 0,
+			optional: true
+		}],
+		output: {
+			codecId: "pg/time-temporal@1",
+			nativeType: "time",
+			typeParams: { precision: {
+				kind: "arg",
+				index: 0
+			} }
+		}
+	},
+	Timetz: {
+		kind: "typeConstructor",
+		documentation: "A time of day with a UTC offset stored as PostgreSQL timetz.",
+		args: [{
+			kind: "number",
+			name: "precision",
+			integer: true,
+			minimum: 0,
+			optional: true
+		}],
+		output: {
+			codecId: "pg/timetz@1",
+			nativeType: "timetz",
+			typeParams: { precision: {
+				kind: "arg",
+				index: 0
+			} }
+		}
+	},
+	Uuid: {
+		kind: "typeConstructor",
+		documentation: "A universally unique identifier stored as PostgreSQL uuid.",
+		output: {
+			codecId: "pg/uuid@1",
+			nativeType: "uuid"
+		}
+	},
+	Inet: {
+		kind: "typeConstructor",
+		documentation: "An IPv4 or IPv6 address with an optional subnet mask.",
+		output: {
+			codecId: "pg/inet@1",
+			nativeType: "inet"
+		}
+	},
+	SmallInt: {
+		kind: "typeConstructor",
+		documentation: "A signed 16-bit integer represented as a JavaScript number.",
+		output: {
+			codecId: "pg/int2@1",
+			nativeType: "int2"
+		}
+	},
+	Real: {
+		kind: "typeConstructor",
+		documentation: "A single-precision floating-point number.",
+		output: {
+			codecId: "pg/float4@1",
+			nativeType: "float4"
+		}
+	},
+	Date: {
+		kind: "typeConstructor",
+		documentation: "A calendar date represented as Temporal.PlainDate.",
+		output: {
+			codecId: "pg/date-temporal@1",
+			nativeType: "date"
+		}
+	},
+	DateString: {
+		kind: "typeConstructor",
+		documentation: "A PostgreSQL date represented as database text rather than Temporal.PlainDate.",
+		output: {
+			codecId: "pg/date-string@1",
+			nativeType: "date"
+		}
+	},
+	TimestampString: {
+		kind: "typeConstructor",
+		documentation: "A timestamp without a time zone represented as PostgreSQL text.",
+		args: [{
+			kind: "number",
+			name: "precision",
+			integer: true,
+			minimum: 0,
+			optional: true
+		}],
+		output: {
+			codecId: "pg/timestamp-string@1",
+			nativeType: "timestamp",
+			typeParams: { precision: {
+				kind: "arg",
+				index: 0
+			} }
+		}
+	},
+	TimestamptzJsDate: {
+		kind: "typeConstructor",
+		documentation: "An instant stored as PostgreSQL timestamptz and represented as a JavaScript Date.",
+		args: [{
+			kind: "number",
+			name: "precision",
+			integer: true,
+			minimum: 0,
+			optional: true
+		}],
+		output: {
+			codecId: PG_TIMESTAMPTZ_DATE_CODEC_ID,
+			nativeType: "timestamptz",
+			typeParams: { precision: {
+				kind: "arg",
+				index: 0
+			} }
+		}
+	},
+	TimestamptzString: {
+		kind: "typeConstructor",
+		documentation: "A timestamp with time zone represented as PostgreSQL text.",
+		args: [{
+			kind: "number",
+			name: "precision",
+			integer: true,
+			minimum: 0,
+			optional: true
+		}],
+		output: {
+			codecId: "pg/timestamptz-string@1",
+			nativeType: "timestamptz",
+			typeParams: { precision: {
+				kind: "arg",
+				index: 0
+			} }
+		}
+	},
+	TimeString: {
+		kind: "typeConstructor",
+		documentation: "A time of day without a time zone represented as PostgreSQL text.",
+		args: [{
+			kind: "number",
+			name: "precision",
+			integer: true,
+			minimum: 0,
+			optional: true
+		}],
+		output: {
+			codecId: "pg/time-string@1",
+			nativeType: "time",
+			typeParams: { precision: {
+				kind: "arg",
+				index: 0
+			} }
+		}
+	}
+};
 function postgresRenderDefault(def, column) {
 	if (def.kind === "function") return def.expression;
 	return renderDefaultLiteral(def.value, column);
@@ -2279,9 +2648,9 @@ function createPostgresTargetDescriptor() {
 		...postgresTargetDescriptorMeta,
 		contractSerializer: new PostgresContractSerializer(),
 		schemaVerifier: new PostgresSchemaVerifier(),
-		inferPslContract(schema, describedContracts) {
+		inferPslContract(schema, context, describedContracts) {
 			PostgresDatabaseSchemaNode.assert(schema);
-			return inferPostgresPslContract(schema, describedContracts);
+			return inferPostgresPslContract(schema, context, describedContracts);
 		},
 		buildPslContract(contract, context) {
 			return buildPostgresPslContract(contract, context);
@@ -2299,10 +2668,10 @@ function createPostgresTargetDescriptor() {
 				return blindCast(createPostgresMigrationRunner(family));
 			},
 			contractToSchema(contract, frameworkComponents) {
-				const expander = buildNativeTypeExpander(frameworkComponents);
+				const expander = buildPostgresNativeTypeExpander(frameworkComponents);
 				return contractToPostgresDatabaseSchemaNode(blindCast(contract), {
 					annotationNamespace: "pg",
-					...ifDefined("expandNativeType", expander),
+					expandNativeType: expander,
 					renderDefault: postgresRenderDefault,
 					resolveDefault: postgresResolveDefault,
 					...ifDefined("dataTypeOf", buildDataTypeResolver(frameworkComponents))
@@ -2333,6 +2702,6 @@ function createPostgresTargetDescriptor() {
 }
 const postgresTargetDescriptor = createPostgresTargetDescriptor();
 //#endregion
-export { postgresTargetDescriptor as n, postgresRenderDefault as t };
+export { postgresTargetDescriptor as i, postgresRenderDefault as n, postgresScalarAuthoringTypes as r, postgresNativeAuthoringTypes as t };
 
-//# sourceMappingURL=control-w3p4NYNx.mjs.map
+//# sourceMappingURL=control-CYQReJto.mjs.map