@prisma/orm-family-sql 8.0.0-rc.1-dev.46 → 8.0.0-rc.10-dev.1

package/dist/{migration-CjDRZNep.d.mts → migration-Bhce5i_m.d.mts}

@@ -1,6 +1,6 @@
 import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
-import "./types-UcHa2cTe.mjs";
-import { f as SqlMigrationPlanOperation, w as SqlPlanTargetDetails } from "./types-IqZMLrFC-DcH8v_u3.mjs";
+import "./types-C36_3E6_.mjs";
+import { f as SqlMigrationPlanOperation, w as SqlPlanTargetDetails } from "./types-IqZMLrFC-BIRftuU7.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { Migration } from "@prisma/orm-toolchain/migration-tools/migration";
 //#region ../../../2-sql/9-family/dist/migration.d.mts
@@ -41,4 +41,4 @@ declare abstract class SqlMigration<TDetails extends SqlPlanTargetDetails, TTarg
 }
 //#endregion
 export { SqlMigration as t };
-//# sourceMappingURL=migration-CjDRZNep.d.mts.map
+//# sourceMappingURL=migration-Bhce5i_m.d.mts.map

package/dist/{migration-CjDRZNep.d.mts.map → migration-Bhce5i_m.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"migration-CjDRZNep.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/migration.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0BuB,aAAa,iBAAiB,sBAAsB,mCAAmC,cAAc,SAAS,cAAc,SAAS,aAAa,YAAY,SAAS,cAAc,SAAS,qBAAqB,UAAU,0BAA0B,kBAAkB,WAAW,OAAO;;;;;;;;;;;MAW5S"}
+{"version":3,"file":"migration-Bhce5i_m.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/migration.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0BuB,aAAa,iBAAiB,sBAAsB,mCAAmC,cAAc,SAAS,cAAc,SAAS,aAAa,YAAY,SAAS,cAAc,SAAS,qBAAqB,UAAU,0BAA0B,kBAAkB,WAAW,OAAO;;;;;;;;;;;MAW5S"}

package/dist/operations.d.mts

@@ -1,2 +1,2 @@
-import { a as SqlOperationRegistry, i as SqlOperationEntry, n as SqlOperationDescriptor, o as createSqlOperationRegistry, r as SqlOperationDescriptors, t as SqlLoweringSpec } from "./index-C5I8D-MB.mjs";
+import { a as SqlOperationRegistry, i as SqlOperationEntry, n as SqlOperationDescriptor, o as createSqlOperationRegistry, r as SqlOperationDescriptors, t as SqlLoweringSpec } from "./index-CLAshwKN.mjs";
 export { SqlLoweringSpec, SqlOperationDescriptor, SqlOperationDescriptors, SqlOperationEntry, SqlOperationRegistry, createSqlOperationRegistry };

package/dist/orm-client.d.mts

@@ -1,14 +1,14 @@
-import { r as StorageTable, t as StorageColumn } from "./storage-table-DSeWszOL-CI-cItEK.mjs";
+import { 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 "./types-C36_3E6_.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-Clw_yBAh.mjs";
+import "./ast-DuLukI6f.mjs";
+import { o as Expression } from "./expression-mku9I7Ue.mjs";
+import { r as ExecutionContext } from "./query-lane-context-Qa-eddrE-BQV6J9nV.mjs";
+import "./query-lane-context-CGdMIEuv.mjs";
+import { h as RuntimeScope, o as ComputeColumnJsType } from "./types-CyxGtOOh-BJnoWm0f.mjs";
+import "./types-DvsoMNLs.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { AnnotationValue, AsyncIterableResult, MetaBuilder, OperationKind } from "@prisma/orm-framework/components/runtime";
 import { SimplifyDeep } from "@prisma/orm-framework/utils/simplify-deep";
@@ -74,14 +74,27 @@ interface CollectionState {
   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
+   * Populated transiently by the read terminals `all` and `first` just before dispatch. Terminals
+   * that compile a plan directly attach annotations to it with `mergeAnnotations` instead; nested
+   * `create()`/`update()` validate annotations and then discard them.
+   * `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>>;
 }
 declare function emptyState(): 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: number | undefined;
+  readonly offset: number | undefined;
+}
 interface CollectionTypeState {
   readonly hasOrderBy: boolean;
   readonly hasWhere: boolean;
@@ -187,7 +200,7 @@ 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 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;
 /**
  * Declares trait requirements and runtime factory for each comparison method.
  *
@@ -249,19 +262,20 @@ 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>) => AnyExpression;
+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 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<FieldJsType<TContract, ModelName, K, NsId>, FieldTraits<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>]: RelationFilterAccessor<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
@@ -269,7 +283,7 @@ type ModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends str
  * `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, 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, NsId> & RelationModelAccessor<TContract, VariantName, NsId> : ModelAccessor<TContract, ModelName, NsId> : ModelAccessor<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
@@ -458,7 +472,7 @@ 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 DefaultModelRow<TContract, ModelName, NsId> & string]: DefaultModelRow<TContract, ModelName, NsId>[K] | 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;
@@ -542,7 +556,8 @@ type IsOptionalCreateField<TContract extends Contract<SqlStorage>, ModelName ext
 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 ScalarCreateInput<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>>>;
+type CreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ScalarCreateInput<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>;
@@ -554,6 +569,7 @@ type DiscriminatorFieldName<TContract extends Contract<SqlStorage>, ModelName ex
 } ? 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 ResolvedScalarCreateInput<TContract extends Contract<SqlStorage>, ModelName extends string, VName extends string | undefined, NsId extends string = never> = IsPolymorphicBase<TContract, ModelName, NsId> extends true ? VName extends string ? Omit<ScalarCreateInput<TContract, ModelName, NsId>, DiscriminatorFieldName<TContract, ModelName, NsId>> & ScalarCreateInput<TContract, VName, NsId> : never : ScalarCreateInput<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: {
@@ -682,31 +698,19 @@ type RelationModelName<Relation> = Relation extends {
   };
 } ? 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
@@ -747,30 +751,58 @@ interface RowSelection<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 {
   readonly kind: 'includeScalar' | 'includeCombine';
-} ? V : IncludeRelationValue<TContract, ParentModelName, RelName, V, NsId> : IncludeRelationValue<TContract, ParentModelName, RelName, DefaultIncludedRow, NsId>;
+} ? V : RefinedIncludeRelationValue<TContract, ParentModelName, RelName, 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> = IsToManyRelation<TContract, ParentModelName, RelName, NsId> extends true ? IncludedRow[] : IncludedRow | null;
 //#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 : 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 : never): GroupedCollection<TContract, ModelName, GroupFields, NsId, HasOrderBy>;
   /**
    * Read terminal: run a grouped aggregate query.
    *
@@ -778,7 +810,7 @@ declare class GroupedCollection<TContract extends Contract<SqlStorage>, ModelNam
    * `MetaBuilder<'read'>` for attaching typed annotations.
    * Annotations are merged into the compiled plan's `meta.annotations`.
    */
-  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/collection.d.ts
@@ -786,6 +818,7 @@ 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> {
   #private;
   readonly [RowType]: Row;
+  readonly _row?: Row;
   /** @internal */
   readonly ctx: CollectionContext<TContract>;
   /** @internal */
@@ -825,7 +858,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
   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(filters: ShorthandWhereFilter<TContract, State['nsId'], ModelName>): Collection<TContract, ModelName, Row, WithWhereState<State>>;
   /**
    * Narrow a polymorphic model to a specific variant. The returned
    * collection has the variant's row shape and a discriminator filter
@@ -862,7 +895,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 +903,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['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']>>(relationName: RelName): Collection<TContract, ModelName, SimplifyDeep<Row & { [K in RelName]: IncludeRelationValue<TContract, RelationOwner, K, SimplifyDeep<InferRootRow<TContract, RelatedName, TargetNs>>, State['nsId']>; }>, State>;
+  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>;
   /**
    * Project the row down to a subset of scalar fields. Previously
    * included relations are preserved on the resulting row shape; only
@@ -907,7 +941,7 @@ 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(selection: ((model: VariantAwareModelAccessor<TContract, ModelName, State['variantName'], State['nsId']>) => OrderByItem) | ReadonlyArray<(model: VariantAwareModelAccessor<TContract, ModelName, State['variantName'], State['nsId']>) => OrderByItem>): Collection<TContract, ModelName, Row, WithOrderByState<State>>;
   /**
    * Switch to grouped-aggregate mode. Returns a `GroupedCollection`
    * whose `.aggregate(...)` terminal produces one row per group with
@@ -932,7 +966,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'),
    *   }),
@@ -953,14 +987,14 @@ 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();
    * ```
    */
@@ -980,6 +1014,8 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * 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 +1024,31 @@ 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)[]]>(...fields: TContract['capabilities'] extends {
+    postgres: {
+      distinctOn: true;
+    };
+  } ? State['hasOrderBy'] extends true ? Fields : never : never): Collection<TContract, ModelName, Row, State>;
   /**
    * 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(n: number): Collection<TContract, ModelName, Row, State>;
   /**
    * 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(n: number): Collection<TContract, ModelName, Row, State>;
   /**
    * Read terminal: execute the query and stream every matching row.
    *
@@ -1019,15 +1059,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:
@@ -1078,7 +1112,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
   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(filter: ShorthandWhereFilter<TContract, State['nsId'], ModelName>, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
   /**
    * Read terminal: run an aggregate query (count, sum, avg, min, max)
    * built via the `AggregateBuilder` callback. Returns one object
@@ -1106,12 +1140,13 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * `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:
@@ -1143,9 +1178,9 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *
    * 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.
+   * `withMutationScope`. In that path the `configure` callback still runs, so `meta.annotate`
+   * validation applies, but the recorded annotations are discarded: neither the nested
+   * statements nor the read-back query carry them.
    */
   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>;
@@ -1176,7 +1211,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * `MetaBuilder<'write'>` for attaching typed annotations to the
    * compiled insert plan.
    */
-  createAll(data: readonly ResolvedCreateInput<TContract, ModelName, State['variantName'], State['nsId']>[], configure?: (meta: MetaBuilder<'write'>) => void): AsyncIterableResult<Row>;
+  createAll(data: readonly ResolvedScalarCreateInput<TContract, ModelName, State['variantName'], State['nsId']>[], configure?: (meta: MetaBuilder<'write'>) => void): AsyncIterableResult<Row>;
   /**
    * Write terminal: insert many rows without materializing the
    * inserted rows, returning the number of inserted records.
@@ -1195,7 +1230,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *
    * 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['variantName'], State['nsId']>[], configure?: (meta: MetaBuilder<'write'>) => void): Promise<number>;
   /**
    * Write terminal: insert a row, or update the existing row on
    * conflict. Returns the resulting row (the inserted one or the
@@ -1229,7 +1264,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * Not supported on MTI variants.
    */
   upsert(input: {
-    create: ResolvedCreateInput<TContract, ModelName, State['variantName']>;
+    create: ResolvedScalarCreateInput<TContract, ModelName, State['variantName'], State['nsId']>;
     update: Partial<DefaultModelRow<TContract, ModelName>>;
     conflictOn?: UniqueConstraintCriterion<TContract, ModelName>;
   }, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row>;
@@ -1239,12 +1274,13 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * 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.
+   * 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:
@@ -1266,9 +1302,9 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *
    * 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.
+   * `withMutationScope`. In that path the `configure` callback still runs, so `meta.annotate`
+   * validation applies, but the recorded annotations are discarded: neither the nested
+   * statements nor the read-back query carry them.
    */
   update(data: State['hasWhere'] extends true ? MutationUpdateInput<TContract, ModelName, State['nsId']> : never, configure?: (meta: MetaBuilder<'write'>) => void): Promise<Row | null>;
   /**
@@ -1392,7 +1428,7 @@ declare function not(expr: AnyExpression): 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, VariantName extends string | undefined = undefined, NsId extends string = string>(context: ExecutionContext<TContract>, namespaceId: NsId, modelName: ModelName, variantName?: VariantName): VariantAwareModelAccessor<TContract, ModelName, VariantName, NsId>;
 //#endregion
 //#region src/orm.d.ts
 interface OrmOptions<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>> {