TML-2952: type SQL enum columns through the codec instead of printing their stored values (#896)

An enum column/field's TypeScript type is the union of its allowed
values (`'low' | 'high' | 'urgent'`). Today that union is built by
printing the stored, codec-encoded values straight to TS literals in two
separate emit-path spots — which **bypasses the codec**, the one
component that knows a stored value's real TypeScript type. It's correct
only by coincidence: today's enums use text/int codecs where the encoded
form happens to equal the output type. This routes emit typing through
the codec, on one path, and removes the duplication. SQL only; Mongo is
the sibling
[TML-2953](https://linear.app/prisma-company/issue/TML-2953).

No user-visible change for today's enums — correctness + de-duplication.

## What changed

- **New codec seam.** `renderValueType(encodedValue, channel)` on
`CodecDescriptor` and `renderValueTypeFor` on `CodecLookup` — the
value-keyed counterpart of the existing `renderOutputType`. It renders a
single codec-encoded value as its TS output literal, or `undefined` when
the codec can't (e.g. a `Date`-output codec — no base-class default, so
non-identity codecs opt out). Implemented for the Postgres and Mongo
primitive codecs.
- **SQL column emit** now renders each value-set value through the codec
via a shared `renderValueSetType` helper, instead of printing the stored
values directly (`renderValueSetUnionBase`/`renderValueSetLiteral`
deleted).
- **Framework field emit** no longer special-cases enums. The hardcoded
domain-enum override (`DomainEnumLookup`, `renderEnumValueUnion`,
`renderEnumMemberLiteral`) is deleted; a new **family-supplied**
`EmissionSpi.resolveFieldValueSet` hook supplies a field's permitted
values, rendered through the same codec helper. The domain `enum` is no
longer a typing input — it keeps only the runtime `db.enums` dictionary.

## Keeping Mongo byte-identical (the one design call worth flagging)

`FieldOutputTypes` is generated once for **both** families, and the
framework emitter must not read `storage`. So deleting the shared
override bare would regress Mongo's emitted enum fields (the demo `role:
'admin' | 'author' | 'reader'` would widen to `string`). The resolver
hook resolves this cleanly:

- **SQL** sources permitted values from the **storage value set** (field
→ column → value set) — the domain enum stops being a SQL typing input.
- **Mongo** supplies an **interim** resolver reading `domain.enum` (it
has no value-set entity yet), keeping its output byte-identical. This is
removed by **TML-2953**, which brings Mongo onto the value-set model.

So the acceptance criterion "domain enum is not a typing input" holds
for SQL now, and repo-wide once TML-2953 lands.

The no-emit (`typeof contract`) path is unchanged — it already
propagated the authored, typed values, and is the reference the emit
path now matches.

## Acceptance evidence

- **A1** — every emit-path enum type goes through the codec; a
structural guard keeps the deleted direct-render helpers gone.
- **A2** — the guard pins the only domain-enum *typing* readers to the
`db.enums` dictionary block and the Mongo interim resolver; the SQL
emitter reads none.
- **A4** — byte-identical for identity codecs, **both families**: empty
`contract.json` diff, `fixtures:check` clean, the mongo-demo
`contract.d.ts`/`.json` git-unchanged across every commit.
- **A5** — a non-identity test codec (encodes `0|1|2`, outputs
`'low'|'high'|'urgent'`) types as the codec **output**, not the raw
encoded literal — on both the column and field surfaces.
- **A6** — the emitted field type equals the no-emit `typeof contract`
union.
- **A7** — no new casts (`lint:casts` delta 0), `lint:deps` clean;
build, typecheck, and the full test suites
(`packages`/`integration`/`e2e`) green.

## Notes

- Shaping artifacts (spec + dispatch plan) live under
`projects/refactor-enum-typing-via-codec/`. The spec was corrected
during shaping: the family-resolver design (the framework must not reach
into storage) and the SQL-scoping of A2.
- The change is additive at the framework layer (the new SPI hook is
optional), so no downstream extension needed updating; one Mongo *test*
harness updated its mock lookup to mirror production.
- Verified on `main` including #880 (Mongo enums in retail-store), which
re-emits byte-identically under this change.

## Upgrade instructions (0.14 → 0.15)

-
`skills/extension-author/prisma-next-extension-upgrade/upgrades/0.14-to-0.15/`
— a real entry: an extension that types a value-set-restricted (enum)
column via a custom `CodecDescriptorImpl` must implement
`renderValueLiteral` (and expose `renderValueLiteralFor` on a hand-built
`CodecLookup`), or the column widens to the codec output type.
Framework-built lookups already supply it. Validated by execution
(reverting `packages/3-extensions/` reddens the mongo enum e2e;
re-applying reproduces the branch, tests green).
- `skills/upgrade/prisma-next-upgrade/upgrades/0.14-to-0.15/` — user
side is incidental (`changes: []`); the only `examples/` touch is a type
test and the emitted contract is byte-identical.

🤖 Generated with [Claude Code](https://claude.com/claude-code)


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
* Value-restricted fields now emit more precise literal unions instead
of broad `string` types.
* Type generation now uses codec-based literal rendering across
supported databases, improving output for enums and similar restricted
values.

* **Bug Fixes**
* Fixed cases where restricted field types could fall back to overly
generic types.
* Improved handling for non-identity codecs so emitted types stay
aligned with stored values.

* **Tests**
* Added coverage for literal rendering, value-set narrowing, and
fallback behavior.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Signed-off-by: willbot <w.a.madden+machine@gmail.com>
Signed-off-by: Will Madden <madden@prisma.io>

Author: wmadden-electric

examples/prisma-next-demo/test/demo-dx.types.test.ts

@@ -46,6 +46,16 @@ test('emitted contract.d.ts types Post.priority as the value union, not string',
   expectTypeOf<PriorityOutput>().not.toEqualTypeOf<string>();
 });
 
+// Emit vs no-emit agreement. The emitted `FieldOutputTypes` enum field type
+// (produced on the emit path via the codec seam) must equal the enum's authored
+// value union carried by `db.enums` (the no-emit reference — the authored member
+// values propagated without serialization). Same enum, both paths, one union.
+test('emitted Post.priority field type equals the no-emit db.enums value union', () => {
+  type EmittedPriority = FieldOutputTypes['public']['Post']['priority'];
+  type NoEmitPriorityValues = EnumValues<typeof db.enums.public.Priority>;
+  expectTypeOf<EmittedPriority>().toEqualTypeOf<NoEmitPriorityValues>();
+});
+
 test('emitted contract: db.sql.public.post SELECT priority yields the value union', () => {
   const plan = db.sql.public.post.select('id', 'priority').build();
   type Row = ResultType<typeof plan>;

packages/1-framework/1-core/framework-components/src/control/control-stack.ts

@@ -1,3 +1,4 @@
+import type { JsonValue } from '@prisma-next/contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import type { Codec } from '../shared/codec';
 import type { AnyCodecDescriptor } from '../shared/codec-descriptor';
@@ -310,6 +311,10 @@ export function extractCodecLookup(
     string,
     (params: Record<string, unknown>) => string | undefined
   >();
+  const valueLiteralRenderersById = new Map<
+    string,
+    (value: JsonValue, side: 'output' | 'input') => string | undefined
+  >();
   const owners = new Map<string, string>();
   for (const descriptor of descriptors) {
     const codecTypes = descriptor.types?.codecTypes;
@@ -337,6 +342,9 @@ export function extractCodecLookup(
       if (typeof codecDescriptor.renderInputType === 'function') {
         inputRenderersById.set(codecDescriptor.codecId, codecDescriptor.renderInputType);
       }
+      if (typeof codecDescriptor.renderValueLiteral === 'function') {
+        valueLiteralRenderersById.set(codecDescriptor.codecId, codecDescriptor.renderValueLiteral);
+      }
       // Materialize a representative `Codec` instance for `byId.get()` so consumers reading the lookup's instance side (e.g. SQL renderer's cast-policy lookup, or the contract emitter's literal-default `encodeJson` resolver) keep finding the codec.
       //
       // Two cohorts:
@@ -376,6 +384,7 @@ export function extractCodecLookup(
     metaFor: (id) => metaById.get(id),
     renderOutputTypeFor: (id, params) => renderersById.get(id)?.(params),
     renderInputTypeFor: (id, params) => inputRenderersById.get(id)?.(params),
+    renderValueLiteralFor: (id, value, side) => valueLiteralRenderersById.get(id)?.(value, side),
   };
 }
 

packages/1-framework/1-core/framework-components/src/control/emission-types.ts

@@ -1,4 +1,4 @@
-import type { Contract, ContractModelBase } from '@prisma-next/contract/types';
+import type { Contract, ContractModelBase, JsonValue } from '@prisma-next/contract/types';
 import type { CodecLookup } from '../shared/codec-types';
 import type { TypesImportSpec } from '../shared/types-import-spec';
 
@@ -33,5 +33,18 @@ export interface EmissionSpi {
     contract: Contract,
   ): Record<string, unknown> | undefined;
 
+  /**
+   * Resolves a field's permitted values (codec-encoded) plus the codec that types them, or
+   * `undefined` for a field with no restricted value set. The framework renders the values into a TS
+   * literal union through the codec seam. Each family decides where the values live — a value set in
+   * its own storage plane, or another family-owned source.
+   */
+  resolveFieldValueSet?(
+    modelName: string,
+    fieldName: string,
+    model: ContractModelBase,
+    contract: Contract,
+  ): { readonly encodedValues: readonly JsonValue[]; readonly codecId: string } | undefined;
+
   getStorageTypeExports?(contract: Contract, codecLookup?: CodecLookup): string | undefined;
 }

packages/1-framework/1-core/framework-components/src/exports/codec.ts

@@ -27,6 +27,7 @@ export type {
   ColumnTypeDescriptor,
 } from '../shared/column-spec';
 export { column } from '../shared/column-spec';
+export { renderTsLiteral } from '../shared/render-ts-literal';
 export {
   CONTRACT_CODEC_DESCRIPTOR_MISSING,
   materializeCodec,

packages/1-framework/1-core/framework-components/src/shared/codec-descriptor.ts

@@ -8,6 +8,7 @@
  * The factory's method-level generic is the load-bearing piece for literal preservation: per-codec column helpers invoke `descriptor.factory(...)` *directly*, and the direct call binds the generic at its call site. Type extraction (`ReturnType<D['factory']>`, structural matching) widens method generics to their constraint — that's why the column-helper surface is per-codec, not polymorphic.
  */
 
+import type { JsonValue } from '@prisma-next/contract/types';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { Codec } from './codec';
 import {
@@ -45,6 +46,17 @@ export interface CodecDescriptor<P = void> {
   readonly renderOutputType?: (params: P) => string | undefined;
   /** Emit-path string renderer for the `contract.d.ts` *input* position (create/update values). Returns the TypeScript input type expression for given params. Optional; absent renderers fall back to the codec's base input type. A codec supplies this when its write type is narrower than the generic codec input — e.g. an enum whose input should be the literal member union, not `string`. */
   readonly renderInputType?: (params: P) => string | undefined;
+  /**
+   * Given one stored (codec-encoded) value, return the TypeScript literal type to print for it
+   * (e.g. `'low'`, `1`), or `undefined` if this codec's output isn't literal-expressible (e.g. a
+   * Date-output codec).
+   *
+   * `value` is the `encodeJson` form stored in the value set. `side` selects which type to print:
+   * `output` = the read/SELECT type; `input` = the create/update type. Most codecs render the same
+   * literal for both, but a codec whose read and write types differ can render per side. Called once
+   * per permitted value; the caller joins the results with `|`.
+   */
+  readonly renderValueLiteral?: (value: JsonValue, side: 'output' | 'input') => string | undefined;
   /** The curried higher-order codec. For non-parameterized codecs, the factory is constant — every call returns the same shared codec instance. For parameterized codecs, the factory is called once per `storage.types` instance (or once per inline-`typeParams` column), with `ctx` carrying the column set the resulting codec serves. */
   readonly factory: (params: P) => (ctx: CodecInstanceContext) => Codec;
 }
@@ -83,6 +95,9 @@ export abstract class CodecDescriptorImpl<TParams = void> implements CodecDescri
   /** Optional emit-path string renderer for the `contract.d.ts` input position. Returns the TypeScript input type expression for the given params; supplied when the write type is narrower than the generic codec input (e.g. an enum's literal member union). */
   renderInputType?(params: TParams): string | undefined;
 
+  /** Optional emit-path renderer for a single stored value. See {@link CodecDescriptor.renderValueLiteral}. */
+  renderValueLiteral?(value: JsonValue, side: 'output' | 'input'): string | undefined;
+
   /**
    * Materialize a curried codec factory for the given params. Concrete subclasses override with a typed return type (e.g. `factory<N>(params: { length: N }): (ctx) => VectorCodec<N>`); per-codec helpers read the typed return at the *direct* call site, which is what preserves method-level generics. Type extraction (e.g. `ReturnType<D['factory']>`) widens method generics to their constraint — that's why the column-helper surface is per-codec, not polymorphic.
    */

packages/1-framework/1-core/framework-components/src/shared/codec-types.ts

@@ -51,6 +51,12 @@ export interface CodecLookup {
   renderOutputTypeFor(id: string, params: Record<string, unknown>): string | undefined;
   /** Codec-id-keyed `renderInputType` renderer for the `contract.d.ts` input position. Optional so existing lookups need not provide it; returns `undefined` when the codec renders no custom input type or the id is unknown. */
   renderInputTypeFor?(id: string, params: Record<string, unknown>): string | undefined;
+  /** Codec-id-keyed `renderValueLiteral` renderer for the emit path (`side`: `output` = read type, `input` = create/update type). Optional so existing lookups need not provide it; returns `undefined` when the codec's output isn't literal-expressible or the id is unknown. */
+  renderValueLiteralFor?(
+    id: string,
+    value: JsonValue,
+    side: 'output' | 'input',
+  ): string | undefined;
 }
 
 /**

packages/1-framework/1-core/framework-components/src/shared/render-ts-literal.ts

@@ -0,0 +1,31 @@
+import type { JsonValue } from '@prisma-next/contract/types';
+
+/**
+ * Renders a codec-encoded value as a TypeScript literal (e.g. `'low'`, `1`, `true`), or `undefined`
+ * when the value isn't literal-expressible (objects, arrays, null).
+ *
+ * Valid **only for identity codecs** whose `encodeJson` output equals their decoded output type
+ * (text, int, float, bool). A non-identity codec (e.g. one that encodes to an int but decodes to a
+ * string literal) must NOT use this: it has to `decodeJson` first, then render, in its own
+ * `renderValueLiteral`.
+ *
+ * String values are fully escaped for a single-quoted `.d.ts` literal: backslash, single quote, and
+ * every character a raw single-quoted TS literal cannot contain — newline, carriage return, and the
+ * U+2028/U+2029 line/paragraph separators (which JS also treats as line terminators).
+ */
+export function renderTsLiteral(value: JsonValue): string | undefined {
+  if (typeof value === 'string') {
+    const escaped = value
+      .replace(/\\/g, '\\\\')
+      .replace(/'/g, "\\'")
+      .replace(/\n/g, '\\n')
+      .replace(/\r/g, '\\r')
+      .replace(/\u2028/g, '\\u2028')
+      .replace(/\u2029/g, '\\u2029');
+    return `'${escaped}'`;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  return undefined;
+}

packages/1-framework/1-core/framework-components/test/control-stack.test.ts

@@ -730,6 +730,33 @@ describe('extractCodecLookup', () => {
       expect.objectContaining({ code: 'CONTRACT.CODEC_DESCRIPTOR_MISSING' }),
     );
   });
+
+  it('renderValueLiteralFor delegates to the descriptor renderValueLiteral', () => {
+    const descriptorWithValueRenderer: AnyCodecDescriptor = {
+      ...stubDescriptor('text@1'),
+      renderValueLiteral: (value: unknown) =>
+        typeof value === 'string' ? `'${value}'` : undefined,
+    };
+    const lookup = extractCodecLookup([
+      { id: 'desc', types: { codecTypes: { codecDescriptors: [descriptorWithValueRenderer] } } },
+    ]);
+    expect(lookup.renderValueLiteralFor?.('text@1', 'low', 'output')).toBe("'low'");
+    expect(lookup.renderValueLiteralFor?.('text@1', 42, 'output')).toBeUndefined();
+  });
+
+  it('renderValueLiteralFor returns undefined for unknown codec ids', () => {
+    const lookup = extractCodecLookup([
+      { id: 'desc', types: { codecTypes: { codecDescriptors: [stubDescriptor('a@1')] } } },
+    ]);
+    expect(lookup.renderValueLiteralFor?.('unknown@1', 'val', 'output')).toBeUndefined();
+  });
+
+  it('renderValueLiteralFor returns undefined when the codec has no renderValueLiteral', () => {
+    const lookup = extractCodecLookup([
+      { id: 'desc', types: { codecTypes: { codecDescriptors: [stubDescriptor('a@1')] } } },
+    ]);
+    expect(lookup.renderValueLiteralFor?.('a@1', 'val', 'output')).toBeUndefined();
+  });
 });
 
 describe('assembleScalarTypeDescriptors', () => {

packages/1-framework/3-tooling/emitter/src/domain-type-generation.ts

@@ -1,12 +1,10 @@
 import type {
-  ContractEnum,
   ContractField,
   ContractManyToManyRelation,
   ContractModelBase,
   ContractValueObject,
   CrossReference,
   JsonValue,
-  ValueSetRef,
 } from '@prisma-next/contract/types';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
@@ -291,20 +289,43 @@ export type FieldTypeParamsResolver = (
   model: ContractModelBase,
 ) => Record<string, unknown> | undefined;
 
-export type DomainEnumLookup = (ref: ValueSetRef) => ContractEnum | undefined;
-
-function renderEnumMemberLiteral(value: JsonValue): string | undefined {
-  if (typeof value === 'string') return serializeValue(value);
-  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
-  return undefined;
-}
-
-function renderEnumValueUnion(values: readonly JsonValue[]): string | undefined {
-  if (values.length === 0) return undefined;
+/**
+ * A field's permitted values (codec-encoded) plus the codec that types them, as supplied by the
+ * family-specific {@link EmissionSpi.resolveFieldValueSet}. The framework renders these into a TS
+ * literal union through the codec seam ({@link renderValueSetType}).
+ */
+export type ResolvedFieldValueSet = {
+  readonly encodedValues: readonly JsonValue[];
+  readonly codecId: string;
+};
+
+export type FieldValueSetResolver = (
+  modelName: string,
+  fieldName: string,
+  model: ContractModelBase,
+) => ResolvedFieldValueSet | undefined;
+
+/**
+ * Renders a value set (a field/column's permitted values, codec-encoded) into a TS literal union by
+ * routing **each** value through the codec's `renderValueLiteral` — the seam owned by the codec, not
+ * a generic serializer. `side`: `output` = read type, `input` = create/update type.
+ *
+ * Returns `undefined` — signalling the caller to fall back to the codec's full output type — when
+ * the lookup is absent, has no `renderValueLiteralFor`, the value set is empty, or **any** value
+ * isn't literal-expressible. A caller that needs column and field types to agree shares this so both
+ * compute the union identically.
+ */
+export function renderValueSetType(
+  values: readonly JsonValue[],
+  codecId: string,
+  side: 'output' | 'input',
+  codecLookup: CodecLookup | undefined,
+): string | undefined {
+  if (values.length === 0 || codecLookup?.renderValueLiteralFor === undefined) return undefined;
   const literals: string[] = [];
   for (const value of values) {
-    const lit = renderEnumMemberLiteral(value);
-    if (lit === undefined) return undefined;
+    const lit = codecLookup.renderValueLiteralFor(codecId, value, side);
+    if (lit === undefined || !isSafeTypeExpression(lit)) return undefined;
     literals.push(lit);
   }
   return literals.join(' | ');
@@ -314,21 +335,29 @@ export function resolveFieldType(
   field: ContractField,
   codecLookup?: CodecLookup,
   resolvedTypeParams?: Record<string, unknown>,
-  domainEnumLookup?: DomainEnumLookup,
+  resolvedValueSet?: ResolvedFieldValueSet,
 ): ResolvedFieldType {
   const { type } = field;
 
   switch (type.kind) {
     case 'scalar': {
-      if (field.valueSet?.entityKind === 'enum' && domainEnumLookup) {
-        const domainEnum = domainEnumLookup(field.valueSet);
-        const union = domainEnum
-          ? renderEnumValueUnion(domainEnum.members.map((m) => m.value))
-          : undefined;
-        if (union !== undefined && isSafeTypeExpression(union)) {
+      if (resolvedValueSet) {
+        const output = renderValueSetType(
+          resolvedValueSet.encodedValues,
+          resolvedValueSet.codecId,
+          'output',
+          codecLookup,
+        );
+        const input = renderValueSetType(
+          resolvedValueSet.encodedValues,
+          resolvedValueSet.codecId,
+          'input',
+          codecLookup,
+        );
+        if (output !== undefined && input !== undefined) {
           return {
-            output: applyModifiers(union, field),
-            input: applyModifiers(union, field),
+            output: applyModifiers(output, field),
+            input: applyModifiers(input, field),
           };
         }
       }
@@ -394,7 +423,7 @@ export function generateBothFieldTypesMaps(
   models: Record<string, ContractModelBase> | undefined,
   codecLookup?: CodecLookup,
   resolveFieldTypeParams?: FieldTypeParamsResolver,
-  domainEnumLookup?: DomainEnumLookup,
+  resolveFieldValueSet?: FieldValueSetResolver,
 ): ResolvedFieldType {
   if (!models || Object.keys(models).length === 0) {
     return { output: 'Record<string, never>', input: 'Record<string, never>' };
@@ -415,7 +444,8 @@ export function generateBothFieldTypesMaps(
           : undefined;
       const resolvedTypeParams =
         inlineTypeParams ?? resolveFieldTypeParams?.(modelName, fieldName, model);
-      const resolved = resolveFieldType(field, codecLookup, resolvedTypeParams, domainEnumLookup);
+      const resolvedValueSet = resolveFieldValueSet?.(modelName, fieldName, model);
+      const resolved = resolveFieldType(field, codecLookup, resolvedTypeParams, resolvedValueSet);
       const key = `readonly ${serializeObjectKey(fieldName)}`;
       outputFieldEntries.push(`${key}: ${resolved.output}`);
       inputFieldEntries.push(`${key}: ${resolved.input}`);
@@ -443,7 +473,7 @@ export function generateFieldTypesMapsByNamespace(
   namespaceModels: ReadonlyArray<readonly [string, Record<string, ContractModelBase>]>,
   codecLookup?: CodecLookup,
   resolveFieldTypeParams?: FieldTypeParamsResolver,
-  domainEnumLookup?: DomainEnumLookup,
+  resolveFieldValueSet?: FieldValueSetResolver,
 ): ResolvedFieldType {
   if (namespaceModels.length === 0) {
     return { output: 'Record<string, never>', input: 'Record<string, never>' };
@@ -456,7 +486,7 @@ export function generateFieldTypesMapsByNamespace(
       models,
       codecLookup,
       resolveFieldTypeParams,
-      domainEnumLookup,
+      resolveFieldValueSet,
     );
     const nsKey = `readonly ${serializeObjectKey(nsId)}`;
     outputNamespaceEntries.push(`${nsKey}: ${inner.output}`);

packages/1-framework/3-tooling/emitter/src/generate-contract-dts.ts

@@ -3,7 +3,6 @@ import type {
   ContractEnum,
   ContractModelBase,
   ContractValueObject,
-  ValueSetRef,
 } from '@prisma-next/contract/types';
 import { DomainNamespaceResolutionError } from '@prisma-next/contract/types';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
@@ -14,7 +13,6 @@ import type {
 } from '@prisma-next/framework-components/emission';
 import { blindCast } from '@prisma-next/utils/casts';
 import {
-  type DomainEnumLookup,
   deduplicateImports,
   generateCodecTypeIntersection,
   generateFieldTypesMapsByNamespace,
@@ -152,16 +150,10 @@ export function generateContractDts(
         emitter.resolveFieldTypeParams?.(modelName, fieldName, model, contract)
     : undefined;
 
-  const domainEnumLookup: DomainEnumLookup = (ref: ValueSetRef) => {
-    if (ref.entityKind !== 'enum') return undefined;
-    const ns = contract.domain.namespaces[ref.namespaceId];
-    if (!ns) return undefined;
-    const enumBlock = blindCast<
-      Record<string, ContractEnum> | undefined,
-      'ns.enum is an optional ContractEnum record in the emitted IR'
-    >(ns.enum);
-    return enumBlock?.[ref.entityName];
-  };
+  const resolveFieldValueSet = emitter.resolveFieldValueSet
+    ? (modelName: string, fieldName: string, model: ContractModelBase) =>
+        emitter.resolveFieldValueSet?.(modelName, fieldName, model, contract)
+    : undefined;
 
   const namespaceModelsForFieldTypes = namespaceEntries.map(
     ([nsId, ns]) => [nsId, ns.models] as const,
@@ -171,7 +163,7 @@ export function generateContractDts(
     namespaceModelsForFieldTypes,
     codecLookup,
     resolveFieldTypeParams,
-    domainEnumLookup,
+    resolveFieldValueSet,
   );
 
   const extraTypeExports = emitter.getStorageTypeExports?.(contract, codecLookup);