@prisma-next/target-postgres 0.14.0-dev.39 → 0.14.0-dev.40

package/dist/{planner-BQ7lSqbm.mjs → planner-CG2pLHk-.mjs}

@@ -1,65 +1,225 @@
-import { d as isPostgresRlsPolicy, l as PostgresRlsPolicy, r as isPostgresSchema, u as assertPostgresRlsPolicy } from "./postgres-schema-DLcc3W2-.mjs";
-import { a as PostgresTableIR, i as isPostgresSchemaIR, n as assertPostgresSchemaIR, r as ensurePostgresSchemaIR, t as PostgresSchemaIR } from "./postgres-schema-ir-I_FiUndw.mjs";
-import { t as resolveDdlSchemaForNamespaceStorage } from "./postgres-schema-ir-annotations-BbDSiwx2.mjs";
+import { d as PostgresRlsPolicy, r as isPostgresSchema } from "./postgres-schema-BLIHBEfX.mjs";
+import { a as PostgresDatabaseSchemaNode, i as PostgresNamespaceSchemaNode, n as PostgresRoleSchemaNode, r as PostgresPolicySchemaNode, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-1nNc8XDT.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-CL1RR1mx.mjs";
 import { t as parsePostgresDefault } from "./default-normalizer-Dug8Fez9.mjs";
 import { t as normalizeSchemaNativeType } from "./native-type-normalizer-Bc9XJzWC.mjs";
-import { C as EnableRowLevelSecurityCall, d as CreatePostgresRlsPolicyCall, x as DropPostgresRlsPolicyCall } from "./op-factory-call-DArx_1HM.mjs";
-import { n as postgresPlannerStrategies, t as planIssues } from "./issue-planner-C-CwZd8D.mjs";
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-3ppG0t3i.mjs";
+import { C as EnableRowLevelSecurityCall, d as CreatePostgresRlsPolicyCall, x as DropPostgresRlsPolicyCall } from "./op-factory-call-t65c4jyY.mjs";
+import { n as postgresPlannerStrategies, t as planIssues } from "./issue-planner-DbFvaAgu.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-BolD0Mvc.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
-import { contractToSchemaIR, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure } from "@prisma-next/family-sql/control";
+import { contractNamespaceToSchemaIR, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure } from "@prisma-next/family-sql/control";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { UNBOUND_NAMESPACE_ID, entityAt } from "@prisma-next/framework-components/ir";
-import { verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
-import { diffSchemas } from "@prisma-next/framework-components/control";
-//#region src/core/migrations/contract-to-postgres-schema-ir.ts
-function contractToPostgresSchemaIR(contract, options) {
-	const sqlIr = contractToSchemaIR(contract, options);
-	const ownedSchemas = contract === null ? [] : Object.values(contract.storage.namespaces).filter((ns) => isPostgresSchema(ns)).map((ns) => resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id));
-	const policiesByTable = /* @__PURE__ */ new Map();
-	if (contract !== null) for (const ns of Object.values(contract.storage.namespaces)) {
+import { verifySqlSchemaTree } from "@prisma-next/family-sql/diff";
+import { SchemaDiff, diffSchemas } from "@prisma-next/framework-components/control";
+//#region src/core/migrations/contract-to-postgres-database-schema-node.ts
+function toPolicyNode(policy, namespaceId) {
+	return new PostgresPolicySchemaNode({
+		name: policy.name,
+		prefix: policy.prefix,
+		tableName: policy.tableName,
+		namespaceId,
+		operation: policy.operation,
+		roles: [...policy.roles],
+		...ifDefined("using", policy.using),
+		...ifDefined("withCheck", policy.withCheck),
+		permissive: policy.permissive
+	});
+}
+/**
+* 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;
-		const resolvedSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id);
+		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 resolved = resolvedSchema === policy.namespaceId ? policy : new PostgresRlsPolicy({
-				name: policy.name,
-				prefix: policy.prefix,
-				tableName: policy.tableName,
-				namespaceId: resolvedSchema,
-				operation: policy.operation,
-				roles: [...policy.roles],
-				...ifDefined("using", policy.using),
-				...ifDefined("withCheck", policy.withCheck),
-				permissive: policy.permissive
-			});
 			const list = policiesByTable.get(policy.tableName) ?? [];
-			list.push(resolved);
+			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;
+			tables[tableName] = new PostgresTableSchemaNode({
+				name: sqlTable.name,
+				columns: sqlTable.columns,
+				foreignKeys: sqlTable.foreignKeys,
+				uniques: sqlTable.uniques,
+				indexes: sqlTable.indexes,
+				...ifDefined("primaryKey", sqlTable.primaryKey),
+				...ifDefined("annotations", sqlTable.annotations),
+				...ifDefined("checks", sqlTable.checks),
+				policies: policiesByTable.get(tableName) ?? []
+			});
+		}
+		for (const [tableName, tablePolicies] of policiesByTable) if (!(tableName in tables)) {
+			const policyName = tablePolicies[0]?.name ?? "(unknown)";
+			throw new Error(`contract-to-postgres-database-schema-node: policy "${policyName}" references table "${tableName}" not present in namespace "${ddlSchema}"`);
+		}
+		namespaces[ddlSchema] = new PostgresNamespaceSchemaNode({
+			schemaName: ddlSchema,
+			tables,
+			nativeEnumTypeNames: []
+		});
+		for (const role of Object.values(ns.role)) roles.push(new PostgresRoleSchemaNode({
+			name: role.name,
+			namespaceId: role.namespaceId
+		}));
 	}
-	const tables = {};
-	for (const [tableName, sqlTable] of Object.entries(sqlIr.tables)) tables[tableName] = new PostgresTableIR({
-		name: sqlTable.name,
-		columns: sqlTable.columns,
-		foreignKeys: sqlTable.foreignKeys,
-		uniques: sqlTable.uniques,
-		indexes: sqlTable.indexes,
-		...sqlTable.primaryKey !== void 0 ? { primaryKey: sqlTable.primaryKey } : {},
-		...sqlTable.annotations !== void 0 ? { annotations: sqlTable.annotations } : {},
-		...sqlTable.checks !== void 0 ? { checks: sqlTable.checks } : {},
-		rlsPolicies: policiesByTable.get(tableName) ?? []
-	});
-	for (const [tableName, policies] of policiesByTable) if (!(tableName in tables)) {
-		const policyName = policies[0]?.name ?? "(unknown)";
-		throw new Error(`contract-to-postgres-schema-ir: policy "${policyName}" references table "${tableName}" not present in the schema`);
-	}
-	return new PostgresSchemaIR({
-		tables,
-		roles: contract === null ? [] : Object.values(contract.storage.namespaces).flatMap((ns) => isPostgresSchema(ns) ? Object.values(ns.role) : []),
-		pgSchemaName: "public",
-		pgVersion: "",
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles,
 		existingSchemas: ownedSchemas,
-		nativeEnumTypeNames: []
+		pgVersion: ""
+	});
+}
+//#endregion
+//#region src/core/migrations/diff-database-schema.ts
+/**
+* The single combined database-schema comparison — the one computation the
+* migration planner and the family schema verify both consume. Composes,
+* once each:
+*
+* - the per-namespace-paired relational diff (`verifySqlSchemaTree`) → table /
+*   column / constraint findings as framework `SchemaIssue`s (with the
+*   verification-tree `root` and pass/warn/fail counts);
+* - the policy diff (`diffPostgresSchema` over the two trees) → RLS policy
+*   presence as `SchemaDiffIssue`s, ownership-filtered to the contract's owned
+*   schemas.
+*
+* `diffPostgresDatabaseSchema` and `verifyPostgresDatabaseSchema` both read
+* this single result, so the relational walk runs once per caller — never
+* once for the diff and again for the verify tree.
+*/
+function computePostgresSchemaComparison(input) {
+	const postgresContract = blindCast(input.contract);
+	const relational = verifySqlSchemaTree({
+		contract: input.contract,
+		actualSchema: input.actualSchema,
+		buildExpectedSchema: (scopedContract) => contractToPostgresDatabaseSchemaNode(blindCast(scopedContract), { annotationNamespace: "pg" }),
+		strict: input.strict,
+		typeMetadataRegistry: input.typeMetadataRegistry,
+		frameworkComponents: input.frameworkComponents,
+		normalizeDefault: parsePostgresDefault,
+		normalizeNativeType: normalizeSchemaNativeType
+	});
+	PostgresDatabaseSchemaNode.assert(input.actualSchema);
+	const expected = contractToPostgresDatabaseSchemaNode(postgresContract, { annotationNamespace: "pg" });
+	return {
+		relational,
+		schemaDiffIssues: filterIssuesByOwnership(diffPostgresSchema(expected, input.actualSchema), ownedSchemaNames(expected))
+	};
+}
+/**
+* The `SchemaDiffer` for Postgres: the target's black-box comparison,
+* projected to the two issue lists. Namespace presence (`missing_schema` →
+* `CREATE SCHEMA`) is intentionally NOT composed here: it is a planner-only
+* op-generation concern (verify rejects on the relational `missing_table` a
+* missing schema already produces), so the planner stitches it in around this
+* diff. Control-policy suppression of the policy issues is likewise a
+* per-consumer post-step (verify filters the issues; the planner filters the
+* calls).
+*/
+function diffPostgresDatabaseSchema(input) {
+	const { relational, schemaDiffIssues } = computePostgresSchemaComparison(input);
+	return new SchemaDiff(relational.schema.issues, schemaDiffIssues);
+}
+/**
+* The same combined comparison as {@link diffPostgresDatabaseSchema}, wrapped
+* in the verify envelope (`ok`/`summary`/`code`/`target`/`timings`) plus the
+* pass/warn/fail tree the CLI renders — i.e. exactly the existing verify-result
+* schema shape, so nothing downstream changes.
+*/
+function verifyPostgresDatabaseSchema(input) {
+	const { relational, schemaDiffIssues } = computePostgresSchemaComparison(input);
+	return {
+		...relational,
+		schema: {
+			...relational.schema,
+			schemaDiffIssues
+		}
+	};
+}
+function ownedSchemaNames(expected) {
+	const policyNamespaces = Object.values(expected.namespaces).flatMap((ns) => Object.values(ns.tables).flatMap((t) => t.policies.map((p) => p.namespaceId)));
+	return new Set([...policyNamespaces, ...expected.existingSchemas]);
+}
+function renderPostgresPolicyReference(policy) {
+	return `policy "${policy.name}" on "${policy.namespaceId}"."${policy.tableName}"`;
+}
+/**
+* The policy node-diff — the structural half of the combined comparison above.
+* Computes RLS-policy drift between two derived schema trees:
+*
+* 1. Runs the framework total diff over the two `PostgresDatabaseSchemaNode`
+*    roots (database → namespace → table → policy).
+* 2. Filters to policy-subject issues only — this is transitional: the generic
+*    differ walks the whole tree, but the legacy relational verifier still owns
+*    table/column drift, so non-policy issues are dropped here.
+* 3. Remaps the message to a human-readable policy reference.
+*
+* Both trees are `PostgresDatabaseSchemaNode`s, so every issue node is a
+* `SqlSchemaDiffNode` — narrow the framework's `SchemaDiffIssue<DiffableNode>`
+* output once here (the single boundary cast), so every downstream consumer
+* (the ownership filter, the planner) reads the concrete node with no cast.
+*
+* Ownership filtering (dropping `extra` issues in namespaces a contract doesn't
+* own) is the caller's responsibility — use `filterIssuesByOwnership`.
+*/
+function diffPostgresSchema(expected, actual) {
+	return blindCast(diffSchemas(expected, actual)).filter((i) => {
+		const node = i.expected ?? i.actual;
+		return node !== void 0 && PostgresPolicySchemaNode.is(node);
+	}).map((i) => {
+		const node = i.expected ?? i.actual;
+		if (node === void 0 || !PostgresPolicySchemaNode.is(node)) return i;
+		return {
+			...i,
+			message: `${i.outcome}: ${renderPostgresPolicyReference(node)}`
+		};
+	});
+}
+/**
+* Filters `extra` policy issues to those in owned namespaces. Call after
+* `diffPostgresSchema` with the union of namespace ids from the expected tree's
+* policies and its `existingSchemas`.
+*/
+function filterIssuesByOwnership(issues, ownedSchemaNameSet) {
+	return issues.filter((i) => {
+		if (i.outcome !== "extra") return true;
+		if (i.actual === void 0) return false;
+		return PostgresPolicySchemaNode.is(i.actual) && ownedSchemaNameSet.has(i.actual.namespaceId);
 	});
 }
 //#endregion
@@ -197,41 +357,6 @@ function resolvePostgresIssueControlPolicySubject(issue, contract) {
 	}
 }
 //#endregion
-//#region src/core/migrations/diff-postgres-schema.ts
-function renderPostgresPolicyReference(policy) {
-	return `policy "${policy.name}" on "${policy.namespaceId}"."${policy.tableName}"`;
-}
-/**
-* Computes schema drift between two derived schema IRs.
-*
-* 1. Runs the framework total diff.
-* 2. Filters to policy-subject issues only — this is transitional: the generic
-*    differ walks the whole tree, but the legacy relational verifier still owns
-*    table/column drift, so non-policy issues are dropped here.
-* 3. Remaps the message to a human-readable policy reference.
-*
-* Ownership filtering (dropping `extra` issues in namespaces a contract doesn't
-* own) is the caller's responsibility — use `filterIssuesByOwnership`.
-*/
-function diffPostgresSchema(expected, actual) {
-	return diffSchemas(expected, ensurePostgresSchemaIR(actual)).filter((i) => isPostgresRlsPolicy(i.expected ?? i.actual)).map((i) => {
-		const policy = i.expected ?? i.actual;
-		if (!isPostgresRlsPolicy(policy)) return i;
-		return {
-			...i,
-			message: `${i.outcome}: ${renderPostgresPolicyReference(policy)}`
-		};
-	});
-}
-/**
-* Filters `extra` policy issues to those in owned namespaces. Call after
-* `diffPostgresSchema` with the union of namespace ids from the expected IR's
-* policies and its `existingSchemas`.
-*/
-function filterIssuesByOwnership(issues, ownedSchemaNames) {
-	return issues.filter((i) => i.outcome !== "extra" || isPostgresRlsPolicy(i.actual) && ownedSchemaNames.has(i.actual.namespaceId));
-}
-//#endregion
 //#region src/core/migrations/verify-postgres-namespaces.ts
 /**
 * Resolves the live-database schema name for a given namespace
@@ -248,25 +373,32 @@ function resolveDdlSchemaName(storage, namespaceId) {
 	return namespaceId;
 }
 /**
-* Reads the introspected list of schema names from a `PostgresSchemaIR`.
-* Defaults to the always-present `public` schema when the schema IR is not a
-* `PostgresSchemaIR` — a fresh Postgres database always carries `public`
-* (unless an operator dropped it manually), so any verifier path that runs
-* without an enriched introspection still suppresses the redundant
-* `CREATE SCHEMA "public"`.
+* Reads the introspected list of schema names from the database-root schema
+* node. `existingSchemas` is database-level, so it lives on the
+* `PostgresDatabaseSchemaNode` root — not on the per-schema namespace nodes.
+*
+* Defaults to the always-present `public` schema when the node is not the
+* database root — a fresh Postgres database always carries `public` (unless an
+* operator dropped it manually), so any verifier path that runs without an
+* enriched introspection still suppresses the redundant `CREATE SCHEMA
+* "public"`.
 *
 * Production introspection (`PostgresControlAdapter.introspect`) is the
 * authoritative source: it queries `pg_namespace` and sets `existingSchemas`
-* on the returned `PostgresSchemaIR`. Tests that want to assert against a
-* richer initial state construct a `PostgresSchemaIR` explicitly.
+* on the returned root. Tests that want to assert against a richer initial
+* state construct a `PostgresDatabaseSchemaNode` explicitly.
 */
 function existingSchemasFromSchema(schema) {
-	if (isPostgresSchemaIR(schema)) return schema.existingSchemas;
+	if (PostgresDatabaseSchemaNode.is(schema)) return schema.existingSchemas;
 	return ["public"];
 }
 /**
 * Emits a `missing_schema` issue for every contract-declared Postgres
-* namespace whose live container does not yet exist.
+* namespace whose live container does not yet exist. The planner's
+* `collectSchemaIssues` prepends these to the relational findings so a
+* multi-schema plan emits `CREATE SCHEMA` before the tables that need it —
+* a planner-only concern (verify already rejects via the `missing_table` a
+* missing schema produces), so this is not part of the shared diff.
 *
 * A namespace's live container is the schema returned by its
 * polymorphic `ddlSchemaName(storage)` method — named schemas resolve
@@ -294,6 +426,7 @@ function verifyPostgresNamespacePresence(input) {
 		if (existing.has(ddlName)) continue;
 		issues.push({
 			kind: "missing_schema",
+			reason: "not-found",
 			namespaceId,
 			message: `Schema "${ddlName}" is missing from database`
 		});
@@ -339,9 +472,19 @@ var PostgresMigrationPlanner = class {
 		const schemaName = options.schemaName ?? Object.keys(options.contract.storage.namespaces).find((id) => id !== UNBOUND_NAMESPACE_ID) ?? UNBOUND_NAMESPACE_ID;
 		const policyResult = this.ensureAdditivePolicy(options.policy);
 		if (policyResult) return policyResult;
-		const schemaIssues = this.collectSchemaIssues(options);
+		PostgresDatabaseSchemaNode.assert(options.schema);
+		const rawDiff = diffPostgresDatabaseSchema({
+			contract: options.contract,
+			actualSchema: options.schema,
+			strict: options.policy.allowedOperationClasses.includes("widening") || options.policy.allowedOperationClasses.includes("destructive"),
+			typeMetadataRegistry: /* @__PURE__ */ new Map(),
+			frameworkComponents: options.frameworkComponents
+		});
+		const databaseDiff = options.keepDiffIssue ? rawDiff.filter(options.keepDiffIssue) : rawDiff;
+		const schemaIssues = this.collectSchemaIssues(options, databaseDiff.issues);
 		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
 		const storageTypes = options.contract.storage.types ?? {};
+		const relationalSchema = relationalNamespaceNode(options.schema, schemaName);
 		const issuePartition = partitionIssuesByControlPolicy({
 			issues: schemaIssues,
 			contract: options.contract,
@@ -356,14 +499,14 @@ var PostgresMigrationPlanner = class {
 			schemaName,
 			codecHooks,
 			storageTypes,
-			schema: options.schema,
+			...ifDefined("schema", relationalSchema),
 			policy: options.policy,
 			frameworkComponents: options.frameworkComponents,
 			strategies: postgresPlannerStrategies
 		});
 		if (!result.ok) return plannerFailure(result.failure);
 		const schemaDiffPartition = partitionCallsByControlPolicy({
-			calls: this.planPostgresSchemaDiff(options),
+			calls: this.planPostgresSchemaDiff(options, databaseDiff.schemaDiffIssues),
 			contract: options.contract,
 			resolveControlPolicySubject: (call) => resolvePostgresCallControlPolicySubject(call, options.contract),
 			resolveFactoryName: (call) => call.factoryName,
@@ -399,26 +542,31 @@ var PostgresMigrationPlanner = class {
 			...warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}
 		});
 	}
-	planPostgresSchemaDiff(options) {
-		assertPostgresSchemaIR(options.schema);
-		const expected = contractToPostgresSchemaIR(blindCast(options.contract), { annotationNamespace: "pg" });
-		const filteredDiffIssues = filterIssuesByOwnership(diffPostgresSchema(expected, ensurePostgresSchemaIR(options.schema)), new Set([...expected.rlsPolicies.map((p) => p.namespaceId), ...expected.existingSchemas]));
+	/**
+	* Maps the RLS policy presence findings of the shared
+	* `diffPostgresDatabaseSchema` (already ownership-filtered) into
+	* `ENABLE RLS` / `CREATE POLICY` / `DROP POLICY` ops. It no longer re-diffs —
+	* it consumes the `schemaDiffIssues` of the one combined diff.
+	*/
+	planPostgresSchemaDiff(options, filteredDiffIssues) {
 		const allowsDestructive = options.policy.allowedOperationClasses.includes("destructive");
 		const calls = [];
 		const seenEnableTables = /* @__PURE__ */ new Set();
 		for (const issue of filteredDiffIssues) if (issue.outcome === "missing") {
-			assertPostgresRlsPolicy(issue.expected);
-			const schemaForTable = resolveDdlSchemaForNamespaceStorage(options.contract.storage, issue.expected.namespaceId, options.schema);
-			const tableKey = `${schemaForTable}.${issue.expected.tableName}`;
+			const expected = issue.expected;
+			PostgresPolicySchemaNode.assert(expected);
+			const schemaForTable = resolveDdlSchemaForNamespaceStorage(options.contract.storage, expected.namespaceId);
+			const tableKey = `${schemaForTable}.${expected.tableName}`;
 			if (!seenEnableTables.has(tableKey)) {
 				seenEnableTables.add(tableKey);
-				calls.push(new EnableRowLevelSecurityCall(schemaForTable, issue.expected.tableName));
+				calls.push(new EnableRowLevelSecurityCall(schemaForTable, expected.tableName));
 			}
-			calls.push(new CreatePostgresRlsPolicyCall(schemaForTable, issue.expected.tableName, issue.expected));
+			calls.push(new CreatePostgresRlsPolicyCall(schemaForTable, expected.tableName, policyNodeToContractPolicy(expected)));
 		} else if (issue.outcome === "extra" && allowsDestructive) {
-			assertPostgresRlsPolicy(issue.actual);
-			const schemaForTable = resolveDdlSchemaForNamespaceStorage(options.contract.storage, issue.actual.namespaceId, options.schema);
-			calls.push(new DropPostgresRlsPolicyCall(schemaForTable, issue.actual.tableName, issue.actual.name));
+			const actual = issue.actual;
+			PostgresPolicySchemaNode.assert(actual);
+			const schemaForTable = resolveDdlSchemaForNamespaceStorage(options.contract.storage, actual.namespaceId);
+			calls.push(new DropPostgresRlsPolicyCall(schemaForTable, actual.tableName, actual.name));
 		}
 		return calls;
 	}
@@ -430,27 +578,63 @@ var PostgresMigrationPlanner = class {
 		}]);
 		return null;
 	}
-	collectSchemaIssues(options) {
-		const allowed = options.policy.allowedOperationClasses;
-		const strict = allowed.includes("widening") || allowed.includes("destructive");
-		const verifyResult = verifySqlSchema({
-			contract: options.contract,
-			schema: options.schema,
-			strict,
-			typeMetadataRegistry: /* @__PURE__ */ new Map(),
-			frameworkComponents: options.frameworkComponents,
-			normalizeDefault: parsePostgresDefault,
-			normalizeNativeType: normalizeSchemaNativeType
-		});
+	/**
+	* The structural issue list `planIssues` consumes: the relational findings
+	* from the shared `diffPostgresDatabaseSchema` plus namespace presence.
+	*
+	* Schema presence (`missing_schema` → `CREATE SCHEMA`) is a planner-only
+	* op-generation concern, so it is stitched in here rather than inside the
+	* shared diff — verify never needs it (a missing schema already surfaces as
+	* `missing_table` in the relational findings). It reads `existingSchemas` off
+	* the database root, so it takes the whole tree. Policy drift is handled
+	* separately via `planPostgresSchemaDiff` from the same shared diff's
+	* `schemaDiffIssues`.
+	*/
+	collectSchemaIssues(options, relationalIssues) {
 		const namespaceIssues = verifyPostgresNamespacePresence({
 			contract: options.contract,
 			schema: options.schema
 		});
-		if (namespaceIssues.length === 0) return verifyResult.schema.issues;
-		return [...namespaceIssues, ...verifyResult.schema.issues];
+		if (namespaceIssues.length === 0) return relationalIssues;
+		return [...namespaceIssues, ...relationalIssues];
 	}
 };
+/**
+* Returns the one namespace node whose tables the relational strategy layer
+* probes for live-table existence — the node matching the planner's resolved
+* schema name, or the first namespace when none matches. `undefined` when the
+* tree has no namespaces, so the strategy context uses its empty-schema default.
+*
+* The relational strategies key tables by bare name, so they can only probe one
+* namespace at a time; probing across every namespace at once is future work.
+*/
+function relationalNamespaceNode(schema, schemaName) {
+	const namespaceNodes = Object.values(schema.namespaces);
+	return namespaceNodes.find((node) => node.schemaName === schemaName) ?? namespaceNodes[0];
+}
+/**
+* Rebuilds the `PostgresRlsPolicy` contract entity `CreatePostgresRlsPolicyCall`
+* carries (its `renderTypeScript`/`createRlsPolicy` paths serialize the whole
+* entity, `namespaceId` included). This reconstructs rather than looking the
+* original up in the contract on purpose: the diff node's `namespaceId` is the
+* *resolved DDL schema* (set when the expected tree was built), which is the
+* value the emitted op must carry; the contract-stored entity holds the raw,
+* pre-resolution coordinate, so a lookup would change the migration output.
+*/
+function policyNodeToContractPolicy(node) {
+	return new PostgresRlsPolicy({
+		name: node.name,
+		prefix: node.prefix,
+		tableName: node.tableName,
+		namespaceId: node.namespaceId,
+		operation: node.operation,
+		roles: [...node.roles],
+		...ifDefined("using", node.using),
+		...ifDefined("withCheck", node.withCheck),
+		permissive: node.permissive
+	});
+}
 //#endregion
-export { contractToPostgresSchemaIR as i, diffPostgresSchema as n, filterIssuesByOwnership as r, createPostgresMigrationPlanner as t };
+export { contractToPostgresDatabaseSchemaNode as i, diffPostgresDatabaseSchema as n, verifyPostgresDatabaseSchema as r, createPostgresMigrationPlanner as t };
 
-//# sourceMappingURL=planner-BQ7lSqbm.mjs.map
+//# sourceMappingURL=planner-CG2pLHk-.mjs.map