@prisma-next/family-sql 0.13.0-dev.28 → 0.13.0-dev.29

package/src/core/migrations/contract-to-schema-ir.ts

@@ -1,18 +1,14 @@
 import type { ColumnDefault, Contract, JsonValue } from '@prisma-next/contract/types';
 import type { MigrationPlannerConflict } from '@prisma-next/framework-components/control';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
   type CheckConstraint,
   type ForeignKey,
   type Index,
-  isPostgresEnumStorageEntry,
   isStorageTypeInstance,
-  type PostgresEnumStorageEntry,
   type SqlStorage,
   type StorageColumn,
   StorageTable,
   type StorageTypeInstance,
-  toStorageTypeInstance,
   type UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
 import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
@@ -26,7 +22,6 @@ import type {
   SqlTableIR,
   SqlUniqueIR,
 } from '@prisma-next/sql-schema-ir/types';
-import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 
 /**
@@ -105,17 +100,7 @@ function convertColumn(
   };
 }
 
-/**
- * `storageTypes` is polymorphic per Decision 18 (Option B) — codec-typed
- * entries match `StorageTypeInstance`; enum entries match the structural
- * `PostgresEnumStorageEntry` shape (Postgres-only; cross-domain layering
- * keeps target IR classes out of the family layer). Both shapes resolve
- * into the same `(codecId, nativeType, typeParams)` triplet at the
- * column-resolution boundary so downstream walks stay uniform.
- */
-type ResolvedStorageTypes = Readonly<
-  Record<string, StorageTypeInstance | PostgresEnumStorageEntry>
->;
+type ResolvedStorageTypes = Readonly<Record<string, StorageTypeInstance>>;
 
 function resolveColumnTypeMetadata(
   column: StorageColumn,
@@ -130,13 +115,6 @@ function resolveColumnTypeMetadata(
       `Column references storage type "${column.typeRef}" but it is not defined in storage.types.`,
     );
   }
-  if (isPostgresEnumStorageEntry(referenced)) {
-    return {
-      codecId: referenced.codecId,
-      nativeType: referenced.nativeType,
-      typeParams: { values: referenced.values } as Record<string, unknown>,
-    };
-  }
   if (isStorageTypeInstance(referenced)) {
     return {
       codecId: referenced.codecId,
@@ -145,7 +123,7 @@ function resolveColumnTypeMetadata(
     };
   }
   throw new Error(
-    `Storage type "${column.typeRef}" has an unknown polymorphic kind; expected codec-instance or postgres-enum.`,
+    `Storage type "${column.typeRef}" has an unknown polymorphic kind; expected a codec-typed StorageTypeInstance.`,
   );
 }
 
@@ -393,21 +371,9 @@ export function contractToSchemaIR(
   }
 
   const storage = contract.storage;
-  const allTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {
+  const storageTypes: ResolvedStorageTypes = {
     ...((storage.types ?? {}) as ResolvedStorageTypes),
   };
-  for (const ns of Object.values(storage.namespaces)) {
-    const nsEnums = ns.entries['type'];
-    if (nsEnums) {
-      for (const [k, v] of Object.entries(nsEnums)) {
-        allTypes[k] = blindCast<
-          PostgresEnumStorageEntry | StorageTypeInstance,
-          'entries.type holds postgres-specific enum entries at runtime'
-        >(v);
-      }
-    }
-  }
-  const storageTypes = allTypes as ResolvedStorageTypes;
   const tables: Record<string, SqlTableIR> = {};
   for (const ns of Object.values(storage.namespaces)) {
     for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {
@@ -445,66 +411,21 @@ export function contractToSchemaIR(
   };
 }
 
-/**
- * Normalises a native enum storage entry to the codec-typed annotation shape
- * `{codecId, nativeType, typeParams}` the introspector writes and
- * `readExistingEnumValues` reads (`existing.codecId` + `existing.typeParams.values`).
- * Without this the projector would emit the raw `PostgresEnumStorageEntry`
- * shape (top-level `values`, no `typeParams`) and the enum would read as new.
- */
-function normalizeEnumAnnotation(entry: PostgresEnumStorageEntry): StorageTypeInstance {
-  return toStorageTypeInstance({
-    codecId: entry.codecId,
-    nativeType: entry.nativeType,
-    typeParams: { values: entry.values },
-  });
-}
-
 function deriveAnnotations(
   storage: SqlStorage,
   annotationNamespace: string,
-  resolveEnumNamespaceSchema: EnumNamespaceSchemaResolver | undefined,
+  _resolveEnumNamespaceSchema: EnumNamespaceSchemaResolver | undefined,
 ): SqlAnnotations | undefined {
   const storageTypes: Record<string, StorageTypeInstance> = {};
-  const enumTypes: Record<string, Record<string, StorageTypeInstance>> = {};
-
-  const addEnum = (namespaceId: string, entry: PostgresEnumStorageEntry): void => {
-    const schemaName = resolveEnumNamespaceSchema
-      ? resolveEnumNamespaceSchema(storage, namespaceId)
-      : 'public';
-    const bySchema = enumTypes[schemaName] ?? {};
-    bySchema[entry.nativeType] = normalizeEnumAnnotation(entry);
-    enumTypes[schemaName] = bySchema;
-  };
 
-  // Top-level `storage.types`: non-enum codec entries (vector, decimal, …) keyed
-  // by bare `nativeType`. Post-S1.B enums live in `namespaces[*].entries.type`;
-  // a defensive top-level enum is nested under the unbound coordinate's schema.
   for (const typeInstance of Object.values((storage.types ?? {}) as ResolvedStorageTypes)) {
-    if (isPostgresEnumStorageEntry(typeInstance)) {
-      addEnum(UNBOUND_NAMESPACE_ID, typeInstance);
-      continue;
-    }
     if (isStorageTypeInstance(typeInstance)) {
       storageTypes[typeInstance.nativeType] = typeInstance;
     }
   }
 
-  // Namespace-scoped enums: nested by live schema so two namespaces sharing a
-  // native type resolve to distinct live-database types, matching the target's
-  // `readExistingEnumValues` read side (`enumTypes[schema][nativeType]`).
-  for (const [namespaceId, ns] of Object.entries(storage.namespaces)) {
-    const nsEnums = ns.entries['type'];
-    if (!nsEnums) continue;
-    for (const entry of Object.values(nsEnums)) {
-      if (!isPostgresEnumStorageEntry(entry)) continue;
-      addEnum(namespaceId, entry);
-    }
-  }
-
   const envelope = {
     ...(Object.keys(storageTypes).length > 0 ? { storageTypes } : {}),
-    ...(Object.keys(enumTypes).length > 0 ? { enumTypes } : {}),
   };
   if (Object.keys(envelope).length === 0) return undefined;
   return { [annotationNamespace]: envelope };

package/src/core/psl-contract-infer/postgres-type-map.ts

@@ -63,8 +63,6 @@ const PARAMETERIZED_NATIVE_TYPES: Record<
 
 const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
 
-const ENUM_CODEC_ID = 'pg/enum@1';
-
 function getOwnMappingValue(map: Record<string, string>, key: string): string | undefined {
   return Object.hasOwn(map, key) ? map[key] : undefined;
 }
@@ -132,30 +130,15 @@ export function createPostgresTypeMap(enumTypeNames?: ReadonlySet<string>): PslT
 
 export function extractEnumInfo(annotations?: Record<string, unknown>): EnumInfo {
   const pgAnnotations = annotations?.['pg'] as Record<string, unknown> | undefined;
-  const enumTypes = pgAnnotations?.['enumTypes'] as
-    | Record<
-        string,
-        Record<
-          string,
-          { codecId: string; nativeType: string; typeParams?: Record<string, unknown> }
-        >
-      >
-    | undefined;
+  const nativeEnumTypeNames = pgAnnotations?.['nativeEnumTypeNames'];
 
   const typeNames = new Set<string>();
   const definitions = new Map<string, readonly string[]>();
 
-  if (enumTypes) {
-    for (const bySchema of Object.values(enumTypes)) {
-      for (const typeInstance of Object.values(bySchema)) {
-        if (typeInstance.codecId === ENUM_CODEC_ID) {
-          const nativeType = typeInstance.nativeType;
-          typeNames.add(nativeType);
-          const values = typeInstance.typeParams?.['values'];
-          if (Array.isArray(values) && values.every((v): v is string => typeof v === 'string')) {
-            definitions.set(nativeType, values);
-          }
-        }
+  if (Array.isArray(nativeEnumTypeNames)) {
+    for (const name of nativeEnumTypeNames) {
+      if (typeof name === 'string') {
+        typeNames.add(name);
       }
     }
   }

package/src/core/psl-contract-infer/sql-schema-ir-to-psl-ast.ts

@@ -3,7 +3,6 @@ import type {
   PslAttribute,
   PslAttributeArgument,
   PslDocumentAst,
-  PslEnum,
   PslField,
   PslFieldAttribute,
   PslModel,
@@ -20,11 +19,10 @@ import {
 import type { SqlColumnIR, SqlSchemaIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
 import type { DefaultMappingOptions } from './default-mapping';
 import { mapDefault } from './default-mapping';
-import { toEnumName, toFieldName, toModelName, toNamedTypeName } from './name-transforms';
+import { toFieldName, toModelName, toNamedTypeName } from './name-transforms';
 import { createPostgresDefaultMapping } from './postgres-default-mapping';
 import { createPostgresTypeMap, extractEnumInfo } from './postgres-type-map';
 import type {
-  EnumInfo,
   PslNativeTypeAttribute,
   PslPrinterOptions,
   PslTypeMap,
@@ -82,10 +80,19 @@ type TopLevelNameResult = {
  */
 export function sqlSchemaIrToPslAst(schemaIR: SqlSchemaIR): PslDocumentAst {
   const enumInfo = extractEnumInfo(schemaIR.annotations);
+  if (enumInfo.typeNames.size > 0) {
+    const names = [...enumInfo.typeNames].join(', ');
+    throw new Error(
+      `contract infer: the database contains native Postgres enum type(s): ${names}. ` +
+        'Native Postgres enums (CREATE TYPE … AS ENUM) are not adoptable by contract infer. ' +
+        'Drop the native type and replace each column with a text column carrying a CHECK constraint, ' +
+        `then re-run contract infer. The domain enum (enum Name { @@type("pg/text@1") … }) authoring ` +
+        'surface generates the required check automatically.',
+    );
+  }
   const options: PslPrinterOptions = {
-    typeMap: createPostgresTypeMap(enumInfo.typeNames),
+    typeMap: createPostgresTypeMap(new Set()),
     defaultMapping: createPostgresDefaultMapping(),
-    enumInfo,
     parseRawDefault,
   };
 
@@ -93,12 +100,7 @@ export function sqlSchemaIrToPslAst(schemaIR: SqlSchemaIR): PslDocumentAst {
 }
 
 function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions): PslDocumentAst {
-  const { typeMap, defaultMapping, enumInfo, parseRawDefault: rawDefaultParser } = options;
-  const emptyEnumInfo: EnumInfo = {
-    typeNames: new Set<string>(),
-    definitions: new Map<string, readonly string[]>(),
-  };
-  const { typeNames: enumTypeNames, definitions: enumDefinitions } = enumInfo ?? emptyEnumInfo;
+  const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
 
   const modelNames = buildTopLevelNameMap(
     Object.keys(schemaIR.tables),
@@ -106,20 +108,15 @@ function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions):
     'model',
     'table',
   );
-  const enumNames = buildTopLevelNameMap(enumTypeNames, toEnumName, 'enum', 'enum type');
-  assertNoCrossKindNameCollisions(modelNames, enumNames);
 
   const modelNameMap = new Map(
     [...modelNames].map(([tableName, result]) => [tableName, result.name]),
   );
-  const enumNameMap = new Map(
-    [...enumNames].map(([pgTypeName, result]) => [pgTypeName, result.name]),
-  );
-  const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames, enumNames);
+  const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames);
 
   const fieldNamesByTable = buildFieldNamesByTable(schemaIR.tables);
   const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
-  const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNamedTypeNames);
+  const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, new Map(), reservedNamedTypeNames);
 
   const models: PslModel[] = [];
   for (const table of Object.values(schemaIR.tables)) {
@@ -127,7 +124,7 @@ function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions):
       buildModel(
         table,
         typeMap,
-        enumNameMap,
+        new Map(),
         fieldNamesByTable,
         namedTypes,
         defaultMapping,
@@ -139,13 +136,6 @@ function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions):
 
   const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
 
-  const enums: PslEnum[] = [];
-  for (const [pgTypeName, values] of enumDefinitions) {
-    const enumName = enumNames.get(pgTypeName) as TopLevelNameResult;
-    enums.push(buildEnum(enumName, values));
-  }
-  enums.sort((a, b) => a.name.localeCompare(b.name));
-
   const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) =>
     a.name.localeCompare(b.name),
   );
@@ -171,7 +161,7 @@ function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions):
       makePslNamespace({
         kind: 'namespace',
         name: UNSPECIFIED_PSL_NAMESPACE_ID,
-        entries: makePslNamespaceEntries(sortedModels, enums, [], []),
+        entries: makePslNamespaceEntries(sortedModels, [], []),
         span: SYNTHETIC_SPAN,
       }),
     ],
@@ -485,24 +475,6 @@ function namedArg(name: string, value: string): PslAttributeArgument {
   return { kind: 'named', name, value, span: SYNTHETIC_SPAN };
 }
 
-function buildEnum(name: TopLevelNameResult, values: readonly string[]): PslEnum {
-  const attrs: PslAttribute[] = [];
-  if (name.map) {
-    attrs.push(buildMapAttribute('enum', name.map));
-  }
-  return {
-    kind: 'enum',
-    name: name.name,
-    values: values.map((value) => ({
-      kind: 'enumValue',
-      name: value,
-      span: SYNTHETIC_SPAN,
-    })),
-    attributes: attrs,
-    span: SYNTHETIC_SPAN,
-  };
-}
-
 function buildNamedTypeDeclaration(entry: NamedTypeRegistryEntry): PslNamedTypeDeclaration {
   const attribute = buildAttribute(
     'namedType',
@@ -647,29 +619,8 @@ function buildTopLevelNameMap(
   return results;
 }
 
-function assertNoCrossKindNameCollisions(
-  modelNames: ReadonlyMap<string, TopLevelNameResult>,
-  enumNames: ReadonlyMap<string, TopLevelNameResult>,
-): void {
-  const enumSourceByName = new Map([...enumNames].map(([source, result]) => [result.name, source]));
-
-  const collisions = [...modelNames.entries()]
-    .map(([tableName, result]) => {
-      const enumSource = enumSourceByName.get(result.name);
-      return enumSource
-        ? `- identifier "${result.name}" from table "${tableName}" collides with enum type "${enumSource}"`
-        : undefined;
-    })
-    .filter((detail): detail is string => detail !== undefined);
-
-  if (collisions.length > 0) {
-    throw new Error(`PSL top-level name collisions detected:\n${collisions.join('\n')}`);
-  }
-}
-
 function createReservedNamedTypeNames(
   modelNames: ReadonlyMap<string, TopLevelNameResult>,
-  enumNames: ReadonlyMap<string, TopLevelNameResult>,
 ): Set<string> {
   const reservedNames = new Set<string>(PSL_SCALAR_TYPE_NAMES);
 
@@ -677,10 +628,6 @@ function createReservedNamedTypeNames(
     reservedNames.add(result.name);
   }
 
-  for (const result of enumNames.values()) {
-    reservedNames.add(result.name);
-  }
-
   return reservedNames;
 }
 

package/src/core/schema-verify/verify-sql-schema.ts

@@ -18,9 +18,7 @@ import type {
 } from '@prisma-next/framework-components/control';
 
 import {
-  isPostgresEnumStorageEntry,
   isStorageTypeInstance,
-  type PostgresEnumStorageEntry,
   type SqlStorage,
   type StorageColumn,
   StorageTable,
@@ -28,7 +26,6 @@ import {
 } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import { canonicalStringify } from '@prisma-next/utils/canonical-stringify';
-import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { extractCodecControlHooks } from '../assembly';
 import { resolveValueSetValues } from '../migrations/contract-to-schema-ir';
@@ -92,22 +89,6 @@ export interface VerifySqlSchemaOptions {
    * with contract native types (e.g., Postgres 'varchar' → 'character varying').
    */
   readonly normalizeNativeType?: NativeTypeNormalizer;
-  /**
-   * Bridging adapter that resolves the existing values for a `PostgresEnumStorageEntry`
-   * (looked up by its native type) from the introspected schema IR. Targets
-   * supply this so the family-level verifier can walk `PostgresEnumStorageEntry` instances
-   * natively without reaching into target-specific `schema.annotations`
-   * shapes itself.
-   *
-   * Returning `null` indicates the type is missing from the database; the
-   * verifier emits a `type_missing` issue. A non-null array triggers a
-   * value-set comparison against the contract's `PostgresEnumStorageEntry.values`.
-   */
-  readonly resolveExistingEnumValues?: (
-    schema: SqlSchemaIR,
-    enumType: PostgresEnumStorageEntry,
-    namespaceId: string,
-  ) => readonly string[] | null;
 }
 
 /**
@@ -129,7 +110,6 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
     typeMetadataRegistry,
     normalizeDefault,
     normalizeNativeType,
-    resolveExistingEnumValues,
   } = options;
   const startTime = Date.now();
 
@@ -138,28 +118,7 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
 
   const { contractStorageHash, contractProfileHash, contractTarget } =
     extractContractMetadata(contract);
-  // Column `typeRef` resolution map: keyed by the bare contract type name
-  // (columns carry bare `typeRef`s). Used by `verifySchemaTables` only.
-  const allStorageTypesMap: Record<string, PostgresEnumStorageEntry | StorageTypeInstance> = {
-    ...((contract.storage.types ?? {}) as Record<
-      string,
-      PostgresEnumStorageEntry | StorageTypeInstance
-    >),
-  };
-  for (const ns of Object.values(contract.storage.namespaces)) {
-    const nsEnums = blindCast<
-      { readonly type?: Readonly<Record<string, PostgresEnumStorageEntry | StorageTypeInstance>> },
-      'postgres target namespace entries carry a type slot beyond the family-shared SqlNamespace.entries type'
-    >(ns.entries).type;
-    if (nsEnums) {
-      for (const [k, v] of Object.entries(nsEnums)) {
-        allStorageTypesMap[k] = v;
-      }
-    }
-  }
-  const storageTypes = allStorageTypesMap as Readonly<
-    Record<string, PostgresEnumStorageEntry | StorageTypeInstance>
-  >;
+  const storageTypes: Readonly<Record<string, StorageTypeInstance>> = contract.storage.types ?? {};
   const { issues, rootChildren } = verifySchemaTables({
     contract,
     schema,
@@ -173,13 +132,6 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
 
   validateFrameworkComponentsForExtensions(contract, options.frameworkComponents);
 
-  // Verify storage type instances. Codec-typed `storage.types` entries dispatch
-  // through the generic codec-hook `verifyType` path (keyed by bare name).
-  // `PostgresEnumStorageEntry` enums are walked natively *per namespace* (using
-  // the bridging adapter `resolveExistingEnumValues`) so two namespaces that
-  // declare an enum with the same name are each verified with their own
-  // namespace coordinate — a bare-name aggregation would collapse them
-  // (last-write-wins) and verify only one.
   const typeNodes: SchemaVerificationNode[] = [];
   // Storage-type findings dispatch through the same control policy as tables
   // and columns: each issue's disposition (fail / warn / suppress) is resolved
@@ -233,29 +185,6 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
     }
   }
 
-  // Namespace-scoped enums, verified per `(namespaceId, typeName)`.
-  for (const nsId of Object.keys(contract.storage.namespaces)) {
-    const ns = contract.storage.namespaces[nsId];
-    if (!ns) continue;
-    const nsEnums = ns.entries['type'];
-    if (!nsEnums) continue;
-    for (const [typeName, entry] of Object.entries(nsEnums)) {
-      if (!isPostgresEnumStorageEntry(entry)) continue;
-      pushTypeNode(
-        typeName,
-        `storage.namespaces.${nsId}.entries.type.${typeName}`,
-        verifyEnumType({
-          typeName,
-          typeInstance: entry,
-          schema,
-          resolveExistingEnumValues,
-          namespaceId: nsId,
-        }),
-        effectiveControlPolicy(entry.control, contract.defaultControlPolicy),
-      );
-    }
-  }
-
   if (typeNodes.length > 0) {
     const typesStatus: VerificationStatus = typeNodes.some((n) => n.status === 'fail')
       ? 'fail'
@@ -321,63 +250,6 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
   };
 }
 
-/**
- * Native verification walk for `PostgresEnumStorageEntry` instances (no codec hook).
- *
- * Bridges the native `PostgresEnumStorageEntry.values` against the introspected schema
- * IR via the target-supplied `resolveExistingEnumValues` adapter. Without an
- * adapter, the verifier conservatively reports the enum as missing — there
- * is no other way for the family layer to learn about live enum types.
- */
-function verifyEnumType(options: {
-  readonly typeName: string;
-  readonly typeInstance: PostgresEnumStorageEntry;
-  readonly schema: SqlSchemaIR;
-  readonly namespaceId: string;
-  readonly resolveExistingEnumValues?:
-    | ((
-        schema: SqlSchemaIR,
-        enumType: PostgresEnumStorageEntry,
-        namespaceId: string,
-      ) => readonly string[] | null)
-    | undefined;
-}): readonly SchemaIssue[] {
-  const { typeName, typeInstance, schema, namespaceId, resolveExistingEnumValues } = options;
-  const desired = typeInstance.values;
-  const existing = resolveExistingEnumValues?.(schema, typeInstance, namespaceId) ?? null;
-  if (!existing) {
-    return [
-      {
-        kind: 'type_missing',
-        typeName,
-        namespaceId,
-        message: `Type "${typeName}" is missing from database`,
-      },
-    ];
-  }
-  if (arraysEqual(existing, desired)) {
-    return [];
-  }
-  const existingSet = new Set(existing);
-  const desiredSet = new Set(desired);
-  const addedValues = desired.filter((v) => !existingSet.has(v));
-  const removedValues = existing.filter((v) => !desiredSet.has(v));
-  const message =
-    removedValues.length === 0
-      ? `Enum type "${typeName}" needs new values: ${addedValues.join(', ')}`
-      : `Enum type "${typeName}" values changed (requires rebuild): +[${addedValues.join(', ')}] -[${removedValues.join(', ')}]`;
-  return [
-    {
-      kind: 'enum_values_changed' as const,
-      namespaceId,
-      typeName,
-      addedValues,
-      removedValues,
-      message,
-    },
-  ];
-}
-
 function extractContractMetadata(contract: Contract<SqlStorage>): {
   contractStorageHash: SqlStorage['storageHash'];
   contractProfileHash?: Contract<SqlStorage>['profileHash'] | undefined;
@@ -399,7 +271,7 @@ function verifySchemaTables(options: {
   strict: boolean;
   typeMetadataRegistry: ReadonlyMap<string, { nativeType?: string }>;
   codecHooks: Map<string, CodecControlHooks>;
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>;
   normalizeDefault?: DefaultNormalizer;
   normalizeNativeType?: NativeTypeNormalizer;
 }): { issues: SchemaIssue[]; rootChildren: SchemaVerificationNode[] } {
@@ -533,7 +405,7 @@ function verifyTableChildren(options: {
   strict: boolean;
   typeMetadataRegistry: ReadonlyMap<string, { nativeType?: string }>;
   codecHooks: Map<string, CodecControlHooks>;
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>;
   normalizeDefault?: DefaultNormalizer;
   normalizeNativeType?: NativeTypeNormalizer;
   contractStorage: SqlStorage;
@@ -717,7 +589,6 @@ function verifyTableChildren(options: {
   // Verify check constraints when the contract declares checks for this table OR
   // when strict mode is on (so extra live checks on zero-check tables are detected).
   // schemaTable.checks carries the introspected live checks (parsed value sets).
-  // This call is additive: verifyEnumType (the native enum path) is untouched.
   const contractCheckIRs = (contractTable.checks ?? []).map((c) => ({
     name: c.name,
     column: c.column,
@@ -751,7 +622,7 @@ function collectContractColumnNodes(options: {
   strict: boolean;
   typeMetadataRegistry: ReadonlyMap<string, { nativeType?: string }>;
   codecHooks: Map<string, CodecControlHooks>;
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>;
   normalizeDefault?: DefaultNormalizer;
   normalizeNativeType?: NativeTypeNormalizer;
 }): SchemaVerificationNode[] {
@@ -889,7 +760,7 @@ function verifyColumn(options: {
   strict: boolean;
   typeMetadataRegistry: ReadonlyMap<string, { nativeType?: string }>;
   codecHooks: Map<string, CodecControlHooks>;
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>;
   normalizeDefault?: DefaultNormalizer;
   normalizeNativeType?: NativeTypeNormalizer;
 }): SchemaVerificationNode {
@@ -1260,7 +1131,7 @@ function validateFrameworkComponentsForExtensions(
  */
 function renderExpectedNativeType(
   contractColumn: StorageColumn,
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>,
   codecHooks: Map<string, CodecControlHooks>,
   context?: {
     readonly tableName: string;
@@ -1290,7 +1161,7 @@ function renderExpectedNativeType(
 
 function resolveContractColumnTypeMetadata(
   contractColumn: StorageColumn,
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>,
   context?: {
     readonly tableName: string;
     readonly columnName: string;
@@ -1310,13 +1181,6 @@ function resolveContractColumnTypeMetadata(
     );
   }
 
-  if (isPostgresEnumStorageEntry(referencedType)) {
-    return {
-      codecId: referencedType.codecId,
-      nativeType: referencedType.nativeType,
-      typeParams: { values: referencedType.values } as Record<string, unknown>,
-    };
-  }
   if (isStorageTypeInstance(referencedType)) {
     return {
       codecId: referencedType.codecId,
@@ -1325,7 +1189,7 @@ function resolveContractColumnTypeMetadata(
     };
   }
   throw new Error(
-    `Storage type "${contractColumn.typeRef}" has an unknown polymorphic kind; expected codec-instance or postgres-enum.`,
+    `Storage type "${contractColumn.typeRef}" has an unknown kind; expected a codec-typed StorageTypeInstance.`,
   );
 }