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

package/dist/planner-Bmje9ii8-B99fEsNM.mjs

@@ -0,0 +1,588 @@
+import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86-Cpp8PTxD.mjs";
+import { d as isPostgresSchema, i as PostgresRlsPolicy } from "./postgres-schema-KSzLDONj-CsXGoY8b.mjs";
+import { n as PostgresNamespaceSchemaNode, r as PostgresPolicySchemaNode, t as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-B8Z5i5D--PObwlU2Z.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-CxqlLW47-0GiHRziS.mjs";
+import { A as RenamePostgresRlsPolicyCall, T as DropPostgresRlsPolicyCall, k as RenameIndexCall, p as CreatePostgresRlsPolicyCall } from "./op-factory-call-DifL68KT-Bo6pxs-R.mjs";
+import { a as planIssues, c as renderPostgresSuppression, d as resolvePostgresNodeIssueControlPolicySubject, f as resolvePostgresNodeIssueCreationFactoryName, i as issueSchemaName, l as resolveNamespaceIdForDdlSchema, n as conflictForDisallowedCall, o as postgresNodeStorageCoordinate, r as issueNode, s as postgresPlannerStrategies, t as coalesceSubtreeIssues, u as resolvePostgresCallControlPolicySubject } from "./control-policy-Cl3RRSPg-CT3QGpR3.mjs";
+import { t as buildPostgresPlanDiff } from "./diff-database-schema-BfRs2vrG-D2o4KII0.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-Cicg2sXg-Ck9iDxGI.mjs";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { namingOf, parseWireName } from "@prisma/orm-family-sql/schema-ir/naming";
+import { issueOutcome } from "@prisma/orm-framework/components/control";
+import { controlPolicyForCall, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure } from "@prisma/orm-family-sql/family/control";
+import { SqlIndexIR } from "@prisma/orm-family-sql/schema-ir/types";
+//#region ../../../3-targets/3-targets/postgres/dist/planner-Bmje9ii8.mjs
+/**
+* Resolves the live-database schema name for a given namespace
+* coordinate. Mirrors `resolveDdlSchemaForNamespace` in
+* `planner-strategies.ts` so the verifier's projection and the
+* planner's projection always agree — Postgres-aware namespaces (the
+* production path) dispatch to `ddlSchemaName(storage)`, and bare
+* object payloads (used by some tests) fall back to the coordinate
+* itself.
+*/
+function resolveDdlSchemaName(storage, namespaceId) {
+	const namespace = storage.namespaces[namespaceId];
+	if (isPostgresSchema(namespace)) return namespace.ddlSchemaName(storage);
+	return namespaceId;
+}
+/**
+* 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 root. Tests that want to assert against a richer initial
+* state construct a `PostgresDatabaseSchemaNode` explicitly.
+*/
+function existingSchemasFromSchema(schema) {
+	if (PostgresDatabaseSchemaNode.is(schema)) return schema.existingSchemas;
+	return [DEFAULT_NAMESPACE_ID];
+}
+/**
+* Emits a `postgres-namespace` `not-found` diff issue for every
+* contract-declared Postgres namespace whose live container does not yet
+* exist. The planner prepends these (node-typed, synthesized) to the
+* relational diff issues so a multi-schema plan emits `CREATE SCHEMA`
+* before the tables that need it — a planner-only concern (verify already
+* rejects via the `not-found` table issues a missing schema already
+* 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
+* to their own id; the unbound singleton returns `UNBOUND_NAMESPACE_ID`
+* and is skipped explicitly (late-bound namespaces have no fixed DDL
+* schema). Issues are emitted only when the resolved name is a real,
+* creatable schema (not the unbound sentinel) and is missing from the
+* introspected list. `public` is suppressed implicitly because the
+* introspection (or its sensible default) always carries it.
+*
+* Each emitted issue's path is `['database', ddlName]` — an ancestor of
+* every table path under that schema, so it must never be run through
+* `coalesceSubtreeIssues` alongside the table diff (it would swallow the
+* table-level `not-found` issues that drive `CREATE TABLE`); the planner
+* adds these AFTER coalescing the relational issues, and they are not
+* subject to sibling-space ownership scoping (mirrors the retired
+* coordinate walk, which prepended namespace issues after that filter).
+*/
+function verifyPostgresNamespacePresence(input) {
+	const { contract, schema } = input;
+	const existing = new Set(existingSchemasFromSchema(schema));
+	const issues = [];
+	const namespaceIds = Object.keys(contract.storage.namespaces).sort();
+	for (const namespaceId of namespaceIds) {
+		if (namespaceId === UNBOUND_NAMESPACE_ID) continue;
+		const ddlName = resolveDdlSchemaName(contract.storage, namespaceId);
+		if (ddlName === UNBOUND_NAMESPACE_ID) continue;
+		if (existing.has(ddlName)) continue;
+		const namespace = new PostgresNamespaceSchemaNode({
+			schemaName: ddlName,
+			tables: {}
+		});
+		issues.push({
+			path: ["database", ddlName],
+			expected: namespace
+		});
+	}
+	return issues;
+}
+function createPostgresMigrationPlanner(lowerer) {
+	return new PostgresMigrationPlanner(lowerer);
+}
+/**
+* Postgres migration planner — a thin wrapper over `planIssues`.
+*
+* `plan()` diffs the target contract against the live schema via the one
+* differ (`buildPostgresPlanDiff`, producing node-typed `SchemaDiffIssue[]`)
+* and delegates to `planIssues` with the unified `postgresPlannerStrategies`
+* list: NOT-NULL backfill, type-change, nullable-tightening, codec-hook
+* storage types, component-declared dependency installs, and
+* shared-temp-default / empty-table-guarded NOT-NULL add-column. The same
+* strategy list runs for `migration plan`, `db update`, and `db init`;
+* behavior diverges purely on `policy.allowedOperationClasses` (the
+* data-safe strategies short-circuit when `'data'` is excluded). The issue
+* planner applies operation-class policy gates and emits a single
+* `PostgresOpFactoryCall[]` that drives both the runtime-ops view (via
+* `renderOps`) and the `renderTypeScript()` authoring surface. RLS policy
+* drift (the structural half of the same one-differ tree) is handled
+* separately via `planPostgresSchemaDiff`.
+*/
+var PostgresMigrationPlanner = class {
+	#lowerer;
+	constructor(lowerer) {
+		this.#lowerer = lowerer;
+	}
+	plan(options) {
+		return this.planSql(options);
+	}
+	emptyMigration(context, spaceId) {
+		return new TypeScriptRenderablePostgresMigration([], {
+			from: context.fromHash,
+			to: context.toHash
+		}, spaceId, context.snapshotsImportPath, this.#lowerer);
+	}
+	planSql(options) {
+		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;
+		PostgresDatabaseSchemaNode.assert(options.schema);
+		const { issues: rawIssues } = buildPostgresPlanDiff({
+			contract: options.contract,
+			actualSchema: options.schema,
+			frameworkComponents: options.frameworkComponents
+		});
+		const policyDiffIssues = rawIssues.filter((issue) => isPolicyDiffIssue(issue));
+		const relationalDiffIssues = rawIssues.filter((issue) => !isPolicyDiffIssue(issue));
+		const strict = options.policy.allowedOperationClasses.includes("widening") || options.policy.allowedOperationClasses.includes("destructive");
+		const owned = retainUnownedExtras(coalesceSubtreeIssues(relationalDiffIssues), options.ownership, options.contract);
+		const gated = strict ? owned : owned.filter((issue) => issueOutcome(issue) !== "not-expected");
+		const schemaIssues = [...verifyPostgresNamespacePresence({
+			contract: options.contract,
+			schema: options.schema
+		}), ...gated];
+		const indexRenames = this.pairIndexRenames(options, schemaIssues);
+		const plannableIssues = indexRenames.consumed.size === 0 ? schemaIssues : schemaIssues.filter((issue) => !indexRenames.consumed.has(issue));
+		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
+		const storageTypes = options.contract.storage.types ?? {};
+		const relationalSchema = relationalNamespaceNode(options.schema, schemaName);
+		const issuePartition = partitionIssuesByControlPolicy({
+			issues: plannableIssues,
+			contract: options.contract,
+			resolveControlPolicySubject: (issue) => resolvePostgresNodeIssueControlPolicySubject(issue, options.contract),
+			resolveCreationFactoryName: resolvePostgresNodeIssueCreationFactoryName
+		});
+		const result = planIssues({
+			issues: issuePartition.plannable,
+			toContract: options.contract,
+			fromContract: options.fromContract,
+			schemaName,
+			codecHooks,
+			storageTypes,
+			...ifDefined("schema", relationalSchema),
+			policy: options.policy,
+			frameworkComponents: options.frameworkComponents,
+			strategies: postgresPlannerStrategies
+		});
+		const schemaDiff = this.planPostgresSchemaDiff(options, policyDiffIssues);
+		if (!result.ok || schemaDiff.conflicts.length > 0) return plannerFailure([...result.ok ? [] : result.failure, ...schemaDiff.conflicts]);
+		const indexRenamePartition = partitionCallsByControlPolicy({
+			calls: indexRenames.calls,
+			contract: options.contract,
+			resolveControlPolicySubject: (call) => resolvePostgresCallControlPolicySubject(call, options.contract),
+			resolveFactoryName: (call) => call.factoryName
+		});
+		const schemaDiffPartition = partitionCallsByControlPolicy({
+			calls: schemaDiff.calls,
+			contract: options.contract,
+			resolveControlPolicySubject: (call) => resolvePostgresCallControlPolicySubject(call, options.contract),
+			resolveFactoryName: (call) => call.factoryName
+		});
+		const fieldEventPartition = partitionCallsByControlPolicy({
+			calls: blindCast(planFieldEventOperations({
+				priorContract: options.fromContract,
+				newContract: options.contract,
+				codecHooks
+			})),
+			contract: options.contract,
+			resolveControlPolicySubject: (call) => resolvePostgresCallControlPolicySubject(call, options.contract),
+			resolveFactoryName: (call) => call.factoryName
+		});
+		const calls = [
+			...result.value.calls,
+			...indexRenamePartition.kept,
+			...schemaDiffPartition.kept,
+			...fieldEventPartition.kept
+		];
+		const seenWarnings = /* @__PURE__ */ new Set();
+		const warnings = [
+			...issuePartition.suppressions,
+			...indexRenamePartition.suppressions,
+			...schemaDiff.suppressions,
+			...schemaDiffPartition.suppressions,
+			...fieldEventPartition.suppressions
+		].map((record) => renderPostgresSuppression(record, options.contract)).filter((warning) => {
+			const key = JSON.stringify(warning);
+			if (seenWarnings.has(key)) return false;
+			seenWarnings.add(key);
+			return true;
+		});
+		return Object.freeze({
+			kind: "success",
+			plan: new TypeScriptRenderablePostgresMigration(calls, {
+				from: options.fromContract?.storage.storageHash ?? null,
+				to: options.contract.storage.storageHash
+			}, options.spaceId, options.snapshotsImportPath, this.#lowerer),
+			...warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}
+		});
+	}
+	/**
+	* Rename post-pass for indexes, per `(schema, table)`, widening-only,
+	* deterministic by sorted names — the same structure as the policy pass
+	* below (which stays untouched: policies pair by hash only).
+	*
+	* Hash pairing (prefix-only renames): extras whose live names parse as
+	* wire names, grouped by `(schema, table, hash)`; missing nodes iterated
+	* in sorted-name order consume the sorted-name-first candidate.
+	*
+	* Content pairing (exact→wire convergence), after hash pairing has
+	* consumed its matches: the remaining wire-named-missing nodes
+	* (`prefix` defined) against the remaining extras of any name shape,
+	* paired iff content-equal (columns ordered-strict both-defined-or-
+	* both-undefined, `unique`/`type` strict, `options` loose, bodies
+	* byte-equal).
+	*
+	* Leftovers proceed as create/drop exactly as before; without the
+	* widening allowance the pass is skipped and pairing degrades to the
+	* additive half, like the policy pass.
+	*/
+	pairIndexRenames(options, issues) {
+		const consumed = /* @__PURE__ */ new Set();
+		const calls = [];
+		if (!options.policy.allowedOperationClasses.includes("widening")) return {
+			calls,
+			consumed
+		};
+		const missing = [];
+		const extra = [];
+		for (const issue of issues) {
+			const node = issueNode(issue);
+			if (node === void 0 || !SqlIndexIR.is(node)) continue;
+			const ddlSchema = issue.path[1];
+			const tableName = issue.path[2];
+			if (ddlSchema === void 0 || tableName === void 0) continue;
+			if (issueOutcome(issue) === "not-found") missing.push({
+				issue,
+				node,
+				ddlSchema,
+				tableName
+			});
+			else if (issueOutcome(issue) === "not-expected") extra.push({
+				issue,
+				node,
+				ddlSchema,
+				tableName
+			});
+		}
+		if (missing.length === 0 || extra.length === 0) return {
+			calls,
+			consumed
+		};
+		const byName = (a, b) => a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0;
+		const emissionSchema = (ddlSchema) => resolveNamespaceIdForDdlSchema(options.contract, ddlSchema) === UNBOUND_NAMESPACE_ID ? UNBOUND_NAMESPACE_ID : ddlSchema;
+		const pairingKey = (finding, hash) => JSON.stringify([
+			finding.ddlSchema,
+			finding.tableName,
+			hash
+		]);
+		const rename = (missingFinding, candidate) => {
+			consumed.add(missingFinding.issue);
+			consumed.add(candidate.issue);
+			calls.push(new RenameIndexCall(emissionSchema(missingFinding.ddlSchema), missingFinding.tableName, candidate.node.name, missingFinding.node.name));
+		};
+		const sortedMissing = [...missing].sort(byName);
+		const extrasByHash = /* @__PURE__ */ new Map();
+		for (const finding of extra) {
+			const parsed = parseWireName(finding.node.name);
+			if (parsed === void 0) continue;
+			const key = pairingKey(finding, parsed.hash);
+			const group = extrasByHash.get(key) ?? [];
+			group.push(finding);
+			extrasByHash.set(key, group);
+		}
+		for (const group of extrasByHash.values()) group.sort(byName);
+		for (const missingFinding of sortedMissing) {
+			const parsed = parseWireName(missingFinding.node.name);
+			if (parsed === void 0) continue;
+			const candidate = extrasByHash.get(pairingKey(missingFinding, parsed.hash))?.shift();
+			if (candidate === void 0) continue;
+			rename(missingFinding, candidate);
+		}
+		const sortedExtras = [...extra].sort(byName);
+		for (const missingFinding of sortedMissing) {
+			if (consumed.has(missingFinding.issue)) continue;
+			if (missingFinding.node.prefix === void 0) continue;
+			const candidate = sortedExtras.find((extraFinding) => !consumed.has(extraFinding.issue) && extraFinding.ddlSchema === missingFinding.ddlSchema && extraFinding.tableName === missingFinding.tableName && missingFinding.node.contentEquals(extraFinding.node, {
+				columnPresence: "matching",
+				bodies: "verbatim"
+			}));
+			if (candidate === void 0) continue;
+			rename(missingFinding, candidate);
+		}
+		return {
+			calls,
+			consumed
+		};
+	}
+	/**
+	* Maps the RLS policy findings of the one combined tree diff
+	* (`buildPostgresPlanDiff`, already ownership-filtered) into
+	* `CREATE POLICY` / `DROP POLICY` / `ALTER POLICY … RENAME TO` ops — a
+	* `not-equal` finding (an exact-named policy whose content drifted)
+	* becomes drop + create, or a disallowed-call conflict when the policy
+	* forbids the destructive drop. It
+	* does not re-diff — it consumes exactly the policy-node subset of the
+	* shared diff's issues. Enablement is NOT decided here: `ENABLE`/`DISABLE
+	* ROW LEVEL SECURITY` derive from the table's marker-driven `rlsEnabled`
+	* attribute diff on the relational side.
+	*
+	* Rename post-pass (the index pass's structure): hash pairing pairs a
+	* `not-found` and a `not-expected` policy on the SAME table whose
+	* wire-name content hashes match but prefixes differ (prefix-only rename);
+	* content pairing then pairs remaining wire-named-missing policies against remaining
+	* extras of any name shape by verbatim content (the node-owned `contentEquals` —
+	* exact→wire adoption). Multi-candidate groups pair deterministically
+	* by sorted name; leftovers proceed as create/drop; an exact-named
+	* missing policy never content-pairs.
+	*
+	* The pairing runs only when the policy allows `widening` (rename's
+	* class). Without it (db-init's additive-only set), pairing degrades
+	* deliberately to the additive half: the new name is CREATEd and the old
+	* policy survives live until a widening/destructive-allowed plan runs —
+	* emitting an ungated widening rename would only fail at the runner's
+	* class re-enforcement.
+	*/
+	planPostgresSchemaDiff(options, filteredDiffIssues) {
+		const allowsDestructive = options.policy.allowedOperationClasses.includes("destructive");
+		const allowsWidening = options.policy.allowedOperationClasses.includes("widening");
+		const missing = [];
+		const extra = [];
+		const changed = [];
+		for (const issue of filteredDiffIssues) if (issueOutcome(issue) === "not-equal") {
+			const expected = issue.expected;
+			PostgresPolicySchemaNode.assert(expected);
+			changed.push({
+				node: expected,
+				schemaForTable: resolveDdlSchemaForNamespaceStorage(options.contract.storage, expected.namespaceId)
+			});
+		} else if (issueOutcome(issue) === "not-found") {
+			const expected = issue.expected;
+			PostgresPolicySchemaNode.assert(expected);
+			missing.push({
+				node: expected,
+				schemaForTable: resolveDdlSchemaForNamespaceStorage(options.contract.storage, expected.namespaceId)
+			});
+		} else if (issueOutcome(issue) === "not-expected") {
+			const actual = issue.actual;
+			PostgresPolicySchemaNode.assert(actual);
+			extra.push({
+				node: actual,
+				schemaForTable: resolveDdlSchemaForNamespaceStorage(options.contract.storage, actual.namespaceId)
+			});
+		}
+		const calls = [];
+		const conflicts = [];
+		const suppressions = [];
+		const renamedExtras = /* @__PURE__ */ new Set();
+		const renamedMissing = /* @__PURE__ */ new Set();
+		const pairingKey = (finding, hash) => JSON.stringify([
+			finding.schemaForTable,
+			finding.node.tableName,
+			hash
+		]);
+		if (allowsWidening) {
+			const extrasByGroup = /* @__PURE__ */ new Map();
+			for (const finding of extra) {
+				const parsed = parseWireName(finding.node.name);
+				if (parsed === void 0) continue;
+				const key = pairingKey(finding, parsed.hash);
+				const group = extrasByGroup.get(key) ?? [];
+				group.push(finding);
+				extrasByGroup.set(key, group);
+			}
+			for (const group of extrasByGroup.values()) group.sort((a, b) => a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0);
+			const sortedMissing = [...missing].sort((a, b) => a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0);
+			for (const missingFinding of sortedMissing) {
+				const parsed = parseWireName(missingFinding.node.name);
+				if (parsed === void 0) continue;
+				const candidate = extrasByGroup.get(pairingKey(missingFinding, parsed.hash))?.shift();
+				if (candidate === void 0) continue;
+				renamedExtras.add(candidate);
+				renamedMissing.add(missingFinding);
+				calls.push(new RenamePostgresRlsPolicyCall(missingFinding.schemaForTable, missingFinding.node.tableName, candidate.node.name, missingFinding.node.name));
+			}
+			const sortedExtras = [...extra].sort((a, b) => a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0);
+			for (const missingFinding of sortedMissing) {
+				if (renamedMissing.has(missingFinding)) continue;
+				if (missingFinding.node.prefix === void 0) continue;
+				const candidate = sortedExtras.find((extraFinding) => !renamedExtras.has(extraFinding) && extraFinding.schemaForTable === missingFinding.schemaForTable && extraFinding.node.tableName === missingFinding.node.tableName && missingFinding.node.contentEquals(extraFinding.node));
+				if (candidate === void 0) continue;
+				renamedExtras.add(candidate);
+				renamedMissing.add(missingFinding);
+				calls.push(new RenamePostgresRlsPolicyCall(missingFinding.schemaForTable, missingFinding.node.tableName, candidate.node.name, missingFinding.node.name));
+			}
+		}
+		for (const finding of changed) {
+			const replacement = {
+				drop: new DropPostgresRlsPolicyCall(finding.schemaForTable, finding.node.tableName, finding.node.name),
+				create: new CreatePostgresRlsPolicyCall(finding.schemaForTable, finding.node.tableName, policyNodeToContractPolicy(finding.node))
+			};
+			const graded = gradePolicyReplacement(replacement, options.contract, options.policy.allowedOperationClasses);
+			if (graded.disposition === "suppress") {
+				suppressions.push(graded.record);
+				continue;
+			}
+			if (graded.disposition === "conflict") {
+				conflicts.push(graded.conflict);
+				continue;
+			}
+			calls.push(replacement.drop);
+			calls.push(replacement.create);
+		}
+		for (const finding of missing) {
+			if (renamedMissing.has(finding)) continue;
+			calls.push(new CreatePostgresRlsPolicyCall(finding.schemaForTable, finding.node.tableName, policyNodeToContractPolicy(finding.node)));
+		}
+		if (allowsDestructive) for (const finding of extra) {
+			if (renamedExtras.has(finding)) continue;
+			calls.push(new DropPostgresRlsPolicyCall(finding.schemaForTable, finding.node.tableName, finding.node.name));
+		}
+		return {
+			calls,
+			conflicts,
+			suppressions
+		};
+	}
+	ensureAdditivePolicy(policy) {
+		if (!policy.allowedOperationClasses.includes("additive")) return plannerFailure([{
+			kind: "unsupportedOperation",
+			summary: "Migration planner requires additive operations be allowed",
+			why: "The planner requires the \"additive\" operation class to be allowed in the policy."
+		}]);
+		return null;
+	}
+};
+/**
+* A diff issue whose node is an RLS policy — the structural half of the one
+* combined tree diff, routed to `planPostgresSchemaDiff` instead of
+* `planIssues`.
+*/
+function isPolicyDiffIssue(issue) {
+	const node = issue.expected ?? issue.actual;
+	return node !== void 0 && PostgresPolicySchemaNode.is(node);
+}
+/**
+* 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 (issueOutcome(issue) !== "not-expected") return true;
+		const node = issueNode(issue);
+		if (node === void 0) return true;
+		const coordinate = postgresNodeStorageCoordinate(node);
+		if (coordinate === void 0) return true;
+		const ddlSchemaName = issueSchemaName(issue);
+		if (ddlSchemaName === void 0) return true;
+		const namespaceId = resolveNamespaceIdForDdlSchema(contract, ddlSchemaName);
+		return !ownership.declaresEntity({
+			namespaceId,
+			...coordinate
+		});
+	});
+}
+/**
+* Returns the one namespace node the relational strategy layer probes for
+* live-table existence and reads codec-hook context off — the namespace
+* 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.
+*
+* 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
+* `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
+* structurally-`SqlSchemaIR`-shaped value.
+*/
+function relationalNamespaceNode(schema, schemaName) {
+	const namespaceNodes = Object.values(schema.namespaces);
+	const namespaceNode = namespaceNodes.find((node) => node.schemaName === schemaName) ?? namespaceNodes[0];
+	if (namespaceNode === void 0) return void 0;
+	return blindCast(namespaceNode);
+}
+/**
+* Grades a {@link PolicyReplacement} as one unit against the table's
+* control policy, BEFORE the pair becomes calls or a conflict. This runs
+* ahead of `partitionCallsByControlPolicy`, which later re-grades the
+* surviving calls per-call — a no-op here, since only managed units
+* survive this grading.
+*
+* A replacement is deliberately STRICTER than the shared
+* `callAllowedUnderControlPolicy` rule: `tolerated` permits whole-object
+* creation, but a replacement's create is the second half of a repair of
+* an existing object, not a new object — so ANY non-managed control
+* (external, observed, tolerated) suppresses the whole unit. Drift on an
+* object the plan does not manage is reported, never repaired; the
+* suppression subject names the drifted policy (`rlsPolicy`) so the
+* report says which policy drifted, matching the conflict path's
+* `location.rlsPolicy`.
+*/
+function gradePolicyReplacement(replacement, contract, allowedOperationClasses) {
+	const subject = resolvePostgresCallControlPolicySubject(replacement.drop, contract);
+	const controlPolicy = controlPolicyForCall(subject, contract.defaultControlPolicy);
+	if (controlPolicy !== "managed") return {
+		disposition: "suppress",
+		record: {
+			subject: subject === void 0 ? void 0 : {
+				...subject,
+				rlsPolicy: replacement.drop.policyName
+			},
+			policy: controlPolicy,
+			factoryName: void 0,
+			createsNewObject: false
+		}
+	};
+	if (!allowedOperationClasses.includes("destructive")) return {
+		disposition: "conflict",
+		conflict: conflictForDisallowedCall(replacement.drop, allowedOperationClasses)
+	};
+	return { disposition: "plan" };
+}
+/**
+* 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({
+		naming: namingOf(node.name, node.prefix),
+		tableName: node.tableName,
+		namespaceId: node.namespaceId,
+		operation: node.operation,
+		roles: [...node.roles],
+		using: node.using,
+		withCheck: node.withCheck,
+		permissive: node.permissive
+	});
+}
+//#endregion
+export { createPostgresMigrationPlanner as t };
+
+//# sourceMappingURL=planner-Bmje9ii8-B99fEsNM.mjs.map