fix(planner): D3b schema-qualify enum projection + cross-namespace column binding

Contract-to-contract migration planning (migration plan) projects the prior
contract to a schema IR via the family provider deriveAnnotations, which keyed
enum storageTypes by bare nativeType. The compound-keyed readExistingEnumValues
could not find them, so the planner took the introduce path instead of the
rebuild recipe.

deriveAnnotations now schema-qualifies namespace-scoped enum keys via an
injected EnumStorageKeyResolver. The Postgres DDL-schema resolution and the
compound-key format stay in target-postgres (control.ts wires the resolver from
resolveDdlSchemaForNamespaceStorage + enumStorageCompoundKey); the family layer
treats the returned string as opaque. Codec-typed storage types stay bare-keyed.
lint:deps stays green — no family to target import.

Also fix enumRebuildCallRecipe column-ref binding: a column carries a bare
typeRef whose enum may live in a different namespace (the builder places
contract-level types: enums in the default public namespace while a model table
sits in the unbound namespace). Resolve the column to its own-namespace enum
when present, else the ambient/public enum, replacing the over-narrow
nsId === namespaceId filter that dropped the alterColumnType migration.

Signed-off-by: Will Madden <madden@prisma.io>

Author: wmadden

packages/2-sql/9-family/src/core/migrations/contract-to-schema-ir.ts

@@ -1,5 +1,6 @@
 import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
 import type { MigrationPlannerConflict } from '@prisma-next/framework-components/control';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
   type ForeignKey,
   type Index,
@@ -52,6 +53,26 @@ export type NativeTypeExpander = (input: {
  */
 export type DefaultRenderer = (def: ColumnDefault, column: StorageColumn) => string;
 
+/**
+ * Target-supplied callback that computes the schema-qualified annotation-map
+ * key for a namespace-scoped enum storage type.
+ *
+ * Enum lookups (`readExistingEnumValues`) are namespace/schema-qualified so two
+ * namespaces holding an enum with the same TypeScript name (and even the same
+ * native type) resolve to distinct live-database types. The *format* of that
+ * key — and the namespace → DDL-schema resolution it depends on — is a
+ * target-specific concern (Postgres schemas; SQLite/MySQL differ), so the
+ * target injects it here as data rather than the family layer importing a
+ * concrete `ddlSchemaName`/key implementation. This keeps the family layer
+ * target-agnostic (no `@prisma-next/target-*` dependency) while the projection
+ * still emits keys that match the target's read side exactly.
+ */
+export type EnumStorageKeyResolver = (
+  storage: SqlStorage,
+  namespaceId: string,
+  nativeType: string,
+) => string;
+
 function convertColumn(
   name: string,
   column: StorageColumn,
@@ -265,6 +286,14 @@ export interface ContractToSchemaIROptions {
   readonly annotationNamespace: string;
   readonly expandNativeType?: NativeTypeExpander;
   readonly renderDefault?: DefaultRenderer;
+  /**
+   * Target-supplied resolver for namespace/schema-qualified enum annotation
+   * keys. When provided (Postgres), every namespace-scoped enum is keyed by the
+   * resolver's output so the projected `storageTypes` map matches the target's
+   * `readExistingEnumValues` lookup. Targets without namespace-qualified enum
+   * storage (SQLite) omit it; enums are absent there.
+   */
+  readonly resolveEnumStorageKey?: EnumStorageKeyResolver;
 }
 
 /**
@@ -330,55 +359,73 @@ export function contractToSchemaIR(
     }
   }
 
-  const annotations = deriveAnnotations(storage, options.annotationNamespace);
+  const annotations = deriveAnnotations(
+    storage,
+    options.annotationNamespace,
+    options.resolveEnumStorageKey,
+  );
 
   return {
     tables,
     ...ifDefined('annotations', annotations),
   };
 }
 
+/**
+ * Normalises a native enum storage entry to the codec-typed annotation shape
+ * `{codecId, nativeType, typeParams}` the introspector writes and
+ * `readExistingEnumValues` reads (`existing.codecId` + `existing.typeParams.values`).
+ * Without this the projector would emit the raw `PostgresEnumStorageEntry`
+ * shape (top-level `values`, no `typeParams`) and the enum would read as new.
+ */
+function normalizeEnumAnnotation(entry: PostgresEnumStorageEntry): StorageTypeInstance {
+  return toStorageTypeInstance({
+    codecId: entry.codecId,
+    nativeType: entry.nativeType,
+    typeParams: { values: entry.values },
+  });
+}
+
 function deriveAnnotations(
   storage: SqlStorage,
   annotationNamespace: string,
+  resolveEnumStorageKey: EnumStorageKeyResolver | undefined,
 ): SqlAnnotations | undefined {
-  const allTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {
-    ...((storage.types ?? {}) as ResolvedStorageTypes),
-  };
-  for (const ns of Object.values(storage.namespaces)) {
-    const nsEnums = (ns as { enum?: Record<string, PostgresEnumStorageEntry> }).enum;
-    if (nsEnums) {
-      for (const [k, v] of Object.entries(nsEnums)) {
-        allTypes[k] = v;
-      }
-    }
-  }
-  const types = allTypes as ResolvedStorageTypes;
-  if (Object.keys(types).length === 0) return undefined;
-  // Re-key by nativeType, normalising every variant to the codec-typed
-  // annotation shape `{codecId, nativeType, typeParams}` produced by the
-  // adapter introspector (`introspectPostgresEnumTypes` writes that shape;
-  // see also `enum-planning.ts § readExistingEnumValues`, which reads
-  // `existing.codecId` + `existing.typeParams.values`). Without this
-  // normalisation, the projector would emit the raw
-  // `PostgresEnumStorageEntry` shape (top-level `values`, no `typeParams`)
-  // and downstream Schema IR consumers that walk the codec-typed shape
-  // would see enum entries as new (e.g. the planner emits a fresh
-  // `CreateEnumTypeCall` instead of the rebuild recipe). Unknown future
-  // kinds without `nativeType` are skipped rather than crashing.
-  const byNativeType: Record<string, StorageTypeInstance> = {};
-  for (const typeInstance of Object.values(types)) {
+  const storageTypes: Record<string, StorageTypeInstance> = {};
+
+  // Top-level `storage.types`: codec-typed entries (vector, decimal, …) keyed
+  // by bare `nativeType` (unchanged). Post-S1.B enums live in
+  // `namespaces[*].enum`, not here; a defensive top-level enum is still
+  // namespace/schema-qualified via the resolver under the unbound coordinate
+  // so it never collides on a bare name.
+  for (const typeInstance of Object.values((storage.types ?? {}) as ResolvedStorageTypes)) {
     if (isPostgresEnumStorageEntry(typeInstance)) {
-      byNativeType[typeInstance.nativeType] = toStorageTypeInstance({
-        codecId: typeInstance.codecId,
-        nativeType: typeInstance.nativeType,
-        typeParams: { values: typeInstance.values },
-      });
+      const key = resolveEnumStorageKey
+        ? resolveEnumStorageKey(storage, UNBOUND_NAMESPACE_ID, typeInstance.nativeType)
+        : typeInstance.nativeType;
+      storageTypes[key] = normalizeEnumAnnotation(typeInstance);
       continue;
     }
     if (isStorageTypeInstance(typeInstance)) {
-      byNativeType[typeInstance.nativeType] = typeInstance;
+      storageTypes[typeInstance.nativeType] = typeInstance;
+    }
+  }
+
+  // Namespace-scoped enums: schema-qualified compound key matching the target's
+  // `readExistingEnumValues` read side, so two namespaces sharing an enum name
+  // (or native type) resolve to distinct live-database types.
+  for (const [namespaceId, ns] of Object.entries(storage.namespaces)) {
+    const nsEnums = (ns as { enum?: Record<string, PostgresEnumStorageEntry> }).enum;
+    if (!nsEnums) continue;
+    for (const entry of Object.values(nsEnums)) {
+      if (!isPostgresEnumStorageEntry(entry)) continue;
+      const key = resolveEnumStorageKey
+        ? resolveEnumStorageKey(storage, namespaceId, entry.nativeType)
+        : entry.nativeType;
+      storageTypes[key] = normalizeEnumAnnotation(entry);
     }
   }
-  return { [annotationNamespace]: { storageTypes: byNativeType } };
+
+  if (Object.keys(storageTypes).length === 0) return undefined;
+  return { [annotationNamespace]: { storageTypes } };
 }

packages/2-sql/9-family/src/exports/control.ts

@@ -17,6 +17,7 @@ export type { SqlControlFamilyInstance } from '../core/control-instance';
 export type {
   ContractToSchemaIROptions,
   DefaultRenderer,
+  EnumStorageKeyResolver,
   NativeTypeExpander,
 } from '../core/migrations/contract-to-schema-ir';
 // Contract → SchemaIR conversion for offline migration planning

packages/3-targets/3-targets/postgres/src/core/migrations/planner-strategies.ts

@@ -127,6 +127,43 @@ export function resolveDdlSchemaForNamespace(ctx: StrategyContext, namespaceId:
   return namespaceId;
 }
 
+/** Default Postgres enum landing namespace — where contract-level (`types:`)
+ * enums are placed by the authoring builder when no explicit namespace is
+ * given. Mirrors `POSTGRES_ENUM_NAMESPACE_ID` in the contract-ts builder. */
+const DEFAULT_ENUM_NAMESPACE_ID = 'public';
+
+function namespaceHasEnum(storage: SqlStorage, namespaceId: string, typeName: string): boolean {
+  const ns = storage.namespaces[namespaceId];
+  if (!ns || !('enum' in ns) || ns.enum == null) return false;
+  return (ns.enum as Record<string, PostgresEnumStorageEntry>)[typeName] !== undefined;
+}
+
+/**
+ * Resolves which namespace's enum a column's bare `typeRef` binds to.
+ *
+ * Columns carry a bare (non-namespace-qualified) `typeRef`; the enum it names
+ * may live in a different namespace than the column's own (the authoring
+ * builder places contract-level `types:` enums in the default `public`
+ * namespace while a model's table may sit in the unbound namespace). The
+ * binding rule: an enum declared in the column's *own* namespace shadows
+ * everything; otherwise the column references the ambient enum — the sole
+ * namespace that defines `typeName`, preferring the default `public`
+ * namespace when several do. Returns `undefined` when no namespace defines it.
+ */
+function resolveColumnEnumNamespace(
+  storage: SqlStorage,
+  columnNamespaceId: string,
+  typeName: string,
+): string | undefined {
+  if (namespaceHasEnum(storage, columnNamespaceId, typeName)) return columnNamespaceId;
+  const owners = Object.keys(storage.namespaces).filter((nsId) =>
+    namespaceHasEnum(storage, nsId, typeName),
+  );
+  if (owners.length === 1) return owners[0];
+  if (owners.includes(DEFAULT_ENUM_NAMESPACE_ID)) return DEFAULT_ENUM_NAMESPACE_ID;
+  return owners[0];
+}
+
 /**
  * Finds a type entry by explicit namespace coordinate. Namespace types (e.g.
  * Postgres enums) live under `storage.namespaces[nsId].enum`. Returns the
@@ -392,12 +429,20 @@ function enumRebuildCallRecipe(
     ctx.schema,
   );
 
+  // Migrate every column whose `typeRef` binds to *this* enum. The column's
+  // bare `typeRef` resolves to an enum namespace (own-namespace shadows;
+  // otherwise the ambient/default `public` enum), so a column in the unbound
+  // namespace correctly binds to a `public`-namespace enum, while two
+  // same-named enums in distinct namespaces keep their columns disjoint.
   const columnRefs: { namespaceId: string; table: string; column: string }[] = [];
   for (const [nsId, ns] of Object.entries(ctx.toContract.storage.namespaces)) {
     for (const [tableName, tableNode] of Object.entries(ns.tables)) {
       const table = tableNode as StorageTable;
       for (const [columnName, column] of Object.entries(table.columns)) {
-        if (column.typeRef === typeName && nsId === namespaceId) {
+        if (
+          column.typeRef === typeName &&
+          resolveColumnEnumNamespace(ctx.toContract.storage, nsId, typeName) === namespaceId
+        ) {
           columnRefs.push({ namespaceId: nsId, table: tableName, column: columnName });
         }
       }

packages/3-targets/3-targets/postgres/src/exports/control.ts

@@ -12,6 +12,10 @@ import type {
 import type { SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { postgresTargetDescriptorMeta } from '../core/descriptor-meta';
+import {
+  enumStorageCompoundKey,
+  resolveDdlSchemaForNamespaceStorage,
+} from '../core/migrations/enum-planning';
 import { createPostgresMigrationPlanner } from '../core/migrations/planner';
 import { renderDefaultLiteral } from '../core/migrations/planner-ddl-builders';
 import type { PostgresPlanTargetDetails } from '../core/migrations/planner-target-details';
@@ -78,6 +82,18 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
           annotationNamespace: 'pg',
           ...ifDefined('expandNativeType', expander),
           renderDefault: postgresRenderDefault,
+          // Schema-qualify enum annotation keys so the projected "from" IR's
+          // `storageTypes` match `readExistingEnumValues` on the read side
+          // (the contract-to-contract `migration plan` path). The DDL-schema
+          // resolution + compound-key format stay here in the target layer;
+          // the family projector treats the returned string as opaque.
+          // `undefined` schema IR ⇒ the unbound coordinate resolves to the
+          // default `public` landing schema, matching the read-side fallback.
+          resolveEnumStorageKey: (storage, namespaceId, nativeType) =>
+            enumStorageCompoundKey(
+              resolveDdlSchemaForNamespaceStorage(storage, namespaceId, undefined),
+              nativeType,
+            ),
         });
       },
     },

packages/3-targets/3-targets/postgres/test/migrations/enum-collision.test.ts

@@ -1,6 +1,7 @@
 import { type Contract, coreHash, profileHash } from '@prisma-next/contract/types';
 import type { MigrationOperationPolicy } from '@prisma-next/family-sql/control';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { StorageTableInput } from '@prisma-next/sql-contract/types';
 import { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
@@ -15,7 +16,7 @@ import {
   DropEnumTypeCall,
 } from '../../src/core/migrations/op-factory-call';
 import { nativeEnumPlanCallStrategy } from '../../src/core/migrations/planner-strategies';
-import { PostgresSchema } from '../../src/core/postgres-schema';
+import { PostgresSchema, PostgresUnboundSchema } from '../../src/core/postgres-schema';
 import { PostgresEnumType } from '../../src/exports/types';
 
 const defaultCtx = {
@@ -268,4 +269,72 @@ describe('enum namespace collision planning', () => {
       expect(dropCalls[0]?.schemaName).toBe('audit');
     });
   });
+
+  describe('cross-namespace column binding: public enum, unbound-namespace table', () => {
+    // The authoring builder places contract-level `types:` enums in the
+    // default `public` namespace, while a model's table lands in the unbound
+    // namespace. A column there carries a bare `typeRef` that must still bind
+    // to the `public` enum so the rebuild migrates it (regression for the
+    // D2 `nsId === namespaceId` over-narrowing).
+    it('rebuilds the public enum and migrates the unbound-namespace column', () => {
+      const userTable: StorageTableInput = {
+        columns: {
+          id: { nativeType: 'int4', codecId: 'pg/int4@1', nullable: false },
+          status: {
+            nativeType: 'status',
+            codecId: 'pg/enum@1',
+            nullable: false,
+            typeRef: 'status',
+          },
+        },
+        primaryKey: { columns: ['id'] },
+        uniques: [],
+        indexes: [],
+        foreignKeys: [],
+      };
+      const toContract: Contract<SqlStorage> = {
+        target: 'postgres',
+        targetFamily: 'sql',
+        profileHash: profileHash('sha256:public-enum-unbound-col'),
+        storage: new SqlStorage({
+          storageHash: coreHash('sha256:public-enum-unbound-col'),
+          namespaces: {
+            public: new PostgresSchema({
+              id: 'public',
+              tables: {},
+              enum: {
+                status: new PostgresEnumType({ name: 'status', values: ['active', 'archived'] }),
+              },
+            }),
+            [UNBOUND_NAMESPACE_ID]: new PostgresUnboundSchema({
+              id: UNBOUND_NAMESPACE_ID,
+              tables: { user: userTable },
+            }),
+          },
+        }),
+        roots: {},
+        models: {},
+        capabilities: {},
+        extensionPacks: {},
+        meta: {},
+      };
+      // Live enum has a value the contract drops → forces the rebuild recipe.
+      const schema = makeLiveEnumSchema([
+        { schemaName: 'public', nativeType: 'status', values: ['active', 'pending', 'archived'] },
+      ]);
+      const policy: MigrationOperationPolicy = {
+        allowedOperationClasses: ['additive', 'destructive', 'widening', 'data'],
+      };
+
+      const calls = planEnumCalls({ toContract, schema, policy });
+      const alterCalls = calls.filter(
+        (c): c is AlterColumnTypeCall => c instanceof AlterColumnTypeCall,
+      );
+
+      expect(alterCalls).toHaveLength(1);
+      expect(alterCalls[0]?.tableName).toBe('user');
+      expect(calls.some((c) => c instanceof CreateEnumTypeCall)).toBe(true);
+      expect(calls.some((c) => c instanceof DropEnumTypeCall)).toBe(true);
+    });
+  });
 });