@prisma-next/sql-contract-ts 0.14.0-dev.7 → 0.14.0-dev.71

package/dist/contract-builder.d.mts

@@ -1,148 +1,194 @@
 import { ColumnDefault, ColumnDefaultLiteralInputValue, Contract, ContractEnum, ContractRelation, ContractValueObject, ControlPolicy, ExecutionMutationDefaultPhases, ExecutionMutationDefaultPhases as ExecutionMutationDefaultPhases$1, ExecutionMutationDefaultValue, NamespaceId, StorageHashBase } from "@prisma-next/contract/types";
-import { EntityHelpersFromNamespace, ExtractAuthoringNamespaceFromPack, ForeignKeyDefaultsState, MergeExtensionAuthoringNamespaces } from "@prisma-next/contract-authoring";
-import { Namespace, StorageType } from "@prisma-next/framework-components/ir";
-import { IndexTypeRegistration } from "@prisma-next/sql-contract/index-types";
-import { ContractWithTypeMaps, Index as Index$1, ReferentialAction, SqlNamespaceTablesInput, SqlStorage, StorageTypeInstance, TypeMaps } from "@prisma-next/sql-contract/types";
+import { BoundEnumType, CodecInput, CodecTypeMap, EntityHelpersFromNamespace, EnumMember, EnumTypeHandle, ExtractAuthoringNamespaceFromPack, ForeignKeyDefaultsState, MergeExtensionAuthoringNamespaces, bindEnumType, enumType, member } from "@prisma-next/contract-authoring";
 import { AuthoringArgumentDescriptor, AuthoringFieldPresetDescriptor, AuthoringTypeConstructorDescriptor } from "@prisma-next/framework-components/authoring";
+import { StorageType } from "@prisma-next/framework-components/ir";
+import { IndexTypeRegistration } from "@prisma-next/sql-contract/index-types";
+import { ContractWithTypeMaps, Index as Index$1, ReferentialAction, SqlNamespaceBase, SqlNamespaceInput, SqlStorage, StorageTypeInstance, TypeMaps } from "@prisma-next/sql-contract/types";
 import { ExtensionPackRef, FamilyPackRef, TargetPackRef } from "@prisma-next/framework-components/components";
 import { CodecLookup, ColumnTypeDescriptor } from "@prisma-next/framework-components/codec";
 
-//#region src/enum-type.d.ts
+//#region src/contract-definition.d.ts
 /**
- * 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.
+ * An author-declared, namespace-scoped pack entity attachment: 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 author can target any declared namespace (default
+ * or named), not only the contract's default namespace.
  */
-interface EnumMember<Name extends string, Value> {
-  readonly name: Name;
-  readonly value: Value;
+type PackEntitiesInput = Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
+interface FieldNode {
+  readonly fieldName: string;
+  readonly columnName: string;
+  readonly descriptor: ColumnTypeDescriptor;
+  readonly nullable: boolean;
+  readonly default?: ColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases$1;
+  readonly many?: boolean;
+  /** Present when the field was authored with `field.namedType(enumHandle)`. */
+  readonly enumTypeHandle?: EnumTypeHandle;
 }
-/**
- * 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.
- */
-declare function member<const Name extends string>(name: Name): EnumMember<Name, Name>;
-declare function member<const Name extends string, const Value>(name: Name, value: Value): EnumMember<Name, Value>;
-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'] };
-/**
- * Internal brand that identifies an EnumTypeHandle in the lowering pipeline.
- * Not exported — callers only interact with `EnumTypeHandle`.
- */
-declare const ENUM_TYPE_HANDLE_BRAND: unique symbol;
-/**
- * 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`.
- */
-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;
+interface PrimaryKeyNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+interface UniqueConstraintNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+interface IndexNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+}
+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;
+  readonly toTable: string;
   /**
-   * Namespaced accessor map: `Role.members.User === 'user'`.
-   * Namespaced under `.members` to avoid collisions with `.values` / `.has`.
+   * 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 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;
+  readonly toNamespaceId?: string;
+  readonly cardinality: '1:1' | '1:N' | 'N:1' | 'N:M';
+  /**
+   * 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;
+    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?: ColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases$1;
+  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 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 extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
+  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[];
+  /** 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>;
+  /**
+   * Author-declared pack entities, keyed by namespace then entity kind then
+   * name. Each entity lowers into `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.
+   */
+  readonly packEntities?: PackEntitiesInput;
 }
-/**
- * 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.
- */
-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.
- */
-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'
- * ```
- */
-declare 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]>>;
-declare function enumType(name: string, codec: Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'>, ...members: EnumMember<string, unknown>[]): EnumTypeHandle;
-/**
- * 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.
- */
-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`.
- */
-declare function bindEnumType<CodecTypes extends CodecTypeMap>(): BoundEnumType<CodecTypes>;
 //#endregion
 //#region src/contract-dsl.d.ts
 type NamingStrategy = 'identity' | 'snake_case';
@@ -154,16 +200,15 @@ type NamedStorageTypeRef = string | StorageTypeInstance | EnumTypeHandle;
 type NamedConstraintNameSpec<Name extends string = string> = {
   readonly name: Name;
 };
-type ScalarFieldState<CodecId extends string = string, TypeRef extends NamedStorageTypeRef | undefined = undefined, Nullable extends boolean = boolean, ColumnName extends string | undefined = string | undefined, IdSpec extends NamedConstraintSpec | undefined = undefined, UniqueSpec extends NamedConstraintSpec | undefined = undefined> = {
+type ScalarFieldState<Descriptor extends ColumnTypeDescriptor = ColumnTypeDescriptor, TypeRef extends NamedStorageTypeRef | undefined = undefined, Nullable extends boolean = boolean, ColumnName extends string | undefined = string | undefined, IdSpec extends NamedConstraintSpec | undefined = undefined, UniqueSpec extends NamedConstraintSpec | undefined = undefined, Many extends boolean = false> = {
   readonly kind: 'scalar';
-  readonly descriptor?: (ColumnTypeDescriptor & {
-    readonly codecId: CodecId;
-  }) | undefined;
+  readonly descriptor?: Descriptor | undefined;
   readonly typeRef?: TypeRef | undefined;
   readonly nullable: Nullable;
   readonly columnName?: ColumnName | undefined;
   readonly default?: ColumnDefault | undefined;
   readonly executionDefaults?: ExecutionMutationDefaultPhases | undefined;
+  readonly many?: Many extends true ? true : undefined;
 } & (IdSpec extends NamedConstraintSpec ? {
   readonly id: IdSpec;
 } : {
@@ -175,19 +220,18 @@ type ScalarFieldState<CodecId extends string = string, TypeRef extends NamedStor
 });
 type AnyScalarFieldState = {
   readonly kind: 'scalar';
-  readonly descriptor?: (ColumnTypeDescriptor & {
-    readonly codecId: string;
-  }) | undefined;
+  readonly descriptor?: ColumnTypeDescriptor | undefined;
   readonly typeRef?: NamedStorageTypeRef | undefined;
   readonly nullable: boolean;
   readonly columnName?: string | undefined;
   readonly default?: ColumnDefault | undefined;
   readonly executionDefaults?: ExecutionMutationDefaultPhases | undefined;
+  readonly many?: boolean | undefined;
   readonly id?: NamedConstraintSpec | undefined;
   readonly unique?: NamedConstraintSpec | undefined;
 };
-type HasNamedConstraintId<State extends AnyScalarFieldState> = State extends ScalarFieldState<string, NamedStorageTypeRef | undefined, boolean, string | undefined, infer IdSpec, NamedConstraintSpec | undefined> ? IdSpec extends NamedConstraintSpec ? true : false : false;
-type HasNamedConstraintUnique<State extends AnyScalarFieldState> = State extends ScalarFieldState<string, NamedStorageTypeRef | undefined, boolean, string | undefined, NamedConstraintSpec | undefined, infer UniqueSpec> ? UniqueSpec extends NamedConstraintSpec ? true : false : false;
+type HasNamedConstraintId<State extends AnyScalarFieldState> = State extends ScalarFieldState<ColumnTypeDescriptor, NamedStorageTypeRef | undefined, boolean, string | undefined, infer IdSpec, NamedConstraintSpec | undefined, boolean> ? IdSpec extends NamedConstraintSpec ? true : false : false;
+type HasNamedConstraintUnique<State extends AnyScalarFieldState> = State extends ScalarFieldState<ColumnTypeDescriptor, NamedStorageTypeRef | undefined, boolean, string | undefined, NamedConstraintSpec | undefined, infer UniqueSpec, boolean> ? UniqueSpec extends NamedConstraintSpec ? true : false : false;
 type FieldSqlSpecForState<State extends AnyScalarFieldState> = {
   readonly column?: string;
 } & (HasNamedConstraintId<State> extends true ? {
@@ -195,7 +239,7 @@ type FieldSqlSpecForState<State extends AnyScalarFieldState> = {
 } : Record<never, never>) & (HasNamedConstraintUnique<State> extends true ? {
   readonly unique?: NamedConstraintNameSpec;
 } : Record<never, never>);
-type ApplyFieldSqlSpec<State extends AnyScalarFieldState, Spec extends FieldSqlSpecForState<State>> = State extends ScalarFieldState<infer CodecId, infer TypeRef, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec> ? ScalarFieldState<CodecId, TypeRef, Nullable, Spec extends {
+type ApplyFieldSqlSpec<State extends AnyScalarFieldState, Spec extends FieldSqlSpecForState<State>> = State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec, infer Many> ? ScalarFieldState<Descriptor, TypeRef, Nullable, Spec extends {
   readonly column: infer NextColumn extends string;
 } ? NextColumn : ColumnName, Spec extends {
   readonly id: {
@@ -205,7 +249,7 @@ type ApplyFieldSqlSpec<State extends AnyScalarFieldState, Spec extends FieldSqlS
   readonly unique: {
     readonly name: infer UniqueName extends string;
   };
-} ? UniqueSpec extends NamedConstraintSpec ? NamedConstraintSpec<UniqueName> : UniqueSpec : UniqueSpec> : never;
+} ? UniqueSpec extends NamedConstraintSpec ? NamedConstraintSpec<UniqueName> : UniqueSpec : UniqueSpec, Many> : AnyScalarFieldState;
 type GeneratedFieldSpec = {
   readonly type: ColumnTypeDescriptor;
   readonly typeParams?: Record<string, unknown>;
@@ -222,27 +266,28 @@ declare class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFi
    * `TargetFieldRef.columnName` so FK target columns are resolved correctly.
    */
   get physicalColumnName(): string | undefined;
-  optional(): ScalarFieldBuilder<State extends ScalarFieldState<infer CodecId, infer TypeRef, boolean, infer ColumnName, infer IdSpec, infer UniqueSpec> ? ScalarFieldState<CodecId, TypeRef, true, ColumnName, IdSpec, UniqueSpec> : never>;
-  column<ColumnName extends string>(name: ColumnName): ScalarFieldBuilder<State extends ScalarFieldState<infer CodecId, infer TypeRef, infer Nullable, string | undefined, infer IdSpec, infer UniqueSpec> ? ScalarFieldState<CodecId, TypeRef, Nullable, ColumnName, IdSpec, UniqueSpec> : never>;
+  optional(): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, boolean, infer ColumnName, infer IdSpec, infer UniqueSpec, infer Many> ? ScalarFieldState<Descriptor, TypeRef, true, ColumnName, IdSpec, UniqueSpec, Many> : AnyScalarFieldState>;
+  column<ColumnName extends string>(name: ColumnName): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, string | undefined, infer IdSpec, infer UniqueSpec, infer Many> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, UniqueSpec, Many> : AnyScalarFieldState>;
+  many(): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, infer ColumnName, infer IdSpec, infer UniqueSpec, boolean> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, UniqueSpec, true> : AnyScalarFieldState>;
   default(value: ColumnDefaultLiteralInputValue | ColumnDefault): ScalarFieldBuilder<State>;
   defaultSql(expression: string): ScalarFieldBuilder<State>;
-  id<const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>): ScalarFieldBuilder<State extends ScalarFieldState<infer CodecId, infer TypeRef, infer Nullable, infer ColumnName, NamedConstraintSpec | undefined, infer UniqueSpec> ? ScalarFieldState<CodecId, TypeRef, Nullable, ColumnName, NamedConstraintSpec<Name>, UniqueSpec> : never>;
-  unique<const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>): ScalarFieldBuilder<State extends ScalarFieldState<infer CodecId, infer TypeRef, infer Nullable, infer ColumnName, infer IdSpec, NamedConstraintSpec | undefined> ? ScalarFieldState<CodecId, TypeRef, Nullable, ColumnName, IdSpec, NamedConstraintSpec<Name>> : never>;
+  id<const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, infer ColumnName, NamedConstraintSpec | undefined, infer UniqueSpec, infer Many> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, NamedConstraintSpec<Name>, UniqueSpec, Many> : AnyScalarFieldState>;
+  unique<const Name extends string | undefined = undefined>(options?: NamedConstraintSpec<Name>): ScalarFieldBuilder<State extends ScalarFieldState<infer Descriptor, infer TypeRef, infer Nullable, infer ColumnName, infer IdSpec, NamedConstraintSpec | undefined, infer Many> ? ScalarFieldState<Descriptor, TypeRef, Nullable, ColumnName, IdSpec, NamedConstraintSpec<Name>, Many> : AnyScalarFieldState>;
   sql<const Spec extends FieldSqlSpecForState<State>>(spec: Spec): ScalarFieldBuilder<ApplyFieldSqlSpec<State, Spec>>;
   build(): State;
 }
-declare class EnumScalarFieldBuilder<Handle extends EnumTypeHandle, State extends AnyScalarFieldState = ScalarFieldState<Handle['codecId'], Handle, false, undefined>> extends ScalarFieldBuilder<State> {
+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>;
   defaultSql(_expression: never): never;
 }
-declare function columnField<Descriptor extends ColumnTypeDescriptor>(descriptor: Descriptor): ScalarFieldBuilder<ScalarFieldState<Descriptor['codecId'], undefined, false, undefined>>;
+declare function columnField<Descriptor extends ColumnTypeDescriptor>(descriptor: Descriptor): ScalarFieldBuilder<ScalarFieldState<Descriptor, undefined, false, undefined>>;
 declare function generatedField<Descriptor extends ColumnTypeDescriptor>(spec: GeneratedFieldSpec & {
   readonly type: Descriptor;
-}): ScalarFieldBuilder<ScalarFieldState<Descriptor['codecId'], undefined, false, undefined>>;
-declare function namedTypeField<TypeRef extends string>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<string, TypeRef, false, undefined>>;
-declare function namedTypeField<TypeRef extends StorageTypeInstance>(typeRef: TypeRef): ScalarFieldBuilder<ScalarFieldState<TypeRef['codecId'], TypeRef, false, undefined>>;
+}): 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';
@@ -571,7 +616,7 @@ type ContractInput<Family extends FamilyPackRef<string> = FamilyPackRef<string>,
    */
   readonly namespaces?: readonly string[];
   /**
-   * Target-supplied factory that materialises a `Namespace` concretion
+   * Target-supplied factory that materialises a `SqlNamespaceBase` concretion
    * for a declared namespace coordinate. The SQL family layer is
    * target-agnostic and cannot import concretions like
    * `PostgresSchema` or `SqliteUnboundDatabase`; the factory is the
@@ -583,14 +628,8 @@ type ContractInput<Family extends FamilyPackRef<string> = FamilyPackRef<string>,
    * `StorageTable.namespaceId` referenced by a model, and the
    * framework `UNBOUND_NAMESPACE_ID` sentinel (always present so the
    * late-bound slot stays available regardless of authoring choices).
-   *
-   * When omitted, the family layer falls back to its placeholder
-   * `SqlUnboundNamespace` singleton for the unbound slot and rejects
-   * any non-unbound coordinate — single-namespace contracts authored
-   * before targets ship their factory stay byte-stable; multi-namespace
-   * contracts must pass the factory through.
    */
-  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
@@ -600,6 +639,15 @@ type ContractInput<Family extends FamilyPackRef<string> = FamilyPackRef<string>,
    * default namespace. Fields reference the enum via `field.namedType(handle)`.
    */
   readonly enums?: Record<string, EnumTypeHandle>;
+  /**
+   * Author-declared pack entities, keyed by namespace id then entity kind
+   * then name — e.g. `{ auth: { native_enum: { AalLevel: <entity> } } }`.
+   * Each entity lowers into `storage.namespaces[ns].entries.<kind>`; when its
+   * registered entity-type descriptor derives a value-set, that also folds
+   * into `entries.valueSet`, mirroring how `enums` flows there. Generic on
+   * purpose — neither this type nor the assembler names a specific kind.
+   */
+  readonly packEntities?: PackEntitiesInput;
 };
 declare function model<const ModelName extends string, Fields extends Record<string, ScalarFieldBuilder>, Relations extends Record<string, AnyRelationBuilder> = Record<never, never>>(modelName: ModelName, input: {
   readonly fields: Fields;
@@ -715,7 +763,7 @@ type ResolveTemplateValue<Template, Args extends readonly unknown[]> = Template
 type ResolveTemplatePathValue<Value, Path extends readonly string[] | undefined> = Path extends readonly [infer Segment extends string, ...infer Rest extends readonly string[]] ? Segment extends keyof NonNullable<Value> ? ResolveTemplatePathValue<NonNullable<Value>[Segment], Rest> : never : Value;
 type ResolveTemplateDefaultValue<Value, Default, Args extends readonly unknown[]> = Default extends undefined ? Value : [Value] extends [never] ? ResolveTemplateValue<Default, Args> : undefined extends Value ? Exclude<Value, undefined> | ResolveTemplateValue<Default, Args> : Value;
 type ResolveTemplateArgValue<Value, Path extends readonly string[] | undefined, Default, Args extends readonly unknown[]> = ResolveTemplateDefaultValue<ResolveTemplatePathValue<Value, Path>, Default, Args>;
-type FieldBuilderFromPresetDescriptor<Descriptor extends AuthoringFieldPresetDescriptor, Args extends readonly unknown[] = readonly [], ConstraintName extends string | undefined = undefined> = ScalarFieldBuilder<ScalarFieldState<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 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 {
   readonly args: infer Args extends readonly AuthoringArgumentDescriptor[];
 } ? <const Params extends TupleFromArgumentDescriptors<Args>>(...args: Params) => FieldBuilderFromPresetDescriptor<Descriptor, Params> : () => FieldBuilderFromPresetDescriptor<Descriptor, readonly []>;
@@ -727,10 +775,10 @@ type FieldHelpersFromNamespace<Namespace> = { readonly [K in keyof Namespace]: N
 //#endregion
 //#region src/contract-types.d.ts
 type ExtractCodecTypesFromPack<P> = P extends {
-  __codecTypes?: infer C;
-} ? C extends Record<string, {
-  output: unknown;
-}> ? C : Record<string, never> : Record<string, never>;
+  __codecTypes?: infer C extends Record<string, {
+    output: unknown;
+  }>;
+} ? C : Record<string, never>;
 type MergeExtensionCodecTypes<Packs extends Record<string, unknown>> = UnionToIntersection<{ [K in keyof Packs]: ExtractCodecTypesFromPack<Packs[K]> }[keyof Packs]>;
 type MergeExtensionCodecTypesSafe<Packs> = Packs extends Record<string, unknown> ? keyof Packs extends never ? Record<string, never> : MergeExtensionCodecTypes<Packs> : Record<string, never>;
 type ExtractIndexTypesFromPack<P> = P extends {
@@ -813,6 +861,9 @@ type FieldTypeRefOf<FieldState> = Present<FieldState extends {
 type FieldNullableOf<FieldState> = FieldState extends {
   readonly nullable: infer Nullable extends boolean;
 } ? Nullable : boolean;
+type FieldManyOf<FieldState> = FieldState extends {
+  readonly many?: true;
+} ? true : false;
 type FieldColumnOverrideOf<FieldState> = Present<FieldState extends {
   readonly columnName?: infer ColumnName;
 } ? ColumnName : never>;
@@ -865,17 +916,19 @@ type AttributeIdName<Definition, ModelName extends ModelNames<Definition>> = Pre
 } ? Name : never>;
 type ModelIdFieldNames<Definition, ModelName extends ModelNames<Definition>> = [AttributeIdFieldNames<Definition, ModelName>] extends [undefined] ? InlineIdFieldNames<Definition, ModelName> : AttributeIdFieldNames<Definition, ModelName>;
 type ModelIdName<Definition, ModelName extends ModelNames<Definition>> = [AttributeIdName<Definition, ModelName>] extends [never] ? Present<InlineIdName<Definition, ModelName>> : AttributeIdName<Definition, ModelName>;
-type StorageColumn<CodecId extends string, Nullable extends boolean, NativeType extends string, TypeRef extends string | undefined = undefined, TypeParams extends Record<string, unknown> | undefined = undefined> = {
+type StorageColumn<CodecId extends string, Nullable extends boolean, 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>) & (TypeParams extends Record<string, unknown> ? {
+} : Record<never, never>) & (TypeParams extends Record<string, unknown> ? {
   readonly typeParams: TypeParams;
-} : Record<string, never>);
-type ModelStorageColumn<Definition, ModelName extends ModelNames<Definition>, FieldName extends string> = FieldName extends ModelFieldNames<Definition, ModelName> ? StorageColumn<DescriptorCodecId<ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName, FieldName>>>, FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>>, DescriptorNativeType<ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName, FieldName>>>, ResolveFieldColumnTypeRef<Definition, ModelFieldState<Definition, ModelName, FieldName>>, ResolveFieldColumnTypeParams<Definition, ModelFieldState<Definition, ModelName, FieldName>>> : never;
+} : Record<never, never>) & (Many extends true ? {
+  readonly many: true;
+} : Record<never, never>);
+type ModelStorageColumn<Definition, ModelName extends ModelNames<Definition>, FieldName extends string> = FieldName extends ModelFieldNames<Definition, ModelName> ? StorageColumn<DescriptorCodecId<ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName, FieldName>>>, FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>>, DescriptorNativeType<ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName, FieldName>>>, ResolveFieldColumnTypeRef<Definition, ModelFieldState<Definition, ModelName, FieldName>>, ResolveFieldColumnTypeParams<Definition, ModelFieldState<Definition, ModelName, FieldName>>, FieldManyOf<ModelFieldState<Definition, ModelName, FieldName>>> : never;
 type BuiltModels<Definition> = { readonly [ModelName in ModelNames<Definition>]: {
   readonly storage: {
     readonly table: ModelTableName<Definition, ModelName>;
@@ -967,10 +1020,23 @@ type BuiltStorage<Definition> = {
     };
   } };
 };
+type StorageColumnManyOf<Col> = Col extends {
+  readonly many: true;
+} ? true : false;
 type EnumValueUnion<FieldState> = [FieldTypeRefOf<FieldState>] extends [EnumTypeHandle<string, infer Values>] ? readonly unknown[] extends Values ? never : Values[number] : never;
-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;
-type FieldChannelType<Definition, ModelName extends ModelNames<Definition>, FieldName extends ModelFieldNames<Definition, ModelName>, Channel extends 'output' | 'input'> = ([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 DescriptorEntityMembers<Descriptor> = Descriptor extends {
+  readonly entityRef: {
+    readonly entity: {
+      readonly members: infer Members extends readonly string[];
+    };
+  };
+} ? Members : never;
+type DescriptorValueSetUnion<FieldState> = [FieldDescriptorOf<FieldState>] extends [never] ? never : readonly string[] extends DescriptorEntityMembers<FieldDescriptorOf<FieldState>> ? never : DescriptorEntityMembers<FieldDescriptorOf<FieldState>>[number];
+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 } ? StorageColumnManyOf<ModelStorageColumn<Definition, ModelName, FieldName>> extends true ? ReadonlyArray<T> : T : unknown : unknown;
+type FieldValueUnion<FieldState> = [EnumValueUnion<FieldState>] extends [never] ? DescriptorValueSetUnion<FieldState> : EnumValueUnion<FieldState>;
+type FieldChannelType<Definition, ModelName extends ModelNames<Definition>, FieldName extends ModelFieldNames<Definition, ModelName>, Channel extends 'output' | 'input'> = ([FieldValueUnion<ModelFieldState<Definition, ModelName, FieldName>>] extends [never] ? CodecChannelType<Definition, ModelName, FieldName, Channel> : 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);
 type FieldChannelTypes<Definition, Channel extends 'output' | 'input'> = { readonly [Ns in DefaultStorageNamespaceId<Definition>]: { readonly [ModelName in ModelNames<Definition>]: { readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldChannelType<Definition, ModelName, FieldName, Channel> } } };
+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> } } };
 type SqlContractResult<Definition> = ContractWithTypeMaps<Omit<Contract<BuiltStorage<Definition>>, 'domain'> & {
   readonly target: DefinitionTargetId<Definition>;
   readonly targetFamily: 'sql';
@@ -982,7 +1048,7 @@ type SqlContractResult<Definition> = ContractWithTypeMaps<Omit<Contract<BuiltSto
   readonly extensionPacks: keyof DefinitionExtensionPacks<Definition> extends never ? Record<string, never> : DefinitionExtensionPacks<Definition>;
   readonly capabilities: DerivedCapabilities<Definition>;
   readonly enumAccessors: BuiltEnumAccessors<Definition>;
-}, TypeMaps<CodecTypesFromDefinition<Definition>, Record<string, never>, FieldChannelTypes<Definition, 'output'>, FieldChannelTypes<Definition, 'input'>>>;
+}, TypeMaps<CodecTypesFromDefinition<Definition>, Record<string, never>, FieldChannelTypes<Definition, 'output'>, FieldChannelTypes<Definition, 'input'>, StorageColumnChannelTypes<Definition, 'output'>, StorageColumnChannelTypes<Definition, 'input'>>>;
 //#endregion
 //#region src/composed-authoring-helpers.d.ts
 type ExtractTypeNamespaceFromPack<Pack> = ExtractAuthoringNamespaceFromPack<Pack, 'type', Record<never, never>>;
@@ -1030,169 +1096,6 @@ type ComposedAuthoringHelpers<Family extends FamilyPackRef<string>, Target exten
   readonly type: TypeHelpersFromNamespace<ExtractTypeNamespaceFromPack<Family> & ExtractTypeNamespaceFromPack<Target> & MergeExtensionTypeNamespaces<ExtensionPacks>>;
 };
 //#endregion
-//#region src/contract-definition.d.ts
-interface FieldNode {
-  readonly fieldName: string;
-  readonly columnName: string;
-  readonly descriptor: ColumnTypeDescriptor;
-  readonly nullable: boolean;
-  readonly default?: ColumnDefault;
-  readonly executionDefaults?: ExecutionMutationDefaultPhases$1;
-  readonly many?: boolean;
-  /** 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;
-}
-interface IndexNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly type?: string;
-  readonly options?: Record<string, unknown>;
-}
-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;
-  readonly toTable: string;
-  /**
-   * 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';
-  /**
-   * 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;
-    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?: ColumnDefault;
-  readonly executionDefaults?: ExecutionMutationDefaultPhases$1;
-  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 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 extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
-  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[];
-  /** Target-supplied factory that materialises a `Namespace` concretion for a declared namespace coordinate. */
-  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
-  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>;
-}
-//#endregion
 //#region src/build-contract.d.ts
 declare function buildSqlContractFromDefinition(definition: ContractDefinition, codecLookup?: CodecLookup): Contract<SqlStorage>;
 //#endregion
@@ -1218,11 +1121,12 @@ type ContractDefinition$1<Family extends FamilyPackRef<string>, Target extends T
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
   readonly defaultControlPolicy?: ControlPolicy;
   readonly namespaces?: Namespaces;
-  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
   readonly enums?: Enums;
+  readonly packEntities?: PackEntitiesInput;
 };
 type ContractScaffold<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Naming extends ContractInput['naming'] | undefined, 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;
@@ -1233,16 +1137,18 @@ type ContractScaffold<Family extends FamilyPackRef<string>, Target extends Targe
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
   readonly defaultControlPolicy?: ControlPolicy;
   readonly namespaces?: Namespaces;
-  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
   readonly types?: never;
   readonly models?: never;
   readonly codecLookup?: CodecLookup;
   readonly enums?: Enums;
+  readonly packEntities?: PackEntitiesInput;
 };
 type ContractFactory<Family extends FamilyPackRef<string>, Target extends TargetPackRef<'sql', string>, Types extends Record<string, StorageTypeInstance>, 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;
+  readonly packEntities?: PackEntitiesInput;
 };
 type BoundDefinitionInput<Types extends Record<string, StorageTypeInstance> = Record<never, never>, Models extends Record<string, ModelLike> = Record<never, never>, ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, Naming extends ContractInput['naming'] | undefined = undefined, StorageHash extends string | undefined = undefined, ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined, Namespaces extends readonly string[] | undefined = undefined> = {
   readonly extensionPacks?: ExtensionPacks;
@@ -1251,11 +1157,12 @@ type BoundDefinitionInput<Types extends Record<string, StorageTypeInstance> = Re
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
   readonly defaultControlPolicy?: ControlPolicy;
   readonly namespaces?: Namespaces;
-  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
   readonly enums?: Record<string, EnumTypeHandle>;
+  readonly packEntities?: PackEntitiesInput;
 };
 type LiteralEnums<E extends Record<string, EnumTypeHandle>> = string extends keyof E ? Record<never, never> : E;
 type MergeEnums<ScaffoldEnums extends Record<string, EnumTypeHandle>, FactoryEnums extends Record<string, EnumTypeHandle>> = LiteralEnums<ScaffoldEnums> & LiteralEnums<FactoryEnums>;
@@ -1279,6 +1186,7 @@ declare function buildBoundContract<const F extends FamilyPackRef<string>, const
   readonly types?: Record<string, StorageTypeInstance>;
   readonly models?: Record<string, ModelLike>;
   readonly enums?: Record<string, EnumTypeHandle>;
+  readonly packEntities?: PackEntitiesInput;
 }>(family: F, target: T, definition: Definition, factory: (helpers: ComposedAuthoringHelpers<F, T, NonNullable<Definition['extensionPacks']>>) => Built): SqlContractResult<WithFamilyTarget<Definition & Built, F, T>>;
 declare function defineContract<const Family extends FamilyPackRef<string>, const Target extends TargetPackRef<'sql', string>, const Types extends Record<string, StorageTypeInstance> = Record<never, never>, const Models extends Record<string, ModelLike> = Record<never, never>, const ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, const Naming extends ContractInput['naming'] | undefined = undefined, 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$1<Family, Target, Types, Models, ExtensionPacks, Naming, StorageHash, ForeignKeyDefaults, Namespaces, Enums>): SqlContractResult<ContractDefinition$1<Family, Target, Types, Models, ExtensionPacks, Naming, StorageHash, ForeignKeyDefaults, Namespaces, Enums>>;
 declare function defineContract<const Family extends FamilyPackRef<string>, const Target extends TargetPackRef<'sql', string>, const Types extends Record<string, StorageTypeInstance> = Record<never, never>, const Models extends Record<string, ModelLike> = Record<never, never>, const ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, const Naming extends ContractInput['naming'] | undefined = undefined, 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, Target, ExtensionPacks, Naming, StorageHash, ForeignKeyDefaults, Namespaces, ScaffoldEnums>, factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks, FactoryEnums>): SqlContractResult<ContractDefinition$1<Family, Target, Types, Models, ExtensionPacks, Naming, StorageHash, ForeignKeyDefaults, Namespaces, MergeEnums<ScaffoldEnums, FactoryEnums>>>;