@prisma-next/target-postgres 0.13.0 → 0.14.0-dev.2

package/dist/{issue-planner-Br0pt1Ea.mjs → issue-planner-DL6g3CmE.mjs}

@@ -1,96 +1,20 @@
-import { t as PostgresEnumType } from "./postgres-enum-type-DPKqCBem.mjs";
-import { i as quoteIdentifier } from "./sql-utils-DcfMz4MQ.mjs";
-import { r as isPostgresSchema } from "./postgres-schema-BuxCxbvB.mjs";
-import { a as readExistingEnumValues, n as determineEnumDiff, s as resolveDdlSchemaForNamespaceStorage } from "./enum-planning-BCyvlFHk.mjs";
-import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-DAdhnI2c.mjs";
-import { C as RenameTypeCall, E as postgresDefaultToDdlColumnDefault, S as RawSqlCall, T as SetNotNullCall, _ as DropDefaultCall, a as AddPrimaryKeyCall, b as DropNotNullCall, c as CreateEnumTypeCall, d as CreateSchemaCall, f as CreateTableCall, g as DropConstraintCall, h as DropColumnCall, i as AddForeignKeyCall, m as DropCheckConstraintCall, n as AddColumnCall, o as AddUniqueCall, p as DataTransformCall, r as AddEnumValuesCall, s as AlterColumnTypeCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropEnumTypeCall, w as SetDefaultCall, x as DropTableCall, y as DropIndexCall } from "./op-factory-call-D2aAUhmS.mjs";
-import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-Cw2n2llW.mjs";
-import { n as resolveIdentityValue } from "./planner-identity-values-BIpa5p2I.mjs";
+import { r as isPostgresSchema } from "./postgres-schema-COGZ1ark.mjs";
+import { t as resolveColumnTypeMetadata } from "./planner-type-resolution-Bt2f_q-F.mjs";
+import { n as qualifyTableName, t as buildExpectedFormatType } from "./planner-sql-checks-jqUUGyQR.mjs";
+import { C as SetNotNullCall, S as SetDefaultCall, T as buildTargetDetails, _ as DropDefaultCall, a as AddNotNullColumnWithTempDefaultCall, b as DropTableCall, c as AlterColumnTypeCall, d as CreateSchemaCall, f as CreateTableCall, g as DropConstraintCall, h as DropColumnCall, i as AddNotNullColumnDirectCall, m as DropCheckConstraintCall, n as AddColumnCall, o as AddPrimaryKeyCall, p as DataTransformCall, r as AddForeignKeyCall, s as AddUniqueCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropIndexCall, w as postgresDefaultToDdlColumnDefault, x as RawSqlCall, y as DropNotNullCall } from "./op-factory-call-D_p5vxwt.mjs";
+import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-B2wOwLqI.mjs";
+import { n as resolveIdentityValue } from "./planner-identity-values-CJPha2Sz.mjs";
 import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-CiVaAQP-.mjs";
+import { blindCast } from "@prisma-next/utils/casts";
 import { resolveValueSetValues } from "@prisma-next/family-sql/control";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { StorageTable, isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 import { arraysEqual } from "@prisma-next/family-sql/schema-verify";
-import { blindCast } from "@prisma-next/utils/casts";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import * as contractFree from "@prisma-next/sql-relational-core/contract-free";
+import { col } from "@prisma-next/sql-relational-core/contract-free";
 import { notOk, ok } from "@prisma-next/utils/result";
-//#region src/core/migrations/planner-target-details.ts
-function buildTargetDetails(objectType, name, schema, table) {
-	return {
-		schema,
-		objectType,
-		name,
-		...ifDefined("table", table)
-	};
-}
-//#endregion
-//#region src/core/migrations/planner-recipes.ts
-function buildAddColumnOperationIdentity(schema, tableName, columnName) {
-	return {
-		id: `column.${tableName}.${columnName}`,
-		label: `Add column ${columnName} to ${tableName}`,
-		summary: `Adds column ${columnName} to table ${tableName}`,
-		target: {
-			id: "postgres",
-			details: buildTargetDetails("table", tableName, schema)
-		}
-	};
-}
-function buildAddNotNullColumnWithTemporaryDefaultOperation(options) {
-	const { schema, tableName, columnName, column, codecHooks, storageTypes, temporaryDefault } = options;
-	const qualified = qualifyTableName(schema, tableName);
-	return {
-		...buildAddColumnOperationIdentity(schema, tableName, columnName),
-		operationClass: "additive",
-		precheck: [{
-			description: `ensure column "${columnName}" is missing`,
-			sql: columnExistsCheck({
-				schema,
-				table: tableName,
-				column: columnName,
-				exists: false
-			})
-		}],
-		execute: [{
-			description: `add column "${columnName}"`,
-			sql: buildAddColumnSql(qualified, columnName, column, codecHooks, temporaryDefault, storageTypes)
-		}, {
-			description: `drop temporary default from column "${columnName}"`,
-			sql: `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`
-		}],
-		postcheck: [
-			{
-				description: `verify column "${columnName}" exists`,
-				sql: columnExistsCheck({
-					schema,
-					table: tableName,
-					column: columnName
-				})
-			},
-			{
-				description: `verify column "${columnName}" is NOT NULL`,
-				sql: columnNullabilityCheck({
-					schema,
-					table: tableName,
-					column: columnName,
-					nullable: false
-				})
-			},
-			{
-				description: `verify column "${columnName}" has no default after temporary default removal`,
-				sql: columnHasNoDefaultCheck({
-					schema,
-					table: tableName,
-					column: columnName
-				})
-			}
-		]
-	};
-}
-//#endregion
+import { StorageTable } from "@prisma-next/sql-contract/types";
 //#region src/core/migrations/planner-strategies.ts
-const REBUILD_SUFFIX = "__prisma_next_new";
 /**
 * Look up a storage table by its explicit namespace coordinate. Returns
 * `undefined` when the namespace has no table by that name (or no such
@@ -102,7 +26,9 @@ const REBUILD_SUFFIX = "__prisma_next_new";
 * contracts where two namespaces can carry the same table name).
 */
 function tableAt(storage, namespaceId, tableName) {
-	return storage.namespaces[namespaceId]?.entries.table[tableName];
+	const ns = storage.namespaces[namespaceId];
+	if (ns === void 0) return void 0;
+	return ns.entries.table?.[tableName];
 }
 /**
 * Default namespace coordinate for an issue that does not carry one
@@ -131,57 +57,24 @@ function resolveDdlSchemaForNamespace(ctx, 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 (!isPostgresSchema(ns)) return false;
-	return ns.entries.type[typeName] !== void 0;
-}
-/**
-* 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, 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].entries.type`. 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 raw = storage.namespaces[namespaceId]?.entries["type"]?.[typeName];
-	if (raw === void 0) return void 0;
-	return blindCast(raw);
-}
 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 storageCol = tableAt(ctx.toContract.storage, namespaceId, table)?.columns[column];
+	if (!storageCol) throw new Error(`Column "${table}"."${column}" not found in destination contract`);
 	const mutableHooks = ctx.codecHooks;
 	const mutableTypes = ctx.storageTypes;
-	return {
-		name: column,
-		typeSql: buildColumnTypeSql(col, mutableHooks, mutableTypes),
-		defaultSql: buildColumnDefaultSql(col.default, col),
-		columnDefault: col.default,
-		nullable: overrides?.nullable ?? col.nullable
-	};
+	const typeSql = buildColumnTypeSql(storageCol, mutableHooks, mutableTypes);
+	const ddlDefault = postgresDefaultToDdlColumnDefault(storageCol.default);
+	const resolved = resolveColumnTypeMetadata(storageCol, mutableTypes);
+	const typeParams = resolved.typeParams === void 0 ? void 0 : blindCast(resolved.typeParams);
+	const codecRef = resolved.codecId ? {
+		codecId: resolved.codecId,
+		...ifDefined("typeParams", typeParams)
+	} : void 0;
+	return col(column, typeSql, {
+		...!(overrides?.nullable ?? storageCol.nullable) ? { notNull: true } : {},
+		...ifDefined("default", ddlDefault),
+		...ifDefined("codecRef", codecRef)
+	});
 }
 function buildAlterTypeOptions(namespaceId, table, column, ctx, using) {
 	const col = tableAt(ctx.toContract.storage, namespaceId, table)?.columns[column];
@@ -277,154 +170,13 @@ const nullableTighteningCallStrategy = (issues, ctx) => {
 		recipe: true
 	};
 };
-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.entries.table)) {
-		const table = tableNode;
-		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(ddlSchema, tempName, desiredValues),
-		...columnRefs.map((ref) => {
-			const using = `${ref.column}::text::${tempName}`;
-			return new AlterColumnTypeCall(resolveDdlSchemaForNamespace(ctx, ref.namespaceId), ref.table, ref.column, {
-				qualifiedTargetType: tempName,
-				formatTypeExpected: tempName,
-				rawTargetTypeForLabel: tempName,
-				using
-			});
-		}),
-		new DropEnumTypeCall(ddlSchema, nativeType),
-		new RenameTypeCall(ddlSchema, tempName, nativeType)
-	];
-}
-/**
-* Single planner strategy for `PostgresEnumType` instances. Walks
-* `toContract.storage.types` directly (no codec-hook dispatch) and
-* resolves existing values via `readExistingEnumValues`, the same
-* Postgres bridging adapter the verifier uses.
-*
-* Per-enum dispatch:
-*
-* - No existing type → `CreateEnumTypeCall` with the contract's desired
-*   values.
-* - Diff is `unchanged` → no calls emitted (consumes the matching
-*   `enum_values_changed` issue if present).
-* - Diff is `add_values` → `AddEnumValuesCall` with the new labels.
-* - Diff is `rebuild` → the create-temp / migrate-columns /
-*   drop-original / rename rebuild recipe. When
-*   `policy.allowedOperationClasses` includes `'data'` and the rebuild
-*   removes labels (`removedValues.length > 0`), prepend a
-*   `DataTransformCall` placeholder so the user can author the value
-*   remap before the destructive recipe runs. Without `'data'` in the
-*   policy (`db update` / `db init`), the rebuild's PG `USING ::text`
-*   cast surfaces any value-removal data loss as a runtime error rather
-*   than silent loss.
-*
-* Returns `recipe: true` only when a rebuild recipe was emitted (its
-* `createEnumType(temp) → alterColumnType → dropEnumType(orig) →
-* renameType` sequence mixes `dep`-class and `alter`-class calls that
-* would mis-order if the planner hoisted them into its DDL sequencing
-* buckets). For the create-only and add-values paths the strategy
-* returns `recipe: false` so the planner hoists `CreateEnumTypeCall`
-* 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 handledKeys = /* @__PURE__ */ new Set();
-	const introducedKeys = /* @__PURE__ */ new Set();
-	const rebuiltKeys = /* @__PURE__ */ new Set();
-	let emittedRebuildRecipe = false;
-	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 ddlSchema = resolveDdlSchemaForNamespaceStorage(ctx.toContract.storage, enumNamespaceId, ctx.schema);
-		const existing = readExistingEnumValues(ctx.schema, ddlSchema, enumType.nativeType);
-		if (!existing) {
-			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") {
-			handledKeys.add(key);
-			continue;
-		}
-		if (diff.kind === "add_values") {
-			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(enumNamespaceId, typeName, ctx));
-		emittedRebuildRecipe = true;
-		handledKeys.add(key);
-		rebuiltKeys.add(key);
-	}
-	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",
-		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) {
-	const result = /* @__PURE__ */ new Map();
-	for (const [nsId, ns] of Object.entries(storage.namespaces)) {
-		if (!isPostgresSchema(ns)) continue;
-		for (const [name, instance] of Object.entries(ns.entries.type).sort(([a], [b]) => a.localeCompare(b))) if (instance instanceof PostgresEnumType) result.set(enumCompoundKey(nsId, name), instance);
-	}
-	return result;
-}
 /**
 * Collects every check constraint from a table in the contract storage.
 * Returns an empty array when the table has no checks or the table is absent.
 */
 function collectContractChecks(storage, namespaceId, tableName) {
-	const tableRaw = storage.namespaces[namespaceId]?.entries.table[tableName];
+	const ns = storage.namespaces[namespaceId];
+	const tableRaw = ns !== void 0 ? ns.entries.table?.[tableName] : void 0;
 	if (!(tableRaw instanceof StorageTable)) return [];
 	const checks = tableRaw.checks;
 	if (!checks || checks.length === 0) return [];
@@ -456,13 +208,11 @@ function checkValueSetsEqual(a, b) {
 *   be altered in place).
 *
 * Consumes `check_missing`, `check_removed`, and `check_mismatch` issues.
-* Does not touch the native enum path (`nativeEnumPlanCallStrategy` is
-* unchanged).
 */
 const checkConstraintPlanCallStrategy = (issues, ctx) => {
 	const calls = [];
 	const handledIssueKeys = /* @__PURE__ */ new Set();
-	for (const [namespaceId, ns] of Object.entries(ctx.toContract.storage.namespaces)) for (const tableName of Object.keys(ns.entries.table)) {
+	for (const [namespaceId, ns] of Object.entries(ctx.toContract.storage.namespaces)) for (const tableName of Object.keys(ns.entries.table ?? {})) {
 		const contractChecks = collectContractChecks(ctx.toContract.storage, namespaceId, tableName);
 		if (contractChecks.length === 0) continue;
 		const liveChecks = ctx.schema.tables[tableName]?.checks ?? [];
@@ -497,10 +247,9 @@ const checkConstraintPlanCallStrategy = (issues, ctx) => {
 	};
 };
 /**
-* Dispatches non-enum codec-typed storage types through their codec's
+* Dispatches codec-typed storage types through their codec's
 * `planTypeOperations` hook (the authoritative source for codec-driven DDL
-* such as custom type creation). Enum dispatch lives in
-* `nativeEnumPlanCallStrategy` and no longer relies on codec hooks.
+* such as custom type creation).
 */
 const storageTypePlanCallStrategy = (issues, ctx) => {
 	const storageTypes = ctx.toContract.storage.types ?? {};
@@ -508,7 +257,6 @@ const storageTypePlanCallStrategy = (issues, ctx) => {
 	const calls = [];
 	const handledTypeNames = /* @__PURE__ */ new Set();
 	for (const [typeName, typeInstance] of Object.entries(storageTypes).sort(([a], [b]) => a.localeCompare(b))) {
-		if (isPostgresEnumStorageEntry(typeInstance)) continue;
 		const codecInstance = typeInstance;
 		const hook = ctx.codecHooks.get(codecInstance.codecId);
 		if (!hook?.planTypeOperations) continue;
@@ -584,54 +332,19 @@ const notNullAddColumnCallStrategy = (issues, ctx) => {
 		matched.push(issue);
 		const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);
 		if (canUseSharedTempDefault && temporaryDefault !== null) {
-			calls.push(new RawSqlCall(buildAddNotNullColumnWithTemporaryDefaultOperation({
-				schema: schemaForTable,
+			calls.push(new AddNotNullColumnWithTempDefaultCall({
+				schemaName: schemaForTable,
 				tableName: issue.table,
 				columnName: issue.column,
 				column,
 				codecHooks: mutableCodecHooks,
 				storageTypes: mutableStorageTypes,
 				temporaryDefault
-			})));
+			}));
 			continue;
 		}
 		const qualified = qualifyTableName(schemaForTable, issue.table);
-		calls.push(new RawSqlCall({
-			...buildAddColumnOperationIdentity(schemaForTable, issue.table, issue.column),
-			operationClass: "additive",
-			precheck: [{
-				description: `ensure column "${issue.column}" is missing`,
-				sql: columnExistsCheck({
-					schema: schemaForTable,
-					table: issue.table,
-					column: issue.column,
-					exists: false
-				})
-			}, {
-				description: `ensure table "${issue.table}" is empty before adding NOT NULL column without default`,
-				sql: tableIsEmptyCheck(qualified)
-			}],
-			execute: [{
-				description: `add column "${issue.column}"`,
-				sql: buildAddColumnSql(qualified, issue.column, column, mutableCodecHooks, void 0, mutableStorageTypes)
-			}],
-			postcheck: [{
-				description: `verify column "${issue.column}" exists`,
-				sql: columnExistsCheck({
-					schema: schemaForTable,
-					table: issue.table,
-					column: issue.column
-				})
-			}, {
-				description: `verify column "${issue.column}" is NOT NULL`,
-				sql: columnNullabilityCheck({
-					schema: schemaForTable,
-					table: issue.table,
-					column: issue.column,
-					nullable: false
-				})
-			}]
-		}));
+		calls.push(new AddNotNullColumnDirectCall(schemaForTable, issue.table, issue.column, buildAddColumnSql(qualified, issue.column, column, mutableCodecHooks, void 0, mutableStorageTypes)));
 	}
 	if (matched.length === 0) return { kind: "no_match" };
 	return {
@@ -662,8 +375,7 @@ function canUseSharedTemporaryDefaultStrategy(options) {
 *
 * - When `'data'` is allowed (`migration plan`), the data-safe strategies
 *   (`notNullBackfillCallStrategy`, `typeChangeCallStrategy`,
-*   `nullableTighteningCallStrategy`) and the enum walk
-*   (`nativeEnumPlanCallStrategy`) consume their matching issues and emit
+*   `nullableTighteningCallStrategy`) consume their matching issues and emit
 *   `DataTransformCall` placeholders or recipe ops.
 *
 * - When `'data'` is not allowed (`db update` / `db init`), the
@@ -671,37 +383,20 @@ function canUseSharedTemporaryDefaultStrategy(options) {
 *   the issue for the downstream walk-schema strategies
 *   (`storageTypePlanCallStrategy`, `notNullAddColumnCallStrategy`) or the
 *   `mapIssueToCall` default to handle with direct DDL.
-*   `nativeEnumPlanCallStrategy` runs in both modes; under `db update` /
-*   `db init` it emits the rebuild recipe without the data-transform
-*   placeholder so value-removal data loss surfaces as a runtime cast
-*   error rather than silent loss.
 *
-* Enum dispatch is unified into a single strategy: the
-* `nativeEnumPlanCallStrategy` decides per-emission whether to emit a
-* rebuild recipe (`recipe: true`, contiguous slot) or hoist the call
-* into the `dep` bucket (`recipe: false`, so a brand-new
-* `CreateEnumTypeCall` runs before any `CreateTableCall` referencing
-* it). Codec-typed entries continue through `storageTypePlanCallStrategy`.
+* Codec-typed storage type entries are dispatched through
+* `storageTypePlanCallStrategy`.
 */
 const postgresPlannerStrategies = [
 	notNullBackfillCallStrategy,
 	typeChangeCallStrategy,
 	nullableTighteningCallStrategy,
-	nativeEnumPlanCallStrategy,
 	checkConstraintPlanCallStrategy,
 	storageTypePlanCallStrategy,
 	notNullAddColumnCallStrategy
 ];
 //#endregion
 //#region src/core/migrations/issue-planner.ts
-/**
-* 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];
-	return isPostgresSchema(ns) ? ns.entries.type[typeName] : void 0;
-}
 const ISSUE_KIND_ORDER = {
 	missing_schema: 1,
 	type_missing: 2,
@@ -743,20 +438,18 @@ function isMissing(issue) {
 	if (issue.kind === "enum_values_changed") return false;
 	return issue.actual === void 0;
 }
-function toColumnSpec(name, column, codecHooks, storageTypes) {
-	return {
-		name,
-		typeSql: buildColumnTypeSql(column, codecHooks, storageTypes),
-		defaultSql: buildColumnDefaultSql(column.default, column),
-		nullable: column.nullable
-	};
-}
 function toDdlColumn(name, column, codecHooks, storageTypes) {
 	const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
 	const ddlDefault = postgresDefaultToDdlColumnDefault(column.default);
+	const resolved = resolveColumnTypeMetadata(column, storageTypes);
+	const codecRef = resolved.codecId ? {
+		codecId: resolved.codecId,
+		...resolved.typeParams !== void 0 ? { typeParams: blindCast(resolved.typeParams) } : {}
+	} : void 0;
 	return contractFree.col(name, typeSql, {
 		...!column.nullable ? { notNull: true } : {},
-		...ddlDefault ? { default: ddlDefault } : {}
+		...ifDefined("default", ddlDefault),
+		...ifDefined("codecRef", codecRef)
 	});
 }
 function mapIssueToCall(issue, ctx) {
@@ -821,7 +514,7 @@ function mapIssueToCall(issue, ctx) {
 				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(tableSchema(issue), issue.table, toColumnSpec(issue.column, column, codecHooks, storageTypes))]);
+				return ok([new AddColumnCall(tableSchema(issue), issue.table, toDdlColumn(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"));
@@ -960,12 +653,9 @@ 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 namespaceId = resolveNamespaceIdForIssue(issue);
-			const typeInstance = ctx.toContract.storage.types?.[issue.typeName] ?? locateNamespaceTypeInStorage(ctx.toContract.storage, namespaceId, issue.typeName);
+			const typeInstance = ctx.toContract.storage.types?.[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(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`));
+			return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" uses codec "${typeInstance.codecId}" — only value-set 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}`));
@@ -980,11 +670,7 @@ function mapIssueToCall(issue, ctx) {
 function classifyCall(call) {
 	switch (call.factoryName) {
 		case "createExtension":
-		case "createSchema":
-		case "createEnumType":
-		case "addEnumValues":
-		case "dropEnumType":
-		case "renameType": return "dep";
+		case "createSchema": return "dep";
 		case "dropTable":
 		case "dropColumn":
 		case "dropConstraint":
@@ -1135,4 +821,4 @@ function planIssues(options) {
 //#endregion
 export { postgresPlannerStrategies as n, planIssues as t };
 
-//# sourceMappingURL=issue-planner-Br0pt1Ea.mjs.map
+//# sourceMappingURL=issue-planner-DL6g3CmE.mjs.map