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

package/dist/descriptor-meta-DnHabAS3-C53XXPQw.mjs

@@ -0,0 +1,28 @@
+import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86-Cpp8PTxD.mjs";
+import { O as postgresQualifyColumnType } from "./codecs-CBl0nD44-CaWPc1bd.mjs";
+import { h as postgresCreateNamespace } from "./postgres-schema-KSzLDONj-CsXGoY8b.mjs";
+import { a as postgresAuthoringTypes, i as postgresAuthoringPslBlockDescriptors, n as postgresAuthoringFieldPresets, o as postgresLowerEntityHandles, r as postgresAuthoringModelAttributes, t as postgresAuthoringEntityTypes } from "./authoring-03FwIL2k-kPjZAp3s.mjs";
+import { t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-UwYdV8fD-B_m_Ha8r.mjs";
+import { type } from "arktype";
+import { defineIndexTypes } from "@prisma/orm-family-sql/contract/index-types";
+//#region ../../../3-targets/3-targets/postgres/dist/descriptor-meta-DnHabAS3.mjs
+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,
+		entityTypes: postgresAuthoringEntityTypes,
+		pslBlockDescriptors: postgresAuthoringPslBlockDescriptors,
+		modelAttributes: postgresAuthoringModelAttributes,
+		createNamespace: postgresCreateNamespace,
+		qualifyColumnType: postgresQualifyColumnType,
+		lowerEntityHandles: postgresLowerEntityHandles
+	}
+};
+//#endregion
+export { postgresTargetDescriptorMeta as t };
+
+//# sourceMappingURL=descriptor-meta-DnHabAS3-C53XXPQw.mjs.map

package/dist/descriptor-meta-DnHabAS3-C53XXPQw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-DnHabAS3-C53XXPQw.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/descriptor-meta-DnHabAS3.mjs"],"sourcesContent":["import { O as postgresQualifyColumnType } from \"./codecs-CBl0nD44.mjs\";\nimport { t as DEFAULT_NAMESPACE_ID } from \"./namespace-ids-xtp_ZY86.mjs\";\nimport { i as postgresCreateNamespace } from \"./postgres-schema-KSzLDONj.mjs\";\nimport { a as postgresAuthoringTypes, i as postgresAuthoringPslBlockDescriptors, n as postgresAuthoringFieldPresets, o as postgresLowerEntityHandles, r as postgresAuthoringModelAttributes, t as postgresAuthoringEntityTypes } from \"./authoring-03FwIL2k.mjs\";\nimport { t as postgresTargetDescriptorMetaRuntime } from \"./descriptor-meta-runtime-UwYdV8fD.mjs\";\nimport { type } from \"arktype\";\nimport { defineIndexTypes } from \"@internal/sql-contract/index-types\";\n//#region src/core/index-types.ts\nconst 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\") });\nconst postgresTargetDescriptorMeta = {\n\t...postgresTargetDescriptorMetaRuntime,\n\tdefaultNamespaceId: DEFAULT_NAMESPACE_ID,\n\tindexTypes: postgresIndexTypes,\n\tauthoring: {\n\t\ttype: postgresAuthoringTypes,\n\t\tfield: postgresAuthoringFieldPresets,\n\t\tentityTypes: postgresAuthoringEntityTypes,\n\t\tpslBlockDescriptors: postgresAuthoringPslBlockDescriptors,\n\t\tmodelAttributes: postgresAuthoringModelAttributes,\n\t\tcreateNamespace: postgresCreateNamespace,\n\t\tqualifyColumnType: postgresQualifyColumnType,\n\t\tlowerEntityHandles: postgresLowerEntityHandles\n\t}\n};\n//#endregion\nexport { postgresTargetDescriptorMeta as t };\n\n//# sourceMappingURL=descriptor-meta-DnHabAS3.mjs.map"],"mappings":";;;;;;;;AAQA,MAAM,qBAAqB,iBAAiB,CAAC,CAAC,IAAI,SAAS,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,QAAQ,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,OAAO,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,QAAQ,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,UAAU,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,QAAQ,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC;AACpS,MAAM,+BAA+B;CACpC,GAAG;CACH,oBAAoB;CACpB,YAAY;CACZ,WAAW;EACV,MAAM;EACN,OAAO;EACP,aAAa;EACb,qBAAqB;EACrB,iBAAiB;EACjB,iBAAiB;EACjB,mBAAmB;EACnB,oBAAoB;CACrB;AACD"}

package/dist/descriptor-meta-runtime-UwYdV8fD-B_m_Ha8r.mjs

@@ -0,0 +1,13 @@
+//#region ../../../3-targets/3-targets/postgres/dist/descriptor-meta-runtime-UwYdV8fD.mjs
+const postgresTargetDescriptorMetaRuntime = {
+	kind: "target",
+	familyId: "sql",
+	targetId: "postgres",
+	id: "postgres",
+	version: "0.0.1",
+	capabilities: {}
+};
+//#endregion
+export { postgresTargetDescriptorMetaRuntime as t };
+
+//# sourceMappingURL=descriptor-meta-runtime-UwYdV8fD-B_m_Ha8r.mjs.map

package/dist/descriptor-meta-runtime-UwYdV8fD-B_m_Ha8r.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-runtime-UwYdV8fD-B_m_Ha8r.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/descriptor-meta-runtime-UwYdV8fD.mjs"],"sourcesContent":["const postgresTargetDescriptorMetaRuntime = {\n\tkind: \"target\",\n\tfamilyId: \"sql\",\n\ttargetId: \"postgres\",\n\tid: \"postgres\",\n\tversion: \"0.0.1\",\n\tcapabilities: {}\n};\n//#endregion\nexport { postgresTargetDescriptorMetaRuntime as t };\n\n//# sourceMappingURL=descriptor-meta-runtime-UwYdV8fD.mjs.map"],"mappings":";AAAA,MAAM,sCAAsC;CAC3C,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,CAAC;AAChB"}

package/dist/diff-database-schema-BfRs2vrG-D2o4KII0.mjs

@@ -0,0 +1,390 @@
+import { n as postgresError } from "./errors-kYxOQjdD-D4T3rbVp.mjs";
+import { d as isPostgresSchema } from "./postgres-schema-KSzLDONj-CsXGoY8b.mjs";
+import { n as postgresResolveDefault } from "./default-normalizer-Ba5ZebHM-isV86rjy.mjs";
+import { a as postgresDiffSubjectGranularity, n as PostgresSchemaNodeKind, r as PostgresTableSchemaNode, t as PostgresNativeEnumSchemaNode } from "./postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs";
+import { i as PostgresRoleSchemaNode, n as PostgresNamespaceSchemaNode, r as PostgresPolicySchemaNode, t as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-B8Z5i5D--PObwlU2Z.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-CxqlLW47-0GiHRziS.mjs";
+import { d as resolvePostgresNodeIssueControlPolicySubject } from "./control-policy-Cl3RRSPg-CT3QGpR3.mjs";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { namingOf } from "@prisma/orm-family-sql/schema-ir/naming";
+import { diffSchemas, issueOutcome } from "@prisma/orm-framework/components/control";
+import { buildNativeTypeExpander, contractNamespaceToSchemaIR } from "@prisma/orm-family-sql/family/control";
+import { PrimaryKey, RelationalSchemaNodeKind, SqlForeignKeyIR, SqlIndexIR, SqlUniqueIR } from "@prisma/orm-family-sql/schema-ir/types";
+import { classifyDiffSubjectGranularity } from "@prisma/orm-family-sql/family/diff";
+//#region ../../../3-targets/3-targets/postgres/dist/diff-database-schema-BfRs2vrG.mjs
+/** 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({
+		naming: namingOf(policy.name, policy.prefix),
+		tableName: policy.tableName,
+		namespaceId,
+		operation: policy.operation,
+		roles: [...policy.roles],
+		using: policy.using,
+		withCheck: policy.withCheck,
+		permissive: policy.permissive,
+		dependsOn: [tableDependsOn(namespaceId, policy.tableName), ...policy.roles.map(roleDependsOn)]
+	});
+}
+/**
+* Projects a Postgres contract into the expected schema-diff tree: a
+* `PostgresDatabaseSchemaNode` root holding one `PostgresNamespaceSchemaNode`
+* per Postgres namespace, each holding its `PostgresTableSchemaNode`s with
+* their `PostgresPolicySchemaNode`s, plus the database roles on the root.
+*
+* Not a duplicate of the family's `contractToSchemaIR`: that builds a flat,
+* single `{ tables }` map (and throws on cross-namespace name collisions, with
+* no RLS/role concept) for SQLite's single-schema world. This is the
+* Postgres-specific *tree* shape — multi-schema, RLS-policy-aware, role-aware.
+* It reuses the family's per-namespace table conversion (`contractNamespaceToSchemaIR`)
+* for column/FK/index building and only adds the Postgres tree/policy/role shape.
+*
+* Tables are grouped by their owning namespace (resolved DDL schema name) so
+* the tree mirrors Postgres's object hierarchy. The DDL schema name is
+* resolved once per namespace.
+*
+* A policy that references a table absent from its namespace is a malformed
+* contract — the loop throws rather than fabricating a stub table.
+*/
+function contractToPostgresDatabaseSchemaNode(contract, options) {
+	if (contract === null) return new PostgresDatabaseSchemaNode({
+		namespaces: {},
+		roles: [],
+		existingSchemas: [],
+		pgVersion: ""
+	});
+	const namespaces = {};
+	const roles = [];
+	const ownedSchemas = [];
+	for (const ns of Object.values(contract.storage.namespaces)) {
+		if (!isPostgresSchema(ns)) continue;
+		for (const role of Object.values(ns.role)) roles.push(new PostgresRoleSchemaNode({
+			name: role.name,
+			namespaceId: role.namespaceId
+		}));
+		if (ns.id === UNBOUND_NAMESPACE_ID) {
+			if (!Object.entries(ns.entries).some(([entriesKey, slot]) => entriesKey !== "role" && Object.keys(slot).length > 0)) continue;
+		}
+		const ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id);
+		ownedSchemas.push(ddlSchema);
+		const sqlTables = contractNamespaceToSchemaIR(contract.storage, ns.id, options).tables;
+		const policiesByTable = /* @__PURE__ */ new Map();
+		for (const policy of Object.values(ns.policy)) {
+			const list = policiesByTable.get(policy.tableName) ?? [];
+			list.push(toPolicyNode(policy, ddlSchema));
+			policiesByTable.set(policy.tableName, list);
+		}
+		const tables = {};
+		for (const tableName of Object.keys(ns.table)) {
+			const sqlTable = sqlTables[tableName];
+			if (sqlTable === void 0) continue;
+			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) => {
+				const base = {
+					naming: namingOf(i.name, i.prefix),
+					where: i.where,
+					unique: i.unique,
+					partial: i.partial,
+					type: i.type,
+					options: i.options,
+					annotations: i.annotations,
+					dependsOn: columnDependsOn(ddlSchema, tableName, i.columns ?? Object.keys(sqlTable.columns))
+				};
+				return new SqlIndexIR(i.expression !== void 0 ? {
+					...base,
+					expression: i.expression
+				} : {
+					...base,
+					columns: 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,
+				indexes,
+				...ifDefined("primaryKey", primaryKey),
+				...ifDefined("annotations", sqlTable.annotations),
+				...ifDefined("checks", sqlTable.checks),
+				policies: policiesByTable.get(tableName) ?? [],
+				rlsEnabled: Object.hasOwn(ns.rls, tableName)
+			});
+		}
+		for (const [tableName, tablePolicies] of policiesByTable) {
+			if (!(tableName in tables)) {
+				const policyName = tablePolicies[0]?.name ?? "(unknown)";
+				throw postgresError("CONTRACT.POLICY_INVALID", `contract-to-postgres-database-schema-node: policy "${policyName}" references table "${tableName}" not present in namespace "${ddlSchema}"`, { meta: {
+					policyName,
+					tableName,
+					namespaceId: ddlSchema,
+					reason: "table-missing"
+				} });
+			}
+			if (!Object.hasOwn(ns.rls, tableName)) {
+				const policyLabel = tablePolicies[0]?.prefix ?? tablePolicies[0]?.name ?? "(unknown)";
+				throw postgresError("CONTRACT.POLICY_INVALID", `contract-to-postgres-database-schema-node: policy "${policyLabel}" targets table "${tableName}" in namespace "${ddlSchema}", which is not RLS-controlled. Mark the model with @@rls (entries.rls["${tableName}"]) or remove the policy.`, { meta: {
+					policyName: policyLabel,
+					tableName,
+					namespaceId: ddlSchema,
+					reason: "table-not-rls-controlled"
+				} });
+			}
+		}
+		namespaces[ddlSchema] = new PostgresNamespaceSchemaNode({
+			schemaName: ddlSchema,
+			tables,
+			nativeEnums: Object.values(ns.entries.native_enum ?? {}).map((entity) => new PostgresNativeEnumSchemaNode({
+				typeName: entity.typeName,
+				namespaceId: ddlSchema,
+				members: entity.members,
+				...ifDefined("control", entity.control)
+			}))
+		});
+	}
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles,
+		existingSchemas: ownedSchemas,
+		pgVersion: ""
+	});
+}
+/**
+* Whether a diff issue's subject node is cluster-scoped — it carries its own
+* `namespaceId` field (only role and policy diff nodes do) and that
+* coordinate is the unbound sentinel, meaning the node is not owned by any
+* schema/namespace. A role node is always cluster-scoped (roles are
+* cluster-level objects); a policy node's `namespaceId` is always its
+* table's resolved DDL schema, never the sentinel. Namespace-ownership
+* scoping (which compares `issue.path[1]` against the set of DDL schemas
+* the contract owns) makes no sense for a cluster-scoped subject — its path
+* segment at that index is the object's own name, not a schema name — so
+* such an issue bypasses that scoping entirely.
+*/
+function isClusterScopedIssue(issue) {
+	const node = issue.expected ?? issue.actual;
+	return node !== void 0 && nodeNamespaceId(node) === UNBOUND_NAMESPACE_ID;
+}
+function nodeNamespaceId(node) {
+	if (!Object.hasOwn(node, "namespaceId")) return void 0;
+	return blindCast(node).namespaceId;
+}
+function ownedSchemaNames(expected) {
+	const policyNamespaces = Object.values(expected.namespaces).flatMap((ns) => Object.values(ns.tables).flatMap((t) => t.policies.map((p) => p.namespaceId)));
+	return /* @__PURE__ */ new Set([...policyNamespaces, ...expected.existingSchemas]);
+}
+/**
+* Drops contract namespaces that declare no tables from the verdict-diff
+* expected tree and the relational owned-schema set. The legacy relational
+* walk skipped a table-less namespace (e.g. an enums-only schema) before
+* pairing, so neither its DDL schema's absence nor that schema's live
+* relational contents ever reached the verdict — the pruned tree
+* reproduces that. The prune loses no expected policies: policies attach
+* to tables, so a table-less namespace carries none (the projection
+* throws on a policy referencing an absent table). Live policies in a
+* pruned schema remain governed via the full owned set (see
+* {@link diffPostgresSchema}).
+*/
+function pruneTableLessNamespaces(expected) {
+	const namespaces = Object.fromEntries(Object.entries(expected.namespaces).filter(([, ns]) => Object.keys(ns.tables).length > 0));
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles: [...expected.roles],
+		existingSchemas: expected.existingSchemas.filter((s) => namespaces[s] !== void 0),
+		pgVersion: expected.pgVersion
+	});
+}
+/**
+* Resolves a verdict-diff issue's subject's declared control policy directly
+* from the contract, by delegating to the same node-typed resolver
+* ({@link resolvePostgresNodeIssueControlPolicySubject}) the planner uses to
+* gate DDL calls. `undefined` when the issue resolves to no contract subject.
+*
+* A role issue resolves through that same resolver to `external`
+* unconditionally (see its role branch), regardless of the contract's own
+* default policy: a role is referenced by the contract but not owned, and
+* `external`'s existing semantics — a missing declared subject still fails,
+* every extra is suppressed — are exactly the wanted asymmetric grading for
+* a cluster object the framework does not own.
+*/
+function resolveControlPolicy(issue, contract) {
+	return resolvePostgresNodeIssueControlPolicySubject(blindCast(issue), contract)?.explicitNodeControlPolicy;
+}
+/**
+* The Postgres full-tree node diff for the family verify verdict: derive
+* the expected tree (resolved leaf values, expander threaded, FK schemas
+* resolved, table-less namespaces pruned), run the generic
+* differ over the trees as derived, and scope out `not-expected` findings under namespaces the
+* contract does not own. Ownership scoping bypasses cluster-scoped subjects
+* (roles today), mirroring the legacy decomposition: relational extras check
+* the PRUNED owned set (the legacy
+* per-namespace walk never visited a table-less namespace, so its live
+* relational contents are invisible), while `structural` extras (RLS
+* policies) check the FULL owned set (the legacy policy diff governed
+* every contract schema regardless of tables — RLS governance does not
+* shrink because a namespace declares no tables). The codec `verifyType`
+* hooks run once per contract namespace with tables against that
+* namespace's paired actual node (the hooks read namespace-scoped state
+* such as `nativeEnums`).
+*/
+function diffPostgresSchema(input) {
+	const postgresContract = blindCast(input.contract);
+	PostgresDatabaseSchemaNode.assert(input.schema);
+	const actual = input.schema;
+	const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {
+		annotationNamespace: "pg",
+		...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 (issueOutcome(issue) !== "not-expected") return true;
+			if (isClusterScopedIssue(issue)) return true;
+			const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
+			const namespaceSegment = issue.path[1];
+			if (namespaceSegment === void 0) return true;
+			return (granularity === "structural" ? structuralOwned : relationalOwned).has(namespaceSegment);
+		}),
+		resolveControlPolicy: (issue) => resolveControlPolicy(issue, postgresContract),
+		namespacePairs: Object.values(expected.namespaces).map((ns) => ({ actual: actual.namespaces[ns.schemaName] }))
+	};
+}
+/**
+* Adds an empty namespace node to the actual tree for every expected namespace
+* absent from it. The relational plan diff pairs on namespace: a contract
+* namespace whose live schema does not exist yet must surface each of its
+* tables as `not-found` (→ `CREATE TABLE`), NOT as a single namespace
+* `not-found` that subtree-coalescing would collapse (leaving `CREATE SCHEMA`
+* with no tables). Padding makes the namespaces pair, so only table/column/
+* policy drift surfaces; `CREATE SCHEMA` comes separately from the synthesized
+* namespace-presence stitch (`verifyPostgresNamespacePresence`), never from the
+* tree diff — matching the retired per-namespace-paired relational walk, which
+* paired a missing schema against an empty namespace node.
+*/
+function padActualNamespaces(expected, actual) {
+	const namespaces = { ...actual.namespaces };
+	let padded = false;
+	for (const schemaName of Object.keys(expected.namespaces)) if (namespaces[schemaName] === void 0) {
+		namespaces[schemaName] = new PostgresNamespaceSchemaNode({
+			schemaName,
+			tables: {}
+		});
+		padded = true;
+	}
+	if (!padded) return actual;
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles: [...actual.roles],
+		existingSchemas: [...actual.existingSchemas],
+		pgVersion: actual.pgVersion
+	});
+}
+/**
+* The Postgres planner's diff input: the SAME tree-building
+* `diffPostgresSchema` uses (expander threaded, FK schemas resolved,
+* table-less namespaces pruned, cluster-scope-aware ownership filter) plus
+* actual namespace padding (so a missing
+* schema's tables surface as `not-found` instead of a swallowed namespace
+* `not-found`). One differ drives both verify and plan; this is the
+* plan-side derivation. The single issue list covers tables / columns /
+* constraints / indexes / defaults AND policies — the caller splits it
+* (relational → `mapNodeIssueToCall`; policy → RLS ops) and stitches in
+* `CREATE SCHEMA` separately.
+*/
+function buildPostgresPlanDiff(input) {
+	const postgresContract = blindCast(input.contract);
+	PostgresDatabaseSchemaNode.assert(input.actualSchema);
+	const actual = input.actualSchema;
+	const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {
+		annotationNamespace: "pg",
+		...ifDefined("expandNativeType", buildNativeTypeExpander(input.frameworkComponents)),
+		resolveDefault: postgresResolveDefault
+	});
+	const expected = pruneTableLessNamespaces(fullExpected);
+	const paddedActual = padActualNamespaces(expected, actual);
+	const relationalOwned = ownedSchemaNames(expected);
+	const structuralOwned = ownedSchemaNames(fullExpected);
+	return {
+		expected,
+		actual: paddedActual,
+		issues: blindCast(diffSchemas(expected, paddedActual)).filter((issue) => {
+			if (issueOutcome(issue) !== "not-expected") return true;
+			if (isClusterScopedIssue(issue)) return true;
+			const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
+			const namespaceSegment = issue.path[1];
+			if (namespaceSegment === void 0) return true;
+			return (granularity === "structural" ? structuralOwned : relationalOwned).has(namespaceSegment);
+		})
+	};
+}
+//#endregion
+export { contractToPostgresDatabaseSchemaNode as n, diffPostgresSchema as r, buildPostgresPlanDiff as t };
+
+//# sourceMappingURL=diff-database-schema-BfRs2vrG-D2o4KII0.mjs.map

package/dist/diff-database-schema-BfRs2vrG-D2o4KII0.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-database-schema-BfRs2vrG-D2o4KII0.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/diff-database-schema-BfRs2vrG.mjs"],"sourcesContent":["import { n as postgresError } from \"./errors-kYxOQjdD.mjs\";\nimport { n as postgresResolveDefault } from \"./default-normalizer-Ba5ZebHM.mjs\";\nimport { r as isPostgresSchema } from \"./postgres-schema-KSzLDONj.mjs\";\nimport { a as postgresDiffSubjectGranularity, n as PostgresNativeEnumSchemaNode, r as PostgresSchemaNodeKind, t as PostgresTableSchemaNode } from \"./postgres-table-schema-node-BBkitBQh.mjs\";\nimport { i as PostgresDatabaseSchemaNode, n as PostgresPolicySchemaNode, r as PostgresNamespaceSchemaNode, t as PostgresRoleSchemaNode } from \"./postgres-role-schema-node-B8Z5i5D-.mjs\";\nimport { t as resolveDdlSchemaForNamespaceStorage } from \"./resolve-ddl-schema-CxqlLW47.mjs\";\nimport { i as resolvePostgresNodeIssueControlPolicySubject } from \"./control-policy-Cl3RRSPg.mjs\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { UNBOUND_NAMESPACE_ID } from \"@internal/framework-components/ir\";\nimport { buildNativeTypeExpander, contractNamespaceToSchemaIR } from \"@internal/family-sql/control\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { namingOf } from \"@internal/sql-schema-ir/naming\";\nimport { PrimaryKey, RelationalSchemaNodeKind, SqlForeignKeyIR, SqlIndexIR, SqlUniqueIR } from \"@internal/sql-schema-ir/types\";\nimport { classifyDiffSubjectGranularity } from \"@internal/family-sql/diff\";\nimport { diffSchemas, issueOutcome } from \"@internal/framework-components/control\";\n//#region src/core/migrations/contract-to-postgres-database-schema-node.ts\n/** The database root's fixed sentinel id (`PostgresDatabaseSchemaNode#id`). */\nfunction databaseStep() {\n\treturn {\n\t\tnodeKind: PostgresSchemaNodeKind.database,\n\t\tid: \"database\"\n\t};\n}\nfunction tableDependsOn(namespaceId, tableName) {\n\treturn [\n\t\tdatabaseStep(),\n\t\t{\n\t\t\tnodeKind: PostgresSchemaNodeKind.namespace,\n\t\t\tid: namespaceId\n\t\t},\n\t\t{\n\t\t\tnodeKind: PostgresSchemaNodeKind.table,\n\t\t\tid: tableName\n\t\t}\n\t];\n}\nfunction roleDependsOn(role) {\n\treturn [databaseStep(), {\n\t\tnodeKind: PostgresSchemaNodeKind.role,\n\t\tid: role\n\t}];\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(namespaceId, tableName, columns) {\n\treturn columns.map((column) => [...tableDependsOn(namespaceId, tableName), {\n\t\tnodeKind: RelationalSchemaNodeKind.column,\n\t\tid: `column:${column}`\n\t}]);\n}\nfunction toPolicyNode(policy, namespaceId) {\n\treturn new PostgresPolicySchemaNode({\n\t\tnaming: namingOf(policy.name, policy.prefix),\n\t\ttableName: policy.tableName,\n\t\tnamespaceId,\n\t\toperation: policy.operation,\n\t\troles: [...policy.roles],\n\t\tusing: policy.using,\n\t\twithCheck: policy.withCheck,\n\t\tpermissive: policy.permissive,\n\t\tdependsOn: [tableDependsOn(namespaceId, policy.tableName), ...policy.roles.map(roleDependsOn)]\n\t});\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*/\nfunction contractToPostgresDatabaseSchemaNode(contract, options) {\n\tif (contract === null) return new PostgresDatabaseSchemaNode({\n\t\tnamespaces: {},\n\t\troles: [],\n\t\texistingSchemas: [],\n\t\tpgVersion: \"\"\n\t});\n\tconst namespaces = {};\n\tconst roles = [];\n\tconst ownedSchemas = [];\n\tfor (const ns of Object.values(contract.storage.namespaces)) {\n\t\tif (!isPostgresSchema(ns)) continue;\n\t\tfor (const role of Object.values(ns.role)) roles.push(new PostgresRoleSchemaNode({\n\t\t\tname: role.name,\n\t\t\tnamespaceId: role.namespaceId\n\t\t}));\n\t\tif (ns.id === UNBOUND_NAMESPACE_ID) {\n\t\t\tif (!Object.entries(ns.entries).some(([entriesKey, slot]) => entriesKey !== \"role\" && Object.keys(slot).length > 0)) continue;\n\t\t}\n\t\tconst ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id);\n\t\townedSchemas.push(ddlSchema);\n\t\tconst sqlTables = contractNamespaceToSchemaIR(contract.storage, ns.id, options).tables;\n\t\tconst policiesByTable = /* @__PURE__ */ new Map();\n\t\tfor (const policy of Object.values(ns.policy)) {\n\t\t\tconst list = policiesByTable.get(policy.tableName) ?? [];\n\t\t\tlist.push(toPolicyNode(policy, ddlSchema));\n\t\t\tpoliciesByTable.set(policy.tableName, list);\n\t\t}\n\t\tconst tables = {};\n\t\tfor (const tableName of Object.keys(ns.table)) {\n\t\t\tconst sqlTable = sqlTables[tableName];\n\t\t\tif (sqlTable === void 0) continue;\n\t\t\tconst foreignKeys = sqlTable.foreignKeys.map((fk) => {\n\t\t\t\tconst resolvedReferencedNamespace = resolveDdlSchemaForNamespaceStorage(contract.storage, fk.referencedSchema ?? UNBOUND_NAMESPACE_ID);\n\t\t\t\treturn new SqlForeignKeyIR({\n\t\t\t\t\tcolumns: fk.columns,\n\t\t\t\t\treferencedTable: fk.referencedTable,\n\t\t\t\t\treferencedColumns: fk.referencedColumns,\n\t\t\t\t\treferencedSchema: fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,\n\t\t\t\t\t...ifDefined(\"name\", fk.name),\n\t\t\t\t\t...ifDefined(\"onDelete\", fk.onDelete),\n\t\t\t\t\t...ifDefined(\"onUpdate\", fk.onUpdate),\n\t\t\t\t\t...ifDefined(\"annotations\", fk.annotations),\n\t\t\t\t\tresolvedReferencedNamespace,\n\t\t\t\t\tdependsOn: [tableDependsOn(resolvedReferencedNamespace, fk.referencedTable), ...columnDependsOn(ddlSchema, tableName, fk.columns)]\n\t\t\t\t});\n\t\t\t});\n\t\t\tconst uniques = sqlTable.uniques.map((u) => new SqlUniqueIR({\n\t\t\t\tcolumns: u.columns,\n\t\t\t\t...ifDefined(\"name\", u.name),\n\t\t\t\t...ifDefined(\"annotations\", u.annotations),\n\t\t\t\tdependsOn: columnDependsOn(ddlSchema, tableName, u.columns)\n\t\t\t}));\n\t\t\tconst indexes = sqlTable.indexes.map((i) => {\n\t\t\t\tconst base = {\n\t\t\t\t\tnaming: namingOf(i.name, i.prefix),\n\t\t\t\t\twhere: i.where,\n\t\t\t\t\tunique: i.unique,\n\t\t\t\t\tpartial: i.partial,\n\t\t\t\t\ttype: i.type,\n\t\t\t\t\toptions: i.options,\n\t\t\t\t\tannotations: i.annotations,\n\t\t\t\t\tdependsOn: columnDependsOn(ddlSchema, tableName, i.columns ?? Object.keys(sqlTable.columns))\n\t\t\t\t};\n\t\t\t\treturn new SqlIndexIR(i.expression !== void 0 ? {\n\t\t\t\t\t...base,\n\t\t\t\t\texpression: i.expression\n\t\t\t\t} : {\n\t\t\t\t\t...base,\n\t\t\t\t\tcolumns: i.columns ?? []\n\t\t\t\t});\n\t\t\t});\n\t\t\tconst primaryKey = sqlTable.primaryKey !== void 0 ? new PrimaryKey({\n\t\t\t\tcolumns: sqlTable.primaryKey.columns,\n\t\t\t\t...ifDefined(\"name\", sqlTable.primaryKey.name),\n\t\t\t\tdependsOn: columnDependsOn(ddlSchema, tableName, sqlTable.primaryKey.columns)\n\t\t\t}) : void 0;\n\t\t\ttables[tableName] = new PostgresTableSchemaNode({\n\t\t\t\tname: sqlTable.name,\n\t\t\t\tcolumns: sqlTable.columns,\n\t\t\t\tforeignKeys,\n\t\t\t\tuniques,\n\t\t\t\tindexes,\n\t\t\t\t...ifDefined(\"primaryKey\", primaryKey),\n\t\t\t\t...ifDefined(\"annotations\", sqlTable.annotations),\n\t\t\t\t...ifDefined(\"checks\", sqlTable.checks),\n\t\t\t\tpolicies: policiesByTable.get(tableName) ?? [],\n\t\t\t\trlsEnabled: Object.hasOwn(ns.rls, tableName)\n\t\t\t});\n\t\t}\n\t\tfor (const [tableName, tablePolicies] of policiesByTable) {\n\t\t\tif (!(tableName in tables)) {\n\t\t\t\tconst policyName = tablePolicies[0]?.name ?? \"(unknown)\";\n\t\t\t\tthrow postgresError(\"CONTRACT.POLICY_INVALID\", `contract-to-postgres-database-schema-node: policy \"${policyName}\" references table \"${tableName}\" not present in namespace \"${ddlSchema}\"`, { meta: {\n\t\t\t\t\tpolicyName,\n\t\t\t\t\ttableName,\n\t\t\t\t\tnamespaceId: ddlSchema,\n\t\t\t\t\treason: \"table-missing\"\n\t\t\t\t} });\n\t\t\t}\n\t\t\tif (!Object.hasOwn(ns.rls, tableName)) {\n\t\t\t\tconst policyLabel = tablePolicies[0]?.prefix ?? tablePolicies[0]?.name ?? \"(unknown)\";\n\t\t\t\tthrow postgresError(\"CONTRACT.POLICY_INVALID\", `contract-to-postgres-database-schema-node: policy \"${policyLabel}\" targets table \"${tableName}\" in namespace \"${ddlSchema}\", which is not RLS-controlled. Mark the model with @@rls (entries.rls[\"${tableName}\"]) or remove the policy.`, { meta: {\n\t\t\t\t\tpolicyName: policyLabel,\n\t\t\t\t\ttableName,\n\t\t\t\t\tnamespaceId: ddlSchema,\n\t\t\t\t\treason: \"table-not-rls-controlled\"\n\t\t\t\t} });\n\t\t\t}\n\t\t}\n\t\tnamespaces[ddlSchema] = new PostgresNamespaceSchemaNode({\n\t\t\tschemaName: ddlSchema,\n\t\t\ttables,\n\t\t\tnativeEnums: Object.values(ns.entries.native_enum ?? {}).map((entity) => new PostgresNativeEnumSchemaNode({\n\t\t\t\ttypeName: entity.typeName,\n\t\t\t\tnamespaceId: ddlSchema,\n\t\t\t\tmembers: entity.members,\n\t\t\t\t...ifDefined(\"control\", entity.control)\n\t\t\t}))\n\t\t});\n\t}\n\treturn new PostgresDatabaseSchemaNode({\n\t\tnamespaces,\n\t\troles,\n\t\texistingSchemas: ownedSchemas,\n\t\tpgVersion: \"\"\n\t});\n}\n//#endregion\n//#region src/core/migrations/diff-database-schema.ts\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) {\n\tconst node = issue.expected ?? issue.actual;\n\treturn node !== void 0 && nodeNamespaceId(node) === UNBOUND_NAMESPACE_ID;\n}\nfunction nodeNamespaceId(node) {\n\tif (!Object.hasOwn(node, \"namespaceId\")) return void 0;\n\treturn blindCast(node).namespaceId;\n}\nfunction ownedSchemaNames(expected) {\n\tconst policyNamespaces = Object.values(expected.namespaces).flatMap((ns) => Object.values(ns.tables).flatMap((t) => t.policies.map((p) => p.namespaceId)));\n\treturn /* @__PURE__ */ new Set([...policyNamespaces, ...expected.existingSchemas]);\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(expected) {\n\tconst namespaces = Object.fromEntries(Object.entries(expected.namespaces).filter(([, ns]) => Object.keys(ns.tables).length > 0));\n\treturn new PostgresDatabaseSchemaNode({\n\t\tnamespaces,\n\t\troles: [...expected.roles],\n\t\texistingSchemas: expected.existingSchemas.filter((s) => namespaces[s] !== void 0),\n\t\tpgVersion: expected.pgVersion\n\t});\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(issue, contract) {\n\treturn resolvePostgresNodeIssueControlPolicySubject(blindCast(issue), contract)?.explicitNodeControlPolicy;\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*/\nfunction diffPostgresSchema(input) {\n\tconst postgresContract = blindCast(input.contract);\n\tPostgresDatabaseSchemaNode.assert(input.schema);\n\tconst actual = input.schema;\n\tconst fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {\n\t\tannotationNamespace: \"pg\",\n\t\t...ifDefined(\"expandNativeType\", buildNativeTypeExpander(input.frameworkComponents)),\n\t\tresolveDefault: postgresResolveDefault\n\t});\n\tconst expected = pruneTableLessNamespaces(fullExpected);\n\tconst relationalOwned = ownedSchemaNames(expected);\n\tconst structuralOwned = ownedSchemaNames(fullExpected);\n\treturn {\n\t\tissues: diffSchemas(expected, actual).filter((issue) => {\n\t\t\tif (issueOutcome(issue) !== \"not-expected\") return true;\n\t\t\tif (isClusterScopedIssue(issue)) return true;\n\t\t\tconst granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);\n\t\t\tconst namespaceSegment = issue.path[1];\n\t\t\tif (namespaceSegment === void 0) return true;\n\t\t\treturn (granularity === \"structural\" ? structuralOwned : relationalOwned).has(namespaceSegment);\n\t\t}),\n\t\tresolveControlPolicy: (issue) => resolveControlPolicy(issue, postgresContract),\n\t\tnamespacePairs: Object.values(expected.namespaces).map((ns) => ({ actual: actual.namespaces[ns.schemaName] }))\n\t};\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(expected, actual) {\n\tconst namespaces = { ...actual.namespaces };\n\tlet padded = false;\n\tfor (const schemaName of Object.keys(expected.namespaces)) if (namespaces[schemaName] === void 0) {\n\t\tnamespaces[schemaName] = new PostgresNamespaceSchemaNode({\n\t\t\tschemaName,\n\t\t\ttables: {}\n\t\t});\n\t\tpadded = true;\n\t}\n\tif (!padded) return actual;\n\treturn new PostgresDatabaseSchemaNode({\n\t\tnamespaces,\n\t\troles: [...actual.roles],\n\t\texistingSchemas: [...actual.existingSchemas],\n\t\tpgVersion: actual.pgVersion\n\t});\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*/\nfunction buildPostgresPlanDiff(input) {\n\tconst postgresContract = blindCast(input.contract);\n\tPostgresDatabaseSchemaNode.assert(input.actualSchema);\n\tconst actual = input.actualSchema;\n\tconst fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {\n\t\tannotationNamespace: \"pg\",\n\t\t...ifDefined(\"expandNativeType\", buildNativeTypeExpander(input.frameworkComponents)),\n\t\tresolveDefault: postgresResolveDefault\n\t});\n\tconst expected = pruneTableLessNamespaces(fullExpected);\n\tconst paddedActual = padActualNamespaces(expected, actual);\n\tconst relationalOwned = ownedSchemaNames(expected);\n\tconst structuralOwned = ownedSchemaNames(fullExpected);\n\treturn {\n\t\texpected,\n\t\tactual: paddedActual,\n\t\tissues: blindCast(diffSchemas(expected, paddedActual)).filter((issue) => {\n\t\t\tif (issueOutcome(issue) !== \"not-expected\") return true;\n\t\t\tif (isClusterScopedIssue(issue)) return true;\n\t\t\tconst granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);\n\t\t\tconst namespaceSegment = issue.path[1];\n\t\t\tif (namespaceSegment === void 0) return true;\n\t\t\treturn (granularity === \"structural\" ? structuralOwned : relationalOwned).has(namespaceSegment);\n\t\t})\n\t};\n}\n//#endregion\nexport { diffPostgresSchema as n, contractToPostgresDatabaseSchemaNode as r, buildPostgresPlanDiff as t };\n\n//# sourceMappingURL=diff-database-schema-BfRs2vrG.mjs.map"],"mappings":"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"}

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

@@ -0,0 +1,38 @@
+import { t as PostgresDatabaseSchemaNode } from "./postgres-database-schema-node-CyfpHXDr-BqyozkQE.mjs";
+import { n as SqlSchemaDiffNode } from "./schema-node-kinds-qlnURWJy-Bo30pwTM.mjs";
+import { SqlStorage } from "@prisma/orm-family-sql/contract/types";
+import { SchemaDiffIssue } from "@prisma/orm-framework/components/control";
+import "@prisma/orm-family-sql/family/control";
+import { SqlSchemaIRNode } from "@prisma/orm-family-sql/schema-ir/types";
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
+//#region ../../../3-targets/3-targets/postgres/dist/diff-database-schema.d.mts
+//#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. */
+  readonly expected: PostgresDatabaseSchemaNode;
+  /** The live ("start") tree, padded with empty namespaces so a missing schema's tables pair. */
+  readonly actual: PostgresDatabaseSchemaNode;
+  /** The one node diff over the two trees: relational + policy drift, cluster-scope-aware ownership filtered. */
+  readonly issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[];
+}
+/**
+ * The Postgres planner's diff input: the SAME tree-building
+ * `diffPostgresSchema` uses (expander threaded, FK schemas resolved,
+ * table-less namespaces pruned, cluster-scope-aware ownership filter) plus
+ * actual namespace padding (so a missing
+ * schema's tables surface as `not-found` instead of a swallowed namespace
+ * `not-found`). One differ drives both verify and plan; this is the
+ * plan-side derivation. The single issue list covers tables / columns /
+ * constraints / indexes / defaults AND policies — the caller splits it
+ * (relational → `mapNodeIssueToCall`; policy → RLS ops) and stitches in
+ * `CREATE SCHEMA` separately.
+ */
+declare function buildPostgresPlanDiff(input: {
+  readonly contract: Contract<SqlStorage>;
+  readonly actualSchema: SqlSchemaIRNode;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}): PostgresPlanDiff;
+//#endregion
+export { buildPostgresPlanDiff as t };
+//# sourceMappingURL=diff-database-schema-DsoNznGC.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diff-database-schema-DsoNznGC.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/diff-database-schema.d.mts"],"mappings":";;;;;;;;;;UASU;;WAEC,UAAU;;WAEV,QAAQ;;WAER,iBAAiB,gBAAgB;;;;;;;;;;;;;;iBAc3B,sBAAsB;WAC5B,UAAU,SAAS;WACnB,cAAc;WACd,qBAAqB,cAAc;IAC1C"}

package/dist/driver.d.mts

@@ -0,0 +1,3 @@
+import { t as PostgresControlDriver } from "./control-B-FTbEnE.mjs";
+import { i as QueryResult, n as PostgresDriverCreateOptions, r as PostgresRuntimeDriver, t as PostgresBinding } from "./runtime-CDewySU9.mjs";
+export { type PostgresBinding, PostgresControlDriver, type PostgresDriverCreateOptions, PostgresRuntimeDriver, type QueryResult };

package/dist/driver.mjs

@@ -0,0 +1,2 @@
+import { t as PostgresControlDriver } from "./control-6WFTtLAM.mjs";
+export { PostgresControlDriver };

package/dist/driver__control.d.mts

@@ -0,0 +1,2 @@
+import { n as postgresDriverDescriptor, t as PostgresControlDriver } from "./control-B-FTbEnE.mjs";
+export { PostgresControlDriver, postgresDriverDescriptor as default };

package/dist/driver__control.mjs

@@ -0,0 +1,2 @@
+import { n as postgresDriverDescriptor, t as PostgresControlDriver } from "./control-6WFTtLAM.mjs";
+export { PostgresControlDriver, postgresDriverDescriptor as default };

package/dist/driver__runtime.d.mts

@@ -0,0 +1,2 @@
+import { a as postgresRuntimeDriverDescriptor, i as QueryResult, n as PostgresDriverCreateOptions, r as PostgresRuntimeDriver, t as PostgresBinding } from "./runtime-CDewySU9.mjs";
+export { type PostgresBinding, type PostgresDriverCreateOptions, PostgresRuntimeDriver, type QueryResult, postgresRuntimeDriverDescriptor as default };