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

package/dist/{op-factory-call-D6_7-7Vc.d.mts.map → op-factory-call-CSIg5XDu.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"op-factory-call-D6_7-7Vc.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts","../src/core/migrations/op-factory-call.ts"],"mappings":"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"}
+{"version":3,"file":"op-factory-call-CSIg5XDu.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts","../src/core/migrations/op-factory-call.ts"],"mappings":"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"}

package/dist/op-factory-call.d.mts

@@ -1,2 +1,2 @@
-import { C as SetDefaultCall, S as RawSqlCall, _ as DropDefaultCall, a as AddPrimaryKeyCall, b as DropTableCall, d as CreateSchemaCall, f as CreateTableCall, g as DropConstraintCall, h as DropColumnCall, i as AddNotNullColumnWithTempDefaultCall, l as CreateExtensionCall, m as DropCheckConstraintCall, n as AddColumnCall, o as AddUniqueCall, p as DataTransformCall, r as AddForeignKeyCall, s as AlterColumnTypeCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropIndexCall, w as SetNotNullCall, y as DropNotNullCall } from "./op-factory-call-D6_7-7Vc.mjs";
-export { AddCheckConstraintCall, AddColumnCall, AddForeignKeyCall, AddNotNullColumnWithTempDefaultCall, AddPrimaryKeyCall, AddUniqueCall, AlterColumnTypeCall, CreateExtensionCall, CreateIndexCall, CreateSchemaCall, CreateTableCall, DataTransformCall, DropCheckConstraintCall, DropColumnCall, DropConstraintCall, DropDefaultCall, DropIndexCall, DropNotNullCall, DropTableCall, RawSqlCall, SetDefaultCall, SetNotNullCall };
+import { E as SetNotNullCall, S as DropTableCall, T as SetDefaultCall, _ as DropConstraintCall, a as AddPrimaryKeyCall, b as DropNativeEnumTypeCall, d as CreateNativeEnumTypeCall, f as CreateSchemaCall, g as DropColumnCall, h as DropCheckConstraintCall, i as AddNotNullColumnWithTempDefaultCall, l as CreateExtensionCall, m as DataTransformCall, n as AddColumnCall, o as AddUniqueCall, p as CreateTableCall, r as AddForeignKeyCall, s as AlterColumnTypeCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropDefaultCall, w as RawSqlCall, x as DropNotNullCall, y as DropIndexCall } from "./op-factory-call-CSIg5XDu.mjs";
+export { AddCheckConstraintCall, AddColumnCall, AddForeignKeyCall, AddNotNullColumnWithTempDefaultCall, AddPrimaryKeyCall, AddUniqueCall, AlterColumnTypeCall, CreateExtensionCall, CreateIndexCall, CreateNativeEnumTypeCall, CreateSchemaCall, CreateTableCall, DataTransformCall, DropCheckConstraintCall, DropColumnCall, DropConstraintCall, DropDefaultCall, DropIndexCall, DropNativeEnumTypeCall, DropNotNullCall, DropTableCall, RawSqlCall, SetDefaultCall, SetNotNullCall };

package/dist/op-factory-call.mjs

@@ -1,2 +1,2 @@
-import { C as DropTableCall, D as SetDefaultCall, O as SetNotNullCall, T as RawSqlCall, _ as DropColumnCall, a as AddNotNullColumnWithTempDefaultCall, b as DropIndexCall, c as AlterColumnTypeCall, f as CreateSchemaCall, g as DropCheckConstraintCall, l as CreateExtensionCall, m as DataTransformCall, n as AddColumnCall, o as AddPrimaryKeyCall, p as CreateTableCall, r as AddForeignKeyCall, s as AddUniqueCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropConstraintCall, x as DropNotNullCall, y as DropDefaultCall } from "./op-factory-call-DxNNKUeZ.mjs";
-export { AddCheckConstraintCall, AddColumnCall, AddForeignKeyCall, AddNotNullColumnWithTempDefaultCall, AddPrimaryKeyCall, AddUniqueCall, AlterColumnTypeCall, CreateExtensionCall, CreateIndexCall, CreateSchemaCall, CreateTableCall, DataTransformCall, DropCheckConstraintCall, DropColumnCall, DropConstraintCall, DropDefaultCall, DropIndexCall, DropNotNullCall, DropTableCall, RawSqlCall, SetDefaultCall, SetNotNullCall };
+import { A as SetNotNullCall, C as DropNotNullCall, D as RawSqlCall, S as DropNativeEnumTypeCall, T as DropTableCall, _ as DropCheckConstraintCall, a as AddNotNullColumnWithTempDefaultCall, b as DropDefaultCall, c as AlterColumnTypeCall, d as CreateNativeEnumTypeCall, h as DataTransformCall, k as SetDefaultCall, l as CreateExtensionCall, m as CreateTableCall, n as AddColumnCall, o as AddPrimaryKeyCall, p as CreateSchemaCall, r as AddForeignKeyCall, s as AddUniqueCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropColumnCall, x as DropIndexCall, y as DropConstraintCall } from "./op-factory-call-C4flTtTG.mjs";
+export { AddCheckConstraintCall, AddColumnCall, AddForeignKeyCall, AddNotNullColumnWithTempDefaultCall, AddPrimaryKeyCall, AddUniqueCall, AlterColumnTypeCall, CreateExtensionCall, CreateIndexCall, CreateNativeEnumTypeCall, CreateSchemaCall, CreateTableCall, DataTransformCall, DropCheckConstraintCall, DropColumnCall, DropConstraintCall, DropDefaultCall, DropIndexCall, DropNativeEnumTypeCall, DropNotNullCall, DropTableCall, RawSqlCall, SetDefaultCall, SetNotNullCall };

package/dist/pack.d.mts

@@ -1,7 +1,7 @@
 import { Y as postgresQualifyColumnType } from "./codecs-Cm-nS4mQ.mjs";
 import { r as CodecTypes } from "./codec-types-BiIWziRO.mjs";
 import { t as PostgresRlsPolicy } from "./postgres-rls-policy--CSddvMR.mjs";
-import { a as postgresCreateNamespace, c as PostgresRlsEnablement, d as PostgresRoleInput, l as PostgresRlsEnablementInput, o as PostgresNativeEnum, u as PostgresRole } from "./postgres-schema-CU4gF6QZ.mjs";
+import { a as postgresCreateNamespace, c as PostgresRlsEnablement, d as PostgresRoleInput, l as PostgresRlsEnablementInput, o as PostgresNativeEnum, u as PostgresRole } from "./postgres-schema-DsrtYp2v.mjs";
 import { PslExtensionBlock } from "@prisma-next/framework-components/authoring";
 
 //#region src/core/authoring.d.ts
@@ -167,6 +167,7 @@ declare const postgresTargetDescriptorMetaBase: {
           kind: "role";
           name: string;
           namespaceId: string;
+          control?: "external";
         }, {}>;
         readonly output: {
           readonly factory: (input: PostgresRoleInput) => PostgresRole;
@@ -200,7 +201,7 @@ declare const postgresTargetDescriptorMetaBase: {
           withCheck?: string;
         }, {}>;
         readonly output: {
-          readonly factory: (block: RlsPolicyExtensionBlock, _ctx: import("@prisma-next/framework-components/authoring").AuthoringEntityContext) => PostgresRlsPolicy;
+          readonly factory: (block: RlsPolicyExtensionBlock, ctx: import("@prisma-next/framework-components/authoring").AuthoringEntityContext) => PostgresRlsPolicy | undefined;
         };
       };
       readonly native_enum: {
@@ -210,7 +211,7 @@ declare const postgresTargetDescriptorMetaBase: {
           kind: "postgres-enum";
           typeName: string;
           members: readonly string[];
-          control?: "managed" | "tolerated" | "external" | "observed";
+          control?: "external" | "managed" | "tolerated" | "observed";
         }, {}>;
         readonly output: {
           factory: (block: import("@prisma-next/psl-parser").PslExtensionBlock, ctx: import("@prisma-next/framework-components/authoring").AuthoringEntityContext) => PostgresNativeEnum | undefined;
@@ -255,6 +256,148 @@ declare const postgresTargetDescriptorMetaBase: {
           readonly attribute: "rls";
         };
       };
+      readonly policy_delete: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_delete";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_insert: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_insert";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly withCheck: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_update: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_update";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+          readonly withCheck: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_all: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_all";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+          readonly withCheck: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
       readonly native_enum: {
         readonly kind: "pslBlock";
         readonly keyword: "native_enum";

package/dist/pack.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta.ts"],"mappings":";;;;;;;UAgDiB,uBAAA,SAAgC,iBAAiB;EAAA,SACvD,WAAW;AAAA;;;cCpChB,gCAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAYI,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEG,4BAAA,SAAqC,gCAAA;EAAA,SACvC,YAAA,GAAe,UAAU;AAAA"}
+{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta.ts"],"mappings":";;;;;;;UAiDiB,uBAAA,SAAgC,iBAAiB;EAAA,SACvD,WAAW;AAAA;;;cCrChB,gCAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAYI,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEG,4BAAA,SAAqC,gCAAA;EAAA,SACvC,YAAA,GAAe,UAAU;AAAA"}

package/dist/pack.mjs

@@ -1,2 +1,2 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-BOcKPaLE.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DEuXJfpR.mjs";
 export { postgresTargetDescriptorMeta as default };

package/dist/{planner-CNrc1Odu.mjs → planner-BtEd5LMr.mjs}

@@ -1,13 +1,12 @@
 import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86.mjs";
-import { h as PostgresRlsPolicy, r as isPostgresSchema } from "./postgres-schema-DTLA_aRi.mjs";
+import { g as PostgresRlsPolicy, r as isPostgresSchema } from "./postgres-schema-DWQ0-CPb.mjs";
 import { n as parseRlsPolicyWireName } from "./wire-name-rHHtr1h0.mjs";
-import { n as PostgresSchemaNodeKind } from "./postgres-table-schema-node-9FCtCUz2.mjs";
-import { i as PostgresDatabaseSchemaNode, n as PostgresPolicySchemaNode, r as PostgresNamespaceSchemaNode } from "./postgres-role-schema-node-BiSTCTNg.mjs";
-import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-Ca88Tg6W.mjs";
-import { t as buildPostgresPlanDiff } from "./diff-database-schema-BOsDnH64.mjs";
-import { E as RenamePostgresRlsPolicyCall, S as DropPostgresRlsPolicyCall, d as CreatePostgresRlsPolicyCall } from "./op-factory-call-DxNNKUeZ.mjs";
-import { a as resolvePostgresNodeIssueCreationFactoryName, c as issueSchemaName, d as postgresPlannerStrategies, i as resolvePostgresNodeIssueControlPolicySubject, l as issueTableName, n as resolveNamespaceIdForDdlSchema, o as coalesceSubtreeIssues, r as resolvePostgresCallControlPolicySubject, s as issueNode, t as formatPostgresControlPolicySubjectLabel, u as planIssues } from "./control-policy-Co_13Hxa.mjs";
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-NI-oGKcw.mjs";
+import { i as PostgresDatabaseSchemaNode, n as PostgresPolicySchemaNode, r as PostgresNamespaceSchemaNode } from "./postgres-role-schema-node-Cm-j0ZGM.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-CAza65Iy.mjs";
+import { t as buildPostgresPlanDiff } from "./diff-database-schema-D2sjvMw9.mjs";
+import { a as resolvePostgresNodeIssueCreationFactoryName, c as issueSchemaName, d as postgresNodeStorageCoordinate, i as resolvePostgresNodeIssueControlPolicySubject, l as planIssues, n as resolveNamespaceIdForDdlSchema, o as coalesceSubtreeIssues, r as resolvePostgresCallControlPolicySubject, s as issueNode, t as renderPostgresSuppression, u as postgresPlannerStrategies } from "./control-policy-DKp0HKpY.mjs";
+import { O as RenamePostgresRlsPolicyCall, f as CreatePostgresRlsPolicyCall, w as DropPostgresRlsPolicyCall } from "./op-factory-call-C4flTtTG.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-Jat3hg4u.mjs";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
 import { extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure } from "@prisma-next/family-sql/control";
@@ -85,8 +84,7 @@ function verifyPostgresNamespacePresence(input) {
 		if (existing.has(ddlName)) continue;
 		const namespace = new PostgresNamespaceSchemaNode({
 			schemaName: ddlName,
-			tables: {},
-			nativeEnumTypeNames: []
+			tables: {}
 		});
 		issues.push({
 			path: ["database", ddlName],
@@ -159,8 +157,7 @@ var PostgresMigrationPlanner = class {
 			issues: schemaIssues,
 			contract: options.contract,
 			resolveControlPolicySubject: (issue) => resolvePostgresNodeIssueControlPolicySubject(issue, options.contract),
-			resolveCreationFactoryName: resolvePostgresNodeIssueCreationFactoryName,
-			formatSubjectLabel: (factoryName, subject) => formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract)
+			resolveCreationFactoryName: resolvePostgresNodeIssueCreationFactoryName
 		});
 		const result = planIssues({
 			issues: issuePartition.plannable,
@@ -179,8 +176,7 @@ var PostgresMigrationPlanner = class {
 			calls: this.planPostgresSchemaDiff(options, policyDiffIssues),
 			contract: options.contract,
 			resolveControlPolicySubject: (call) => resolvePostgresCallControlPolicySubject(call, options.contract),
-			resolveFactoryName: (call) => call.factoryName,
-			formatSubjectLabel: (factoryName, subject) => formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract)
+			resolveFactoryName: (call) => call.factoryName
 		});
 		const fieldEventPartition = partitionCallsByControlPolicy({
 			calls: blindCast(planFieldEventOperations({
@@ -190,8 +186,7 @@ var PostgresMigrationPlanner = class {
 			})),
 			contract: options.contract,
 			resolveControlPolicySubject: (call) => resolvePostgresCallControlPolicySubject(call, options.contract),
-			resolveFactoryName: (call) => call.factoryName,
-			formatSubjectLabel: (factoryName, subject) => formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract)
+			resolveFactoryName: (call) => call.factoryName
 		});
 		const calls = [
 			...result.value.calls,
@@ -199,10 +194,10 @@ var PostgresMigrationPlanner = class {
 			...fieldEventPartition.kept
 		];
 		const warnings = [
-			...issuePartition.warnings,
-			...schemaDiffPartition.warnings,
-			...fieldEventPartition.warnings
-		];
+			...issuePartition.suppressions,
+			...schemaDiffPartition.suppressions,
+			...fieldEventPartition.suppressions
+		].map((record) => renderPostgresSuppression(record, options.contract));
 		return Object.freeze({
 			kind: "success",
 			plan: new TypeScriptRenderablePostgresMigration(calls, {
@@ -314,56 +309,29 @@ function isPolicyDiffIssue(issue) {
 	return node !== void 0 && PostgresPolicySchemaNode.is(node);
 }
 /**
-* Drops a `not-expected` issue when it is a whole extra TABLE that some
-* contract space owns, asking the ownership oracle per node.
-*
-* The consultation applies ONLY to table-level extras — a live table this
-* space's contract lacks — identified by asking the issue's own node
-* (`nodeKind === table`), never by counting path segments. `declaresEntity`
-* answers over the whole composition (self included), keyed on the schema-IR
-* entity coordinate so a genuine orphan in one namespace is never conflated
-* with a same-named table a sibling space declares in another, or with a
-* same-named non-table entity (an enum, an RLS policy) a sibling declares in
-* the SAME namespace: a positive answer means another space owns THIS table
-* in THIS namespace (a table this space owned would be in its expected tree,
-* never an extra) — leave it. A negative answer means no space owns it — a
-* genuine orphan to drop. `entityKind` is the literal `'table'` here: this
-* function only ever asks about a node already confirmed to be
-* `PostgresSchemaNodeKind.table` (checked just above), and the diff tree's
-* `nodeKind` vocabulary (`'postgres-table'`) is distinct from the storage
-* `entries` vocabulary `elementCoordinates` walks (`'table'`) — the literal
-* is that storage-entries spelling, not the node kind.
-*
-* The issue path carries the *resolved DDL schema* (e.g. `public`), but a
-* contract space's own declared namespace id can be the unbound sentinel
-* (`__unbound__`) that resolves to that schema — the two spellings would
-* never string-match. `resolveNamespaceIdForDdlSchema` recovers the raw
-* namespace id THIS space's own contract would use for that DDL schema, so
-* a table this space's own unbound namespace declares (and any sibling
-* whose own unbound namespace resolves the same way) is compared on the
-* same coordinate the aggregate's `elementCoordinates` walk yields.
-*
-* A DEEPER extra (an extra column/constraint on a table this space DOES own —
-* only the child drifted, so the table is in the expected tree) is this
-* space's own drift and is always kept for dropping; asking the oracle there
-* would wrongly suppress it, because the owned table answers `true`. Shallower
-* issues (namespace/root) are never ownership-scoped here. No oracle ⇒ every
-* extra is kept (single-space plan).
+* Drops a `not-expected` issue when it is a whole extra storage entity (a table
+* or a native enum) that some space in the composition owns. Each such node
+* yields its own storage coordinate (see {@link postgresNodeStorageCoordinate}),
+* so `declaresEntity` answers over the whole composition on one uniform
+* coordinate: a positive answer means a sibling owns this entity here — leave
+* it; a negative answer means a genuine orphan — drop it. A node with no storage
+* coordinate (a namespace, or a deeper column/constraint drift on an owned
+* table) is this space's own and is always kept. No oracle ⇒ keep everything.
 */
 function retainUnownedExtras(issues, ownership, contract) {
 	if (ownership === void 0) return issues;
 	return issues.filter((issue) => {
 		if (issue.reason !== "not-expected") return true;
 		const node = issueNode(issue);
-		if (node === void 0 || node.nodeKind !== PostgresSchemaNodeKind.table) return true;
+		if (node === void 0) return true;
+		const coordinate = postgresNodeStorageCoordinate(node);
+		if (coordinate === void 0) return true;
 		const ddlSchemaName = issueSchemaName(issue);
-		const tableName = issueTableName(issue);
-		if (ddlSchemaName === void 0 || tableName === void 0) return true;
+		if (ddlSchemaName === void 0) return true;
 		const namespaceId = resolveNamespaceIdForDdlSchema(contract, ddlSchemaName);
 		return !ownership.declaresEntity({
 			namespaceId,
-			entityKind: "table",
-			entityName: tableName
+			...coordinate
 		});
 	});
 }
@@ -380,9 +348,9 @@ function retainUnownedExtras(issues, ownership, contract) {
 * Returns the real `PostgresNamespaceSchemaNode` reference rather than a
 * projection: `storageTypePlanCallStrategy` hands this same value to codec
 * `planTypeOperations` hooks as `schema`, and hooks read the Postgres-specific
-* `nativeEnumTypeNames` field off it (via `PostgresNamespaceSchemaNode.is`) to
-* decide whether a native enum type already exists — a projection that only
-* copies `tables` would silently drop that signal. `StrategyContext.schema`'s
+* `nativeEnums` field off it (via `PostgresNamespaceSchemaNode.is`) to decide
+* whether a native enum type already exists — a projection that only copies
+* `tables` would silently drop that signal. `StrategyContext.schema`'s
 * declared type (`SqlSchemaIR`, shared with SQLite's flat shape) doesn't
 * capture this, so the return is `blindCast` the same way `namespaceSchemaNodes`
 * in the family's relational walk already treats a namespace node as a
@@ -419,4 +387,4 @@ function policyNodeToContractPolicy(node) {
 //#endregion
 export { createPostgresMigrationPlanner as t };
 
-//# sourceMappingURL=planner-CNrc1Odu.mjs.map
+//# sourceMappingURL=planner-BtEd5LMr.mjs.map

package/dist/planner-BtEd5LMr.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-BtEd5LMr.mjs","names":["#lowerer"],"sources":["../src/core/migrations/verify-postgres-namespaces.ts","../src/core/migrations/planner.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SchemaDiffIssue } 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 { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\nimport { isPostgresSchema } from '../postgres-schema';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';\nimport type { SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';\n\n/**\n * Resolves the live-database schema name for a given namespace\n * coordinate. Mirrors `resolveDdlSchemaForNamespace` in\n * `planner-strategies.ts` so the verifier's projection and the\n * planner's projection always agree — Postgres-aware namespaces (the\n * production path) dispatch to `ddlSchemaName(storage)`, and bare\n * object payloads (used by some tests) fall back to the coordinate\n * itself.\n */\nfunction resolveDdlSchemaName(storage: SqlStorage, namespaceId: string): string {\n  const namespace = storage.namespaces[namespaceId];\n  if (isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n\n/**\n * Reads the introspected list of schema names from the database-root schema\n * node. `existingSchemas` is database-level, so it lives on the\n * `PostgresDatabaseSchemaNode` root — not on the per-schema namespace nodes.\n *\n * Defaults to the always-present `public` schema when the node is not the\n * database root — a fresh Postgres database always carries `public` (unless an\n * operator dropped it manually), so any verifier path that runs without an\n * enriched introspection still suppresses the redundant `CREATE SCHEMA\n * \"public\"`.\n *\n * Production introspection (`PostgresControlAdapter.introspect`) is the\n * authoritative source: it queries `pg_namespace` and sets `existingSchemas`\n * on the returned root. Tests that want to assert against a richer initial\n * state construct a `PostgresDatabaseSchemaNode` explicitly.\n */\nfunction existingSchemasFromSchema(schema: SqlSchemaIRNode): readonly string[] {\n  if (PostgresDatabaseSchemaNode.is(schema)) {\n    return schema.existingSchemas;\n  }\n  return [DEFAULT_NAMESPACE_ID];\n}\n\n/**\n * Emits a `postgres-namespace` `not-found` diff issue for every\n * contract-declared Postgres namespace whose live container does not yet\n * exist. The planner prepends these (node-typed, synthesized) to the\n * relational diff issues so a multi-schema plan emits `CREATE SCHEMA`\n * before the tables that need it — a planner-only concern (verify already\n * rejects via the `not-found` table issues a missing schema already\n * produces), so this is not part of the shared diff.\n *\n * A namespace's live container is the schema returned by its\n * polymorphic `ddlSchemaName(storage)` method — named schemas resolve\n * to their own id; the unbound singleton returns `UNBOUND_NAMESPACE_ID`\n * and is skipped explicitly (late-bound namespaces have no fixed DDL\n * schema). Issues are emitted only when the resolved name is a real,\n * creatable schema (not the unbound sentinel) and is missing from the\n * introspected list. `public` is suppressed implicitly because the\n * introspection (or its sensible default) always carries it.\n *\n * Each emitted issue's path is `['database', ddlName]` — an ancestor of\n * every table path under that schema, so it must never be run through\n * `coalesceSubtreeIssues` alongside the table diff (it would swallow the\n * table-level `not-found` issues that drive `CREATE TABLE`); the planner\n * adds these AFTER coalescing the relational issues, and they are not\n * subject to sibling-space ownership scoping (mirrors the retired\n * coordinate walk, which prepended namespace issues after that filter).\n */\nexport function verifyPostgresNamespacePresence(input: {\n  readonly contract: Contract<SqlStorage>;\n  readonly schema: SqlSchemaIRNode;\n}): readonly SchemaDiffIssue<SqlSchemaDiffNode>[] {\n  const { contract, schema } = input;\n  const existing = new Set(existingSchemasFromSchema(schema));\n  const issues: SchemaDiffIssue<SqlSchemaDiffNode>[] = [];\n  const namespaceIds = Object.keys(contract.storage.namespaces).sort();\n  for (const namespaceId of namespaceIds) {\n    if (namespaceId === UNBOUND_NAMESPACE_ID) continue;\n    const ddlName = resolveDdlSchemaName(contract.storage, namespaceId);\n    if (ddlName === UNBOUND_NAMESPACE_ID) continue;\n    if (existing.has(ddlName)) continue;\n    const namespace = new PostgresNamespaceSchemaNode({\n      schemaName: ddlName,\n      tables: {},\n    });\n    issues.push({\n      path: ['database', ddlName],\n      reason: 'not-found',\n      expected: namespace,\n    });\n  }\n  return issues;\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationPolicy,\n  SqlMigrationPlannerPlanOptions,\n  SqlPlannerConflict,\n  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport {\n  extractCodecControlHooks,\n  partitionCallsByControlPolicy,\n  partitionIssuesByControlPolicy,\n  planFieldEventOperations,\n  plannerFailure,\n} from '@prisma-next/family-sql/control';\nimport type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanner,\n  MigrationPlanWithAuthoringSurface,\n  MigrationScaffoldContext,\n  SchemaDiffIssue,\n  SchemaOwnership,\n} 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 { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { PostgresRlsPolicy } from '../postgres-rls-policy';\nimport { parseRlsPolicyWireName } from '../rls/wire-name';\nimport { postgresNodeStorageCoordinate } from '../schema-ir/node-storage-coordinate';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';\nimport type { SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';\nimport {\n  renderPostgresSuppression,\n  resolveNamespaceIdForDdlSchema,\n  resolvePostgresCallControlPolicySubject,\n  resolvePostgresNodeIssueControlPolicySubject,\n  resolvePostgresNodeIssueCreationFactoryName,\n} from './control-policy';\nimport { buildPostgresPlanDiff } from './diff-database-schema';\nimport { coalesceSubtreeIssues, issueNode, issueSchemaName, planIssues } from './issue-planner';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport {\n  CreatePostgresRlsPolicyCall,\n  DropPostgresRlsPolicyCall,\n  RenamePostgresRlsPolicyCall,\n} from './op-factory-call';\nimport { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';\nimport { postgresPlannerStrategies } from './planner-strategies';\nimport { resolveDdlSchemaForNamespaceStorage } from './resolve-ddl-schema';\nimport { verifyPostgresNamespacePresence } from './verify-postgres-namespaces';\n\ntype PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {\n  readonly frameworkComponents: infer T;\n}\n  ? T\n  : ReadonlyArray<unknown>;\n\ntype PlannerOptionsWithComponents = SqlMigrationPlannerPlanOptions & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\nexport function createPostgresMigrationPlanner(\n  lowerer: ExecuteRequestLowerer,\n): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner(lowerer);\n}\n\n/**\n * Result of `PostgresMigrationPlanner.plan()`. A discriminated union whose\n * success variant carries a `TypeScriptRenderablePostgresMigration` — a\n * migration object that both the CLI (via `renderTypeScript()`) and the\n * SQL-typed callers (via `operations`, `describe()`, etc.) consume\n * uniformly.\n */\nexport type PostgresPlanResult =\n  | {\n      readonly kind: 'success';\n      readonly plan: TypeScriptRenderablePostgresMigration;\n      readonly warnings?: readonly SqlPlannerConflict[];\n    }\n  | SqlPlannerFailureResult;\n\n/**\n * Postgres migration planner — a thin wrapper over `planIssues`.\n *\n * `plan()` diffs the target contract against the live schema via the one\n * differ (`buildPostgresPlanDiff`, producing node-typed `SchemaDiffIssue[]`)\n * and delegates to `planIssues` with the unified `postgresPlannerStrategies`\n * list: NOT-NULL backfill, type-change, nullable-tightening, codec-hook\n * storage types, component-declared dependency installs, and\n * shared-temp-default / empty-table-guarded NOT-NULL add-column. The same\n * strategy list runs for `migration plan`, `db update`, and `db init`;\n * behavior diverges purely on `policy.allowedOperationClasses` (the\n * data-safe strategies short-circuit when `'data'` is excluded). The issue\n * planner applies operation-class policy gates and emits a single\n * `PostgresOpFactoryCall[]` that drives both the runtime-ops view (via\n * `renderOps`) and the `renderTypeScript()` authoring surface. RLS policy\n * drift (the structural half of the same one-differ tree) is handled\n * separately via `planPostgresSchemaDiff`.\n */\nexport class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {\n  readonly #lowerer: ExecuteRequestLowerer | undefined;\n\n  constructor(lowerer?: ExecuteRequestLowerer) {\n    this.#lowerer = lowerer;\n  }\n\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts\n     * at), or `null` for reconciliation flows. Only `migration plan` ever\n     * supplies a non-null value; `db update` / `db init` reconcile against\n     * the live schema and pass `null`. When present alongside the\n     * `'data'` operation class, strategies that need from/to column-shape\n     * comparisons (unsafe type change, nullability tightening) activate.\n     *\n     * Typed as the framework `Contract | null` to satisfy the\n     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL\n     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate\n     * `describe().from` on the produced plan as\n     * `fromContract?.storage.storageHash ?? null`.\n     */\n    readonly fromContract: Contract | null;\n    readonly schemaName?: string;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n    /**\n     * Contract space this plan applies to. Stamped onto the produced\n     * {@link TypeScriptRenderablePostgresMigration.spaceId} so the runner keys\n     * the marker row by the right space.\n     */\n    readonly spaceId: string;\n    /**\n     * Ownership oracle over the contract-space composition — see\n     * {@link SqlMigrationPlannerPlanOptions.ownership}.\n     */\n    readonly ownership?: SchemaOwnership;\n  }): PostgresPlanResult {\n    return this.planSql(options as SqlMigrationPlannerPlanOptions);\n  }\n\n  emptyMigration(\n    context: MigrationScaffoldContext,\n    spaceId: string,\n  ): MigrationPlanWithAuthoringSurface {\n    return new TypeScriptRenderablePostgresMigration(\n      [],\n      {\n        from: context.fromHash,\n        to: context.toHash,\n      },\n      spaceId,\n      this.#lowerer,\n    );\n  }\n\n  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {\n    const schemaName =\n      options.schemaName ??\n      Object.keys(options.contract.storage.namespaces).find((id) => id !== UNBOUND_NAMESPACE_ID) ??\n      UNBOUND_NAMESPACE_ID;\n    const policyResult = this.ensureAdditivePolicy(options.policy);\n    if (policyResult) {\n      return policyResult;\n    }\n\n    // The one combined tree diff drives the whole plan: relational findings\n    // become structural DDL via `planIssues`, policy findings become RLS ops\n    // via `planPostgresSchemaDiff`. Verify runs its own full-tree node diff\n    // (`diffSchema`) over the same schema and rejects on a\n    // surviving failure.\n    PostgresDatabaseSchemaNode.assert(options.schema);\n    const { issues: rawIssues } = buildPostgresPlanDiff({\n      contract: options.contract,\n      actualSchema: options.schema,\n      frameworkComponents: options.frameworkComponents,\n    });\n    const policyDiffIssues = rawIssues.filter((issue) => isPolicyDiffIssue(issue));\n    // Role diff issues resolve to the `external` control policy (see\n    // `resolvePostgresNodeIssueControlPolicySubject`'s role branch), so the\n    // control-policy partition below suppresses them to zero ops on its own,\n    // before `mapNodeIssueToCall` ever sees them — no separate exclusion\n    // needed here.\n    const relationalDiffIssues = rawIssues.filter((issue) => !isPolicyDiffIssue(issue));\n\n    // The generic differ is total and un-gated: strict-mode extras filtering\n    // (dropping `not-expected` findings outside strict mode, mirroring the\n    // retired coordinate walk's `if (strict) { ...extra_* } }` guards),\n    // subtree coalescing (a missing/extra table also emits an issue for\n    // every child under it — redundant once the table-level Create/Drop call\n    // already accounts for the whole subtree), and ownership are all post-diff\n    // planner steps.\n    //\n    // Ownership: a live extra is only this plan's to drop when no contract\n    // space owns it. The differ ran against THIS space's contract, so a table\n    // a sibling space owns surfaces here as `not-expected`; the planner asks\n    // the ownership oracle (the passive aggregate) whether any space declares\n    // it and, if so, leaves it alone — it is a sibling's table, not an orphan.\n    // A table no space owns stays a genuine extra to drop under a destructive\n    // policy. Ownership lives in the aggregate; the planner only asks. Absent\n    // oracle (single-space, none handed) keeps every extra. Coalescing MUST\n    // run before this so a sibling-owned table's child issues have already\n    // collapsed into the one table-level issue that carries the table name.\n    const strict =\n      options.policy.allowedOperationClasses.includes('widening') ||\n      options.policy.allowedOperationClasses.includes('destructive');\n    const coalesced = coalesceSubtreeIssues(relationalDiffIssues);\n    const owned = retainUnownedExtras(coalesced, options.ownership, options.contract);\n    const gated = strict ? owned : owned.filter((issue) => issue.reason !== 'not-expected');\n\n    // Namespace presence (`CREATE SCHEMA`) is a planner-only op-generation\n    // concern stitched in here rather than inside the shared diff — verify\n    // never needs it (a missing schema already surfaces as a `not-found`\n    // table in the relational findings). These synthesized issues are added\n    // AFTER coalescing/scoping (never coalesced against the table diff —\n    // their path is an ancestor of every table path under that schema, so\n    // running them through the same coalesce would swallow the table-level\n    // `not-found` issues that drive `CREATE TABLE`) and are NOT subject to\n    // sibling-space scoping, matching the retired coordinate walk exactly.\n    const namespaceIssues = verifyPostgresNamespacePresence({\n      contract: options.contract,\n      schema: options.schema,\n    });\n    const schemaIssues = [...namespaceIssues, ...gated];\n\n    const codecHooks = extractCodecControlHooks(options.frameworkComponents);\n    const storageTypes = options.contract.storage.types ?? {};\n    // The strategy layer reads the live schema by bare table name for existence\n    // checks (shared-temp-default safety, FK/unique probes), so it takes one\n    // per-schema namespace node — never the whole tree root, and never a flat\n    // merge of every namespace (which would collide same-named tables across\n    // schemas). Probing more than one namespace at once is future work.\n    const relationalSchema = relationalNamespaceNode(options.schema, schemaName);\n\n    // Input-side control-policy partition. `external` / `observed` subjects\n    // — and non-creation issues for `tolerated` subjects — are dropped from\n    // the planner's input entirely; the planner never observes them, never\n    // diffs them, never generates DDL for them. Suppression warnings are\n    // built directly from the suppressed partition (one per subject), so the\n    // user-visible message survives even when the planner would have failed\n    // to model the subject's live shape.\n    const issuePartition = partitionIssuesByControlPolicy({\n      issues: schemaIssues,\n      contract: options.contract,\n      resolveControlPolicySubject: (issue) =>\n        resolvePostgresNodeIssueControlPolicySubject(issue, options.contract),\n      resolveCreationFactoryName: resolvePostgresNodeIssueCreationFactoryName,\n    });\n\n    const result = planIssues({\n      issues: issuePartition.plannable,\n      toContract: options.contract,\n      // `fromContract` is only supplied by `migration plan`. It is `null` for\n      // `db update` / `db init`, which means data-safety strategies needing\n      // from/to comparisons (unsafe type change, nullable tightening) are\n      // inapplicable there — reconciliation falls through to\n      // `mapNodeIssueToCall`'s direct destructive handlers.\n      fromContract: options.fromContract,\n      schemaName,\n      codecHooks,\n      storageTypes,\n      ...ifDefined('schema', relationalSchema),\n      policy: options.policy,\n      frameworkComponents: options.frameworkComponents,\n      strategies: postgresPlannerStrategies,\n    });\n\n    if (!result.ok) {\n      return plannerFailure(result.failure);\n    }\n\n    const schemaDiffCalls = this.planPostgresSchemaDiff(options, policyDiffIssues);\n    const schemaDiffPartition = partitionCallsByControlPolicy({\n      calls: schemaDiffCalls,\n      contract: options.contract,\n      resolveControlPolicySubject: (call) =>\n        resolvePostgresCallControlPolicySubject(call, options.contract),\n      resolveFactoryName: (call) => call.factoryName,\n    });\n\n    // Inline `onFieldEvent`-emitted ops after structural DDL. The fixed\n    // ordering is `structural → added → dropped → altered`, with\n    // within-group sorting by `(tableName, fieldName)` so re-emits are\n    // byte-stable. The hook fires only at the application emitter —\n    // extension-space planning never reaches this helper.\n    const fieldEventOps = planFieldEventOperations({\n      priorContract: options.fromContract,\n      newContract: options.contract,\n      codecHooks,\n    });\n    // Codec hook ops are target-agnostic `OpFactoryCall`; Postgres planning\n    // lifts them at this integration boundary (see field-event-planner JSDoc).\n    const fieldEventPostgresCalls = blindCast<\n      readonly PostgresOpFactoryCall[],\n      'Codec hook ops conform to PostgresOpFactoryCall at the app emitter boundary'\n    >(fieldEventOps);\n    const fieldEventPartition = partitionCallsByControlPolicy({\n      calls: fieldEventPostgresCalls,\n      contract: options.contract,\n      resolveControlPolicySubject: (call) =>\n        resolvePostgresCallControlPolicySubject(call, options.contract),\n      resolveFactoryName: (call) => call.factoryName,\n    });\n    const calls = [...result.value.calls, ...schemaDiffPartition.kept, ...fieldEventPartition.kept];\n    const warnings: SqlPlannerConflict[] = [\n      ...issuePartition.suppressions,\n      ...schemaDiffPartition.suppressions,\n      ...fieldEventPartition.suppressions,\n    ].map((record) => renderPostgresSuppression(record, options.contract));\n\n    return Object.freeze({\n      kind: 'success' as const,\n      plan: new TypeScriptRenderablePostgresMigration(\n        calls,\n        {\n          from: options.fromContract?.storage.storageHash ?? null,\n          to: options.contract.storage.storageHash,\n        },\n        options.spaceId,\n        this.#lowerer,\n      ),\n      ...(warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}),\n    });\n  }\n\n  /**\n   * Maps the RLS policy presence findings of the one combined tree diff\n   * (`buildPostgresPlanDiff`, already ownership-filtered) into\n   * `CREATE POLICY` / `DROP POLICY` / `ALTER POLICY … RENAME TO` ops. It\n   * does not re-diff — it consumes exactly the policy-node subset of the\n   * shared diff's issues. Enablement is NOT decided here: `ENABLE`/`DISABLE\n   * ROW LEVEL SECURITY` derive from the table's marker-driven `rlsEnabled`\n   * attribute diff on the relational side.\n   *\n   * Rename post-pass: a `not-found` and a `not-expected` policy on the SAME\n   * table whose wire-name content hashes match but prefixes differ are one\n   * prefix-only rename, collapsed into a single non-destructive\n   * `RenamePostgresRlsPolicyCall`. Multi-candidate hash groups pair\n   * deterministically by sorted wire name; leftovers proceed as\n   * create/drop. Unparseable wire names never pair.\n   *\n   * The pairing runs only when the policy allows `widening` (rename's\n   * class). Without it (db-init's additive-only set), pairing degrades\n   * deliberately to the additive half: the new name is CREATEd and the old\n   * policy survives live until a widening/destructive-allowed plan runs —\n   * emitting an ungated widening rename would only fail at the runner's\n   * class re-enforcement.\n   */\n  private planPostgresSchemaDiff(\n    options: PlannerOptionsWithComponents,\n    filteredDiffIssues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n  ): readonly PostgresOpFactoryCall[] {\n    const allowsDestructive = options.policy.allowedOperationClasses.includes('destructive');\n    const allowsWidening = options.policy.allowedOperationClasses.includes('widening');\n\n    interface PolicyFinding {\n      readonly node: PostgresPolicySchemaNode;\n      readonly schemaForTable: string;\n    }\n    const missing: PolicyFinding[] = [];\n    const extra: PolicyFinding[] = [];\n\n    for (const issue of filteredDiffIssues) {\n      // 'not-equal' is unreachable for content-addressed policies: the wire name\n      // encodes the body hash, so two policies sharing a local key (same name)\n      // are always equal and isEqualTo never returns false.\n      if (issue.reason === 'not-found') {\n        const expected = issue.expected;\n        PostgresPolicySchemaNode.assert(expected);\n        // expected.namespaceId is the DDL schema name (resolved during projection);\n        // this re-resolution is a no-op as long as PostgresSchema.ddlSchemaName() returns this.id.\n        missing.push({\n          node: expected,\n          schemaForTable: resolveDdlSchemaForNamespaceStorage(\n            options.contract.storage,\n            expected.namespaceId,\n          ),\n        });\n      } else if (issue.reason === 'not-expected') {\n        const actual = issue.actual;\n        PostgresPolicySchemaNode.assert(actual);\n        extra.push({\n          node: actual,\n          schemaForTable: resolveDdlSchemaForNamespaceStorage(\n            options.contract.storage,\n            actual.namespaceId,\n          ),\n        });\n      }\n    }\n\n    const calls: PostgresOpFactoryCall[] = [];\n    const renamedExtras = new Set<PolicyFinding>();\n    const renamedMissing = new Set<PolicyFinding>();\n    const pairingKey = (finding: PolicyFinding, hash: string): string =>\n      JSON.stringify([finding.schemaForTable, finding.node.tableName, hash]);\n\n    if (allowsWidening) {\n      const extrasByGroup = new Map<string, PolicyFinding[]>();\n      for (const finding of extra) {\n        const parsed = parseRlsPolicyWireName(finding.node.name);\n        if (parsed === undefined) continue;\n        const key = pairingKey(finding, parsed.hash);\n        const group = extrasByGroup.get(key) ?? [];\n        group.push(finding);\n        extrasByGroup.set(key, group);\n      }\n      for (const group of extrasByGroup.values()) {\n        group.sort((a, b) => (a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0));\n      }\n\n      const sortedMissing = [...missing].sort((a, b) =>\n        a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0,\n      );\n      for (const missingFinding of sortedMissing) {\n        const parsed = parseRlsPolicyWireName(missingFinding.node.name);\n        if (parsed === undefined) continue;\n        const candidates = extrasByGroup.get(pairingKey(missingFinding, parsed.hash));\n        const candidate = candidates?.shift();\n        if (candidate === undefined) continue;\n        // Same name would never surface as missing+extra (the differ pairs by\n        // name), so a matched candidate always differs in prefix only.\n        renamedExtras.add(candidate);\n        renamedMissing.add(missingFinding);\n        calls.push(\n          new RenamePostgresRlsPolicyCall(\n            missingFinding.schemaForTable,\n            missingFinding.node.tableName,\n            candidate.node.name,\n            missingFinding.node.name,\n          ),\n        );\n      }\n    }\n\n    for (const finding of missing) {\n      if (renamedMissing.has(finding)) continue;\n      calls.push(\n        new CreatePostgresRlsPolicyCall(\n          finding.schemaForTable,\n          finding.node.tableName,\n          policyNodeToContractPolicy(finding.node),\n        ),\n      );\n    }\n    if (allowsDestructive) {\n      for (const finding of extra) {\n        if (renamedExtras.has(finding)) continue;\n        calls.push(\n          new DropPostgresRlsPolicyCall(\n            finding.schemaForTable,\n            finding.node.tableName,\n            finding.node.name,\n          ),\n        );\n      }\n    }\n\n    return calls;\n  }\n\n  private ensureAdditivePolicy(policy: MigrationOperationPolicy) {\n    if (!policy.allowedOperationClasses.includes('additive')) {\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: 'Migration planner requires additive operations be allowed',\n          why: 'The planner requires the \"additive\" operation class to be allowed in the policy.',\n        },\n      ]);\n    }\n    return null;\n  }\n}\n\n/**\n * A diff issue whose node is an RLS policy — the structural half of the one\n * combined tree diff, routed to `planPostgresSchemaDiff` instead of\n * `planIssues`.\n */\nfunction isPolicyDiffIssue(issue: SchemaDiffIssue<SqlSchemaDiffNode>): boolean {\n  const node = issue.expected ?? issue.actual;\n  return node !== undefined && PostgresPolicySchemaNode.is(node);\n}\n\n/**\n * Drops a `not-expected` issue when it is a whole extra storage entity (a table\n * or a native enum) that some space in the composition owns. Each such node\n * yields its own storage coordinate (see {@link postgresNodeStorageCoordinate}),\n * so `declaresEntity` answers over the whole composition on one uniform\n * coordinate: a positive answer means a sibling owns this entity here — leave\n * it; a negative answer means a genuine orphan — drop it. A node with no storage\n * coordinate (a namespace, or a deeper column/constraint drift on an owned\n * table) is this space's own and is always kept. No oracle ⇒ keep everything.\n */\nfunction retainUnownedExtras(\n  issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n  ownership: SchemaOwnership | undefined,\n  contract: Contract<SqlStorage>,\n): readonly SchemaDiffIssue<SqlSchemaDiffNode>[] {\n  if (ownership === undefined) return issues;\n  return issues.filter((issue) => {\n    if (issue.reason !== 'not-expected') return true;\n    const node = issueNode(issue);\n    if (node === undefined) return true;\n    const coordinate = postgresNodeStorageCoordinate(node);\n    if (coordinate === undefined) return true;\n    const ddlSchemaName = issueSchemaName(issue);\n    if (ddlSchemaName === undefined) return true;\n    const namespaceId = resolveNamespaceIdForDdlSchema(contract, ddlSchemaName);\n    return !ownership.declaresEntity({ namespaceId, ...coordinate });\n  });\n}\n\n/**\n * Returns the one namespace node the relational strategy layer probes for\n * live-table existence and reads codec-hook context off — the namespace\n * matching the planner's resolved schema name, or the first namespace when\n * none matches. `undefined` when the tree has no namespaces, so the strategy\n * context uses its empty-schema default.\n *\n * The relational strategies key tables by bare name, so they can only probe one\n * namespace at a time; probing across every namespace at once is future work.\n *\n * Returns the real `PostgresNamespaceSchemaNode` reference rather than a\n * projection: `storageTypePlanCallStrategy` hands this same value to codec\n * `planTypeOperations` hooks as `schema`, and hooks read the Postgres-specific\n * `nativeEnums` field off it (via `PostgresNamespaceSchemaNode.is`) to decide\n * whether a native enum type already exists — a projection that only copies\n * `tables` would silently drop that signal. `StrategyContext.schema`'s\n * declared type (`SqlSchemaIR`, shared with SQLite's flat shape) doesn't\n * capture this, so the return is `blindCast` the same way `namespaceSchemaNodes`\n * in the family's relational walk already treats a namespace node as a\n * structurally-`SqlSchemaIR`-shaped value.\n */\nfunction relationalNamespaceNode(\n  schema: PostgresDatabaseSchemaNode,\n  schemaName: string,\n): SqlSchemaIR | undefined {\n  const namespaceNodes = Object.values(schema.namespaces);\n  const namespaceNode =\n    namespaceNodes.find((node) => node.schemaName === schemaName) ?? namespaceNodes[0];\n  if (namespaceNode === undefined) return undefined;\n  return blindCast<\n    SqlSchemaIR,\n    'PostgresNamespaceSchemaNode carries tables (+ nativeEnums, read by codec hooks via PostgresNamespaceSchemaNode.is) structurally compatible with the SqlSchemaIR shape the strategy layer declares'\n  >(namespaceNode);\n}\n\n/**\n * Rebuilds the `PostgresRlsPolicy` contract entity `CreatePostgresRlsPolicyCall`\n * carries (its `renderTypeScript`/`createRlsPolicy` paths serialize the whole\n * entity, `namespaceId` included). This reconstructs rather than looking the\n * original up in the contract on purpose: the diff node's `namespaceId` is the\n * *resolved DDL schema* (set when the expected tree was built), which is the\n * value the emitted op must carry; the contract-stored entity holds the raw,\n * pre-resolution coordinate, so a lookup would change the migration output.\n */\nfunction policyNodeToContractPolicy(node: PostgresPolicySchemaNode): PostgresRlsPolicy {\n  return new PostgresRlsPolicy({\n    name: node.name,\n    prefix: node.prefix,\n    tableName: node.tableName,\n    namespaceId: node.namespaceId,\n    operation: node.operation,\n    roles: [...node.roles],\n    ...ifDefined('using', node.using),\n    ...ifDefined('withCheck', node.withCheck),\n    permissive: node.permissive,\n  });\n}\n"],"mappings":"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"}

package/dist/{planner-ddl-builders-B8Nn6nHN.mjs → planner-ddl-builders-BKlmGDJl.mjs}

@@ -1,4 +1,4 @@
-import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-DcfMz4MQ.mjs";
+import { a as quoteQualifiedName, i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-SU4FDvIV.mjs";
 import { t as resolveColumnTypeMetadata } from "./planner-type-resolution-Bt2f_q-F.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 //#region src/core/migrations/planner-ddl-builders.ts
@@ -36,10 +36,14 @@ function buildColumnTypeSql(column, codecHooks, storageTypes = {}, allowPseudoTy
 			if (resolved.nativeType === "int2" || resolved.nativeType === "smallint") return "SMALLSERIAL";
 		}
 	}
+	if (typeof resolved.typeParams?.["typeName"] === "string") {
+		const quoted = quoteQualifiedName(resolved.nativeType);
+		return column.many ? `${quoted}[]` : quoted;
+	}
 	const expanded = expandParameterizedTypeSql(resolved, codecHooks);
 	if (expanded !== null) return column.many ? `${expanded}[]` : expanded;
 	if (column.typeRef) {
-		const base = quoteIdentifier(resolved.nativeType);
+		const base = quoteQualifiedName(resolved.nativeType);
 		return column.many ? `${base}[]` : base;
 	}
 	assertSafeNativeType(resolved.nativeType);
@@ -90,4 +94,4 @@ function renderArrayLiteralDefault(elements) {
 //#endregion
 export { buildColumnTypeSql as n, renderDefaultLiteral as r, buildColumnDefaultSql as t };
 
-//# sourceMappingURL=planner-ddl-builders-B8Nn6nHN.mjs.map
+//# sourceMappingURL=planner-ddl-builders-BKlmGDJl.mjs.map

package/dist/planner-ddl-builders-BKlmGDJl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-ddl-builders-BKlmGDJl.mjs","names":[],"sources":["../src/core/migrations/planner-ddl-builders.ts"],"sourcesContent":["import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { escapeLiteral, quoteIdentifier, quoteQualifiedName } from '../sql-utils';\nimport type { PostgresColumnDefault } from '../types';\nimport { resolveColumnTypeMetadata } from './planner-type-resolution';\n\n/**\n * Pattern for safe PostgreSQL type names.\n * Allows letters, digits, underscores, spaces (for \"double precision\", \"character varying\"),\n * and trailing [] for array types.\n */\nconst SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*(\\[\\])?$/;\n\nfunction assertSafeNativeType(nativeType: string): void {\n  if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) {\n    throw new Error(\n      `Unsafe native type name in contract: \"${nativeType}\". ` +\n        'Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*(\\\\[\\\\])?$/',\n    );\n  }\n}\n\n/**\n * Sanity check against accidental SQL injection from malformed contract files.\n * Rejects semicolons, SQL comment tokens, and dollar-quoting.\n * Not a comprehensive security boundary — the contract is developer-authored.\n */\nfunction assertSafeDefaultExpression(expression: string): void {\n  if (expression.includes(';') || /--|\\/\\*|\\$\\$|\\bSELECT\\b/i.test(expression)) {\n    throw new Error(\n      `Unsafe default expression in contract: \"${expression}\". ` +\n        'Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.',\n    );\n  }\n}\n\n/**\n * Renders the SQL type for a column in DDL context.\n *\n * @param allowPseudoTypes - When true (default), autoincrement integer columns\n *   produce SERIAL/BIGSERIAL/SMALLSERIAL pseudo-types. Set to false for contexts\n *   like ALTER COLUMN TYPE where pseudo-types are invalid.\n */\nexport function buildColumnTypeSql(\n  column: StorageColumn,\n  codecHooks: ReadonlyMap<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance> = {},\n  allowPseudoTypes = true,\n): string {\n  const resolved = resolveColumnTypeMetadata(column, storageTypes);\n\n  if (allowPseudoTypes) {\n    const columnDefault = column.default;\n    if (columnDefault?.kind === 'function' && columnDefault.expression === 'autoincrement()') {\n      if (resolved.nativeType === 'int4' || resolved.nativeType === 'integer') {\n        return 'SERIAL';\n      }\n      if (resolved.nativeType === 'int8' || resolved.nativeType === 'bigint') {\n        return 'BIGSERIAL';\n      }\n      if (resolved.nativeType === 'int2' || resolved.nativeType === 'smallint') {\n        return 'SMALLSERIAL';\n      }\n    }\n  }\n\n  // A column whose codec supplied a `typeParams.typeName` references a named\n  // database type (e.g. a native enum), not a parameterized builtin: render it\n  // as its quoted, schema-qualified type-name identifier. DDL-render only — the\n  // verify comparison value (`resolvedNativeType`) stays the bare name the\n  // family expander produces, matching introspection.\n  if (typeof resolved.typeParams?.['typeName'] === 'string') {\n    const quoted = quoteQualifiedName(resolved.nativeType);\n    return column.many ? `${quoted}[]` : quoted;\n  }\n\n  const expanded = expandParameterizedTypeSql(resolved, codecHooks);\n  if (expanded !== null) {\n    return column.many ? `${expanded}[]` : expanded;\n  }\n\n  if (column.typeRef) {\n    const base = quoteQualifiedName(resolved.nativeType);\n    return column.many ? `${base}[]` : base;\n  }\n\n  assertSafeNativeType(resolved.nativeType);\n  return column.many ? `${resolved.nativeType}[]` : resolved.nativeType;\n}\n\nfunction expandParameterizedTypeSql(\n  column: Pick<StorageColumn, 'nativeType' | 'codecId' | 'typeParams'>,\n  codecHooks: ReadonlyMap<string, CodecControlHooks>,\n): string | null {\n  if (!column.typeParams || Object.keys(column.typeParams).length === 0) {\n    return null;\n  }\n\n  if (!column.codecId) {\n    throw new Error(\n      `Column declares typeParams for nativeType \"${column.nativeType}\" but has no codecId. ` +\n        'Ensure the column is associated with a codec.',\n    );\n  }\n\n  const hooks = codecHooks.get(column.codecId);\n  if (!hooks?.expandNativeType) {\n    if (hooks?.planTypeOperations) {\n      return null;\n    }\n    throw new Error(\n      `Column declares typeParams for nativeType \"${column.nativeType}\" ` +\n        `but no expandNativeType hook is registered for codecId \"${column.codecId}\". ` +\n        'Ensure the extension providing this codec is included in extensionPacks.',\n    );\n  }\n\n  const expanded = hooks.expandNativeType({\n    nativeType: column.nativeType,\n    codecId: column.codecId,\n    ...ifDefined('typeParams', column.typeParams),\n  });\n\n  return expanded !== column.nativeType ? expanded : null;\n}\n\n/** Autoincrement columns use SERIAL types, so this returns empty for them. */\nexport function buildColumnDefaultSql(\n  columnDefault: PostgresColumnDefault | undefined,\n  column?: Pick<StorageColumn, 'many' | 'nativeType'>,\n): string {\n  if (!columnDefault) {\n    return '';\n  }\n\n  switch (columnDefault.kind) {\n    case 'literal':\n      return `DEFAULT ${renderDefaultLiteral(columnDefault.value, column)}`;\n    case 'function': {\n      if (columnDefault.expression === 'autoincrement()') {\n        return '';\n      }\n      assertSafeDefaultExpression(columnDefault.expression);\n      return `DEFAULT (${columnDefault.expression})`;\n    }\n    case 'sequence':\n      return `DEFAULT nextval('${escapeLiteral(quoteIdentifier(columnDefault.name))}'::regclass)`;\n  }\n}\n\nexport function renderDefaultLiteral(\n  value: unknown,\n  column?: Pick<StorageColumn, 'many' | 'nativeType'>,\n): string {\n  const isJsonColumn = column?.nativeType === 'json' || column?.nativeType === 'jsonb';\n\n  if (column?.many && Array.isArray(value)) {\n    return renderArrayLiteralDefault(value);\n  }\n\n  if (value instanceof Date) {\n    return `'${escapeLiteral(value.toISOString())}'`;\n  }\n  if (typeof value === 'string') {\n    return `'${escapeLiteral(value)}'`;\n  }\n  if (typeof value === 'number' || typeof value === 'boolean') {\n    return String(value);\n  }\n  if (value === null) {\n    return 'NULL';\n  }\n  const json = JSON.stringify(value);\n  if (isJsonColumn) {\n    return `'${escapeLiteral(json)}'::${column.nativeType}`;\n  }\n  return `'${escapeLiteral(json)}'`;\n}\n\nfunction renderArrayLiteralDefault(elements: unknown[]): string {\n  if (elements.length === 0) {\n    return \"'{}'\";\n  }\n  const rendered = elements.map((el) => renderDefaultLiteral(el)).join(', ');\n  return `ARRAY[${rendered}]`;\n}\n"],"mappings":"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"}

package/dist/planner-ddl-builders.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner-ddl-builders.d.mts","names":[],"sources":["../src/core/migrations/planner-ddl-builders.ts"],"mappings":";;;;;;;AA4CA;;;;;iBAAgB,kBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,WAAA,SAAoB,iBAAA,GAChC,YAAA,GAAc,MAAA,SAAe,mBAAA,GAC7B,gBAAA;;iBAsEc,qBAAA,CACd,aAAA,EAAe,qBAAA,cACf,MAAA,GAAS,IAAA,CAAK,aAAA;AAAA,iBAqBA,oBAAA,CACd,KAAA,WACA,MAAA,GAAS,IAAI,CAAC,aAAA"}
+{"version":3,"file":"planner-ddl-builders.d.mts","names":[],"sources":["../src/core/migrations/planner-ddl-builders.ts"],"mappings":";;;;;;;AA4CA;;;;;iBAAgB,kBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,WAAA,SAAoB,iBAAA,GAChC,YAAA,GAAc,MAAA,SAAe,mBAAA,GAC7B,gBAAA;;iBAgFc,qBAAA,CACd,aAAA,EAAe,qBAAA,cACf,MAAA,GAAS,IAAA,CAAK,aAAA;AAAA,iBAqBA,oBAAA,CACd,KAAA,WACA,MAAA,GAAS,IAAI,CAAC,aAAA"}

package/dist/planner-ddl-builders.mjs

@@ -1,2 +1,2 @@
-import { n as buildColumnTypeSql, r as renderDefaultLiteral, t as buildColumnDefaultSql } from "./planner-ddl-builders-B8Nn6nHN.mjs";
+import { n as buildColumnTypeSql, r as renderDefaultLiteral, t as buildColumnDefaultSql } from "./planner-ddl-builders-BKlmGDJl.mjs";
 export { buildColumnDefaultSql, buildColumnTypeSql, renderDefaultLiteral };

package/dist/{planner-produced-postgres-migration-a-tjfKsA.d.mts → planner-produced-postgres-migration-CXue-6M9.d.mts}

@@ -1,5 +1,5 @@
 import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrRO.mjs";
-import { t as PostgresMigration } from "./postgres-migration-Bzzi0Asr.mjs";
+import { t as PostgresMigration } from "./postgres-migration-DkmgGNcv.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { MigrationPlanWithAuthoringSurface, OpFactoryCall } from "@prisma-next/framework-components/control";
 import { MigrationMeta } from "@prisma-next/migration-tools/migration";
@@ -21,4 +21,4 @@ declare class TypeScriptRenderablePostgresMigration extends PostgresMigration im
 }
 //#endregion
 export { TypeScriptRenderablePostgresMigration as t };
-//# sourceMappingURL=planner-produced-postgres-migration-a-tjfKsA.d.mts.map
+//# sourceMappingURL=planner-produced-postgres-migration-CXue-6M9.d.mts.map

package/dist/{planner-produced-postgres-migration-a-tjfKsA.d.mts.map → planner-produced-postgres-migration-CXue-6M9.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-produced-postgres-migration-a-tjfKsA.d.mts","names":[],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"mappings":";;;;;;;;cAqCa,qCAAA,SACH,iBAAA,YACG,iCAAA;EAAA;cAcT,KAAA,WAAgB,aAAA,IAChB,IAAA,EAAM,aAAA,EACN,OAAA,UACA,OAAA,GAAU,qBAAA;EAAA,IASC,UAAA,cACT,yBAAA,CAA0B,yBAAA,IAC1B,OAAA,CAAQ,yBAAA,CAA0B,yBAAA;EAM7B,QAAA,IAAY,aAAA;EARR;;;;;EAAA,IAiBT,OAAA;EAIJ,gBAAA;AAAA"}
+{"version":3,"file":"planner-produced-postgres-migration-CXue-6M9.d.mts","names":[],"sources":["../src/core/migrations/planner-produced-postgres-migration.ts"],"mappings":";;;;;;;;cAqCa,qCAAA,SACH,iBAAA,YACG,iCAAA;EAAA;cAcT,KAAA,WAAgB,aAAA,IAChB,IAAA,EAAM,aAAA,EACN,OAAA,UACA,OAAA,GAAU,qBAAA;EAAA,IASC,UAAA,cACT,yBAAA,CAA0B,yBAAA,IAC1B,OAAA,CAAQ,yBAAA,CAA0B,yBAAA;EAM7B,QAAA,IAAY,aAAA;EARR;;;;;EAAA,IAiBT,OAAA;EAIJ,gBAAA;AAAA"}

package/dist/{planner-produced-postgres-migration-NI-oGKcw.mjs → planner-produced-postgres-migration-Jat3hg4u.mjs}

@@ -1,4 +1,4 @@
-import { t as PostgresMigration } from "./postgres-migration-ChyRsWvE.mjs";
+import { t as PostgresMigration } from "./postgres-migration-ChLMQRd-.mjs";
 import { t as renderOps } from "./render-ops-BREh1kHe.mjs";
 import { t as renderCallsToTypeScript } from "./render-typescript-7yqILcwr.mjs";
 //#region src/core/migrations/planner-produced-postgres-migration.ts
@@ -40,4 +40,4 @@ var TypeScriptRenderablePostgresMigration = class extends PostgresMigration {
 //#endregion
 export { TypeScriptRenderablePostgresMigration as t };
 
-//# sourceMappingURL=planner-produced-postgres-migration-NI-oGKcw.mjs.map
+//# sourceMappingURL=planner-produced-postgres-migration-Jat3hg4u.mjs.map