@prisma/orm-family-sql 8.0.0-rc.12-dev.16 → 8.0.0-rc.12-dev.17

package/dist/{contract-builder-C2VKBKK5.d.mts → contract-builder-Ct1IMc8_.d.mts}

@@ -11,11 +11,269 @@ import { i as IndexTypeRegistration } from "./index-types-DPVhsW0v-D-BikM4h.mjs"
 import "./index-types-CNhHgKHi.mjs";
 import { AuthoringArgumentDescriptor, AuthoringFieldPresetDescriptor, AuthoringTypeConstructorDescriptor, AuthoringWarning } from "@prisma/orm-framework/components/authoring";
 import { StorageType } from "@prisma/orm-framework/components/ir";
-import { ColumnDefault, ColumnDefaultLiteralInputValue, Contract, ContractEnum, ContractRelation, ContractValueObject, ControlPolicy, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue, NamespaceId, StorageHashBase } from "@prisma/orm-framework/contract/types";
-import { BoundEnumType, CodecInput, CodecTypeMap, EntityHelpersFromNamespace, EnumMember, EnumTypeHandle, ExtractAuthoringNamespaceFromPack, ForeignKeyDefaultsState, MergeExtensionAuthoringNamespaces, ResolveTemplateValue, TupleFromArgumentDescriptors, bindEnumType, enumType, member } from "@prisma/orm-framework/contract-authoring";
+import { ColumnDefault, Contract, ContractEnum, ContractRelation, ContractValueObject, ControlPolicy, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue, NamespaceId, StorageHashBase } from "@prisma/orm-framework/contract/types";
+import { BoundEnumType, CodecInput, CodecInput as CodecInput$1, CodecTypeMap, CodecTypeMap as CodecTypeMap$1, EntityHelpersFromNamespace, EnumMember, EnumTypeHandle, ExtractAuthoringNamespaceFromPack, ForeignKeyDefaultsState, MergeExtensionAuthoringNamespaces, ResolveTemplateValue, TupleFromArgumentDescriptors, bindEnumType, enumType, member } from "@prisma/orm-framework/contract-authoring";
 import { CodecLookup, ColumnTypeDescriptor } from "@prisma/orm-framework/components/codec";
 import { ExtensionPackRef, FamilyPackRef, TargetPackRef } from "@prisma/orm-framework/components/components";
 //#region ../../../2-sql/2-authoring/contract-ts/dist/contract-builder.d.mts
+//#region src/contract-definition.d.ts
+/**
+ * Namespace-scoped pack-entity attachments, the internal build IR carrying
+ * the lowered `entities` handle list: namespace id → entity kind (the
+ * discriminator the target/extension pack registered its
+ * `AuthoringContributions.entityTypes` descriptor under, e.g. `native_enum`)
+ * → entity name → the lowered entity instance. Generic on purpose — neither
+ * the framework nor `contract-ts` names a specific entity kind here; the
+ * shape mirrors `SqlNamespaceInput.entries` (`entries.<kind>[name]`), just
+ * namespace-nested so an attachment can target any declared namespace
+ * (default or named), not only the contract's default namespace. Produced by
+ * the generic entity-handle walk in `buildContractDefinition`; never an
+ * author-facing input.
+ */
+type AttachedEntities = Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
+/**
+ * A literal default as an authoring surface builds it: a value of the column codec's input type, which the contract build encodes through that codec into a {@link ColumnDefault}. Only the codec knows the type, so it is `unknown` until encoded.
+ */
+type AuthoredColumnDefaultLiteralValue = unknown;
+type AuthoredColumnDefault = ColumnDefault | {
+  readonly kind: 'literal';
+  readonly value: AuthoredColumnDefaultLiteralValue;
+  /**
+   * Whether the value is already the canonical form the contract stores. A text contract source
+   * reads a written default into the canonical form itself, through the column's data type and
+   * its casts, so the build stores it as it stands; a TypeScript `.default(value)` hands over an
+   * application value, which the column's codec encodes. ADR 254.
+   */
+  readonly canonical?: boolean;
+};
+interface FieldNode {
+  readonly fieldName: string;
+  readonly columnName: string;
+  readonly descriptor: ColumnTypeDescriptor;
+  readonly nullable: boolean;
+  readonly default?: AuthoredColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+  readonly many?: boolean;
+  /**
+   * Generated-check kinds the author declined for this column. The PSL
+   * interpreter always writes concrete kinds; the TS builder's bare
+   * `noCheck()` arrives as `[]` and is resolved to the column shape's
+   * derivable kinds at contract build time.
+   */
+  readonly noCheck?: readonly CheckKind[];
+  /** Present when the field was authored with `field.namedType(enumHandle)`. */
+  readonly enumTypeHandle?: EnumTypeHandle;
+}
+interface PrimaryKeyNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+interface UniqueConstraintNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+/** A definition-tree index's element structure — column tuple xor expression. */
+type IndexNodeElements = {
+  /** Column tuple. */
+  readonly columns: readonly string[];
+  readonly expression?: never;
+} | {
+  readonly columns?: never;
+  /** Opaque SQL: the entire element list of CREATE INDEX — never parsed. */
+  readonly expression: string;
+};
+type IndexNode = IndexNodeElements & AuthoredIndexMethod & {
+  /** Opaque SQL: partial-index predicate (WHERE body, without the keyword). */
+  readonly where: string | undefined;
+  readonly unique: boolean | undefined;
+  /** Exact physical name (`map:`) — adopted verbatim, no wire hash. */
+  readonly map: string | undefined;
+  /** Wire-name prefix (`name:`) — lowers to `<name>_<8hex>`. */
+  readonly name: string | undefined;
+};
+/**
+ * A definition-tree check constraint: `map` adopts an exact physical name
+ * verbatim, `name` is a wire-name prefix — exactly one is required (a check
+ * has no column tuple to derive a default from, unlike an index).
+ */
+type CheckNode = {
+  readonly expression: string;
+  readonly map: string | undefined;
+  readonly name: string | undefined;
+};
+interface ForeignKeyNode {
+  readonly columns: readonly string[];
+  readonly references: {
+    readonly model: string;
+    readonly table: string;
+    readonly columns: readonly string[];
+    /**
+     * Namespace coordinate of the referenced table. When omitted the
+     * assembler resolves the coordinate from the referenced model node's
+     * own `namespaceId`; the field exists so authoring paths that already
+     * know the target namespace can stamp it explicitly.
+     */
+    readonly namespaceId?: string;
+    /**
+     * Contract-space identity of the referenced table. When present, the
+     * table lives in a different contract space (identified by this value)
+     * rather than the current contract. Absent for local FKs.
+     */
+    readonly spaceId?: string;
+  };
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  readonly constraint?: boolean;
+  readonly index?: boolean;
+}
+interface RelationNode {
+  readonly fieldName: string;
+  readonly toModel: string;
+  /**
+   * Physical table of the related model. Undefined only for a cross-space
+   * relation whose handle carries no static table name.
+   */
+  readonly toTable: string | undefined;
+  /**
+   * Namespace coordinate of the related model. When omitted the assembler
+   * resolves the coordinate from the referenced model node's own
+   * `namespaceId`; the field exists so authoring paths that already know the
+   * target namespace can stamp it explicitly — required to disambiguate a
+   * relation to a model whose bare name also exists in another namespace.
+   */
+  readonly toNamespaceId?: string;
+  readonly cardinality: '1:1' | '1:N' | 'N:1' | 'N:M';
+  /**
+   * Whether the related row may be absent, as stated by the schema. Present on
+   * every `'1:1'` and `'N:1'` relation; absent on `'1:N'` and `'N:M'`.
+   */
+  readonly nullable?: boolean;
+  /**
+   * Contract-space identity of the related model. When present, the
+   * related model lives in a different contract space. Absent for local
+   * (same-space) relations.
+   */
+  readonly spaceId?: string;
+  /**
+   * Namespace coordinate of the related model in the foreign space.
+   * Only set when `spaceId` is present.
+   */
+  readonly namespaceId?: string;
+  readonly on: {
+    readonly parentTable: string;
+    readonly parentColumns: readonly string[];
+    readonly childTable: string | undefined;
+    readonly childColumns: readonly string[];
+  };
+  readonly through?: {
+    readonly table: string;
+    /**
+     * Namespace the junction table lives in. Set from the junction model's
+     * declared namespace at lowering time; junction table names are unique per
+     * namespace, not globally, so this disambiguates a junction whose bare table
+     * name also exists in another namespace. Omitted for a junction in the
+     * default namespace (resolved to the target's default at build time).
+     */
+    readonly namespaceId?: string;
+    readonly parentColumns: readonly string[];
+    readonly childColumns: readonly string[];
+  };
+}
+interface ValueObjectFieldNode {
+  readonly fieldName: string;
+  readonly columnName: string;
+  readonly valueObjectName: string;
+  readonly nullable: boolean;
+  readonly default?: AuthoredColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+  readonly many?: boolean;
+}
+interface ValueObjectNode {
+  readonly name: string;
+  readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
+}
+interface ModelNode {
+  readonly modelName: string;
+  readonly tableName: string;
+  /**
+   * Resolved namespace coordinate for this model — the key into the
+   * parent contract's `SqlStorage.namespaces` map. Omitting the field
+   * (or setting it to the framework's `UNBOUND_NAMESPACE_ID` sentinel)
+   * selects the late-bound slot, which renders as unqualified DDL.
+   *
+   * Populated by per-target PSL interpreters from the resolved
+   * `namespace { … }` AST bucket; the TS builder also sets it from the
+   * per-model `namespace` field once that authoring surface lands.
+   */
+  readonly namespaceId?: string;
+  readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
+  readonly id?: PrimaryKeyNode;
+  readonly uniques?: readonly UniqueConstraintNode[];
+  readonly indexes?: readonly IndexNode[];
+  readonly checks?: readonly CheckNode[];
+  readonly foreignKeys?: readonly ForeignKeyNode[];
+  readonly relations?: readonly RelationNode[];
+  readonly control?: ControlPolicy;
+  /**
+   * Single-table-inheritance variants share their base model's storage table:
+   * the variant's columns are materialised onto the base `ModelNode`, and this
+   * model contributes a domain model but no storage table of its own. When set,
+   * the assembler builds the domain model but skips creating a (shadow) storage
+   * table and a root for this model — the base owns both.
+   */
+  readonly sharesBaseTable?: boolean;
+}
+interface ContractDefinition {
+  readonly target: TargetPackRef<'sql', string>;
+  readonly defaultControlPolicy?: ControlPolicy;
+  readonly extensions?: Record<string, ExtensionPackRef<'sql', string>>;
+  /**
+   * Test-fixture escape hatch: pins the emitted `storage.storageHash`
+   * instead of computing it from content. A pinned hash is not
+   * content-derived, so snapshot content verification
+   * (`MIGRATION.CONTRACT_SNAPSHOT_CONTENT_MISMATCH`) rejects any migration
+   * snapshot addressed by it — never set this in a real project.
+   */
+  readonly storageHash?: string;
+  readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
+  readonly storageTypes?: Record<string, StorageTypeInstance>;
+  /**
+   * Declared namespace coordinates for this contract — populates
+   * `SqlStorage.namespaces` together with `createNamespace`.
+   */
+  readonly namespaces?: readonly string[];
+  /**
+   * Authoring warnings collected by the definition producer before the
+   * build runs (the PSL interpreter's entity factories run ahead of
+   * `buildSqlContractFromDefinition`); seeds the build's single per-build
+   * flush. Required key: a producer with nothing collected states
+   * `undefined` explicitly.
+   */
+  readonly warnings: readonly AuthoringWarning[] | undefined;
+  /** Target-supplied factory that materialises a `SqlNamespaceBase` concretion for a declared namespace coordinate. */
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
+  readonly models: readonly ModelNode[];
+  readonly valueObjects?: readonly ValueObjectNode[];
+  /**
+   * Domain enum handles authored via `enumType()`. Each entry lowers to a
+   * domain `enum` entry and a storage `valueSet` entry in the contract's
+   * default namespace.
+   */
+  readonly enums?: Record<string, EnumTypeHandle>;
+  /**
+   * Pack-entity attachments lowered from the `entities` handle list, keyed by
+   * namespace then entity kind then name. Each entity lands in
+   * `storage.namespaces[ns].entries.<kind>`; when the registered entity-type
+   * descriptor's factory output implements the
+   * `SqlValueSetDerivingEntityTypeOutput.deriveValueSet` hook, the derived
+   * value-set also folds into `entries.valueSet`, mirroring how `enums` flows
+   * there. Internal build IR — populated by `buildContractDefinition`, not an
+   * author input.
+   */
+  readonly attachedEntities?: AttachedEntities;
+}
+//#endregion
 //#region src/contract-dsl.d.ts
 type NamingStrategy = 'identity' | 'snake_case';
 type NamingConfig = {
@@ -32,7 +290,7 @@ type ScalarFieldState<Descriptor extends ColumnTypeDescriptor = ColumnTypeDescri
   readonly typeRef?: TypeRef | undefined;
   readonly nullable: Nullable;
   readonly columnName?: ColumnName | undefined;
-  readonly default?: ColumnDefault | undefined;
+  readonly default?: AuthoredColumnDefault | undefined;
   readonly executionDefaults?: ExecutionMutationDefaultPhases | undefined;
   readonly many?: Many extends true ? true : undefined;
   readonly noCheck?: readonly CheckKind[] | undefined;
@@ -51,7 +309,7 @@ type AnyScalarFieldState = {
   readonly typeRef?: NamedStorageTypeRef | undefined;
   readonly nullable: boolean;
   readonly columnName?: string | undefined;
-  readonly default?: ColumnDefault | undefined;
+  readonly default?: AuthoredColumnDefault | undefined;
   readonly executionDefaults?: ExecutionMutationDefaultPhases | undefined;
   readonly many?: boolean | undefined;
   readonly noCheck?: readonly CheckKind[] | undefined;
@@ -83,6 +341,22 @@ type GeneratedFieldSpec = {
   readonly typeParams?: Record<string, unknown>;
   readonly generated: ExecutionMutationDefaultValue;
 };
+type CarriesCodecInput<Input> = {
+  /** Exists only in types: carries the input type of the column's codec, which `.default()` takes. */
+  __codecInput?(input: Input): void;
+};
+type WithCodecInput<Descriptor, Input> = Descriptor & CarriesCodecInput<Input>;
+type DefaultInputOf<State> = State extends {
+  readonly descriptor?: infer Descriptor;
+} ? NonNullable<Descriptor> extends CarriesCodecInput<infer Input> ? Input : unknown : unknown;
+type IsList<State> = State extends {
+  readonly many?: infer Many;
+} ? true extends Many ? true : false : false;
+type DefaultLiteralOf<State> = unknown extends DefaultInputOf<State> ? unknown : IsList<State> extends true ? readonly DefaultInputOf<State>[] : DefaultInputOf<State>;
+type EnumHandleOf<State> = State extends {
+  readonly typeRef?: infer TypeRef;
+} ? string extends TypeRef ? never : Extract<TypeRef, EnumTypeHandle> : never;
+type DefaultArgumentOf<State> = [EnumHandleOf<State>] extends [never] ? DefaultLiteralOf<State> | ColumnDefault : IsList<State> extends true ? readonly EnumHandleOf<State>['values'][number][] : EnumHandleOf<State>['values'][number];
 declare class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFieldState> {
   private readonly state;
   readonly __state: State;
@@ -105,7 +379,9 @@ declare class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFi
    * is waived.
    */
   noCheck(...kinds: readonly CheckKind[]): ScalarFieldBuilder<State>;
-  default(value: ColumnDefaultLiteralInputValue | ColumnDefault): ScalarFieldBuilder<State>;
+  default<Self extends {
+    readonly __state: AnyScalarFieldState;
+  }>(this: Self, value: DefaultArgumentOf<Self['__state']>): ScalarFieldBuilder<State>;
   /**
    * @deprecated Write `.default(now())` or `.default(autoincrement())`, or `` .default(sql`...`) `` for any other SQL. Removed in 8.0.0.
    */
@@ -118,16 +394,21 @@ declare class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFi
 declare class EnumScalarFieldBuilder<Handle extends EnumTypeHandle, State extends AnyScalarFieldState = ScalarFieldState<ColumnTypeDescriptor, Handle, false, undefined>> extends ScalarFieldBuilder<State> {
   #private;
   constructor(state: State, handle: Handle);
-  default(value: Handle['values'][number]): EnumScalarFieldBuilder<Handle, State>;
+  default<Self extends {
+    readonly __state: AnyScalarFieldState;
+  }>(this: Self, value: DefaultArgumentOf<Self['__state']>): EnumScalarFieldBuilder<Handle, State>;
   defaultSql(_expression: never): never;
 }
-declare function columnField<Descriptor extends ColumnTypeDescriptor>(descriptor: Descriptor): ScalarFieldBuilder<ScalarFieldState<Descriptor, undefined, false, undefined>>;
+type CodecTypesOfNoPacks = Record<never, never>;
+type ColumnFieldHelper<CodecTypes extends CodecTypeMap = CodecTypesOfNoPacks> = <Descriptor extends ColumnTypeDescriptor>(descriptor: Descriptor) => ScalarFieldBuilder<ScalarFieldState<WithCodecInput<Descriptor, CodecInput<CodecTypes, Descriptor>>, undefined, false, undefined>>;
+type NamedTypeFieldHelper<CodecTypes extends CodecTypeMap = CodecTypesOfNoPacks> = {
+  <TypeRef extends string>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<ColumnTypeDescriptor, TypeRef, false, undefined>>;
+  <TypeRef extends StorageTypeInstance>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<WithCodecInput<ColumnTypeDescriptor<TypeRef['codecId']>, CodecInput<CodecTypes, TypeRef>>, TypeRef, false, undefined>>;
+  <Handle extends EnumTypeHandle>(typeRef: Handle): EnumScalarFieldBuilder<Handle>;
+};
 declare function generatedField<Descriptor extends ColumnTypeDescriptor>(spec: GeneratedFieldSpec & {
   readonly type: Descriptor;
 }): ScalarFieldBuilder<ScalarFieldState<Descriptor, undefined, false, undefined>>;
-declare function namedTypeField<TypeRef extends string>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<ColumnTypeDescriptor, TypeRef, false, undefined>>;
-declare function namedTypeField<TypeRef extends StorageTypeInstance>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<ColumnTypeDescriptor<TypeRef['codecId']>, TypeRef, false, undefined>>;
-declare function namedTypeField<Handle extends EnumTypeHandle>(typeRef: Handle): EnumScalarFieldBuilder<Handle>;
 type RelationModelRefSource = 'string' | 'token' | 'lazyToken';
 type TargetFieldRefSource = 'string' | 'token';
 type EagerRelationModelName<ModelName extends string = string, Source extends Exclude<RelationModelRefSource, 'lazyToken'> = Exclude<RelationModelRefSource, 'lazyToken'>> = {
@@ -671,9 +952,9 @@ declare const rel: {
   manyToMany: typeof manyToMany;
 };
 declare const field: {
-  column: typeof columnField;
+  column: ColumnFieldHelper<CodecTypesOfNoPacks>;
   generated: typeof generatedField;
-  namedType: typeof namedTypeField;
+  namedType: NamedTypeFieldHelper<CodecTypesOfNoPacks>;
 };
 type FieldStateOf<T> = T extends ScalarFieldBuilder<infer State> ? State : never;
 type RelationStateOf<T> = T extends RelationBuilder<infer State> ? State : never;
@@ -693,10 +974,13 @@ type SupportsNamedConstraintOptions<Descriptor extends AuthoringFieldPresetDescr
 } ? true : Descriptor['output'] extends {
   readonly unique: true;
 } ? true : false;
-type FieldBuilderFromPresetDescriptor<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[] = readonly [], ConstraintName extends string | undefined = undefined> = ScalarFieldBuilder<ScalarFieldState<ColumnTypeDescriptor<ResolveTemplateValue<Descriptor['output']['codecId'], Args> extends string ? ResolveTemplateValue<Descriptor['output']['codecId'], Args> : string>, undefined, ResolveTemplateValue<Descriptor['output']['nullable'], Args> extends true ? true : false, undefined, NamedConstraintState<ResolveTemplateValue<Descriptor['output']['id'], Args> extends true ? true : false, ConstraintName>, NamedConstraintState<ResolveTemplateValue<Descriptor['output']['unique'], Args> extends true ? true : false, ConstraintName>>>;
-type FieldHelperFunctionWithoutNamedConstraint<Descriptor extends AuthoringFieldPresetDescriptor> = Descriptor extends {
+type PresetCodecId<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[]> = ResolveTemplateValue<Descriptor['output']['codecId'], Args> extends string ? ResolveTemplateValue<Descriptor['output']['codecId'], Args> : string;
+type FieldBuilderFromPresetDescriptor<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[] = readonly [], ConstraintName extends string | undefined = undefined, CodecTypes extends CodecTypeMap = Record<never, never>> = ScalarFieldBuilder<ScalarFieldState<WithCodecInput<ColumnTypeDescriptor<PresetCodecId<Descriptor, Args>>, CodecInput<CodecTypes, {
+  readonly codecId: PresetCodecId<Descriptor, Args>;
+}>>, undefined, ResolveTemplateValue<Descriptor['output']['nullable'], Args> extends true ? true : false, undefined, NamedConstraintState<ResolveTemplateValue<Descriptor['output']['id'], Args> extends true ? true : false, ConstraintName>, NamedConstraintState<ResolveTemplateValue<Descriptor['output']['unique'], Args> extends true ? true : false, ConstraintName>>>;
+type FieldHelperFunctionWithoutNamedConstraint<Descriptor extends AuthoringFieldPresetDescriptor, CodecTypes extends CodecTypeMap = Record<never, never>> = Descriptor extends {
   readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
-} ? <const Params extends TupleFromArgumentDescriptors<Args>>(...args: Params) => FieldBuilderFromPresetDescriptor<Descriptor, Params> : () => FieldBuilderFromPresetDescriptor<Descriptor, readonly []>;
+} ? <const Params extends TupleFromArgumentDescriptors<Args>>(...args: Params) => FieldBuilderFromPresetDescriptor<Descriptor, Params, undefined, CodecTypes> : () => FieldBuilderFromPresetDescriptor<Descriptor, readonly [], undefined, CodecTypes>;
 /**
  * An intersection of two call signatures rather than one rest-tuple signature
  * with a trailing `options?`. Once optional descriptors yield optional tuple
@@ -706,11 +990,11 @@ type FieldHelperFunctionWithoutNamedConstraint<Descriptor extends AuthoringField
  * signature first, and falling through to the options-required signature only
  * when the argument list cannot satisfy it, keeps both spellings working.
  */
-type FieldHelperFunctionWithNamedConstraint<Descriptor extends AuthoringFieldPresetDescriptor> = Descriptor extends {
+type FieldHelperFunctionWithNamedConstraint<Descriptor extends AuthoringFieldPresetDescriptor, CodecTypes extends CodecTypeMap = Record<never, never>> = Descriptor extends {
   readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
-} ? (<const Params extends TupleFromArgumentDescriptors<Args>>(...args: Params) => FieldBuilderFromPresetDescriptor<Descriptor, Params>) & (<const Params extends TupleFromArgumentDescriptors<Args>, const Name extends string | undefined = undefined>(...args: [...params: Params, options: NamedConstraintSpec<Name>]) => FieldBuilderFromPresetDescriptor<Descriptor, Params, Name>) : <const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>) => FieldBuilderFromPresetDescriptor<Descriptor, readonly [], Name>;
-type FieldHelperFunction<Descriptor extends AuthoringFieldPresetDescriptor> = SupportsNamedConstraintOptions<Descriptor> extends true ? FieldHelperFunctionWithNamedConstraint<Descriptor> : FieldHelperFunctionWithoutNamedConstraint<Descriptor>;
-type FieldHelpersFromNamespace<Namespace> = { readonly [K in keyof Namespace]: Namespace[K] extends AuthoringFieldPresetDescriptor ? FieldHelperFunction<Namespace[K]> : Namespace[K] extends Record<string, unknown> ? FieldHelpersFromNamespace<Namespace[K]> : never; };
+} ? (<const Params extends TupleFromArgumentDescriptors<Args>>(...args: Params) => FieldBuilderFromPresetDescriptor<Descriptor, Params, undefined, CodecTypes>) & (<const Params extends TupleFromArgumentDescriptors<Args>, const Name extends string | undefined = undefined>(...args: [...params: Params, options: NamedConstraintSpec<Name>]) => FieldBuilderFromPresetDescriptor<Descriptor, Params, Name, CodecTypes>) : <const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>) => FieldBuilderFromPresetDescriptor<Descriptor, readonly [], Name, CodecTypes>;
+type FieldHelperFunction<Descriptor extends AuthoringFieldPresetDescriptor, CodecTypes extends CodecTypeMap = Record<never, never>> = SupportsNamedConstraintOptions<Descriptor> extends true ? FieldHelperFunctionWithNamedConstraint<Descriptor, CodecTypes> : FieldHelperFunctionWithoutNamedConstraint<Descriptor, CodecTypes>;
+type FieldHelpersFromNamespace<Namespace, CodecTypes extends CodecTypeMap = Record<never, never>> = { readonly [K in keyof Namespace]: Namespace[K] extends AuthoringFieldPresetDescriptor ? FieldHelperFunction<Namespace[K], CodecTypes> : Namespace[K] extends Record<string, unknown> ? FieldHelpersFromNamespace<Namespace[K], CodecTypes> : unknown; };
 //#endregion
 //#region src/contract-types.d.ts
 type PublicCodecTypes<CodecTypes extends Record<string, {
@@ -1014,7 +1298,11 @@ type TypeHelperFunction<Descriptor extends AuthoringTypeConstructorDescriptor> =
   readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
 } ? <const Params extends TupleFromArgumentDescriptors<Args>>(...args: Params) => StorageTypeFromDescriptor<Descriptor, Params> : () => StorageTypeFromDescriptor<Descriptor, readonly []>;
 type TypeHelpersFromNamespace<Namespace> = { readonly [K in keyof Namespace]: Namespace[K] extends AuthoringTypeConstructorDescriptor ? TypeHelperFunction<Namespace[K]> : Namespace[K] extends Record<string, unknown> ? TypeHelpersFromNamespace<Namespace[K]> : never; };
-type CoreFieldHelpers = Pick<typeof field, 'column' | 'generated' | 'namedType'>;
+type FieldHelpersForCodecs<CodecTypes extends CodecTypeMap> = Pick<typeof field, 'generated'> & {
+  readonly column: ColumnFieldHelper<CodecTypes>;
+  readonly namedType: NamedTypeFieldHelper<CodecTypes>;
+};
+type CodecTypesOfPacks<Family, Target, Extensions> = ExtractCodecTypesFromPack<Family> & ExtractCodecTypesFromPack<Target> & MergeExtensionCodecTypesSafe<Extensions>;
 type MergeAllPackIndexTypes<Family, Target, Extensions> = MergeExtensionIndexTypes<{
   readonly __family: Family;
   readonly __target: Target;
@@ -1032,271 +1320,12 @@ type PackAwareModel<IndexTypes extends IndexTypeMap> = {
   }): ContractModelBuilder<undefined, Fields, Relations, undefined, undefined, IndexTypes>;
 };
 type ComposedAuthoringHelpers<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined> = EntityHelpersFromNamespace<ExtractEntitiesNamespaceFromPack<Family> & ExtractEntitiesNamespaceFromPack<Target> & MergeExtensionEntityNamespaces<Extensions>> & {
-  readonly field: CoreFieldHelpers & FieldHelpersFromNamespace<ExtractFieldNamespaceFromPack<Family> & ExtractFieldNamespaceFromPack<Target> & MergeExtensionFieldNamespaces<Extensions>>;
+  readonly field: FieldHelpersForCodecs<CodecTypesOfPacks<Family, Target, Extensions>> & FieldHelpersFromNamespace<ExtractFieldNamespaceFromPack<Family> & ExtractFieldNamespaceFromPack<Target> & MergeExtensionFieldNamespaces<Extensions>, CodecTypesOfPacks<Family, Target, Extensions>>;
   readonly model: PackAwareModel<MergeAllPackIndexTypes<Family, Target, Extensions>>;
   readonly rel: typeof rel;
   readonly type: TypeHelpersFromNamespace<ExtractTypeNamespaceFromPack<Family> & ExtractTypeNamespaceFromPack<Target> & MergeExtensionTypeNamespaces<Extensions>>;
 };
 //#endregion
-//#region src/contract-definition.d.ts
-/**
- * Namespace-scoped pack-entity attachments, the internal build IR carrying
- * the lowered `entities` handle list: namespace id → entity kind (the
- * discriminator the target/extension pack registered its
- * `AuthoringContributions.entityTypes` descriptor under, e.g. `native_enum`)
- * → entity name → the lowered entity instance. Generic on purpose — neither
- * the framework nor `contract-ts` names a specific entity kind here; the
- * shape mirrors `SqlNamespaceInput.entries` (`entries.<kind>[name]`), just
- * namespace-nested so an attachment can target any declared namespace
- * (default or named), not only the contract's default namespace. Produced by
- * the generic entity-handle walk in `buildContractDefinition`; never an
- * author-facing input.
- */
-type AttachedEntities = Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
-/**
- * A literal default as an authoring surface builds it. The contract build encodes it through the
- * column codec into a {@link ColumnDefault}, so it may hold a `bigint`, which JSON cannot.
- */
-type AuthoredColumnDefaultLiteralValue = ColumnDefaultLiteralInputValue | bigint | readonly AuthoredColumnDefaultLiteralValue[];
-type AuthoredColumnDefault = ColumnDefault | {
-  readonly kind: 'literal';
-  readonly value: AuthoredColumnDefaultLiteralValue;
-  /**
-   * Whether the value is already the canonical form the contract stores. A text contract source
-   * reads a written default into the canonical form itself, through the column's data type and
-   * its casts, so the build stores it as it stands; a TypeScript `.default(value)` hands over an
-   * application value, which the column's codec encodes. ADR 254.
-   */
-  readonly canonical?: boolean;
-};
-interface FieldNode {
-  readonly fieldName: string;
-  readonly columnName: string;
-  readonly descriptor: ColumnTypeDescriptor;
-  readonly nullable: boolean;
-  readonly default?: AuthoredColumnDefault;
-  readonly executionDefaults?: ExecutionMutationDefaultPhases;
-  readonly many?: boolean;
-  /**
-   * Generated-check kinds the author declined for this column. The PSL
-   * interpreter always writes concrete kinds; the TS builder's bare
-   * `noCheck()` arrives as `[]` and is resolved to the column shape's
-   * derivable kinds at contract build time.
-   */
-  readonly noCheck?: readonly CheckKind[];
-  /** Present when the field was authored with `field.namedType(enumHandle)`. */
-  readonly enumTypeHandle?: EnumTypeHandle;
-}
-interface PrimaryKeyNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-}
-interface UniqueConstraintNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-}
-/** A definition-tree index's element structure — column tuple xor expression. */
-type IndexNodeElements = {
-  /** Column tuple. */
-  readonly columns: readonly string[];
-  readonly expression?: never;
-} | {
-  readonly columns?: never;
-  /** Opaque SQL: the entire element list of CREATE INDEX — never parsed. */
-  readonly expression: string;
-};
-type IndexNode = IndexNodeElements & AuthoredIndexMethod & {
-  /** Opaque SQL: partial-index predicate (WHERE body, without the keyword). */
-  readonly where: string | undefined;
-  readonly unique: boolean | undefined;
-  /** Exact physical name (`map:`) — adopted verbatim, no wire hash. */
-  readonly map: string | undefined;
-  /** Wire-name prefix (`name:`) — lowers to `<name>_<8hex>`. */
-  readonly name: string | undefined;
-};
-/**
- * A definition-tree check constraint: `map` adopts an exact physical name
- * verbatim, `name` is a wire-name prefix — exactly one is required (a check
- * has no column tuple to derive a default from, unlike an index).
- */
-type CheckNode = {
-  readonly expression: string;
-  readonly map: string | undefined;
-  readonly name: string | undefined;
-};
-interface ForeignKeyNode {
-  readonly columns: readonly string[];
-  readonly references: {
-    readonly model: string;
-    readonly table: string;
-    readonly columns: readonly string[];
-    /**
-     * Namespace coordinate of the referenced table. When omitted the
-     * assembler resolves the coordinate from the referenced model node's
-     * own `namespaceId`; the field exists so authoring paths that already
-     * know the target namespace can stamp it explicitly.
-     */
-    readonly namespaceId?: string;
-    /**
-     * Contract-space identity of the referenced table. When present, the
-     * table lives in a different contract space (identified by this value)
-     * rather than the current contract. Absent for local FKs.
-     */
-    readonly spaceId?: string;
-  };
-  readonly name?: string;
-  readonly onDelete?: ReferentialAction;
-  readonly onUpdate?: ReferentialAction;
-  readonly constraint?: boolean;
-  readonly index?: boolean;
-}
-interface RelationNode {
-  readonly fieldName: string;
-  readonly toModel: string;
-  /**
-   * Physical table of the related model. Undefined only for a cross-space
-   * relation whose handle carries no static table name.
-   */
-  readonly toTable: string | undefined;
-  /**
-   * Namespace coordinate of the related model. When omitted the assembler
-   * resolves the coordinate from the referenced model node's own
-   * `namespaceId`; the field exists so authoring paths that already know the
-   * target namespace can stamp it explicitly — required to disambiguate a
-   * relation to a model whose bare name also exists in another namespace.
-   */
-  readonly toNamespaceId?: string;
-  readonly cardinality: '1:1' | '1:N' | 'N:1' | 'N:M';
-  /**
-   * Whether the related row may be absent, as stated by the schema. Present on
-   * every `'1:1'` and `'N:1'` relation; absent on `'1:N'` and `'N:M'`.
-   */
-  readonly nullable?: boolean;
-  /**
-   * Contract-space identity of the related model. When present, the
-   * related model lives in a different contract space. Absent for local
-   * (same-space) relations.
-   */
-  readonly spaceId?: string;
-  /**
-   * Namespace coordinate of the related model in the foreign space.
-   * Only set when `spaceId` is present.
-   */
-  readonly namespaceId?: string;
-  readonly on: {
-    readonly parentTable: string;
-    readonly parentColumns: readonly string[];
-    readonly childTable: string | undefined;
-    readonly childColumns: readonly string[];
-  };
-  readonly through?: {
-    readonly table: string;
-    /**
-     * Namespace the junction table lives in. Set from the junction model's
-     * declared namespace at lowering time; junction table names are unique per
-     * namespace, not globally, so this disambiguates a junction whose bare table
-     * name also exists in another namespace. Omitted for a junction in the
-     * default namespace (resolved to the target's default at build time).
-     */
-    readonly namespaceId?: string;
-    readonly parentColumns: readonly string[];
-    readonly childColumns: readonly string[];
-  };
-}
-interface ValueObjectFieldNode {
-  readonly fieldName: string;
-  readonly columnName: string;
-  readonly valueObjectName: string;
-  readonly nullable: boolean;
-  readonly default?: AuthoredColumnDefault;
-  readonly executionDefaults?: ExecutionMutationDefaultPhases;
-  readonly many?: boolean;
-}
-interface ValueObjectNode {
-  readonly name: string;
-  readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
-}
-interface ModelNode {
-  readonly modelName: string;
-  readonly tableName: string;
-  /**
-   * Resolved namespace coordinate for this model — the key into the
-   * parent contract's `SqlStorage.namespaces` map. Omitting the field
-   * (or setting it to the framework's `UNBOUND_NAMESPACE_ID` sentinel)
-   * selects the late-bound slot, which renders as unqualified DDL.
-   *
-   * Populated by per-target PSL interpreters from the resolved
-   * `namespace { … }` AST bucket; the TS builder also sets it from the
-   * per-model `namespace` field once that authoring surface lands.
-   */
-  readonly namespaceId?: string;
-  readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
-  readonly id?: PrimaryKeyNode;
-  readonly uniques?: readonly UniqueConstraintNode[];
-  readonly indexes?: readonly IndexNode[];
-  readonly checks?: readonly CheckNode[];
-  readonly foreignKeys?: readonly ForeignKeyNode[];
-  readonly relations?: readonly RelationNode[];
-  readonly control?: ControlPolicy;
-  /**
-   * Single-table-inheritance variants share their base model's storage table:
-   * the variant's columns are materialised onto the base `ModelNode`, and this
-   * model contributes a domain model but no storage table of its own. When set,
-   * the assembler builds the domain model but skips creating a (shadow) storage
-   * table and a root for this model — the base owns both.
-   */
-  readonly sharesBaseTable?: boolean;
-}
-interface ContractDefinition {
-  readonly target: TargetPackRef<'sql', string>;
-  readonly defaultControlPolicy?: ControlPolicy;
-  readonly extensions?: Record<string, ExtensionPackRef<'sql', string>>;
-  /**
-   * Test-fixture escape hatch: pins the emitted `storage.storageHash`
-   * instead of computing it from content. A pinned hash is not
-   * content-derived, so snapshot content verification
-   * (`MIGRATION.CONTRACT_SNAPSHOT_CONTENT_MISMATCH`) rejects any migration
-   * snapshot addressed by it — never set this in a real project.
-   */
-  readonly storageHash?: string;
-  readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
-  readonly storageTypes?: Record<string, StorageTypeInstance>;
-  /**
-   * Declared namespace coordinates for this contract — populates
-   * `SqlStorage.namespaces` together with `createNamespace`.
-   */
-  readonly namespaces?: readonly string[];
-  /**
-   * Authoring warnings collected by the definition producer before the
-   * build runs (the PSL interpreter's entity factories run ahead of
-   * `buildSqlContractFromDefinition`); seeds the build's single per-build
-   * flush. Required key: a producer with nothing collected states
-   * `undefined` explicitly.
-   */
-  readonly warnings: readonly AuthoringWarning[] | undefined;
-  /** Target-supplied factory that materialises a `SqlNamespaceBase` concretion for a declared namespace coordinate. */
-  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
-  readonly models: readonly ModelNode[];
-  readonly valueObjects?: readonly ValueObjectNode[];
-  /**
-   * Domain enum handles authored via `enumType()`. Each entry lowers to a
-   * domain `enum` entry and a storage `valueSet` entry in the contract's
-   * default namespace.
-   */
-  readonly enums?: Record<string, EnumTypeHandle>;
-  /**
-   * Pack-entity attachments lowered from the `entities` handle list, keyed by
-   * namespace then entity kind then name. Each entity lands in
-   * `storage.namespaces[ns].entries.<kind>`; when the registered entity-type
-   * descriptor's factory output implements the
-   * `SqlValueSetDerivingEntityTypeOutput.deriveValueSet` hook, the derived
-   * value-set also folds into `entries.valueSet`, mirroring how `enums` flows
-   * there. Internal build IR — populated by `buildContractDefinition`, not an
-   * author input.
-   */
-  readonly attachedEntities?: AttachedEntities;
-}
-//#endregion
 //#region src/build-contract.d.ts
 declare function buildSqlContractFromDefinition(definition: ContractDefinition, codecLookup?: CodecLookup): Contract<SqlStorage>;
 //#endregion
@@ -1418,5 +1447,5 @@ declare function autoincrement(): ColumnDefault;
  */
 declare function sql(strings: TemplateStringsArray, ...values: readonly never[]): ColumnDefault;
 //#endregion
-export { UniqueConstraintNode as A, field as B, MergeEnums as C, RelationNode as D, PrimaryKeyNode as E, buildSqlContractFromDefinition as F, sql as G, model as H, check as I, defineContract as L, bindEnumType as M, buildBoundContract as N, ScalarFieldBuilder as O, buildContractDefinition as P, enumType as R, IndexNode as S, ModelNode as T, now as U, member as V, rel as W, ExtractCodecTypesFromPack as _, CheckNode as a, IndexConstraint as b, ColumnRef as c, ContractInput as d, ContractModelBuilder as f, EnumTypeHandle as g, EnumMember as h, BoundEnumType as i, autoincrement as j, TargetFieldRef as k, ComposedAuthoringHelpers as l, DeferredIndexExpression as m, AuthoredColumnDefault as n, CodecInput as o, DeferredIndexColumn as p, AuthoredColumnDefaultLiteralValue as r, CodecTypeMap as s, AttachedEntities as t, ContractDefinition as u, FieldNode as v, ModelLike as w, IndexExpressionInput as x, ForeignKeyNode as y, extensionModel as z };
-//# sourceMappingURL=contract-builder-C2VKBKK5.d.mts.map
+export { UniqueConstraintNode as A, field as B, MergeEnums as C, RelationNode as D, PrimaryKeyNode as E, buildSqlContractFromDefinition as F, sql as G, model as H, check as I, defineContract as L, bindEnumType as M, buildBoundContract as N, ScalarFieldBuilder as O, buildContractDefinition as P, enumType as R, IndexNode as S, ModelNode as T, now as U, member as V, rel as W, ExtractCodecTypesFromPack as _, CheckNode as a, IndexConstraint as b, ColumnRef as c, ContractInput as d, ContractModelBuilder as f, EnumTypeHandle as g, EnumMember as h, BoundEnumType as i, autoincrement as j, TargetFieldRef as k, ComposedAuthoringHelpers as l, DeferredIndexExpression as m, AuthoredColumnDefault as n, CodecInput$1 as o, DeferredIndexColumn as p, AuthoredColumnDefaultLiteralValue as r, CodecTypeMap$1 as s, AttachedEntities as t, ContractDefinition as u, FieldNode as v, ModelLike as w, IndexExpressionInput as x, ForeignKeyNode as y, extensionModel as z };
+//# sourceMappingURL=contract-builder-Ct1IMc8_.d.mts.map