@prisma-next/target-postgres 0.9.0 → 0.10.0-dev.1

package/dist/{issue-planner-BhWVYyE1.mjs → issue-planner-qalHRCI2.mjs}

@@ -1,12 +1,14 @@
 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 { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-Cd016Ycs.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, v as DropNotNullCall, x as RenameTypeCall, y as DropTableCall } from "./op-factory-call-DerP9BoT.mjs";
-import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-5QIyhBUF.mjs";
-import { n as resolveIdentityValue } from "./planner-identity-values-BUYNOCwb.mjs";
-import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup--u9whY_Y.mjs";
+import { r as isPostgresSchema } from "./postgres-schema-BosNxhWq.mjs";
+import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-BM4sD6Xc.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-Zsrdty3k.mjs";
+import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-DINYrbJ3.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 { ifDefined } from "@prisma-next/utils/defined";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 import { arraysEqual } from "@prisma-next/family-sql/schema-verify";
 import { notOk, ok } from "@prisma-next/utils/result";
@@ -86,8 +88,60 @@ function buildAddNotNullColumnWithTemporaryDefaultOperation(options) {
 //#endregion
 //#region src/core/migrations/planner-strategies.ts
 const REBUILD_SUFFIX = "__prisma_next_new";
-function buildColumnSpec(table, column, ctx, overrides) {
-	const col = ctx.toContract.storage.tables[table]?.columns[column];
+/**
+* Look up a storage table by its explicit namespace coordinate. Returns
+* `undefined` when the namespace has no table by that name (or no such
+* namespace exists). Callers that get `undefined` MUST treat it as an
+* explicit conflict — never silently fall back to a global default
+* schema or a name-only walk, because that footgun would resolve a
+* stale or duplicate table name to whichever namespace the iteration
+* order surfaced first (a real data-loss hazard in multi-namespace
+* contracts where two namespaces can carry the same table name).
+*/
+function tableAt(storage, namespaceId, tableName) {
+	return storage.namespaces[namespaceId]?.tables[tableName];
+}
+/**
+* Default namespace coordinate for an issue that does not carry one
+* explicitly. Hand-crafted unit-test issues and `extra_table` issues
+* fall back to `__unbound__`, the only namespace any single-namespace
+* contract carries — verifier-emitted issues for legacy
+* single-namespace contracts already stamp this id explicitly. Typed
+* structurally so issue variants without a `namespaceId` slot
+* (e.g. `EnumValuesChangedIssue`) flow through to the same fallback.
+*/
+function resolveNamespaceIdForIssue(issue) {
+	return issue.namespaceId ?? UNBOUND_NAMESPACE_ID;
+}
+/**
+* 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.
+*/
+function resolveDdlSchemaForNamespace(ctx, namespaceId) {
+	const namespace = ctx.toContract.storage.namespaces[namespaceId];
+	if (isPostgresSchema(namespace)) return namespace.ddlSchemaName(ctx.toContract.storage);
+	return namespaceId;
+}
+/**
+* Finds a type entry by name across all namespace type registries.
+* Namespace types (e.g. Postgres enums) live under
+* `storage.namespaces[nsId].types`, not under `storage.types`.
+*/
+function locateNamespaceType(storage, typeName) {
+	for (const ns of Object.values(storage.namespaces)) {
+		if (!("types" in ns) || ns.types == null) continue;
+		const entry = ns.types[typeName];
+		if (entry !== void 0) return entry;
+	}
+}
+function buildColumnSpec(namespaceId, table, column, ctx, overrides) {
+	const col = tableAt(ctx.toContract.storage, namespaceId, table)?.columns[column];
 	if (!col) throw new Error(`Column "${table}"."${column}" not found in destination contract`);
 	const mutableHooks = ctx.codecHooks;
 	const mutableTypes = ctx.storageTypes;
@@ -98,8 +152,8 @@ function buildColumnSpec(table, column, ctx, overrides) {
 		nullable: overrides?.nullable ?? col.nullable
 	};
 }
-function buildAlterTypeOptions(table, column, ctx, using) {
-	const col = ctx.toContract.storage.tables[table]?.columns[column];
+function buildAlterTypeOptions(namespaceId, table, column, ctx, using) {
+	const col = tableAt(ctx.toContract.storage, namespaceId, table)?.columns[column];
 	if (!col) throw new Error(`Column "${table}"."${column}" not found in destination contract`);
 	const mutableHooks = ctx.codecHooks;
 	const mutableTypes = ctx.storageTypes;
@@ -117,12 +171,14 @@ const notNullBackfillCallStrategy = (issues, ctx) => {
 	const calls = [];
 	for (const issue of issues) {
 		if (issue.kind !== "missing_column" || !issue.table || !issue.column) continue;
-		const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+		const namespaceId = resolveNamespaceIdForIssue(issue);
+		const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
 		if (!column) continue;
 		if (column.nullable === true || column.default !== void 0) continue;
 		matched.push(issue);
-		const spec = buildColumnSpec(issue.table, issue.column, ctx, { nullable: true });
-		calls.push(new AddColumnCall(ctx.schemaName, issue.table, spec), new DataTransformCall(`backfill-${issue.table}-${issue.column}`, `backfill-${issue.table}-${issue.column}:check`, `backfill-${issue.table}-${issue.column}:run`), new SetNotNullCall(ctx.schemaName, issue.table, issue.column));
+		const spec = buildColumnSpec(namespaceId, issue.table, issue.column, ctx, { nullable: true });
+		const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);
+		calls.push(new AddColumnCall(schemaForTable, issue.table, spec), new DataTransformCall(`backfill-${issue.table}-${issue.column}`, `backfill-${issue.table}-${issue.column}:check`, `backfill-${issue.table}-${issue.column}:run`), new SetNotNullCall(schemaForTable, issue.table, issue.column));
 	}
 	if (matched.length === 0) return { kind: "no_match" };
 	return {
@@ -145,8 +201,9 @@ const typeChangeCallStrategy = (issues, ctx) => {
 	for (const issue of issues) {
 		if (issue.kind !== "type_mismatch") continue;
 		if (!issue.table || !issue.column) continue;
-		const fromColumn = ctx.fromContract?.storage.tables[issue.table]?.columns[issue.column];
-		const toColumn = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+		const namespaceId = resolveNamespaceIdForIssue(issue);
+		const fromColumn = ctx.fromContract ? tableAt(ctx.fromContract.storage, namespaceId, issue.table)?.columns[issue.column] : void 0;
+		const toColumn = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
 		if (!fromColumn || !toColumn) continue;
 		const fromType = fromColumn.nativeType;
 		const toType = toColumn.nativeType;
@@ -154,9 +211,10 @@ const typeChangeCallStrategy = (issues, ctx) => {
 		const isSafeWidening = SAFE_WIDENINGS.has(`${fromType}→${toType}`);
 		if (!isSafeWidening && !dataAllowed) continue;
 		matched.push(issue);
-		const alterOpts = buildAlterTypeOptions(issue.table, issue.column, ctx);
-		if (isSafeWidening) calls.push(new AlterColumnTypeCall(ctx.schemaName, issue.table, issue.column, alterOpts));
-		else calls.push(new DataTransformCall(`typechange-${issue.table}-${issue.column}`, `typechange-${issue.table}-${issue.column}:check`, `typechange-${issue.table}-${issue.column}:run`), new AlterColumnTypeCall(ctx.schemaName, issue.table, issue.column, alterOpts));
+		const alterOpts = buildAlterTypeOptions(namespaceId, issue.table, issue.column, ctx);
+		const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);
+		if (isSafeWidening) calls.push(new AlterColumnTypeCall(schemaForTable, issue.table, issue.column, alterOpts));
+		else calls.push(new DataTransformCall(`typechange-${issue.table}-${issue.column}`, `typechange-${issue.table}-${issue.column}:check`, `typechange-${issue.table}-${issue.column}:run`), new AlterColumnTypeCall(schemaForTable, issue.table, issue.column, alterOpts));
 	}
 	if (matched.length === 0) return { kind: "no_match" };
 	return {
@@ -172,11 +230,13 @@ const nullableTighteningCallStrategy = (issues, ctx) => {
 	const calls = [];
 	for (const issue of issues) {
 		if (issue.kind !== "nullability_mismatch" || !issue.table || !issue.column) continue;
-		const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+		const namespaceId = resolveNamespaceIdForIssue(issue);
+		const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
 		if (!column) continue;
 		if (column.nullable === true) continue;
 		matched.push(issue);
-		calls.push(new DataTransformCall(`handle-nulls-${issue.table}-${issue.column}`, `handle-nulls-${issue.table}-${issue.column}:check`, `handle-nulls-${issue.table}-${issue.column}:run`), new SetNotNullCall(ctx.schemaName, issue.table, issue.column));
+		const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);
+		calls.push(new DataTransformCall(`handle-nulls-${issue.table}-${issue.column}`, `handle-nulls-${issue.table}-${issue.column}:check`, `handle-nulls-${issue.table}-${issue.column}:run`), new SetNotNullCall(schemaForTable, issue.table, issue.column));
 	}
 	if (matched.length === 0) return { kind: "no_match" };
 	return {
@@ -187,22 +247,26 @@ const nullableTighteningCallStrategy = (issues, ctx) => {
 	};
 };
 function enumRebuildCallRecipe(typeName, ctx) {
-	const toType = ctx.toContract.storage.types?.[typeName];
+	const toType = locateNamespaceType(ctx.toContract.storage, 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 columnRefs = [];
-	for (const [tableName, table] of Object.entries(ctx.toContract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) if (column.typeRef === typeName) columnRefs.push({
-		table: tableName,
-		column: columnName
-	});
+	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({
+			namespaceId: nsId,
+			table: tableName,
+			column: columnName
+		});
+	}
 	return [
 		new CreateEnumTypeCall(ctx.schemaName, tempName, desiredValues),
 		...columnRefs.map((ref) => {
 			const using = `${ref.column}::text::${tempName}`;
-			return new AlterColumnTypeCall(ctx.schemaName, ref.table, ref.column, {
+			return new AlterColumnTypeCall(resolveDdlSchemaForNamespace(ctx, ref.namespaceId), ref.table, ref.column, {
 				qualifiedTargetType: tempName,
 				formatTypeExpected: tempName,
 				rawTargetTypeForLabel: tempName,
@@ -246,7 +310,7 @@ function enumRebuildCallRecipe(typeName, ctx) {
 * `CreateTableCall` that references the new enum.
 */
 const nativeEnumPlanCallStrategy = (issues, ctx) => {
-	const enumTypes = collectPostgresEnumTypes(ctx.toContract.storage.types);
+	const enumTypes = collectPostgresEnumTypes(ctx.toContract.storage);
 	if (enumTypes.size === 0) return { kind: "no_match" };
 	const dataAllowed = ctx.policy.allowedOperationClasses.includes("data");
 	const calls = [];
@@ -289,9 +353,13 @@ const nativeEnumPlanCallStrategy = (issues, ctx) => {
 		recipe: emittedRebuildRecipe
 	};
 };
-function collectPostgresEnumTypes(storageTypes) {
+function collectPostgresEnumTypes(storage) {
 	const result = /* @__PURE__ */ new Map();
-	for (const [name, instance] of Object.entries(storageTypes ?? {}).sort(([a], [b]) => a.localeCompare(b))) if (instance instanceof PostgresEnumType) result.set(name, instance);
+	for (const ns of Object.values(storage.namespaces)) {
+		if (!("types" in ns) || ns.types == null) continue;
+		const nsTypes = ns.types;
+		for (const [name, instance] of Object.entries(nsTypes).sort(([a], [b]) => a.localeCompare(b))) if (instance instanceof PostgresEnumType) result.set(name, instance);
+	}
 	return result;
 }
 /**
@@ -362,7 +430,8 @@ const notNullAddColumnCallStrategy = (issues, ctx) => {
 	const mutableStorageTypes = ctx.storageTypes;
 	for (const issue of issues) {
 		if (issue.kind !== "missing_column" || !issue.table || !issue.column) continue;
-		const contractTable = ctx.toContract.storage.tables[issue.table];
+		const namespaceId = resolveNamespaceIdForIssue(issue);
+		const contractTable = tableAt(ctx.toContract.storage, namespaceId, issue.table);
 		const column = contractTable?.columns[issue.column];
 		if (!column) continue;
 		const notNull = column.nullable !== true;
@@ -379,9 +448,10 @@ const notNullAddColumnCallStrategy = (issues, ctx) => {
 			columnName: issue.column
 		});
 		matched.push(issue);
+		const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);
 		if (canUseSharedTempDefault && temporaryDefault !== null) {
 			calls.push(new RawSqlCall(buildAddNotNullColumnWithTemporaryDefaultOperation({
-				schema: ctx.schemaName,
+				schema: schemaForTable,
 				tableName: issue.table,
 				columnName: issue.column,
 				column,
@@ -391,14 +461,14 @@ const notNullAddColumnCallStrategy = (issues, ctx) => {
 			})));
 			continue;
 		}
-		const qualified = qualifyTableName(ctx.schemaName, issue.table);
+		const qualified = qualifyTableName(schemaForTable, issue.table);
 		calls.push(new RawSqlCall({
-			...buildAddColumnOperationIdentity(ctx.schemaName, issue.table, issue.column),
+			...buildAddColumnOperationIdentity(schemaForTable, issue.table, issue.column),
 			operationClass: "additive",
 			precheck: [{
 				description: `ensure column "${issue.column}" is missing`,
 				sql: columnExistsCheck({
-					schema: ctx.schemaName,
+					schema: schemaForTable,
 					table: issue.table,
 					column: issue.column,
 					exists: false
@@ -414,14 +484,14 @@ const notNullAddColumnCallStrategy = (issues, ctx) => {
 			postcheck: [{
 				description: `verify column "${issue.column}" exists`,
 				sql: columnExistsCheck({
-					schema: ctx.schemaName,
+					schema: schemaForTable,
 					table: issue.table,
 					column: issue.column
 				})
 			}, {
 				description: `verify column "${issue.column}" is NOT NULL`,
 				sql: columnNullabilityCheck({
-					schema: ctx.schemaName,
+					schema: schemaForTable,
 					table: issue.table,
 					column: issue.column,
 					nullable: false
@@ -444,7 +514,7 @@ function canUseSharedTemporaryDefaultStrategy(options) {
 		if (!schemaLookup || !hasUniqueConstraint(schemaLookup, unique.columns)) return false;
 	}
 	for (const foreignKey of table.foreignKeys) {
-		if (foreignKey.constraint === false || !foreignKey.columns.includes(columnName)) continue;
+		if (foreignKey.constraint === false || !foreignKey.source.columns.includes(columnName)) continue;
 		if (!schemaLookup || !hasForeignKey(schemaLookup, foreignKey)) return false;
 	}
 	return true;
@@ -489,7 +559,15 @@ const postgresPlannerStrategies = [
 ];
 //#endregion
 //#region src/core/migrations/issue-planner.ts
+function locateNamespaceTypeInStorage(storage, typeName) {
+	for (const ns of Object.values(storage.namespaces)) {
+		if (!("types" in ns) || ns.types == null) continue;
+		const entry = ns.types[typeName];
+		if (entry !== void 0) return entry;
+	}
+}
 const ISSUE_KIND_ORDER = {
+	missing_schema: 1,
 	type_missing: 2,
 	type_values_mismatch: 3,
 	enum_values_changed: 3,
@@ -536,79 +614,94 @@ function toColumnSpec(name, column, codecHooks, storageTypes) {
 }
 function mapIssueToCall(issue, ctx) {
 	const { schemaName, codecHooks, storageTypes } = ctx;
+	const tableSchema = (issue) => {
+		if (issue.kind === "extra_table") return schemaName;
+		if (!("table" in issue) || !issue.table) return schemaName;
+		return resolveDdlSchemaForNamespace(ctx, resolveNamespaceIdForIssue(issue));
+	};
 	switch (issue.kind) {
+		case "missing_schema": {
+			const namespaceId = issue.namespaceId;
+			if (!namespaceId) return notOk(issueConflict("unsupportedOperation", "Missing schema issue has no namespaceId"));
+			return ok([new CreateSchemaCall(resolveDdlSchemaForNamespace(ctx, namespaceId))]);
+		}
 		case "missing_table": {
 			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Missing table issue has no table name"));
-			const contractTable = ctx.toContract.storage.tables[issue.table];
-			if (!contractTable) return notOk(issueConflict("unsupportedOperation", `Table "${issue.table}" reported missing but not found in destination contract`));
+			const namespaceId = resolveNamespaceIdForIssue(issue);
+			const contractTable = tableAt(ctx.toContract.storage, namespaceId, issue.table);
+			if (!contractTable) return notOk(issueConflict("unsupportedOperation", `Table "${issue.table}" in namespace "${namespaceId}" reported missing but not found in destination contract`));
+			const schemaForTable = tableSchema(issue);
 			const columns = Object.entries(contractTable.columns).map(([name, column]) => toColumnSpec(name, column, codecHooks, storageTypes));
 			const primaryKey = contractTable.primaryKey ? { columns: contractTable.primaryKey.columns } : void 0;
-			const calls = [new CreateTableCall(schemaName, issue.table, columns, primaryKey)];
+			const calls = [new CreateTableCall(schemaForTable, issue.table, columns, primaryKey)];
 			for (const index of contractTable.indexes) {
 				const indexName = index.name ?? `${issue.table}_${index.columns.join("_")}_idx`;
 				const extras = {};
 				if (index.type !== void 0) extras.type = index.type;
 				if (index.options !== void 0) extras.options = index.options;
-				calls.push(new CreateIndexCall(schemaName, issue.table, indexName, [...index.columns], extras));
+				calls.push(new CreateIndexCall(schemaForTable, issue.table, indexName, [...index.columns], extras));
 			}
 			const explicitIndexColumnSets = new Set(contractTable.indexes.map((idx) => idx.columns.join(",")));
 			for (const fk of contractTable.foreignKeys) {
 				if (fk.constraint) {
 					const fkSpec = {
-						name: fk.name ?? `${issue.table}_${fk.columns.join("_")}_fkey`,
-						columns: fk.columns,
+						name: fk.name ?? `${issue.table}_${fk.source.columns.join("_")}_fkey`,
+						columns: fk.source.columns,
 						references: {
-							table: fk.references.table,
-							columns: fk.references.columns
+							schema: fk.target.namespaceId,
+							table: fk.target.tableName,
+							columns: fk.target.columns
 						},
 						...fk.onDelete !== void 0 && { onDelete: fk.onDelete },
 						...fk.onUpdate !== void 0 && { onUpdate: fk.onUpdate }
 					};
-					calls.push(new AddForeignKeyCall(schemaName, issue.table, fkSpec));
+					calls.push(new AddForeignKeyCall(schemaForTable, issue.table, fkSpec));
 				}
-				if (fk.index && !explicitIndexColumnSets.has(fk.columns.join(","))) {
-					const indexName = `${issue.table}_${fk.columns.join("_")}_idx`;
-					calls.push(new CreateIndexCall(schemaName, issue.table, indexName, [...fk.columns]));
+				if (fk.index && !explicitIndexColumnSets.has(fk.source.columns.join(","))) {
+					const indexName = `${issue.table}_${fk.source.columns.join("_")}_idx`;
+					calls.push(new CreateIndexCall(schemaForTable, issue.table, indexName, [...fk.source.columns]));
 				}
 			}
 			for (const unique of contractTable.uniques) {
 				const constraintName = unique.name ?? `${issue.table}_${unique.columns.join("_")}_key`;
-				calls.push(new AddUniqueCall(schemaName, issue.table, constraintName, [...unique.columns]));
+				calls.push(new AddUniqueCall(schemaForTable, issue.table, constraintName, [...unique.columns]));
 			}
 			return ok(calls);
 		}
 		case "missing_column":
 			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Missing column issue has no table/column name"));
 			{
-				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+				const namespaceId = resolveNamespaceIdForIssue(issue);
+				const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
 				if (!column) return notOk(issueConflict("unsupportedOperation", `Column "${issue.table}"."${issue.column}" not in destination contract`));
-				return ok([new AddColumnCall(schemaName, issue.table, toColumnSpec(issue.column, column, codecHooks, storageTypes))]);
+				return ok([new AddColumnCall(tableSchema(issue), issue.table, toColumnSpec(issue.column, column, codecHooks, storageTypes))]);
 			}
 		case "default_missing":
 			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Default missing issue has no table/column name"));
 			{
-				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+				const namespaceId = resolveNamespaceIdForIssue(issue);
+				const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
 				if (!column?.default) return notOk(issueConflict("unsupportedOperation", `Column "${issue.table}"."${issue.column}" has no default in contract`));
 				const defaultSql = buildColumnDefaultSql(column.default, column);
 				if (!defaultSql) return ok([]);
-				return ok([new SetDefaultCall(schemaName, issue.table, issue.column, defaultSql)]);
+				return ok([new SetDefaultCall(tableSchema(issue), issue.table, issue.column, defaultSql)]);
 			}
 		case "extra_table":
 			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Extra table issue has no table name"));
-			return ok([new DropTableCall(schemaName, issue.table)]);
+			return ok([new DropTableCall(tableSchema(issue), issue.table)]);
 		case "extra_column":
 			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Extra column issue has no table/column name"));
-			return ok([new DropColumnCall(schemaName, issue.table, issue.column)]);
+			return ok([new DropColumnCall(tableSchema(issue), issue.table, issue.column)]);
 		case "extra_index":
 			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Extra index issue has no table/index name"));
-			return ok([new DropIndexCall(schemaName, issue.table, issue.indexOrConstraint)]);
+			return ok([new DropIndexCall(tableSchema(issue), issue.table, issue.indexOrConstraint)]);
 		case "extra_unique_constraint":
 		case "extra_foreign_key":
 		case "extra_primary_key": {
 			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Extra constraint issue has no table/constraint name"));
 			const constraintName = issue.indexOrConstraint ?? (issue.kind === "extra_primary_key" ? `${issue.table}_pkey` : void 0);
 			if (!constraintName) return notOk(issueConflict("unsupportedOperation", "Extra constraint issue has no table/constraint name"));
-			return ok([new DropConstraintCall(schemaName, issue.table, constraintName, {
+			return ok([new DropConstraintCall(tableSchema(issue), issue.table, constraintName, {
 				extra_unique_constraint: "unique",
 				extra_foreign_key: "foreignKey",
 				extra_primary_key: "primaryKey"
@@ -616,23 +709,26 @@ function mapIssueToCall(issue, ctx) {
 		}
 		case "extra_default":
 			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Extra default issue has no table/column name"));
-			return ok([new DropDefaultCall(schemaName, issue.table, issue.column)]);
+			return ok([new DropDefaultCall(tableSchema(issue), issue.table, issue.column)]);
 		case "nullability_mismatch": {
 			if (!issue.table || !issue.column) return notOk(issueConflict("nullabilityConflict", "Nullability mismatch has no table/column name"));
-			const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+			const namespaceId = resolveNamespaceIdForIssue(issue);
+			const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
 			if (!column) return notOk(issueConflict("nullabilityConflict", `Column "${issue.table}"."${issue.column}" not found in destination contract`));
-			return ok(column.nullable ? [new DropNotNullCall(schemaName, issue.table, issue.column)] : [new SetNotNullCall(schemaName, issue.table, issue.column)]);
+			const schemaForTable = tableSchema(issue);
+			return ok(column.nullable ? [new DropNotNullCall(schemaForTable, issue.table, issue.column)] : [new SetNotNullCall(schemaForTable, issue.table, issue.column)]);
 		}
 		case "type_mismatch":
 			if (!issue.table || !issue.column) return notOk(issueConflict("typeMismatch", "Type mismatch has no table/column name"));
 			{
-				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+				const namespaceId = resolveNamespaceIdForIssue(issue);
+				const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
 				if (!column) return notOk(issueConflict("typeMismatch", `Column "${issue.table}"."${issue.column}" not in destination contract`));
 				const hooksMap = codecHooks;
 				const typesMap = storageTypes;
 				const qualifiedTargetType = buildColumnTypeSql(column, hooksMap, typesMap, false);
 				const formatTypeExpected = buildExpectedFormatType(column, hooksMap, typesMap);
-				return ok([new AlterColumnTypeCall(schemaName, issue.table, issue.column, {
+				return ok([new AlterColumnTypeCall(tableSchema(issue), issue.table, issue.column, {
 					qualifiedTargetType,
 					formatTypeExpected,
 					rawTargetTypeForLabel: qualifiedTargetType
@@ -641,19 +737,21 @@ function mapIssueToCall(issue, ctx) {
 		case "default_mismatch":
 			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Default mismatch has no table/column name"));
 			{
-				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+				const namespaceId = resolveNamespaceIdForIssue(issue);
+				const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
 				if (!column?.default) return ok([]);
 				const defaultSql = buildColumnDefaultSql(column.default, column);
 				if (!defaultSql) return ok([]);
-				return ok([new SetDefaultCall(schemaName, issue.table, issue.column, defaultSql, "widening")]);
+				return ok([new SetDefaultCall(tableSchema(issue), issue.table, issue.column, defaultSql, "widening")]);
 			}
 		case "primary_key_mismatch":
 			if (!issue.table) return notOk(issueConflict("indexIncompatible", "Primary key issue has no table name"));
 			if (isMissing(issue)) {
-				const pk = ctx.toContract.storage.tables[issue.table]?.primaryKey;
+				const namespaceId = resolveNamespaceIdForIssue(issue);
+				const pk = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.primaryKey;
 				if (!pk) return notOk(issueConflict("indexIncompatible", `No primary key in contract for "${issue.table}"`));
 				const constraintName = pk.name ?? `${issue.table}_pkey`;
-				return ok([new AddPrimaryKeyCall(schemaName, issue.table, constraintName, pk.columns)]);
+				return ok([new AddPrimaryKeyCall(tableSchema(issue), issue.table, constraintName, pk.columns)]);
 			}
 			return notOk(issueConflict("indexIncompatible", `Primary key on "${issue.table}" has different columns (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
 		case "unique_constraint_mismatch":
@@ -661,19 +759,20 @@ function mapIssueToCall(issue, ctx) {
 			if (isMissing(issue) && issue.expected) {
 				const columns = issue.expected.split(", ");
 				const constraintName = `${issue.table}_${columns.join("_")}_key`;
-				return ok([new AddUniqueCall(schemaName, issue.table, constraintName, columns)]);
+				return ok([new AddUniqueCall(tableSchema(issue), issue.table, constraintName, columns)]);
 			}
 			return notOk(issueConflict("indexIncompatible", `Unique constraint on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
 		case "index_mismatch":
 			if (!issue.table) return notOk(issueConflict("indexIncompatible", "Index issue has no table name"));
 			if (isMissing(issue) && issue.expected) {
+				const namespaceId = resolveNamespaceIdForIssue(issue);
 				const columns = issue.expected.split(", ");
-				const contractIndex = ctx.toContract.storage.tables[issue.table]?.indexes.find((idx) => arraysEqual(idx.columns, columns));
+				const contractIndex = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.indexes.find((idx) => arraysEqual(idx.columns, columns));
 				const indexName = contractIndex?.name ?? `${issue.table}_${columns.join("_")}_idx`;
 				const extras = {};
 				if (contractIndex?.type !== void 0) extras.type = contractIndex.type;
 				if (contractIndex?.options !== void 0) extras.options = contractIndex.options;
-				return ok([new CreateIndexCall(schemaName, issue.table, indexName, columns, extras)]);
+				return ok([new CreateIndexCall(tableSchema(issue), issue.table, indexName, columns, extras)]);
 			}
 			return notOk(issueConflict("indexIncompatible", `Index on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
 		case "foreign_key_mismatch":
@@ -681,21 +780,23 @@ function mapIssueToCall(issue, ctx) {
 			if (isMissing(issue) && issue.expected) {
 				const arrowIdx = issue.expected.indexOf(" -> ");
 				if (arrowIdx >= 0) {
+					const namespaceId = resolveNamespaceIdForIssue(issue);
 					const columns = issue.expected.slice(0, arrowIdx).split(", ");
 					const fkName = `${issue.table}_${columns.join("_")}_fkey`;
-					const fk = ctx.toContract.storage.tables[issue.table]?.foreignKeys.find((k) => k.columns.join(", ") === columns.join(", "));
+					const fk = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.foreignKeys.find((k) => k.source.columns.join(", ") === columns.join(", "));
 					if (fk) {
 						const fkSpec = {
 							name: fkName,
-							columns: fk.columns,
+							columns: fk.source.columns,
 							references: {
-								table: fk.references.table,
-								columns: fk.references.columns
+								schema: fk.target.namespaceId,
+								table: fk.target.tableName,
+								columns: fk.target.columns
 							},
 							...fk.onDelete !== void 0 && { onDelete: fk.onDelete },
 							...fk.onUpdate !== void 0 && { onUpdate: fk.onUpdate }
 						};
-						return ok([new AddForeignKeyCall(schemaName, issue.table, fkSpec)]);
+						return ok([new AddForeignKeyCall(tableSchema(issue), issue.table, fkSpec)]);
 					}
 					return notOk(issueConflict("foreignKeyConflict", `Foreign key on "${issue.table}" (${columns.join(", ")}) not found in destination contract`, { table: issue.table }));
 				}
@@ -703,10 +804,11 @@ 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];
+			const typeInstance = ctx.toContract.storage.types?.[issue.typeName] ?? locateNamespaceTypeInStorage(ctx.toContract.storage, 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)]);
-			return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" uses codec "${typeInstance.codecId}" — only enum types are supported`));
+			const codecInstance = typeInstance;
+			return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" uses codec "${codecInstance.codecId}" — only enum types are supported`));
 		}
 		case "type_values_mismatch": return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName ?? "unknown"}" values differ — type alteration not yet supported`));
 		default: return notOk(issueConflict("unsupportedOperation", `Unhandled issue kind: ${issue.kind}`));
@@ -874,4 +976,4 @@ function planIssues(options) {
 //#endregion
 export { postgresPlannerStrategies as n, planIssues as t };
 
-//# sourceMappingURL=issue-planner-BhWVYyE1.mjs.map
+//# sourceMappingURL=issue-planner-qalHRCI2.mjs.map