@prisma/orm-target-postgres 0.16.0-dev.36

package/dist/control-DRMWptiJ.mjs

@@ -0,0 +1,1355 @@
+import { n as postgresError } from "./errors-kYxOQjdD-D4T3rbVp.mjs";
+import { n as postgresResolveDefault } from "./default-normalizer-Ba5ZebHM-isV86rjy.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DnHabAS3-C53XXPQw.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 { r as renderDefaultLiteral } from "./planner-ddl-builders-CbfICQfm-CxYiLrhX.mjs";
+import { n as contractToPostgresDatabaseSchemaNode, r as diffPostgresSchema } from "./diff-database-schema-BfRs2vrG-D2o4KII0.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-view-FdLX7dV9-Cat1VKV9.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-Bmje9ii8-B99fEsNM.mjs";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { UNBOUND_NAMESPACE_ID, coordinateKey, elementCoordinates } from "@prisma/orm-framework/components/ir";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { computeIndexContentHash, parseWireName } from "@prisma/orm-family-sql/schema-ir/naming";
+import { assertDefined } from "@prisma/orm-framework/utils/assertions";
+import { APP_SPACE_ID } from "@prisma/orm-framework/components/control";
+import { buildNativeTypeExpander, runnerFailure, runnerSuccess } from "@prisma/orm-family-sql/family/control";
+import { SqlSchemaIR, SqlTableIR } from "@prisma/orm-family-sql/schema-ir/types";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { notOk, ok, okVoid } from "@prisma/orm-framework/utils/result";
+import { SqlSchemaVerifierBase } from "@prisma/orm-family-sql/family/ir";
+import { SqlQueryError } from "@prisma/orm-family-sql/errors";
+import { buildChildRelationField, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, toEnumMemberName, toEnumName, toFieldName, toModelName } from "@prisma/orm-family-sql/family/psl-infer";
+import { UNSPECIFIED_PSL_NAMESPACE_ID, makePslNamespace, makePslNamespaceEntries } from "@prisma/orm-framework/components/psl-ast";
+import { isColumnDefault } from "@prisma/orm-framework/contract/types";
+//#region ../../../3-targets/3-targets/postgres/dist/control.mjs
+const LOCK_DOMAIN = "prisma_next.contract.marker";
+/**
+* Deep clones and freezes a record object to prevent mutation.
+* Recursively clones nested objects and arrays to ensure complete isolation.
+*/
+function cloneAndFreezeRecord(value) {
+	const cloned = {};
+	for (const [key, val] of Object.entries(value)) if (val === null || val === void 0) cloned[key] = val;
+	else if (Array.isArray(val)) cloned[key] = Object.freeze([...val]);
+	else if (typeof val === "object") cloned[key] = cloneAndFreezeRecord(val);
+	else cloned[key] = val;
+	return Object.freeze(cloned);
+}
+function createPostgresMigrationRunner(family) {
+	return new PostgresMigrationRunner(family);
+}
+var PostgresMigrationRunner = class {
+	family;
+	constructor(family) {
+		this.family = family;
+	}
+	/**
+	* Body of the migration runner without transaction management. The
+	* caller ({@link PostgresMigrationRunner.execute}) owns the
+	* `BEGIN`/`COMMIT`/`ROLLBACK` lifecycle.
+	*/
+	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 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));
+		const destinationCheck = this.ensurePlanMatchesDestinationContract(options.plan.destination, options.destinationContract);
+		if (!destinationCheck.ok) return destinationCheck;
+		const policyCheck = this.enforcePolicyCompatibility(options.policy, planOps);
+		if (!policyCheck.ok) return policyCheck;
+		await this.acquireLock(driver, lockKey);
+		const ensureResult = await this.ensureControlTables(driver, options.destinationContract);
+		if (!ensureResult.ok) return ensureResult;
+		const existingMarker = await this.family.readMarker({
+			driver,
+			space
+		});
+		const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
+		if (!markerCheck.ok) return markerCheck;
+		const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
+		const isSelfEdge = options.plan.origin?.storageHash === options.plan.destination.storageHash;
+		const skipOperations = markerAtDestination && options.plan.origin != null && !isSelfEdge;
+		let applyValue;
+		if (skipOperations) applyValue = {
+			operationsExecuted: 0,
+			executedOperations: []
+		};
+		else {
+			const applyResult = await this.applyPlan(driver, options, planOps);
+			if (!applyResult.ok) return applyResult;
+			applyValue = applyResult.value;
+		}
+		if (space === APP_SPACE_ID) {
+			const schemaNode = await this.family.introspect({
+				driver,
+				contract: options.destinationContract
+			});
+			const schemaVerifyResult = this.family.verifySchema({
+				contract: options.destinationContract,
+				schema: schemaNode,
+				strict: options.strictVerification ?? true,
+				frameworkComponents: options.frameworkComponents
+			});
+			if (!schemaVerifyResult.ok) return runnerFailure("MIGRATION.SCHEMA_VERIFY_FAILED", schemaVerifyResult.summary, {
+				why: "The resulting database schema does not satisfy the destination contract.",
+				meta: { issues: schemaVerifyResult.schema.issues }
+			});
+		}
+		const incomingInvariants = options.plan.providedInvariants ?? [];
+		const existingInvariants = new Set(existingMarker?.invariants ?? []);
+		const incomingIsSubsetOfExisting = incomingInvariants.every((id) => existingInvariants.has(id));
+		if (!(isSelfEdge && applyValue.operationsExecuted === 0 && incomingIsSubsetOfExisting)) {
+			const markerResult = await this.upsertMarker(driver, options, existingMarker, space);
+			if (!markerResult.ok) return markerResult;
+			await this.recordLedgerEntries(driver, options, applyValue.executedOperations, planOps.length);
+		}
+		return runnerSuccess({
+			operationsPlanned: planOps.length,
+			operationsExecuted: applyValue.operationsExecuted
+		});
+	}
+	async execute(options) {
+		const driver = options.driver;
+		const perSpaceOptions = options.perSpaceOptions;
+		if (perSpaceOptions.length === 0) return ok({ perSpaceResults: [] });
+		await this.beginTransaction(driver);
+		let committed = false;
+		try {
+			const perSpaceResults = [];
+			for (const spaceOptions of perSpaceOptions) {
+				const space = spaceOptions.space ?? spaceOptions.plan.spaceId;
+				const result = await this.executeOnConnection({
+					...spaceOptions,
+					driver,
+					space
+				});
+				if (!result.ok) return notOk({
+					...result.failure,
+					failingSpace: space
+				});
+				perSpaceResults.push({
+					space,
+					value: result.value
+				});
+			}
+			await this.commitTransaction(driver);
+			committed = true;
+			return ok({ perSpaceResults });
+		} finally {
+			if (!committed) await this.rollbackTransaction(driver);
+		}
+	}
+	async applyPlan(driver, options, ops) {
+		const checks = options.executionChecks;
+		const runPrechecks = checks?.prechecks !== false;
+		const runPostchecks = checks?.postchecks !== false;
+		const runIdempotency = checks?.idempotencyChecks !== false;
+		let operationsExecuted = 0;
+		const executedOperations = [];
+		for (const operation of ops) {
+			options.callbacks?.onOperationStart?.(operation);
+			try {
+				if (runPostchecks && runIdempotency) {
+					if (await this.expectationsAreSatisfied(driver, operation.postcheck)) {
+						executedOperations.push(this.createPostcheckPreSatisfiedSkipRecord(operation));
+						continue;
+					}
+				}
+				if (runPrechecks) {
+					const precheckResult = await this.runExpectationSteps(driver, operation.precheck, operation, "precheck");
+					if (!precheckResult.ok) return precheckResult;
+				}
+				const executeResult = await this.runExecuteSteps(driver, operation.execute, operation);
+				if (!executeResult.ok) return executeResult;
+				if (runPostchecks) {
+					const postcheckResult = await this.runExpectationSteps(driver, operation.postcheck, operation, "postcheck");
+					if (!postcheckResult.ok) return postcheckResult;
+				}
+				executedOperations.push(operation);
+				operationsExecuted += 1;
+			} finally {
+				options.callbacks?.onOperationComplete?.(operation);
+			}
+		}
+		return ok({
+			operationsExecuted,
+			executedOperations
+		});
+	}
+	async ensureControlTables(driver, contract) {
+		const lowererContext = { contract };
+		const [schemaQuery, ...tableQueries] = this.family.bootstrapControlTableQueries();
+		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;
+		for (const query of tableQueries) await this.executeStatement(driver, await this.family.lowerAst(query, lowererContext));
+		return okVoid();
+	}
+	async detectLegacyMarkerShape(driver) {
+		const result = await driver.query(`select column_name
+         from information_schema.columns
+        where table_schema = 'prisma_contract'
+          and table_name = 'marker'`);
+		if (result.rows.length === 0) return okVoid();
+		const columns = new Set(result.rows.map((row) => row.column_name));
+		if (columns.has("space")) return okVoid();
+		return runnerFailure("MIGRATION.LEGACY_MARKER_SHAPE", "Legacy marker-table shape detected on prisma_contract.marker (no `space` column). Prisma Next is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. Drop `prisma_contract.marker` and re-run `dbInit` to reinitialise from a clean baseline.", { meta: {
+			table: "prisma_contract.marker",
+			columns: [...columns].sort()
+		} });
+	}
+	async runExpectationSteps(driver, steps, operation, phase) {
+		for (const step of steps) {
+			const result = await driver.query(step.sql, step.params ?? []);
+			if (!this.stepResultIsTrue(result.rows)) return runnerFailure(phase === "precheck" ? "MIGRATION.PRECHECK_FAILED" : "MIGRATION.POSTCHECK_FAILED", `Operation ${operation.id} failed during ${phase}: ${step.description}`, { meta: {
+				operationId: operation.id,
+				phase,
+				stepDescription: step.description
+			} });
+		}
+		return okVoid();
+	}
+	async runExecuteSteps(driver, steps, operation) {
+		for (const step of steps) try {
+			await driver.query(step.sql, step.params ?? []);
+		} catch (error) {
+			if (SqlQueryError.is(error)) return runnerFailure("MIGRATION.EXECUTION_FAILED", `Operation ${operation.id} failed during execution: ${step.description}`, {
+				why: error.message,
+				meta: {
+					operationId: operation.id,
+					stepDescription: step.description,
+					sql: step.sql,
+					sqlState: error.sqlState,
+					constraint: error.constraint,
+					table: error.table,
+					column: error.column,
+					detail: error.detail
+				}
+			});
+			throw error;
+		}
+		return okVoid();
+	}
+	stepResultIsTrue(rows) {
+		if (!rows || rows.length === 0) return false;
+		const firstRow = rows[0];
+		const firstValue = firstRow ? Object.values(firstRow)[0] : void 0;
+		if (typeof firstValue === "boolean") return firstValue;
+		if (typeof firstValue === "number") return firstValue !== 0;
+		if (typeof firstValue === "string") {
+			const lower = firstValue.toLowerCase();
+			if (lower === "t" || lower === "true" || lower === "1") return true;
+			if (lower === "f" || lower === "false" || lower === "0") return false;
+			return firstValue.length > 0;
+		}
+		return Boolean(firstValue);
+	}
+	async expectationsAreSatisfied(driver, steps) {
+		if (steps.length === 0) return false;
+		for (const step of steps) {
+			const result = await driver.query(step.sql, step.params ?? []);
+			if (!this.stepResultIsTrue(result.rows)) return false;
+		}
+		return true;
+	}
+	createPostcheckPreSatisfiedSkipRecord(operation) {
+		const clonedMeta = operation.meta ? cloneAndFreezeRecord(operation.meta) : void 0;
+		const runnerMeta = Object.freeze({
+			skipped: true,
+			reason: "postcheck_pre_satisfied"
+		});
+		const mergedMeta = Object.freeze({
+			...clonedMeta ?? {},
+			runner: runnerMeta
+		});
+		const frozenPostcheck = Object.freeze([...operation.postcheck]);
+		return Object.freeze({
+			id: operation.id,
+			label: operation.label,
+			...ifDefined("summary", operation.summary),
+			operationClass: operation.operationClass,
+			target: operation.target,
+			precheck: Object.freeze([]),
+			execute: Object.freeze([]),
+			postcheck: frozenPostcheck,
+			...ifDefined("meta", operation.meta || mergedMeta ? mergedMeta : void 0)
+		});
+	}
+	markerMatchesDestination(marker, plan) {
+		if (!marker) return false;
+		if (marker.storageHash !== plan.destination.storageHash) return false;
+		if (plan.destination.profileHash && marker.profileHash !== plan.destination.profileHash) return false;
+		return true;
+	}
+	enforcePolicyCompatibility(policy, operations) {
+		const allowedClasses = new Set(policy.allowedOperationClasses);
+		for (const operation of operations) if (!allowedClasses.has(operation.operationClass)) return runnerFailure("MIGRATION.POLICY_VIOLATION", `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`, {
+			why: `Policy only allows: ${policy.allowedOperationClasses.join(", ")}.`,
+			meta: {
+				operationId: operation.id,
+				operationClass: operation.operationClass,
+				allowedClasses: policy.allowedOperationClasses
+			}
+		});
+		return okVoid();
+	}
+	ensureMarkerCompatibility(marker, plan) {
+		const origin = plan.origin ?? null;
+		if (!origin) return okVoid();
+		if (!marker) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
+		if (marker.storageHash !== origin.storageHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
+			markerStorageHash: marker.storageHash,
+			expectedOriginStorageHash: origin.storageHash
+		} });
+		if (origin.profileHash && marker.profileHash !== origin.profileHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker profile hash (${marker.profileHash}) does not match plan origin profile hash (${origin.profileHash}).`, { meta: {
+			markerProfileHash: marker.profileHash,
+			expectedOriginProfileHash: origin.profileHash
+		} });
+		return okVoid();
+	}
+	ensurePlanMatchesDestinationContract(destination, contract) {
+		if (destination.storageHash !== contract.storage.storageHash) return runnerFailure("MIGRATION.DESTINATION_CONTRACT_MISMATCH", `Plan destination storage hash (${destination.storageHash}) does not match provided contract storage hash (${contract.storage.storageHash}).`, { meta: {
+			planStorageHash: destination.storageHash,
+			contractStorageHash: contract.storage.storageHash
+		} });
+		if (destination.profileHash && contract.profileHash && destination.profileHash !== contract.profileHash) return runnerFailure("MIGRATION.DESTINATION_CONTRACT_MISMATCH", `Plan destination profile hash (${destination.profileHash}) does not match provided contract profile hash (${contract.profileHash}).`, { meta: {
+			planProfileHash: destination.profileHash,
+			contractProfileHash: contract.profileHash
+		} });
+		return okVoid();
+	}
+	async upsertMarker(driver, options, existingMarker, space) {
+		const destination = {
+			storageHash: options.plan.destination.storageHash,
+			profileHash: options.plan.destination.profileHash ?? options.destinationContract.profileHash ?? options.plan.destination.storageHash,
+			invariants: options.plan.providedInvariants ?? []
+		};
+		if (!existingMarker) {
+			await this.family.initMarker({
+				driver,
+				space,
+				destination
+			});
+			return okVoid();
+		}
+		if (!await this.family.updateMarker({
+			driver,
+			space,
+			expectedFrom: existingMarker.storageHash,
+			destination
+		})) return runnerFailure("MIGRATION.MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
+			space,
+			expectedStorageHash: existingMarker.storageHash,
+			destinationStorageHash: options.plan.destination.storageHash
+		} });
+		return okVoid();
+	}
+	async recordLedgerEntries(driver, options, executedOperations, planOpsLength) {
+		const space = options.plan.spaceId;
+		const edges = options.migrationEdges;
+		const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
+		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);
+			offset += edge.operationCount;
+			await this.family.writeLedgerEntry({
+				driver,
+				space,
+				entry: {
+					edgeId: `${edge.from}->${edge.to}`,
+					from: edge.from,
+					to: edge.to,
+					migrationName: edge.dirName,
+					migrationHash: edge.migrationHash,
+					operations: edgeOps,
+					...ifDefined("destinationContractJson", edge.destinationContractJson)
+				}
+			});
+		}
+	}
+	async acquireLock(driver, key) {
+		await driver.query("select pg_advisory_xact_lock(hashtext($1))", [key]);
+	}
+	async beginTransaction(driver) {
+		await driver.query("BEGIN");
+	}
+	async commitTransaction(driver) {
+		await driver.query("COMMIT");
+	}
+	async rollbackTransaction(driver) {
+		await driver.query("ROLLBACK");
+	}
+	async executeStatement(driver, statement) {
+		await driver.query(statement.sql, statement.params);
+	}
+};
+/**
+* Postgres target `SchemaVerifier` concretion. Plugs into the
+* SQL-shared verification surface; production verification today still
+* 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
+* point `verifyCommonSqlSchema` will likely lift onto the family base
+* (mirroring `verifyCommonMongoSchema`) and `verifyTargetExtensions`
+* will house Postgres-only kinds (functions, RLS policies in a future
+* project).
+*/
+var PostgresSchemaVerifier = class extends SqlSchemaVerifierBase {
+	verifyCommonSqlSchema(_options) {
+		return [];
+	}
+	verifyTargetExtensions(_options) {
+		return [];
+	}
+};
+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) 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 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);
+		assertDefined(modelName, `topologicalSort: no model name mapped for table "${tableName}"`);
+		tableToModel.set(tableName, modelName);
+		deps.set(modelName, /* @__PURE__ */ new Set());
+	}
+	for (const [tableName, table] of Object.entries(tables)) {
+		const modelName = tableToModel.get(tableName);
+		assertDefined(modelName, `topologicalSort: no model name recorded for table "${tableName}"`);
+		const modelDeps = deps.get(modelName);
+		assertDefined(modelDeps, `topologicalSort: no dependency set recorded for model "${modelName}"`);
+		for (const fk of table.foreignKeys) {
+			const refModelName = tableToModel.get(fk.referencedTable);
+			if (refModelName && refModelName !== modelName) modelDeps.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 nameDeps = deps.get(name);
+		assertDefined(nameDeps, `topologicalSort: no dependency set recorded for model "${name}"`);
+		const sortedDeps = [...nameDeps].sort();
+		for (const dep of sortedDeps) visit(dep);
+		visiting.delete(name);
+		visited.add(name);
+		const model = modelByName.get(name);
+		assertDefined(model, `topologicalSort: no model block recorded for "${name}"`);
+		result.push(model);
+	}
+	for (const name of sortedNames) visit(name);
+	return result;
+}
+const SYNTHETIC_SPAN = {
+	start: {
+		offset: 0,
+		line: 1,
+		column: 1
+	},
+	end: {
+		offset: 0,
+		line: 1,
+		column: 1
+	}
+};
+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 escapePslString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+/**
+* Formats a resolved literal-default array as PSL literal-list syntax
+* (`[1, 2, 3]`, `["a", "b"]`, `[]`). PSL's list-literal grammar only accepts
+* string/number/boolean elements, so any other element (e.g. `null`, a
+* nested array/object) makes the value unrepresentable and this returns
+* `undefined`.
+*/
+function formatPslListLiteralValue(elements) {
+	const parts = [];
+	for (const element of elements) if (typeof element === "string") parts.push(`"${escapePslString(element)}"`);
+	else if (typeof element === "number" || typeof element === "boolean") parts.push(String(element));
+	else return;
+	return `[${parts.join(", ")}]`;
+}
+/**
+* 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;
+	return isColumnDefault(value) ? value : void 0;
+}
+const PSL_SCALAR_TYPE_NAMES = /* @__PURE__ */ new Set([
+	"String",
+	"Boolean",
+	"Int",
+	"BigInt",
+	"Float",
+	"Decimal",
+	"DateTime",
+	"Json",
+	"Bytes"
+]);
+/**
+* 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",
+		keyword: "native_enum",
+		name,
+		parameters,
+		blockAttributes: name === typeName ? [] : [{
+			name: "map",
+			args: [{
+				kind: "positional",
+				value: `"${escapePslString(typeName)}"`,
+				span: SYNTHETIC_SPAN
+			}],
+			span: SYNTHETIC_SPAN
+		}],
+		span: SYNTHETIC_SPAN
+	};
+}
+/**
+* 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();
+	const danglingForeignKeysByTable = /* @__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 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);
+					const relationField = {
+						...buildChildRelationField(fieldName, target.modelName, fk, optional, void 0, table),
+						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);
+			else {
+				const dangling = {
+					columns: fk.columns,
+					referencedSchema: fk.referencedSchema,
+					referencedTable: fk.referencedTable
+				};
+				const existingDangling = danglingForeignKeysByTable.get(tableName);
+				if (existingDangling) existingDangling.push(dangling);
+				else danglingForeignKeysByTable.set(tableName, [dangling]);
+			}
+		}
+		resultTables[tableName] = keptForeignKeys.length === table.foreignKeys.length ? table : new SqlTableIR({
+			...table,
+			foreignKeys: keptForeignKeys
+		});
+	}
+	return {
+		tables: resultTables,
+		extraRelationsByTable,
+		crossSpaceFieldNamesByTable,
+		danglingForeignKeysByTable
+	};
+}
+/**
+* Explains a foreign key `resolveForeignKeys` dropped as dangling: the
+* database enforces it, but its target lives outside the introspected
+* schema, so infer has no model to point a relation at. The suggested fix
+* targets the common cause — an unconfigured extension pack's schema
+* (e.g. Supabase's `auth`).
+*/
+function buildDanglingForeignKeyWarning(danglingForeignKeys, fieldNamesByTable, tableName) {
+	return `Foreign key ${danglingForeignKeys.map((fk) => {
+		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 extensions and re-run infer.`;
+}
+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);
+}
+/**
+* Emits one `@@index` attribute at full fidelity. The index's identity is
+* re-detected rather than trusted: `name:` is emitted only when the live name
+* parses as a wire name AND that hash recomputes from the introspected
+* content; otherwise the live name is adopted verbatim with `map:`.
+*/
+function buildIndexAttribute(index, fieldNames) {
+	const args = [];
+	if (fieldNames !== void 0) args.push(positionalArg(`[${fieldNames.join(", ")}]`));
+	else {
+		assertDefined(index.expression, `buildIndexAttribute: index "${index.name}" carries neither columns nor expression; SqlIndexIR enforces exactly one`);
+		args.push(namedArg("expression", `"${escapePslString(index.expression)}"`));
+	}
+	const parsed = parseWireName(index.name);
+	const recomputed = computeIndexContentHash({
+		...index.columns !== void 0 ? { columns: index.columns } : {},
+		...index.expression !== void 0 ? { expression: index.expression } : {},
+		...index.where !== void 0 ? { where: index.where } : {},
+		unique: index.unique,
+		...index.type !== void 0 ? { type: index.type } : {},
+		...index.options !== void 0 ? { options: index.options } : {}
+	});
+	if (parsed !== void 0 && parsed.hash === recomputed) args.push(namedArg("name", `"${escapePslString(parsed.prefix)}"`));
+	else args.push(namedArg("map", `"${escapePslString(index.name)}"`));
+	if (index.where !== void 0) args.push(namedArg("where", `"${escapePslString(index.where)}"`));
+	if (index.unique) args.push(namedArg("unique", "true"));
+	const hasOptions = index.options !== void 0 && Object.keys(index.options).length > 0;
+	if (index.type !== void 0 || hasOptions) args.push(namedArg("type", `"${escapePslString(index.type ?? "btree")}"`));
+	if (hasOptions) {
+		const entries = Object.entries(index.options ?? {}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, value]) => `${key}: "${escapePslString(String(value))}"`);
+		args.push(namedArg("options", `{ ${entries.join(", ")} }`));
+	}
+	return buildAttribute("model", "index", args);
+}
+function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, defaultMapping, rawDefaultParser, relationFields, danglingForeignKeys, rlsEnabled = false, policySkipNotes = []) {
+	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, 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) {
+		const indexFieldNames = index.columns?.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
+		modelAttributes.push(buildIndexAttribute(index, indexFieldNames));
+	}
+	if (mapName) modelAttributes.push(buildMapAttribute("model", mapName));
+	if (rlsEnabled) modelAttributes.push(buildAttribute("model", "rls", []));
+	const warnings = [];
+	if (!table.primaryKey) warnings.push("This table has no primary key in the database");
+	if (danglingForeignKeys.length > 0) warnings.push(buildDanglingForeignKeyWarning(danglingForeignKeys, fieldNamesByTable, table.name));
+	const commentLines = [...warnings.length > 0 ? [`// WARNING: ${warnings.join(" ")}`] : [], ...policySkipNotes];
+	const comment = commentLines.length > 0 ? commentLines.join("\n") : void 0;
+	return {
+		kind: "model",
+		name: modelName,
+		fields,
+		attributes: modelAttributes,
+		span: SYNTHETIC_SPAN,
+		...comment !== void 0 ? { comment } : {}
+	};
+}
+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;
+	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.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;
+		typeConstructor = {
+			kind: "typeConstructor",
+			path: ["pg", "enum"],
+			args: [positionalArg(enumPslName)],
+			span: SYNTHETIC_SPAN
+		};
+	}
+	const attributes = [];
+	const isId = isSinglePk && pkColumns.has(column.name);
+	if (isId) attributes.push(buildSimpleConstraintFieldAttribute("id", singlePkConstraintName));
+	if (column.default === void 0 && column.resolvedDefault?.kind === "function" && column.resolvedDefault.expression === "autoincrement()") attributes.push(parseDefaultAttributeString("@default(autoincrement())"));
+	else if (column.many === true && column.resolvedDefault?.kind === "literal") {
+		const formatted = Array.isArray(column.resolvedDefault.value) ? formatPslListLiteralValue(column.resolvedDefault.value) : void 0;
+		if (formatted !== void 0) attributes.push(parseDefaultAttributeString(`@default(${formatted})`));
+	} else 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)}"`));
+		if (rel.index === false) args.push(namedArg("index", "false"));
+	} 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
+	};
+}
+const POLICY_OPERATION_KEYWORD = {
+	select: "policy_select",
+	insert: "policy_insert",
+	update: "policy_update",
+	delete: "policy_delete",
+	all: "policy_all"
+};
+/** The PSL tokenizer's identifier grammar: leading letter/underscore, then letters/digits/`_`/`-`. */
+const PSL_IDENTIFIER = /^[\p{L}_][\p{L}\p{N}_-]*$/u;
+/** Replaces invalid character runs with `_`; prepends `_` when the first character is invalid. */
+function sanitizePolicyHead(raw) {
+	let head = raw.replace(/[^\p{L}\p{N}_-]+/gu, "_");
+	if (!/^[\p{L}_]/u.test(head)) head = `_${head}`;
+	return head;
+}
+/**
+* Builds one `policy_<operation>` block per introspected policy. Every
+* adopted policy is exact-named: a reprinted body never reliably re-hashes to
+* the live suffix, so `@@map` always carries the physical name and the head
+* is only an identifier. A policy granting to a role whose name is not a
+* legal identifier cannot be authored at all — role references have no
+* `@@map` escape — so it is skipped with a note.
+*/
+function buildPolicyBlocks(policiesByTable, modelNameMap, reservedHeads = /* @__PURE__ */ new Set()) {
+	const all = [];
+	for (const [tableName, policies] of policiesByTable) for (const policy of policies) all.push({
+		policy,
+		tableName
+	});
+	all.sort((a, b) => {
+		if (a.policy.name !== b.policy.name) return a.policy.name < b.policy.name ? -1 : 1;
+		if (a.tableName !== b.tableName) return a.tableName < b.tableName ? -1 : 1;
+		return a.policy.operation < b.policy.operation ? -1 : a.policy.operation > b.policy.operation ? 1 : 0;
+	});
+	const usedHeads = new Set(reservedHeads);
+	const blocks = [];
+	const skipNotesByTable = /* @__PURE__ */ new Map();
+	for (const { policy, tableName } of all) {
+		const modelName = modelNameMap.get(tableName);
+		assertDefined(modelName, `buildPolicyBlocks: policy "${policy.name}" targets table "${tableName}" with no emitted model; tables and policies come from the same introspection walk`);
+		const badRole = policy.roles.find((role) => !PSL_IDENTIFIER.test(role));
+		if (badRole !== void 0) {
+			const notes = skipNotesByTable.get(tableName) ?? [];
+			notes.push(`// prisma-next: skipped policy "${policy.name}": role "${badRole}" is not a valid PSL identifier and role references cannot be escaped`);
+			skipNotesByTable.set(tableName, notes);
+			continue;
+		}
+		let head = sanitizePolicyHead(parseWireName(policy.name)?.prefix ?? policy.name);
+		if (usedHeads.has(head)) {
+			let n = 2;
+			while (usedHeads.has(`${head}_${n}`)) n += 1;
+			head = `${head}_${n}`;
+		}
+		usedHeads.add(head);
+		blocks.push({
+			kind: "policy",
+			keyword: POLICY_OPERATION_KEYWORD[policy.operation],
+			name: head,
+			parameters: {
+				target: {
+					kind: "ref",
+					identifier: modelName,
+					span: SYNTHETIC_SPAN
+				},
+				roles: {
+					kind: "list",
+					items: policy.roles.map((role) => ({
+						kind: "ref",
+						identifier: role,
+						span: SYNTHETIC_SPAN
+					})),
+					span: SYNTHETIC_SPAN
+				},
+				...policy.using !== void 0 ? { using: {
+					kind: "value",
+					raw: JSON.stringify(policy.using),
+					span: SYNTHETIC_SPAN
+				} } : {},
+				...policy.withCheck !== void 0 ? { withCheck: {
+					kind: "value",
+					raw: JSON.stringify(policy.withCheck),
+					span: SYNTHETIC_SPAN
+				} } : {},
+				...policy.permissive ? {} : { permissive: {
+					kind: "value",
+					raw: "false",
+					span: SYNTHETIC_SPAN
+				} }
+			},
+			blockAttributes: [{
+				name: "map",
+				args: [{
+					kind: "positional",
+					value: `"${escapePslString(policy.name)}"`,
+					span: SYNTHETIC_SPAN
+				}],
+				span: SYNTHETIC_SPAN
+			}],
+			span: SYNTHETIC_SPAN
+		});
+	}
+	return {
+		blocks,
+		skipNotesByTable
+	};
+}
+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
+	};
+}
+const POSTGRES_TO_PSL = {
+	text: "String",
+	bool: "Boolean",
+	boolean: "Boolean",
+	int4: "Int",
+	integer: "Int",
+	int8: "BigInt",
+	bigint: "BigInt",
+	float8: "Float",
+	"double precision": "Float",
+	jsonb: "Jsonb",
+	bytea: "Bytes"
+};
+const PRESERVED_NATIVE_TYPES = {
+	"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": "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 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: { name: nativeType },
+			nativeType
+		};
+		const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);
+		if (paramMatch) {
+			const [, baseType = nativeType, params = ""] = paramMatch;
+			const typeName = getOwnMappingValue(PARAMETERIZED_NATIVE_TYPES, baseType);
+			if (typeName) return {
+				pslType: {
+					name: typeName,
+					args: splitTypeParameterList(params)
+				},
+				nativeType,
+				typeParams: {
+					baseType,
+					params
+				}
+			};
+		}
+		const preservedType = getOwnMappingValue(PRESERVED_NATIVE_TYPES, nativeType);
+		if (preservedType) return {
+			pslType: { name: preservedType },
+			nativeType
+		};
+		const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
+		if (pslType) return {
+			pslType: { name: pslType },
+			nativeType
+		};
+		return {
+			unsupported: true,
+			nativeType
+		};
+	} };
+}
+/**
+* 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 enumDefinitions = /* @__PURE__ */ new Map();
+	const packOwnedEnumTypesByNamespace = /* @__PURE__ */ new Map();
+	const enumNamespaceNames = /* @__PURE__ */ new Set();
+	for (const namespace of namespaces) for (const { typeName, members } of namespace.nativeEnums) {
+		const owner = owners.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, members);
+		enumNamespaceNames.add(namespace.schemaName);
+	}
+	const tables = {};
+	const tableNamespaceNames = /* @__PURE__ */ new Set();
+	const rlsEnabledTables = /* @__PURE__ */ new Set();
+	const policiesByTable = /* @__PURE__ */ new Map();
+	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 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 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);
+			if (table.rlsEnabled) rlsEnabledTables.add(tableName);
+			if (table.policies.length > 0) policiesByTable.set(tableName, table.policies);
+		}
+	}
+	let wrapNamespaceName;
+	if (enumDefinitions.size > 0 || policiesByTable.size > 0) {
+		const contentNamespaces = /* @__PURE__ */ new Set([...enumNamespaceNames, ...tableNamespaceNames]);
+		if (contentNamespaces.size > 1) throw postgresError("CONTRACT.INFER_UNSUPPORTED", `contract infer: adopting native enums or RLS policies 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);
+	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,
+		danglingForeignKeysByTable
+	}, wrapNamespaceName, {
+		rlsEnabledTables,
+		policiesByTable
+	});
+}
+function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName, rlsExtras) {
+	const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
+	const { extraRelationsByTable, crossSpaceFieldNamesByTable, danglingForeignKeysByTable } = 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 fieldNamesByTable = new Map([...crossSpaceFieldNamesByTable, ...buildFieldNamesByTable(schemaIR.tables)]);
+	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
+	const policyEmission = buildPolicyBlocks(rlsExtras?.policiesByTable ?? /* @__PURE__ */ new Map(), modelNameMap, /* @__PURE__ */ new Set([...modelNameMap.values(), ...bareEnumNameMap.values()]));
+	const models = [];
+	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) ?? [], rlsExtras?.rlsEnabledTables.has(table.name) ?? false, policyEmission.skipNotesByTable.get(table.name) ?? []));
+	const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
+	return {
+		kind: "document",
+		sourceId: "<sql-schema-ir>",
+		namespaces: [makePslNamespace({
+			kind: "namespace",
+			name: namespaceName ?? UNSPECIFIED_PSL_NAMESPACE_ID,
+			entries: makePslNamespaceEntries(sortedModels, [], [...enumBlocks, ...policyEmission.blocks]),
+			span: SYNTHETIC_SPAN
+		})],
+		span: SYNTHETIC_SPAN
+	};
+}
+function postgresRenderDefault(def, column) {
+	if (def.kind === "function") return def.expression;
+	return renderDefaultLiteral(def.value, column);
+}
+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);
+		},
+		createRunner(family) {
+			return createPostgresMigrationRunner(family);
+		},
+		contractToSchema(contract, frameworkComponents) {
+			const expander = buildNativeTypeExpander(frameworkComponents);
+			return contractToPostgresDatabaseSchemaNode(blindCast(contract), {
+				annotationNamespace: "pg",
+				...ifDefined("expandNativeType", expander),
+				renderDefault: postgresRenderDefault,
+				resolveDefault: postgresResolveDefault
+			});
+		}
+	},
+	create() {
+		return {
+			familyId: "sql",
+			targetId: "postgres"
+		};
+	},
+	/**
+	* Direct method for SQL-specific usage.
+	* @deprecated Use migrations.createPlanner() for CLI compatibility.
+	*/
+	createPlanner(adapter) {
+		return createPostgresMigrationPlanner(adapter);
+	},
+	/**
+	* Direct method for SQL-specific usage.
+	* @deprecated Use migrations.createRunner() for CLI compatibility.
+	*/
+	createRunner(family) {
+		return createPostgresMigrationRunner(family);
+	}
+};
+//#endregion
+export { postgresTargetDescriptor as n, postgresRenderDefault as t };
+
+//# sourceMappingURL=control-DRMWptiJ.mjs.map