@prisma-next/sql-contract-ts 0.13.0-dev.4 → 0.13.0-dev.40

package/src/contract-lowering.ts

@@ -1,10 +1,6 @@
 import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef } from '@prisma-next/framework-components/components';
-import {
-  isPostgresEnumStorageEntry,
-  type PostgresEnumStorageEntry,
-  type StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type {
   ContractDefinition,
@@ -59,15 +55,15 @@ type RuntimeModelSpec = {
 };
 
 type RuntimeCollection = {
-  readonly storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  readonly storageTypes: Record<string, StorageTypeInstance>;
   readonly models: Record<string, RuntimeModel>;
   readonly modelSpecs: ReadonlyMap<string, RuntimeModelSpec>;
 };
 
 function buildStorageTypeReverseLookup(
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
-): ReadonlyMap<StorageTypeInstance | PostgresEnumStorageEntry, string> {
-  const lookup = new Map<StorageTypeInstance | PostgresEnumStorageEntry, string>();
+  storageTypes: Record<string, StorageTypeInstance>,
+): ReadonlyMap<StorageTypeInstance, string> {
+  const lookup = new Map<StorageTypeInstance, string>();
   for (const [key, instance] of Object.entries(storageTypes)) {
     lookup.set(instance, key);
   }
@@ -78,8 +74,8 @@ function resolveFieldDescriptor(
   modelName: string,
   fieldName: string,
   fieldState: FieldStateOf<ScalarFieldBuilder>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
-  storageTypeReverseLookup: ReadonlyMap<StorageTypeInstance | PostgresEnumStorageEntry, string>,
+  storageTypes: Record<string, StorageTypeInstance>,
+  storageTypeReverseLookup: ReadonlyMap<StorageTypeInstance, string>,
 ): ColumnTypeDescriptor {
   if ('descriptor' in fieldState && fieldState.descriptor) {
     return fieldState.descriptor;
@@ -96,9 +92,7 @@ function resolveFieldDescriptor(
     const typeRef =
       typeof fieldState.typeRef === 'string'
         ? fieldState.typeRef
-        : storageTypeReverseLookup.get(
-            fieldState.typeRef as StorageTypeInstance | PostgresEnumStorageEntry,
-          );
+        : storageTypeReverseLookup.get(fieldState.typeRef as StorageTypeInstance);
 
     if (!typeRef) {
       throw new Error(
@@ -113,11 +107,8 @@ function resolveFieldDescriptor(
       );
     }
 
-    const codecId = isPostgresEnumStorageEntry(referencedType)
-      ? referencedType.codecId
-      : referencedType.codecId;
     return {
-      codecId,
+      codecId: referencedType.codecId,
       nativeType: referencedType.nativeType,
       typeRef,
     };
@@ -705,8 +696,8 @@ function resolveForeignKeyNodes(
 function resolveModelNode(
   spec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
-  storageTypeReverseLookup: ReadonlyMap<StorageTypeInstance | PostgresEnumStorageEntry, string>,
+  storageTypes: Record<string, StorageTypeInstance>,
+  storageTypeReverseLookup: ReadonlyMap<StorageTypeInstance, string>,
   extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>,
 ): ModelNode {
   const fields: FieldNode[] = [];
@@ -783,10 +774,7 @@ function resolveModelNode(
 }
 
 function collectRuntimeModelSpecs(definition: ContractInput): RuntimeCollection {
-  const storageTypes = { ...(definition.types ?? {}) } as Record<
-    string,
-    StorageTypeInstance | PostgresEnumStorageEntry
-  >;
+  const storageTypes = { ...(definition.types ?? {}) } as Record<string, StorageTypeInstance>;
   const models = { ...(definition.models ?? {}) } as Record<string, RuntimeModel>;
 
   emitTypedNamedTypeFallbackWarnings(models, storageTypes);

package/src/contract-types.ts

@@ -1,7 +1,9 @@
 import type {
   ColumnDefault,
   Contract,
+  ContractEnum,
   ContractRelation,
+  ContractValueObject,
   NamespaceId,
   StorageHashBase,
 } from '@prisma-next/contract/types';
@@ -17,6 +19,7 @@ import type {
 } from '@prisma-next/sql-contract/types';
 import type { UnionToIntersection } from './authoring-type-utils';
 import type { AttributeStageIdFieldNames, FieldStateOf, ScalarFieldBuilder } from './contract-dsl';
+import type { EnumTypeHandle } from './enum-type';
 
 export type ExtractCodecTypesFromPack<P> = P extends { __codecTypes?: infer C }
   ? C extends Record<string, { output: unknown }>
@@ -333,17 +336,39 @@ type ResolveNamedStorageType<Definition, TypeRef> =
       : StorageTypeInstance
     : StorageTypeInstance;
 
-type ResolveFieldDescriptor<Definition, FieldState> = [FieldDescriptorOf<FieldState>] extends [
-  never,
-]
-  ? ResolveNamedStorageType<Definition, FieldTypeRefOf<FieldState>>
-  : FieldDescriptorOf<FieldState>;
+// An enum-typed field carries its `EnumTypeHandle` (an object with a `codecId`
+// and `nativeType`, but no `kind`) as the field's `typeRef`. It is neither a
+// string nor a registered `StorageType`, so the named-type lookup cannot reach
+// it; `EnumFieldHandle` short-circuits the resolvers to read codec + native type
+// straight off the handle, with no column type-ref (the enum name is carried
+// elsewhere). The `[...] extends [never]` guard excludes plain column fields,
+// whose `typeRef` is `never`.
+type EnumFieldHandle<FieldState> = [FieldTypeRefOf<FieldState>] extends [never]
+  ? never
+  : FieldTypeRefOf<FieldState> extends EnumTypeHandle
+    ? FieldTypeRefOf<FieldState>
+    : never;
+
+type EnumHandleDescriptor<Handle> = Handle extends {
+  readonly codecId: infer CodecId extends string;
+  readonly nativeType: infer NativeType extends string;
+}
+  ? { readonly codecId: CodecId; readonly nativeType: NativeType }
+  : never;
+
+type ResolveFieldDescriptor<Definition, FieldState> = [EnumFieldHandle<FieldState>] extends [never]
+  ? [FieldDescriptorOf<FieldState>] extends [never]
+    ? ResolveNamedStorageType<Definition, FieldTypeRefOf<FieldState>>
+    : FieldDescriptorOf<FieldState>
+  : EnumHandleDescriptor<EnumFieldHandle<FieldState>>;
 
-type ResolveFieldColumnTypeRef<Definition, FieldState> = [FieldTypeRefOf<FieldState>] extends [
+type ResolveFieldColumnTypeRef<Definition, FieldState> = [EnumFieldHandle<FieldState>] extends [
   never,
 ]
-  ? DescriptorTypeRef<FieldDescriptorOf<FieldState>>
-  : ResolveNamedStorageTypeKey<Definition, FieldTypeRefOf<FieldState>>;
+  ? [FieldTypeRefOf<FieldState>] extends [never]
+    ? DescriptorTypeRef<FieldDescriptorOf<FieldState>>
+    : ResolveNamedStorageTypeKey<Definition, FieldTypeRefOf<FieldState>>
+  : undefined;
 
 type ResolveFieldColumnTypeParams<Definition, FieldState> = [
   ResolveFieldColumnTypeRef<Definition, FieldState>,
@@ -558,6 +583,37 @@ type BuiltStorageTables<Definition> = {
     : Record<string, never>);
 };
 
+type DefinitionEnums<Definition> = Definition extends {
+  readonly enums?: infer E;
+}
+  ? Present<E> extends Record<string, EnumTypeHandle>
+    ? // A bare `Record<string, EnumTypeHandle>` (no literal keys) is the
+      // widened default for a contract authored without enums; treat it as
+      // empty so `db.enums` carries only literally-authored enums.
+      string extends keyof Present<E>
+      ? Record<never, never>
+      : Present<E>
+    : Record<never, never>
+  : Record<never, never>;
+
+type EnumHandleAccessorType<Handle> =
+  Handle extends EnumTypeHandle<infer _Name, infer Values, infer Names, infer MembersMap>
+    ? {
+        readonly values: Values;
+        readonly names: Names;
+        readonly members: MembersMap;
+        has(v: Values[number]): boolean;
+        nameOf(v: Values[number]): string | undefined;
+        ordinalOf(v: Values[number]): number;
+      }
+    : never;
+
+type BuiltEnumAccessors<Definition> = {
+  readonly [K in keyof DefinitionEnums<Definition>]: EnumHandleAccessorType<
+    DefinitionEnums<Definition>[K]
+  >;
+};
+
 type BuiltDocumentScopedTypes<Definition> = {
   readonly [K in keyof DefinitionTypes<Definition> as DefinitionTypes<Definition>[K] extends StorageTypeInstance
     ? K
@@ -573,6 +629,17 @@ type BuiltDomain<Definition> =
         };
       };
 
+// Per-namespace domain entry carrying the precise per-model field/storage shapes
+// for DSL inference. Modelled as an index signature (rather than enumerating
+// namespace ids) so that any namespace coordinate resolves the full model map,
+// matching how the authoring path lumps every model under the default storage
+// namespace.
+type BuiltDomainNamespace<Definition> = {
+  readonly models: BuiltModels<Definition>;
+  readonly valueObjects?: Record<string, ContractValueObject>;
+  readonly enum?: Record<string, ContractEnum>;
+};
+
 type DefaultStorageNamespaceId<Definition> =
   DefinitionTargetId<Definition> extends 'postgres' ? 'public' : '__unbound__';
 
@@ -610,47 +677,83 @@ type BuiltStorage<Definition> = {
   };
 };
 
-type FieldOutputType<
+// The enum value union for an enum-typed field, or `never` for a non-enum
+// field. The field's `typeRef` carries the authored `EnumTypeHandle`, whose
+// `Values` tuple preserves the literal member values (text or numeric).
+type EnumValueUnion<FieldState> = [FieldTypeRefOf<FieldState>] extends [
+  EnumTypeHandle<string, infer Values>,
+]
+  ? readonly unknown[] extends Values
+    ? never
+    : Values[number]
+  : never;
+
+// The codec's `output` / `input` JS type for a field's column, before
+// nullability. `unknown` when the codec is not in the definition's codec map.
+type CodecChannelType<
   Definition,
   ModelName extends ModelNames<Definition>,
   FieldName extends ModelFieldNames<Definition, ModelName>,
+  Channel extends 'output' | 'input',
+> = ModelStorageColumn<Definition, ModelName, FieldName>['codecId'] extends infer Id extends
+  keyof CodecTypesFromDefinition<Definition>
+  ? CodecTypesFromDefinition<Definition>[Id] extends { readonly [K in Channel]: infer T }
+    ? T
+    : unknown
+  : unknown;
+
+// A field's read/write JS type: the enum value union when the field is
+// enum-typed, otherwise the codec channel type, with column nullability applied.
+type FieldChannelType<
+  Definition,
+  ModelName extends ModelNames<Definition>,
+  FieldName extends ModelFieldNames<Definition, ModelName>,
+  Channel extends 'output' | 'input',
 > =
-  ModelStorageColumn<Definition, ModelName, FieldName> extends infer Col
-    ? Col extends { readonly codecId: infer Id extends string }
-      ? Id extends keyof CodecTypesFromDefinition<Definition>
-        ? CodecTypesFromDefinition<Definition>[Id] extends { readonly output: infer O }
-          ? Col extends { readonly nullable: true }
-            ? O | null
-            : O
-          : unknown
-        : unknown
-      : unknown
-    : unknown;
-
-type FieldOutputTypes<Definition> = {
-  readonly [ModelName in ModelNames<Definition>]: {
-    readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldOutputType<
-      Definition,
-      ModelName,
-      FieldName
-    >;
+  | ([EnumValueUnion<ModelFieldState<Definition, ModelName, FieldName>>] extends [never]
+      ? CodecChannelType<Definition, ModelName, FieldName, Channel>
+      : EnumValueUnion<ModelFieldState<Definition, ModelName, FieldName>>)
+  | (FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>> extends true
+      ? null
+      : never);
+
+// Nested by namespace coordinate (`{ [ns]: { [model]: { [field]: type } } }`)
+// to mirror the emitter's namespace-nested `FieldOutputTypes` (and the
+// `TypeMaps` constraint). The TS authoring path lumps every model under the
+// target's default storage namespace (see `BuiltStorage`), so the per-model
+// field-type map nests under that same coordinate.
+type FieldChannelTypes<Definition, Channel extends 'output' | 'input'> = {
+  readonly [Ns in DefaultStorageNamespaceId<Definition>]: {
+    readonly [ModelName in ModelNames<Definition>]: {
+      readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldChannelType<
+        Definition,
+        ModelName,
+        FieldName,
+        Channel
+      >;
+    };
   };
 };
 
 export type SqlContractResult<Definition> = ContractWithTypeMaps<
-  Contract<BuiltStorage<Definition>, BuiltModels<Definition>> & {
+  Omit<Contract<BuiltStorage<Definition>>, 'domain'> & {
     readonly target: DefinitionTargetId<Definition>;
     readonly targetFamily: 'sql';
-  } & { readonly domain: BuiltDomain<Definition> } & {
+  } & {
+    readonly domain: {
+      readonly namespaces: Readonly<Record<string, BuiltDomainNamespace<Definition>>>;
+    } & BuiltDomain<Definition>;
+  } & {
     readonly extensionPacks: keyof DefinitionExtensionPacks<Definition> extends never
       ? Record<string, never>
       : DefinitionExtensionPacks<Definition>;
     readonly capabilities: DerivedCapabilities<Definition>;
+    readonly enumAccessors: BuiltEnumAccessors<Definition>;
   },
   TypeMaps<
     CodecTypesFromDefinition<Definition>,
     Record<string, never>,
-    Record<string, never>,
-    FieldOutputTypes<Definition>
+    FieldChannelTypes<Definition, 'output'>,
+    FieldChannelTypes<Definition, 'input'>
   >
 >;

package/src/contract-warnings.ts

@@ -1,7 +1,4 @@
-import type {
-  PostgresEnumStorageEntry,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import {
   type ContractModelBuilder,
   type ModelAttributesSpec,
@@ -28,7 +25,7 @@ type RuntimeModelSpec = {
 };
 
 type RuntimeCollection = {
-  readonly storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  readonly storageTypes: Record<string, StorageTypeInstance>;
   readonly models: Record<string, RuntimeModel>;
   readonly modelSpecs: ReadonlyMap<string, RuntimeModelSpec>;
 };
@@ -136,7 +133,7 @@ function formatFallbackWarning(location: string, current: string, suggested: str
 
 export function emitTypedNamedTypeFallbackWarnings(
   models: Record<string, RuntimeModel>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+  storageTypes: Record<string, StorageTypeInstance>,
 ): void {
   const warnings: string[] = [];
   const warnedFields = new Set<string>();

package/src/enum-type.ts

@@ -8,24 +8,27 @@ import { blindCast } from '@prisma-next/utils/casts';
 /**
  * A single enum member produced by `member()`. The `Name` and `Value` generics
  * are preserved as literal types so `enumType()` can carry the ordered value
- * tuple in its return type.
+ * tuple in its return type. `Value` is whatever the codec dictates — its type
+ * is constrained at `enumType` against the codec's input type, not here.
  */
-export interface EnumMember<Name extends string, Value extends string> {
+export interface EnumMember<Name extends string, Value> {
   readonly name: Name;
   readonly value: Value;
 }
 
 /**
- * Declare an enum member. The `value` defaults to `name` when omitted.
- * Both generics are preserved as literals so downstream `enumType` can
- * carry the ordered value tuple in its type.
+ * Declare an enum member. The `value` defaults to `name` when omitted. The
+ * value is an unconstrained literal here; `enumType` constrains it against the
+ * codec's input type. Both generics are preserved as literals so downstream
+ * `enumType` carries the value union in its type; the value is serialized to its
+ * codec string form only at lowering.
  */
 export function member<const Name extends string>(name: Name): EnumMember<Name, Name>;
-export function member<const Name extends string, const Value extends string>(
+export function member<const Name extends string, const Value>(
   name: Name,
   value: Value,
 ): EnumMember<Name, Value>;
-export function member<const Name extends string, const Value extends string = Name>(
+export function member<const Name extends string, const Value = Name>(
   name: Name,
   value?: Value,
 ): EnumMember<Name, Value> {
@@ -42,15 +45,15 @@ export function member<const Name extends string, const Value extends string = N
 // Internal types for inferring the literal tuple from the members spread
 // ---------------------------------------------------------------------------
 
-type MembersToValues<Members extends readonly EnumMember<string, string>[]> = {
+type MembersToValues<Members extends readonly EnumMember<string, unknown>[]> = {
   readonly [K in keyof Members]: Members[K] extends EnumMember<string, infer V> ? V : never;
 };
 
-type MembersToNames<Members extends readonly EnumMember<string, string>[]> = {
-  readonly [K in keyof Members]: Members[K] extends EnumMember<infer N, string> ? N : never;
+type MembersToNames<Members extends readonly EnumMember<string, unknown>[]> = {
+  readonly [K in keyof Members]: Members[K] extends EnumMember<infer N, unknown> ? N : never;
 };
 
-type MembersAccessorMap<Members extends readonly EnumMember<string, string>[]> = {
+type MembersAccessorMap<Members extends readonly EnumMember<string, unknown>[]> = {
   readonly [M in Members[number] as M['name']]: M['value'];
 };
 
@@ -80,9 +83,9 @@ export const ENUM_TYPE_HANDLE_BRAND = Symbol('EnumTypeHandle');
  */
 export interface EnumTypeHandle<
   Name extends string = string,
-  Values extends readonly string[] = readonly string[],
+  Values extends readonly unknown[] = readonly unknown[],
   Names extends readonly string[] = readonly string[],
-  MembersMap extends Record<string, string> = Record<string, string>,
+  MembersMap extends Record<string, unknown> = Record<string, unknown>,
 > {
   /** Internal brand for lowering-pipeline detection. */
   readonly [ENUM_TYPE_HANDLE_BRAND]: true;
@@ -97,7 +100,7 @@ export interface EnumTypeHandle<
   readonly nativeType: string;
 
   /** Ordered member list for lowering (name + value pairs). */
-  readonly enumMembers: readonly { readonly name: string; readonly value: string }[];
+  readonly enumMembers: readonly { readonly name: string; readonly value: Values[number] }[];
 
   /** Ordered literal value tuple. Declaration order is preserved. */
   readonly values: Values;
@@ -112,19 +115,43 @@ export interface EnumTypeHandle<
   readonly members: MembersMap;
 
   /** Returns `true` if `v` is a declared member value. */
-  has(v: string): boolean;
+  has(v: Values[number]): boolean;
 
   /** Returns the member name for a value, or `undefined` if not found. */
-  nameOf(v: string): string | undefined;
+  nameOf(v: Values[number]): string | undefined;
 
   /** Returns the zero-based declaration index of a value, or `-1` if not found. */
-  ordinalOf(v: string): number;
+  ordinalOf(v: Values[number]): number;
 }
 
 // ---------------------------------------------------------------------------
 // enumType()
 // ---------------------------------------------------------------------------
 
+/**
+ * A codec typemap: codecId → `{ input, output }`, the same shape the query
+ * lanes consume (e.g. `{ 'pg/text@1': { input: string }, 'pg/int4@1': { input: number } }`).
+ * The bound `enumType` wrappers supply the target pack's typemap; the core
+ * defaults to an empty map (no codec is known), so member values stay
+ * unconstrained.
+ */
+export type CodecTypeMap = Record<string, { readonly input?: unknown }>;
+
+/**
+ * The application input type the codec dictates for an enum's member values:
+ * looks `Codec['codecId']` up in the supplied codec typemap. When the codecId
+ * isn't in the map (the core's empty default, or an unknown codec) the input is
+ * unconstrained, so any member-value literal is accepted and inferred verbatim.
+ */
+export type CodecInput<
+  CodecTypes extends CodecTypeMap,
+  Codec extends { readonly codecId: string },
+> = Codec['codecId'] extends keyof CodecTypes
+  ? CodecTypes[Codec['codecId']] extends { readonly input: infer In }
+    ? In
+    : unknown
+  : unknown;
+
 /**
  * Declare a domain enum for use in TS-authoring contracts.
  *
@@ -152,9 +179,16 @@ export interface EnumTypeHandle<
  * ```
  */
 export function enumType<
-  const Name extends string,
-  const Codec extends Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'>,
-  const Members extends readonly [EnumMember<string, string>, ...EnumMember<string, string>[]],
+  CodecTypes extends CodecTypeMap = Record<string, never>,
+  const Name extends string = string,
+  const Codec extends Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'> = Pick<
+    ColumnTypeDescriptor,
+    'codecId' | 'nativeType'
+  >,
+  const Members extends readonly [
+    EnumMember<string, CodecInput<CodecTypes, Codec>>,
+    ...EnumMember<string, CodecInput<CodecTypes, Codec>>[],
+  ] = readonly [EnumMember<string, CodecInput<CodecTypes, Codec>>],
 >(
   name: Name,
   codec: Codec,
@@ -168,12 +202,12 @@ export function enumType<
 export function enumType(
   name: string,
   codec: Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'>,
-  ...members: EnumMember<string, string>[]
+  ...members: EnumMember<string, unknown>[]
 ): EnumTypeHandle;
 export function enumType(
   name: string,
   codec: Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'>,
-  ...members: EnumMember<string, string>[]
+  ...members: EnumMember<string, unknown>[]
 ): EnumTypeHandle {
   if (members.length === 0) {
     throw new Error(`enumType("${name}"): must have at least one member.`);
@@ -189,12 +223,13 @@ export function enumType(
     }
     seenNames.add(m.name);
 
-    if (seenValues.has(m.value)) {
+    const loweredValue = String(m.value);
+    if (seenValues.has(loweredValue)) {
       throw new Error(
-        `enumType("${name}"): duplicate member value "${m.value}". Member values must be unique.`,
+        `enumType("${name}"): duplicate member value "${loweredValue}". Member values must be unique.`,
       );
     }
-    seenValues.add(m.value);
+    seenValues.add(loweredValue);
   }
 
   const values = Object.freeze(members.map((m) => m.value));
@@ -216,12 +251,47 @@ export function enumType(
     values,
     names,
     members: membersAccessor,
-    has: (v: string) => valueSet.has(v),
-    nameOf: (v: string) => valueToName.get(v),
-    ordinalOf: (v: string) => valueToOrdinal.get(v) ?? -1,
+    has: (v: unknown) => valueSet.has(v),
+    nameOf: (v: unknown) => valueToName.get(v),
+    ordinalOf: (v: unknown) => valueToOrdinal.get(v) ?? -1,
   };
 }
 
+/**
+ * The signature of an `enumType` whose codec typemap is already bound — the
+ * shape a target-bound wrapper (e.g. `@prisma-next/postgres/contract-builder`)
+ * exposes. The member values are constrained to the codec's input type drawn
+ * from `CodecTypes` (so a `pg/text@1` codec rejects numeric members, etc.),
+ * while `Name`, `Codec`, and the member tuple still infer from the call.
+ */
+export type BoundEnumType<CodecTypes extends CodecTypeMap> = <
+  const Name extends string,
+  const Codec extends Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'>,
+  const Members extends readonly [
+    EnumMember<string, CodecInput<CodecTypes, Codec>>,
+    ...EnumMember<string, CodecInput<CodecTypes, Codec>>[],
+  ],
+>(
+  name: Name,
+  codec: Codec,
+  ...members: Members
+) => EnumTypeHandle<
+  Name,
+  MembersToValues<[...Members]>,
+  MembersToNames<[...Members]>,
+  MembersAccessorMap<[...Members]>
+>;
+
+/**
+ * Bind `enumType` to a target's codec typemap. The returned function is the
+ * same runtime `enumType`, retyped so member values are constrained to the
+ * codec's input type. Target packages call this with their pack's
+ * `ExtractCodecTypesFromPack<Pack>` to expose a codec-aware `enumType`.
+ */
+export function bindEnumType<CodecTypes extends CodecTypeMap>(): BoundEnumType<CodecTypes> {
+  return enumType;
+}
+
 /**
  * Returns true when the value is an `EnumTypeHandle` produced by
  * `enumType()`. Used in the lowering pipeline to detect enum handles

package/src/exports/contract-builder.ts

@@ -2,6 +2,7 @@ export type {
   ComposedAuthoringHelpers,
   ContractInput,
   ContractModelBuilder,
+  MergeEnums,
   ModelLike,
   ScalarFieldBuilder,
 } from '../contract-builder';
@@ -25,5 +26,12 @@ export type {
   UniqueConstraintNode,
 } from '../contract-definition';
 export type { TargetFieldRef } from '../contract-dsl';
-export type { EnumMember, EnumTypeHandle } from '../enum-type';
-export { enumType, member } from '../enum-type';
+export type { ExtractCodecTypesFromPack } from '../contract-types';
+export type {
+  BoundEnumType,
+  CodecInput,
+  CodecTypeMap,
+  EnumMember,
+  EnumTypeHandle,
+} from '../enum-type';
+export { bindEnumType, enumType, member } from '../enum-type';