@prisma-next/target-postgres 0.11.0-dev.9 → 0.12.0-dev.1

package/src/core/migrations/enum-planning.ts

@@ -5,9 +5,138 @@
  */
 
 import { arraysEqual } from '@prisma-next/family-sql/schema-verify';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import type { PostgresEnumStorageEntry, SqlStorage } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import { PG_ENUM_CODEC_ID } from '../codec-ids';
 import type { PostgresEnumType } from '../postgres-enum-type';
+import { isPostgresSchema } from '../postgres-schema';
+
+/**
+ * Codec-typed enum entry shape stored under
+ * `schema.annotations.pg.storageTypes[(schemaName, nativeType)]`.
+ */
+interface PgStorageTypeEntry {
+  readonly codecId?: string;
+  readonly typeParams?: { readonly values?: unknown };
+}
+
+/** Postgres-specific subtree on family `SqlSchemaIR.annotations`. */
+export interface PostgresSchemaIrAnnotations {
+  readonly schema?: string;
+  readonly storageTypes?: Readonly<Record<string, PgStorageTypeEntry>>;
+}
+
+function readOptionalString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function readPgStorageTypeEntry(value: unknown): PgStorageTypeEntry | undefined {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+  const codecId = Reflect.get(value, 'codecId');
+  const typeParamsRaw = Reflect.get(value, 'typeParams');
+  const typeParams =
+    typeParamsRaw !== undefined &&
+    typeParamsRaw !== null &&
+    typeof typeParamsRaw === 'object' &&
+    !Array.isArray(typeParamsRaw)
+      ? { values: Reflect.get(typeParamsRaw, 'values') }
+      : undefined;
+  return {
+    ...(typeof codecId === 'string' ? { codecId } : {}),
+    ...(typeParams !== undefined ? { typeParams } : {}),
+  };
+}
+
+function readPgStorageTypesMap(
+  value: unknown,
+): Readonly<Record<string, PgStorageTypeEntry>> | undefined {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+  const entries: Record<string, PgStorageTypeEntry> = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    const entry = readPgStorageTypeEntry(entryValue);
+    if (entry !== undefined) {
+      entries[key] = entry;
+    }
+  }
+  return Object.keys(entries).length > 0 ? entries : undefined;
+}
+
+/**
+ * Reads the Postgres annotation envelope (`schema.annotations.pg`) from
+ * family Schema IR. `SqlAnnotations` is an open target-pack extensibility
+ * map (`Record<string, unknown>`); this accessor narrows the `pg` slot at
+ * runtime so Postgres code can read introspection fields without casts.
+ */
+export function readPostgresSchemaIrAnnotations(schema: SqlSchemaIR): PostgresSchemaIrAnnotations {
+  const raw = schema.annotations?.['pg'];
+  if (raw === undefined || raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+    return {};
+  }
+  const schemaField = readOptionalString(Reflect.get(raw, 'schema'));
+  const storageTypes = readPgStorageTypesMap(Reflect.get(raw, 'storageTypes'));
+  return {
+    ...(schemaField !== undefined ? { schema: schemaField } : {}),
+    ...(storageTypes !== undefined ? { storageTypes } : {}),
+  };
+}
+
+/**
+ * Separator for `(schemaName, nativeType)` keys in introspected
+ * `schema.annotations.pg.storageTypes`. NUL cannot appear in Postgres
+ * identifiers, so the pair is unambiguous.
+ */
+export const ENUM_STORAGE_KEY_SEP = '\u0000';
+
+/** Builds the schema-qualified storageTypes map key for a live Postgres enum. */
+export function enumStorageCompoundKey(schemaName: string, nativeType: string): string {
+  return `${schemaName}${ENUM_STORAGE_KEY_SEP}${nativeType}`;
+}
+
+/**
+ * Resolves the live-schema name a namespace's enums are introspected under,
+ * for keying `readExistingEnumValues` lookups. The unbound namespace's
+ * `ddlSchemaName` is a planner-emit sentinel (`__unbound__`) that never names a
+ * real schema, so for the unbound coordinate we read the *introspected* schema
+ * recorded on `annotations.pg.schema` (the live `current_schema()` the adapter
+ * walked) — that is the schema the enum's `storageTypes` entry is keyed under.
+ * Named namespaces resolve to their own DDL schema, which matches the
+ * per-schema introspection key directly.
+ */
+export function resolveDdlSchemaForNamespaceStorage(
+  storage: SqlStorage,
+  namespaceId: string,
+  schemaIr?: SqlSchemaIR,
+): string {
+  if (namespaceId === UNBOUND_NAMESPACE_ID) {
+    return (schemaIr ? readPostgresSchemaIrAnnotations(schemaIr).schema : undefined) ?? 'public';
+  }
+  const namespace = storage.namespaces[namespaceId];
+  if (namespace && isPostgresSchema(namespace)) {
+    return namespace.ddlSchemaName(storage);
+  }
+  return namespaceId;
+}
+
+/** Contract-scoped bridge for the family verifier's enum value resolver. */
+export function createResolveExistingEnumValues(
+  storage: SqlStorage,
+): (
+  schema: SqlSchemaIR,
+  enumType: PostgresEnumStorageEntry,
+  namespaceId: string,
+) => readonly string[] | null {
+  return (schema, enumType, namespaceId) =>
+    readExistingEnumValues(
+      schema,
+      resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schema),
+      enumType.nativeType,
+    );
+}
 
 /**
  * Categorisation of how an existing enum type's values relate to the
@@ -19,7 +148,7 @@ export type EnumDiff =
   | { readonly kind: 'rebuild'; readonly removedValues: readonly string[] };
 
 /**
- * Reads existing enum values for `nativeType` from the
+ * Reads existing enum values for `(schemaName, nativeType)` from the
  * Postgres-introspected `schema.annotations.pg.storageTypes` map.
  *
  * Schema IR's `storageTypes` slots are always codec-typed
@@ -33,20 +162,11 @@ export type EnumDiff =
  */
 export function readExistingEnumValues(
   schema: SqlSchemaIR,
+  schemaName: string,
   nativeType: string,
 ): readonly string[] | null {
-  const storageTypes = (schema.annotations?.['pg'] as Record<string, unknown> | undefined)?.[
-    'storageTypes'
-  ] as
-    | Record<
-        string,
-        {
-          codecId?: string;
-          typeParams?: { values?: unknown };
-        }
-      >
-    | undefined;
-  const existing = storageTypes?.[nativeType];
+  const storageTypes = readPostgresSchemaIrAnnotations(schema).storageTypes;
+  const existing = storageTypes?.[enumStorageCompoundKey(schemaName, nativeType)];
   if (!existing || existing.codecId !== PG_ENUM_CODEC_ID) {
     return null;
   }
@@ -54,7 +174,7 @@ export function readExistingEnumValues(
   if (!Array.isArray(enumValues) || !enumValues.every((v) => typeof v === 'string')) {
     return null;
   }
-  return enumValues as readonly string[];
+  return enumValues;
 }
 
 /**

package/src/core/migrations/issue-planner.ts

@@ -63,13 +63,18 @@ import {
 
 export type { CallMigrationStrategy, StrategyContext };
 
-function locateNamespaceTypeInStorage(storage: SqlStorage, typeName: string): unknown {
-  for (const ns of Object.values(storage.namespaces)) {
-    if (!('enum' in ns) || ns.enum == null) continue;
-    const entry = (ns.enum as Record<string, unknown>)[typeName];
-    if (entry !== undefined) return entry;
-  }
-  return undefined;
+/**
+ * Finds a type entry by explicit namespace coordinate. Reads the named
+ * namespace's `enum` slot directly — never scans other namespaces.
+ */
+function locateNamespaceTypeInStorage(
+  storage: SqlStorage,
+  namespaceId: string,
+  typeName: string,
+): unknown {
+  const ns = storage.namespaces[namespaceId];
+  if (!ns || !('enum' in ns) || ns.enum == null) return undefined;
+  return (ns.enum as Record<string, unknown>)[typeName];
 }
 
 // ============================================================================
@@ -596,11 +601,14 @@ function mapIssueToCall(
     case 'type_missing': {
       if (!issue.typeName)
         return notOk(issueConflict('unsupportedOperation', 'Type missing issue has no typeName'));
-      // Enum types live in namespace.enum; codec aliases live in storage.types.
-      // Check both so the planner handles whichever slot the type is in.
+      // Codec aliases live in storage.types; enum types live in namespace.enum.
+      // Check types first; fall back to the namespace-keyed enum slot using the
+      // issue's namespace coordinate (populated by the verifier for enum-related
+      // issues per the BaseSchemaIssue.namespaceId contract).
+      const namespaceId = resolveNamespaceIdForIssue(issue);
       const typeInstance: unknown =
         ctx.toContract.storage.types?.[issue.typeName] ??
-        locateNamespaceTypeInStorage(ctx.toContract.storage, issue.typeName);
+        locateNamespaceTypeInStorage(ctx.toContract.storage, namespaceId, issue.typeName);
       if (!typeInstance) {
         return notOk(
           issueConflict(
@@ -610,9 +618,10 @@ function mapIssueToCall(
         );
       }
       if (typeInstance instanceof PostgresEnumType) {
+        const ddlSchema = resolveDdlSchemaForNamespace(ctx, namespaceId);
         return ok([
           new CreateEnumTypeCall(
-            schemaName,
+            ddlSchema,
             issue.typeName,
             typeInstance.values,
             typeInstance.nativeType,

package/src/core/migrations/planner-produced-postgres-migration.ts

@@ -29,7 +29,6 @@ import type {
   OpFactoryCall,
 } from '@prisma-next/framework-components/control';
 import type { MigrationMeta } from '@prisma-next/migration-tools/migration';
-import { ifDefined } from '@prisma-next/utils/defined';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 import { PostgresMigration } from './postgres-migration';
 import { renderOps } from './render-ops';
@@ -73,7 +72,6 @@ export class TypeScriptRenderablePostgresMigration
     return renderCallsToTypeScript(this.#calls, {
       from: this.#meta.from,
       to: this.#meta.to,
-      ...ifDefined('labels', this.#meta.labels),
     });
   }
 }

package/src/core/migrations/planner-strategies.ts

@@ -37,7 +37,11 @@ import {
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import { PostgresEnumType } from '../postgres-enum-type';
 import { isPostgresSchema } from '../postgres-schema';
-import { determineEnumDiff, readExistingEnumValues } from './enum-planning';
+import {
+  determineEnumDiff,
+  readExistingEnumValues,
+  resolveDdlSchemaForNamespaceStorage,
+} from './enum-planning';
 import {
   AddColumnCall,
   AddEnumValuesCall,
@@ -108,12 +112,12 @@ export function resolveNamespaceIdForIssue(issue: { readonly namespaceId?: strin
 /**
  * Resolve the DDL schema name for a namespace coordinate. Postgres-aware
  * namespaces dispatch to their polymorphic `ddlSchemaName` override —
- * named schemas return their own id and the unbound singleton projects
- * to `'public'` (sibling-present) or the framework sentinel
- * (sibling-absent). Legacy single-namespace contracts whose `__unbound__`
- * slot is the framework-default `SqlUnboundNamespace` (rather than the
- * Postgres-aware `PostgresUnboundSchema`) flow the coordinate through
- * unchanged so downstream `qualifyTableName` resolves polymorphically.
+ * named schemas return their own id; the unbound singleton returns
+ * `UNBOUND_NAMESPACE_ID`. Legacy single-namespace contracts whose
+ * `__unbound__` slot is the framework-default `SqlUnboundNamespace`
+ * (rather than the Postgres-aware `PostgresUnboundSchema`) flow the
+ * coordinate through unchanged so downstream `qualifyTableName`
+ * resolves polymorphically.
  */
 export function resolveDdlSchemaForNamespace(ctx: StrategyContext, namespaceId: string): string {
   const namespace = ctx.toContract.storage.namespaces[namespaceId];
@@ -123,21 +127,57 @@ 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;
+}
+
 /**
- * Finds a type entry by name across all namespace type registries.
- * Namespace types (e.g. Postgres enums) live under
- * `storage.namespaces[nsId].enum`, not under `storage.types`.
+ * 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
+ * entry from the named namespace only — never scans other namespaces, so two
+ * namespaces that hold an enum with the same name resolve independently.
  */
 function locateNamespaceType(
   storage: SqlStorage,
+  namespaceId: string,
   typeName: string,
 ): PostgresEnumStorageEntry | undefined {
-  for (const ns of Object.values(storage.namespaces)) {
-    if (!('enum' in ns) || ns.enum == null) continue;
-    const entry = (ns.enum as Record<string, PostgresEnumStorageEntry>)[typeName];
-    if (entry !== undefined) return entry;
-  }
-  return undefined;
+  const ns = storage.namespaces[namespaceId];
+  if (!ns || !('enum' in ns) || ns.enum == null) return undefined;
+  return (ns.enum as Record<string, PostgresEnumStorageEntry>)[typeName];
 }
 
 // ============================================================================
@@ -369,10 +409,11 @@ export const nullableTighteningCallStrategy: CallMigrationStrategy = (issues, ct
 };
 
 function enumRebuildCallRecipe(
+  namespaceId: string,
   typeName: string,
   ctx: StrategyContext,
 ): readonly PostgresOpFactoryCall[] {
-  const toType = locateNamespaceType(ctx.toContract.storage, typeName);
+  const toType = locateNamespaceType(ctx.toContract.storage, namespaceId, typeName);
   if (!toType) return [];
   const isEnum = isPostgresEnumStorageEntry(toType);
   const nativeType = toType.nativeType;
@@ -380,13 +421,28 @@ function enumRebuildCallRecipe(
     ? toType.values
     : (((toType as StorageTypeInstance).typeParams['values'] ?? []) as readonly string[]);
   const tempName = `${nativeType}${REBUILD_SUFFIX}`;
+  // Type DDL targets the enum's real schema — the unbound coordinate resolves
+  // to the introspected `current_schema()`, never the `__unbound__` sentinel.
+  const ddlSchema = resolveDdlSchemaForNamespaceStorage(
+    ctx.toContract.storage,
+    namespaceId,
+    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) {
+        if (
+          column.typeRef === typeName &&
+          resolveColumnEnumNamespace(ctx.toContract.storage, nsId, typeName) === namespaceId
+        ) {
           columnRefs.push({ namespaceId: nsId, table: tableName, column: columnName });
         }
       }
@@ -394,7 +450,7 @@ function enumRebuildCallRecipe(
   }
 
   return [
-    new CreateEnumTypeCall(ctx.schemaName, tempName, desiredValues),
+    new CreateEnumTypeCall(ddlSchema, tempName, desiredValues),
     ...columnRefs.map((ref) => {
       const using = `${ref.column}::text::${tempName}`;
       return new AlterColumnTypeCall(
@@ -409,8 +465,8 @@ function enumRebuildCallRecipe(
         },
       );
     }),
-    new DropEnumTypeCall(ctx.schemaName, nativeType),
-    new RenameTypeCall(ctx.schemaName, tempName, nativeType),
+    new DropEnumTypeCall(ddlSchema, nativeType),
+    new RenameTypeCall(ddlSchema, tempName, nativeType),
   ];
 }
 
@@ -450,6 +506,18 @@ function enumRebuildCallRecipe(
  * into the `dep` bucket — i.e. `CREATE TYPE` runs before any
  * `CreateTableCall` that references the new enum.
  */
+/**
+ * Separator character for compound enum map keys (`namespaceId\u0000typeName`).
+ * NUL (`\u0000`) is invalid in both Postgres identifiers and TypeScript symbol
+ * names so it cannot appear in either component — unambiguous separator.
+ */
+const COMPOUND_KEY_SEP = '\u0000';
+
+/** Builds the compound map key for a namespace-qualified enum entry. */
+function enumCompoundKey(namespaceId: string, typeName: string): string {
+  return `${namespaceId}${COMPOUND_KEY_SEP}${typeName}`;
+}
+
 export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) => {
   const enumTypes = collectPostgresEnumTypes(ctx.toContract.storage);
   if (enumTypes.size === 0) return { kind: 'no_match' };
@@ -457,28 +525,42 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
   const dataAllowed = ctx.policy.allowedOperationClasses.includes('data');
 
   const calls: PostgresOpFactoryCall[] = [];
-  const handledTypeNames = new Set<string>();
-  const introducedTypeNames = new Set<string>();
-  const rebuiltTypeNames = new Set<string>();
+  const handledKeys = new Set<string>();
+  const introducedKeys = new Set<string>();
+  const rebuiltKeys = new Set<string>();
   let emittedRebuildRecipe = false;
 
-  for (const [typeName, enumType] of enumTypes) {
+  for (const [key, enumType] of enumTypes) {
+    const sepIdx = key.indexOf(COMPOUND_KEY_SEP);
+    const enumNamespaceId = key.slice(0, sepIdx);
+    const typeName = key.slice(sepIdx + 1);
+
     const desired = enumType.values;
-    const existing = readExistingEnumValues(ctx.schema, enumType.nativeType);
+    // The enum's live schema: for the unbound coordinate this resolves to the
+    // introspected `current_schema()` (e.g. `public`), never the `__unbound__`
+    // DDL-emit sentinel — so both the existing-values lookup key and the
+    // emitted `CREATE TYPE` / `ALTER TYPE` target the real schema the type
+    // lives in. Named namespaces resolve to their own DDL schema.
+    const ddlSchema = resolveDdlSchemaForNamespaceStorage(
+      ctx.toContract.storage,
+      enumNamespaceId,
+      ctx.schema,
+    );
+    const existing = readExistingEnumValues(ctx.schema, ddlSchema, enumType.nativeType);
     if (!existing) {
-      calls.push(new CreateEnumTypeCall(ctx.schemaName, typeName, desired, enumType.nativeType));
-      handledTypeNames.add(typeName);
-      introducedTypeNames.add(typeName);
+      calls.push(new CreateEnumTypeCall(ddlSchema, typeName, desired, enumType.nativeType));
+      handledKeys.add(key);
+      introducedKeys.add(key);
       continue;
     }
     const diff = determineEnumDiff(existing, desired);
     if (diff.kind === 'unchanged') {
-      handledTypeNames.add(typeName);
+      handledKeys.add(key);
       continue;
     }
     if (diff.kind === 'add_values') {
-      calls.push(new AddEnumValuesCall(ctx.schemaName, typeName, enumType.nativeType, diff.values));
-      handledTypeNames.add(typeName);
+      calls.push(new AddEnumValuesCall(ddlSchema, typeName, enumType.nativeType, diff.values));
+      handledKeys.add(key);
       continue;
     }
     if (dataAllowed && diff.removedValues.length > 0) {
@@ -490,10 +572,10 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
         ),
       );
     }
-    calls.push(...enumRebuildCallRecipe(typeName, ctx));
+    calls.push(...enumRebuildCallRecipe(enumNamespaceId, typeName, ctx));
     emittedRebuildRecipe = true;
-    handledTypeNames.add(typeName);
-    rebuiltTypeNames.add(typeName);
+    handledKeys.add(key);
+    rebuiltKeys.add(key);
   }
 
   // The strategy emits a single `recipe` flag for the entire pass,
@@ -505,9 +587,17 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
   // enum would fail at runtime with a confusing `type "X" does not
   // exist` error. Surface the unrepresentable case here as a
   // planner-time error so the failure mode is loud, not silent.
-  if (introducedTypeNames.size > 0 && rebuiltTypeNames.size > 0) {
+  if (introducedKeys.size > 0 && rebuiltKeys.size > 0) {
+    const introducedDisplay = [...introducedKeys]
+      .sort()
+      .map((k) => k.replace(COMPOUND_KEY_SEP, '.'))
+      .join(', ');
+    const rebuiltDisplay = [...rebuiltKeys]
+      .sort()
+      .map((k) => k.replace(COMPOUND_KEY_SEP, '.'))
+      .join(', ');
     throw new Error(
-      `nativeEnumPlanCallStrategy: cannot emit both a brand-new enum and a rebuild on a different enum in the same plan; the single recipe flag cannot route them to different buckets. Introduced: [${[...introducedTypeNames].sort().join(', ')}]; rebuilt: [${[...rebuiltTypeNames].sort().join(', ')}]. Split the strategy or grow the \`match\` return type before this case lands.`,
+      `nativeEnumPlanCallStrategy: cannot emit both a brand-new enum and a rebuild on a different enum in the same plan; the single recipe flag cannot route them to different buckets. Introduced: [${introducedDisplay}]; rebuilt: [${rebuiltDisplay}]. Split the strategy or grow the \`match\` return type before this case lands.`,
     );
   }
 
@@ -516,7 +606,7 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
       !(
         (issue.kind === 'type_missing' || issue.kind === 'enum_values_changed') &&
         issue.typeName &&
-        handledTypeNames.has(issue.typeName)
+        handledKeys.has(enumCompoundKey(resolveNamespaceIdForIssue(issue), issue.typeName))
       ),
   );
 
@@ -538,14 +628,22 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
   return { kind: 'match', issues: remaining, calls, recipe: emittedRebuildRecipe };
 };
 
+/**
+ * Collects every `PostgresEnumType` instance across all declared namespaces,
+ * returning a compound-keyed map (`${namespaceId}\u0000${typeName}`). Two
+ * namespaces that declare an enum with the same name produce two distinct
+ * entries — no name collision, no last-write-wins.
+ *
+ * Entries within each namespace are sorted by name for deterministic ordering.
+ */
 function collectPostgresEnumTypes(storage: SqlStorage): ReadonlyMap<string, PostgresEnumType> {
   const result = new Map<string, PostgresEnumType>();
-  for (const ns of Object.values(storage.namespaces)) {
+  for (const [nsId, ns] of Object.entries(storage.namespaces)) {
     if (!('enum' in ns) || ns.enum == null) continue;
     const nsEnums = ns.enum as Record<string, unknown>;
     for (const [name, instance] of Object.entries(nsEnums).sort(([a], [b]) => a.localeCompare(b))) {
       if (instance instanceof PostgresEnumType) {
-        result.set(name, instance);
+        result.set(enumCompoundKey(nsId, name), instance);
       }
     }
   }

package/src/core/migrations/planner.ts

@@ -17,9 +17,10 @@ import type {
   MigrationScaffoldContext,
   SchemaIssue,
 } from '@prisma-next/framework-components/control';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
-import { readExistingEnumValues } from './enum-planning';
+import { createResolveExistingEnumValues } from './enum-planning';
 import { planIssues } from './issue-planner';
 import { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';
 import { postgresPlannerStrategies } from './planner-strategies';
@@ -39,21 +40,8 @@ type VerifySqlSchemaOptionsWithComponents = Parameters<typeof verifySqlSchema>[0
   readonly frameworkComponents: PlannerFrameworkComponents;
 };
 
-interface PlannerConfig {
-  readonly defaultSchema: string;
-}
-
-const DEFAULT_PLANNER_CONFIG: PlannerConfig = {
-  defaultSchema: 'public',
-};
-
-export function createPostgresMigrationPlanner(
-  config: Partial<PlannerConfig> = {},
-): PostgresMigrationPlanner {
-  return new PostgresMigrationPlanner({
-    ...DEFAULT_PLANNER_CONFIG,
-    ...config,
-  });
+export function createPostgresMigrationPlanner(): PostgresMigrationPlanner {
+  return new PostgresMigrationPlanner();
 }
 
 /**
@@ -84,8 +72,6 @@ export type PostgresPlanResult =
  * authoring surface.
  */
 export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {
-  constructor(private readonly config: PlannerConfig) {}
-
   plan(options: {
     readonly contract: unknown;
     readonly schema: unknown;
@@ -132,7 +118,10 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
   }
 
   private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {
-    const schemaName = options.schemaName ?? this.config.defaultSchema;
+    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;
@@ -219,8 +208,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       frameworkComponents: options.frameworkComponents,
       normalizeDefault: parsePostgresDefault,
       normalizeNativeType: normalizeSchemaNativeType,
-      resolveExistingEnumValues: (schema, enumType) =>
-        readExistingEnumValues(schema, enumType.nativeType),
+      resolveExistingEnumValues: createResolveExistingEnumValues(options.contract.storage),
     };
     const verifyResult = verifySqlSchema(verifyOptions);
     // Schema presence is a Postgres-specific concern (no equivalent in

package/src/core/migrations/render-typescript.ts

@@ -11,12 +11,11 @@
 
 import type { OpFactoryCall } from '@prisma-next/framework-components/control';
 import { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';
-import { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-next/ts-render';
+import { type ImportRequirement, renderImports } from '@prisma-next/ts-render';
 
 export interface RenderMigrationMeta {
   readonly from: string | null;
   readonly to: string;
-  readonly labels?: readonly string[];
 }
 
 /**
@@ -83,9 +82,6 @@ function buildDescribeMethod(meta: RenderMigrationMeta): string {
   lines.push('    return {');
   lines.push(`      from: ${JSON.stringify(meta.from)},`);
   lines.push(`      to: ${JSON.stringify(meta.to)},`);
-  if (meta.labels && meta.labels.length > 0) {
-    lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
-  }
   lines.push('    };');
   lines.push('  }');
   lines.push('');