@prisma-next/sql-contract-ts 0.13.0-dev.1 → 0.13.0-dev.10

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.13.0-dev.1",
+  "version": "0.13.0-dev.10",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL-specific TypeScript contract authoring surface for Prisma Next",
   "dependencies": {
-    "@prisma-next/config": "0.13.0-dev.1",
-    "@prisma-next/contract": "0.13.0-dev.1",
-    "@prisma-next/contract-authoring": "0.13.0-dev.1",
-    "@prisma-next/framework-components": "0.13.0-dev.1",
-    "@prisma-next/sql-contract": "0.13.0-dev.1",
-    "@prisma-next/utils": "0.13.0-dev.1",
+    "@prisma-next/config": "0.13.0-dev.10",
+    "@prisma-next/contract": "0.13.0-dev.10",
+    "@prisma-next/contract-authoring": "0.13.0-dev.10",
+    "@prisma-next/framework-components": "0.13.0-dev.10",
+    "@prisma-next/sql-contract": "0.13.0-dev.10",
+    "@prisma-next/utils": "0.13.0-dev.10",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3",
     "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.13.0-dev.1",
-    "@prisma-next/tsconfig": "0.13.0-dev.1",
+    "@prisma-next/test-utils": "0.13.0-dev.10",
+    "@prisma-next/tsconfig": "0.13.0-dev.10",
     "@types/pg": "8.20.0",
     "pg": "8.21.0",
-    "@prisma-next/tsdown": "0.13.0-dev.1",
+    "@prisma-next/tsdown": "0.13.0-dev.10",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/build-contract.ts

@@ -6,7 +6,6 @@ import {
 import {
   asNamespaceId,
   type ColumnDefault,
-  type ColumnDefaultLiteralInputValue,
   type Contract,
   type ContractEnum,
   type ContractField,
@@ -63,16 +62,15 @@ type DomainFieldRef =
   | { readonly kind: 'scalar'; readonly many?: boolean }
   | { readonly kind: 'valueObject'; readonly name: string; readonly many?: boolean };
 
-function encodeDefaultLiteralValue(
-  value: ColumnDefaultLiteralInputValue,
-  codecId: string,
-  codecLookup?: CodecLookup,
-): JsonValue {
+function encodeViaCodec(value: unknown, codecId: string, codecLookup?: CodecLookup): JsonValue {
   const codec = codecLookup?.get(codecId);
   if (codec) {
     return codec.encodeJson(value);
   }
-  return value as JsonValue;
+  return blindCast<
+    JsonValue,
+    'no codec lookup at build time: literal/enum member value is already JSON-safe'
+  >(value);
 }
 
 function encodeColumnDefault(
@@ -85,7 +83,7 @@ function encodeColumnDefault(
   }
   return {
     kind: 'literal',
-    value: encodeDefaultLiteralValue(defaultInput.value, codecId, codecLookup),
+    value: encodeViaCodec(defaultInput.value, codecId, codecLookup),
   };
 }
 
@@ -771,7 +769,10 @@ export function buildSqlContractFromDefinition(
     }
     domainSlot[enumName] = {
       codecId: handle.codecId,
-      members: handle.enumMembers,
+      members: handle.enumMembers.map((m) => ({
+        name: m.name,
+        value: encodeViaCodec(m.value, handle.codecId, codecLookup),
+      })),
     };
 
     let storageSlot = storageValueSetsByNs[nsId];
@@ -781,7 +782,7 @@ export function buildSqlContractFromDefinition(
     }
     storageSlot[enumName] = {
       kind: 'value-set',
-      values: handle.values,
+      values: handle.values.map((v) => encodeViaCodec(v, handle.codecId, codecLookup)),
     };
   }
 

package/src/contract-builder.ts

@@ -62,6 +62,7 @@ type ContractDefinition<
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
   Namespaces extends readonly string[] | undefined = undefined,
+  Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 > = {
   readonly family: Family;
   readonly target: Target;
@@ -75,7 +76,7 @@ type ContractDefinition<
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
-  readonly enums?: Record<string, EnumTypeHandle>;
+  readonly enums?: Enums;
 };
 
 type ContractScaffold<
@@ -86,6 +87,7 @@ type ContractScaffold<
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
   Namespaces extends readonly string[] | undefined = undefined,
+  Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 > = {
   readonly family: Family;
   readonly target: Target;
@@ -99,7 +101,7 @@ type ContractScaffold<
   readonly types?: never;
   readonly models?: never;
   readonly codecLookup?: CodecLookup;
-  readonly enums?: Record<string, EnumTypeHandle>;
+  readonly enums?: Enums;
 };
 
 type ContractFactory<
@@ -108,9 +110,11 @@ type ContractFactory<
   Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
   Models extends Record<string, ModelLike>,
   ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
+  Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 > = (helpers: ComposedAuthoringHelpers<Family, Target, ExtensionPacks>) => {
   readonly types?: Types;
   readonly models?: Models;
+  readonly enums?: Enums;
 };
 
 function validateTargetPackRef(
@@ -324,6 +328,20 @@ type BoundDefinitionInput<
   readonly enums?: Record<string, EnumTypeHandle>;
 };
 
+// A bare `Record<string, EnumTypeHandle>` (no literal keys) is the widened
+// default for a side that declared no enums; drop it so the merge keeps only
+// literally-authored enum handles.
+type LiteralEnums<E extends Record<string, EnumTypeHandle>> = string extends keyof E
+  ? Record<never, never>
+  : E;
+
+// Merges enum handles authored on the scaffold definition with those returned
+// from the factory callback. Either side may be the widened default (empty).
+export type MergeEnums<
+  ScaffoldEnums extends Record<string, EnumTypeHandle>,
+  FactoryEnums extends Record<string, EnumTypeHandle>,
+> = LiteralEnums<ScaffoldEnums> & LiteralEnums<FactoryEnums>;
+
 // Merges a bound input with the pre-bound family/target to produce a full ContractDefinition.
 type WithFamilyTarget<
   Input,
@@ -375,6 +393,7 @@ export function buildBoundContract<
   const Built extends {
     readonly types?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
     readonly models?: Record<string, ModelLike>;
+    readonly enums?: Record<string, EnumTypeHandle>;
   },
 >(
   family: F,
@@ -399,6 +418,7 @@ export function buildBoundContract(
       ) => {
         readonly types?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
         readonly models?: Record<string, ModelLike>;
+        readonly enums?: Record<string, EnumTypeHandle>;
       })
     | undefined,
 ) {
@@ -412,10 +432,12 @@ export function buildBoundContract(
         extensionPacks: definition.extensionPacks,
       }),
     );
+    const mergedEnums = { ...(definition.enums ?? {}), ...built.enums };
     return buildContractFromDsl({
       ...full,
       ...ifDefined('types', built.types),
       ...ifDefined('models', built.models),
+      ...ifDefined('enums', Object.keys(mergedEnums).length > 0 ? mergedEnums : undefined),
     });
   }
 
@@ -437,6 +459,7 @@ export function defineContract<
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
   const Namespaces extends readonly string[] | undefined = undefined,
+  const Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 >(
   definition: ContractDefinition<
     Family,
@@ -447,7 +470,8 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    Enums
   >,
 ): SqlContractResult<
   ContractDefinition<
@@ -459,7 +483,8 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    Enums
   >
 >;
 export function defineContract<
@@ -477,6 +502,8 @@ export function defineContract<
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
   const Namespaces extends readonly string[] | undefined = undefined,
+  const ScaffoldEnums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
+  const FactoryEnums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 >(
   definition: ContractScaffold<
     Family,
@@ -485,9 +512,10 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    ScaffoldEnums
   >,
-  factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks>,
+  factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks, FactoryEnums>,
 ): SqlContractResult<
   ContractDefinition<
     Family,
@@ -498,7 +526,8 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    MergeEnums<ScaffoldEnums, FactoryEnums>
   >
 >;
 export function defineContract(

package/src/contract-types.ts

@@ -17,6 +17,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 +334,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 ResolveFieldColumnTypeRef<Definition, FieldState> = [FieldTypeRefOf<FieldState>] extends [
+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> = [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 +581,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
@@ -610,29 +664,53 @@ 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> = {
+  | ([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);
+
+type FieldChannelTypes<Definition, Channel extends 'output' | 'input'> = {
   readonly [ModelName in ModelNames<Definition>]: {
-    readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldOutputType<
+    readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldChannelType<
       Definition,
       ModelName,
-      FieldName
+      FieldName,
+      Channel
     >;
   };
 };
@@ -646,11 +724,12 @@ export type SqlContractResult<Definition> = ContractWithTypeMaps<
       ? 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/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';