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

package/dist/enum-planning.d.mts

@@ -1,7 +1,45 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-CNhPTDhy.mjs";
+import { t as PostgresEnumType } from "./postgres-enum-type-5MBoKsIj.mjs";
+import { PostgresEnumStorageEntry, SqlStorage } from "@prisma-next/sql-contract/types";
 import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 
 //#region src/core/migrations/enum-planning.d.ts
+/**
+ * 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`. */
+interface PostgresSchemaIrAnnotations {
+  readonly schema?: string;
+  readonly storageTypes?: Readonly<Record<string, PgStorageTypeEntry>>;
+}
+/**
+ * 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.
+ */
+declare function readPostgresSchemaIrAnnotations(schema: SqlSchemaIR): PostgresSchemaIrAnnotations;
+/** Builds the schema-qualified storageTypes map key for a live Postgres enum. */
+declare function enumStorageCompoundKey(schemaName: string, nativeType: string): string;
+/**
+ * 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.
+ */
+declare function resolveDdlSchemaForNamespaceStorage(storage: SqlStorage, namespaceId: string, schemaIr?: SqlSchemaIR): string;
+/** Contract-scoped bridge for the family verifier's enum value resolver. */
+declare function createResolveExistingEnumValues(storage: SqlStorage): (schema: SqlSchemaIR, enumType: PostgresEnumStorageEntry, namespaceId: string) => readonly string[] | null;
 /**
  * Categorisation of how an existing enum type's values relate to the
  * desired set in the contract.
@@ -16,7 +54,7 @@ type EnumDiff = {
   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
@@ -28,7 +66,7 @@ type EnumDiff = {
  *
  * Returns `null` when no enum entry exists for the given native type.
  */
-declare function readExistingEnumValues(schema: SqlSchemaIR, nativeType: string): readonly string[] | null;
+declare function readExistingEnumValues(schema: SqlSchemaIR, schemaName: string, nativeType: string): readonly string[] | null;
 /**
  * Determines what changes are needed to transform existing enum values to
  * desired values.
@@ -44,5 +82,5 @@ declare function determineEnumDiff(existing: readonly string[], desired: readonl
  */
 declare function getDesiredEnumValues(typeInstance: PostgresEnumType): readonly string[];
 //#endregion
-export { type EnumDiff, determineEnumDiff, getDesiredEnumValues, readExistingEnumValues };
+export { type EnumDiff, type PostgresSchemaIrAnnotations, createResolveExistingEnumValues, determineEnumDiff, enumStorageCompoundKey, getDesiredEnumValues, readExistingEnumValues, readPostgresSchemaIrAnnotations, resolveDdlSchemaForNamespaceStorage };
 //# sourceMappingURL=enum-planning.d.mts.map

package/dist/enum-planning.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"enum-planning.d.mts","names":[],"sources":["../src/core/migrations/enum-planning.ts"],"mappings":";;;;;;;;KAeY,QAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAA6B,MAAA;AAAA;EAAA,SAC7B,IAAA;EAAA,SAA0B,aAAA;AAAA;;;;;AAiDzC;;;;;;;;;iBAlCgB,sBAAA,CACd,MAAA,EAAQ,WAAA,EACR,UAAA;;;;;;;;;iBAgCc,iBAAA,CACd,QAAA,qBACA,OAAA,sBACC,QAAA;;;;;iBAoBa,oBAAA,CAAqB,YAAA,EAAc,gBAAA"}
+{"version":3,"file":"enum-planning.d.mts","names":[],"sources":["../src/core/migrations/enum-planning.ts"],"mappings":";;;;;;;;;UAkBU,kBAAA;EAAA,SACC,OAAA;EAAA,SACA,UAAA;IAAA,SAAwB,MAAA;EAAA;AAAA;;UAIlB,2BAAA;EAAA,SACN,MAAA;EAAA,SACA,YAAA,GAAe,QAAA,CAAS,MAAA,SAAe,kBAAA;AAAA;;;;;;AAAkB;iBAgDpD,+BAAA,CAAgC,MAAA,EAAQ,WAAA,GAAc,2BAA2B;;iBAqBjF,sBAAA,CAAuB,UAAA,UAAoB,UAAkB;AAA7E;;;;AAA6E;AAc7E;;;;;AAdA,iBAcgB,mCAAA,CACd,OAAA,EAAS,UAAA,EACT,WAAA,UACA,QAAA,GAAW,WAAW;;iBAaR,+BAAA,CACd,OAAA,EAAS,UAAA,IAET,MAAA,EAAQ,WAAA,EACR,QAAA,EAAU,wBAAA,EACV,WAAA;;;AAlBsB;AAaxB;KAmBY,QAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAA6B,MAAA;AAAA;EAAA,SAC7B,IAAA;EAAA,SAA0B,aAAA;AAAA;;;;;;;AAjBpB;AAcrB;;;;;;iBAkBgB,sBAAA,CACd,MAAA,EAAQ,WAAW,EACnB,UAAA,UACA,UAAA;;;;AAlBoD;AAetD;;;;iBAyBgB,iBAAA,CACd,QAAA,qBACA,OAAA,sBACC,QAAQ;;;;;iBAoBK,oBAAA,CAAqB,YAA8B,EAAhB,gBAAgB"}

package/dist/enum-planning.mjs

@@ -1,2 +1,2 @@
-import { n as getDesiredEnumValues, r as readExistingEnumValues, t as determineEnumDiff } from "./enum-planning-Bqp96iIw.mjs";
-export { determineEnumDiff, getDesiredEnumValues, readExistingEnumValues };
+import { a as readExistingEnumValues, i as getDesiredEnumValues, n as determineEnumDiff, o as readPostgresSchemaIrAnnotations, r as enumStorageCompoundKey, s as resolveDdlSchemaForNamespaceStorage, t as createResolveExistingEnumValues } from "./enum-planning-DrNWCtCp.mjs";
+export { createResolveExistingEnumValues, determineEnumDiff, enumStorageCompoundKey, getDesiredEnumValues, readExistingEnumValues, readPostgresSchemaIrAnnotations, resolveDdlSchemaForNamespaceStorage };

package/dist/{errors--zafB5_n.mjs → errors-BbnITmAD.mjs}

@@ -30,4 +30,4 @@ function errorPostgresMigrationStackMissing() {
 //#endregion
 export { errorPostgresMigrationStackMissing as t };
 
-//# sourceMappingURL=errors--zafB5_n.mjs.map
+//# sourceMappingURL=errors-BbnITmAD.mjs.map

package/dist/{errors--zafB5_n.mjs.map → errors-BbnITmAD.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"errors--zafB5_n.mjs","names":[],"sources":["../src/core/errors.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `PostgresMigration` instance method that needs the materialized control\n * adapter (currently only `this.dataTransform(...)`) was invoked, but the\n * migration was constructed without a `ControlStack`. Concrete authoring\n * usage always goes through the migration CLI entrypoint, which assembles\n * a stack from the loaded `prisma-next.config.ts`; reaching this error\n * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection\n * only).\n *\n * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`\n * (data-transform query plan against wrong contract) because the missing\n * input is the stack itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-postgres/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`PostgresMigration`, the Postgres control\n * adapter, the Postgres-target stack) only exists in this package.\n */\nexport function errorPostgresMigrationStackMissing(): CliStructuredError {\n  return new CliStructuredError(\n    '2007',\n    'PostgresMigration.dataTransform requires a control adapter',\n    {\n      domain: 'MIG',\n      why: 'PostgresMigration.dataTransform was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so dataTransform cannot lower its query plan.',\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',\n      meta: {},\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,qCAAyD;CACvE,OAAO,IAAI,mBACT,QACA,8DACA;EACE,QAAQ;EACR,KAAK;EACL,KAAK;EACL,MAAM,EAAE;EACT,CACF"}
+{"version":3,"file":"errors-BbnITmAD.mjs","names":[],"sources":["../src/core/errors.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `PostgresMigration` instance method that needs the materialized control\n * adapter (currently only `this.dataTransform(...)`) was invoked, but the\n * migration was constructed without a `ControlStack`. Concrete authoring\n * usage always goes through the migration CLI entrypoint, which assembles\n * a stack from the loaded `prisma-next.config.ts`; reaching this error\n * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection\n * only).\n *\n * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`\n * (data-transform query plan against wrong contract) because the missing\n * input is the stack itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-postgres/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`PostgresMigration`, the Postgres control\n * adapter, the Postgres-target stack) only exists in this package.\n */\nexport function errorPostgresMigrationStackMissing(): CliStructuredError {\n  return new CliStructuredError(\n    '2007',\n    'PostgresMigration.dataTransform requires a control adapter',\n    {\n      domain: 'MIG',\n      why: 'PostgresMigration.dataTransform was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so dataTransform cannot lower its query plan.',\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',\n      meta: {},\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,qCAAyD;CACvE,OAAO,IAAI,mBACT,QACA,8DACA;EACE,QAAQ;EACR,KAAK;EACL,KAAK;EACL,MAAM,CAAC;CACT,CACF;AACF"}

package/dist/errors.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":";;;;;AAqBA;;;;;;;;;;;;;;;;;iBAAgB,kCAAA,CAAA,GAAsC,kBAAA"}
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":";;;;;AAqBA;;;;AAAwE;;;;;;;;;;;;;iBAAxD,kCAAA,CAAA,GAAsC,kBAAkB"}

package/dist/errors.mjs

@@ -1,2 +1,2 @@
-import { t as errorPostgresMigrationStackMissing } from "./errors--zafB5_n.mjs";
+import { t as errorPostgresMigrationStackMissing } from "./errors-BbnITmAD.mjs";
 export { errorPostgresMigrationStackMissing };

package/dist/{issue-planner-Ct9xNqbr.mjs → issue-planner-2RgYsjUJ.mjs}

@@ -1,12 +1,12 @@
 import { t as PostgresEnumType } from "./postgres-enum-type-DS-KLVRH.mjs";
-import { r as readExistingEnumValues, t as determineEnumDiff } from "./enum-planning-Bqp96iIw.mjs";
-import { i as quoteIdentifier } from "./sql-utils-BewXAnsG.mjs";
-import { r as isPostgresSchema } from "./postgres-schema-BL0RAvew.mjs";
-import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-BDtJQ9WD.mjs";
-import { C as SetNotNullCall, S as SetDefaultCall, _ as DropIndexCall, a as AddUniqueCall, b as RawSqlCall, d as CreateTableCall, f as DataTransformCall, g as DropEnumTypeCall, h as DropDefaultCall, i as AddPrimaryKeyCall, l as CreateIndexCall, m as DropConstraintCall, n as AddEnumValuesCall, o as AlterColumnTypeCall, p as DropColumnCall, r as AddForeignKeyCall, s as CreateEnumTypeCall, t as AddColumnCall, u as CreateSchemaCall, v as DropNotNullCall, x as RenameTypeCall, y as DropTableCall } from "./op-factory-call-CB6tPJ3f.mjs";
-import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders--0TmW6Ey.mjs";
-import { n as resolveIdentityValue } from "./planner-identity-values-ojX-6cPV.mjs";
-import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-BGyukuzG.mjs";
+import { i as quoteIdentifier } from "./sql-utils-CggjWNij.mjs";
+import { r as isPostgresSchema } from "./postgres-schema-vp5rvbYg.mjs";
+import { a as readExistingEnumValues, n as determineEnumDiff, s as resolveDdlSchemaForNamespaceStorage } from "./enum-planning-DrNWCtCp.mjs";
+import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-BMu3fiMc.mjs";
+import { C as SetNotNullCall, S as SetDefaultCall, _ as DropIndexCall, a as AddUniqueCall, b as RawSqlCall, d as CreateTableCall, f as DataTransformCall, g as DropEnumTypeCall, h as DropDefaultCall, i as AddPrimaryKeyCall, l as CreateIndexCall, m as DropConstraintCall, n as AddEnumValuesCall, o as AlterColumnTypeCall, p as DropColumnCall, r as AddForeignKeyCall, s as CreateEnumTypeCall, t as AddColumnCall, u as CreateSchemaCall, v as DropNotNullCall, x as RenameTypeCall, y as DropTableCall } from "./op-factory-call-C_K5ibAY.mjs";
+import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-DgyqpFji.mjs";
+import { n as resolveIdentityValue } from "./planner-identity-values-nhVj0hp-.mjs";
+import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-CGxxYfnD.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
@@ -116,29 +116,56 @@ function resolveNamespaceIdForIssue(issue) {
 /**
 * 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.
 */
 function resolveDdlSchemaForNamespace(ctx, namespaceId) {
 	const namespace = ctx.toContract.storage.namespaces[namespaceId];
 	if (isPostgresSchema(namespace)) return namespace.ddlSchemaName(ctx.toContract.storage);
 	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, namespaceId, typeName) {
+	const ns = storage.namespaces[namespaceId];
+	if (!ns || !("enum" in ns) || ns.enum == null) return false;
+	return ns.enum[typeName] !== void 0;
+}
 /**
-* 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 locateNamespaceType(storage, typeName) {
-	for (const ns of Object.values(storage.namespaces)) {
-		if (!("enum" in ns) || ns.enum == null) continue;
-		const entry = ns.enum[typeName];
-		if (entry !== void 0) return entry;
-	}
+function resolveColumnEnumNamespace(storage, columnNamespaceId, typeName) {
+	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, namespaceId, typeName) {
+	const ns = storage.namespaces[namespaceId];
+	if (!ns || !("enum" in ns) || ns.enum == null) return void 0;
+	return ns.enum[typeName];
 }
 function buildColumnSpec(namespaceId, table, column, ctx, overrides) {
 	const col = tableAt(ctx.toContract.storage, namespaceId, table)?.columns[column];
@@ -246,24 +273,25 @@ const nullableTighteningCallStrategy = (issues, ctx) => {
 		recipe: true
 	};
 };
-function enumRebuildCallRecipe(typeName, ctx) {
-	const toType = locateNamespaceType(ctx.toContract.storage, typeName);
+function enumRebuildCallRecipe(namespaceId, typeName, ctx) {
+	const toType = locateNamespaceType(ctx.toContract.storage, namespaceId, typeName);
 	if (!toType) return [];
 	const isEnum = isPostgresEnumStorageEntry(toType);
 	const nativeType = toType.nativeType;
 	const desiredValues = isEnum ? toType.values : toType.typeParams["values"] ?? [];
 	const tempName = `${nativeType}${REBUILD_SUFFIX}`;
+	const ddlSchema = resolveDdlSchemaForNamespaceStorage(ctx.toContract.storage, namespaceId, ctx.schema);
 	const columnRefs = [];
 	for (const [nsId, ns] of Object.entries(ctx.toContract.storage.namespaces)) for (const [tableName, tableNode] of Object.entries(ns.tables)) {
 		const table = tableNode;
-		for (const [columnName, column] of Object.entries(table.columns)) if (column.typeRef === typeName) columnRefs.push({
+		for (const [columnName, column] of Object.entries(table.columns)) if (column.typeRef === typeName && resolveColumnEnumNamespace(ctx.toContract.storage, nsId, typeName) === namespaceId) columnRefs.push({
 			namespaceId: nsId,
 			table: tableName,
 			column: columnName
 		});
 	}
 	return [
-		new CreateEnumTypeCall(ctx.schemaName, tempName, desiredValues),
+		new CreateEnumTypeCall(ddlSchema, tempName, desiredValues),
 		...columnRefs.map((ref) => {
 			const using = `${ref.column}::text::${tempName}`;
 			return new AlterColumnTypeCall(resolveDdlSchemaForNamespace(ctx, ref.namespaceId), ref.table, ref.column, {
@@ -273,8 +301,8 @@ function enumRebuildCallRecipe(typeName, ctx) {
 				using
 			});
 		}),
-		new DropEnumTypeCall(ctx.schemaName, nativeType),
-		new RenameTypeCall(ctx.schemaName, tempName, nativeType)
+		new DropEnumTypeCall(ddlSchema, nativeType),
+		new RenameTypeCall(ddlSchema, tempName, nativeType)
 	];
 }
 /**
@@ -309,42 +337,60 @@ function enumRebuildCallRecipe(typeName, ctx) {
 * 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 = "\0";
+/** Builds the compound map key for a namespace-qualified enum entry. */
+function enumCompoundKey(namespaceId, typeName) {
+	return `${namespaceId}${COMPOUND_KEY_SEP}${typeName}`;
+}
 const nativeEnumPlanCallStrategy = (issues, ctx) => {
 	const enumTypes = collectPostgresEnumTypes(ctx.toContract.storage);
 	if (enumTypes.size === 0) return { kind: "no_match" };
 	const dataAllowed = ctx.policy.allowedOperationClasses.includes("data");
 	const calls = [];
-	const handledTypeNames = /* @__PURE__ */ new Set();
-	const introducedTypeNames = /* @__PURE__ */ new Set();
-	const rebuiltTypeNames = /* @__PURE__ */ new Set();
+	const handledKeys = /* @__PURE__ */ new Set();
+	const introducedKeys = /* @__PURE__ */ new Set();
+	const rebuiltKeys = /* @__PURE__ */ new Set();
 	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);
+		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) calls.push(new DataTransformCall(`migrate-${typeName}-values`, `migrate-${typeName}-values:check`, `migrate-${typeName}-values:run`));
-		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);
 	}
-	if (introducedTypeNames.size > 0 && rebuiltTypeNames.size > 0) 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.`);
-	const remaining = issues.filter((issue) => !((issue.kind === "type_missing" || issue.kind === "enum_values_changed") && issue.typeName && handledTypeNames.has(issue.typeName)));
+	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: [${introducedDisplay}]; rebuilt: [${rebuiltDisplay}]. Split the strategy or grow the \`match\` return type before this case lands.`);
+	}
+	const remaining = issues.filter((issue) => !((issue.kind === "type_missing" || issue.kind === "enum_values_changed") && issue.typeName && handledKeys.has(enumCompoundKey(resolveNamespaceIdForIssue(issue), issue.typeName))));
 	if (calls.length === 0 && remaining.length === issues.length) return { kind: "no_match" };
 	return {
 		kind: "match",
@@ -353,12 +399,20 @@ const nativeEnumPlanCallStrategy = (issues, ctx) => {
 		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) {
 	const result = /* @__PURE__ */ new Map();
-	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;
-		for (const [name, instance] of Object.entries(nsEnums).sort(([a], [b]) => a.localeCompare(b))) if (instance instanceof PostgresEnumType) result.set(name, instance);
+		for (const [name, instance] of Object.entries(nsEnums).sort(([a], [b]) => a.localeCompare(b))) if (instance instanceof PostgresEnumType) result.set(enumCompoundKey(nsId, name), instance);
 	}
 	return result;
 }
@@ -559,12 +613,14 @@ const postgresPlannerStrategies = [
 ];
 //#endregion
 //#region src/core/migrations/issue-planner.ts
-function locateNamespaceTypeInStorage(storage, typeName) {
-	for (const ns of Object.values(storage.namespaces)) {
-		if (!("enum" in ns) || ns.enum == null) continue;
-		const entry = ns.enum[typeName];
-		if (entry !== void 0) return entry;
-	}
+/**
+* Finds a type entry by explicit namespace coordinate. Reads the named
+* namespace's `enum` slot directly — never scans other namespaces.
+*/
+function locateNamespaceTypeInStorage(storage, namespaceId, typeName) {
+	const ns = storage.namespaces[namespaceId];
+	if (!ns || !("enum" in ns) || ns.enum == null) return void 0;
+	return ns.enum[typeName];
 }
 const ISSUE_KIND_ORDER = {
 	missing_schema: 1,
@@ -804,9 +860,10 @@ function mapIssueToCall(issue, ctx) {
 			return notOk(issueConflict("foreignKeyConflict", `Foreign key on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
 		case "type_missing": {
 			if (!issue.typeName) return notOk(issueConflict("unsupportedOperation", "Type missing issue has no typeName"));
-			const typeInstance = ctx.toContract.storage.types?.[issue.typeName] ?? locateNamespaceTypeInStorage(ctx.toContract.storage, issue.typeName);
+			const namespaceId = resolveNamespaceIdForIssue(issue);
+			const typeInstance = ctx.toContract.storage.types?.[issue.typeName] ?? locateNamespaceTypeInStorage(ctx.toContract.storage, namespaceId, issue.typeName);
 			if (!typeInstance) return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" reported missing but not found in destination contract`));
-			if (typeInstance instanceof PostgresEnumType) return ok([new CreateEnumTypeCall(schemaName, issue.typeName, typeInstance.values, typeInstance.nativeType)]);
+			if (typeInstance instanceof PostgresEnumType) return ok([new CreateEnumTypeCall(resolveDdlSchemaForNamespace(ctx, namespaceId), issue.typeName, typeInstance.values, typeInstance.nativeType)]);
 			const codecInstance = typeInstance;
 			return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" uses codec "${codecInstance.codecId}" — only enum types are supported`));
 		}
@@ -976,4 +1033,4 @@ function planIssues(options) {
 //#endregion
 export { postgresPlannerStrategies as n, planIssues as t };
 
-//# sourceMappingURL=issue-planner-Ct9xNqbr.mjs.map
+//# sourceMappingURL=issue-planner-2RgYsjUJ.mjs.map