@prisma-next/target-postgres 0.16.0-dev.3 → 0.16.0-dev.31

package/dist/control.mjs

@@ -1,11 +1,12 @@
+import { n as postgresError } from "./errors-DBSNx7EJ.mjs";
 import { n as postgresResolveDefault } from "./default-normalizer-B9ZUiyUE.mjs";
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-qubYaxQA.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DGlJurgA.mjs";
 import { a as postgresDiffSubjectGranularity, i as postgresDiffSubjectEntityKind } from "./postgres-table-schema-node-D6LvInCe.mjs";
 import { i as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-bg32e7I-.mjs";
-import { n as diffPostgresSchema, r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-C-hnJ5mr.mjs";
-import { r as renderDefaultLiteral } from "./planner-ddl-builders-BKlmGDJl.mjs";
-import { n as PostgresContractSerializer } from "./postgres-contract-view-DebHMqGR.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-DPGxFcXo.mjs";
+import { n as diffPostgresSchema, r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-qRPwuYBH.mjs";
+import { r as renderDefaultLiteral } from "./planner-ddl-builders-CVo3L7Nd.mjs";
+import { n as PostgresContractSerializer } from "./postgres-contract-view-BeIEyZfD.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-BhnkIJX-.mjs";
 import { UNBOUND_NAMESPACE_ID, coordinateKey, elementCoordinates } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
 import { buildNativeTypeExpander, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
@@ -13,9 +14,10 @@ import { ifDefined } from "@prisma-next/utils/defined";
 import { SqlSchemaIR, SqlTableIR } from "@prisma-next/sql-schema-ir/types";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
 import { notOk, ok, okVoid } from "@prisma-next/utils/result";
+import { InternalError } from "@prisma-next/utils/internal-error";
 import { SqlSchemaVerifierBase } from "@prisma-next/family-sql/ir";
 import { SqlQueryError } from "@prisma-next/sql-errors";
-import { buildChildRelationField, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, toEnumMemberName, toEnumName, toFieldName, toModelName, toNamedTypeName } from "@prisma-next/family-sql/psl-infer";
+import { buildChildRelationField, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, toEnumMemberName, toEnumName, toFieldName, toModelName } from "@prisma-next/family-sql/psl-infer";
 import { UNSPECIFIED_PSL_NAMESPACE_ID, makePslNamespace, makePslNamespaceEntries } from "@prisma-next/framework-components/psl-ast";
 //#region src/core/migrations/runner.ts
 const LOCK_DOMAIN = "prisma_next.contract.marker";
@@ -47,7 +49,10 @@ var PostgresMigrationRunner = class {
 	async executeOnConnection(options) {
 		const schema = options.schemaName ?? Object.keys(options.destinationContract.storage.namespaces).find((id) => id !== UNBOUND_NAMESPACE_ID) ?? UNBOUND_NAMESPACE_ID;
 		const driver = options.driver;
-		if (options.space !== void 0 && options.space !== options.plan.spaceId) throw new Error(`SqlMigrationRunner: options.space (${options.space}) does not match plan.spaceId (${options.plan.spaceId})`);
+		if (options.space !== void 0 && options.space !== options.plan.spaceId) throw postgresError("MIGRATION.CONTRACT_SPACE_VIOLATION", `SqlMigrationRunner: options.space (${options.space}) does not match plan.spaceId (${options.plan.spaceId})`, { meta: {
+			space: options.space,
+			planSpaceId: options.plan.spaceId
+		} });
 		const space = options.plan.spaceId;
 		const lockKey = `${LOCK_DOMAIN}:${schema}:${space}`;
 		const planOps = blindCast(await Promise.all(options.plan.operations));
@@ -177,7 +182,7 @@ var PostgresMigrationRunner = class {
 	async ensureControlTables(driver, contract) {
 		const lowererContext = { contract };
 		const [schemaQuery, ...tableQueries] = this.family.bootstrapControlTableQueries();
-		if (schemaQuery === void 0) throw new Error("Postgres control-table bootstrap must include CREATE SCHEMA");
+		if (schemaQuery === void 0) throw new InternalError("Postgres control-table bootstrap must include CREATE SCHEMA");
 		await this.executeStatement(driver, await this.family.lowerAst(schemaQuery, lowererContext));
 		const legacyDetection = await this.detectLegacyMarkerShape(driver);
 		if (!legacyDetection.ok) return legacyDetection;
@@ -347,7 +352,7 @@ var PostgresMigrationRunner = class {
 		const space = options.plan.spaceId;
 		const edges = options.migrationEdges;
 		const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
-		if (totalEdgeOps !== planOpsLength) throw new Error(`Ledger write: plan.operations length (${planOpsLength}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`);
+		if (totalEdgeOps !== planOpsLength) throw new InternalError(`Ledger write: plan.operations length (${planOpsLength}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`);
 		let offset = 0;
 		for (const edge of edges) {
 			const edgeOps = executedOperations.slice(offset, offset + edge.operationCount);
@@ -432,170 +437,82 @@ const POSTGRES_TO_PSL = {
 	bigint: "BigInt",
 	float8: "Float",
 	"double precision": "Float",
-	numeric: "Decimal",
-	decimal: "Decimal",
-	timestamptz: "DateTime",
-	"timestamp with time zone": "DateTime",
-	jsonb: "Json",
+	jsonb: "Jsonb",
 	bytea: "Bytes"
 };
 const PRESERVED_NATIVE_TYPES = {
-	"character varying": {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	character: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	char: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	varchar: {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	uuid: {
-		pslType: "String",
-		attributeName: "db.Uuid"
-	},
-	inet: {
-		pslType: "String",
-		attributeName: "db.Inet"
-	},
-	int2: {
-		pslType: "Int",
-		attributeName: "db.SmallInt"
-	},
-	smallint: {
-		pslType: "Int",
-		attributeName: "db.SmallInt"
-	},
-	float4: {
-		pslType: "Float",
-		attributeName: "db.Real"
-	},
-	real: {
-		pslType: "Float",
-		attributeName: "db.Real"
-	},
-	timestamp: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	"timestamp without time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	date: {
-		pslType: "DateTime",
-		attributeName: "db.Date"
-	},
-	time: {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	"time without time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	timetz: {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	},
-	"time with time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	},
-	json: {
-		pslType: "Json",
-		attributeName: "db.Json"
-	}
+	"character varying": "VarChar",
+	character: "Char",
+	char: "Char",
+	varchar: "VarChar",
+	uuid: "Uuid",
+	inet: "Inet",
+	int2: "SmallInt",
+	smallint: "SmallInt",
+	float4: "Real",
+	real: "Real",
+	numeric: "Numeric",
+	decimal: "Numeric",
+	timestamp: "Timestamp",
+	"timestamp without time zone": "Timestamp",
+	timestamptz: "Timestamptz",
+	"timestamp with time zone": "Timestamptz",
+	date: "Date",
+	time: "Time",
+	"time without time zone": "Time",
+	timetz: "Timetz",
+	"time with time zone": "Timetz",
+	json: "Json"
 };
 const PARAMETERIZED_NATIVE_TYPES = {
-	"character varying": {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	character: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	char: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	varchar: {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	numeric: {
-		pslType: "Decimal",
-		attributeName: "db.Numeric"
-	},
-	timestamp: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	timestamptz: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamptz"
-	},
-	time: {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	timetz: {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	}
+	"character varying": "VarChar",
+	character: "Char",
+	char: "Char",
+	varchar: "VarChar",
+	numeric: "Numeric",
+	decimal: "Numeric",
+	timestamp: "Timestamp",
+	timestamptz: "Timestamptz",
+	time: "Time",
+	timetz: "Timetz"
 };
 const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
 function getOwnMappingValue(map, key) {
 	return Object.hasOwn(map, key) ? map[key] : void 0;
 }
-function getOwnRecordValue(map, key) {
-	return Object.hasOwn(map, key) ? map[key] : void 0;
-}
-function createNativeTypeAttribute(name, args) {
-	return args && args.length > 0 ? {
-		name,
-		args
-	} : { name };
-}
 function splitTypeParameterList(params) {
 	return params.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
 }
 function createPostgresTypeMap(enumTypeNames) {
 	return { resolve(nativeType) {
 		if (enumTypeNames?.has(nativeType)) return {
-			pslType: nativeType,
+			pslType: { name: nativeType },
 			nativeType
 		};
 		const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);
 		if (paramMatch) {
 			const [, baseType = nativeType, params = ""] = paramMatch;
-			const template = getOwnRecordValue(PARAMETERIZED_NATIVE_TYPES, baseType);
-			if (template) return {
-				pslType: template.pslType,
+			const typeName = getOwnMappingValue(PARAMETERIZED_NATIVE_TYPES, baseType);
+			if (typeName) return {
+				pslType: {
+					name: typeName,
+					args: splitTypeParameterList(params)
+				},
 				nativeType,
 				typeParams: {
 					baseType,
 					params
-				},
-				nativeTypeAttribute: createNativeTypeAttribute(template.attributeName, splitTypeParameterList(params))
+				}
 			};
 		}
-		const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
+		const preservedType = getOwnMappingValue(PRESERVED_NATIVE_TYPES, nativeType);
 		if (preservedType) return {
-			pslType: preservedType.pslType,
-			nativeType,
-			nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName)
+			pslType: { name: preservedType },
+			nativeType
 		};
 		const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
 		if (pslType) return {
-			pslType,
+			pslType: { name: pslType },
 			nativeType
 		};
 		return {
@@ -704,7 +621,10 @@ function resolveForeignKeys(tables, owners) {
 				}));
 				if (owner !== void 0) {
 					const target = resolveCrossSpaceTarget(owner, fk.referencedSchema, fk.referencedTable);
-					if (target === void 0) throw new Error(`contract infer: described contract space "${owner.spaceId}" owns storage coordinate "${fk.referencedSchema}.${fk.referencedTable}" but declares no domain model mapped to it. A pack that describes a table must also declare the domain model it maps to; this pack is malformed.`);
+					if (target === void 0) throw postgresError("CONTRACT.PACK_CONTRIBUTION_INVALID", `contract infer: described contract space "${owner.spaceId}" owns storage coordinate "${fk.referencedSchema}.${fk.referencedTable}" but declares no domain model mapped to it. A pack that describes a table must also declare the domain model it maps to; this pack is malformed.`, { meta: {
+						spaceId: owner.spaceId,
+						tableName: fk.referencedTable
+					} });
 					if (!crossSpaceFieldNamesByTable.has(fk.referencedTable)) crossSpaceFieldNamesByTable.set(fk.referencedTable, target.fieldNamesByColumn);
 					const fieldName = deriveRelationFieldName(fk.columns, fk.referencedTable);
 					const optional = fk.columns.some((columnName) => table.columns[columnName]?.nullable ?? false);
@@ -799,10 +719,13 @@ function inferPostgresPslContract(tree, describedContracts) {
 				entityKind: "table",
 				entityName: tableName
 			}))) continue;
-			if (tables[tableName] !== void 0) throw new Error(`contract infer: duplicate table name "${tableName}" across schemas is not yet supported (single-namespace PSL inference emits one flat bucket; multi-namespace \`namespace { … }\` output is a later slice).`);
+			if (tables[tableName] !== void 0) throw postgresError("CONTRACT.INFER_UNSUPPORTED", `contract infer: duplicate table name "${tableName}" across schemas is not yet supported (single-namespace PSL inference emits one flat bucket; multi-namespace \`namespace { … }\` output is a later slice).`, { meta: { tableName } });
 			if (ownedEnumTypes !== void 0) for (const column of Object.values(table.columns)) {
 				const owningSpaceId = ownedEnumTypes.get(column.nativeType);
-				if (owningSpaceId !== void 0) throw new Error(`contract infer: column "${tableName}"."${column.name}" is typed by native enum type "${column.nativeType}", which extension pack space "${owningSpaceId}" already describes. A cross-space enum-typed column has no authorable PSL form yet; describe the table in that pack's contract or retype the column before re-running contract infer.`);
+				if (owningSpaceId !== void 0) throw postgresError("CONTRACT.INFER_UNSUPPORTED", `contract infer: column "${tableName}"."${column.name}" is typed by native enum type "${column.nativeType}", which extension pack space "${owningSpaceId}" already describes. A cross-space enum-typed column has no authorable PSL form yet; describe the table in that pack's contract or retype the column before re-running contract infer.`, { meta: {
+					tableName,
+					columnName: column.name
+				} });
 			}
 			tables[tableName] = new SqlTableIR(table);
 			tableNamespaceNames.add(namespace.schemaName);
@@ -811,7 +734,7 @@ function inferPostgresPslContract(tree, describedContracts) {
 	let wrapNamespaceName;
 	if (enumDefinitions.size > 0) {
 		const contentNamespaces = /* @__PURE__ */ new Set([...enumNamespaceNames, ...tableNamespaceNames]);
-		if (contentNamespaces.size > 1) throw new Error(`contract infer: native enum adoption with content across multiple schemas is not yet supported (single-namespace PSL inference emits one \`namespace { … }\` block; multi-namespace output is a later slice). Schemas: ${[...contentNamespaces].sort().join(", ")}.`);
+		if (contentNamespaces.size > 1) throw postgresError("CONTRACT.INFER_UNSUPPORTED", `contract infer: native enum adoption with content across multiple schemas is not yet supported (single-namespace PSL inference emits one \`namespace { … }\` block; multi-namespace output is a later slice). Schemas: ${[...contentNamespaces].sort().join(", ")}.`, { meta: { schemas: [...contentNamespaces].sort() } });
 		wrapNamespaceName = [...contentNamespaces][0];
 	}
 	const { tables: resolvedTables, extraRelationsByTable, crossSpaceFieldNamesByTable, danglingForeignKeysByTable } = resolveForeignKeys(tables, owners);
@@ -841,19 +764,11 @@ function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName)
 	const { enumNameMap: bareEnumNameMap, enumBlocks } = buildNativeEnumBlocks(options.enumInfo?.definitions ?? /* @__PURE__ */ new Map(), modelNames);
 	const enumNameMap = new Map(bareEnumNameMap);
 	if (namespaceName !== void 0) for (const [typeName, pslName] of bareEnumNameMap) enumNameMap.set(`${namespaceName}.${typeName}`, pslName);
-	const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames, enumNameMap);
 	const fieldNamesByTable = new Map([...crossSpaceFieldNamesByTable, ...buildFieldNamesByTable(schemaIR.tables)]);
 	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
-	const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNamedTypeNames);
 	const models = [];
-	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, [...relationsByTable.get(table.name) ?? [], ...extraRelationsByTable.get(table.name) ?? []], danglingForeignKeysByTable.get(table.name) ?? []));
+	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, enumNameMap, fieldNamesByTable, defaultMapping, rawDefaultParser, [...relationsByTable.get(table.name) ?? [], ...extraRelationsByTable.get(table.name) ?? []], danglingForeignKeysByTable.get(table.name) ?? []));
 	const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
-	const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) => a.name.localeCompare(b.name));
-	const types = namedTypeEntries.length > 0 ? {
-		kind: "types",
-		declarations: namedTypeEntries.map(buildNamedTypeDeclaration),
-		span: SYNTHETIC_SPAN
-	} : void 0;
 	return {
 		kind: "document",
 		sourceId: "<sql-schema-ir>",
@@ -863,7 +778,6 @@ function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName)
 			entries: makePslNamespaceEntries(sortedModels, [], enumBlocks),
 			span: SYNTHETIC_SPAN
 		})],
-		...types ? { types } : {},
 		span: SYNTHETIC_SPAN
 	};
 }
@@ -923,7 +837,7 @@ function buildNativeEnumBlock(name, typeName, values) {
 		span: SYNTHETIC_SPAN
 	};
 }
-function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationFields, danglingForeignKeys) {
+function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, defaultMapping, rawDefaultParser, relationFields, danglingForeignKeys) {
 	const { name: modelName, map: mapName } = toModelName(table.name);
 	const fieldNameMap = fieldNamesByTable.get(table.name);
 	const pkColumns = new Set(table.primaryKey?.columns ?? []);
@@ -936,7 +850,7 @@ function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes,
 		if (!uniqueColumns.has(columnName) || existingConstraintName === void 0 && unique.name) uniqueColumns.set(columnName, unique.name);
 	}
 	const fields = [];
-	for (const column of Object.values(table.columns)) fields.push(buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns));
+	for (const column of Object.values(table.columns)) fields.push(buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns));
 	const usedFieldNames = new Set(fields.map((field) => field.name));
 	for (const rel of relationFields) fields.push(buildRelationField(rel, table.name, fieldNamesByTable, usedFieldNames));
 	const modelAttributes = [];
@@ -948,9 +862,12 @@ function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes,
 		const uniqueFieldNames = unique.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
 		modelAttributes.push(buildModelConstraintAttribute("unique", uniqueFieldNames, unique.name));
 	}
-	for (const index of table.indexes) if (!index.unique) {
-		const indexFieldNames = index.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
-		modelAttributes.push(buildModelConstraintAttribute("index", indexFieldNames, index.name, index.type));
+	for (const index of table.indexes) {
+		if (index.columns === void 0 || index.where !== void 0) continue;
+		if (!index.unique) {
+			const indexFieldNames = index.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
+			modelAttributes.push(buildModelConstraintAttribute("index", indexFieldNames, index.name, index.type));
+		}
 	}
 	if (mapName) modelAttributes.push(buildMapAttribute("model", mapName));
 	const warnings = [];
@@ -978,9 +895,9 @@ function buildDanglingForeignKeyWarning(danglingForeignKeys, fieldNamesByTable,
 		const fieldNames = fk.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, tableName, columnName));
 		const target = fk.referencedSchema !== void 0 ? `${fk.referencedSchema}.${fk.referencedTable}` : fk.referencedTable;
 		return `"${fieldNames.join(", ")}" -> "${target}"`;
-	}).join(", ")} exists in the database, but its target schema is outside the introspected scope, so no relation field was generated. If the target schema is described by an extension pack, add it to extensionPacks and re-run infer.`;
+	}).join(", ")} exists in the database, but its target schema is outside the introspected scope, so no relation field was generated. If the target schema is described by an extension pack, add it to extensions and re-run infer.`;
 }
-function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns) {
+function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns) {
 	const resolvedField = fieldNameMap?.get(column.name);
 	const fieldName = resolvedField?.fieldName ?? toFieldName(column.name).name;
 	const fieldMap = resolvedField?.fieldMap;
@@ -998,8 +915,13 @@ function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, nam
 			span: SYNTHETIC_SPAN
 		};
 	}
-	let typeName = resolution.pslType;
-	let typeConstructor;
+	let typeName = resolution.pslType.name;
+	let typeConstructor = resolution.pslType.args ? {
+		kind: "typeConstructor",
+		path: [resolution.pslType.name],
+		args: resolution.pslType.args.map(positionalArg),
+		span: SYNTHETIC_SPAN
+	} : void 0;
 	const enumPslName = enumNameMap.get(column.nativeType);
 	if (enumPslName) {
 		typeName = enumPslName;
@@ -1010,7 +932,6 @@ function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, nam
 			span: SYNTHETIC_SPAN
 		};
 	}
-	if (resolution.nativeTypeAttribute && !enumPslName) typeName = resolveNamedTypeName(namedTypes, resolution);
 	const attributes = [];
 	const isId = isSinglePk && pkColumns.has(column.name);
 	if (isId) attributes.push(buildSimpleConstraintFieldAttribute("id", singlePkConstraintName));
@@ -1115,16 +1036,6 @@ function namedArg(name, value) {
 		span: SYNTHETIC_SPAN
 	};
 }
-function buildNamedTypeDeclaration(entry) {
-	const attribute = buildAttribute("namedType", entry.nativeTypeAttribute.name, (entry.nativeTypeAttribute.args ?? []).map(positionalArg));
-	return {
-		kind: "namedType",
-		name: entry.name,
-		baseType: entry.baseType,
-		attributes: [attribute],
-		span: SYNTHETIC_SPAN
-	};
-}
 function escapePslString(value) {
 	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
 }
@@ -1202,71 +1113,12 @@ function buildTopLevelNameMap(sources, normalize, kind, sourceKind) {
 		normalizedToSources.set(normalized.name, [...normalizedToSources.get(normalized.name) ?? [], source]);
 	}
 	const duplicates = [...normalizedToSources.entries()].filter(([, conflictingSources]) => conflictingSources.length > 1);
-	if (duplicates.length > 0) {
-		const details = duplicates.map(([normalizedName, conflictingSources]) => `- ${kind} "${normalizedName}" from ${sourceKind}s ${conflictingSources.map((source) => `"${source}"`).join(", ")}`);
-		throw new Error(`PSL ${kind} name collisions detected:\n${details.join("\n")}`);
-	}
+	if (duplicates.length > 0) throw postgresError("CONTRACT.NAME_DUPLICATE", `PSL ${kind} name collisions detected:\n${duplicates.map(([normalizedName, conflictingSources]) => `- ${kind} "${normalizedName}" from ${sourceKind}s ${conflictingSources.map((source) => `"${source}"`).join(", ")}`).join("\n")}`, { meta: {
+		kind,
+		names: duplicates.map(([normalizedName]) => normalizedName)
+	} });
 	return results;
 }
-function createReservedNamedTypeNames(modelNames, enumNameMap) {
-	const reservedNames = new Set(PSL_SCALAR_TYPE_NAMES);
-	for (const result of modelNames.values()) reservedNames.add(result.name);
-	for (const enumPslName of enumNameMap.values()) reservedNames.add(enumPslName);
-	return reservedNames;
-}
-function seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNames) {
-	const seeds = /* @__PURE__ */ new Map();
-	for (const tableName of Object.keys(schemaIR.tables).sort()) {
-		const table = schemaIR.tables[tableName];
-		if (!table) continue;
-		for (const columnName of Object.keys(table.columns).sort()) {
-			const column = table.columns[columnName];
-			if (!column) continue;
-			const resolution = typeMap.resolve(column.nativeType, table.annotations);
-			if ("unsupported" in resolution || enumNameMap.has(column.nativeType) || !resolution.nativeTypeAttribute) continue;
-			const signatureKey = createNamedTypeSignatureKey(resolution);
-			if (!seeds.has(signatureKey)) seeds.set(signatureKey, {
-				baseType: resolution.pslType,
-				desiredName: toNamedTypeName(column.name),
-				nativeTypeAttribute: resolution.nativeTypeAttribute
-			});
-		}
-	}
-	const registry = {
-		entriesByKey: /* @__PURE__ */ new Map(),
-		usedNames: new Set(reservedNames)
-	};
-	const sortedSeeds = [...seeds.entries()].sort((left, right) => {
-		const desiredNameComparison = left[1].desiredName.localeCompare(right[1].desiredName);
-		if (desiredNameComparison !== 0) return desiredNameComparison;
-		return left[0].localeCompare(right[0]);
-	});
-	for (const [signatureKey, seed] of sortedSeeds) {
-		const name = createUniqueFieldName(seed.desiredName, registry.usedNames);
-		registry.entriesByKey.set(signatureKey, {
-			name,
-			baseType: seed.baseType,
-			nativeTypeAttribute: seed.nativeTypeAttribute
-		});
-		registry.usedNames.add(name);
-	}
-	return registry;
-}
-function resolveNamedTypeName(registry, resolution) {
-	const key = createNamedTypeSignatureKey(resolution);
-	const existing = registry.entriesByKey.get(key);
-	if (existing) return existing.name;
-	throw new Error(`Named type registry was not seeded for native type "${resolution.nativeType}"`);
-}
-function createNamedTypeSignatureKey(resolution) {
-	return JSON.stringify({
-		baseType: resolution.pslType,
-		nativeTypeAttribute: resolution.nativeTypeAttribute ? {
-			name: resolution.nativeTypeAttribute.name,
-			args: resolution.nativeTypeAttribute.args ?? null
-		} : null
-	});
-}
 function topologicalSort(models, tables, modelNameMap) {
 	const modelByName = /* @__PURE__ */ new Map();
 	for (const model of models) modelByName.set(model.name, model);