@prisma-next/target-postgres 0.14.0-dev.6 → 0.14.0-dev.60

package/dist/control.mjs

@@ -1,18 +1,22 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CpGygXpI.mjs";
-import { t as parsePostgresDefault } from "./default-normalizer-DyyCHQWs.mjs";
-import { t as normalizeSchemaNativeType } from "./native-type-normalizer-Bc9XJzWC.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-Bs_baQax.mjs";
-import { a as renderDefaultLiteral } from "./planner-ddl-builders-B2wOwLqI.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-serializer-k3TAcPMY.mjs";
+import { t as PostgresNativeEnum } from "./postgres-native-enum-xdiqmBf_.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-BOcKPaLE.mjs";
+import { i as postgresDiffSubjectGranularity, r as postgresDiffSubjectEntityKind } from "./postgres-table-schema-node-9FCtCUz2.mjs";
+import { i as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-BiSTCTNg.mjs";
+import { n as diffPostgresSchema, r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-BOsDnH64.mjs";
+import { r as renderDefaultLiteral } from "./planner-ddl-builders-B8Nn6nHN.mjs";
+import { n as PostgresContractSerializer } from "./postgres-contract-view-Dg-N7KA7.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-CNrc1Odu.mjs";
+import { UNBOUND_NAMESPACE_ID, coordinateKey, elementCoordinates, isPlainRecord } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
-import { contractToSchemaIR, extractCodecControlHooks, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
+import { buildNativeTypeExpander, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { notOk, ok, okVoid } from "@prisma-next/utils/result";
+import { SqlSchemaIR, SqlTableIR } from "@prisma-next/sql-schema-ir/types";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
-import { SqlQueryError } from "@prisma-next/sql-errors";
+import { notOk, ok, okVoid } from "@prisma-next/utils/result";
 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 { 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";
 /**
@@ -74,19 +78,15 @@ var PostgresMigrationRunner = class {
 			applyValue = applyResult.value;
 		}
 		if (space === APP_SPACE_ID) {
-			const schemaIR = await this.family.introspect({
+			const schemaNode = await this.family.introspect({
 				driver,
 				contract: options.destinationContract
 			});
-			const schemaVerifyResult = verifySqlSchema({
+			const schemaVerifyResult = this.family.verifySchema({
 				contract: options.destinationContract,
-				schema: schemaIR,
+				schema: schemaNode,
 				strict: options.strictVerification ?? true,
-				context: options.context ?? {},
-				typeMetadataRegistry: this.family.typeMetadataRegistry,
-				frameworkComponents: options.frameworkComponents,
-				normalizeDefault: parsePostgresDefault,
-				normalizeNativeType: normalizeSchemaNativeType
+				frameworkComponents: options.frameworkComponents
 			});
 			if (!schemaVerifyResult.ok) return runnerFailure("SCHEMA_VERIFY_FAILED", schemaVerifyResult.summary, {
 				why: "The resulting database schema does not satisfy the destination contract.",
@@ -387,10 +387,10 @@ var PostgresMigrationRunner = class {
 /**
 * Postgres target `SchemaVerifier` concretion. Plugs into the
 * SQL-shared verification surface; production verification today still
-* routes through the legacy `verifySqlSchema` entry point, which
-* carries options (codec hooks, normalizers, framework components)
-* that the framework-level `SchemaVerifyOptions` shape does not yet
-* surface.
+* routes through the family verify verdict (`verifySqlSchemaByDiff` over
+* `diffPostgresSchema`), which carries options (codec hooks,
+* normalizers, framework components) that the framework-level
+* `SchemaVerifyOptions` shape does not yet surface.
 *
 * The hooks return the empty list pending the call-site migration that
 * routes the existing verifier behaviour through the SPI — at that
@@ -408,18 +408,873 @@ var PostgresSchemaVerifier = class extends SqlSchemaVerifierBase {
 	}
 };
 //#endregion
-//#region src/exports/control.ts
-function buildNativeTypeExpander(frameworkComponents) {
-	if (!frameworkComponents) return;
-	const codecHooks = extractCodecControlHooks(frameworkComponents);
-	return (input) => {
-		if (!input.typeParams) return input.nativeType;
-		if (!input.codecId) return input.nativeType;
-		const hooks = codecHooks.get(input.codecId);
-		if (!hooks?.expandNativeType) return input.nativeType;
-		return hooks.expandNativeType(input);
+//#region src/core/psl-infer/postgres-default-mapping.ts
+const POSTGRES_FUNCTION_ATTRIBUTES = { "gen_random_uuid()": "@default(dbgenerated(\"gen_random_uuid()\"))" };
+function formatDbGeneratedAttribute(expression) {
+	return `@default(dbgenerated(${JSON.stringify(expression)}))`;
+}
+function createPostgresDefaultMapping() {
+	return {
+		functionAttributes: POSTGRES_FUNCTION_ATTRIBUTES,
+		fallbackFunctionAttribute: formatDbGeneratedAttribute
+	};
+}
+//#endregion
+//#region src/core/psl-infer/postgres-type-map.ts
+const POSTGRES_TO_PSL = {
+	text: "String",
+	bool: "Boolean",
+	boolean: "Boolean",
+	int4: "Int",
+	integer: "Int",
+	int8: "BigInt",
+	bigint: "BigInt",
+	float8: "Float",
+	"double precision": "Float",
+	numeric: "Decimal",
+	decimal: "Decimal",
+	timestamptz: "DateTime",
+	"timestamp with time zone": "DateTime",
+	jsonb: "Json",
+	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"
+	},
+	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"
+	}
+};
+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"
+	}
+};
+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,
+			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,
+				nativeType,
+				typeParams: {
+					baseType,
+					params
+				},
+				nativeTypeAttribute: createNativeTypeAttribute(template.attributeName, splitTypeParameterList(params))
+			};
+		}
+		const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
+		if (preservedType) return {
+			pslType: preservedType.pslType,
+			nativeType,
+			nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName)
+		};
+		const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
+		if (pslType) return {
+			pslType,
+			nativeType
+		};
+		return {
+			unsupported: true,
+			nativeType
+		};
+	} };
+}
+//#endregion
+//#region src/core/psl-infer/infer-psl-contract.ts
+const SYNTHETIC_SPAN = {
+	start: {
+		offset: 0,
+		line: 1,
+		column: 1
+	},
+	end: {
+		offset: 0,
+		line: 1,
+		column: 1
+	}
+};
+const PSL_SCALAR_TYPE_NAMES = new Set([
+	"String",
+	"Boolean",
+	"Int",
+	"BigInt",
+	"Float",
+	"Decimal",
+	"DateTime",
+	"Json",
+	"Bytes"
+]);
+/**
+* Coordinates every element a set of already-assembled contracts declare,
+* mapped to the {@link SqlDescribedContractSpace} that owns it and keyed by
+* the shared {@link coordinateKey} helper. `contract infer` uses this to omit
+* database elements a stack extension pack's contract space already
+* describes — reusing the same coordinate walk the contract-space aggregate
+* and cross-space collision check use (`elementCoordinates`), rather than a
+* bespoke per-entity-kind membership test — and, for a foreign key whose
+* referenced table an entry owns, to resolve the qualified cross-space
+* relation it describes.
+*/
+function describedContractOwners(describedContracts) {
+	const owners = /* @__PURE__ */ new Map();
+	for (const entry of describedContracts) for (const coordinate of elementCoordinates(entry.contract.storage)) owners.set(coordinateKey(coordinate), entry);
+	return owners;
+}
+function resolveCrossSpaceTarget(owner, namespaceId, tableName) {
+	const domainNamespace = owner.contract.domain.namespaces[namespaceId];
+	if (domainNamespace === void 0) return;
+	for (const [modelName, model] of Object.entries(domainNamespace.models)) {
+		const storage = blindCast(model.storage);
+		if (storage.namespaceId !== namespaceId || storage.table !== tableName) continue;
+		const fieldNamesByColumn = /* @__PURE__ */ new Map();
+		for (const [fieldName, fieldStorage] of Object.entries(storage.fields)) fieldNamesByColumn.set(fieldStorage.column, { fieldName });
+		return {
+			spaceId: owner.spaceId,
+			namespaceId,
+			modelName,
+			fieldNamesByColumn
+		};
+	}
+}
+/**
+* Classifies every foreign key on a surviving table into one of three cases.
+* A foreign key that carries a `referencedSchema` is checked against the
+* pack-owned coordinates first, so a pack-owned target wins even when a local
+* table happens to share its bare name; only foreign keys with no owned
+* coordinate fall through to the local/dangling distinction.
+*
+* - **Cross-space**: `referencedSchema` is set and a described contract owns
+*   the coordinate `(referencedSchema, 'table', referencedTable)`. The
+*   referenced table is absent from the tree (omitted because the pack
+*   describes it, or never introspected — `contract infer` walks a single
+*   namespace). Removed from `foreignKeys` (so `inferRelations` never falls
+*   back to a bare, unqualified table name for it) and replaced with a
+*   `RelationField` qualified with the owning pack's space id and namespace
+*   id. `owners` holds only pack-declared coordinates, so an app's own table
+*   (e.g. `public.users`) is never owned and cannot be captured here.
+* - **Local**: not a pack-owned coordinate, and the referenced table survived
+*   introspection — left untouched, `inferRelations` handles it as before.
+* - **Dangling**: not a pack-owned coordinate, and the referenced table is
+*   neither in the tree nor owned by any described contract. Removed from
+*   `foreignKeys`, keeping the scalar column, rather than emitting a relation
+*   to a model that was never defined.
+*
+* A pack that owns the referenced coordinate but declares no domain model
+* mapped to it is malformed; that case throws rather than degrading to a
+* silent drop, which would contradict the dangling definition above.
+*/
+function resolveForeignKeys(tables, owners) {
+	const resultTables = {};
+	const extraRelationsByTable = /* @__PURE__ */ new Map();
+	const crossSpaceFieldNamesByTable = /* @__PURE__ */ new Map();
+	for (const [tableName, table] of Object.entries(tables)) {
+		const keptForeignKeys = [];
+		for (const fk of table.foreignKeys) {
+			if (fk.referencedSchema !== void 0) {
+				const owner = owners.get(coordinateKey({
+					namespaceId: fk.referencedSchema,
+					entityKind: "table",
+					entityName: fk.referencedTable
+				}));
+				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 (!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);
+					const relationField = {
+						...buildChildRelationField(fieldName, target.modelName, fk, optional),
+						typeNamespaceId: target.namespaceId,
+						typeContractSpaceId: target.spaceId
+					};
+					const existingRelations = extraRelationsByTable.get(tableName);
+					if (existingRelations) existingRelations.push(relationField);
+					else extraRelationsByTable.set(tableName, [relationField]);
+					continue;
+				}
+			}
+			if (tables[fk.referencedTable] !== void 0) keptForeignKeys.push(fk);
+		}
+		resultTables[tableName] = keptForeignKeys.length === table.foreignKeys.length ? table : new SqlTableIR({
+			...table,
+			foreignKeys: keptForeignKeys
+		});
+	}
+	return {
+		tables: resultTables,
+		extraRelationsByTable,
+		crossSpaceFieldNamesByTable
+	};
+}
+/**
+* Infers a PSL AST (for `printPsl`) from an introspected Postgres schema tree.
+*
+* Target-owned inference: it walks the `PostgresDatabaseSchemaNode` tree and
+* owns the Postgres dialect knowledge — the native type map and default map.
+* Relation inference, name transforms, generic default mapping, and raw-default
+* parsing are shape-neutral utilities imported from the SQL family.
+*
+* This slice emits relational-only PSL, byte-identical to the prior flat
+* inference: the tree's tables (across its namespaces — `contract infer`
+* introspects a single live namespace) are gathered into the model set and
+* emitted as one `UNSPECIFIED_PSL_NAMESPACE_ID` bucket. Top-level entities
+* (policies/roles → PSL extension blocks) are a later slice.
+*
+* `describedContracts` — the stack's extension packs' already-assembled
+* contracts, each paired with its space id — is consulted while gathering
+* tables: a table whose coordinate `(schemaName, 'table', tableName)` one of
+* those contracts already declares is omitted, before the duplicate-name
+* check below and before relation inference, so it cannot spuriously
+* collide with an app table and never contributes a bare relation field. A
+* surviving table's foreign key into an omitted, pack-owned table is not
+* dropped: {@link resolveForeignKeys} rewrites it into a relation qualified
+* with the pack's space id (`<spaceId>:<namespaceId>.<Model>`) instead.
+*/
+function inferPostgresPslContract(tree, describedContracts) {
+	const namespaces = Object.values(tree.namespaces);
+	const owners = describedContractOwners(describedContracts ?? []);
+	const enumOwners = describedNativeEnumOwnersByTypeName(describedContracts ?? []);
+	const enumDefinitions = /* @__PURE__ */ new Map();
+	const packOwnedEnumTypesByNamespace = /* @__PURE__ */ new Map();
+	const enumNamespaceNames = /* @__PURE__ */ new Set();
+	for (const namespace of namespaces) {
+		const definitionsForNamespace = new Set(namespace.nativeEnums.map((e) => e.typeName));
+		for (const typeName of namespace.nativeEnumTypeNames) if (!definitionsForNamespace.has(typeName)) throw new Error(`contract infer: introspection reported native enum type "${typeName}" in schema "${namespace.schemaName}" without member values — the introspected tree's \`nativeEnumTypeNames\` and \`nativeEnums\` are out of sync (internal invariant).`);
+		for (const { typeName, values } of namespace.nativeEnums) {
+			const owner = enumOwners.get(coordinateKey({
+				namespaceId: namespace.schemaName,
+				entityKind: "native_enum",
+				entityName: typeName
+			}));
+			if (owner !== void 0) {
+				const owned = packOwnedEnumTypesByNamespace.get(namespace.schemaName) ?? /* @__PURE__ */ new Map();
+				owned.set(typeName, owner.spaceId);
+				owned.set(`${namespace.schemaName}.${typeName}`, owner.spaceId);
+				packOwnedEnumTypesByNamespace.set(namespace.schemaName, owned);
+				continue;
+			}
+			enumDefinitions.set(typeName, values);
+			enumNamespaceNames.add(namespace.schemaName);
+		}
+	}
+	const tables = {};
+	const tableNamespaceNames = /* @__PURE__ */ new Set();
+	for (const namespace of namespaces) {
+		const ownedEnumTypes = packOwnedEnumTypesByNamespace.get(namespace.schemaName);
+		for (const [tableName, table] of Object.entries(namespace.tables)) {
+			if (owners.has(coordinateKey({
+				namespaceId: namespace.schemaName,
+				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 (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.`);
+			}
+			tables[tableName] = new SqlTableIR(table);
+			tableNamespaceNames.add(namespace.schemaName);
+		}
+	}
+	let wrapNamespaceName;
+	if (enumDefinitions.size > 0) {
+		const contentNamespaces = 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(", ")}.`);
+		wrapNamespaceName = [...contentNamespaces][0];
+	}
+	const { tables: resolvedTables, extraRelationsByTable, crossSpaceFieldNamesByTable } = resolveForeignKeys(tables, owners);
+	const schemaIR = new SqlSchemaIR({ tables: resolvedTables });
+	const enumTypeNames = new Set(enumDefinitions.keys());
+	if (wrapNamespaceName !== void 0) for (const typeName of enumDefinitions.keys()) enumTypeNames.add(`${wrapNamespaceName}.${typeName}`);
+	const enumInfo = {
+		typeNames: enumTypeNames,
+		definitions: enumDefinitions
+	};
+	return buildPslDocumentAst(schemaIR, {
+		typeMap: createPostgresTypeMap(enumInfo.typeNames),
+		defaultMapping: createPostgresDefaultMapping(),
+		parseRawDefault,
+		...enumDefinitions.size > 0 ? { enumInfo } : {}
+	}, {
+		extraRelationsByTable,
+		crossSpaceFieldNamesByTable
+	}, wrapNamespaceName);
+}
+/**
+* Native-enum ownership index for pack subtraction, keyed by TYPE NAME
+* coordinate. A pack contract keys `entries.native_enum` by HANDLE name
+* (`AalLevel`) while introspection sees the Postgres type name (`aal_level`);
+* the entity's `typeName` field carries the mapping, so this walk indexes by
+* it rather than reusing {@link describedContractOwners}' entries-key
+* coordinates.
+*
+* Reads `entries.native_enum` directly: the kind map is carried
+* non-enumerable on `PostgresSchema.entries`, so the generic
+* `elementCoordinates` walk never yields it. Serialized pack contracts do
+* not carry `native_enum` entries at all (`PostgresContractSerializer`
+* strips them; only the derived `valueSet` survives), so this subtraction
+* currently matches in-memory described contracts only.
+*/
+function describedNativeEnumOwnersByTypeName(describedContracts) {
+	const owners = /* @__PURE__ */ new Map();
+	for (const entry of describedContracts) for (const [namespaceId, ns] of Object.entries(entry.contract.storage.namespaces)) {
+		const kindMap = ns.entries["native_enum"];
+		if (!isPlainRecord(kindMap)) continue;
+		for (const entity of Object.values(kindMap)) {
+			if (!PostgresNativeEnum.is(entity)) continue;
+			owners.set(coordinateKey({
+				namespaceId,
+				entityKind: "native_enum",
+				entityName: entity.typeName
+			}), entry);
+		}
+	}
+	return owners;
+}
+function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName) {
+	const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
+	const { extraRelationsByTable, crossSpaceFieldNamesByTable } = foreignKeyExtras;
+	const modelNames = buildTopLevelNameMap(Object.keys(schemaIR.tables), toModelName, "model", "table");
+	const modelNameMap = new Map([...modelNames].map(([tableName, result]) => [tableName, result.name]));
+	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) ?? []]));
+	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>",
+		namespaces: [makePslNamespace({
+			kind: "namespace",
+			name: namespaceName ?? UNSPECIFIED_PSL_NAMESPACE_ID,
+			entries: makePslNamespaceEntries(sortedModels, [], enumBlocks),
+			span: SYNTHETIC_SPAN
+		})],
+		...types ? { types } : {},
+		span: SYNTHETIC_SPAN
+	};
+}
+/**
+* Builds one `native_enum` extension-block AST node per introspected enum
+* definition. Block names go through the shared top-level transform
+* (`toEnumName`, intra-enum collisions throw like model collisions) and are
+* then reserved against the model names — an enum whose PSL name a model
+* already claims gets a numeric suffix, with `@@map` carrying the real type
+* name. Members print as explicit `member = "value"` pairs: the member name
+* is the sanitized value (deduplicated within the block), the JSON-encoded
+* value carries the truth verbatim.
+*/
+function buildNativeEnumBlocks(definitions, modelNames) {
+	const enumNames = buildTopLevelNameMap([...definitions.keys()].sort(), toEnumName, "enum", "enum type");
+	const usedTopLevelNames = new Set(PSL_SCALAR_TYPE_NAMES);
+	for (const result of modelNames.values()) usedTopLevelNames.add(result.name);
+	const enumNameMap = /* @__PURE__ */ new Map();
+	const enumBlocks = [];
+	for (const [typeName, result] of enumNames) {
+		const name = createUniqueFieldName(result.name, usedTopLevelNames);
+		usedTopLevelNames.add(name);
+		enumNameMap.set(typeName, name);
+		enumBlocks.push(buildNativeEnumBlock(name, typeName, definitions.get(typeName) ?? []));
+	}
+	return {
+		enumNameMap,
+		enumBlocks
+	};
+}
+function buildNativeEnumBlock(name, typeName, values) {
+	const usedMemberNames = /* @__PURE__ */ new Set();
+	const parameters = {};
+	for (const value of values) {
+		const memberName = createUniqueFieldName(toEnumMemberName(value), usedMemberNames);
+		usedMemberNames.add(memberName);
+		parameters[memberName] = {
+			kind: "value",
+			raw: JSON.stringify(value),
+			span: SYNTHETIC_SPAN
+		};
+	}
+	return {
+		kind: "native_enum",
+		name,
+		parameters,
+		blockAttributes: name === typeName ? [] : [{
+			name: "map",
+			args: [{
+				kind: "positional",
+				value: `"${escapePslString(typeName)}"`,
+				span: SYNTHETIC_SPAN
+			}],
+			span: SYNTHETIC_SPAN
+		}],
+		span: SYNTHETIC_SPAN
+	};
+}
+function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationFields) {
+	const { name: modelName, map: mapName } = toModelName(table.name);
+	const fieldNameMap = fieldNamesByTable.get(table.name);
+	const pkColumns = new Set(table.primaryKey?.columns ?? []);
+	const isSinglePk = pkColumns.size === 1;
+	const singlePkConstraintName = isSinglePk ? table.primaryKey?.name : void 0;
+	const uniqueColumns = /* @__PURE__ */ new Map();
+	for (const unique of table.uniques) if (unique.columns.length === 1) {
+		const [columnName = ""] = unique.columns;
+		const existingConstraintName = uniqueColumns.get(columnName);
+		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));
+	const usedFieldNames = new Set(fields.map((field) => field.name));
+	for (const rel of relationFields) fields.push(buildRelationField(rel, table.name, fieldNamesByTable, usedFieldNames));
+	const modelAttributes = [];
+	if (table.primaryKey && table.primaryKey.columns.length > 1) {
+		const pkFieldNames = table.primaryKey.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
+		modelAttributes.push(buildModelConstraintAttribute("id", pkFieldNames, table.primaryKey.name));
+	}
+	for (const unique of table.uniques) if (unique.columns.length > 1) {
+		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));
+	}
+	if (mapName) modelAttributes.push(buildMapAttribute("model", mapName));
+	const comment = table.primaryKey ? void 0 : "// WARNING: This table has no primary key in the database";
+	return {
+		kind: "model",
+		name: modelName,
+		fields,
+		attributes: modelAttributes,
+		span: SYNTHETIC_SPAN,
+		...comment !== void 0 ? { comment } : {}
+	};
+}
+function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns) {
+	const resolvedField = fieldNameMap?.get(column.name);
+	const fieldName = resolvedField?.fieldName ?? toFieldName(column.name).name;
+	const fieldMap = resolvedField?.fieldMap;
+	const resolution = typeMap.resolve(column.nativeType, table.annotations);
+	if ("unsupported" in resolution) {
+		const attrs = [];
+		if (fieldMap !== void 0) attrs.push(buildMapAttribute("field", fieldMap));
+		return {
+			kind: "field",
+			name: fieldName,
+			typeName: `Unsupported("${escapePslString(resolution.nativeType)}")`,
+			optional: column.nullable,
+			list: column.many === true,
+			attributes: attrs,
+			span: SYNTHETIC_SPAN
+		};
+	}
+	let typeName = resolution.pslType;
+	let typeConstructor;
+	const enumPslName = enumNameMap.get(column.nativeType);
+	if (enumPslName) {
+		typeName = enumPslName;
+		typeConstructor = {
+			kind: "typeConstructor",
+			path: ["pg", "enum"],
+			args: [positionalArg(enumPslName)],
+			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));
+	if (column.default !== void 0) {
+		const parsed = parseColumnDefault(column.default, column.nativeType, rawDefaultParser);
+		if (parsed) {
+			const result = mapDefault(parsed, defaultMapping);
+			if ("attribute" in result) attributes.push(parseDefaultAttributeString(result.attribute));
+		}
+	}
+	if (uniqueColumns.has(column.name) && !isId) {
+		const uniqueConstraintName = uniqueColumns.get(column.name);
+		attributes.push(buildSimpleConstraintFieldAttribute("unique", uniqueConstraintName));
+	}
+	if (fieldMap !== void 0) attributes.push(buildMapAttribute("field", fieldMap));
+	return {
+		kind: "field",
+		name: fieldName,
+		typeName,
+		...ifDefined("typeConstructor", typeConstructor),
+		optional: column.nullable,
+		list: column.many === true,
+		attributes,
+		span: SYNTHETIC_SPAN
+	};
+}
+function buildRelationField(rel, hostTableName, fieldNamesByTable, usedFieldNames) {
+	const fieldName = createUniqueFieldName(rel.fieldName, usedFieldNames);
+	usedFieldNames.add(fieldName);
+	const args = [];
+	if (rel.fields && rel.references) {
+		if (rel.relationName) args.push(namedArg("name", `"${escapePslString(rel.relationName)}"`));
+		args.push(namedArg("fields", `[${rel.fields.map((columnName) => resolveColumnFieldName(fieldNamesByTable, hostTableName, columnName)).join(", ")}]`));
+		args.push(namedArg("references", `[${rel.references.map((columnName) => resolveColumnFieldName(fieldNamesByTable, rel.referencedTableName ?? "", columnName)).join(", ")}]`));
+		if (rel.onDelete) args.push(namedArg("onDelete", rel.onDelete));
+		if (rel.onUpdate) args.push(namedArg("onUpdate", rel.onUpdate));
+		if (rel.fkName) args.push(namedArg("map", `"${escapePslString(rel.fkName)}"`));
+	} else if (rel.relationName) args.push(namedArg("name", `"${escapePslString(rel.relationName)}"`));
+	const attrs = args.length > 0 ? [buildAttribute("field", "relation", args)] : [];
+	return {
+		kind: "field",
+		name: fieldName,
+		typeName: rel.typeName,
+		...ifDefined("typeNamespaceId", rel.typeNamespaceId),
+		...ifDefined("typeContractSpaceId", rel.typeContractSpaceId),
+		optional: rel.optional,
+		list: rel.list,
+		attributes: attrs,
+		span: SYNTHETIC_SPAN
+	};
+}
+function buildModelConstraintAttribute(name, fields, constraintName) {
+	const args = [positionalArg(`[${fields.join(", ")}]`)];
+	if (constraintName !== void 0) args.push(namedArg("map", `"${escapePslString(constraintName)}"`));
+	return buildAttribute("model", name, args);
+}
+function buildSimpleConstraintFieldAttribute(name, constraintName) {
+	if (constraintName === void 0) return buildAttribute("field", name, []);
+	return buildAttribute("field", name, [namedArg("map", `"${escapePslString(constraintName)}"`)]);
+}
+function parseDefaultAttributeString(attributeText) {
+	return buildAttribute("field", "default", [positionalArg(attributeText.replace(/^@default\(/, "").replace(/\)$/, ""))]);
+}
+function buildMapAttribute(target, mapName) {
+	return buildAttribute(target, "map", [positionalArg(`"${escapePslString(mapName)}"`)]);
+}
+function buildAttribute(target, name, args) {
+	return {
+		kind: "attribute",
+		target,
+		name,
+		args,
+		span: SYNTHETIC_SPAN
+	};
+}
+function positionalArg(value) {
+	return {
+		kind: "positional",
+		value,
+		span: SYNTHETIC_SPAN
 	};
 }
+function namedArg(name, value) {
+	return {
+		kind: "named",
+		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");
+}
+/**
+* Resolves a `SqlColumnIR.default` value into a normalized {@link ColumnDefault}.
+*
+* `SqlSchemaIR` types the column default as `string` (a raw database default
+* expression). Some legacy fixtures and tests still pass already-normalized
+* `ColumnDefault` objects in the same slot, so we accept either shape
+* defensively at runtime.
+*/
+function parseColumnDefault(value, nativeType, rawDefaultParser) {
+	if (typeof value === "string") return rawDefaultParser ? rawDefaultParser(value, nativeType) : void 0;
+	if (value !== null && typeof value === "object" && "kind" in value) return value;
+}
+function buildFieldNamesByTable(tables) {
+	const fieldNamesByTable = /* @__PURE__ */ new Map();
+	for (const table of Object.values(tables)) {
+		const assignmentOrder = [...Object.values(table.columns).map((column, index) => {
+			const { name, map } = toFieldName(column.name);
+			return {
+				columnName: column.name,
+				desiredFieldName: name,
+				fieldMap: map,
+				index
+			};
+		})].sort((left, right) => {
+			const mapComparison = Number(left.fieldMap !== void 0) - Number(right.fieldMap !== void 0);
+			if (mapComparison !== 0) return mapComparison;
+			return left.index - right.index;
+		});
+		const usedFieldNames = /* @__PURE__ */ new Set();
+		const tableFieldNames = /* @__PURE__ */ new Map();
+		for (const column of assignmentOrder) {
+			const fieldName = createUniqueFieldName(column.desiredFieldName, usedFieldNames);
+			usedFieldNames.add(fieldName);
+			tableFieldNames.set(column.columnName, {
+				fieldName,
+				fieldMap: column.fieldMap
+			});
+		}
+		fieldNamesByTable.set(table.name, tableFieldNames);
+	}
+	return fieldNamesByTable;
+}
+function resolveColumnFieldName(fieldNamesByTable, tableName, columnName) {
+	return fieldNamesByTable.get(tableName)?.get(columnName)?.fieldName ?? toFieldName(columnName).name;
+}
+function createUniqueFieldName(desiredName, usedFieldNames) {
+	if (!usedFieldNames.has(desiredName)) return desiredName;
+	let counter = 2;
+	while (usedFieldNames.has(`${desiredName}${counter}`)) counter++;
+	return `${desiredName}${counter}`;
+}
+function buildTopLevelNameMap(sources, normalize, kind, sourceKind) {
+	const results = /* @__PURE__ */ new Map();
+	const normalizedToSources = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const normalized = normalize(source);
+		results.set(source, normalized);
+		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")}`);
+	}
+	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);
+	const deps = /* @__PURE__ */ new Map();
+	const tableToModel = /* @__PURE__ */ new Map();
+	for (const tableName of Object.keys(tables)) {
+		const modelName = modelNameMap.get(tableName);
+		tableToModel.set(tableName, modelName);
+		deps.set(modelName, /* @__PURE__ */ new Set());
+	}
+	for (const [tableName, table] of Object.entries(tables)) {
+		const modelName = tableToModel.get(tableName);
+		for (const fk of table.foreignKeys) {
+			const refModelName = tableToModel.get(fk.referencedTable);
+			if (refModelName && refModelName !== modelName) deps.get(modelName).add(refModelName);
+		}
+	}
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
+	const sortedNames = [...deps.keys()].sort();
+	function visit(name) {
+		if (visited.has(name)) return;
+		if (visiting.has(name)) return;
+		visiting.add(name);
+		const sortedDeps = [...deps.get(name)].sort();
+		for (const dep of sortedDeps) visit(dep);
+		visiting.delete(name);
+		visited.add(name);
+		result.push(modelByName.get(name));
+	}
+	for (const name of sortedNames) visit(name);
+	return result;
+}
+//#endregion
+//#region src/exports/control.ts
 function postgresRenderDefault(def, column) {
 	if (def.kind === "function") return def.expression;
 	return renderDefaultLiteral(def.value, column);
@@ -428,6 +1283,15 @@ const postgresTargetDescriptor = {
 	...postgresTargetDescriptorMeta,
 	contractSerializer: new PostgresContractSerializer(),
 	schemaVerifier: new PostgresSchemaVerifier(),
+	inferPslContract(schema, describedContracts) {
+		PostgresDatabaseSchemaNode.assert(schema);
+		return inferPostgresPslContract(schema, describedContracts);
+	},
+	diffSchema(input) {
+		return diffPostgresSchema(input);
+	},
+	classifySubjectGranularity: postgresDiffSubjectGranularity,
+	classifyEntityKind: postgresDiffSubjectEntityKind,
 	migrations: {
 		createPlanner(adapter) {
 			return createPostgresMigrationPlanner(adapter);
@@ -436,9 +1300,10 @@ const postgresTargetDescriptor = {
 			return createPostgresMigrationRunner(family);
 		},
 		contractToSchema(contract, frameworkComponents) {
-			return contractToSchemaIR(contract, {
+			const expander = buildNativeTypeExpander(frameworkComponents);
+			return contractToPostgresDatabaseSchemaNode(blindCast(contract), {
 				annotationNamespace: "pg",
-				...ifDefined("expandNativeType", buildNativeTypeExpander(frameworkComponents)),
+				...ifDefined("expandNativeType", expander),
 				renderDefault: postgresRenderDefault
 			});
 		}