@prisma-next/sql-contract-ts 0.14.0-dev.8 → 0.14.0-dev.81

package/src/contract-lowering.ts

@@ -1,8 +1,18 @@
+import {
+  type AuthoringEntityTypeNamespace,
+  isAuthoringEntityTypeDescriptor,
+} from '@prisma-next/framework-components/authoring';
 import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef } from '@prisma-next/framework-components/components';
+import {
+  providesEntityHandleLowering,
+  type ResolvedEntityHandleRef,
+  type ResolvedPackEntityHandle,
+} from '@prisma-next/sql-contract/entity-handle-lowering-hook';
 import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type {
+  AttachedEntities,
   ContractDefinition,
   FieldNode,
   ForeignKeyNode,
@@ -19,6 +29,7 @@ import {
   type FieldStateOf,
   type ForeignKeyConstraint,
   type IdConstraint,
+  isCrossSpaceHandle,
   type ModelAttributesSpec,
   normalizeRelationFieldNames,
   type RelationBuilder,
@@ -727,6 +738,7 @@ function resolveModelNode(
       columnName,
       descriptor,
       nullable: fieldState.nullable,
+      ...(fieldState.many === true ? { many: true } : {}),
       ...(fieldState.default ? { default: fieldState.default } : {}),
       ...(fieldState.executionDefaults ? { executionDefaults: fieldState.executionDefaults } : {}),
       ...(enumHandle !== undefined ? { enumTypeHandle: enumHandle } : {}),
@@ -863,9 +875,150 @@ function lowerModels(
   );
 }
 
+/**
+ * Kind-agnostic walk over the author-declared `entities` handle list:
+ *
+ * 1. Index the bound packs' `entityTypes` contributions by discriminator so
+ *    each handle's `entityKind` maps to the pack that registered it; a
+ *    handle whose kind no composed pack registers is an error naming the
+ *    kind.
+ * 2. Resolve each handle's declared model refs (`handle.refs`, actual
+ *    model-handle objects) to storage table coordinates — identity against
+ *    the contract's `models` record first, then the handle's declared model
+ *    name against the build's model specs; never by re-deriving a table
+ *    name. A cross-space (extensionModel) handle resolves to its own
+ *    coordinate annotated with `spaceId`.
+ * 3. Call each owning pack's batch lowering hook once with all of its
+ *    claimed handles, and fold the returned rows into the namespace-scoped
+ *    attachments (namespace → kind → key), rejecting two different entities
+ *    in one slot. The result becomes `ContractDefinition.attachedEntities`.
+ *
+ * No entity kind is named anywhere in this walk.
+ */
+function lowerPackEntityHandles(
+  definition: ContractInput,
+  modelSpecs: ReadonlyMap<string, RuntimeModelSpec>,
+): AttachedEntities | undefined {
+  const entities = definition.entities;
+  if (entities === undefined || entities.length === 0) return undefined;
+
+  const components: readonly {
+    readonly authoring?: import('@prisma-next/framework-components/authoring').AuthoringContributions;
+  }[] = [
+    definition.target,
+    ...Object.values<ExtensionPackRef<'sql', string>>(definition.extensionPacks ?? {}),
+  ];
+  const owningComponent = new Map<string, (typeof components)[number]>();
+  const walkEntityTypes = (
+    namespace: AuthoringEntityTypeNamespace,
+    component: (typeof components)[number],
+  ): void => {
+    for (const value of Object.values(namespace)) {
+      if (isAuthoringEntityTypeDescriptor(value)) {
+        owningComponent.set(value.discriminator, component);
+      } else {
+        walkEntityTypes(value, component);
+      }
+    }
+  };
+  for (const component of components) {
+    const entityTypes = component.authoring?.entityTypes;
+    if (entityTypes !== undefined) walkEntityTypes(entityTypes, component);
+  }
+
+  const defaultNamespaceId = definition.target.defaultNamespaceId;
+  const modelNamesByIdentity = new Map<unknown, string>();
+  for (const [modelName, modelBuilder] of Object.entries(definition.models ?? {})) {
+    modelNamesByIdentity.set(modelBuilder, modelName);
+  }
+  const coordinateOf = (modelName: string): ResolvedEntityHandleRef | undefined => {
+    const spec = modelSpecs.get(modelName);
+    if (spec === undefined) return undefined;
+    return {
+      kind: 'resolved',
+      namespaceId: spec.namespace ?? defaultNamespaceId,
+      tableName: spec.tableName,
+      modelName,
+    };
+  };
+  const declaredModelName = (value: unknown): string | undefined => {
+    if (typeof value !== 'object' || value === null || !('stageOne' in value)) return undefined;
+    const stageOne = value.stageOne;
+    if (typeof stageOne !== 'object' || stageOne === null || !('modelName' in stageOne)) {
+      return undefined;
+    }
+    return typeof stageOne.modelName === 'string' ? stageOne.modelName : undefined;
+  };
+  const resolveRef = (value: unknown): ResolvedEntityHandleRef => {
+    const modelName = declaredModelName(value);
+    if (isCrossSpaceHandle(value)) {
+      const tableName = value.tableName;
+      const namespaceId = value.stageOne.namespace;
+      if (tableName !== undefined && namespaceId !== undefined) {
+        return {
+          kind: 'cross-space',
+          spaceId: value.spaceId,
+          namespaceId,
+          tableName,
+          ...ifDefined('modelName', modelName),
+        };
+      }
+      return { kind: 'unresolved', ...ifDefined('modelName', modelName) };
+    }
+    const identityName = modelNamesByIdentity.get(value);
+    const resolved =
+      (identityName !== undefined ? coordinateOf(identityName) : undefined) ??
+      (modelName !== undefined ? coordinateOf(modelName) : undefined);
+    return resolved ?? { kind: 'unresolved', ...ifDefined('modelName', modelName) };
+  };
+
+  const claimed = new Map<(typeof components)[number], ResolvedPackEntityHandle[]>();
+  for (const handle of entities) {
+    const component = owningComponent.get(handle.entityKind);
+    if (component === undefined) {
+      throw new Error(
+        `defineContract: entities contains a handle with entityKind "${handle.entityKind}", which no composed pack registers. Compose a pack whose entityTypes contribution claims "${handle.entityKind}", or remove the handle.`,
+      );
+    }
+    const refs: Record<string, ResolvedEntityHandleRef> = {};
+    for (const [refName, refValue] of Object.entries(handle.refs ?? {})) {
+      refs[refName] = resolveRef(refValue);
+    }
+    const forComponent = claimed.get(component) ?? [];
+    forComponent.push({ handle, refs });
+    claimed.set(component, forComponent);
+  }
+
+  const pack: Record<string, Record<string, Record<string, unknown>>> = {};
+  for (const [component, handles] of claimed) {
+    const authoring = component.authoring;
+    if (!providesEntityHandleLowering(authoring)) {
+      const kinds = [...new Set(handles.map((entry) => entry.handle.entityKind))].sort();
+      throw new Error(
+        `defineContract: entityKind(s) ${kinds.map((kind) => `"${kind}"`).join(', ')} are registered by a pack that does not implement entity-handle lowering (no lowerEntityHandles on its authoring contributions).`,
+      );
+    }
+    for (const row of authoring.lowerEntityHandles({ handles, defaultNamespaceId })) {
+      const forNamespace = pack[row.namespaceId] ?? {};
+      pack[row.namespaceId] = forNamespace;
+      const forKind = forNamespace[row.entityKind] ?? {};
+      forNamespace[row.entityKind] = forKind;
+      const existing = forKind[row.key];
+      if (existing !== undefined && existing !== row.entity) {
+        throw new Error(
+          `defineContract: two different "${row.entityKind}" entities named "${row.key}" in namespace "${row.namespaceId}" — pack-entity names must be unique per namespace.`,
+        );
+      }
+      forKind[row.key] = row.entity;
+    }
+  }
+  return pack;
+}
+
 export function buildContractDefinition(definition: ContractInput): ContractDefinition {
   const collection = collectRuntimeModelSpecs(definition);
   const models = lowerModels(collection, definition.extensionPacks);
+  const attachedEntities = lowerPackEntityHandles(definition, collection.modelSpecs);
 
   return {
     target: definition.target,
@@ -877,10 +1030,11 @@ export function buildContractDefinition(definition: ContractInput): ContractDefi
       ? { storageTypes: collection.storageTypes }
       : {}),
     ...(definition.namespaces ? { namespaces: definition.namespaces } : {}),
-    ...(definition.createNamespace ? { createNamespace: definition.createNamespace } : {}),
+    createNamespace: definition.createNamespace,
     ...(definition.enums && Object.keys(definition.enums).length > 0
       ? { enums: definition.enums }
       : {}),
+    ...(attachedEntities && Object.keys(attachedEntities).length > 0 ? { attachedEntities } : {}),
     models,
   };
 }

package/src/contract-types.ts

@@ -21,10 +21,10 @@ 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 }>
-    ? C
-    : Record<string, never>
+export type ExtractCodecTypesFromPack<P> = P extends {
+  __codecTypes?: infer C extends Record<string, { output: unknown }>;
+}
+  ? C
   : Record<string, never>;
 
 export type MergeExtensionCodecTypes<Packs extends Record<string, unknown>> = UnionToIntersection<
@@ -279,6 +279,8 @@ type FieldNullableOf<FieldState> = FieldState extends {
   ? Nullable
   : boolean;
 
+type FieldManyOf<FieldState> = FieldState extends { readonly many?: true } ? true : false;
+
 type FieldColumnOverrideOf<FieldState> = Present<
   FieldState extends { readonly columnName?: infer ColumnName } ? ColumnName : never
 >;
@@ -471,15 +473,17 @@ type StorageColumn<
   NativeType extends string,
   TypeRef extends string | undefined = undefined,
   TypeParams extends Record<string, unknown> | undefined = undefined,
+  Many extends boolean = false,
 > = {
   readonly nativeType: NativeType;
   readonly codecId: CodecId;
   readonly nullable: Nullable;
   readonly default?: ColumnDefault;
-} & (TypeRef extends string ? { readonly typeRef: TypeRef } : Record<string, never>) &
+} & (TypeRef extends string ? { readonly typeRef: TypeRef } : Record<never, never>) &
   (TypeParams extends Record<string, unknown>
     ? { readonly typeParams: TypeParams }
-    : Record<string, never>);
+    : Record<never, never>) &
+  (Many extends true ? { readonly many: true } : Record<never, never>);
 
 type ModelStorageColumn<
   Definition,
@@ -496,7 +500,8 @@ type ModelStorageColumn<
           ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName, FieldName>>
         >,
         ResolveFieldColumnTypeRef<Definition, ModelFieldState<Definition, ModelName, FieldName>>,
-        ResolveFieldColumnTypeParams<Definition, ModelFieldState<Definition, ModelName, FieldName>>
+        ResolveFieldColumnTypeParams<Definition, ModelFieldState<Definition, ModelName, FieldName>>,
+        FieldManyOf<ModelFieldState<Definition, ModelName, FieldName>>
       >
     : never;
 
@@ -677,6 +682,8 @@ type BuiltStorage<Definition> = {
   };
 };
 
+type StorageColumnManyOf<Col> = Col extends { readonly many: true } ? true : false;
+
 // 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).
@@ -688,6 +695,31 @@ type EnumValueUnion<FieldState> = [FieldTypeRefOf<FieldState>] extends [
     : Values[number]
   : never;
 
+// The member-value literal tuple carried on a descriptor's `entityRef.entity`
+// (e.g. a target's native-enum entity), or `never` when the descriptor has no
+// entityRef, its entity has no `members`, or `members` is widened to
+// `readonly string[]` — this is checked with non-optional property shapes so
+// a descriptor genuinely lacking `entityRef` fails the structural match
+// instead of matching vacuously through the framework type's optional slot.
+type DescriptorEntityMembers<Descriptor> = Descriptor extends {
+  readonly entityRef: {
+    readonly entity: { readonly members: infer Members extends readonly string[] };
+  };
+}
+  ? Members
+  : never;
+
+// The value-set member union for a descriptor-carried entity (the type-level
+// mirror of the runtime's generic `deriveValueSetFromEntity` fold), or
+// `never` for a field with no descriptor, a descriptor with no entityRef.entity,
+// or a widened (non-literal) members tuple — mirroring `EnumValueUnion`'s
+// erasure guard.
+type DescriptorValueSetUnion<FieldState> = [FieldDescriptorOf<FieldState>] extends [never]
+  ? never
+  : readonly string[] extends DescriptorEntityMembers<FieldDescriptorOf<FieldState>>
+    ? never
+    : DescriptorEntityMembers<FieldDescriptorOf<FieldState>>[number];
+
 // 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<
@@ -698,21 +730,33 @@ type CodecChannelType<
 > = ModelStorageColumn<Definition, ModelName, FieldName>['codecId'] extends infer Id extends
   keyof CodecTypesFromDefinition<Definition>
   ? CodecTypesFromDefinition<Definition>[Id] extends { readonly [K in Channel]: infer T }
-    ? T
+    ? StorageColumnManyOf<ModelStorageColumn<Definition, ModelName, FieldName>> extends true
+      ? ReadonlyArray<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.
+// The literal value union for a field: the enum-typed union takes precedence
+// (matching today's behavior), falling back to the descriptor-carried
+// value-set union; `never` when neither applies.
+type FieldValueUnion<FieldState> = [EnumValueUnion<FieldState>] extends [never]
+  ? DescriptorValueSetUnion<FieldState>
+  : EnumValueUnion<FieldState>;
+
+// A field's read/write JS type: the value union (enum or descriptor value-set)
+// when the field carries one, 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',
 > =
-  | ([EnumValueUnion<ModelFieldState<Definition, ModelName, FieldName>>] extends [never]
+  | ([FieldValueUnion<ModelFieldState<Definition, ModelName, FieldName>>] extends [never]
       ? CodecChannelType<Definition, ModelName, FieldName, Channel>
-      : EnumValueUnion<ModelFieldState<Definition, ModelName, FieldName>>)
+      : StorageColumnManyOf<ModelStorageColumn<Definition, ModelName, FieldName>> extends true
+        ? ReadonlyArray<FieldValueUnion<ModelFieldState<Definition, ModelName, FieldName>>>
+        : FieldValueUnion<ModelFieldState<Definition, ModelName, FieldName>>)
   | (FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>> extends true
       ? null
       : never);
@@ -735,6 +779,17 @@ type FieldChannelTypes<Definition, Channel extends 'output' | 'input'> = {
   };
 };
 
+type StorageColumnChannelTypes<Definition, Channel extends 'output' | 'input'> = {
+  readonly [Ns in DefaultStorageNamespaceId<Definition>]: {
+    readonly [ModelName in ModelNames<Definition> as BuiltModelTableName<Definition, ModelName>]: {
+      readonly [FieldName in ModelFieldNames<Definition, ModelName> as BuiltModelColumnMappings<
+        Definition,
+        ModelName
+      >[FieldName]['column']]: FieldChannelType<Definition, ModelName, FieldName, Channel>;
+    };
+  };
+};
+
 export type SqlContractResult<Definition> = ContractWithTypeMaps<
   Omit<Contract<BuiltStorage<Definition>>, 'domain'> & {
     readonly target: DefinitionTargetId<Definition>;
@@ -754,6 +809,8 @@ export type SqlContractResult<Definition> = ContractWithTypeMaps<
     CodecTypesFromDefinition<Definition>,
     Record<string, never>,
     FieldChannelTypes<Definition, 'output'>,
-    FieldChannelTypes<Definition, 'input'>
+    FieldChannelTypes<Definition, 'input'>,
+    StorageColumnChannelTypes<Definition, 'output'>,
+    StorageColumnChannelTypes<Definition, 'input'>
   >
 >;

package/src/enum-type.ts

@@ -1,306 +1,14 @@
-import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
-import { blindCast } from '@prisma-next/utils/casts';
-
-// ---------------------------------------------------------------------------
-// EnumMember — a single member declaration with literal type preservation
-// ---------------------------------------------------------------------------
-
-/**
- * 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. `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> {
-  readonly name: Name;
-  readonly value: Value;
-}
-
-/**
- * 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>(
-  name: Name,
-  value: Value,
-): EnumMember<Name, Value>;
-export function member<const Name extends string, const Value = Name>(
-  name: Name,
-  value?: Value,
-): EnumMember<Name, Value> {
-  return {
-    name,
-    value: blindCast<
-      Value,
-      'overload signatures enforce Value=Name when value is omitted; default generic Value=Name makes this safe'
-    >(value ?? name),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Internal types for inferring the literal tuple from the members spread
-// ---------------------------------------------------------------------------
-
-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, unknown>[]> = {
-  readonly [K in keyof Members]: Members[K] extends EnumMember<infer N, unknown> ? N : never;
-};
-
-type MembersAccessorMap<Members extends readonly EnumMember<string, unknown>[]> = {
-  readonly [M in Members[number] as M['name']]: M['value'];
-};
-
-// ---------------------------------------------------------------------------
-// EnumTypeHandle — the authoring handle returned by enumType()
-// ---------------------------------------------------------------------------
-
-/**
- * Internal brand that identifies an EnumTypeHandle in the lowering pipeline.
- * Not exported — callers only interact with `EnumTypeHandle`.
- */
-export const ENUM_TYPE_HANDLE_BRAND = Symbol('EnumTypeHandle');
-
-/**
- * Authoring handle returned by `enumType()`. Carries:
- *
- * - The ordered literal value tuple (`.values`) and name tuple (`.names`)
- *   so downstream type-tests can assert literal preservation.
- * - A namespaced member accessor map (`.members`) to avoid collisions with
- *   `.values` / `.has` / `.nameOf` / `.ordinalOf`.
- * - Runtime helpers `.has()`, `.nameOf()`, `.ordinalOf()`.
- * - Internal metadata (`enumName`, `codecId`, `nativeType`,
- *   `enumMembers`) for the lowering pipeline.
- *
- * The type is generic over the ordered value tuple so callers that assign
- * `const Role = enumType(...)` retain the literal tuple on `.values`.
- */
-export interface EnumTypeHandle<
-  Name extends string = string,
-  Values extends readonly unknown[] = readonly unknown[],
-  Names extends readonly string[] = readonly string[],
-  MembersMap extends Record<string, unknown> = Record<string, unknown>,
-> {
-  /** Internal brand for lowering-pipeline detection. */
-  readonly [ENUM_TYPE_HANDLE_BRAND]: true;
-
-  /** The enum's declared name (used as the key in domain `enum` / storage `valueSet`). */
-  readonly enumName: Name;
-
-  /** codecId from the codec passed to `enumType`. */
-  readonly codecId: string;
-
-  /** nativeType from the codec passed to `enumType`. */
-  readonly nativeType: string;
-
-  /** Ordered member list for lowering (name + value pairs). */
-  readonly enumMembers: readonly { readonly name: string; readonly value: Values[number] }[];
-
-  /** Ordered literal value tuple. Declaration order is preserved. */
-  readonly values: Values;
-
-  /** Ordered literal name tuple. Declaration order is preserved. */
-  readonly names: Names;
-
-  /**
-   * Namespaced accessor map: `Role.members.User === 'user'`.
-   * Namespaced under `.members` to avoid collisions with `.values` / `.has`.
-   */
-  readonly members: MembersMap;
-
-  /** Returns `true` if `v` is a declared member value. */
-  has(v: Values[number]): boolean;
-
-  /** Returns the member name for a value, or `undefined` if not found. */
-  nameOf(v: Values[number]): string | undefined;
-
-  /** Returns the zero-based declaration index of a value, or `-1` if not found. */
-  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.
- *
- * - The codec is an explicit required argument — the `codecId` and
- *   `nativeType` are taken from the passed `ColumnTypeDescriptor` (e.g.
- *   `{ codecId: 'pg/text@1', nativeType: 'text' }` from a field preset
- *   output or a direct inline object).
- * - `const` generics on the members spread preserve the ordered literal
- *   value tuple so `Role.values` is `readonly ['user','admin']`, not
- *   `string[]`.
- * - Well-formedness assertions at construction: non-empty member list;
- *   unique names; unique values.
- *
- * The returned handle wires into `field.namedType(handle)` to set
- * `valueSet` refs on both the domain field and the storage column.
- *
- * @example
- * ```ts
- * const Role = enumType('Role', { codecId: 'pg/text@1', nativeType: 'text' },
- *   member('User', 'user'),
- *   member('Admin', 'admin'),
- * );
- * // Role.values → readonly ['user', 'admin']
- * // Role.members.User → 'user'
- * ```
- */
-export function enumType<
-  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,
-  ...members: Members
-): EnumTypeHandle<
-  Name,
-  MembersToValues<[...Members]>,
-  MembersToNames<[...Members]>,
-  MembersAccessorMap<[...Members]>
->;
-export function enumType(
-  name: string,
-  codec: Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'>,
-  ...members: EnumMember<string, unknown>[]
-): EnumTypeHandle;
-export function enumType(
-  name: string,
-  codec: Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'>,
-  ...members: EnumMember<string, unknown>[]
-): EnumTypeHandle {
-  if (members.length === 0) {
-    throw new Error(`enumType("${name}"): must have at least one member.`);
-  }
-
-  const seenNames = new Set<string>();
-  const seenValues = new Set<string>();
-  for (const m of members) {
-    if (seenNames.has(m.name)) {
-      throw new Error(
-        `enumType("${name}"): duplicate member name "${m.name}". Member names must be unique.`,
-      );
-    }
-    seenNames.add(m.name);
-
-    const loweredValue = String(m.value);
-    if (seenValues.has(loweredValue)) {
-      throw new Error(
-        `enumType("${name}"): duplicate member value "${loweredValue}". Member values must be unique.`,
-      );
-    }
-    seenValues.add(loweredValue);
-  }
-
-  const values = Object.freeze(members.map((m) => m.value));
-  const names = Object.freeze(members.map((m) => m.name));
-  const enumMembers = Object.freeze(members.map((m) => ({ name: m.name, value: m.value })));
-
-  const membersAccessor = Object.freeze(Object.fromEntries(members.map((m) => [m.name, m.value])));
-
-  const valueSet = new Set(values);
-  const valueToName = new Map(members.map((m) => [m.value, m.name]));
-  const valueToOrdinal = new Map(values.map((v, i) => [v, i]));
-
-  return {
-    [ENUM_TYPE_HANDLE_BRAND]: true,
-    enumName: name,
-    codecId: codec.codecId,
-    nativeType: codec.nativeType,
-    enumMembers,
-    values,
-    names,
-    members: membersAccessor,
-    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
- * in field state without importing the BRAND symbol at every call site.
- */
-export function isEnumTypeHandle(value: unknown): value is EnumTypeHandle {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    Reflect.get(value, ENUM_TYPE_HANDLE_BRAND) === true
-  );
-}
+export type {
+  BoundEnumType,
+  CodecInput,
+  CodecTypeMap,
+  EnumMember,
+  EnumTypeHandle,
+} from '@prisma-next/contract-authoring';
+export {
+  bindEnumType,
+  ENUM_TYPE_HANDLE_BRAND,
+  enumType,
+  isEnumTypeHandle,
+  member,
+} from '@prisma-next/contract-authoring';