@prisma/orm-family-sql 8.0.0-rc.2-dev.2 → 8.0.0-rc.20

package/dist/orm-client.d.mts

@@ -1,20 +1,117 @@
-import { r as StorageTable, t as StorageColumn } from "./storage-table-DSeWszOL-CI-cItEK.mjs";
-import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
-import { f as ExtractFieldOutputTypes, l as ExtractAggregateTypes, p as ExtractQueryOperationTypes, u as ExtractCodecTypes } from "./types-BDUG29Df-LE85dIXP.mjs";
-import "./types-UcHa2cTe.mjs";
-import { It as WhereArg, T as CodecRef$1, a as AndExpr, g as BinaryExpr, gt as OrderByItem, ht as OrExpr, pt as NullCheckExpr, r as AggregateFn, s as AnyExpression } from "./types-v3qxLLxo-DCeKv7yY.mjs";
-import "./ast-HFcfQZr-.mjs";
-import { o as Expression } from "./expression-FJK6Ar-d.mjs";
-import { r as ExecutionContext } from "./query-lane-context-Qa-eddrE-kuZ8Z86-.mjs";
-import "./query-lane-context-XMvk7fmY.mjs";
-import { h as RuntimeScope, o as ComputeColumnJsType } from "./types-CyxGtOOh-BggSa6Fe.mjs";
-import "./types-B0msOnBM.mjs";
+import { t as StorageColumn } from "./storage-table-Bf1ZjnxO-pUj6pyP0.mjs";
+import { l as SqlStorage } from "./sql-storage-DeCAh5Hi-CEM-m8cs.mjs";
+import { D as QueryOperationTypesBase, d as ExtractAggregateTypes, f as ExtractCodecTypes, h as ExtractQueryOperationTypes, m as ExtractFieldOutputTypes, p as ExtractFieldInputTypes } from "./types-DfKvtJwS-CrpWTGBJ.mjs";
+import { n as HasExecutionCreateDefault, r as IsOptionalCreateColumn } from "./types-CkAd8SWm.mjs";
+import { Bt as TableSource, Ct as OrderByNulls, E as CodecRef$1, O as ColumnRef, St as OrderByItem, Ut as WhereArg, _ as BinaryExpr, a as AndExpr, c as AnyExpression, ct as LimitOffsetValue, dt as LockStrength, pt as LockingClause, r as AggregateFn, xt as OrExpr, yt as NullCheckExpr } from "./types-DriMIMNQ-BkbsW7w3.mjs";
+import { n as SqlQueryPlan, t as Preparable } from "./plan-Cr4azjnG-CuL8FqXC.mjs";
+import { C as TraitExpression, g as RawSqlInterpolation, i as CodecTypesBase, o as Expression, r as CodecExpression } from "./expression-6ld_ZQL6-fOuazzzm.mjs";
+import "./expression-D8HstQiB.mjs";
+import { n as BuiltinFunctions, t as BooleanCodecType } from "./functions-EW-RrRn3.mjs";
+import { c as LockOptionCapabilities, l as LockStrengthCapabilities, u as LockWaitOptions } from "./ast-YEMe_B8z.mjs";
+import { r as TableIndexReferences, t as IndexReference } from "./index-reference-4wsdeB7v-DCwswK-q.mjs";
+import "./index-reference-D8ewQRJr.mjs";
+import "./plan-Di6Gs2JD.mjs";
+import { c as CollectionMethodRegistry, r as CollectionMethodContributionId, u as ContributedMethodSignature } from "./collection-methods-D2UnCS0S-DOy2qHYS.mjs";
+import { n as ExecutionContext } from "./query-lane-context-BCEoKy0_-CzmyavC9.mjs";
+import "./query-lane-context-VqH0mS9B.mjs";
+import { h as RuntimeScope, o as ComputeColumnJsType } from "./types-TXO7x1BA-CYYIY8NI.mjs";
+import "./types-B9wSEUsV.mjs";
+import { l as PreparedFor, n as Declaration, o as ParamsFromDeclaration, t as BindSiteParams, u as PreparedStatement } from "./transaction-state-DR3nKTmH-D29jmVE-.mjs";
+import "./collection-methods-BB8YH69u.mjs";
+import { F as ActivitySourceTarget, W as Runtime, X as RuntimeQueryable$1 } from "./index-7nHHQsAj.mjs";
+import { CodecDescriptorRef, ScalarFieldDeclarationBuilder } from "@prisma/orm-framework/components/codec";
 import { Contract } from "@prisma/orm-framework/contract/types";
-import { AnnotationValue, AsyncIterableResult, MetaBuilder, OperationKind } from "@prisma/orm-framework/components/runtime";
+import { AsyncIterableResult, MetaBuilder, ResultType, RuntimeExecuteOptions } from "@prisma/orm-framework/components/runtime";
 import { SimplifyDeep } from "@prisma/orm-framework/utils/simplify-deep";
 //#region ../../../3-extensions/sql-orm-client/dist/index.d.mts
+//#region src/table-scope.d.ts
+interface TableStorageCoordinate {
+  readonly namespaceId: string;
+  readonly tableName: string;
+}
+interface AliasedTable {
+  readonly alias: string;
+  readonly storage: TableStorageCoordinate;
+  column(name: string): ColumnRef;
+  tableSource(contract: Contract<SqlStorage>): TableSource;
+}
+interface TableScope {
+  alias(preferred: string): string;
+  aliasTable(storage: TableStorageCoordinate): AliasedTable;
+  copy(): TableScope;
+}
+//#endregion
+//#region src/collection-tables.d.ts
+interface CollectionTables {
+  readonly scope: TableScope;
+  readonly root: AliasedTable;
+  readonly variants: ReadonlyMap<string, AliasedTable>;
+}
+declare function createCollectionTables(contract: Contract<SqlStorage>, namespaceId: string, modelName: string, tableName?: string): CollectionTables;
+//#endregion
+//#region src/collection-types.d.ts
+declare const RowType: unique symbol;
+declare const TypeState: unique symbol;
+/** Something that yields values of type `Row`: a collection, whose row includes the relations and values `include` adds, or an include scalar or combine, which yields one value per parent row. */
+interface HasRow<Row = unknown> {
+  readonly [RowType]: Row;
+}
+/** A collection whose type state is `State`. */
+interface HasTypeState<State = CollectionTypeState> {
+  readonly [TypeState]: State;
+}
+/** The fact that a filter has been applied: the type-state flag `hasWhere` is `true`. Write `Filtered<C>` for a filtered collection; error messages print `HasWhere`. */
+interface HasWhere extends HasTypeState<{
+  readonly hasWhere: true;
+}> {}
+/** The fact that an order has been applied: the type-state flag `hasOrderBy` is `true`. Write `Ordered<C>` for an ordered collection; error messages print `HasOrderBy`. */
+interface HasOrderBy extends HasTypeState<{
+  readonly hasOrderBy: true;
+}> {}
+/** The fact that no variant has been selected: the type-state field `variantValue` is `undefined`. `variant()` needs it; error messages print `HasNoVariant`. */
+interface HasNoVariant extends HasTypeState<{
+  readonly variantValue: undefined;
+}> {}
+declare const UniqueFilter: unique symbol;
+interface HasUniqueFilter extends HasTypeState<{
+  readonly uniqueFilter: true;
+}> {
+  readonly [UniqueFilter]: true;
+}
+interface HasNoUniqueFilter extends HasTypeState<{
+  readonly hasWhere: boolean;
+  readonly uniqueFilter?: never;
+}> {
+  readonly [UniqueFilter]?: never;
+}
+type WithoutUniqueFilter<Self> = [Self] extends [HasTypeState<{
+  readonly uniqueFilter: true;
+}>] ? never : unknown;
+/** A collection with a filter applied: `C & HasWhere`. */
+type Filtered<C> = C & HasWhere;
+type UniquelyFiltered<C> = C & HasWhere & HasUniqueFilter;
+/** A collection with an order applied: `C & HasOrderBy`. */
+type Ordered<C> = C & HasOrderBy;
+/** A collection whose rows also have the fields of `Added`, such as an included relation. */
+type Including<C extends HasRow, Added> = C & HasRow<CollectionRowOf<C> & Added>;
+/** A query fragment: a function from one collection to another. `collection.with(fragment)` runs it. A fragment that only adds conditions is also called a scope. */
+type QueryFragment<In, Out> = (collection: In) => Out;
+/** What a fragment made by `collection.fragment` accepts: a collection of the model, in the same namespace when the fragment's collection names one, whose rows have every field of the model and that is not narrowed to a variant. */
+type ModelFragmentReceiver<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = HasRow<DefaultModelRow<TContract, ModelName, NsId>> & HasTypeState<[NsId] extends [never] ? {
+  readonly variantValue: undefined;
+} : {
+  readonly variantValue: undefined;
+  readonly nsId: NsId;
+}> & {
+  readonly modelName: ModelName;
+};
+/** The type state of a collection. */
+type CollectionTypeStateOf<C extends HasTypeState> = C[typeof TypeState];
+/** The rows a collection produces, as one object type. Declarations print it by this name, so it never names `RowType`. */
+type CollectionRowOf<C extends HasRow> = C[typeof RowType] extends (infer Row extends C[typeof RowType]) ? { [K in keyof Row]: Row[K]; } : never;
+//#endregion
 //#region src/types.d.ts
-interface IncludeScalar<Result> extends RowSelection<Result> {
+interface IncludeScalar<Result> extends HasRow<Result> {
   readonly kind: 'includeScalar';
   /** An operation name from the contract's emitted aggregate map — an open vocabulary. */
   readonly fn: string;
@@ -30,7 +127,7 @@ interface IncludeScalarBranch {
   readonly selector: IncludeScalar<unknown>;
 }
 type IncludeCombineBranch = IncludeRowsBranch | IncludeScalarBranch;
-interface IncludeCombine<ResultShape extends Record<string, unknown>> extends RowSelection<ResultShape> {
+interface IncludeCombine<ResultShape extends Record<string, unknown>> extends HasRow<ResultShape> {
   readonly kind: 'includeCombine';
   readonly branches: Readonly<Record<string, IncludeCombineBranch>>;
 }
@@ -52,16 +149,20 @@ interface IncludeExpr {
   readonly relatedModelName: string;
   readonly relatedNamespaceId: string;
   readonly relatedTableName: string;
-  readonly localTableName: string;
-  readonly targetColumn: string;
-  readonly localColumn: string;
+  readonly localVariantValue?: string;
+  /** Target-side join columns, positionally paired with `localColumns`. */
+  readonly targetColumns: readonly string[];
+  /** Local-side join columns, positionally paired with `targetColumns`. */
+  readonly localColumns: readonly string[];
   readonly cardinality: RelationCardinalityTag | undefined;
   readonly through?: IncludeThroughDescriptor;
+  readonly junction?: AliasedTable;
   readonly nested: CollectionState;
   readonly scalar: IncludeScalar<unknown> | undefined;
   readonly combine: Readonly<Record<string, IncludeCombineBranch>> | undefined;
 }
 interface CollectionState {
+  readonly tables: CollectionTables;
   readonly filters: readonly AnyExpression[];
   readonly includes: readonly IncludeExpr[];
   readonly orderBy: readonly OrderByItem[] | undefined;
@@ -69,24 +170,27 @@ interface CollectionState {
   readonly distinct: readonly string[] | undefined;
   readonly distinctOn: readonly string[] | undefined;
   readonly selectedFields: readonly string[] | undefined;
-  readonly limit: number | undefined;
-  readonly offset: number | undefined;
-  readonly variantName: string | undefined;
-  /**
-   * Annotations attached to this query at terminal-call time.
-   * Populated transiently by terminal methods (`first`, `all`, `create`,
-   * etc.) just before dispatch — `Collection` itself has no chainable
-   * `.annotate()`. Stored as a `Map<namespace, AnnotationValue>` so
-   * duplicate namespaces last-write-win. Empty on a fresh state.
-   */
-  readonly annotations: ReadonlyMap<string, AnnotationValue<unknown, OperationKind>>;
+  readonly limit: LimitOffsetValue | undefined;
+  readonly offset: LimitOffsetValue | undefined;
+  readonly variantValue: string | undefined;
+  readonly locking: ReadonlyArray<LockingClause> | undefined;
+}
+declare function emptyState(tables: CollectionTables): CollectionState;
+/**
+ * `GroupedCollection`'s own post-group chain — orders/pages the grouped rows
+ * themselves. Kept separate from {@link CollectionState}: pre-group and
+ * post-group clauses are different clauses at different levels, and merging
+ * them into one state is the defect this shape exists to prevent.
+ */
+interface GroupPagingState {
+  readonly orderBy: readonly OrderByItem[];
+  readonly limit: LimitOffsetValue | undefined;
+  readonly offset: LimitOffsetValue | undefined;
 }
-declare function emptyState(): CollectionState;
 interface CollectionTypeState {
   readonly hasOrderBy: boolean;
   readonly hasWhere: boolean;
-  readonly hasUniqueFilter: boolean;
-  readonly variantName: string | undefined;
+  readonly variantValue: string | undefined;
   /**
    * The namespace coordinate this collection resolves at — set by the
    * `orm.<ns>.<Model>` facet so the create/update/where input types (and the
@@ -99,10 +203,9 @@ interface CollectionTypeState {
 }
 type RelationCardinalityTag = '1:1' | 'N:1' | '1:N' | 'N:M';
 type DefaultCollectionTypeState = {
-  readonly hasOrderBy: false;
-  readonly hasWhere: false;
-  readonly hasUniqueFilter: false;
-  readonly variantName: undefined;
+  readonly hasOrderBy: boolean;
+  readonly hasWhere: boolean;
+  readonly variantValue: undefined;
   readonly nsId: never;
 };
 type WithNsId<State extends CollectionTypeState, NsId extends string> = Omit<State, 'nsId'> & {
@@ -116,7 +219,8 @@ interface RuntimeTransaction extends RuntimeScope {
   commit?(): Promise<void>;
   rollback?(): Promise<void>;
 }
-interface RuntimeQueryable extends RuntimeScope {
+/** What the ORM sends its statements to. It must carry an `activitySource` member, as the SQL runtime's queryables, connections, transactions and activity handles do: every terminal method starts an `orm-call` activity through it, and a terminal method on a queryable without one fails with `ORM.ACTIVITY_SOURCE_MISSING`. The member is optional in this type only because the public runtime types do not show it. */
+interface RuntimeQueryable extends RuntimeScope, Partial<ActivitySourceTarget> {
   connection?(): Promise<RuntimeConnection>;
   transaction?(): Promise<RuntimeTransaction>;
 }
@@ -124,27 +228,48 @@ interface CollectionContext<TContract extends Contract<SqlStorage>> {
   readonly runtime: RuntimeQueryable;
   readonly context: ExecutionContext<TContract>;
 }
-type ComparisonMethodFns<T> = {
-  eq(value: T): AnyExpression;
-  neq(value: T): AnyExpression;
+type PredicateOperand<T, CodecId extends string> = T | Expression<{
+  codecId: CodecId;
+  nullable: false;
+  many?: never;
+}>;
+type ComparisonMethodFns<T, CodecId extends string = never> = {
+  eq(value: T | Expression<{
+    codecId: CodecId;
+    nullable: boolean;
+    many?: never;
+  }>): AnyExpression;
+  neq(value: T | Expression<{
+    codecId: CodecId;
+    nullable: boolean;
+    many?: never;
+  }>): AnyExpression;
   gt(value: T): AnyExpression;
   lt(value: T): AnyExpression;
   gte(value: T): AnyExpression;
   lte(value: T): AnyExpression;
-  like(pattern: string): AnyExpression;
+  like(pattern: PredicateOperand<string, CodecId>): AnyExpression;
   in(values: readonly T[]): AnyExpression;
   notIn(values: readonly T[]): AnyExpression;
   isNull(): AnyExpression;
   isNotNull(): AnyExpression;
-  asc(): OrderByItem;
-  desc(): OrderByItem;
+  asc: Orderable['asc'];
+  desc: Orderable['desc'];
+};
+type OrderOptions = {
+  readonly nulls?: OrderByNulls;
+};
+/** A value the collection can order by: `asc`/`desc`, optionally placing nulls first or last. */
+type Orderable = {
+  asc(options?: OrderOptions): OrderByItem;
+  desc(options?: OrderOptions): OrderByItem;
 };
 /**
  * Trait-gated comparison methods. Only methods whose required traits are all present in `Traits` are included.
  *
  * - `traits: []` → always available (isNull, isNotNull)
  */
-type ComparisonMethods<T, Traits> = { [K in keyof ComparisonMethodsMeta as [ComparisonMethodsMeta[K]['traits'][number]] extends [Traits] ? K : never]: ComparisonMethodFns<T>[K]; };
+type ComparisonMethods<T, Traits, CodecId extends string = never> = { [K in keyof ComparisonMethodsMeta as [ComparisonMethodsMeta[K]['traits'][number]] extends [Traits] ? K : never]: ComparisonMethodFns<PredicateOperand<T, CodecId>, CodecId>[K]; };
 type QueryOperationReturnTraits<Returns, TCodecTypes extends Record<string, unknown>> = Returns extends {
   readonly codecId: infer Id extends string;
 } ? Id extends keyof TCodecTypes ? TCodecTypes[Id] extends {
@@ -187,7 +312,26 @@ type OpMatchesField<Op, CodecId extends string, CT extends Record<string, unknow
 } ? CodecId extends keyof CT ? CT[CodecId] extends {
   readonly traits: infer FieldTraits;
 } ? [RequiredTraits[number]] extends [FieldTraits] ? true : false : false : false : false : false;
-type FieldOperations<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string> = FieldCodecId<TContract, ModelName, FieldName> extends (infer CodecId extends string) ? ExtractQueryOperationTypes<TContract> extends (infer AllOps) ? { [OpName in keyof AllOps & string as OpMatchesField<AllOps[OpName], CodecId, ExtractCodecTypes<TContract>> extends true ? OpName : never]: QueryOperationMethod<AllOps[OpName], ExtractCodecTypes<TContract>>; } : unknown : unknown;
+type CodecOperations<TContract extends Contract<SqlStorage>, CodecId extends string> = ExtractQueryOperationTypes<TContract> extends (infer AllOps) ? { [OpName in keyof AllOps & string as OpMatchesField<AllOps[OpName], CodecId, ExtractCodecTypes<TContract>> extends true ? OpName : never]: QueryOperationMethod<AllOps[OpName], ExtractCodecTypes<TContract>>; } : unknown;
+type FieldOperations<TContract extends Contract<SqlStorage>, NsId extends string, ModelName extends string, FieldName extends string> = FieldCodecId<TContract, ModelName, FieldName, NsId> extends (infer CodecId extends string) ? ExtractQueryOperationTypes<TContract> extends (infer AllOps) ? { [OpName in keyof AllOps & string as OpMatchesField<AllOps[OpName], CodecId, ExtractCodecTypes<TContract>> extends true ? OpName : never]: QueryOperationMethod<AllOps[OpName], ExtractCodecTypes<TContract>>; } : unknown : unknown;
+type CodecTraits<TContract extends Contract<SqlStorage>, CodecId extends string> = CodecId extends keyof ExtractCodecTypes<TContract> ? ExtractCodecTypes<TContract>[CodecId] extends {
+  readonly traits: infer T;
+} ? T : never : never;
+type CodecInput<TContract extends Contract<SqlStorage>, CodecId extends string> = CodecId extends keyof ExtractCodecTypes<TContract> ? ExtractCodecTypes<TContract>[CodecId] extends {
+  readonly input: infer I;
+} ? I : unknown : unknown;
+/**
+ * The model accessor's type for any field with the codec `CodecId` and the given nullability. A function of `{ deletedAt: CodecField<Contract, 'pg/timestamptz-temporal@1', true> }` is a `where` callback for every model with such a field. Values are checked against the codec's input type, as they are for a model's own fields.
+ */
+type CodecField<TContract extends Contract<SqlStorage>, CodecId extends keyof ExtractCodecTypes<TContract> & string, Nullable extends boolean = false> = Expression<{
+  codecId: CodecId;
+  nullable: Nullable;
+}> & ComparisonMethods<CodecInput<TContract, CodecId> | (Nullable extends true ? null : never), CodecTraits<TContract, CodecId>, CodecId> & CodecOperations<TContract, CodecId>;
+/** The model accessor's type for a list field whose elements have the codec `CodecId`, as a fragment for any model declares it with `.many()`, or with `.many({ elementsNullable: true })` when `ElementNullable` is `true`. */
+type CodecListField<TContract extends Contract<SqlStorage>, CodecId extends keyof ExtractCodecTypes<TContract> & string, Nullable extends boolean = false, ElementNullable extends boolean = false> = Expression<{
+  codecId: CodecId;
+  nullable: Nullable;
+}> & ComparisonMethods<ReadonlyArray<CodecInput<TContract, CodecId> | (ElementNullable extends true ? null : never)> | (Nullable extends true ? null : never), CodecTraits<TContract, CodecId>, CodecId> & CodecOperations<TContract, CodecId>;
 /**
  * Declares trait requirements and runtime factory for each comparison method.
  *
@@ -233,11 +377,11 @@ declare const COMPARISON_METHODS_META: {
   };
   readonly asc: {
     readonly traits: readonly ["order"];
-    readonly create: (left: AnyExpression) => () => OrderByItem;
+    readonly create: (left: AnyExpression) => (options?: OrderOptions) => OrderByItem;
   };
   readonly desc: {
     readonly traits: readonly ["order"];
-    readonly create: (left: AnyExpression) => () => OrderByItem;
+    readonly create: (left: AnyExpression) => (options?: OrderOptions) => OrderByItem;
   };
   readonly isNull: {
     readonly traits: readonly [];
@@ -249,27 +393,115 @@ declare const COMPARISON_METHODS_META: {
   };
 };
 type ComparisonMethodsMeta = typeof COMPARISON_METHODS_META;
-type RelationPredicate<TContract extends Contract<SqlStorage>, ModelName extends string> = (model: ModelAccessor<TContract, ModelName>) => AnyExpression;
-type RelationPredicateInput<TContract extends Contract<SqlStorage>, ModelName extends string> = RelationPredicate<TContract, ModelName> | Record<string, unknown>;
-type RelationFilterAccessor<TContract extends Contract<SqlStorage>, RelatedModelName extends string> = {
-  some(predicate?: RelationPredicateInput<TContract, RelatedModelName>): AnyExpression;
-  every(predicate: RelationPredicateInput<TContract, RelatedModelName>): AnyExpression;
-  none(predicate?: RelationPredicateInput<TContract, RelatedModelName>): AnyExpression;
+type DomainNamespaceId<TContract extends Contract<SqlStorage>> = keyof TContract['domain']['namespaces'] & string;
+type RelationPredicate<TContract extends Contract<SqlStorage>, NsId extends DomainNamespaceId<TContract>, ModelName extends string> = (model: ModelAccessor<TContract, ModelName, NsId>, tools: ModelCallbackTools<TContract, ModelName, NsId>) => Condition;
+type RelationPredicateInput<TContract extends Contract<SqlStorage>, NsId extends DomainNamespaceId<TContract>, ModelName extends string> = RelationPredicate<TContract, NsId, ModelName> | Record<string, unknown>;
+type RelationFilterAccessor<TContract extends Contract<SqlStorage>, RelatedNsId extends DomainNamespaceId<TContract>, RelatedModelName extends string> = {
+  some(predicate?: RelationPredicateInput<TContract, RelatedNsId, RelatedModelName>): AnyExpression;
+  every(predicate: RelationPredicateInput<TContract, RelatedNsId, RelatedModelName>): AnyExpression;
+  none(predicate?: RelationPredicateInput<TContract, RelatedNsId, RelatedModelName>): AnyExpression;
+};
+type RelationAccessorMethodName = keyof RelationFilterAccessor<Contract<SqlStorage>, never, string> | 'count';
+type IsOrderable<Traits> = ['order'] extends [Traits] ? true : false;
+type OrderableFields<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string> = { [K in keyof FieldsOf<TContract, ModelName, NsId> & string as IsOrderable<FieldTraits<TContract, ModelName, K, NsId>> extends true ? K : never]: Orderable; };
+/** The fields of a model whose codec has the `order` trait. */
+type OrderableFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = keyof OrderableFields<TContract, ModelName, NsId> & string;
+/**
+ * A to-one relation inside `where`/`orderBy`: the relation filters plus each orderable scalar field of the related model. A related field named like a relation method is not exposed.
+ */
+type ToOneRelationAccessor<TContract extends Contract<SqlStorage>, RelatedNsId extends DomainNamespaceId<TContract>, RelatedModelName extends string> = RelationFilterAccessor<TContract, RelatedNsId, RelatedModelName> & Omit<OrderableFields<TContract, RelatedModelName, RelatedNsId>, RelationAccessorMethodName>;
+/**
+ * A to-many relation inside `where`/`orderBy`: the relation filters plus `count`, which orders by the number of related rows matching an optional predicate.
+ */
+type ToManyRelationAccessor<TContract extends Contract<SqlStorage>, RelatedNsId extends DomainNamespaceId<TContract>, RelatedModelName extends string> = RelationFilterAccessor<TContract, RelatedNsId, RelatedModelName> & {
+  count(predicate?: RelationPredicateInput<TContract, RelatedNsId, RelatedModelName>): Orderable;
 };
 type ScalarModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in keyof FieldsOf<TContract, ModelName, NsId> & string]: Expression<{
   codecId: FieldCodecId<TContract, ModelName, K, NsId>;
   nullable: FieldNullable<TContract, ModelName, K, NsId>;
-}> & ComparisonMethods<FieldJsType<TContract, ModelName, K, NsId>, FieldTraits<TContract, ModelName, K, NsId>> & FieldOperations<TContract, ModelName, K>; };
-type RelationModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string> = { [K in RelationNames<TContract, ModelName>]: RelationFilterAccessor<TContract, RelatedModelName<TContract, ModelName, K> & string>; };
-type ModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ScalarModelAccessor<TContract, ModelName, NsId> & RelationModelAccessor<TContract, ModelName>;
+}> & ComparisonMethods<FieldInputJsType<TContract, ModelName, K, NsId>, FieldTraits<TContract, ModelName, K, NsId>, FieldCodecId<TContract, ModelName, K, NsId>> & FieldOperations<TContract, NsId, ModelName, K>; };
+type RelationModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in RelationNames<TContract, ModelName, NsId>]: RelationCardinality<TContract, ModelName, K, NsId> extends '1:1' | 'N:1' ? ToOneRelationAccessor<TContract, RelationTargetNamespace<TContract, ModelName, K, NsId>, RelatedModelName<TContract, ModelName, K, NsId> & string> : ToManyRelationAccessor<TContract, RelationTargetNamespace<TContract, ModelName, K, NsId>, RelatedModelName<TContract, ModelName, K, NsId> & string>; };
+type ModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ScalarModelAccessor<TContract, ModelName, NsId> & RelationModelAccessor<TContract, ModelName, NsId>;
 /**
  * The predicate accessor for a collection narrowed to a variant. When a real
  * variant is selected its (possibly MTI) fields and relations are merged onto
- * the base accessor so `t.variant('Feature').where(x => x.priority…)` and
- * `t.variant('Feature').where(x => x.assignee.some(…))` type-check; with no
+ * the base accessor so `t.variant('feature').where(x => x.priority…)` and
+ * `t.variant('feature').where(x => x.assignee.some(…))` type-check; with no
  * variant the accessor is the plain base `ModelAccessor` and is unchanged.
  */
-type VariantAwareModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName extends string | undefined, NsId extends string = never> = [VariantName] extends [string] ? VariantName extends VariantNames<TContract, ModelName, NsId> ? ScalarModelAccessor<TContract, ModelName, NsId> & ScalarModelAccessor<TContract, VariantName, NsId> & RelationModelAccessor<TContract, ModelName> & RelationModelAccessor<TContract, VariantName> : ModelAccessor<TContract, ModelName, NsId> : ModelAccessor<TContract, ModelName, NsId>;
+type VariantAwareModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue extends string | undefined, NsId extends string = never> = [VariantValue] extends [string] ? VariantValue extends DiscriminatorValues<TContract, ModelName, NsId> ? ScalarModelAccessor<TContract, ModelName, NsId> & ScalarModelAccessor<TContract, VariantModelName<TContract, ModelName, VariantValue, NsId>, VariantModelNamespace<TContract, ModelName, VariantValue, NsId>> & RelationModelAccessor<TContract, ModelName, NsId> & RelationModelAccessor<TContract, VariantModelName<TContract, ModelName, VariantValue, NsId>, VariantModelNamespace<TContract, ModelName, VariantValue, NsId>> : ModelAccessor<TContract, ModelName, NsId> : ModelAccessor<TContract, ModelName, NsId>;
+/** A condition from `fns`. */
+type FunctionCondition = Expression<BooleanCodecType>;
+/** A condition: an ORM filter expression, or a condition from `fns`. */
+type Condition = AnyExpression | FunctionCondition;
+/** What a `where` callback may return: a filter, or a condition from `fns`. */
+type WhereCallbackResult = WhereArg | FunctionCondition;
+type IsBooleanCodec<CodecId, TCodecTypes extends Record<string, unknown>> = CodecId extends keyof TCodecTypes ? TCodecTypes[CodecId] extends {
+  readonly traits: infer Traits;
+} ? 'boolean' extends Traits ? true : false : false : false;
+/** A function's result in the ORM: a value, as opposed to a condition, also has `asc()` and `desc()`. */
+type OrmFunctionResult<R, TCodecTypes extends Record<string, unknown>> = R extends Expression<infer Field> ? IsBooleanCodec<Field['codecId'], TCodecTypes> extends true ? R : R & Orderable : R;
+type SameSignature<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+/**
+ * An operation's implementation with each result as {@link OrmFunctionResult}. Matching four call signatures reads the last four overloads, and TypeScript repeats the signatures of an implementation with fewer; a single signature stays one. An implementation with five or more overloads loses all but its last four, and a generic signature keeps its parameters at their constraints.
+ */
+type OrmOperation<Impl, CT extends Record<string, unknown>> = Impl extends {
+  (...args: infer A1): infer R1;
+  (...args: infer A2): infer R2;
+  (...args: infer A3): infer R3;
+  (...args: infer A4): infer R4;
+} ? SameSignature<[A1, R1] | [A2, R2] | [A3, R3], [A4, R4]> extends true ? (...args: A4) => OrmFunctionResult<R4, CT> : {
+  (...args: A1): OrmFunctionResult<R1, CT>;
+  (...args: A2): OrmFunctionResult<R2, CT>;
+  (...args: A3): OrmFunctionResult<R3, CT>;
+  (...args: A4): OrmFunctionResult<R4, CT>;
+} : Impl;
+/** `fns.raw` in the ORM: its result also has `asc()` and `desc()`. */
+interface OrmRawSqlBuilder {
+  returns<S extends string>(spec: S): Expression<{
+    codecId: S;
+    nullable: false;
+  }> & Orderable;
+  returns<S extends string, N extends boolean = false>(spec: {
+    readonly codecId: S;
+    readonly nullable?: N;
+  }): Expression<{
+    codecId: S;
+    nullable: N;
+  }> & Orderable;
+}
+type OrmRawSqlTag = (strings: TemplateStringsArray, ...values: RawSqlInterpolation[]) => OrmRawSqlBuilder;
+/** `fns.and` and `fns.or` in the ORM: they also take ORM conditions, such as `p.title.ilike(...)`. */
+type OrmLogicalFunction<CT extends Record<string, {
+  readonly input: unknown;
+}>> = (...conditions: (AnyExpression | CodecExpression<'pg/bool@1', boolean, CT>)[]) => FunctionCondition;
+/** The SQL query builder's functions over the given codec types and query operations, as the ORM's callbacks receive them. */
+type OrmFunctionsOf<CT extends Record<string, {
+  readonly input: unknown;
+}>, OT extends QueryOperationTypesBase> = Omit<BuiltinFunctions<CT>, 'raw' | 'and' | 'or'> & {
+  readonly raw: OrmRawSqlTag;
+  readonly and: OrmLogicalFunction<CT>;
+  readonly or: OrmLogicalFunction<CT>;
+} & { readonly [K in keyof OT]: OrmOperation<OT[K]['impl'], CT>; };
+/** The SQL query builder's functions for a contract, as the ORM's callbacks receive them. */
+type OrmFunctions<TContract extends Contract<SqlStorage>> = OrmFunctionsOf<ExtractCodecTypes<TContract>, ExtractQueryOperationTypes<TContract>>;
+/** The indexes of the table a model is stored in, keyed by the name the contract source gave each. */
+type ModelIndexReferences<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = string extends NsId ? Readonly<Record<string, IndexReference>> : TableIndexReferences<NamespaceTableDef<TContract, ModelTableName<TContract, ModelName, NsId> & string, ResolvedNsId<TContract, ModelName, NsId>>>;
+/** One model as a collection method contribution reads it: the contract's target, the model's fields and relations, and its storage table. */
+type CollectionMethodModelTypeOf<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string> = {
+  readonly target: TContract['target'];
+  readonly name: ModelName;
+  readonly fields: FieldsOf<TContract, ModelName, NsId>;
+  readonly relations: ModelDef<TContract, ModelName, NsId> extends {
+    readonly relations: infer Relations extends object;
+  } ? Relations : Record<string, never>;
+  readonly table: NamespaceTableDef<TContract, ModelTableName<TContract, ModelName, NsId> & string, ResolvedNsId<TContract, ModelName, NsId>>;
+};
+/** The second argument of a `where` or `orderBy` callback: the SQL query builder's functions, and the model's indexes. */
+interface ModelCallbackTools<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> {
+  readonly fns: OrmFunctions<TContract>;
+  readonly indexes: ModelIndexReferences<TContract, ModelName, NsId>;
+}
 /**
  * The flat default row of a single model: its own declared fields mapped to
  * their JS types, with no variant flattening. Use this when you want exactly
@@ -283,6 +515,10 @@ type VariantAwareModelAccessor<TContract extends Contract<SqlStorage>, ModelName
  * re-expressed in terms of `InferRootRow`.
  */
 type DefaultModelRow<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in keyof FieldsOf<TContract, ModelName, NsId> & string]: FieldJsType<TContract, ModelName, K, NsId>; };
+/**
+ * The values a filter, `create` or `update` accepts for each of a model's own fields. A field whose read type is refined by its type parameters, such as `Char<36>`, accepts its codec's input type, such as `string`.
+ */
+type DefaultModelInputRow<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in keyof FieldsOf<TContract, ModelName, NsId> & string]: FieldInputJsType<TContract, ModelName, K, NsId>; };
 type Simplify<T> = { [K in keyof T]: T[K]; } & {};
 type VariantRow<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
   readonly discriminator: {
@@ -290,20 +526,30 @@ type VariantRow<TContract extends Contract<SqlStorage>, ModelName extends string
   };
   readonly variants: infer V;
 } ? V extends Record<string, {
-  readonly value: string;
-}> ? { [VK in keyof V]: VK extends string & CollectionModelName<TContract> ? Simplify<Omit<DefaultModelRow<TContract, ModelName, NsId>, DiscField> & DefaultModelRow<TContract, VK, NsId> & Record<DiscField, V[VK]['value']>> : never; }[keyof V] : DefaultModelRow<TContract, ModelName, NsId> : DefaultModelRow<TContract, ModelName, NsId>;
+  readonly model: string;
+}> ? { [Value in keyof V & string]: V[Value]['model'] extends (infer VK extends string & CollectionModelName<TContract>) ? Simplify<Omit<DefaultModelRow<TContract, ModelName, NsId>, DiscField> & DefaultModelRow<TContract, VK, VariantModelNamespace<TContract, ModelName, Value, NsId>> & Record<DiscField, Value>> : never; }[keyof V & string] : DefaultModelRow<TContract, ModelName, NsId> : DefaultModelRow<TContract, ModelName, NsId>;
 type InferRootRow<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = VariantRow<TContract, ModelName, NsId>;
-type VariantNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+type DiscriminatorValues<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
   readonly variants: infer V extends Record<string, unknown>;
 } ? keyof V & string : never;
-type VariantModelRow<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+type VariantModelName<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
+  readonly variants: infer V;
+} ? VariantValue extends keyof V ? V[VariantValue] extends {
+  readonly model: infer Model extends string;
+} ? Model : never : never : never;
+type VariantModelNamespace<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue, NsId extends string = never> = [NsId] extends [never] ? never : ModelDef<TContract, ModelName, NsId> extends {
+  readonly variants: infer V;
+} ? VariantValue extends keyof V ? V[VariantValue] extends {
+  readonly namespace: infer Namespace extends string;
+} ? ContractNamespaceKey<TContract, Namespace> : never : never : never;
+type VariantModelRow<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
   readonly discriminator: {
     readonly field: infer DiscField extends string;
   };
   readonly variants: infer V;
 } ? V extends Record<string, {
-  readonly value: string;
-}> ? VariantName extends keyof V & string & CollectionModelName<TContract> ? Simplify<Omit<DefaultModelRow<TContract, ModelName, NsId>, DiscField> & DefaultModelRow<TContract, VariantName, NsId> & Record<DiscField, V[VariantName]['value']>> : DefaultModelRow<TContract, ModelName, NsId> : DefaultModelRow<TContract, ModelName, NsId> : DefaultModelRow<TContract, ModelName, NsId>;
+  readonly model: string;
+}> ? VariantValue extends keyof V ? V[VariantValue]['model'] extends (infer VK extends string & CollectionModelName<TContract>) ? Simplify<Omit<DefaultModelRow<TContract, ModelName, NsId>, DiscField> & DefaultModelRow<TContract, VK, VariantModelNamespace<TContract, ModelName, VariantValue, NsId>> & Record<DiscField, VariantValue>> : DefaultModelRow<TContract, ModelName, NsId> : DefaultModelRow<TContract, ModelName, NsId> : DefaultModelRow<TContract, ModelName, NsId> : DefaultModelRow<TContract, ModelName, NsId>;
 /**
  * The value an aggregate hands the application, read from the contract's emitted aggregate map.
  *
@@ -430,22 +676,24 @@ type IncludeReducerMethod<TContract extends Contract<SqlStorage>, ModelName exte
  * index signature off the collection surface.
  */
 type AggregateIncludeReducers<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = string extends AggregateOperationNames<TContract> ? AggregateOperationsUnavailable : { readonly [Op in AggregateOperationNames<TContract>]: IncludeReducerMethod<TContract, ModelName, Op, NsId>; };
-type HavingComparisonMethods<T> = Pick<ComparisonMethods<T, 'equality' | 'order'>, 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte'>;
+type HavingComparisonMethods<T, CodecId extends string = never> = Pick<ComparisonMethods<T, 'equality' | 'order', CodecId>, 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte'>;
 /**
- * The value a HAVING comparison accepts. The comparison happens inside the
- * database, where the operand is an inlined numeric literal — so the
- * comparand stays `number` regardless of the result's application
- * representation. A field-taking metric compares as `number | null` — a
+ * Literal HAVING comparands stay `number` regardless of the result's application
+ * representation; prepared comparands carry the declared aggregate output codec.
+ * A field-taking metric compares as `number | null` — a
  * grouped value's SQL domain includes NULL; a no-input metric reads
  * nullability off its declared row, so `count()` compares as plain `number`.
  */
 type HavingZeroArgComparand<Row> = Row extends {
   readonly nullable: infer Nullable extends boolean;
 } ? Nullable extends true ? number | null : number : never;
-type FieldHavingCall<TContract extends Contract<SqlStorage>, ModelName extends string, Op extends string, NsId extends string> = <FieldName extends AggregateFieldNames<TContract, ModelName, Op, NsId>>(field: FieldName) => HavingComparisonMethods<number | null>;
+type AggregateOutputCodecId<Row> = Row extends {
+  readonly output: infer Id extends string;
+} ? Id : never;
+type FieldHavingCall<TContract extends Contract<SqlStorage>, ModelName extends string, Op extends string, NsId extends string> = <FieldName extends AggregateFieldNames<TContract, ModelName, Op, NsId>>(field: FieldName) => HavingComparisonMethods<number | null, AggregateOutputCodecId<AggregateRowFor<TContract, Op, FieldCodecId<TContract, ModelName, FieldName, NsId>>>>;
 type HavingMethod<TContract extends Contract<SqlStorage>, ModelName extends string, Op extends string, NsId extends string> = HasZeroArgCall<TContract, Op> extends true ? {
-  (): HavingComparisonMethods<HavingZeroArgComparand<AggregateRowFor<TContract, Op, never>>>;
-  <FieldName extends AggregateFieldNames<TContract, ModelName, Op, NsId>>(field: FieldName): HavingComparisonMethods<number | null>;
+  (): HavingComparisonMethods<HavingZeroArgComparand<AggregateRowFor<TContract, Op, never>>, AggregateOutputCodecId<AggregateRowFor<TContract, Op, never>>>;
+  <FieldName extends AggregateFieldNames<TContract, ModelName, Op, NsId>>(field: FieldName): HavingComparisonMethods<number | null, AggregateOutputCodecId<AggregateRowFor<TContract, Op, FieldCodecId<TContract, ModelName, FieldName, NsId>>>>;
 } : FieldHavingCall<TContract, ModelName, Op, NsId>;
 /**
  * The metric surface `groupBy().having()` hands its callback, derived from
@@ -458,7 +706,11 @@ type HavingMethod<TContract extends Contract<SqlStorage>, ModelName extends stri
  * methods.
  */
 type HavingBuilder<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = string extends AggregateOperationNames<TContract> ? AggregateOperationsUnavailable : { readonly [Op in AggregateOperationNames<TContract> & AggregateFn]: HavingMethod<TContract, ModelName, Op, NsId>; };
-type ShorthandWhereFilter<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Partial<{ [K in keyof DefaultModelRow<TContract, ModelName, NsId> & string]: DefaultModelRow<TContract, ModelName, NsId>[K] | null | undefined; }>;
+type ShorthandWhereFilter<TContract extends Contract<SqlStorage>, NsId extends DomainNamespaceId<TContract>, ModelName extends string> = Partial<{ [K in keyof DefaultModelInputRow<TContract, ModelName, NsId> & string]: DefaultModelInputRow<TContract, ModelName, NsId>[K] | ('equality' extends FieldTraits<TContract, ModelName, K, NsId> ? Expression<{
+  codecId: FieldCodecId<TContract, ModelName, K, NsId>;
+  nullable: boolean;
+  many?: never;
+}> : never) | null | undefined; }>;
 type NamespaceModelsOf<TContract extends Contract<SqlStorage>, NsId extends string> = NsId extends keyof TContract['domain']['namespaces'] ? TContract['domain']['namespaces'][NsId]['models'] extends (infer M extends Record<string, unknown>) ? M : Record<string, never> : Record<string, never>;
 type ScannedModelDef<TContract extends Contract<SqlStorage>, ModelName extends string> = { [Ns in keyof TContract['domain']['namespaces']]: ModelName extends keyof TContract['domain']['namespaces'][Ns]['models'] ? TContract['domain']['namespaces'][Ns]['models'][ModelName] : never; }[keyof TContract['domain']['namespaces']];
 type ModelDef<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = [NsId] extends [never] ? ScannedModelDef<TContract, ModelName> : ModelName extends keyof NamespaceModelsOf<TContract, NsId> ? NamespaceModelsOf<TContract, NsId>[ModelName] : never;
@@ -511,6 +763,8 @@ type ResolvedStorageColumn<TContract extends Contract<SqlStorage>, ModelName ext
 type FieldStorageJsType<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = ResolvedStorageColumn<TContract, ModelName, FieldName, NsId> extends (infer Col extends StorageColumn) ? Col extends StorageColumn ? ComputeColumnJsType<TContract, ResolvedNsId<TContract, ModelName, NsId>, ModelTableName<TContract, ModelName, NsId> & string, FieldColumnName<TContract, ModelName, FieldName, NsId> & string, ExtractCodecTypes<TContract>> : never : never;
 type NamespaceFieldOutputType<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = ResolvedNsId<TContract, ModelName, NsId> extends (infer Ns extends string) ? ExtractFieldOutputTypes<TContract> extends (infer Outputs) ? Ns extends keyof Outputs ? Outputs[Ns] extends (infer NamespaceOutputs) ? ModelName extends keyof NamespaceOutputs ? NamespaceOutputs[ModelName] extends (infer ModelOutputs) ? FieldName extends keyof ModelOutputs ? ModelOutputs[FieldName] : never : never : never : never : never : never : never;
 type FieldJsType<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = [NamespaceFieldOutputType<TContract, ModelName, FieldName, NsId>] extends [never] ? [FieldStorageJsType<TContract, ModelName, FieldName, NsId>] extends [never] ? unknown : FieldStorageJsType<TContract, ModelName, FieldName, NsId> : NamespaceFieldOutputType<TContract, ModelName, FieldName, NsId>;
+type NamespaceFieldInputType<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = ResolvedNsId<TContract, ModelName, NsId> extends (infer Ns extends string) ? ExtractFieldInputTypes<TContract> extends (infer Inputs) ? Ns extends keyof Inputs ? Inputs[Ns] extends (infer NamespaceInputs) ? ModelName extends keyof NamespaceInputs ? NamespaceInputs[ModelName] extends (infer ModelInputs) ? FieldName extends keyof ModelInputs ? ModelInputs[FieldName] : never : never : never : never : never : never : never;
+type FieldInputJsType<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = [NamespaceFieldInputType<TContract, ModelName, FieldName, NsId>] extends [never] ? FieldJsType<TContract, ModelName, FieldName, NsId> : NamespaceFieldInputType<TContract, ModelName, FieldName, NsId>;
 type FieldStorageColumn<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = ResolvedStorageColumn<TContract, ModelName, FieldName, NsId>;
 type FieldCodecId<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = FieldStorageColumn<TContract, ModelName, FieldName, NsId> extends {
   readonly codecId: infer Id extends string;
@@ -522,27 +776,13 @@ type FieldTraits<TContract extends Contract<SqlStorage>, ModelName extends strin
   readonly traits: infer T;
 } ? T : never : never : never;
 type NumericFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in keyof DefaultModelRow<TContract, ModelName, NsId> & string]: 'numeric' extends FieldTraits<TContract, ModelName, K, NsId> ? K : never; }[keyof DefaultModelRow<TContract, ModelName, NsId> & string];
-type ExecutionDefaultEntry<TContract extends Contract<SqlStorage>> = TContract['execution'] extends {
-  readonly mutations: {
-    readonly defaults: infer Defaults;
-  };
-} ? Defaults extends ReadonlyArray<unknown> ? Defaults[number] : never : never;
-type HasExecutionCreateDefault<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = [Extract<ExecutionDefaultEntry<TContract>, {
-  readonly ref: {
-    readonly table: ModelTableName<TContract, ModelName, NsId>;
-    readonly column: FieldColumnName<TContract, ModelName, FieldName, NsId>;
-  } & ([NsId] extends [never] ? unknown : {
-    readonly namespace: NsId;
-  });
-  readonly onCreate?: unknown;
-}>] extends [never] ? false : true;
-type IsOptionalCreateField<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = FieldStorageColumn<TContract, ModelName, FieldName, NsId> extends (infer Column) ? Column extends StorageColumn ? Column['nullable'] extends true ? true : Column extends {
-  readonly default: unknown;
-} ? true : HasExecutionCreateDefault<TContract, ModelName, FieldName, NsId> : HasExecutionCreateDefault<TContract, ModelName, FieldName, NsId> : HasExecutionCreateDefault<TContract, ModelName, FieldName, NsId>;
+type FieldHasExecutionCreateDefault<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = HasExecutionCreateDefault<TContract, ResolvedNsId<TContract, ModelName, NsId>, ModelTableName<TContract, ModelName, NsId>, FieldColumnName<TContract, ModelName, FieldName, NsId>>;
+type IsOptionalCreateField<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string, NsId extends string = never> = FieldStorageColumn<TContract, ModelName, FieldName, NsId> extends (infer Column) ? Column extends StorageColumn ? IsOptionalCreateColumn<TContract, Column, ResolvedNsId<TContract, ModelName, NsId>, ModelTableName<TContract, ModelName, NsId>, FieldColumnName<TContract, ModelName, FieldName, NsId>> : FieldHasExecutionCreateDefault<TContract, ModelName, FieldName, NsId> : FieldHasExecutionCreateDefault<TContract, ModelName, FieldName, NsId>;
 type CreateFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = keyof DefaultModelRow<TContract, ModelName, NsId> & string;
 type RequiredCreateFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in CreateFieldNames<TContract, ModelName, NsId>]-?: IsOptionalCreateField<TContract, ModelName, K, NsId> extends true ? never : K; }[CreateFieldNames<TContract, ModelName, NsId>];
 type OptionalCreateFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in CreateFieldNames<TContract, ModelName, NsId>]-?: IsOptionalCreateField<TContract, ModelName, K, NsId> extends true ? K : never; }[CreateFieldNames<TContract, ModelName, NsId>];
-type CreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Pick<DefaultModelRow<TContract, ModelName, NsId>, RequiredCreateFieldNames<TContract, ModelName, NsId>> & Partial<Pick<DefaultModelRow<TContract, ModelName, NsId>, OptionalCreateFieldNames<TContract, ModelName, NsId>>> & RelationMutationFields<TContract, ModelName, 'create'>;
+type RowCreateFields<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Pick<DefaultModelInputRow<TContract, ModelName, NsId>, RequiredCreateFieldNames<TContract, ModelName, NsId>> & Partial<Pick<DefaultModelInputRow<TContract, ModelName, NsId>, OptionalCreateFieldNames<TContract, ModelName, NsId>>>;
+type CreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = RowCreateFields<TContract, ModelName, NsId> & RelationMutationFields<TContract, ModelName, 'create'>;
 type IsPolymorphicBase<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
   readonly discriminator: unknown;
   readonly variants: Record<string, unknown>;
@@ -552,8 +792,15 @@ type DiscriminatorFieldName<TContract extends Contract<SqlStorage>, ModelName ex
     readonly field: infer F extends string;
   };
 } ? F : never;
-type VariantCreateInput<TContract extends Contract<SqlStorage>, BaseModelName extends string, VariantName extends string, NsId extends string = never> = Omit<CreateInput<TContract, BaseModelName, NsId>, DiscriminatorFieldName<TContract, BaseModelName, NsId>> & CreateInput<TContract, VariantName, NsId>;
-type ResolvedCreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, VName extends string | undefined, NsId extends string = never> = IsPolymorphicBase<TContract, ModelName, NsId> extends true ? VName extends string ? VariantCreateInput<TContract, ModelName, VName, NsId> : never : CreateInput<TContract, ModelName, NsId>;
+type VariantCreateInput<TContract extends Contract<SqlStorage>, BaseModelName extends string, VariantValue extends string, NsId extends string = never> = VariantValue extends string ? Omit<CreateInput<TContract, BaseModelName, NsId>, DiscriminatorFieldName<TContract, BaseModelName, NsId>> & CreateInput<TContract, VariantModelName<TContract, BaseModelName, VariantValue, NsId>, VariantModelNamespace<TContract, BaseModelName, VariantValue, NsId>> : never;
+/**
+ * An input with no keys is `Record<string, never>`, not `{}`: TypeScript accepts any object where `{}` is expected, so a model with no fields would accept any key.
+ */
+type ClosedWhenEmpty<T> = [keyof T] extends [never] ? Record<string, never> : T;
+/** The scalar fields an update of the model takes. For a model with no fields, it rejects every key. */
+type ScalarUpdateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ClosedWhenEmpty<Partial<DefaultModelInputRow<TContract, ModelName, NsId>>>;
+type ResolvedCreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue extends string | undefined, NsId extends string = never> = ClosedWhenEmpty<IsPolymorphicBase<TContract, ModelName, NsId> extends true ? VariantValue extends string ? VariantCreateInput<TContract, ModelName, VariantValue, NsId> : never : CreateInput<TContract, ModelName, NsId>>;
+type ResolvedScalarCreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue extends string | undefined, NsId extends string = never> = ClosedWhenEmpty<IsPolymorphicBase<TContract, ModelName, NsId> extends true ? VariantValue extends string ? Omit<RowCreateFields<TContract, ModelName, NsId>, DiscriminatorFieldName<TContract, ModelName, NsId>> & RowCreateFields<TContract, VariantModelName<TContract, ModelName, VariantValue, NsId>, VariantModelNamespace<TContract, ModelName, VariantValue, NsId>> : never : RowCreateFields<TContract, ModelName, NsId>>;
 type ModelStorageTableDef<TContract extends Contract<SqlStorage>, ModelName extends string> = ModelTableName<TContract, ModelName> extends (infer TableName extends string) ? NamespaceTableDef<TContract, TableName> : never;
 type PrimaryKeyConstraintColumns<TContract extends Contract<SqlStorage>, ModelName extends string> = ModelStorageTableDef<TContract, ModelName> extends {
   readonly primaryKey: {
@@ -566,8 +813,8 @@ type UniqueConstraintColumns<TContract extends Contract<SqlStorage>, ModelName e
   readonly columns: infer Columns extends readonly string[];
 } ? Columns : never : never : never;
 type FieldNameForColumn<TContract extends Contract<SqlStorage>, ModelName extends string, ColumnName extends string> = { [K in keyof DefaultModelRow<TContract, ModelName> & string]: FieldColumnName<TContract, ModelName, K> extends ColumnName ? K : never; }[keyof DefaultModelRow<TContract, ModelName> & string] extends (infer Matched) ? Matched extends string ? Matched : ColumnName : ColumnName;
-type RowValueForField<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string> = FieldName extends keyof DefaultModelRow<TContract, ModelName> ? DefaultModelRow<TContract, ModelName>[FieldName] : unknown;
-type CriterionFromConstraintColumns<TContract extends Contract<SqlStorage>, ModelName extends string, Columns extends readonly string[]> = string extends Columns[number] ? Record<string, unknown> : { [C in Columns[number] as FieldNameForColumn<TContract, ModelName, C>]: RowValueForField<TContract, ModelName, FieldNameForColumn<TContract, ModelName, C>>; };
+type RowValueForField<TContract extends Contract<SqlStorage>, ModelName extends string, FieldName extends string> = FieldName extends keyof DefaultModelInputRow<TContract, ModelName> ? DefaultModelInputRow<TContract, ModelName>[FieldName] : unknown;
+type CriterionFromConstraintColumns<TContract extends Contract<SqlStorage>, ModelName extends string, Columns extends readonly string[]> = string extends Columns[number] ? Record<string, unknown> : { [C in Columns[number] as FieldNameForColumn<TContract, ModelName, C>]: Exclude<RowValueForField<TContract, ModelName, FieldNameForColumn<TContract, ModelName, C>>, null>; };
 type ConstraintColumnsUnion<TContract extends Contract<SqlStorage>, ModelName extends string> = PrimaryKeyConstraintColumns<TContract, ModelName> | UniqueConstraintColumns<TContract, ModelName>;
 type UniqueConstraintCriterion<TContract extends Contract<SqlStorage>, ModelName extends string> = ConstraintColumnsUnion<TContract, ModelName> extends (infer Columns) ? Columns extends readonly string[] ? CriterionFromConstraintColumns<TContract, ModelName, Columns> : never : never;
 type RelationConnectCriterion<TContract extends Contract<SqlStorage>, ModelName extends string> = [UniqueConstraintCriterion<TContract, ModelName>] extends [never] ? Record<string, unknown> : UniqueConstraintCriterion<TContract, ModelName>;
@@ -658,55 +905,43 @@ type ChildForeignKeyFieldNames<TContract extends Contract<SqlStorage>, ModelName
 } ? Fields[number] : never : never;
 type NestedOptionalCreateFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = OptionalCreateFieldNames<TContract, ModelName, NsId> | Extract<ChildForeignKeyFieldNames<TContract, ModelName>, CreateFieldNames<TContract, ModelName, NsId>>;
 type NestedRequiredCreateFieldNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Exclude<CreateFieldNames<TContract, ModelName, NsId>, NestedOptionalCreateFieldNames<TContract, ModelName, NsId>>;
-type NestedCreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Pick<DefaultModelRow<TContract, ModelName, NsId>, NestedRequiredCreateFieldNames<TContract, ModelName, NsId>> & Partial<Pick<DefaultModelRow<TContract, ModelName, NsId>, NestedOptionalCreateFieldNames<TContract, ModelName, NsId>>>;
+type NestedCreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Pick<DefaultModelInputRow<TContract, ModelName, NsId>, NestedRequiredCreateFieldNames<TContract, ModelName, NsId>> & Partial<Pick<DefaultModelInputRow<TContract, ModelName, NsId>, NestedOptionalCreateFieldNames<TContract, ModelName, NsId>>>;
 type AtLeastOne<T> = keyof T extends never ? never : { [K in keyof T]-?: Pick<T, K> & Partial<Omit<T, K>>; }[keyof T];
 type MutationCreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = NestedCreateInput<TContract, ModelName, NsId> & RelationMutationFields<TContract, ModelName, 'create'>;
 type MutationCreateInputWithRelations<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = NestedCreateInput<TContract, ModelName, NsId> & AtLeastOne<RelationMutationFields<TContract, ModelName, 'create'>>;
-type MutationUpdateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = Partial<DefaultModelRow<TContract, ModelName, NsId>> & RelationMutationFields<TContract, ModelName, 'update'>;
+type MutationUpdateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ClosedWhenEmpty<Partial<DefaultModelInputRow<TContract, ModelName, NsId>> & RelationMutationFields<TContract, ModelName, 'update'>>;
 type ModelRelations<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ModelDef<TContract, ModelName, NsId> extends {
   readonly relations: infer R;
 } ? R extends Record<string, unknown> ? R : Record<string, never> : Record<string, never>;
 type ExactRecord<T> = T extends Record<string, unknown> ? string extends keyof T ? Record<string, never> : T : Record<string, never>;
 type RelationsOf<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ExactRecord<ModelRelations<TContract, ModelName, NsId>>;
 type RelationNames<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = (string extends keyof RelationsOf<TContract, ModelName, NsId> ? never : { [K in keyof RelationsOf<TContract, ModelName, NsId>]: RelationsOf<TContract, ModelName, NsId>[K] extends never ? never : K; }[keyof RelationsOf<TContract, ModelName, NsId>]) & string;
-type IsUnion<T, Whole = T> = T extends Whole ? ([Whole] extends [T] ? false : true) : never;
-type IsSingletonString<T> = [T] extends [string] ? string extends T ? false : IsUnion<T> extends true ? false : true : false;
-type SelectedVariantNames<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName, NsId extends string> = [VariantName] extends [string] ? string extends VariantName ? VariantNames<TContract, ModelName, NsId> : VariantName : never;
-type VariantDeclaredRelationKeys<TContract extends Contract<SqlStorage>, VariantName extends string, NsId extends string> = VariantName extends string ? keyof RelationsOf<TContract, VariantName, NsId> : never;
-type SelectedVariantDeclaredRelationKeys<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName, NsId extends string> = VariantDeclaredRelationKeys<TContract, SelectedVariantNames<TContract, ModelName, VariantName, NsId>, NsId>;
-type VariantAwareIncludeRelationNames<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName, NsId extends string = never> = IsSingletonString<VariantName> extends true ? RelationNames<TContract, Extract<VariantName, string>, NsId> | Exclude<RelationNames<TContract, ModelName, NsId>, keyof RelationsOf<TContract, Extract<VariantName, string>, NsId>> : [VariantName] extends [string] ? Exclude<RelationNames<TContract, ModelName, NsId>, SelectedVariantDeclaredRelationKeys<TContract, ModelName, VariantName, NsId>> : RelationNames<TContract, ModelName, NsId>;
-type IncludeRelationOwner<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName, RelName extends string, NsId extends string = never> = IsSingletonString<VariantName> extends true ? RelName extends keyof RelationsOf<TContract, Extract<VariantName, string>, NsId> ? Extract<VariantName, string> : ModelName : ModelName;
+type IsUnion$1<T, Whole = T> = T extends Whole ? ([Whole] extends [T] ? false : true) : never;
+type IsSingletonString<T> = [T] extends [string] ? string extends T ? false : IsUnion$1<T> extends true ? false : true : false;
+type VariantDeclaredRelationKeys<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue, NsId extends string> = VariantValue extends string ? keyof RelationsOf<TContract, VariantModelName<TContract, ModelName, VariantValue, NsId>, VariantModelNamespace<TContract, ModelName, VariantValue, NsId>> : never;
+type SelectedVariantDeclaredRelationKeys<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue, NsId extends string> = VariantDeclaredRelationKeys<TContract, ModelName, string extends VariantValue ? DiscriminatorValues<TContract, ModelName, NsId> : VariantValue, NsId>;
+type VariantAwareIncludeRelationNames<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue, NsId extends string = never> = IsSingletonString<VariantValue> extends true ? RelationNames<TContract, VariantModelName<TContract, ModelName, VariantValue, NsId>, VariantModelNamespace<TContract, ModelName, VariantValue, NsId>> | Exclude<RelationNames<TContract, ModelName, NsId>, keyof RelationsOf<TContract, VariantModelName<TContract, ModelName, VariantValue, NsId>, VariantModelNamespace<TContract, ModelName, VariantValue, NsId>>> : [VariantValue] extends [string] ? Exclude<RelationNames<TContract, ModelName, NsId>, SelectedVariantDeclaredRelationKeys<TContract, ModelName, VariantValue, NsId>> : RelationNames<TContract, ModelName, NsId>;
+type IncludeRelationOwner<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue, RelName extends string, NsId extends string = never> = IsSingletonString<VariantValue> extends true ? RelName extends keyof RelationsOf<TContract, VariantModelName<TContract, ModelName, VariantValue, NsId>, VariantModelNamespace<TContract, ModelName, VariantValue, NsId>> ? VariantModelName<TContract, ModelName, VariantValue, NsId> : ModelName : ModelName;
+type IncludeRelationOwnerNamespace<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue, RelName extends string, NsId extends string = never> = IsSingletonString<VariantValue> extends true ? RelName extends keyof RelationsOf<TContract, VariantModelName<TContract, ModelName, VariantValue, NsId>, VariantModelNamespace<TContract, ModelName, VariantValue, NsId>> ? VariantModelNamespace<TContract, ModelName, VariantValue, NsId> : NsId : NsId;
 type RelationModelName<Relation> = Relation extends {
   readonly to: {
     readonly model: infer To extends string;
   };
 } ? To : never;
 type RelatedModelName<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = RelationsOf<TContract, ModelName, NsId> extends (infer Rels) ? Rels extends Record<string, unknown> ? RelName extends keyof Rels ? RelationModelName<Rels[RelName]> : never : never : never;
+type ContractNamespaceKey<TContract extends Contract<SqlStorage>, NsId extends string> = { [K in keyof TContract['domain']['namespaces'] & string]: NsId extends K ? K : never; }[keyof TContract['domain']['namespaces'] & string];
 type RelationTargetNamespace<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = [NsId] extends [never] ? never : RelationsOf<TContract, ModelName, NsId> extends (infer Rels) ? Rels extends Record<string, unknown> ? RelName extends keyof Rels ? Rels[RelName] extends {
   readonly to: {
     readonly namespace: infer N extends string;
   };
-} ? N : never : never : never : never;
+} ? ContractNamespaceKey<TContract, N> : never : never : never : never;
 type RelationCardinalityFromRelation<Relation> = Relation extends {
   readonly cardinality: infer Cardinality extends RelationCardinalityTag;
 } ? Cardinality : '1:N';
 type RelationCardinality<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = RelationsOf<TContract, ModelName, NsId> extends (infer Rels) ? Rels extends Record<string, unknown> ? RelName extends keyof Rels ? RelationCardinalityFromRelation<Rels[RelName]> : '1:N' : '1:N' : '1:N';
-type RelationLocalFieldColumns<TContract extends Contract<SqlStorage>, ModelName extends string, Relation> = Relation extends {
-  readonly on: {
-    readonly localFields: infer Fields extends readonly string[];
-  };
-} ? MapFieldsToColumns<TContract, ModelName, Fields> : readonly [];
-type MapFieldsToColumns<TContract extends Contract<SqlStorage>, ModelName extends string, Fields extends readonly string[]> = Fields extends readonly [infer Head extends string, ...infer Tail extends string[]] ? readonly [FieldColumnName<TContract, ModelName, Head>, ...MapFieldsToColumns<TContract, ModelName, Tail>] : readonly [];
-type AnyColumnNullable<Columns extends Record<string, StorageColumn>, ColNames extends readonly string[]> = ColNames extends readonly [infer Head extends string, ...infer Tail extends string[]] ? Head extends keyof Columns ? Columns[Head]['nullable'] extends true ? true : AnyColumnNullable<Columns, Tail> : true : false;
-type HasForeignKeyForCols<FKs extends readonly unknown[], Cols extends readonly string[]> = FKs extends readonly [infer Head, ...infer Tail extends unknown[]] ? Head extends {
-  readonly source: {
-    readonly columns: Cols;
-  };
-} ? true : HasForeignKeyForCols<Tail, Cols> : false;
-type IsFkSideOfRelation<Table extends StorageTable, ParentCols extends readonly string[]> = Table extends {
-  readonly foreignKeys: infer FKs extends readonly unknown[];
-} ? HasForeignKeyForCols<FKs, ParentCols> : false;
-type IsToOneRelationNullable<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = ModelTableName<TContract, ModelName, NsId> extends (infer TableName extends string) ? NamespaceTableDef<TContract, TableName, ResolvedNsId<TContract, ModelName, NsId>> extends (infer Table extends StorageTable) ? RelationsOf<TContract, ModelName, NsId> extends (infer Rels extends Record<string, unknown>) ? RelName extends keyof Rels ? RelationLocalFieldColumns<TContract, ModelName, Rels[RelName]> extends (infer Cols extends readonly string[]) ? IsFkSideOfRelation<Table, Cols> extends true ? AnyColumnNullable<Table['columns'], Cols> : true : true : true : true : true : true;
+type IsToOneRelationNullable<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = RelationsOf<TContract, ModelName, NsId> extends (infer Rels extends Record<string, unknown>) ? RelName extends keyof Rels ? Rels[RelName] extends {
+  readonly nullable: false;
+} ? false : true : true : true;
 type IncludeRelationValue<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, IncludedRow, NsId extends string = never> = RelationCardinality<TContract, ModelName, RelName, NsId> extends '1:1' | 'N:1' ? IsToOneRelationNullable<TContract, ModelName, RelName, NsId> extends true ? IncludedRow | null : IncludedRow : IncludedRow[];
 type CollectionModelName<TContract extends Contract<SqlStorage>> = { [Ns in keyof TContract['domain']['namespaces']]: keyof TContract['domain']['namespaces'][Ns]['models'] & string; }[keyof TContract['domain']['namespaces']];
 //#endregion
@@ -722,14 +957,11 @@ type CollectionConstructor<TContract extends Contract<SqlStorage>> = new (ctx: C
 type WithWhereState<State extends CollectionTypeState> = Omit<State, 'hasWhere'> & {
   readonly hasWhere: true;
 };
-type WithOrderByState<State extends CollectionTypeState> = Omit<State, 'hasOrderBy'> & {
-  readonly hasOrderBy: true;
-};
-type WithVariantState<State extends CollectionTypeState, V extends string> = Omit<State, 'variantName'> & {
-  readonly variantName: V;
+type WithVariantState<State extends CollectionTypeState, V extends string> = Omit<State, 'variantValue'> & {
+  readonly variantValue: V;
 };
 type IncludedRelationsForRow<TContract extends Contract<SqlStorage>, ModelName extends string, Row> = Omit<Row, keyof DefaultModelRow<TContract, ModelName>>;
-type IncludeRefinementTerminals = 'all' | 'first' | 'aggregate' | 'groupBy' | 'create' | 'createAll' | 'createAndCount' | 'update' | 'updateAll' | 'updateAndCount' | 'delete' | 'deleteAll' | 'deleteAndCount' | 'upsert';
+type IncludeRefinementTerminals = 'all' | 'first' | 'firstOrThrow' | 'aggregate' | 'groupBy' | 'create' | 'createAll' | 'createAndCount' | 'update' | 'updateAll' | 'updateAndCount' | 'delete' | 'deleteAll' | 'deleteAndCount' | 'upsert';
 /**
  * The members a to-one refinement collection strips: the scalar reducers the
  * contract's emitted aggregate map declares, plus `combine`. Both reduce a
@@ -738,54 +970,262 @@ type IncludeRefinementTerminals = 'all' | 'first' | 'aggregate' | 'groupBy' | 'c
  * subtracting the non-literal key set would strip the whole surface.
  */
 type IncludeRefinementScalarMethods<TContract extends Contract<SqlStorage>> = (string extends keyof ExtractAggregateTypes<TContract> & string ? never : keyof ExtractAggregateTypes<TContract> & string) | 'combine';
-type IncludeRefinementCollection<TContract extends Contract<SqlStorage>, ModelName extends string, Row, State extends CollectionTypeState, IsToMany extends boolean> = Omit<Collection<TContract, ModelName, Row, State>, IncludeRefinementTerminals | (IsToMany extends true ? never : IncludeRefinementScalarMethods<TContract>)>;
+type IncludeRefinementCollection<TContract extends Contract<SqlStorage>, ModelName extends string, Row, State extends CollectionTypeState, IsToMany extends boolean> = Omit<Collection<TContract, ModelName, Row, State>, IncludeRefinementTerminals | 'whereUnique' | (IsToMany extends true ? never : IncludeRefinementScalarMethods<TContract>)>;
 type IsToManyRelation<TContract extends Contract<SqlStorage>, ModelName extends string, RelName extends string, NsId extends string = never> = RelationCardinality<TContract, ModelName, RelName, NsId> extends '1:N' | 'N:M' ? true : false;
 type IncludeRefinementResult<TContract extends Contract<SqlStorage>, RelatedName extends string, IsToMany extends boolean> = IncludeRefinementCollection<TContract, RelatedName, unknown, CollectionTypeState, IsToMany> | (IsToMany extends true ? IncludeScalar<unknown> | IncludeCombine<Record<string, unknown>> : never);
-declare const RowType: unique symbol;
-interface RowSelection<T> {
-  [RowType]: T;
-}
-type IncludeRefinementValue<TContract extends Contract<SqlStorage>, ParentModelName extends string, RelName extends string, DefaultIncludedRow, RefinedResult, NsId extends string = never> = RefinedResult extends RowSelection<infer V> ? RefinedResult extends {
+type IncludeRefinementValue<TContract extends Contract<SqlStorage>, ParentModelName extends string, RelName extends string, DefaultIncludedRow, RefinedResult, NsId extends string = never> = RefinedResult extends HasRow<infer V> ? RefinedResult extends {
   readonly kind: 'includeScalar' | 'includeCombine';
-} ? V : IncludeRelationValue<TContract, ParentModelName, RelName, V, NsId> : IncludeRelationValue<TContract, ParentModelName, RelName, DefaultIncludedRow, NsId>;
+} ? V : RefinedIncludeRelationValue<TContract, ParentModelName, RelName, CollectionRowOf<HasRow<V>>, NsId> : IncludeRelationValue<TContract, ParentModelName, RelName, DefaultIncludedRow, NsId>;
+/**
+ * A refined to-one include is nullable whatever the relation's `nullable` flag
+ * says: the refinement's filter can exclude the related row.
+ */
+type RefinedIncludeRelationValue<TContract extends Contract<SqlStorage>, ParentModelName extends string, RelName extends string, IncludedRow, NsId extends string = never> = RelationCardinality<TContract, ParentModelName, RelName, NsId> extends '1:1' | 'N:1' ? IncludedRow | null : IncludedRow[];
+type WhereInput<TContract extends Contract<SqlStorage>, NsId extends string, ModelName extends string, VariantValue extends string | undefined = undefined> = ((model: VariantAwareModelAccessor<TContract, ModelName, VariantValue, NsId>, tools: ModelCallbackTools<TContract, ModelName, NsId>) => WhereCallbackResult) | ShorthandWhereFilter<TContract, NsId, ModelName>;
+//#endregion
+//#region src/collection-methods.d.ts
+type MethodsOf<Entry, Model> = (Entry & {
+  readonly model: Model;
+})['methods' & keyof Entry];
+type ContributedTables<Model> = { readonly [Id in CollectionMethodContributionId]: MethodsOf<CollectionMethodRegistry[Id], Model>; };
+type MethodNames<Tables> = { [Id in keyof Tables]: keyof Tables[Id]; }[keyof Tables];
+type SignatureFrom<Tables, Name> = { [Id in keyof Tables]: Name extends keyof Tables[Id] ? Tables[Id][Name] : never; }[keyof Tables];
+type IsUnion<T, All = T> = T extends unknown ? ([All] extends [T] ? false : true) : never;
+/** The type of a method name that more than one contribution gives the same model. Calling it is a compile error that names the model and the contributions. */
+interface CollectionMethodNameClash<Name, ModelName, Contributions> {
+  readonly clash: `more than one contribution gives model "${ModelName & string}" a collection method named "${Name & string}"`;
+  readonly contributions: Contributions;
+}
+/** What a contributed method returns: the collection it was called on, with `Filtered` and `Ordered` added as its signature declares. */
+type ContributedMethodResult<Signature, Self> = Signature extends {
+  readonly filters: true;
+} ? Signature extends {
+  readonly orders: true;
+} ? Ordered<Filtered<Self>> : Filtered<Self> : Signature extends {
+  readonly orders: true;
+} ? Ordered<Self> : Self;
+type ContributedCollectionMethod<Signature extends ContributedMethodSignature, Self> = <Receiver extends Self = Self>(...args: Signature['parameters']) => ContributedMethodResult<Signature, Receiver>;
+type MergedTable<Tables, ModelName> = { readonly [Name in MethodNames<Tables>]: { [Id in keyof Tables]: Name extends keyof Tables[Id] ? Id : never; }[keyof Tables] extends (infer Ids) ? true extends IsUnion<Ids> ? CollectionMethodNameClash<Name, ModelName, Ids> : SignatureFrom<Tables, Name> : never; };
+/** Each contributed method of a model, by name, with its signature. It does not depend on the receiver, so TypeScript computes it once per model. */
+type ModelContributedMethodTable<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string> = string extends ModelName | NsId ? Record<never, never> : MergedTable<ContributedTables<CollectionMethodModelTypeOf<TContract, ModelName, NsId>>, ModelName>;
+/** The contributed methods of a model's collection `Self`: the type of `using`. */
+type ContributedCollectionMethods<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string, Self, Table = ModelContributedMethodTable<TContract, ModelName, NsId>> = { readonly [Name in keyof Table]: Table[Name] extends ContributedMethodSignature ? ContributedCollectionMethod<Table[Name], Self> : Table[Name]; };
+//#endregion
+//#region src/fragments.d.ts
+type FieldMultiplicity = false | {
+  readonly elementNullable: boolean;
+};
+/** A field declared by its codec and nullability, for a fragment written without a field builder. `many` declares a list field as a contract field records one: `{ elementNullable: false }`, or `{ elementNullable: true }` when its elements may be null. */
+interface DeclaredField<CodecId extends string = string, Nullable extends boolean = boolean, Many extends FieldMultiplicity = false> {
+  readonly codecId: CodecId;
+  readonly nullable: Nullable;
+  readonly many?: Many | undefined;
+}
+type AnyDeclaredField = DeclaredField<string, boolean, FieldMultiplicity>;
+type MultiplicityOf<Many> = Many extends {
+  readonly elementNullable: infer ElementNullable extends boolean;
+} ? {
+  readonly elementNullable: ElementNullable;
+} : false;
+type DeclaredMultiplicity<Field> = Field extends {
+  readonly many?: false | undefined;
+} ? false : Field extends {
+  readonly many?: infer Many;
+} ? MultiplicityOf<Exclude<Many, undefined>> : false;
+type BuiltMultiplicity<Builder> = Builder extends {
+  build(): infer Built;
+} ? DeclaredMultiplicity<Built> : false;
+/** A field builder from the contract DSL, such as `field.text().optional()`, with the codec and nullability it declares. */
+type DeclaredFieldsFragmentFieldBuilder<CodecId extends string = string, Nullable extends boolean = boolean> = ScalarFieldDeclarationBuilder<CodecDescriptorRef<CodecId>, Nullable>;
+/** The fields a fragment for any model needs, each declared with a field builder or a {@link DeclaredField}. */
+type DeclaredFieldsFragmentFieldDeclarations<CodecId extends string = string> = Readonly<Record<string, DeclaredFieldsFragmentFieldBuilder<CodecId> | DeclaredField<CodecId, boolean, FieldMultiplicity>>>;
+type DeclarationField<Declaration> = Declaration extends DeclaredFieldsFragmentFieldBuilder<infer Id, infer Nullable> ? DeclaredField<Id, Nullable, BuiltMultiplicity<Declaration>> : Declaration extends DeclaredField<infer Id, infer Nullable, FieldMultiplicity> ? DeclaredField<Id, Nullable, DeclaredMultiplicity<Declaration>> : never;
+/** The declared fields with each builder read as its codec and nullability. */
+type DeclaredFields<Declarations extends DeclaredFieldsFragmentFieldDeclarations> = { readonly [K in keyof Declarations]: DeclarationField<Declarations[K]>; } extends (infer Fields) ? { readonly [K in keyof Fields]: Fields[K]; } : never;
+/** The model accessor of a fragment for any model: only the declared fields, typed by codec. */
+type DeclaredFieldsFragmentModelAccessor<TContract extends Contract<SqlStorage>, Fields extends Readonly<Record<string, AnyDeclaredField>>> = { readonly [K in keyof Fields]: Fields[K]['codecId'] extends keyof ExtractCodecTypes<TContract> & string ? DeclaredMultiplicity<Fields[K]> extends {
+  readonly elementNullable: infer ElementNullable extends boolean;
+} ? CodecListField<TContract, Fields[K]['codecId'], Fields[K]['nullable'], ElementNullable> : CodecField<TContract, Fields[K]['codecId'], Fields[K]['nullable']> : never; };
+declare const FragmentFactsType: unique symbol;
+/** What the body of a fragment for any model has established. A flag that is `boolean` is not known; `true` is established. */
+interface FragmentFacts {
+  readonly hasWhere: boolean;
+  readonly hasOrderBy: boolean;
+}
+/** The second argument of a `where` or `orderBy` callback in the body of a fragment for any model: every function, and no index, as the body does not know its model. */
+interface DeclaredFieldsFragmentCallbackTools<TContract extends Contract<SqlStorage>> {
+  readonly fns: OrmFunctions<TContract>;
+  readonly indexes: Readonly<Record<never, never>>;
+}
+type OrderSelector<Row, TContract extends Contract<SqlStorage>> = (row: Row, tools: DeclaredFieldsFragmentCallbackTools<TContract>) => OrderByItem;
+/** The collection the body of a fragment for any model receives: the methods that keep the row, on the declared fields, and what has been established so far. */
+interface DeclaredFieldsFragmentCollection<Row, Facts extends FragmentFacts, TContract extends Contract<SqlStorage> = Contract<SqlStorage>> {
+  readonly [FragmentFactsType]: Facts;
+  where(fn: (row: Row, tools: DeclaredFieldsFragmentCallbackTools<TContract>) => WhereCallbackResult): DeclaredFieldsFragmentCollection<Row, {
+    readonly hasWhere: true;
+    readonly hasOrderBy: Facts['hasOrderBy'];
+  }, TContract>;
+  orderBy(selection: OrderSelector<Row, TContract> | ReadonlyArray<OrderSelector<Row, TContract>>): DeclaredFieldsFragmentCollection<Row, {
+    readonly hasWhere: Facts['hasWhere'];
+    readonly hasOrderBy: true;
+  }, TContract>;
+  limit(n: number): DeclaredFieldsFragmentCollection<Row, Facts, TContract>;
+  offset(n: number): DeclaredFieldsFragmentCollection<Row, Facts, TContract>;
+}
+type ContractFieldMultiplicity<Field> = Field extends {
+  readonly many: infer Many;
+} ? MultiplicityOf<Many> : false;
+/** The declared fields that the model lacks, or has with another codec or nullability, as a list where the declaration has one value or the reverse, or as a list whose elements differ in nullability from the declared ones. For a union of models, the fields any of them lacks. */
+type MissingDeclaredFieldsFragmentFields<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string, Fields extends Readonly<Record<string, AnyDeclaredField>>> = ModelName extends string ? { [K in keyof Fields & string]: K extends keyof FieldsOf<TContract, ModelName, NsId> ? [FieldCodecId<TContract, ModelName, K, NsId>, FieldNullable<TContract, ModelName, K, NsId>, ContractFieldMultiplicity<FieldsOf<TContract, ModelName, NsId>[K]>] extends [Fields[K]['codecId'], Fields[K]['nullable'], DeclaredMultiplicity<Fields[K]>] ? [Fields[K]['codecId'], Fields[K]['nullable'], DeclaredMultiplicity<Fields[K]>] extends [FieldCodecId<TContract, ModelName, K, NsId>, FieldNullable<TContract, ModelName, K, NsId>, ContractFieldMultiplicity<FieldsOf<TContract, ModelName, NsId>[K]>] ? never : K : K : K; }[keyof Fields & string] : never;
+/** What a fragment for any model requires of its receiver beyond the collection's own members: nothing when the model has the declared fields, otherwise a property whose name says why it is refused. */
+type DeclaredFieldsFragmentFieldsCheck<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string, Fields extends Readonly<Record<string, AnyDeclaredField>>> = string extends ModelName ? {
+  readonly 'the fragment could not read the model of the collection from its type': ModelName;
+} : [MissingDeclaredFieldsFragmentFields<TContract, ModelName, NsId, Fields>] extends [never] ? unknown : {
+  readonly 'the model has no field that matches the declaration in the fragment': MissingDeclaredFieldsFragmentFields<TContract, ModelName, NsId, Fields>;
+};
+/** A collection plus the filter and order a fragment's body established. */
+type WithFacts<C, Facts extends FragmentFacts> = Facts['hasOrderBy'] extends true ? Ordered<Facts['hasWhere'] extends true ? Filtered<C> : C> : Facts['hasWhere'] extends true ? Filtered<C> : C;
+/**
+ * A fragment made by the client's `fragment` method: it accepts a collection of any model that has the declared fields, checked against the collection's own contract, model and namespace, and returns that collection with what the body established. `with` reads the result from the receiver's type and the fragment's facts.
+ */
+interface DeclaredFieldsFragment<TContract extends Contract<SqlStorage>, Fields extends Readonly<Record<string, AnyDeclaredField>>, Facts extends FragmentFacts> {
+  <C, ModelName extends string, ReceiverContract extends Contract<SqlStorage> = TContract, NsId extends string = never>(collection: C & HasTypeState<{
+    readonly nsId: NsId;
+  }> & {
+    readonly modelName: ModelName;
+    readonly ctx: {
+      readonly context: {
+        readonly contract: ReceiverContract;
+      };
+    };
+  } & DeclaredFieldsFragmentFieldsCheck<ReceiverContract, ModelName, NsId, Fields>): WithFacts<C, Facts>;
+  readonly [FragmentFactsType]: Facts;
+}
+interface ModelCollection$1<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string> {
+  readonly ctx: {
+    readonly context: ExecutionContext<TContract>;
+  };
+  readonly modelName: ModelName;
+  readonly namespaceId: NsId;
+  readonly tableName: string;
+}
+/**
+ * An `orderBy` selector for a field named by a string, such as an order parameter of a request. `allowed` lists the fields a request may order by. A name that is not in `allowed` or not an orderable field of the collection's model, and a direction other than `asc` or `desc`, throw `ORM.ARGUMENT_INVALID`. An undefined direction is `asc`.
+ *
+ * ```ts
+ * db.Post.orderBy(orderByField(db.Post, input.orderBy, input.direction, ['title', 'createdAt']));
+ * ```
+ */
+declare function orderByField<TContract extends Contract<SqlStorage>, ModelName extends string, const Allowed extends OrderableFieldNames<TContract, ModelName, NsId>, NsId extends string = never>(collection: ModelCollection$1<TContract, ModelName, NsId>, name: string, direction: string | undefined, allowed: readonly [Allowed, ...Allowed[]]): (row: { readonly [K in Allowed]: Orderable; }) => OrderByItem;
 //#endregion
 //#region src/grouped-collection.d.ts
 interface GroupedCollectionInit {
   readonly tableName: string;
   readonly namespaceId: string;
-  readonly baseFilters: readonly AnyExpression[];
+  readonly preGroupState: CollectionState;
   readonly groupByFields: readonly string[];
   readonly groupByColumns: readonly string[];
   readonly havingFilters: readonly AnyExpression[];
+  readonly postGroup: GroupPagingState;
 }
 type GroupByFieldName<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = keyof DefaultModelRow<TContract, ModelName, NsId> & string;
-declare class GroupedCollection<TContract extends Contract<SqlStorage>, ModelName extends string, GroupFields extends readonly GroupByFieldName<TContract, ModelName, NsId>[], NsId extends string = never> {
+type GroupedAggregateRow<TContract extends Contract<SqlStorage>, ModelName extends string, GroupFields extends readonly GroupByFieldName<TContract, ModelName, NsId>[], NsId extends string, Spec extends AggregateSpec> = SimplifyDeep<Pick<DefaultModelRow<TContract, ModelName, NsId>, GroupFields[number]> & AggregateResult<Spec>>;
+declare class GroupedCollection<TContract extends Contract<SqlStorage>, ModelName extends string, GroupFields extends readonly GroupByFieldName<TContract, ModelName, NsId>[], NsId extends string = never, HasOrderBy extends boolean = false> {
+  #private;
   readonly ctx: CollectionContext<TContract>;
   private readonly contract;
   readonly modelName: ModelName;
   readonly tableName: string;
-  readonly namespaceId: string;
-  readonly baseFilters: readonly AnyExpression[];
+  readonly namespaceId: NsId;
+  readonly preGroupState: CollectionState;
   readonly groupByFields: readonly string[];
   readonly groupByColumns: readonly string[];
   readonly havingFilters: readonly AnyExpression[];
+  readonly postGroup: GroupPagingState;
   constructor(ctx: CollectionContext<TContract>, modelName: ModelName, options: GroupedCollectionInit);
-  having(predicate: (having: HavingBuilder<TContract, ModelName, NsId>) => AnyExpression): GroupedCollection<TContract, ModelName, GroupFields, NsId>;
+  having(predicate: (having: HavingBuilder<TContract, ModelName, NsId>) => AnyExpression): GroupedCollection<TContract, ModelName, GroupFields, NsId, HasOrderBy>;
+  /**
+   * Append an `ORDER BY` clause on the grouped rows themselves — orders by
+   * group key. Ordering by an aggregate alias needs a builder surface over
+   * the aliases and isn't supported here. Unlocks post-group `limit(...)` /
+   * `offset(...)`, which page a group order that would otherwise be undefined.
+   */
+  orderBy(selection: ((model: Pick<ModelAccessor<TContract, ModelName, NsId>, GroupFields[number]>) => OrderByItem) | readonly [(model: Pick<ModelAccessor<TContract, ModelName, NsId>, GroupFields[number]>) => OrderByItem, ...ReadonlyArray<(model: Pick<ModelAccessor<TContract, ModelName, NsId>, GroupFields[number]>) => OrderByItem>]): GroupedCollection<TContract, ModelName, GroupFields, NsId, true>;
+  /**
+   * Apply `LIMIT n` to the grouped rows. Replaces any previous post-group
+   * limit. Requires a prior `orderBy(...)` — a database may return groups in
+   * any order, so "the first n groups" is undefined without one.
+   */
+  limit(n: HasOrderBy extends true ? number | TraitExpression<readonly ['numeric'], false, ExtractCodecTypes<TContract>> : never): GroupedCollection<TContract, ModelName, GroupFields, NsId, HasOrderBy>;
+  /**
+   * Apply `OFFSET n` to the grouped rows. Replaces any previous post-group
+   * offset. Requires a prior `orderBy(...)`, same as `limit(...)` — both
+   * pagination methods need a deterministic group order.
+   */
+  offset(n: HasOrderBy extends true ? number | TraitExpression<readonly ['numeric'], false, ExtractCodecTypes<TContract>> : never): GroupedCollection<TContract, ModelName, GroupFields, NsId, HasOrderBy>;
+  get prepared(): {
+    aggregate: <Spec extends AggregateSpec>(fn: (aggregate: AggregateBuilder<TContract, ModelName, NsId>) => Spec, configure?: (meta: MetaBuilder<"read">) => void) => Preparable<Record<string, unknown>, Promise<SimplifyDeep<Pick<DefaultModelRow<TContract, ModelName, NsId>, GroupFields[number]> & AggregateResult<Spec>>[]>>;
+  };
   /**
    * Read terminal: run a grouped aggregate query.
    *
    * Accepts an optional `configure` callback that receives a
-   * `MetaBuilder<'read'>` for attaching typed annotations.
-   * Annotations are merged into the compiled plan's `meta.annotations`.
+   * `MetaBuilder<'read'>` for attaching typed annotations to the call.
    */
-  aggregate<Spec extends AggregateSpec>(fn: (aggregate: AggregateBuilder<TContract, ModelName, NsId>) => Spec, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Array<SimplifyDeep<Pick<DefaultModelRow<TContract, ModelName, NsId>, GroupFields[number]> & AggregateResult<Spec>>>>;
+  aggregate<Spec extends AggregateSpec>(fn: (aggregate: AggregateBuilder<TContract, ModelName, NsId>) => Spec, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Array<GroupedAggregateRow<TContract, ModelName, GroupFields, NsId, Spec>>>;
+}
+//#endregion
+//#region src/prepared-collection.d.ts
+interface PreparedCollection<TContract extends Contract<SqlStorage>, ModelName extends string, Row, State extends CollectionTypeState> extends HasTypeState<State> {
+  aggregate<Spec extends AggregateSpec, Self = unknown>(this: Self & HasNoUniqueFilter, selector: (aggregate: AggregateBuilder<TContract, ModelName, State['nsId']>) => Spec, configure?: (meta: MetaBuilder<'read'>) => void): Preparable<Record<string, unknown>, Promise<AggregateResult<Spec>>>;
+  all<Self>(this: Self & HasNoUniqueFilter, configure?: (meta: MetaBuilder<'read'>) => void): Preparable<Record<string, unknown>, AsyncIterableResult<Row>>;
+  first(filter?: WhereInput<TContract, State['nsId'], ModelName, State['variantValue']>, configure?: (meta: MetaBuilder<'read'>) => void): Preparable<Record<string, unknown>, Promise<Row | null>>;
+  firstOrThrow(filter?: WhereInput<TContract, State['nsId'], ModelName, State['variantValue']>, configure?: (meta: MetaBuilder<'read'>) => void): Preparable<Record<string, unknown>, Promise<Row>>;
 }
 //#endregion
 //#region src/collection.d.ts
 type WhereDirectInput = WhereArg;
-declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName extends string, Row = SimplifyDeep<InferRootRow<TContract, ModelName>>, State extends CollectionTypeState = DefaultCollectionTypeState> implements RowSelection<Row> {
+type OrderBySelector<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName extends string | undefined, NsId extends string> = (model: VariantAwareModelAccessor<TContract, ModelName, VariantName, NsId>, tools: ModelCallbackTools<TContract, ModelName, NsId>) => OrderByItem;
+type LockMethodArgs<Capabilities, Strength extends LockStrength> = Capabilities extends LockStrengthCapabilities[Strength] & LockOptionCapabilities['of'] ? [options?: LockWaitOptions<Capabilities>] : never;
+type WriteConfigure = (meta: MetaBuilder<'write'>) => void;
+/**
+ * Ask the database to skip rows that collide with a unique constraint
+ * instead of failing the whole statement.
+ *
+ * `conflictOn` names the scalar fields of the constraint to watch; omit
+ * it to skip on any unique constraint of the table. Requires the
+ * contract capability `insertOnConflictSkip`, and
+ * `insertOnConflictWithoutTarget` as well when `conflictOn` is omitted.
+ */
+interface CreateConflictOptions<TContract extends Contract<SqlStorage>, ModelName extends string> {
+  readonly onConflict: 'skip';
+  readonly conflictOn?: readonly (keyof DefaultModelRow<TContract, ModelName> & string)[];
+}
+/** What `fragment` reads from the collection it is called on: its contract, its model and its query state. */
+interface FragmentSource {
+  readonly modelName: string;
+  readonly namespaceId: string;
+  readonly state: CollectionState;
+  readonly ctx: {
+    readonly context: {
+      readonly contract: Contract<SqlStorage>;
+    };
+  };
+}
+type ContractOf<C extends FragmentSource> = C['ctx']['context']['contract'];
+type ModelNameOf<C extends FragmentSource> = C['modelName'];
+/** The compile error `fragment` gives on a collection whose type records a filter, an order or an include. */
+interface FragmentNeedsRootCollection {
+  readonly fragmentNeedsRootCollection: 'the fragment is built from the model alone, so call fragment on the root collection of the model';
+}
+type HasRowBeyondModel<Self extends FragmentSource, NsId extends string> = Self extends HasRow ? [Exclude<keyof CollectionRowOf<Self>, keyof DefaultModelRow<ContractOf<Self>, ModelNameOf<Self>, NsId>>] extends [never] ? false : true : false;
+type RootCollectionOnly<Self extends FragmentSource, NsId extends string> = Self extends HasWhere | HasOrderBy ? FragmentNeedsRootCollection : HasRowBeyondModel<Self, NsId> extends true ? FragmentNeedsRootCollection : unknown;
+type ModelFragmentBody<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string> = [NsId] extends [never] ? Collection<TContract, ModelName> : Collection<TContract, ModelName, InferRootRow<TContract, ModelName, NsId>, WithNsId<DefaultCollectionTypeState, NsId>>;
+declare class CollectionBase<TContract extends Contract<SqlStorage>, ModelName extends string, Row = SimplifyDeep<InferRootRow<TContract, ModelName>>, State extends CollectionTypeState = DefaultCollectionTypeState> implements HasRow<Row>, HasTypeState<State> {
   #private;
+  readonly [TypeState]: State;
   readonly [RowType]: Row;
+  readonly _row?: CollectionRowOf<this>;
   /** @internal */
   readonly ctx: CollectionContext<TContract>;
   /** @internal */
@@ -795,7 +1235,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
   /** @internal */
   readonly tableName: string;
   /** @internal */
-  readonly namespaceId: string;
+  readonly namespaceId: State['nsId'];
   /** @internal */
   readonly state: CollectionState;
   /** @internal */
@@ -822,30 +1262,57 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * const adults = await db.orm.User.where({ active: true }).where((u) => u.age.gt(18)).all();
    * ```
    */
-  where(fn: (model: VariantAwareModelAccessor<TContract, ModelName, State['variantName'], State['nsId']>) => WhereDirectInput): Collection<TContract, ModelName, Row, WithWhereState<State>>;
-  where(input: WhereDirectInput): Collection<TContract, ModelName, Row, WithWhereState<State>>;
-  where(fn: (model: VariantAwareModelAccessor<TContract, ModelName, State['variantName'], State['nsId']>) => WhereArg): Collection<TContract, ModelName, Row, WithWhereState<State>>;
-  where(filters: ShorthandWhereFilter<TContract, ModelName, State['nsId']>): Collection<TContract, ModelName, Row, WithWhereState<State>>;
+  where<Self>(this: Self, fn: (model: VariantAwareModelAccessor<TContract, ModelName, State['variantValue'], State['nsId']>, tools: ModelCallbackTools<TContract, ModelName, State['nsId']>) => WhereCallbackResult): Filtered<Self>;
+  where<Self>(this: Self, input: WhereDirectInput): Filtered<Self>;
+  where<Self>(this: Self, filters: ShorthandWhereFilter<TContract, State['nsId'], ModelName>): Filtered<Self>;
   /**
-   * Narrow a polymorphic model to a specific variant. The returned
-   * collection has the variant's row shape and a discriminator filter
-   * is automatically applied. Chaining `.variant(...)` again replaces
-   * the previous variant filter.
+   * The collection methods packages contribute for this model. Each contribution reads the model and names its methods. Each method returns this collection with the method's filter and order added.
+   */
+  get using(): ContributedCollectionMethods<TContract, ModelName, State['nsId'], this>;
+  whereUnique<Self>(this: Self, criterion: UniqueConstraintCriterion<TContract, ModelName>): UniquelyFiltered<Self>;
+  /**
+   * Call `fn`, a query fragment, with this collection and return its result. `fn` may be a scope, which only imposes conditions and declares the fields it needs, or a fragment for what `where` cannot express, such as a shared `select` and `include`, an order or a limit. A condition on one row that needs no declared fields is `where(rowFragment)`. For a fragment made by the client's `fragment` method, the result is this collection's own type plus the filter and order the fragment's body established.
+   */
+  with<Self, Facts extends FragmentFacts>(this: Self, fragment: ((collection: NoInfer<Self>) => unknown) & {
+    readonly [FragmentFactsType]: Facts;
+  }): WithFacts<Self, Facts>;
+  with<Self, Out>(this: Self, fn: (collection: Self) => Out): Out;
+  /**
+   * Define a query fragment for this collection's model, such as a shared `select` and `include`. The body is typed once, against the model's plain collection. The fragment can be applied to any collection of the model that `select` and `variant` have not narrowed.
+   *
+   * The fragment is built from the model alone, so call `fragment` on the model's root collection. On a collection with chained calls it throws `ORM.ARGUMENT_INVALID`. The type check is partial: it refuses a collection whose type records a filter, an order or an include, and a collection typed by a type parameter, such as `this` in a class method; it does not see `limit`, `offset`, `select`, `cursor`, `distinct`, `variant` or a lock, a union with a root collection, or a value typed as the plain collection.
+   *
+   * ```ts
+   * const summary = db.Post.fragment((posts) => posts.select('id', 'title').include('user'));
+   * db.User.include('posts', (posts) => posts.with(summary));
+   * ```
+   */
+  fragment<Self extends FragmentSource, NsId extends string, Result>(this: Self & HasTypeState<{
+    readonly nsId: NsId;
+  }> & RootCollectionOnly<Self, NsId>, body: (collection: ModelFragmentBody<ContractOf<Self>, ModelNameOf<Self>, NsId>) => Result): QueryFragment<ModelFragmentReceiver<ContractOf<Self>, ModelNameOf<Self>, NsId>, Result>;
+  /**
+   * Narrow a polymorphic model to the variant declared with the given
+   * discriminator value. The returned collection has the variant's row
+   * shape and a discriminator filter is automatically applied. Call
+   * `.variant(...)` once, on the base collection: a collection that
+   * already has a variant selected refuses it. To select a different
+   * variant, start again from the base collection.
    *
    * ```typescript
    * // Read only admin users (STI):
-   * const admins = await db.orm.User.variant('Admin').all();
+   * const admins = await db.orm.User.variant('admin').all();
    *
    * // Iterate the rows:
-   * for await (const admin of db.orm.User.variant('Admin').all()) {
+   * for await (const admin of db.orm.User.variant('admin').all()) {
    *   console.log(admin.role);
    * }
    *
    * // Insert under a variant — discriminator is injected automatically:
-   * await db.orm.User.variant('Admin').create({ name: 'Ada', role: 'super' });
+   * await db.orm.User.variant('admin').create({ name: 'Ada', role: 'super' });
    * ```
    */
-  variant<V extends VariantNames<TContract, ModelName>>(variantName: V): Collection<TContract, ModelName, VariantModelRow<TContract, ModelName, V>, WithVariantState<WithWhereState<State>, V>>;
+  variant<V extends DiscriminatorValues<TContract, ModelName, S['nsId']>, S extends CollectionTypeState = State>(this: HasTypeState<S> & HasNoVariant, value: V): Collection<TContract, ModelName, VariantModelRow<TContract, ModelName, V, S['nsId']>, WithVariantState<WithWhereState<S>, V>>;
+  variant<V extends DiscriminatorValues<TContract, ModelName, State['nsId']>>(this: HasNoVariant, value: V): Collection<TContract, ModelName, VariantModelRow<TContract, ModelName, V, State['nsId']>, WithVariantState<WithWhereState<State>, V>>;
   /**
    * Eagerly load a related model. The relation appears on every
    * returned row under its declared name; to-one relations are mapped
@@ -862,7 +1329,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *
    * // Refine the related collection:
    * const withRecent = await db.orm.User.include('posts', (posts) =>
-   *   posts.where({ published: true }).orderBy((p) => p.createdAt.desc()).take(5),
+   *   posts.where({ published: true }).orderBy((p) => p.createdAt.desc()).limit(5),
    * ).all();
    *
    * // Reduce a to-many relation to a scalar value:
@@ -870,11 +1337,12 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *
    * // Multiple sub-views via combine():
    * const overview = await db.orm.User.include('posts', (posts) =>
-   *   posts.combine({ recent: posts.take(3), total: posts.count() }),
+   *   posts.combine({ recent: posts.limit(3), total: posts.count() }),
    * ).all();
    * ```
    */
-  include<RelName extends VariantAwareIncludeRelationNames<TContract, ModelName, State['variantName'], State['nsId']>, RelationOwner extends string = IncludeRelationOwner<TContract, ModelName, State['variantName'], RelName, State['nsId']> & string, RelatedName extends RelatedModelName<TContract, RelationOwner, RelName, State['nsId']> & string = RelatedModelName<TContract, RelationOwner, RelName, State['nsId']> & string, TargetNs extends string = RelationTargetNamespace<TContract, RelationOwner, RelName, State['nsId']>, IsToMany extends boolean = IsToManyRelation<TContract, RelationOwner, RelName, State['nsId']>, RefinedResult extends IncludeRefinementResult<TContract, RelatedName, IsToMany> = IncludeRefinementCollection<TContract, RelatedName, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, CollectionTypeState, IsToMany>>(relationName: RelName, refineFn?: (collection: IncludeRefinementCollection<TContract, RelatedName, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, DefaultCollectionTypeState, IsToMany>) => RefinedResult): Collection<TContract, ModelName, SimplifyDeep<Row & { [K in RelName]: IncludeRefinementValue<TContract, RelationOwner, K, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, RefinedResult, State['nsId']>; }>, State>;
+  include<RelName extends VariantAwareIncludeRelationNames<TContract, ModelName, State['variantValue'], State['nsId']>, RelationOwner extends string = IncludeRelationOwner<TContract, ModelName, State['variantValue'], RelName, State['nsId']> & string, OwnerNs extends string = IncludeRelationOwnerNamespace<TContract, ModelName, State['variantValue'], RelName, State['nsId']>, RelatedName extends RelatedModelName<TContract, RelationOwner, RelName, OwnerNs> & string = RelatedModelName<TContract, RelationOwner, RelName, OwnerNs> & string, TargetNs extends string = RelationTargetNamespace<TContract, RelationOwner, RelName, OwnerNs>, Self extends HasRow = never>(this: Self, relationName: RelName): Including<Self, { [K in RelName]: IncludeRelationValue<TContract, RelationOwner, K, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, OwnerNs>; }>;
+  include<RelName extends VariantAwareIncludeRelationNames<TContract, ModelName, State['variantValue'], State['nsId']>, RelationOwner extends string = IncludeRelationOwner<TContract, ModelName, State['variantValue'], RelName, State['nsId']> & string, OwnerNs extends string = IncludeRelationOwnerNamespace<TContract, ModelName, State['variantValue'], RelName, State['nsId']>, RelatedName extends RelatedModelName<TContract, RelationOwner, RelName, OwnerNs> & string = RelatedModelName<TContract, RelationOwner, RelName, OwnerNs> & string, TargetNs extends string = RelationTargetNamespace<TContract, RelationOwner, RelName, OwnerNs>, IsToMany extends boolean = IsToManyRelation<TContract, RelationOwner, RelName, OwnerNs>, RefinedResult extends IncludeRefinementResult<TContract, RelatedName, IsToMany> = IncludeRefinementCollection<TContract, RelatedName, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, CollectionTypeState, IsToMany>, Self extends HasRow = never>(this: Self, relationName: RelName, refineFn: (collection: IncludeRefinementCollection<TContract, RelatedName, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, DefaultCollectionTypeState, IsToMany>) => RefinedResult): Including<Self, { [K in RelName]: IncludeRefinementValue<TContract, RelationOwner, K, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, RefinedResult, OwnerNs>; }>;
   /**
    * Project the row down to a subset of scalar fields. Previously
    * included relations are preserved on the resulting row shape; only
@@ -889,6 +1357,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * }
    * ```
    */
+  select<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]], S extends CollectionTypeState = State, R = Row>(this: HasTypeState<S> & HasRow<R>, ...fields: Fields): Collection<TContract, ModelName, SimplifyDeep<Pick<DefaultModelRow<TContract, ModelName>, Fields[number]> & IncludedRelationsForRow<TContract, ModelName, R>>, S>;
   select<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]]>(...fields: Fields): Collection<TContract, ModelName, SimplifyDeep<Pick<DefaultModelRow<TContract, ModelName>, Fields[number]> & IncludedRelationsForRow<TContract, ModelName, Row>>, State>;
   /**
    * Append an `ORDER BY` clause. Pass a single selector callback or an
@@ -907,7 +1376,8 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *   .all();
    * ```
    */
-  orderBy(selection: ((model: VariantAwareModelAccessor<TContract, ModelName, State['variantName']>) => OrderByItem) | ReadonlyArray<(model: VariantAwareModelAccessor<TContract, ModelName, State['variantName']>) => OrderByItem>): Collection<TContract, ModelName, Row, WithOrderByState<State>>;
+  orderBy<Self extends WithoutUniqueFilter<Self>>(this: Self, selection: OrderBySelector<TContract, ModelName, State['variantValue'], State['nsId']> | ReadonlyArray<OrderBySelector<TContract, ModelName, State['variantValue'], State['nsId']>>): Ordered<Self>;
+  orderBy<Self>(this: Self & HasNoUniqueFilter, selection: OrderBySelector<TContract, ModelName, State['variantValue'], State['nsId']> | ReadonlyArray<OrderBySelector<TContract, ModelName, State['variantValue'], State['nsId']>>): Ordered<Self>;
   /**
    * Switch to grouped-aggregate mode. Returns a `GroupedCollection`
    * whose `.aggregate(...)` terminal produces one row per group with
@@ -921,7 +1391,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * // [{ userId: 1, count: 3, totalViews: 120 }, ...]
    * ```
    */
-  groupBy<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName, State['nsId']> & string, ...(keyof DefaultModelRow<TContract, ModelName, State['nsId']> & string)[]]>(...fields: Fields): GroupedCollection<TContract, ModelName, Fields, State['nsId']>;
+  groupBy<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName, State['nsId']> & string, ...(keyof DefaultModelRow<TContract, ModelName, State['nsId']> & string)[]], Self = unknown>(this: Self & HasNoUniqueFilter, ...fields: Fields): GroupedCollection<TContract, ModelName, Fields, State['nsId']>;
   /**
    * Produce multiple named sub-views of a to-many relation in a
    * single `include(...)`. Each branch is either another refined
@@ -932,7 +1402,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * ```typescript
    * const users = await db.orm.User.include('posts', (posts) =>
    *   posts.combine({
-   *     recent: posts.where({ published: true }).take(3),
+   *     recent: posts.where({ published: true }).limit(3),
    *     total: posts.count(),
    *     averageViews: posts.avg('views'),
    *   }),
@@ -943,7 +1413,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * // }
    * ```
    */
-  combine<Spec extends Record<string, CollectionImpl<TContract, ModelName, unknown, CollectionTypeState> | IncludeScalar<unknown>>>(spec: Spec): IncludeCombine<{ [K in keyof Spec]: Spec[K] extends IncludeScalar<infer ScalarResult> ? ScalarResult : Spec[K] extends CollectionImpl<TContract, ModelName, infer BranchRow, CollectionTypeState> ? BranchRow[] : never; }>;
+  combine<Spec extends Record<string, IncludeRefinementCollection<TContract, ModelName, unknown, CollectionTypeState, true> | IncludeScalar<unknown>>>(spec: Spec): IncludeCombine<{ [K in keyof Spec]: Spec[K] extends IncludeScalar<infer ScalarResult> ? ScalarResult : Spec[K] extends HasRow ? CollectionRowOf<Spec[K]>[] : never; }>;
   /**
    * Resume pagination from a known cursor position. Requires a prior
    * `orderBy(...)` so the cursor has a stable basis; provide a value
@@ -953,18 +1423,19 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * ```typescript
    * const page1 = await db.orm.Post
    *   .orderBy((p) => p.createdAt.desc())
-   *   .take(20)
+   *   .limit(20)
    *   .all();
    *
    * const last = page1[page1.length - 1]!;
    * const page2 = await db.orm.Post
    *   .orderBy((p) => p.createdAt.desc())
    *   .cursor({ createdAt: last.createdAt })
-   *   .take(20)
+   *   .limit(20)
    *   .all();
    * ```
    */
-  cursor(cursorValues: State['hasOrderBy'] extends true ? Partial<Record<keyof DefaultModelRow<TContract, ModelName> & string, unknown>> : never): Collection<TContract, ModelName, Row, State>;
+  cursor<Self extends HasOrderBy & WithoutUniqueFilter<Self>>(this: Self, cursorValues: Partial<Record<keyof DefaultModelRow<TContract, ModelName> & string, unknown>>): Self;
+  cursor<Self extends HasOrderBy>(this: Self & HasNoUniqueFilter, cursorValues: Partial<Record<keyof DefaultModelRow<TContract, ModelName> & string, unknown>>): Self;
   /**
    * Emit `SELECT DISTINCT` keyed on the given fields. Replaces any
    * previous `distinct(...)` / `distinctOn(...)` selection.
@@ -973,13 +1444,16 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * const groups = await db.orm.User.distinct('country', 'role').all();
    * ```
    */
-  distinct<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]]>(...fields: Fields): Collection<TContract, ModelName, Row, State>;
+  distinct<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]], Self extends WithoutUniqueFilter<Self>>(this: Self, ...fields: Fields): Self;
+  distinct<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]], Self>(this: Self & HasNoUniqueFilter, ...fields: Fields): Self;
   /**
    * Emit `SELECT DISTINCT ON (fields)` — keep the first row per
    * distinct key according to the current `orderBy(...)`. Requires a
    * prior `orderBy(...)`; replaces any previous `distinct(...)` /
    * `distinctOn(...)` selection.
    *
+   * Requires the `postgres.distinctOn` capability.
+   *
    * ```typescript
    * // Latest post per user:
    * const latestPerUser = await db.orm.Post
@@ -988,27 +1462,66 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *   .all();
    * ```
    */
-  distinctOn<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]]>(...fields: State['hasOrderBy'] extends true ? Fields : never): Collection<TContract, ModelName, Row, State>;
+  distinctOn<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]], Self extends HasOrderBy & WithoutUniqueFilter<Self>>(this: Self, ...fields: TContract['capabilities'] extends {
+    postgres: {
+      distinctOn: true;
+    };
+  } ? Fields : never): Self;
+  distinctOn<Fields extends readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]], Self extends HasOrderBy>(this: Self & HasNoUniqueFilter, ...fields: TContract['capabilities'] extends {
+    postgres: {
+      distinctOn: true;
+    };
+  } ? Fields : never): Self;
+  /**
+   * Lock the selected rows of this model with `FOR UPDATE` until the transaction ends.
+   *
+   * Requires the `sql.forUpdate` and `sql.lockOf` capabilities, because the lock always names the model's table with `OF`.
+   *
+   * ```typescript
+   * const job = await tx.orm.Job.where({ state: 'queued' }).limit(1).forUpdate({ skipLocked: true }).first();
+   * ```
+   */
+  forUpdate<Self>(this: Self, ...options: LockMethodArgs<TContract['capabilities'], 'forUpdate'>): Self;
+  /**
+   * Lock the selected rows of this model with `FOR NO KEY UPDATE` until the transaction ends. Unlike `forUpdate`, it does not block foreign-key checks from rows that reference them.
+   *
+   * Requires the `postgres.forNoKeyUpdate` and `sql.lockOf` capabilities, because the lock always names the model's table with `OF`.
+   */
+  forNoKeyUpdate<Self>(this: Self, ...options: LockMethodArgs<TContract['capabilities'], 'forNoKeyUpdate'>): Self;
+  /**
+   * Lock the selected rows of this model with `FOR SHARE` until the transaction ends; other transactions may share-lock them but not write them.
+   *
+   * Requires the `sql.forShare` and `sql.lockOf` capabilities, because the lock always names the model's table with `OF`.
+   */
+  forShare<Self>(this: Self, ...options: LockMethodArgs<TContract['capabilities'], 'forShare'>): Self;
+  /**
+   * Lock the selected rows of this model with `FOR KEY SHARE` until the transaction ends; only deletes and key changes are blocked.
+   *
+   * Requires the `postgres.forKeyShare` and `sql.lockOf` capabilities, because the lock always names the model's table with `OF`.
+   */
+  forKeyShare<Self>(this: Self, ...options: LockMethodArgs<TContract['capabilities'], 'forKeyShare'>): Self;
   /**
    * Apply `LIMIT n`. Replaces any previous limit set on this collection.
    *
    * ```typescript
-   * const firstTen = await db.orm.User.orderBy((u) => u.id.asc()).take(10).all();
+   * const firstTen = await db.orm.User.orderBy((u) => u.id.asc()).limit(10).all();
    * ```
    */
-  take(n: number): Collection<TContract, ModelName, Row, State>;
+  limit<Self extends WithoutUniqueFilter<Self>>(this: Self, n: number | TraitExpression<readonly ['numeric'], false, ExtractCodecTypes<TContract>>): Self;
+  limit<Self>(this: Self & HasNoUniqueFilter, n: number | TraitExpression<readonly ['numeric'], false, ExtractCodecTypes<TContract>>): Self;
   /**
    * Apply `OFFSET n`. Replaces any previous offset set on this collection.
    *
    * ```typescript
    * const page2 = await db.orm.User
    *   .orderBy((u) => u.id.asc())
-   *   .skip(10)
-   *   .take(10)
+   *   .offset(10)
+   *   .limit(10)
    *   .all();
    * ```
    */
-  skip(n: number): Collection<TContract, ModelName, Row, State>;
+  offset<Self extends WithoutUniqueFilter<Self>>(this: Self, n: number | TraitExpression<readonly ['numeric'], false, ExtractCodecTypes<TContract>>): Self;
+  offset<Self>(this: Self & HasNoUniqueFilter, n: number | TraitExpression<readonly ['numeric'], false, ExtractCodecTypes<TContract>>): Self;
   /**
    * Read terminal: execute the query and stream every matching row.
    *
@@ -1019,15 +1532,9 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * whichever fits the caller. A single result can only be consumed
    * once.
    *
-   * Streaming is the default and the expected execution model. The
-   * only scenarios that fall back to buffering internally before
-   * yielding are drivers that cannot expose a cursor to the
-   * underlying database, and — for queries with `include(...)` —
-   * targets whose SQL dialect supports neither lateral joins nor
-   * correlated subqueries (so child rows cannot be stitched in a
-   * single streaming query). These are implementation details below
-   * the public API; the iteration shape itself is genuinely
-   * streaming whenever the driver and plan allow it.
+   * Queries without `include(...)` stream rows as the driver yields them (drivers that cannot
+   * expose a cursor buffer internally first). Queries with `include(...)` read the whole parent
+   * result set into memory before yielding the first row.
    *
    * ```typescript
    * // Thenable — collect to an array:
@@ -1040,17 +1547,15 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * }
    * ```
    *
-   * Accepts an optional `configure` callback that receives a
-   * `MetaBuilder<'read'>` so the caller can attach typed user
-   * annotations to the executed plan. `meta.annotate(...)` enforces
-   * applicability at the type level and at runtime; annotations are
-   * merged into `plan.meta.annotations` at compile time.
+   * Accepts an optional `configure` callback that receives a `MetaBuilder<'read'>` so the caller can attach typed user annotations to the call. `meta.annotate(...)` enforces applicability at the type level and at runtime. Every terminal method runs as one `orm-call` activity that carries the annotations; the statements it sends carry none.
    *
    * ```typescript
-   * await db.orm.User.all((meta) => meta.annotate(cacheAnnotation({ ttl: 60 })));
+   * await db.orm.User.all((meta) => meta.annotate(cacheAnnotation({ key: 'users' })));
    * ```
    */
-  all(configure?: (meta: MetaBuilder<'read'>) => void): AsyncIterableResult<Row>;
+  all<Self extends this>(this: Self & HasNoUniqueFilter, configure?: (meta: MetaBuilder<'read'>) => void): AsyncIterableResult<CollectionRowOf<Self>>;
+  all<Self>(this: Self & HasNoUniqueFilter, configure?: (meta: MetaBuilder<'read'>) => void): AsyncIterableResult<CollectionRowOf<this>>;
+  get prepared(): PreparedCollection<TContract, ModelName, CollectionRowOf<this>, CollectionTypeStateOf<this>>;
   /**
    * Read terminal: return the first matching row, or `null` if none
    * match. Optionally accepts a filter (callback or shorthand object)
@@ -1071,14 +1576,14 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *
    * // Annotate without filtering further:
    * await db.orm.User.first(undefined, (meta) =>
-   *   meta.annotate(cacheAnnotation({ ttl: 60 })),
+   *   meta.annotate(cacheAnnotation({})),
    * );
    * ```
    */
-  first(): Promise<Row | null>;
-  first(filter: undefined, configure: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
-  first(filter: (model: VariantAwareModelAccessor<TContract, ModelName, State['variantName'], State['nsId']>) => WhereArg, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
-  first(filter: ShorthandWhereFilter<TContract, ModelName, State['nsId']>, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
+  first<Self extends this>(this: Self, filter?: WhereInput<TContract, State['nsId'], ModelName, State['variantValue']>, configure?: (meta: MetaBuilder<'read'>) => void): Promise<CollectionRowOf<Self> | null>;
+  first(filter?: WhereInput<TContract, State['nsId'], ModelName, State['variantValue']>, configure?: (meta: MetaBuilder<'read'>) => void): Promise<CollectionRowOf<this> | null>;
+  firstOrThrow<Self extends this>(this: Self, filter?: WhereInput<TContract, State['nsId'], ModelName, State['variantValue']>, configure?: (meta: MetaBuilder<'read'>) => void): Promise<CollectionRowOf<Self>>;
+  firstOrThrow(filter?: WhereInput<TContract, State['nsId'], ModelName, State['variantValue']>, configure?: (meta: MetaBuilder<'read'>) => void): Promise<CollectionRowOf<this>>;
   /**
    * Read terminal: run an aggregate query (count, sum, avg, min, max)
    * built via the `AggregateBuilder` callback. Returns one object
@@ -1097,21 +1602,21 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * ```
    *
    * Accepts an optional `configure` callback that receives a
-   * `MetaBuilder<'read'>` for attaching typed annotations.
-   * Annotations are merged into the compiled plan's `meta.annotations`.
+   * `MetaBuilder<'read'>` for attaching typed annotations to the call.
    */
-  aggregate<Spec extends AggregateSpec>(fn: (aggregate: AggregateBuilder<TContract, ModelName, State['nsId']>) => Spec, configure?: (meta: MetaBuilder<'read'>) => void): Promise<AggregateResult<Spec>>;
+  aggregate<Spec extends AggregateSpec, Self = unknown>(this: Self & HasNoUniqueFilter, fn: (aggregate: AggregateBuilder<TContract, ModelName, State['nsId']>) => Spec, configure?: (meta: MetaBuilder<'read'>) => void): Promise<AggregateResult<Spec>>;
   /**
    * Write terminal: insert one row and return it (with any configured
    * `select(...)` / `include(...)` projections applied to the returned
    * shape).
    *
-   * Related rows can be created or linked through relation callbacks
-   * on parent/child-owned relations (one-to-one or one-to-many).
-   * The callback receives a mutator exposing `create(...)` and
-   * `connect(...)`; `disconnect(...)` is only supported in nested
-   * `update(...)` mutations. Many-to-many relations are not yet
-   * supported as nested-mutation targets.
+   * Related rows can be created or linked through relation callbacks on any relation: to-one
+   * (1:1, N:1), to-many (1:N), and many-to-many (N:M, written through the junction table). The
+   * callback receives a mutator exposing `create(...)` and `connect(...)`; `disconnect(...)` is
+   * only supported in nested `update(...)` mutations. To-one relations take a single row or
+   * criterion.
+   * N:M `create`/`connect` are unavailable when the junction has required columns the relation API
+   * cannot populate.
    *
    * ```typescript
    * // Simple insert:
@@ -1136,19 +1641,11 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * });
    * ```
    *
-   * Accepts an optional `configure` callback that receives a
-   * `MetaBuilder<'write'>` for attaching typed annotations.
-   * Annotations are merged into the compiled mutation plan's
-   * `meta.annotations`.
-   *
-   * Note: when the input contains nested-mutation callbacks, the
-   * operation is executed as a graph of internal queries via
-   * `withMutationScope`. In that path, annotations apply to the
-   * logical `create()` call but do not currently flow into each
-   * constituent SQL statement issued for the related rows.
+   * Accepts an optional `configure` callback that receives a `MetaBuilder<'write'>` for attaching typed annotations to the call, including when the input contains relation callbacks and the call sends several statements and a read-back.
    */
-  create(data: ResolvedCreateInput<TContract, ModelName, State['variantName'], State['nsId']>, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row>;
-  create(data: MutationCreateInputWithRelations<TContract, ModelName, State['nsId']>, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row>;
+  create<Self extends this>(this: Self, data: ResolvedCreateInput<TContract, ModelName, State['variantValue'], State['nsId']>, configure?: (meta: MetaBuilder<'write'>) => void): Promise<CollectionRowOf<Self>>;
+  create<Self extends this>(this: Self, data: MutationCreateInputWithRelations<TContract, ModelName, State['nsId']>, configure?: (meta: MetaBuilder<'write'>) => void): Promise<CollectionRowOf<Self>>;
+  create(data: MutationCreateInputWithRelations<TContract, ModelName, State['nsId']>, configure?: (meta: MetaBuilder<'write'>) => void): Promise<CollectionRowOf<this>>;
   /**
    * Write terminal: insert many rows and stream the inserted rows.
    *
@@ -1170,16 +1667,25 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * for await (const row of db.orm.User.createAll(seedUsers)) {
    *   console.log('inserted', row.id);
    * }
+   *
+   * // Let the database skip rows that collide with a unique
+   * // constraint; only the rows it inserted come back:
+   * const inserted = await db.orm.User.createAll(seedUsers, {
+   *   onConflict: 'skip',
+   *   conflictOn: ['email'],
+   * });
    * ```
    *
    * Accepts an optional `configure` callback that receives a
    * `MetaBuilder<'write'>` for attaching typed annotations to the
-   * compiled insert plan.
+   * call. It may be passed in second position when there are no options.
    */
-  createAll(data: readonly ResolvedCreateInput<TContract, ModelName, State['variantName'], State['nsId']>[], configure?: (meta: MetaBuilder<'write'>) => void): AsyncIterableResult<Row>;
+  createAll<Self extends this>(this: Self, data: readonly ResolvedScalarCreateInput<TContract, ModelName, State['variantValue'], State['nsId']>[], optionsOrConfigure?: CreateConflictOptions<TContract, ModelName> | WriteConfigure, configure?: WriteConfigure): AsyncIterableResult<CollectionRowOf<Self>>;
+  createAll(data: readonly ResolvedScalarCreateInput<TContract, ModelName, State['variantValue'], State['nsId']>[], optionsOrConfigure?: CreateConflictOptions<TContract, ModelName> | WriteConfigure, configure?: WriteConfigure): AsyncIterableResult<CollectionRowOf<this>>;
   /**
    * Write terminal: insert many rows without materializing the
-   * inserted rows, returning the number of inserted records.
+   * inserted rows, returning the number of rows the database reports
+   * inserting.
    *
    * Prefer `createAll(...)` when you need the returned rows; prefer
    * this when you only need to know how many rows were inserted (the
@@ -1191,11 +1697,17 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *   { email: 'b@example.com' },
    * ]);
    * // inserted === 2
+   *
+   * // Let the database skip rows that collide with a unique
+   * // constraint; the count is how many it actually inserted:
+   * const added = await db.orm.User.createAndCount(seedUsers, {
+   *   onConflict: 'skip',
+   * });
    * ```
    *
    * Not supported on MTI variants — use `createAll(...)` instead.
    */
-  createAndCount(data: readonly ResolvedCreateInput<TContract, ModelName, State['variantName']>[], configure?: (meta: MetaBuilder<'write'>) => void): Promise<number>;
+  createAndCount(data: readonly ResolvedScalarCreateInput<TContract, ModelName, State['variantValue'], State['nsId']>[], optionsOrConfigure?: CreateConflictOptions<TContract, ModelName> | WriteConfigure, configure?: WriteConfigure): Promise<number>;
   /**
    * Write terminal: insert a row, or update the existing row on
    * conflict. Returns the resulting row (the inserted one or the
@@ -1212,13 +1724,14 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *   conflictOn: { email: 'alice@example.com' },
    * });
    *
-   * // Conditional create — `update: {}` keeps the existing row
-   * // unchanged. `conflictOn` must reference the constraint that
-   * // makes the row "already exist"; omit only when the conflict is
-   * // on the primary key. On conflict,
-   * // `ON CONFLICT DO NOTHING RETURNING ...` may return zero rows,
-   * // so a follow-up reload is issued to fetch and return the
-   * // existing row.
+   * // Conditional create: with `update: {}` the row is returned whether it
+   * // was inserted or already existed. When it already exists, the conflict
+   * // clause assigns the first conflict column its own value, which is an
+   * // update: update triggers fire, the row is locked until the transaction
+   * // ends, the caller needs UPDATE privilege on the table, and the call
+   * // fails if that column is generated. `conflictOn` must reference the
+   * // constraint that makes the row "already exist"; omit it only when the
+   * // conflict is on the primary key.
    * await db.orm.User.upsert({
    *   create: { email: 'alice@example.com', name: 'Alice' },
    *   update: {},
@@ -1228,23 +1741,31 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *
    * Not supported on MTI variants.
    */
+  upsert<Self extends this>(this: Self, input: {
+    create: ResolvedScalarCreateInput<TContract, ModelName, State['variantValue'], State['nsId']>;
+    update: ScalarUpdateInput<TContract, ModelName>;
+    conflictOn?: UniqueConstraintCriterion<TContract, ModelName>;
+  }, configure?: (meta: MetaBuilder<'write'>) => void): Promise<CollectionRowOf<Self>>;
   upsert(input: {
-    create: ResolvedCreateInput<TContract, ModelName, State['variantName']>;
-    update: Partial<DefaultModelRow<TContract, ModelName>>;
+    create: ResolvedScalarCreateInput<TContract, ModelName, State['variantValue'], State['nsId']>;
+    update: ScalarUpdateInput<TContract, ModelName>;
     conflictOn?: UniqueConstraintCriterion<TContract, ModelName>;
-  }, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row>;
+  }, configure?: (meta: MetaBuilder<'write'>) => void): Promise<CollectionRowOf<this>>;
   /**
    * Write terminal: update a single matching row — the first one the
    * filter matches — and return it (or `null` when no row matched).
    * Requires a prior `.where(...)` — calling `update(...)` on an
    * unfiltered collection is a type error.
    *
-   * Related rows can be created or relinked through relation
-   * callbacks on parent/child-owned relations (one-to-one or
-   * one-to-many). The callback receives a mutator exposing
-   * `create(...)`, `connect(...)`, and `disconnect(...)`. Nested
-   * updates against existing related rows, and many-to-many relations
-   * as nested-mutation targets, are not supported through this API.
+   * The row is the one `first()` returns, so an order, an offset, a cursor, `distinct` and `distinctOn` choose it; after `limit(0)` no row changes and the result is `null`. An update with a relation callback finds its row by the filter alone, so it throws `ORM.ARGUMENT_INVALID` on a collection with an order, a limit, an offset, a cursor, `distinct` or `distinctOn`.
+   *
+   * Related rows can be created, linked, or unlinked through relation callbacks on any relation:
+   * to-one (1:1, N:1), to-many (1:N), and many-to-many (N:M, written through the junction table).
+   * The callback receives a mutator exposing `create(...)`, `connect(...)`, and `disconnect(...)`.
+   * A to-one `disconnect()` clears the foreign key; a to-many `disconnect()` with no criteria
+   * unlinks every related row; an N:M `disconnect()` requires criteria. N:M `create`/`connect` are
+   * unavailable when the junction has required columns the relation API cannot populate. Nested
+   * updates against existing related rows are not supported through this API.
    *
    * ```typescript
    * // Update one row by id:
@@ -1262,18 +1783,12 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * ```
    *
    * Accepts an optional `configure` callback that receives a
-   * `MetaBuilder<'write'>` for attaching typed annotations.
-   *
-   * Note: when the input contains nested-mutation callbacks, the
-   * operation is executed as a graph of internal queries via
-   * `withMutationScope`. In that path, annotations apply to the logical
-   * `update()` call but do not currently flow into each constituent SQL
-   * statement issued for the related rows.
+   * `MetaBuilder<'write'>` for attaching typed annotations to the call, including when the input contains relation callbacks.
    */
-  update(data: State['hasWhere'] extends true ? MutationUpdateInput<TContract, ModelName, State['nsId']> : never, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row | null>;
+  update<Self extends HasWhere>(this: Self, data: MutationUpdateInput<TContract, ModelName, State['nsId']>, configure?: (meta: MetaBuilder<'write'>) => void): Promise<CollectionRowOf<Self & HasRow<CollectionRowOf<this>>> | null>;
   /**
    * Write terminal: update every matching row and stream the updated
-   * rows. Requires a prior `.where(...)` filter.
+   * rows. Requires a prior `.where(...)` filter. Throws `ORM.ARGUMENT_INVALID` on a collection with a limit, an offset, a cursor, `distinct` or `distinctOn`, which the statement cannot apply.
    *
    * The returned `AsyncIterableResult<Row>` is BOTH a thenable that
    * resolves to `Row[]` AND an async iterable that streams updated
@@ -1296,11 +1811,11 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * Accepts an optional `configure` callback that receives a
    * `MetaBuilder<'write'>` for attaching typed annotations.
    */
-  updateAll(data: State['hasWhere'] extends true ? Partial<DefaultModelRow<TContract, ModelName, State['nsId']>> : never, configure?: (meta: MetaBuilder<'write'>) => void): AsyncIterableResult<Row>;
+  updateAll<Self extends HasWhere>(this: Self & HasNoUniqueFilter, data: ScalarUpdateInput<TContract, ModelName, State['nsId']>, configure?: (meta: MetaBuilder<'write'>) => void): AsyncIterableResult<CollectionRowOf<Self & HasRow<CollectionRowOf<this>>>>;
   /**
    * Write terminal: update every matching row without returning them,
    * resolving to the count of rows that were updated. Requires a prior
-   * `.where(...)` filter.
+   * `.where(...)` filter. Throws `ORM.ARGUMENT_INVALID` on a collection with a limit, an offset, a cursor, `distinct` or `distinctOn`, which the statement cannot apply.
    *
    * Prefer `updateAll(...)` when you need the updated rows; prefer
    * this when you only need the affected-row count.
@@ -1311,12 +1826,12 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *   .updateAndCount({ published: true });
    * ```
    */
-  updateAndCount(data: State['hasWhere'] extends true ? Partial<DefaultModelRow<TContract, ModelName, State['nsId']>> : never, configure?: (meta: MetaBuilder<'write'>) => void): Promise<number>;
+  updateAndCount<Self extends HasWhere>(this: Self & HasNoUniqueFilter, data: ScalarUpdateInput<TContract, ModelName, State['nsId']>, configure?: (meta: MetaBuilder<'write'>) => void): Promise<number>;
   /**
    * Write terminal: delete a single matching row — the first one the
    * filter matches — and return it (or `null` when no row matched).
    * Requires a prior `.where(...)` — calling `delete()` on an
-   * unfiltered collection is a type error.
+   * unfiltered collection is a type error. The row is the one `first()` returns, so an order, an offset, a cursor, `distinct` and `distinctOn` choose it; after `limit(0)` no row is deleted and the result is `null`.
    *
    * ```typescript
    * const deleted = await db.orm.User.where({ id: 1 }).delete();
@@ -1326,10 +1841,10 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * Accepts an optional `configure` callback that receives a
    * `MetaBuilder<'write'>` for attaching typed annotations.
    */
-  delete(this: State['hasWhere'] extends true ? Collection<TContract, ModelName, Row, State> : never, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row | null>;
+  delete<Self extends HasWhere>(this: Self, configure?: (meta: MetaBuilder<'write'>) => void): Promise<CollectionRowOf<Self & HasRow<CollectionRowOf<this>>> | null>;
   /**
    * Write terminal: delete every matching row and stream the deleted
-   * rows. Requires a prior `.where(...)` filter.
+   * rows. Requires a prior `.where(...)` filter. Throws `ORM.ARGUMENT_INVALID` on a collection with a limit, an offset, a cursor, `distinct` or `distinctOn`, which the statement cannot apply.
    *
    * The returned `AsyncIterableResult<Row>` is BOTH a thenable that
    * resolves to `Row[]` AND an async iterable that streams deleted
@@ -1350,11 +1865,11 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * Accepts an optional `configure` callback that receives a
    * `MetaBuilder<'write'>` for attaching typed annotations.
    */
-  deleteAll(this: State['hasWhere'] extends true ? Collection<TContract, ModelName, Row, State> : never, configure?: (meta: MetaBuilder<'write'>) => void): AsyncIterableResult<Row>;
+  deleteAll<Self extends HasWhere>(this: Self & HasNoUniqueFilter, configure?: (meta: MetaBuilder<'write'>) => void): AsyncIterableResult<CollectionRowOf<Self & HasRow<CollectionRowOf<this>>>>;
   /**
    * Write terminal: delete every matching row without returning them,
    * resolving to the count of rows that were deleted. Requires a prior
-   * `.where(...)` filter.
+   * `.where(...)` filter. Throws `ORM.ARGUMENT_INVALID` on a collection with a limit, an offset, a cursor, `distinct` or `distinctOn`, which the statement cannot apply.
    *
    * Prefer `deleteAll(...)` when you need the deleted rows; prefer
    * this when you only need the affected-row count.
@@ -1363,7 +1878,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * const removed = await db.orm.Post.where({ archived: true }).deleteAndCount();
    * ```
    */
-  deleteAndCount(this: State['hasWhere'] extends true ? Collection<TContract, ModelName, Row, State> : never, configure?: (meta: MetaBuilder<'write'>) => void): Promise<number>;
+  deleteAndCount<Self extends HasWhere>(this: Self & HasNoUniqueFilter, configure?: (meta: MetaBuilder<'write'>) => void): Promise<number>;
 }
 /**
  * The public collection surface: the chainable builder and terminal methods
@@ -1373,7 +1888,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
  * chaining preserves it, and a contributed operation surfaces without any
  * client change.
  */
-type Collection<TContract extends Contract<SqlStorage>, ModelName extends string, Row = SimplifyDeep<InferRootRow<TContract, ModelName>>, State extends CollectionTypeState = DefaultCollectionTypeState> = CollectionImpl<TContract, ModelName, Row, State> & AggregateIncludeReducers<TContract, ModelName, State['nsId']>;
+type Collection<TContract extends Contract<SqlStorage>, ModelName extends string, Row = SimplifyDeep<InferRootRow<TContract, ModelName>>, State extends CollectionTypeState = DefaultCollectionTypeState> = CollectionBase<TContract, ModelName, Row, State> & AggregateIncludeReducers<TContract, ModelName, State['nsId']>;
 /**
  * The constructor face of {@link Collection}: constructing — or subclassing,
  * as custom collections registered via `orm({ collections })` do — yields the
@@ -1386,29 +1901,64 @@ interface CollectionSurfaceConstructor {
 declare const Collection: CollectionSurfaceConstructor;
 //#endregion
 //#region src/filters.d.ts
-declare function and(...exprs: AnyExpression[]): AndExpr;
-declare function or(...exprs: AnyExpression[]): OrExpr;
-declare function not(expr: AnyExpression): AnyExpression;
+declare function and(...exprs: Condition[]): AndExpr;
+declare function or(...exprs: Condition[]): OrExpr;
+declare function not(expr: Condition): AnyExpression;
 declare function all(): AnyExpression;
 //#endregion
 //#region src/model-accessor.d.ts
-declare function createModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, VariantName extends string | undefined = undefined>(context: ExecutionContext<TContract>, namespaceId: string, modelName: ModelName, variantName?: VariantName): VariantAwareModelAccessor<TContract, ModelName, VariantName>;
+declare function createModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, VariantValue extends string | undefined = undefined, NsId extends string = string>(context: ExecutionContext<TContract>, namespaceId: NsId, modelName: ModelName, tables: CollectionTables, variantValue?: VariantValue): VariantAwareModelAccessor<TContract, ModelName, VariantValue, NsId>;
 //#endregion
 //#region src/orm.d.ts
-interface OrmOptions<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>> {
+interface OrmOptions<TContract extends Contract<SqlStorage>, TCollections extends CollectionClasses> {
   readonly runtime: RuntimeQueryable;
-  readonly collections?: Collections;
+  readonly collections?: TCollections;
   readonly context: ExecutionContext<TContract>;
 }
 type ModelNames<TContract extends Contract<SqlStorage>> = CollectionModelName<TContract>;
 type AnyCollectionClass = new (...args: never[]) => object;
-type CustomCollectionForKey<Collections extends Partial<Record<string, AnyCollectionClass>>, Key extends string> = Key extends keyof Collections ? Collections[Key] extends AnyCollectionClass ? InstanceType<Collections[Key]> : never : never;
-type ModelCollection<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>, NsId extends string, ModelName extends ModelNames<TContract>> = [CustomCollectionForKey<Collections, ModelName>] extends [never] ? Collection<TContract, ModelName, InferRootRow<TContract, ModelName, NsId>, WithNsId<DefaultCollectionTypeState, NsId>> : CustomCollectionForKey<Collections, ModelName>;
+/** Custom collection classes keyed by model name, as `orm({ collections })` and the clients take them. */
+type CollectionClasses = Partial<Record<string, AnyCollectionClass>>;
+/** No custom collection classes: the default of `orm()` and of every client type. */
+type NoCollectionClasses = Record<never, never>;
+type CustomCollectionForKey<TCollections extends CollectionClasses, Key extends string> = Key extends keyof TCollections ? TCollections[Key] extends AnyCollectionClass ? InstanceType<TCollections[Key]> : never : never;
+type ModelCollection<TContract extends Contract<SqlStorage>, TCollections extends CollectionClasses, NsId extends string, ModelName extends ModelNames<TContract>> = [CustomCollectionForKey<TCollections, ModelName>] extends [never] ? Collection<TContract, ModelName, InferRootRow<TContract, ModelName, NsId>, WithNsId<DefaultCollectionTypeState, NsId>> : CustomCollectionForKey<TCollections, ModelName>;
 type NamespaceModelNames<TContract extends Contract<SqlStorage>, NsId extends keyof TContract['domain']['namespaces']> = keyof TContract['domain']['namespaces'][NsId]['models'] & string & ModelNames<TContract>;
-type OrmNamespace<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>, NsId extends keyof TContract['domain']['namespaces']> = { [K in NamespaceModelNames<TContract, NsId>]: ModelCollection<TContract, Collections, NsId & string, K>; };
-type NamespacedClientMap<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>> = { [Ns in keyof TContract['domain']['namespaces']]: OrmNamespace<TContract, Collections, Ns>; };
-type OrmClient<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>> = NamespacedClientMap<TContract, Collections>;
-declare function orm<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>> = Record<never, never>>(options: OrmOptions<TContract, Collections>): OrmClient<TContract, Collections>;
+type OrmNamespace<TContract extends Contract<SqlStorage>, TCollections extends CollectionClasses, NsId extends keyof TContract['domain']['namespaces']> = { [K in NamespaceModelNames<TContract, NsId>]: ModelCollection<TContract, TCollections, NsId & string, K>; };
+type NamespacedClientMap<TContract extends Contract<SqlStorage>, TCollections extends CollectionClasses> = { [Ns in keyof TContract['domain']['namespaces']]: OrmNamespace<TContract, TCollections, Ns>; };
+/** The members of the ORM client that sit beside its namespaces, such as `fragment`. */
+interface OrmClientRootMembers<TContract extends Contract<SqlStorage>> {
+  /**
+   * Define a query fragment for any model that has the declared fields. Declare each field with a field builder from the contract DSL or with `{ codecId, nullable }`, and a list field with `.many()` or `many: { elementNullable: false }`, or `.many({ elementsNullable: true })` or `many: { elementNullable: true }` when its elements may be null. The body sees only the declared fields and may call `where`, `orderBy`, `limit` and `offset`; `updateAll`, `updateAndCount`, `deleteAll` and `deleteAndCount` throw `ORM.ARGUMENT_INVALID` after a fragment that set a limit or an offset, as they do for any limit, offset, cursor, `distinct` or `distinctOn` they would ignore. The fragment accepts a collection of any model whose fields include the declared ones with the same codec and nullability, a list with the same element nullability exactly where the declaration declares one, and returns that collection with the filter and order the body applied.
+   *
+   * ```ts
+   * const notDeleted = db.orm.fragment(
+   *   { deletedAt: field.temporal.timestamptz().optional() },
+   *   (rows) => rows.where((r) => r.deletedAt.isNull()),
+   * );
+   * db.orm.public.Post.with(notDeleted).deleteAll();
+   * ```
+   */
+  fragment<const Declarations extends DeclaredFieldsFragmentFieldDeclarations<keyof ExtractCodecTypes<TContract> & string>, Facts extends FragmentFacts>(fields: Declarations, body: (rows: DeclaredFieldsFragmentCollection<DeclaredFieldsFragmentModelAccessor<TContract, DeclaredFields<Declarations>>, FragmentFacts, TContract>) => DeclaredFieldsFragmentCollection<DeclaredFieldsFragmentModelAccessor<TContract, DeclaredFields<Declarations>>, Facts, TContract>): DeclaredFieldsFragment<TContract, DeclaredFields<Declarations>, Facts>;
+}
+type OrmClient<TContract extends Contract<SqlStorage>, TCollections extends CollectionClasses> = NamespacedClientMap<TContract, TCollections> & ('fragment' extends keyof TContract['domain']['namespaces'] ? unknown : OrmClientRootMembers<TContract>);
+declare function orm<TContract extends Contract<SqlStorage>, TCollections extends CollectionClasses = NoCollectionClasses>(options: OrmOptions<TContract, TCollections>): OrmClient<TContract, TCollections>;
+/**
+ * Checks that each custom collection class is a `Collection` subclass registered under a model the contract has, and returns the classes by model name. `orm()` calls it, and a client calls it when it is created, so a wrong class fails there and not on the first query.
+ */
+declare function checkCollectionClasses<TContract extends Contract<SqlStorage>, TCollections extends CollectionClasses>(contract: TContract, collections: TCollections | undefined): ReadonlyMap<string, AnyCollectionClass>;
+//#endregion
+//#region src/prepared-row-query.d.ts
+interface PreparedRowQuery<Params, Result> {
+  query(target: RuntimeQueryable$1, params: Params, options?: RuntimeExecuteOptions): Result;
+}
+/** The `prepare` member a client and its transactions offer, typed by the client's contract. */
+interface PrepareMember<TContract extends Contract<SqlStorage>> {
+  prepare<D extends Declaration<CT>, Q extends SqlQueryPlan | Preparable<unknown, unknown>, CT extends CodecTypesBase = ExtractCodecTypes<TContract>>(declaration: D, callback: (params: BindSiteParams<D>) => Q): Promise<PreparedFrom<ParamsFromDeclaration<D, CT>, Q>>;
+}
+type PreparedFrom<Params, Q extends SqlQueryPlan | Preparable<unknown, unknown>> = Q extends Preparable<unknown, infer Result> ? PreparedRowQuery<Params, Result> : PreparedFor<Params, ResultType<Q>>;
+declare function prepareQuery<D extends Declaration<CT>, Q extends SqlQueryPlan | Preparable<unknown, unknown>, CT extends CodecTypesBase>(runtime: Runtime, declaration: D, callback: (params: BindSiteParams<D>) => Q): Promise<PreparedFrom<ParamsFromDeclaration<D, CT>, Q>>;
+declare function createPreparedRowQuery<Params, DbRow, Result>(description: Preparable<DbRow, Result>, statement: PreparedStatement<Params, DbRow>): PreparedRowQuery<Params, Result>;
 //#endregion
-export { type AggregateBuilder, type AggregateResult, type AggregateSpec, Collection, type CollectionContext, type CollectionModelName, type CollectionState, type CollectionTypeState, type ComparisonMethods, type CreateInput, type DefaultCollectionTypeState, type DefaultModelRow, GroupedCollection, type IncludeExpr, type ModelAccessor, type NumericFieldNames, type OrmOptions, type RelatedModelName, type RelationFilterAccessor, type RelationMutator, type RelationNames, type RelationPredicate, type RelationPredicateInput, type RelationsOf, type RuntimeQueryable, type ShorthandWhereFilter, type UniqueConstraintCriterion, all, and, createModelAccessor, emptyState, not, or, orm };
+export { type AggregateBuilder, type AggregateIncludeReducers, type AggregateResult, type AggregateSelector, type AggregateSpec, type AliasedTable, type CodecField, type CodecListField, Collection, type CollectionClasses, type CollectionContext, type CollectionMethodNameClash, type CollectionModelName, type CollectionRowOf, type CollectionState, type CollectionTables, type CollectionTypeState, type CollectionTypeStateOf, type ComparisonMethods, type Condition, type ContributedCollectionMethod, type ContributedCollectionMethods, type ContributedMethodResult, type CreateInput, type DeclaredField, type DeclaredFieldsFragment, type DeclaredFieldsFragmentCallbackTools, type DefaultCollectionTypeState, type DefaultModelRow, type Filtered, type FragmentFacts, type FunctionCondition, GroupedCollection, type HasNoVariant, type HasOrderBy, type HasRow, type HasTypeState, type HasUniqueFilter, type HasWhere, type IncludeExpr, type IncludeScalar, type Including, type ModelAccessor, type ModelCallbackTools, type ModelContributedMethodTable, type ModelIndexReferences, type NoCollectionClasses, type NumericFieldNames, type OrderOptions, type Orderable, type OrderableFieldNames, type Ordered, type OrmClientRootMembers, type OrmFunctions, type OrmFunctionsOf, type OrmOptions, type OrmRawSqlBuilder, type OrmRawSqlTag, type PrepareMember, type PreparedCollection, type PreparedFrom, type PreparedRowQuery, type QueryFragment, type RelatedModelName, type RelationFilterAccessor, type RelationMutator, type RelationNames, type RelationPredicate, type RelationPredicateInput, type RelationsOf, type RowType, type RuntimeQueryable, type ScalarUpdateInput, type ShorthandWhereFilter, type TableScope, type TableStorageCoordinate, type ToManyRelationAccessor, type ToOneRelationAccessor, type TypeState, type UniqueConstraintCriterion, type UniquelyFiltered, type WhereCallbackResult, all, and, checkCollectionClasses, createCollectionTables, createModelAccessor, createPreparedRowQuery, emptyState, not, or, orderByField, orm, prepareQuery };
 //# sourceMappingURL=orm-client.d.mts.map