@prisma-next/target-postgres 0.15.0 → 0.16.0-dev.10

package/dist/default-normalizer.mjs

@@ -1,248 +1,2 @@
-//#region src/core/default-normalizer.ts
-/**
-* Pre-compiled regex patterns for performance.
-* These are compiled once at module load time rather than on each function call.
-*/
-const NEXTVAL_PATTERN = /^nextval\s*\(/i;
-const NOW_FUNCTION_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP)$/i;
-const CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\s*\(\s*\)$/i;
-const TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\s+(?:with|without)\s+time\s+zone)?$/i;
-const TEXT_CAST_SUFFIX = /::text$/i;
-const NOW_LITERAL_PATTERN = /^'now'$/i;
-const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
-const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
-const NULL_PATTERN = /^NULL(?:::.+)?$/i;
-const TRUE_PATTERN = /^true$/i;
-const FALSE_PATTERN = /^false$/i;
-const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
-const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
-/**
-* Matches a Postgres array literal default of the form `'{...}'::elemtype[]`.
-* The literal body is captured in group 1; the cast (including `[]`) is optional.
-* Examples: `'{}'::text[]`, `'{1,2}'::integer[]`, `'{}'`
-*/
-const ARRAY_LITERAL_PATTERN = /^'(\{.*\})'(?:::.+\[\])?$/;
-/**
-* Returns the canonical expression for a timestamp default function, or undefined
-* if the expression is not a recognized timestamp default.
-*
-* Keeps now()/CURRENT_TIMESTAMP and clock_timestamp() distinct:
-* - now(), CURRENT_TIMESTAMP, ('now'::text)::timestamp... → 'now()'
-* - clock_timestamp(), clock_timestamp()::timestamptz → 'clock_timestamp()'
-*
-* These are semantically different in Postgres: now() returns the transaction
-* start time (constant within a transaction), while clock_timestamp() returns
-* the actual wall-clock time (can differ across rows in a single INSERT).
-*/
-function canonicalizeTimestampDefault(expr) {
-	if (NOW_FUNCTION_PATTERN.test(expr)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return "clock_timestamp()";
-	if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return void 0;
-	let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, "").trim();
-	if (inner.startsWith("(") && inner.endsWith(")")) inner = inner.slice(1, -1).trim();
-	if (NOW_FUNCTION_PATTERN.test(inner)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return "clock_timestamp()";
-	inner = inner.replace(TEXT_CAST_SUFFIX, "").trim();
-	if (NOW_LITERAL_PATTERN.test(inner)) return "now()";
-}
-/**
-* Splits a Postgres array literal body (without the enclosing braces) into its
-* element tokens, honouring quoting. A comma only separates elements when it is
-* outside double quotes; inside a quoted element a doubled quote (`""`) or a
-* backslash-escaped quote (`\"`) is a literal quote, and a backslash escapes the
-* next character. Returns undefined if the body is malformed (e.g. an unbalanced
-* quote).
-*/
-function splitArrayElements(inner) {
-	const tokens = [];
-	let current = "";
-	let inQuotes = false;
-	let quoted = false;
-	for (let i = 0; i < inner.length; i++) {
-		const char = inner[i];
-		if (inQuotes) {
-			if (char === "\\") {
-				const next = inner[i + 1];
-				if (next === void 0) return void 0;
-				current += next;
-				i++;
-				continue;
-			}
-			if (char === "\"") {
-				if (inner[i + 1] === "\"") {
-					current += "\"";
-					i++;
-					continue;
-				}
-				inQuotes = false;
-				continue;
-			}
-			current += char;
-			continue;
-		}
-		if (char === "\"") {
-			inQuotes = true;
-			quoted = true;
-			continue;
-		}
-		if (char === ",") {
-			tokens.push({
-				value: current,
-				quoted
-			});
-			current = "";
-			quoted = false;
-			continue;
-		}
-		current += char;
-	}
-	if (inQuotes) return void 0;
-	tokens.push({
-		value: current,
-		quoted
-	});
-	return tokens;
-}
-/**
-* Parses a Postgres array literal body (`{...}`) into a JS array of primitives.
-* Returns undefined if the body cannot be reliably parsed.
-*
-* Handles:
-* - `{}` → `[]`
-* - `{elem1,elem2,...}` → `[elem1, elem2, ...]` with numeric and string element coercion
-* - quoted elements that contain commas, doubled/escaped quotes, and the literal
-*   strings `NULL`/`true`/`false` (a quoted token is always a string)
-*/
-function parseArrayLiteralBody(body) {
-	const inner = body.slice(1, -1).trim();
-	if (inner === "") return [];
-	const tokens = splitArrayElements(inner);
-	if (tokens === void 0) return void 0;
-	const result = [];
-	for (const token of tokens) {
-		if (token.quoted) {
-			result.push(token.value);
-			continue;
-		}
-		const el = token.value.trim();
-		if (el.toUpperCase() === "NULL") {
-			result.push(null);
-			continue;
-		}
-		if (el === "true") {
-			result.push(true);
-			continue;
-		}
-		if (el === "false") {
-			result.push(false);
-			continue;
-		}
-		if (NUMERIC_PATTERN.test(el)) {
-			result.push(Number(el));
-			continue;
-		}
-		return;
-	}
-	return result;
-}
-/**
-* Parses a raw Postgres column default expression into a normalized ColumnDefault.
-* This enables semantic comparison between contract defaults and introspected schema defaults.
-*
-* Used by the migration diff layer to normalize raw database defaults during comparison,
-* keeping the introspection layer focused on faithful data capture.
-*
-* @param rawDefault - Raw default expression from information_schema.columns.column_default
-* @param nativeType - Native column type, used for type-aware parsing (array, bigint, JSON)
-* @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
-*/
-function parsePostgresDefault(rawDefault, nativeType) {
-	const trimmed = rawDefault.trim();
-	const normalizedType = nativeType?.toLowerCase();
-	const isBigInt = normalizedType === "bigint" || normalizedType === "int8";
-	const isArrayType = normalizedType?.endsWith("[]") ?? false;
-	if (NEXTVAL_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "autoincrement()"
-	};
-	if (isArrayType) {
-		const arrayMatch = trimmed.match(ARRAY_LITERAL_PATTERN);
-		if (arrayMatch?.[1] !== void 0) {
-			const parsed = parseArrayLiteralBody(arrayMatch[1]);
-			if (parsed !== void 0) return {
-				kind: "literal",
-				value: parsed
-			};
-		}
-	}
-	const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
-	if (canonicalTimestamp) return {
-		kind: "function",
-		expression: canonicalTimestamp
-	};
-	if (UUID_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "gen_random_uuid()"
-	};
-	if (UUID_OSSP_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "gen_random_uuid()"
-	};
-	if (NULL_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: null
-	};
-	if (TRUE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: true
-	};
-	if (FALSE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: false
-	};
-	if (NUMERIC_PATTERN.test(trimmed)) {
-		const num = Number(trimmed);
-		if (!Number.isFinite(num)) return void 0;
-		if (isBigInt && !Number.isSafeInteger(num)) return {
-			kind: "literal",
-			value: trimmed
-		};
-		return {
-			kind: "literal",
-			value: num
-		};
-	}
-	const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
-	if (stringMatch?.[1] !== void 0) {
-		const unescaped = stringMatch[1].replace(/''/g, "'");
-		if (normalizedType === "json" || normalizedType === "jsonb") try {
-			return {
-				kind: "literal",
-				value: JSON.parse(unescaped)
-			};
-		} catch {}
-		if (isBigInt && NUMERIC_PATTERN.test(unescaped)) {
-			const num = Number(unescaped);
-			if (Number.isSafeInteger(num)) return {
-				kind: "literal",
-				value: num
-			};
-			return {
-				kind: "literal",
-				value: unescaped
-			};
-		}
-		return {
-			kind: "literal",
-			value: unescaped
-		};
-	}
-	return {
-		kind: "function",
-		expression: trimmed
-	};
-}
-//#endregion
-export { parsePostgresDefault };
-
-//# sourceMappingURL=default-normalizer.mjs.map
+import { n as postgresResolveDefault, t as parsePostgresDefault } from "./default-normalizer-B9ZUiyUE.mjs";
+export { parsePostgresDefault, postgresResolveDefault };

package/dist/{descriptor-meta-CFQKLXl_.mjs → descriptor-meta-qubYaxQA.mjs}

@@ -1,11 +1,16 @@
-import { E as postgresQualifyColumnType } from "./codecs-DRbb26Or.mjs";
+import { D as postgresQualifyColumnType } from "./codecs-TCsGgW-Y.mjs";
 import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86.mjs";
-import { i as postgresCreateNamespace } from "./postgres-schema-Cm4DtiGA.mjs";
-import { a as postgresAuthoringTypes, i as postgresAuthoringPslBlockDescriptors, n as postgresAuthoringFieldPresets, o as postgresLowerEntityHandles, r as postgresAuthoringModelAttributes, t as postgresAuthoringEntityTypes } from "./authoring-BtsOWgI3.mjs";
+import { i as postgresCreateNamespace } from "./postgres-schema-CewLYHB7.mjs";
+import { a as postgresAuthoringTypes, i as postgresAuthoringPslBlockDescriptors, n as postgresAuthoringFieldPresets, o as postgresLowerEntityHandles, r as postgresAuthoringModelAttributes, t as postgresAuthoringEntityTypes } from "./authoring-34L18kA1.mjs";
 import { t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-UwYdV8fD.mjs";
+import { type } from "arktype";
+import { defineIndexTypes } from "@prisma-next/sql-contract/index-types";
+//#region src/core/index-types.ts
+const postgresIndexTypes = defineIndexTypes().add("btree", { options: type("object") }).add("hash", { options: type("object") }).add("gin", { options: type("object") }).add("gist", { options: type("object") }).add("spgist", { options: type("object") }).add("brin", { options: type("object") });
 const postgresTargetDescriptorMeta = {
 	...postgresTargetDescriptorMetaRuntime,
 	defaultNamespaceId: DEFAULT_NAMESPACE_ID,
+	indexTypes: postgresIndexTypes,
 	authoring: {
 		type: postgresAuthoringTypes,
 		field: postgresAuthoringFieldPresets,
@@ -20,4 +25,4 @@ const postgresTargetDescriptorMeta = {
 //#endregion
 export { postgresTargetDescriptorMeta as t };
 
-//# sourceMappingURL=descriptor-meta-CFQKLXl_.mjs.map
+//# sourceMappingURL=descriptor-meta-qubYaxQA.mjs.map

package/dist/descriptor-meta-qubYaxQA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-qubYaxQA.mjs","names":[],"sources":["../src/core/index-types.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import { defineIndexTypes } from '@prisma-next/sql-contract/index-types';\nimport { type } from 'arktype';\n\n// Postgres's built-in index access methods (`CREATE INDEX ... USING <method>`).\n// Per-method option validation (e.g. `gin` operator classes) is out of scope;\n// every method accepts any options object until a later slice narrows it.\nexport const postgresIndexTypes = defineIndexTypes()\n  .add('btree', { options: type('object') })\n  .add('hash', { options: type('object') })\n  .add('gin', { options: type('object') })\n  .add('gist', { options: type('object') })\n  .add('spgist', { options: type('object') })\n  .add('brin', { options: type('object') });\n\nexport type IndexTypes = typeof postgresIndexTypes.IndexTypes;\n","import type { CodecTypes } from '../exports/codec-types';\nimport {\n  postgresAuthoringEntityTypes,\n  postgresAuthoringFieldPresets,\n  postgresAuthoringModelAttributes,\n  postgresAuthoringPslBlockDescriptors,\n  postgresAuthoringTypes,\n  postgresLowerEntityHandles,\n} from './authoring';\nimport { postgresQualifyColumnType } from './codecs';\nimport { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';\nimport { postgresIndexTypes } from './index-types';\nimport { DEFAULT_NAMESPACE_ID } from './namespace-ids';\nimport { postgresCreateNamespace } from './postgres-schema';\n\nconst postgresTargetDescriptorMetaBase = {\n  ...postgresTargetDescriptorMetaRuntime,\n  defaultNamespaceId: DEFAULT_NAMESPACE_ID,\n  indexTypes: postgresIndexTypes,\n  authoring: {\n    type: postgresAuthoringTypes,\n    field: postgresAuthoringFieldPresets,\n    entityTypes: postgresAuthoringEntityTypes,\n    pslBlockDescriptors: postgresAuthoringPslBlockDescriptors,\n    modelAttributes: postgresAuthoringModelAttributes,\n    createNamespace: postgresCreateNamespace,\n    qualifyColumnType: postgresQualifyColumnType,\n    lowerEntityHandles: postgresLowerEntityHandles,\n  },\n} as const;\n\nexport const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaBase;\n"],"mappings":";;;;;;;;AAMA,MAAa,qBAAqB,iBAAiB,CAAC,CACjD,IAAI,SAAS,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC,CAAC,CACzC,IAAI,QAAQ,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC,CAAC,CACxC,IAAI,OAAO,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC,CAAC,CACvC,IAAI,QAAQ,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC,CAAC,CACxC,IAAI,UAAU,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC,CAAC,CAC1C,IAAI,QAAQ,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC;ACmB1C,MAAa,+BAET;CAjBF,GAAG;CACH,oBAAoB;CACpB,YAAY;CACZ,WAAW;EACT,MAAM;EACN,OAAO;EACP,aAAa;EACb,qBAAqB;EACrB,iBAAiB;EACjB,iBAAiB;EACjB,mBAAmB;EACnB,oBAAoB;CACtB;AAKE"}

package/dist/{diff-database-schema-GncqMuSI.mjs → diff-database-schema-BRxq7l98.mjs}

@@ -1,16 +1,55 @@
-import { r as isPostgresSchema } from "./postgres-schema-Cm4DtiGA.mjs";
-import { a as postgresDiffSubjectGranularity, n as PostgresNativeEnumSchemaNode, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-D6LvInCe.mjs";
-import { i as PostgresDatabaseSchemaNode, n as PostgresPolicySchemaNode, r as PostgresNamespaceSchemaNode, t as PostgresRoleSchemaNode } from "./postgres-role-schema-node-Cm-j0ZGM.mjs";
-import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-XyBaaenM.mjs";
-import { i as resolvePostgresNodeIssueControlPolicySubject } from "./control-policy-DtbkLLGv.mjs";
+import { n as postgresResolveDefault } from "./default-normalizer-B9ZUiyUE.mjs";
+import { r as isPostgresSchema } from "./postgres-schema-CewLYHB7.mjs";
+import { a as postgresDiffSubjectGranularity, n as PostgresNativeEnumSchemaNode, r as PostgresSchemaNodeKind, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-D6LvInCe.mjs";
+import { i as PostgresDatabaseSchemaNode, n as PostgresPolicySchemaNode, r as PostgresNamespaceSchemaNode, t as PostgresRoleSchemaNode } from "./postgres-role-schema-node-bg32e7I-.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-D0wi_P9Q.mjs";
+import { i as resolvePostgresNodeIssueControlPolicySubject } from "./control-policy-S7XBe07W.mjs";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
 import { buildNativeTypeExpander, contractNamespaceToSchemaIR } from "@prisma-next/family-sql/control";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { SqlForeignKeyIR } from "@prisma-next/sql-schema-ir/types";
+import { PrimaryKey, RelationalSchemaNodeKind, SqlForeignKeyIR, SqlIndexIR, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
 import { classifyDiffSubjectGranularity } from "@prisma-next/family-sql/diff";
-import { diffSchemas } from "@prisma-next/framework-components/control";
+import { diffSchemas, issueOutcome } from "@prisma-next/framework-components/control";
 //#region src/core/migrations/contract-to-postgres-database-schema-node.ts
+/** The database root's fixed sentinel id (`PostgresDatabaseSchemaNode#id`). */
+function databaseStep() {
+	return {
+		nodeKind: PostgresSchemaNodeKind.database,
+		id: "database"
+	};
+}
+function tableDependsOn(namespaceId, tableName) {
+	return [
+		databaseStep(),
+		{
+			nodeKind: PostgresSchemaNodeKind.namespace,
+			id: namespaceId
+		},
+		{
+			nodeKind: PostgresSchemaNodeKind.table,
+			id: tableName
+		}
+	];
+}
+function roleDependsOn(role) {
+	return [databaseStep(), {
+		nodeKind: PostgresSchemaNodeKind.role,
+		id: role
+	}];
+}
+/**
+* The chains from a table-child object (foreign key, index, unique, primary
+* key) to each of the own columns it is built on, in the Postgres tree.
+* Dropping a covered column auto-drops the object, so the object's drop must
+* precede the column's; the graph derives that direction from these edges.
+*/
+function columnDependsOn(namespaceId, tableName, columns) {
+	return columns.map((column) => [...tableDependsOn(namespaceId, tableName), {
+		nodeKind: RelationalSchemaNodeKind.column,
+		id: `column:${column}`
+	}]);
+}
 function toPolicyNode(policy, namespaceId) {
 	return new PostgresPolicySchemaNode({
 		name: policy.name,
@@ -21,7 +60,8 @@ function toPolicyNode(policy, namespaceId) {
 		roles: [...policy.roles],
 		...ifDefined("using", policy.using),
 		...ifDefined("withCheck", policy.withCheck),
-		permissive: policy.permissive
+		permissive: policy.permissive,
+		dependsOn: [tableDependsOn(namespaceId, policy.tableName), ...policy.roles.map(roleDependsOn)]
 	});
 }
 /**
@@ -76,24 +116,48 @@ function contractToPostgresDatabaseSchemaNode(contract, options) {
 		for (const tableName of Object.keys(ns.table)) {
 			const sqlTable = sqlTables[tableName];
 			if (sqlTable === void 0) continue;
-			const foreignKeys = sqlTable.foreignKeys.map((fk) => new SqlForeignKeyIR({
-				columns: fk.columns,
-				referencedTable: fk.referencedTable,
-				referencedColumns: fk.referencedColumns,
-				referencedSchema: fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,
-				...ifDefined("name", fk.name),
-				...ifDefined("onDelete", fk.onDelete),
-				...ifDefined("onUpdate", fk.onUpdate),
-				...ifDefined("annotations", fk.annotations),
-				resolvedReferencedNamespace: resolveDdlSchemaForNamespaceStorage(contract.storage, fk.referencedSchema ?? UNBOUND_NAMESPACE_ID)
+			const foreignKeys = sqlTable.foreignKeys.map((fk) => {
+				const resolvedReferencedNamespace = resolveDdlSchemaForNamespaceStorage(contract.storage, fk.referencedSchema ?? UNBOUND_NAMESPACE_ID);
+				return new SqlForeignKeyIR({
+					columns: fk.columns,
+					referencedTable: fk.referencedTable,
+					referencedColumns: fk.referencedColumns,
+					referencedSchema: fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,
+					...ifDefined("name", fk.name),
+					...ifDefined("onDelete", fk.onDelete),
+					...ifDefined("onUpdate", fk.onUpdate),
+					...ifDefined("annotations", fk.annotations),
+					resolvedReferencedNamespace,
+					dependsOn: [tableDependsOn(resolvedReferencedNamespace, fk.referencedTable), ...columnDependsOn(ddlSchema, tableName, fk.columns)]
+				});
+			});
+			const uniques = sqlTable.uniques.map((u) => new SqlUniqueIR({
+				columns: u.columns,
+				...ifDefined("name", u.name),
+				...ifDefined("annotations", u.annotations),
+				dependsOn: columnDependsOn(ddlSchema, tableName, u.columns)
+			}));
+			const indexes = sqlTable.indexes.map((i) => new SqlIndexIR({
+				columns: i.columns,
+				unique: i.unique,
+				...ifDefined("name", i.name),
+				...ifDefined("type", i.type),
+				...ifDefined("options", i.options),
+				...ifDefined("annotations", i.annotations),
+				dependsOn: columnDependsOn(ddlSchema, tableName, i.columns)
 			}));
+			const primaryKey = sqlTable.primaryKey !== void 0 ? new PrimaryKey({
+				columns: sqlTable.primaryKey.columns,
+				...ifDefined("name", sqlTable.primaryKey.name),
+				dependsOn: columnDependsOn(ddlSchema, tableName, sqlTable.primaryKey.columns)
+			}) : void 0;
 			tables[tableName] = new PostgresTableSchemaNode({
 				name: sqlTable.name,
 				columns: sqlTable.columns,
 				foreignKeys,
-				uniques: sqlTable.uniques,
-				indexes: sqlTable.indexes,
-				...ifDefined("primaryKey", sqlTable.primaryKey),
+				uniques,
+				indexes,
+				...ifDefined("primaryKey", primaryKey),
 				...ifDefined("annotations", sqlTable.annotations),
 				...ifDefined("checks", sqlTable.checks),
 				policies: policiesByTable.get(tableName) ?? [],
@@ -214,14 +278,15 @@ function diffPostgresSchema(input) {
 	const actual = input.schema;
 	const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {
 		annotationNamespace: "pg",
-		...ifDefined("expandNativeType", buildNativeTypeExpander(input.frameworkComponents))
+		...ifDefined("expandNativeType", buildNativeTypeExpander(input.frameworkComponents)),
+		resolveDefault: postgresResolveDefault
 	});
 	const expected = pruneTableLessNamespaces(fullExpected);
 	const relationalOwned = ownedSchemaNames(expected);
 	const structuralOwned = ownedSchemaNames(fullExpected);
 	return {
 		issues: diffSchemas(expected, actual).filter((issue) => {
-			if (issue.reason !== "not-expected") return true;
+			if (issueOutcome(issue) !== "not-expected") return true;
 			if (isClusterScopedIssue(issue)) return true;
 			const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
 			const namespaceSegment = issue.path[1];
@@ -280,7 +345,8 @@ function buildPostgresPlanDiff(input) {
 	const actual = input.actualSchema;
 	const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {
 		annotationNamespace: "pg",
-		...ifDefined("expandNativeType", buildNativeTypeExpander(input.frameworkComponents))
+		...ifDefined("expandNativeType", buildNativeTypeExpander(input.frameworkComponents)),
+		resolveDefault: postgresResolveDefault
 	});
 	const expected = pruneTableLessNamespaces(fullExpected);
 	const paddedActual = padActualNamespaces(expected, actual);
@@ -290,7 +356,7 @@ function buildPostgresPlanDiff(input) {
 		expected,
 		actual: paddedActual,
 		issues: blindCast(diffSchemas(expected, paddedActual)).filter((issue) => {
-			if (issue.reason !== "not-expected") return true;
+			if (issueOutcome(issue) !== "not-expected") return true;
 			if (isClusterScopedIssue(issue)) return true;
 			const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
 			const namespaceSegment = issue.path[1];
@@ -302,4 +368,4 @@ function buildPostgresPlanDiff(input) {
 //#endregion
 export { diffPostgresSchema as n, contractToPostgresDatabaseSchemaNode as r, buildPostgresPlanDiff as t };
 
-//# sourceMappingURL=diff-database-schema-GncqMuSI.mjs.map
+//# sourceMappingURL=diff-database-schema-BRxq7l98.mjs.map

package/dist/diff-database-schema-BRxq7l98.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-database-schema-BRxq7l98.mjs","names":[],"sources":["../src/core/migrations/contract-to-postgres-database-schema-node.ts","../src/core/migrations/diff-database-schema.ts"],"sourcesContent":["import type { ContractToSchemaIROptions } from '@prisma-next/family-sql/control';\nimport { contractNamespaceToSchemaIR } from '@prisma-next/family-sql/control';\nimport type { SchemaNodeRef } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport {\n  PrimaryKey,\n  RelationalSchemaNodeKind,\n  SqlForeignKeyIR,\n  SqlIndexIR,\n  SqlUniqueIR,\n} from '@prisma-next/sql-schema-ir/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresRlsPolicy } from '../postgres-rls-policy';\nimport type { PostgresContract } from '../postgres-schema';\nimport { isPostgresSchema } from '../postgres-schema';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';\nimport { PostgresNativeEnumSchemaNode } from '../schema-ir/postgres-native-enum-schema-node';\nimport { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';\nimport { PostgresRoleSchemaNode } from '../schema-ir/postgres-role-schema-node';\nimport { PostgresTableSchemaNode } from '../schema-ir/postgres-table-schema-node';\nimport { PostgresSchemaNodeKind } from '../schema-ir/schema-node-kinds';\nimport { resolveDdlSchemaForNamespaceStorage } from './resolve-ddl-schema';\n\n/** The database root's fixed sentinel id (`PostgresDatabaseSchemaNode#id`). */\nfunction databaseStep(): { readonly nodeKind: string; readonly id: string } {\n  return { nodeKind: PostgresSchemaNodeKind.database, id: 'database' };\n}\n\nfunction tableDependsOn(namespaceId: string, tableName: string): SchemaNodeRef {\n  return [\n    databaseStep(),\n    { nodeKind: PostgresSchemaNodeKind.namespace, id: namespaceId },\n    { nodeKind: PostgresSchemaNodeKind.table, id: tableName },\n  ];\n}\n\nfunction roleDependsOn(role: string): SchemaNodeRef {\n  return [databaseStep(), { nodeKind: PostgresSchemaNodeKind.role, id: role }];\n}\n\n/**\n * The chains from a table-child object (foreign key, index, unique, primary\n * key) to each of the own columns it is built on, in the Postgres tree.\n * Dropping a covered column auto-drops the object, so the object's drop must\n * precede the column's; the graph derives that direction from these edges.\n */\nfunction columnDependsOn(\n  namespaceId: string,\n  tableName: string,\n  columns: readonly string[],\n): readonly SchemaNodeRef[] {\n  return columns.map((column) => [\n    ...tableDependsOn(namespaceId, tableName),\n    { nodeKind: RelationalSchemaNodeKind.column, id: `column:${column}` },\n  ]);\n}\n\nfunction toPolicyNode(policy: PostgresRlsPolicy, namespaceId: string): PostgresPolicySchemaNode {\n  return new PostgresPolicySchemaNode({\n    name: policy.name,\n    prefix: policy.prefix,\n    tableName: policy.tableName,\n    namespaceId,\n    operation: policy.operation,\n    roles: [...policy.roles],\n    ...ifDefined('using', policy.using),\n    ...ifDefined('withCheck', policy.withCheck),\n    permissive: policy.permissive,\n    dependsOn: [tableDependsOn(namespaceId, policy.tableName), ...policy.roles.map(roleDependsOn)],\n  });\n}\n\n/**\n * Projects a Postgres contract into the expected schema-diff tree: a\n * `PostgresDatabaseSchemaNode` root holding one `PostgresNamespaceSchemaNode`\n * per Postgres namespace, each holding its `PostgresTableSchemaNode`s with\n * their `PostgresPolicySchemaNode`s, plus the database roles on the root.\n *\n * Not a duplicate of the family's `contractToSchemaIR`: that builds a flat,\n * single `{ tables }` map (and throws on cross-namespace name collisions, with\n * no RLS/role concept) for SQLite's single-schema world. This is the\n * Postgres-specific *tree* shape — multi-schema, RLS-policy-aware, role-aware.\n * It reuses the family's per-namespace table conversion (`contractNamespaceToSchemaIR`)\n * for column/FK/index building and only adds the Postgres tree/policy/role shape.\n *\n * Tables are grouped by their owning namespace (resolved DDL schema name) so\n * the tree mirrors Postgres's object hierarchy. The DDL schema name is\n * resolved once per namespace.\n *\n * A policy that references a table absent from its namespace is a malformed\n * contract — the loop throws rather than fabricating a stub table.\n */\nexport function contractToPostgresDatabaseSchemaNode(\n  contract: PostgresContract | null,\n  options: ContractToSchemaIROptions,\n): PostgresDatabaseSchemaNode {\n  if (contract === null) {\n    return new PostgresDatabaseSchemaNode({\n      namespaces: {},\n      roles: [],\n      existingSchemas: [],\n      pgVersion: '',\n    });\n  }\n\n  const namespaces: Record<string, PostgresNamespaceSchemaNode> = {};\n  const roles: PostgresRoleSchemaNode[] = [];\n  const ownedSchemas: string[] = [];\n\n  for (const ns of Object.values(contract.storage.namespaces)) {\n    if (!isPostgresSchema(ns)) continue;\n\n    // Role entries are root-level diff subjects: they hoist to the database\n    // root from every slot and never count toward whether a namespace\n    // materializes a schema node.\n    for (const role of Object.values(ns.role)) {\n      roles.push(new PostgresRoleSchemaNode({ name: role.name, namespaceId: role.namespaceId }));\n    }\n\n    // The unbound slot resolves its DDL schema to 'public', so it\n    // materializes a schema node exactly when it has non-role content — a\n    // late-binding contract keeps today's behavior (the slot carries the\n    // tables), while a roles-only unbound slot alongside named namespaces\n    // contributes only root roles and no node (which would otherwise be a\n    // spurious empty 'public' node, clobbering a real bound 'public'\n    // namespace's node keyed by the same resolved schema name).\n    if (ns.id === UNBOUND_NAMESPACE_ID) {\n      const hasNonRoleContent = Object.entries(ns.entries).some(\n        ([entriesKey, slot]) => entriesKey !== 'role' && Object.keys(slot).length > 0,\n      );\n      if (!hasNonRoleContent) continue;\n    }\n\n    const ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id);\n    ownedSchemas.push(ddlSchema);\n\n    // Convert only THIS namespace's tables (passing the full storage for\n    // type/value-set/enum resolution that spans namespaces), so the same table\n    // name can exist in two schemas without colliding in a bare-keyed record.\n    const sqlTables = contractNamespaceToSchemaIR(contract.storage, ns.id, options).tables;\n\n    const policiesByTable = new Map<string, PostgresPolicySchemaNode[]>();\n    for (const policy of Object.values(ns.policy)) {\n      const list = policiesByTable.get(policy.tableName) ?? [];\n      list.push(toPolicyNode(policy, ddlSchema));\n      policiesByTable.set(policy.tableName, list);\n    }\n\n    const tables: Record<string, PostgresTableSchemaNode> = {};\n    for (const tableName of Object.keys(ns.table)) {\n      const sqlTable = sqlTables[tableName];\n      if (sqlTable === undefined) continue;\n      // The family conversion stamps `referencedSchema` only for bound FK\n      // targets; an absent value means the FK targets the unbound namespace.\n      // Postgres restores its own coordinate for that slot (the unbound\n      // singleton's id) so the raw coordinate keeps qualifying REFERENCES\n      // clauses, and resolves the real live DDL schema — introspected FKs\n      // already carry the live schema, so this is what lets an expected FK\n      // pair (by diff-node id) with its introspected counterpart.\n      const foreignKeys = sqlTable.foreignKeys.map((fk) => {\n        const resolvedReferencedNamespace = resolveDdlSchemaForNamespaceStorage(\n          contract.storage,\n          fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,\n        );\n        return new SqlForeignKeyIR({\n          columns: fk.columns,\n          referencedTable: fk.referencedTable,\n          referencedColumns: fk.referencedColumns,\n          referencedSchema: fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,\n          ...ifDefined('name', fk.name),\n          ...ifDefined('onDelete', fk.onDelete),\n          ...ifDefined('onUpdate', fk.onUpdate),\n          ...ifDefined('annotations', fk.annotations),\n          resolvedReferencedNamespace,\n          dependsOn: [\n            tableDependsOn(resolvedReferencedNamespace, fk.referencedTable),\n            ...columnDependsOn(ddlSchema, tableName, fk.columns),\n          ],\n        });\n      });\n      // The family stamped these children's own-column `dependsOn` with the\n      // flat (single-schema) chain; the Postgres tree nests them under a\n      // namespace, so re-stamp with the multi-schema chain that matches this\n      // tree's paths. Every other field is carried through unchanged.\n      const uniques = sqlTable.uniques.map(\n        (u) =>\n          new SqlUniqueIR({\n            columns: u.columns,\n            ...ifDefined('name', u.name),\n            ...ifDefined('annotations', u.annotations),\n            dependsOn: columnDependsOn(ddlSchema, tableName, u.columns),\n          }),\n      );\n      const indexes = sqlTable.indexes.map(\n        (i) =>\n          new SqlIndexIR({\n            columns: i.columns,\n            unique: i.unique,\n            ...ifDefined('name', i.name),\n            ...ifDefined('type', i.type),\n            ...ifDefined('options', i.options),\n            ...ifDefined('annotations', i.annotations),\n            dependsOn: columnDependsOn(ddlSchema, tableName, i.columns),\n          }),\n      );\n      const primaryKey =\n        sqlTable.primaryKey !== undefined\n          ? new PrimaryKey({\n              columns: sqlTable.primaryKey.columns,\n              ...ifDefined('name', sqlTable.primaryKey.name),\n              dependsOn: columnDependsOn(ddlSchema, tableName, sqlTable.primaryKey.columns),\n            })\n          : undefined;\n      tables[tableName] = new PostgresTableSchemaNode({\n        name: sqlTable.name,\n        columns: sqlTable.columns,\n        foreignKeys,\n        uniques,\n        indexes,\n        ...ifDefined('primaryKey', primaryKey),\n        ...ifDefined('annotations', sqlTable.annotations),\n        ...ifDefined('checks', sqlTable.checks),\n        policies: policiesByTable.get(tableName) ?? [],\n        // Marker-driven, never derived from the policy set: the `rls` entry\n        // is the single authored source of enablement.\n        rlsEnabled: Object.hasOwn(ns.rls, tableName),\n      });\n    }\n\n    for (const [tableName, tablePolicies] of policiesByTable) {\n      if (!(tableName in tables)) {\n        const policyName = tablePolicies[0]?.name ?? '(unknown)';\n        throw new Error(\n          `contract-to-postgres-database-schema-node: policy \"${policyName}\" references table \"${tableName}\" not present in namespace \"${ddlSchema}\"`,\n        );\n      }\n      if (!Object.hasOwn(ns.rls, tableName)) {\n        const policyPrefix = tablePolicies[0]?.prefix ?? '(unknown)';\n        throw new Error(\n          `contract-to-postgres-database-schema-node: policy \"${policyPrefix}\" targets table \"${tableName}\" in namespace \"${ddlSchema}\", which is not RLS-controlled. Mark the model with @@rls (entries.rls[\"${tableName}\"]) or remove the policy.`,\n        );\n      }\n    }\n\n    const nativeEnums = Object.values(ns.entries.native_enum ?? {}).map(\n      (entity) =>\n        new PostgresNativeEnumSchemaNode({\n          typeName: entity.typeName,\n          namespaceId: ddlSchema,\n          members: entity.members,\n          ...ifDefined('control', entity.control),\n        }),\n    );\n\n    namespaces[ddlSchema] = new PostgresNamespaceSchemaNode({\n      schemaName: ddlSchema,\n      tables,\n      nativeEnums,\n    });\n  }\n\n  return new PostgresDatabaseSchemaNode({\n    namespaces,\n    roles,\n    existingSchemas: ownedSchemas,\n    pgVersion: '',\n  });\n}\n","import type { Contract, ControlPolicy } from '@prisma-next/contract/types';\nimport type { SqlSchemaDiffResult } from '@prisma-next/family-sql/control';\nimport { buildNativeTypeExpander } from '@prisma-next/family-sql/control';\nimport { classifyDiffSubjectGranularity } from '@prisma-next/family-sql/diff';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type { DiffableNode, SchemaDiffIssue } from '@prisma-next/framework-components/control';\nimport { diffSchemas, issueOutcome } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { postgresResolveDefault } from '../default-normalizer';\nimport type { PostgresContract } from '../postgres-schema';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';\nimport {\n  postgresDiffSubjectGranularity,\n  type SqlSchemaDiffNode,\n} from '../schema-ir/schema-node-kinds';\nimport { contractToPostgresDatabaseSchemaNode } from './contract-to-postgres-database-schema-node';\nimport { resolvePostgresNodeIssueControlPolicySubject } from './control-policy';\n\n/**\n * Whether a diff issue's subject node is cluster-scoped — it carries its own\n * `namespaceId` field (only role and policy diff nodes do) and that\n * coordinate is the unbound sentinel, meaning the node is not owned by any\n * schema/namespace. A role node is always cluster-scoped (roles are\n * cluster-level objects); a policy node's `namespaceId` is always its\n * table's resolved DDL schema, never the sentinel. Namespace-ownership\n * scoping (which compares `issue.path[1]` against the set of DDL schemas\n * the contract owns) makes no sense for a cluster-scoped subject — its path\n * segment at that index is the object's own name, not a schema name — so\n * such an issue bypasses that scoping entirely.\n */\nfunction isClusterScopedIssue(issue: SchemaDiffIssue): boolean {\n  const node = issue.expected ?? issue.actual;\n  return node !== undefined && nodeNamespaceId(node) === UNBOUND_NAMESPACE_ID;\n}\n\nfunction nodeNamespaceId(node: DiffableNode): string | undefined {\n  if (!Object.hasOwn(node, 'namespaceId')) return undefined;\n  return blindCast<\n    { namespaceId: string },\n    'presence of an own namespaceId field was just checked via Object.hasOwn'\n  >(node).namespaceId;\n}\n\nfunction ownedSchemaNames(expected: PostgresDatabaseSchemaNode): ReadonlySet<string> {\n  const policyNamespaces = Object.values(expected.namespaces).flatMap((ns) =>\n    Object.values(ns.tables).flatMap((t) => t.policies.map((p) => p.namespaceId)),\n  );\n  return new Set([...policyNamespaces, ...expected.existingSchemas]);\n}\n\n/**\n * Drops contract namespaces that declare no tables from the verdict-diff\n * expected tree and the relational owned-schema set. The legacy relational\n * walk skipped a table-less namespace (e.g. an enums-only schema) before\n * pairing, so neither its DDL schema's absence nor that schema's live\n * relational contents ever reached the verdict — the pruned tree\n * reproduces that. The prune loses no expected policies: policies attach\n * to tables, so a table-less namespace carries none (the projection\n * throws on a policy referencing an absent table). Live policies in a\n * pruned schema remain governed via the full owned set (see\n * {@link diffPostgresSchema}).\n */\nfunction pruneTableLessNamespaces(\n  expected: PostgresDatabaseSchemaNode,\n): PostgresDatabaseSchemaNode {\n  const namespaces = Object.fromEntries(\n    Object.entries(expected.namespaces).filter(([, ns]) => Object.keys(ns.tables).length > 0),\n  );\n  return new PostgresDatabaseSchemaNode({\n    namespaces,\n    roles: [...expected.roles],\n    existingSchemas: expected.existingSchemas.filter((s) => namespaces[s] !== undefined),\n    pgVersion: expected.pgVersion,\n  });\n}\n\n/**\n * Resolves a verdict-diff issue's subject's declared control policy directly\n * from the contract, by delegating to the same node-typed resolver\n * ({@link resolvePostgresNodeIssueControlPolicySubject}) the planner uses to\n * gate DDL calls. `undefined` when the issue resolves to no contract subject.\n *\n * A role issue resolves through that same resolver to `external`\n * unconditionally (see its role branch), regardless of the contract's own\n * default policy: a role is referenced by the contract but not owned, and\n * `external`'s existing semantics — a missing declared subject still fails,\n * every extra is suppressed — are exactly the wanted asymmetric grading for\n * a cluster object the framework does not own.\n */\nfunction resolveControlPolicy(\n  issue: SchemaDiffIssue,\n  contract: Contract<SqlStorage>,\n): ControlPolicy | undefined {\n  const nodeIssue = blindCast<\n    SchemaDiffIssue<SqlSchemaDiffNode>,\n    'every node in a Postgres schema diff tree is a SqlSchemaDiffNode'\n  >(issue);\n  return resolvePostgresNodeIssueControlPolicySubject(nodeIssue, contract)\n    ?.explicitNodeControlPolicy;\n}\n\n/**\n * The Postgres full-tree node diff for the family verify verdict: derive\n * the expected tree (resolved leaf values, expander threaded, FK schemas\n * resolved, table-less namespaces pruned), run the generic\n * differ over the trees as derived, and scope out `not-expected` findings under namespaces the\n * contract does not own. Ownership scoping bypasses cluster-scoped subjects\n * (roles today), mirroring the legacy decomposition: relational extras check\n * the PRUNED owned set (the legacy\n * per-namespace walk never visited a table-less namespace, so its live\n * relational contents are invisible), while `structural` extras (RLS\n * policies) check the FULL owned set (the legacy policy diff governed\n * every contract schema regardless of tables — RLS governance does not\n * shrink because a namespace declares no tables). The codec `verifyType`\n * hooks run once per contract namespace with tables against that\n * namespace's paired actual node (the hooks read namespace-scoped state\n * such as `nativeEnums`).\n */\nexport function diffPostgresSchema(input: {\n  readonly contract: Contract<SqlStorage>;\n  readonly schema: SqlSchemaIRNode;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n}): SqlSchemaDiffResult {\n  const postgresContract = blindCast<\n    PostgresContract,\n    'diffPostgresSchema is only called with a postgres contract'\n  >(input.contract);\n  PostgresDatabaseSchemaNode.assert(input.schema);\n  const actual = input.schema;\n  const expandNativeType = buildNativeTypeExpander(input.frameworkComponents);\n  const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {\n    annotationNamespace: 'pg',\n    ...ifDefined('expandNativeType', expandNativeType),\n    resolveDefault: postgresResolveDefault,\n  });\n  const expected = pruneTableLessNamespaces(fullExpected);\n  const relationalOwned = ownedSchemaNames(expected);\n  const structuralOwned = ownedSchemaNames(fullExpected);\n  const issues = diffSchemas(expected, actual).filter((issue) => {\n    if (issueOutcome(issue) !== 'not-expected') return true;\n    if (isClusterScopedIssue(issue)) return true;\n    const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);\n    const namespaceSegment = issue.path[1];\n    if (namespaceSegment === undefined) return true;\n    const owned = granularity === 'structural' ? structuralOwned : relationalOwned;\n    return owned.has(namespaceSegment);\n  });\n  const namespacePairs = Object.values(expected.namespaces).map((ns) => ({\n    actual: actual.namespaces[ns.schemaName],\n  }));\n  return {\n    issues,\n    resolveControlPolicy: (issue) => resolveControlPolicy(issue, postgresContract),\n    namespacePairs,\n  };\n}\n\n/**\n * Adds an empty namespace node to the actual tree for every expected namespace\n * absent from it. The relational plan diff pairs on namespace: a contract\n * namespace whose live schema does not exist yet must surface each of its\n * tables as `not-found` (→ `CREATE TABLE`), NOT as a single namespace\n * `not-found` that subtree-coalescing would collapse (leaving `CREATE SCHEMA`\n * with no tables). Padding makes the namespaces pair, so only table/column/\n * policy drift surfaces; `CREATE SCHEMA` comes separately from the synthesized\n * namespace-presence stitch (`verifyPostgresNamespacePresence`), never from the\n * tree diff — matching the retired per-namespace-paired relational walk, which\n * paired a missing schema against an empty namespace node.\n */\nfunction padActualNamespaces(\n  expected: PostgresDatabaseSchemaNode,\n  actual: PostgresDatabaseSchemaNode,\n): PostgresDatabaseSchemaNode {\n  const namespaces: Record<string, PostgresNamespaceSchemaNode> = { ...actual.namespaces };\n  let padded = false;\n  for (const schemaName of Object.keys(expected.namespaces)) {\n    if (namespaces[schemaName] === undefined) {\n      namespaces[schemaName] = new PostgresNamespaceSchemaNode({\n        schemaName,\n        tables: {},\n      });\n      padded = true;\n    }\n  }\n  if (!padded) return actual;\n  return new PostgresDatabaseSchemaNode({\n    namespaces,\n    roles: [...actual.roles],\n    existingSchemas: [...actual.existingSchemas],\n    pgVersion: actual.pgVersion,\n  });\n}\n\nexport interface PostgresPlanDiff {\n  /** The desired (\"end\") tree — resolved leaf values (incl. `codecRef`) on every column, table-less namespaces pruned. */\n  readonly expected: PostgresDatabaseSchemaNode;\n  /** The live (\"start\") tree, padded with empty namespaces so a missing schema's tables pair. */\n  readonly actual: PostgresDatabaseSchemaNode;\n  /** The one node diff over the two trees: relational + policy drift, cluster-scope-aware ownership filtered. */\n  readonly issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[];\n}\n\n/**\n * The Postgres planner's diff input: the SAME tree-building\n * `diffPostgresSchema` uses (expander threaded, FK schemas resolved,\n * table-less namespaces pruned, cluster-scope-aware ownership filter) plus\n * actual namespace padding (so a missing\n * schema's tables surface as `not-found` instead of a swallowed namespace\n * `not-found`). One differ drives both verify and plan; this is the\n * plan-side derivation. The single issue list covers tables / columns /\n * constraints / indexes / defaults AND policies — the caller splits it\n * (relational → `mapNodeIssueToCall`; policy → RLS ops) and stitches in\n * `CREATE SCHEMA` separately.\n */\nexport function buildPostgresPlanDiff(input: {\n  readonly contract: Contract<SqlStorage>;\n  readonly actualSchema: SqlSchemaIRNode;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n}): PostgresPlanDiff {\n  const postgresContract = blindCast<\n    PostgresContract,\n    'buildPostgresPlanDiff is only called with a postgres contract'\n  >(input.contract);\n  PostgresDatabaseSchemaNode.assert(input.actualSchema);\n  const actual = input.actualSchema;\n  const expandNativeType = buildNativeTypeExpander(input.frameworkComponents);\n  const projectionOptions = {\n    annotationNamespace: 'pg',\n    ...ifDefined('expandNativeType', expandNativeType),\n    resolveDefault: postgresResolveDefault,\n  };\n  const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, projectionOptions);\n  const expected = pruneTableLessNamespaces(fullExpected);\n  const paddedActual = padActualNamespaces(expected, actual);\n  const relationalOwned = ownedSchemaNames(expected);\n  const structuralOwned = ownedSchemaNames(fullExpected);\n  const issues = blindCast<\n    readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n    'both trees are PostgresDatabaseSchemaNodes, so every diff-issue node is a SqlSchemaDiffNode'\n  >(diffSchemas(expected, paddedActual)).filter((issue) => {\n    if (issueOutcome(issue) !== 'not-expected') return true;\n    if (isClusterScopedIssue(issue)) return true;\n    const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);\n    const namespaceSegment = issue.path[1];\n    if (namespaceSegment === undefined) return true;\n    const owned = granularity === 'structural' ? structuralOwned : relationalOwned;\n    return owned.has(namespaceSegment);\n  });\n  return { expected, actual: paddedActual, issues };\n}\n"],"mappings":"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"}

package/dist/diff-database-schema.d.mts

@@ -1,20 +1,11 @@
-import { t as PostgresDatabaseSchemaNode } from "./postgres-database-schema-node-CJv5bfbs.mjs";
+import { t as PostgresDatabaseSchemaNode } from "./postgres-database-schema-node-DMXsIwAb.mjs";
+import { n as SqlSchemaDiffNode } from "./schema-node-kinds-DxvWh2Ic.mjs";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
+import "@prisma-next/family-sql/control";
 import { SqlSchemaIRNode } from "@prisma-next/sql-schema-ir/types";
-import { DiffableNode, SchemaDiffIssue } from "@prisma-next/framework-components/control";
+import { SchemaDiffIssue } from "@prisma-next/framework-components/control";
 import { Contract } from "@prisma-next/contract/types";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
-
-//#region src/core/schema-ir/schema-node-kinds.d.ts
-/**
- * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements
- * `DiffableNode` (the five `Postgres*SchemaNode` classes). `SqlSchemaIRNode`
- * alone is not a `DiffableNode` — its relational subclasses (`SqlColumnIR`, …)
- * carry no `id`/`isEqualTo`/`children` — so this intersection is the honest node
- * type the differ produces and the planner consumes (`SchemaDiff<SqlSchemaDiffNode>`).
- */
-type SqlSchemaDiffNode = SqlSchemaIRNode & DiffableNode;
-//#endregion
 //#region src/core/migrations/diff-database-schema.d.ts
 interface PostgresPlanDiff {
   /** The desired ("end") tree — resolved leaf values (incl. `codecRef`) on every column, table-less namespaces pruned. */

package/dist/diff-database-schema.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"diff-database-schema.d.mts","names":[],"sources":["../src/core/schema-ir/schema-node-kinds.ts","../src/core/migrations/diff-database-schema.ts"],"mappings":";;;;;;;;;;;;;;;KAiBY,iBAAA,GAAoB,eAAA,GAAkB,YAAY;;;UCmL7C,gBAAA;EAMW;EAAA,SAJjB,QAAA,EAAU,0BAAA;EAIwC;EAAA,SAFlD,MAAA,EAAQ,0BAAA;EAiBH;EAAA,SAfL,MAAA,WAAiB,eAAA,CAAgB,iBAAA;AAAA;;;;;;;;;;;;;iBAe5B,qBAAA,CAAsB,KAAA;EAAA,SAC3B,QAAA,EAAU,QAAA,CAAS,UAAA;EAAA,SACnB,YAAA,EAAc,eAAA;EAAA,SACd,mBAAA,EAAqB,aAAA,CAAc,8BAAA;AAAA,IAC1C,gBAAA"}
+{"version":3,"file":"diff-database-schema.d.mts","names":[],"sources":["../src/core/migrations/diff-database-schema.ts"],"mappings":";;;;;;;;;UAsMiB;;WAEN,UAAU;;WAEV,QAAQ;;WAER,iBAAiB,gBAAgB;;;;;;;;;;;;;;iBAe5B,sBAAsB;WAC3B,UAAU,SAAS;WACnB,cAAc;WACd,qBAAqB,cAAc;IAC1C"}

package/dist/diff-database-schema.mjs

@@ -1,2 +1,2 @@
-import { t as buildPostgresPlanDiff } from "./diff-database-schema-GncqMuSI.mjs";
+import { t as buildPostgresPlanDiff } from "./diff-database-schema-BRxq7l98.mjs";
 export { buildPostgresPlanDiff };

package/dist/{errors-DO-w0EUS.mjs → errors-ByDS0xJL.mjs}

@@ -12,9 +12,10 @@ import { CliStructuredError } from "@prisma-next/errors/control";
 * The `operation` argument is required so every throw site names the operation
 * that actually failed; a new operation cannot inherit a misattributed message.
 *
-* Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
-* (data-transform query plan against wrong contract) because the missing
-* input is the stack itself, not the per-operation contract.
+* Distinct from `MIGRATION.UNFILLED_PLACEHOLDER` (placeholder not filled)
+* and `MIGRATION.DATA_TRANSFORM_CONTRACT_MISMATCH` (data-transform query
+* plan against wrong contract) because the missing input is the stack
+* itself, not the per-operation contract.
 *
 * Lives in `@prisma-next/target-postgres/errors` rather than the shared
 * framework migration errors module because the failure is target-specific:
@@ -22,8 +23,7 @@ import { CliStructuredError } from "@prisma-next/errors/control";
 * adapter, the Postgres-target stack) only exists in this package.
 */
 function errorPostgresMigrationStackMissing(operation) {
-	return new CliStructuredError("2007", `PostgresMigration.${operation} requires a control adapter`, {
-		domain: "MIG",
+	return new CliStructuredError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `PostgresMigration.${operation} requires a control adapter`, {
 		why: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,
 		fix: "Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.",
 		meta: { operation }
@@ -32,4 +32,4 @@ function errorPostgresMigrationStackMissing(operation) {
 //#endregion
 export { errorPostgresMigrationStackMissing as t };
 
-//# sourceMappingURL=errors-DO-w0EUS.mjs.map
+//# sourceMappingURL=errors-ByDS0xJL.mjs.map

package/dist/errors-ByDS0xJL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-ByDS0xJL.mjs","names":[],"sources":["../src/core/errors.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `PostgresMigration` operation that needs the materialized control adapter\n * — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —\n * was invoked, but the migration was constructed without a `ControlStack`.\n * Concrete authoring usage always goes through the migration CLI entrypoint,\n * which assembles a stack from the loaded `prisma-next.config.ts`; reaching this\n * error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection only).\n *\n * The `operation` argument is required so every throw site names the operation\n * that actually failed; a new operation cannot inherit a misattributed message.\n *\n * Distinct from `MIGRATION.UNFILLED_PLACEHOLDER` (placeholder not filled)\n * and `MIGRATION.DATA_TRANSFORM_CONTRACT_MISMATCH` (data-transform query\n * plan against wrong contract) because the missing input is the stack\n * itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-postgres/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`PostgresMigration`, the Postgres control\n * adapter, the Postgres-target stack) only exists in this package.\n */\nexport function errorPostgresMigrationStackMissing(operation: string): CliStructuredError {\n  return new CliStructuredError(\n    'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',\n    `PostgresMigration.${operation} requires a control adapter`,\n    {\n      why: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',\n      meta: { operation },\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,mCAAmC,WAAuC;CACxF,OAAO,IAAI,mBACT,4CACA,qBAAqB,UAAU,8BAC/B;EACE,KAAK,qBAAqB,UAAU;EACpC,KAAK;EACL,MAAM,EAAE,UAAU;CACpB,CACF;AACF"}

package/dist/errors.d.mts

@@ -1,5 +1,4 @@
 import { CliStructuredError } from "@prisma-next/errors/control";
-
 //#region src/core/errors.d.ts
 /**
  * A `PostgresMigration` operation that needs the materialized control adapter
@@ -13,9 +12,10 @@ import { CliStructuredError } from "@prisma-next/errors/control";
  * The `operation` argument is required so every throw site names the operation
  * that actually failed; a new operation cannot inherit a misattributed message.
  *
- * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
- * (data-transform query plan against wrong contract) because the missing
- * input is the stack itself, not the per-operation contract.
+ * Distinct from `MIGRATION.UNFILLED_PLACEHOLDER` (placeholder not filled)
+ * and `MIGRATION.DATA_TRANSFORM_CONTRACT_MISMATCH` (data-transform query
+ * plan against wrong contract) because the missing input is the stack
+ * itself, not the per-operation contract.
  *
  * Lives in `@prisma-next/target-postgres/errors` rather than the shared
  * framework migration errors module because the failure is target-specific:

package/dist/errors.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":";;;;;AAuBA;;;;AAAyF;;;;;;;;;;;;;;;iBAAzE,kCAAA,CAAmC,SAAA,WAAoB,kBAAkB"}
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;iBAwBgB,mCAAmC,oBAAoB"}

package/dist/errors.mjs

@@ -1,2 +1,2 @@
-import { t as errorPostgresMigrationStackMissing } from "./errors-DO-w0EUS.mjs";
+import { t as errorPostgresMigrationStackMissing } from "./errors-ByDS0xJL.mjs";
 export { errorPostgresMigrationStackMissing };