@prisma-next-idb/client-idb 0.1.0

package/dist/idb-orm-B5H6xka-.d.mts

@@ -0,0 +1,702 @@
+import { AsyncIterableResult } from "@prisma-next/framework-components/runtime";
+import { IdbFieldFilter, IdbFilterExpr, IdbNullCheckExpr, IdbQueryPlan } from "@prisma-next-idb/adapter-idb/runtime";
+import { Contract, ContractModelBase, ContractReferenceRelation } from "@prisma-next/contract/types";
+import { ExtractIdbFieldInputTypes, ExtractIdbFieldOutputTypes, IdbStorage } from "@prisma-next-idb/target-idb/pack";
+
+//#region src/core/types.d.ts
+/**
+ * Extract the model map from a contract by traversing the domain namespace.
+ *
+ * 0.14.0: `Contract` dropped the 2nd `TModels` type parameter; models are now
+ * accessed via `domain.namespaces[ns].models`. For a single-namespace contract
+ * (the only IDB case) this resolves to the typed model map; falls back to
+ * `Record<string, ContractModelBase>` for un-typed/multi-namespace inputs.
+ */
+type ModelsOf<TContract> = TContract extends {
+  readonly domain: {
+    readonly namespaces: infer NS;
+  };
+} ? NS[keyof NS] extends {
+  readonly models: infer M;
+} ? M extends Record<string, ContractModelBase> ? M : Record<string, ContractModelBase> : Record<string, ContractModelBase> : Record<string, ContractModelBase>;
+/**
+ * A `Contract` narrowed to the IDB storage shape. Accepts any contract whose
+ * `storage` block includes an `stores` record, regardless of the model set or
+ * whether type maps are attached.
+ */
+type IdbContract = Contract<IdbStorage>;
+/**
+ * Resolve the output row type for a model from the contract's type maps.
+ *
+ * When `fieldOutputTypes` is parameterised (the emitted contract carries
+ * `IdbContractWithTypeMaps<Base, IdbTypeMaps<Codecs, FieldOutputTypes, ...>>`),
+ * each field gets the exact TypeScript type emitted by the family (e.g. `Date`
+ * for `idb/date@1`).
+ *
+ * Falls back to `Record<string, unknown>` when type maps are absent (plain
+ * `IdbContract` or when the model name is not in the type maps).
+ */
+type NsFieldOutputTypes<TContract> = ExtractIdbFieldOutputTypes<TContract>[keyof ExtractIdbFieldOutputTypes<TContract>];
+type ResolvedOutputRow<TContract, ModelName extends string> = string extends keyof ExtractIdbFieldOutputTypes<TContract> ? Record<string, unknown> : NsFieldOutputTypes<TContract> extends Record<string, unknown> ? ModelName extends keyof NsFieldOutputTypes<TContract> ? { -readonly [K in keyof NsFieldOutputTypes<TContract>[ModelName]]: NsFieldOutputTypes<TContract>[ModelName][K] } : Record<string, unknown> : Record<string, unknown>;
+/**
+ * Resolve the input row type for a model from the contract's type maps.
+ *
+ * Mirrors `ResolvedOutputRow` but uses `fieldInputTypes` — the input types
+ * used for `create()`, `where()`, and mutation payloads.
+ */
+type NsFieldInputTypes<TContract> = ExtractIdbFieldInputTypes<TContract>[keyof ExtractIdbFieldInputTypes<TContract>];
+type ResolvedInputRow<TContract, ModelName extends string> = string extends keyof ExtractIdbFieldInputTypes<TContract> ? Record<string, unknown> : NsFieldInputTypes<TContract> extends Record<string, unknown> ? ModelName extends keyof NsFieldInputTypes<TContract> ? { -readonly [K in keyof NsFieldInputTypes<TContract>[ModelName]]: NsFieldInputTypes<TContract>[ModelName][K] } : Record<string, unknown> : Record<string, unknown>;
+/** The full TypeScript row shape returned by `all()`, `first()`, and `create()`. */
+type DefaultModelRow<TContract, ModelName extends string> = ResolvedOutputRow<TContract, ModelName>;
+/**
+ * Partial equality filter applied as an in-memory predicate during cursor scans.
+ *
+ * All fields are optional — only provided fields are checked. Values use the
+ * output types (from `fieldOutputTypes`) since the values are compared against
+ * decoded row data.
+ */
+type WhereFilter<TContract, ModelName extends string> = { readonly [K in keyof DefaultModelRow<TContract, ModelName>]?: DefaultModelRow<TContract, ModelName>[K] };
+/**
+ * The literal `keyPath` string for a model, extracted from
+ * `contract.models[ModelName].storage.keyPath`.
+ *
+ * Used at the type level to exclude the key field from `CreateInput` and to
+ * narrow the `findUnique` / `delete` key parameter type.
+ */
+type ModelKeyPath<TContract, ModelName extends string> = ModelName extends keyof ModelsOf<TContract> ? ModelsOf<TContract>[ModelName] extends {
+  storage: {
+    keyPath: infer P;
+  };
+} ? P extends string ? P : never : never : never;
+/**
+ * TypeScript type of the primary key field for a given model.
+ *
+ * When the output row type has a field matching `ModelKeyPath`, that field's
+ * type is used. Otherwise falls back to `IDBValidKey` (the DOM union of valid
+ * IDB key types).
+ */
+type KeyType<TContract, ModelName extends string> = ModelKeyPath<TContract, ModelName> extends keyof ResolvedOutputRow<TContract, ModelName> ? ResolvedOutputRow<TContract, ModelName>[ModelKeyPath<TContract, ModelName>] : IDBValidKey;
+/** The keyPath field when it exists in the resolved input row (may be absent for models with no typed maps). */
+type KeyPathField<TContract, ModelName extends string> = ModelKeyPath<TContract, ModelName> & keyof ResolvedInputRow<TContract, ModelName>;
+/**
+ * Input shape for `create()`: the full input row with the primary key field
+ * made optional (IDB can generate keys via `autoIncrement`, or clients may
+ * omit the key when using `cuid()` / `uuid()` at the application layer).
+ */
+type CreateInput<TContract, ModelName extends string> = Omit<ResolvedInputRow<TContract, ModelName>, ModelKeyPath<TContract, ModelName>> & Partial<Pick<ResolvedInputRow<TContract, ModelName>, KeyPathField<TContract, ModelName>>>;
+/** Extract the relations record for a model. */
+type ModelRelations<TContract, ModelName extends string> = ModelName extends keyof ModelsOf<TContract> ? ModelsOf<TContract>[ModelName] extends {
+  relations: infer R;
+} ? R extends Record<string, unknown> ? R : Record<string, never> : Record<string, never> : Record<string, never>;
+/**
+ * Union of relation keys on a model that are `ContractReferenceRelation`s
+ * (i.e. cross-store joins, not embedded documents).
+ *
+ * Used to constrain the `include()` method's `relation` parameter to only
+ * valid reference relation names.
+ */
+type ReferenceRelKeys<TContract, ModelName extends string> = { [K in keyof ModelRelations<TContract, ModelName>]: ModelRelations<TContract, ModelName>[K] extends ContractReferenceRelation ? K : never }[keyof ModelRelations<TContract, ModelName>] & string;
+/**
+ * TypeScript row type for an included relation.
+ *
+ * - `1:N` cardinality → `RelatedRow[]`
+ * - `N:1` or `1:1` cardinality → `RelatedRow | null`
+ */
+type RelationRowType<TContract, ModelName extends string, RelKey extends string> = RelKey extends keyof ModelRelations<TContract, ModelName> ? ModelRelations<TContract, ModelName>[RelKey] extends ContractReferenceRelation ? ModelRelations<TContract, ModelName>[RelKey] extends {
+  to: {
+    model: infer To extends string;
+  };
+  cardinality: infer C;
+} ? C extends "1:N" ? DefaultModelRow<TContract, To>[] : DefaultModelRow<TContract, To> | null : never : never : never;
+/**
+ * Per-relation include marker tracked at the type level.
+ *
+ * - `true` — the relation is loaded as rows (array for `1:N`, single/null
+ *   otherwise), optionally refined by a `where`/`orderBy`/`take` callback.
+ * - `"scalar"` — the relation is reduced to a `count()` (Phase 6.5), so the
+ *   row field becomes a `number` instead of related rows.
+ */
+type IncludeMarker = true | "scalar";
+/** Which relations are included in the current accessor chain. */
+type IncludeSpec<TContract, ModelName extends string> = Partial<Record<ReferenceRelKeys<TContract, ModelName>, IncludeMarker>>;
+/** Empty include spec — no relations included. */
+type NoIncludes = Record<never, never>;
+/**
+ * The relation fields contributed by a set of `.include()` calls.
+ *
+ * A key is added only when its `TIncludes` marker is set; the field type is
+ * `number` for a scalar `count()` include and the cardinality-shaped related
+ * row(s) otherwise. Split out from {@link IncludedRow} so {@link SelectedRow}
+ * can re-use it on top of a projected (picked) scalar base.
+ */
+type IncludeFields<TContract, ModelName extends string, TIncludes extends IncludeSpec<TContract, ModelName>> = { -readonly [K in keyof TIncludes & string as TIncludes[K] extends IncludeMarker ? K : never]: TIncludes[K] extends "scalar" ? number : RelationRowType<TContract, ModelName, K> };
+/**
+ * A row type that merges the base model row with any included relation fields.
+ *
+ * The extra fields are only added when the corresponding key in `TIncludes` is
+ * set, so the type stays narrow until `.include()` is called.
+ */
+type IncludedRow<TContract, ModelName extends string, TIncludes extends IncludeSpec<TContract, ModelName>> = DefaultModelRow<TContract, ModelName> & IncludeFields<TContract, ModelName, TIncludes>;
+/**
+ * The row type after an optional `.select()` projection.
+ *
+ * When `TSelected` is `never` (no `.select()` call) the full {@link IncludedRow}
+ * is returned. Otherwise the scalar base is narrowed to the picked fields, with
+ * any included relation fields preserved (mirrors the vendor `select()` which
+ * keeps relations and narrows only scalar columns).
+ */
+type SelectedRow<TContract, ModelName extends string, TIncludes extends IncludeSpec<TContract, ModelName>, TSelected extends string> = [TSelected] extends [never] ? IncludedRow<TContract, ModelName, TIncludes> : Pick<DefaultModelRow<TContract, ModelName>, TSelected & keyof DefaultModelRow<TContract, ModelName>> & IncludeFields<TContract, ModelName, TIncludes>;
+/**
+ * Partial update shape for `update()`, `updateAll()`, `updateCount()`, and the
+ * `update` arm of `upsert()`. All fields are optional — only provided fields
+ * are shallow-merged onto the existing record.
+ */
+type PatchInput<TContract, ModelName extends string> = Partial<DefaultModelRow<TContract, ModelName>>;
+/** Extracts the `to` model name for a named relation on a model. */
+type RelatedModelOf<TContract, ModelName extends string, RelName extends string> = ModelName extends keyof ModelsOf<TContract> ? ModelsOf<TContract>[ModelName] extends {
+  relations: Record<RelName, {
+    to: {
+      model: infer To extends string;
+    };
+  }>;
+} ? To : string : string;
+/** Nested-create descriptor: insert one or more related records. */
+interface RelationMutationCreate<TContract, ModelName extends string> {
+  readonly kind: "create";
+  readonly data: readonly CreateInput<TContract, ModelName>[];
+}
+/** Nested-connect descriptor: link existing records to the parent via FK update. */
+interface RelationMutationConnect {
+  readonly kind: "connect";
+  readonly criteria: readonly Record<string, unknown>[];
+}
+/**
+ * Nested-disconnect descriptor: unlink related records by setting FK to null.
+ * With no criteria, disconnects all child records from this parent.
+ */
+interface RelationMutationDisconnect {
+  readonly kind: "disconnect";
+  readonly criteria?: readonly Record<string, unknown>[];
+}
+/** Discriminated union of all nested relation mutation descriptors. */
+type IdbRelationMutation<TContract, ModelName extends string> = RelationMutationCreate<TContract, ModelName> | RelationMutationConnect | RelationMutationDisconnect;
+/** Relation mutator object passed to the user's relation callback. */
+interface IdbRelationMutator<TContract, ModelName extends string> {
+  create(data: CreateInput<TContract, ModelName> | readonly CreateInput<TContract, ModelName>[]): RelationMutationCreate<TContract, ModelName>;
+  connect(criteria: Record<string, unknown> | readonly Record<string, unknown>[]): RelationMutationConnect;
+  disconnect(criteria?: readonly Record<string, unknown>[]): RelationMutationDisconnect;
+}
+/**
+ * Maps each reference relation key to an optional mutation callback.
+ *
+ * When `ReferenceRelKeys` widens to `string` (a loosely-typed `IdbContract`
+ * with no emitted type maps), a naive mapped type would become an index
+ * signature `{ [k: string]: callback }` that incorrectly forces *every* field —
+ * scalars included — to be a relation callback, so even `create({ name: "x" })`
+ * would fail to type-check. The `string extends …` guard detects that case and
+ * contributes no constraint (`& unknown` is identity), leaving plain scalar
+ * payloads valid. Precisely-typed contracts (the emitted `contract.d.ts`)
+ * resolve `ReferenceRelKeys` to a finite union and get the full callback typing.
+ */
+type RelationMutationFields<TContract, ModelName extends string> = string extends ReferenceRelKeys<TContract, ModelName> ? unknown : Partial<{ [K in ReferenceRelKeys<TContract, ModelName>]: (mutator: IdbRelationMutator<TContract, RelatedModelOf<TContract, ModelName, K>>) => IdbRelationMutation<TContract, RelatedModelOf<TContract, ModelName, K>> }>;
+/**
+ * The `localFields` of all N:1 relations on a model — the FK fields that are
+ * owned by this model and can be supplied via a relation callback instead of
+ * as a scalar value. Resolves to `never` for loosely-typed contracts where
+ * cardinality is not preserved as a literal (e.g. `defineContract` in tests).
+ *
+ * Mirrors `ChildForeignKeyFieldNames` from `sql-orm-client`, simplified: instead
+ * of crawling all models for relations pointing *to* this one, we look at this
+ * model's own N:1 relations directly — same field set, one model.
+ */
+type N1LocalFieldNames<TContract, ModelName extends string> = { [K in keyof ModelRelations<TContract, ModelName>]: ModelRelations<TContract, ModelName>[K] extends {
+  readonly cardinality: "N:1";
+  readonly on: {
+    readonly localFields: infer Fields extends readonly string[];
+  };
+} ? Fields[number] : never }[keyof ModelRelations<TContract, ModelName>] & string;
+/**
+ * Like `CreateInput` but with N:1 FK fields made optional.
+ *
+ * An N:1 FK field (e.g. `authorId` on `Post`) can be supplied either as a
+ * scalar value or via a relation callback (`author: (rel) => rel.connect({id})`).
+ * Making it optional here lets callers omit it when using the callback form —
+ * the executor populates it from the related record before inserting.
+ *
+ * Mirrors `NestedCreateInput` from `sql-orm-client`.
+ */
+type NestedCreateInput<TContract, ModelName extends string> = Omit<CreateInput<TContract, ModelName>, N1LocalFieldNames<TContract, ModelName>> & Partial<Pick<CreateInput<TContract, ModelName>, N1LocalFieldNames<TContract, ModelName> & keyof CreateInput<TContract, ModelName>>>;
+/**
+ * Input shape for `create()` with optional relation callbacks.
+ * N:1 FK fields (e.g. `authorId`) are optional when using a relation callback.
+ * Relation fields accept a callback `(rel) => rel.create([...])` / `rel.connect(...)`.
+ */
+type MutationCreateInput<TContract, ModelName extends string> = NestedCreateInput<TContract, ModelName> & RelationMutationFields<TContract, ModelName>;
+/**
+ * Input shape for `update()` with optional relation callbacks.
+ * All scalar fields are optional (shallow merge); relation fields accept
+ * `connect` or `disconnect` callbacks.
+ */
+type MutationUpdateInput<TContract, ModelName extends string> = PatchInput<TContract, ModelName> & RelationMutationFields<TContract, ModelName>;
+/** Sort direction for `orderBy()`. */
+type SortDirection = "asc" | "desc";
+/** Partial sort spec: field name → direction. */
+type OrderBySpec<TContract, ModelName extends string> = Partial<Record<string & keyof DefaultModelRow<TContract, ModelName>, SortDirection>>;
+/** The five aggregation functions, matching the vendor `AggregateFn`. */
+type AggregateFn = "count" | "sum" | "avg" | "min" | "max";
+/**
+ * Fields eligible for numeric aggregation (`sum`/`avg`/`min`/`max`).
+ *
+ * For an emitted (precisely-typed) contract this narrows to the fields whose
+ * output type is assignable to `number`. For a loosely-typed `IdbContract`
+ * (no type maps — `DefaultModelRow` is `Record<string, unknown>`) the row key
+ * set widens to `string`, so we allow any field name rather than collapsing to
+ * `never`. Mirrors `NumericFieldNames` from `sql-orm-client`, trait-free.
+ */
+type NumericFieldNames<TContract, ModelName extends string> = string extends keyof DefaultModelRow<TContract, ModelName> ? string : { [K in keyof DefaultModelRow<TContract, ModelName> & string]: NonNullable<DefaultModelRow<TContract, ModelName>[K]> extends number ? K : never }[keyof DefaultModelRow<TContract, ModelName> & string];
+declare const idbAggregateResultBrand: unique symbol;
+/**
+ * A single aggregation selector produced by the {@link IdbAggregateBuilder}.
+ *
+ * The phantom `Result` brand carries the per-selector result type so
+ * {@link IdbAggregateResult} can map each alias back to its value type.
+ * Mirrors the vendor `AggregateSelector`.
+ */
+interface IdbAggregateSelector<Result> {
+  readonly kind: "aggregate";
+  readonly fn: AggregateFn;
+  readonly field?: string;
+  readonly [idbAggregateResultBrand]?: Result;
+}
+/** A map of result aliases → aggregation selectors (the `aggregate()` spec). */
+type IdbAggregateSpec = Record<string, IdbAggregateSelector<unknown>>;
+/** The result row shape for an {@link IdbAggregateSpec}: alias → value type. */
+type IdbAggregateResult<Spec extends IdbAggregateSpec> = { [K in keyof Spec]: Spec[K] extends IdbAggregateSelector<infer Result> ? Result : never };
+/**
+ * The builder handed to an `.aggregate(agg => …)` callback. `count()` is always
+ * available; the field reducers are constrained to {@link NumericFieldNames}.
+ * Mirrors the vendor `AggregateBuilder`, minus the SQL column mapping.
+ */
+interface IdbAggregateBuilder<TContract, ModelName extends string> {
+  count(): IdbAggregateSelector<number>;
+  sum<F extends NumericFieldNames<TContract, ModelName>>(field: F): IdbAggregateSelector<number | null>;
+  avg<F extends NumericFieldNames<TContract, ModelName>>(field: F): IdbAggregateSelector<number | null>;
+  min<F extends NumericFieldNames<TContract, ModelName>>(field: F): IdbAggregateSelector<number | null>;
+  max<F extends NumericFieldNames<TContract, ModelName>>(field: F): IdbAggregateSelector<number | null>;
+}
+//#endregion
+//#region src/core/executor.d.ts
+/**
+ * Thin executor interface for the IDB ORM client.
+ *
+ * Any object with a compatible `execute()` method satisfies this interface,
+ * including `IdbRuntime` from `@prisma-next-idb/runtime-idb`. The separation
+ * avoids a direct dependency on `runtime-idb`, keeping `client-idb` composable
+ * and independently testable.
+ *
+ * @example
+ * ```ts
+ * import { createIdbRuntime } from "@prisma-next-idb/runtime-idb/runtime";
+ * const runtime = createIdbRuntime({ adapter, driver });
+ * const client = idbOrm({ contract, executor: runtime }); // runtime satisfies IdbQueryExecutor
+ * ```
+ */
+interface IdbQueryExecutor {
+  execute<Row>(plan: IdbQueryPlan<Row>): AsyncIterableResult<Row>;
+}
+//#endregion
+//#region src/core/model-accessor.d.ts
+/**
+ * Operator surface available on every field. All return frozen AST nodes
+ * — they are values, not statements, so chaining and logical combinators
+ * compose naturally.
+ */
+interface IdbFieldAccessor<T> {
+  eq(value: T): IdbFieldFilter;
+  neq(value: T): IdbFieldFilter;
+  gt(value: T): IdbFieldFilter;
+  lt(value: T): IdbFieldFilter;
+  gte(value: T): IdbFieldFilter;
+  lte(value: T): IdbFieldFilter;
+  in(values: ReadonlyArray<T>): IdbFieldFilter;
+  notIn(values: ReadonlyArray<T>): IdbFieldFilter;
+  contains(sub: string): IdbFieldFilter;
+  startsWith(sub: string): IdbFieldFilter;
+  endsWith(sub: string): IdbFieldFilter;
+  isNull(): IdbNullCheckExpr;
+  isNotNull(): IdbNullCheckExpr;
+}
+/**
+ * The accessor object handed to a `where(fn)` callback. Each key resolves
+ * to an {@link IdbFieldAccessor} typed against the field's output type.
+ *
+ * The Proxy makes every string key resolve to an accessor at runtime; the
+ * type narrows the visible surface to the model's declared fields so the
+ * developer gets autocomplete.
+ */
+type IdbModelAccessor<TContract, ModelName extends string> = { readonly [K in keyof DefaultModelRow<TContract, ModelName>]-?: IdbFieldAccessor<DefaultModelRow<TContract, ModelName>[K]> };
+//#endregion
+//#region src/core/store-state.d.ts
+/**
+ * One entry in {@link IdbAccessorState.includes} — describes how a single
+ * `.include()`d relation should be materialised.
+ *
+ * - `collection`: load the related rows, applying the refined `state`
+ *   (its `filters` / `orderBy` / `skip` / `take`) to the child scan.
+ *   `state` is `emptyAccessorState()` for an unrefined `.include(rel)`.
+ * - `scalar`: reduce the related rows to a single number (Phase 6.5 supports
+ *   `count`). The `state.filters` still constrain which children are counted.
+ *
+ * Mirrors the `IncludeExpr` / `IncludeScalar` split from
+ * `vendor/prisma-next/.../sql-orm-client`, collapsed to the two shapes IDB
+ * needs (no SQL column mapping, no `combine()` branches).
+ */
+type IncludeEntry = {
+  readonly kind: "collection";
+  readonly state: IdbAccessorState;
+} | {
+  readonly kind: "scalar";
+  readonly fn: "count";
+  readonly state: IdbAccessorState;
+};
+/**
+ * Marker returned by the child accessor's `.count()` terminal when it is
+ * called inside an `include()` refinement callback. Carries the refined
+ * child `state` so the relation loader counts only the matching children.
+ *
+ * Detected by {@link isIncludeScalar}; mirrors `IncludeScalar` from the
+ * vendor `sql-orm-client/include-descriptors.ts`.
+ */
+interface IdbIncludeScalar {
+  readonly kind: "includeScalar";
+  readonly fn: "count";
+  readonly state: IdbAccessorState;
+}
+/**
+ * Immutable state carried by each {@link IdbStoreAccessorImpl} node in the
+ * builder chain.
+ *
+ * Every mutating method (`.where()`, `.take()`, etc.) returns a cloned
+ * instance with an updated state rather than mutating in place, making the
+ * accessor safe to reuse across multiple query branches.
+ */
+interface IdbAccessorState {
+  /**
+   * Accumulated filter expressions. Multiple `.where()` calls compose
+   * with AND semantics — the planner wraps them in an `andExpr` when
+   * lowering. Each entry is already either an `IdbFieldFilter`, a
+   * combinator, or a `null-check` node — never raw shorthand records.
+   */
+  readonly filters: ReadonlyArray<IdbFilterExpr>;
+  /** Sort spec: field → direction. Applied as an in-memory comparator. */
+  readonly orderBy?: Record<string, "asc" | "desc">;
+  /** OFFSET (number of rows to skip). */
+  readonly skip?: number;
+  /** LIMIT (maximum number of rows to return). */
+  readonly take?: number;
+  /**
+   * Relations that have been `.include()`d — keys are relation names, values
+   * describe how to materialise each (collection vs scalar count, plus any
+   * refinement state). See {@link IncludeEntry}.
+   */
+  readonly includes: Record<string, IncludeEntry>;
+  /**
+   * Fields kept by `.select()`. `undefined` means "all fields". When set,
+   * the materialised rows are projected down to these fields (plus any
+   * included relation keys) after the scan and relation loads complete.
+   */
+  readonly selectedFields?: ReadonlyArray<string>;
+}
+//#endregion
+//#region src/core/grouped-accessor.d.ts
+/**
+ * One grouped-aggregate result row: the group-key fields picked from the model
+ * row, intersected with the aggregate aliases.
+ */
+type GroupedResultRow<TContract, ModelName extends string, Fields extends readonly string[], Spec extends IdbAggregateSpec> = Pick<DefaultModelRow<TContract, ModelName>, Fields[number] & keyof DefaultModelRow<TContract, ModelName>> & IdbAggregateResult<Spec>;
+/**
+ * Grouped-aggregate builder returned by `accessor.groupBy(...)`.
+ *
+ * Port of the vendor `GroupedCollection` (`sql-orm-client/grouped-collection.ts`),
+ * but purely in-memory: there is no SQL compilation, so `aggregate()`
+ * materialises the matching rows, partitions them by the group-key fields, and
+ * reduces each partition with the requested selectors.
+ */
+interface IdbGroupedAccessor<TContract, ModelName extends string, Fields extends readonly string[]> {
+  /**
+   * Reduce each group to one row of `{ ...groupKeyFields, ...aggregates }`.
+   *
+   * @example
+   * ```ts
+   * const byUser = await db.posts
+   *   .where({ published: true })
+   *   .groupBy("authorId")
+   *   .aggregate((agg) => ({ count: agg.count(), totalViews: agg.sum("views") }));
+   * // [{ authorId: "u1", count: 3, totalViews: 120 }, ...]
+   * ```
+   */
+  aggregate<Spec extends IdbAggregateSpec>(fn: (agg: IdbAggregateBuilder<TContract, ModelName>) => Spec): Promise<Array<GroupedResultRow<TContract, ModelName, Fields, Spec>>>;
+}
+//#endregion
+//#region src/core/store-accessor.d.ts
+/** Callback form of `.where(fn)` — receives the typed model accessor proxy. */
+type WhereCallback<TContract, ModelName extends string> = (m: IdbModelAccessor<TContract, ModelName>) => IdbFilterExpr;
+/** Tuple of one-or-more field names of a model (for `select()` / `groupBy()`). */
+type FieldTuple<TContract, ModelName extends string> = readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]];
+/**
+ * The child accessor handed to an `include()` refinement callback.
+ *
+ * Exposes the chainable narrowing methods (`where` / `orderBy` / `take` /
+ * `skip`) plus the scalar `count()` reducer. Mirrors the vendor
+ * `IncludeRefinementCollection`: chainable methods return the same refinement
+ * surface so `count()` stays reachable after a `where()`, and `count()` returns
+ * an {@link IdbIncludeScalar} marker rather than the async terminal `count()`
+ * found on the top-level accessor.
+ */
+interface IdbIncludeRefinementAccessor<TContract, ModelName extends string> {
+  where(filter: WhereFilter<TContract, ModelName> | WhereCallback<TContract, ModelName>): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  orderBy(spec: OrderBySpec<TContract, ModelName>): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  take(n: number): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  skip(n: number): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  count(): IdbIncludeScalar;
+}
+/** Refinement callback type for a given relation key `K`. */
+type IncludeRefineFn<TContract, ModelName extends string, K extends string, R> = (collection: IdbIncludeRefinementAccessor<TContract, RelatedModelOf<TContract, ModelName, K>>) => R;
+/**
+ * Immutable query-builder for a single IDB object store.
+ *
+ * Each method that narrows the query (`.where()`, `.take()`, etc.) returns a
+ * new, independent accessor instance — the original is never mutated. This
+ * mirrors the `MongoCollection` pattern from `@prisma-next/2-mongo-family`.
+ *
+ * @template TContract   - The full IDB contract (with or without type maps).
+ * @template ModelName   - The model (store) this accessor targets.
+ * @template TIncludes   - Tracks which relations have been included via
+ *   `.include()` calls, so the return type widens progressively.
+ * @template TSelected   - Field names kept by `.select()`. `never` (the
+ *   default) means "all fields"; otherwise the row narrows to these fields
+ *   (plus any included relations).
+ */
+interface IdbStoreAccessor<TContract, ModelName extends string, TIncludes extends IncludeSpec<TContract, ModelName> = NoIncludes, TSelected extends string = never> {
+  /**
+   * Add a filter (ANDed with any previous `.where()` calls).
+   *
+   * Two forms:
+   *
+   * - **Shorthand**: `where({ field: value })` — multi-key shorthand
+   *   objects compose as AND. `null` values become null-checks rather
+   *   than literal-null equalities so absent fields match.
+   * - **Callback**: `where((m) => m.field.op(value))` — receives the
+   *   typed model accessor proxy and returns an `IdbFilterExpr` built
+   *   via the operator surface. Combinators (`and`, `or`, `not` from
+   *   `@prisma-next-idb/client-idb/orm`) compose nodes.
+   */
+  where(filter: WhereFilter<TContract, ModelName> | WhereCallback<TContract, ModelName>): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /** Set the sort order. Replaces any previous `.orderBy()` call. */
+  orderBy(spec: OrderBySpec<TContract, ModelName>): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /** Limit the number of rows returned. */
+  take(n: number): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /** Skip the first `n` rows (OFFSET). */
+  skip(n: number): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /**
+   * Include a reference relation in the returned rows.
+   *
+   * The relation is loaded via a single batch cursor scan after the main
+   * query — O(1) round trips to IDB per included relation regardless of
+   * the number of parent rows. The return type gains the relation field
+   * automatically.
+   *
+   * An optional refinement callback narrows the loaded relation:
+   *
+   * - return the (chained) collection to apply `where` / `orderBy` /
+   *   `take` / `skip` to the related rows (per-parent for `1:N`);
+   * - return `collection.count()` to reduce a to-many relation to the
+   *   number of matching children (the field becomes a `number`).
+   *
+   * @example
+   * ```ts
+   * db.users.include("posts", (posts) => posts.where({ published: true }).take(5))
+   * db.users.include("posts", (posts) => posts.count())
+   * ```
+   */
+  include<K extends ReferenceRelKeys<TContract, ModelName>>(relation: K, refineFn?: IncludeRefineFn<TContract, ModelName, K, IdbIncludeRefinementAccessor<TContract, RelatedModelOf<TContract, ModelName, K>>>): IdbStoreAccessor<TContract, ModelName, TIncludes & Record<K, true>, TSelected>;
+  include<K extends ReferenceRelKeys<TContract, ModelName>>(relation: K, refineFn: IncludeRefineFn<TContract, ModelName, K, IdbIncludeScalar>): IdbStoreAccessor<TContract, ModelName, TIncludes & Record<K, "scalar">, TSelected>;
+  /**
+   * Project the row down to a subset of scalar fields. Any previously
+   * `.include()`d relations are preserved on the result; only the scalar
+   * fields are narrowed.
+   *
+   * @example
+   * ```ts
+   * const summaries = await db.users.select("id", "email").all();
+   * // typeof summaries[number] === { id: string; email: string }
+   * ```
+   */
+  select<Fields extends FieldTuple<TContract, ModelName>>(...fields: Fields): IdbStoreAccessor<TContract, ModelName, TIncludes, Fields[number]>;
+  /** Return all matching rows as an async iterable (also awaitable as `Row[]`). */
+  all(): AsyncIterableResult<SelectedRow<TContract, ModelName, TIncludes, TSelected>>;
+  /** Return the first matching row, or `null` if none match. */
+  first(): Promise<SelectedRow<TContract, ModelName, TIncludes, TSelected> | null>;
+  /**
+   * Run an in-memory aggregate (count/sum/avg/min/max) over the rows matching
+   * the accumulated `.where()` filter. Returns one result object keyed by the
+   * aliases supplied in the spec.
+   *
+   * @example
+   * ```ts
+   * const stats = await db.posts.where({ published: true }).aggregate((agg) => ({
+   *   total: agg.count(),
+   *   avgViews: agg.avg("views"),
+   * }));
+   * ```
+   */
+  aggregate<Spec extends IdbAggregateSpec>(fn: (agg: IdbAggregateBuilder<TContract, ModelName>) => Spec): Promise<IdbAggregateResult<Spec>>;
+  /**
+   * Switch to grouped-aggregate mode. The returned {@link IdbGroupedAccessor}'s
+   * `.aggregate(...)` terminal produces one row per group with the chosen key
+   * fields plus the requested aggregates.
+   *
+   * @example
+   * ```ts
+   * const byUser = await db.posts
+   *   .where({ published: true })
+   *   .groupBy("authorId")
+   *   .aggregate((agg) => ({ count: agg.count(), totalViews: agg.sum("views") }));
+   * ```
+   */
+  groupBy<Fields extends FieldTuple<TContract, ModelName>>(...fields: Fields): IdbGroupedAccessor<TContract, ModelName, Fields>;
+  /**
+   * Insert a record into the store and return the stored row.
+   *
+   * The primary key field is optional in `data` — pass it to use a
+   * client-generated ID (`cuid`, `uuid`) or omit it for auto-increment stores.
+   *
+   * Relation fields accept a mutation callback:
+   * `posts: (rel) => rel.create([...])` or `author: (rel) => rel.connect({ id })`.
+   * When any relation callback is present, all writes are wrapped in a single
+   * multi-store IDB transaction (requires IdbRuntime, not a plain executor).
+   */
+  create(data: MutationCreateInput<TContract, ModelName>): Promise<DefaultModelRow<TContract, ModelName>>;
+  /** Look up a single row by primary key. Returns `null` if not found. */
+  findUnique(key: KeyType<TContract, ModelName>): Promise<DefaultModelRow<TContract, ModelName> | null>;
+  /** Delete the row with the given primary key. */
+  delete(key: KeyType<TContract, ModelName>): Promise<void>;
+  /**
+   * Update the first row matching the accumulated `.where()` filter.
+   * Returns the merged row, or `null` if no row matches.
+   *
+   * Relation fields accept `connect` or `disconnect` callbacks. When any
+   * relation callback is present, all writes run in a single multi-store
+   * IDB transaction (requires IdbRuntime).
+   */
+  update(patch: MutationUpdateInput<TContract, ModelName>): Promise<DefaultModelRow<TContract, ModelName> | null>;
+  /**
+   * Update all rows matching the accumulated `.where()` filter and return
+   * them as an `AsyncIterableResult` (also awaitable as `Row[]`).
+   */
+  updateAll(patch: PatchInput<TContract, ModelName>): AsyncIterableResult<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Update all rows matching the accumulated `.where()` filter.
+   * Returns the count of updated rows.
+   */
+  updateCount(patch: PatchInput<TContract, ModelName>): Promise<number>;
+  /**
+   * Insert or update a single record.
+   *
+   * - If a row matching `where` exists: shallow-merge `update` onto it and
+   *   return the merged row.
+   * - If no matching row exists: insert `create` and return it.
+   */
+  upsert(args: {
+    create: CreateInput<TContract, ModelName>;
+    update: PatchInput<TContract, ModelName>;
+    where: WhereFilter<TContract, ModelName>;
+  }): Promise<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Insert multiple records in a single atomic transaction.
+   * Returns all inserted rows as an `AsyncIterableResult`.
+   */
+  createAll(data: CreateInput<TContract, ModelName>[]): AsyncIterableResult<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Insert multiple records in a single atomic transaction.
+   * Returns the count of inserted rows.
+   */
+  createCount(data: CreateInput<TContract, ModelName>[]): Promise<number>;
+  /**
+   * Delete all rows matching the accumulated `.where()` filter.
+   * Returns the deleted rows as an `AsyncIterableResult`.
+   */
+  deleteAll(): AsyncIterableResult<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Delete all rows matching the accumulated `.where()` filter.
+   * Returns the count of deleted rows.
+   */
+  deleteCount(): Promise<number>;
+  /**
+   * Count all rows matching the accumulated `.where()` filter.
+   * With no filter, counts all rows in the store.
+   *
+   * **Note — `skip`/`take` are respected**: unlike Prisma's SQL `count()`,
+   * which ignores pagination, this implementation reuses the same cursor-scan
+   * plan as `all()`. That means `where(...).take(5).count()` returns at most 5,
+   * not the total number of matching rows. Use `where(...).count()` without
+   * `take`/`skip` when you need an unbounded total.
+   */
+  count(): Promise<number>;
+}
+//#endregion
+//#region src/core/idb-orm.d.ts
+/**
+ * The ORM client object returned by {@link idbOrm}.
+ *
+ * Keys are the root keys from `contract.roots` (e.g. `"users"`, `"posts"`).
+ * Each value is an {@link IdbStoreAccessor} targeting the corresponding model.
+ *
+ * @example
+ * ```ts
+ * const db = idbOrm({ contract, executor: runtime });
+ * const users = await db.users.all(); // IdbStoreAccessor<..., "User">
+ * ```
+ */
+type IdbOrmClient<TContract extends Contract<IdbStorage>> = { readonly [K in string & keyof TContract["roots"]]: TContract["roots"][K] extends {
+  model: infer ModelName extends string;
+} ? IdbStoreAccessor<TContract, ModelName> : never };
+/**
+ * Options for {@link idbOrm}.
+ */
+interface IdbOrmOptions<TContract extends IdbContract> {
+  /** The resolved IDB contract (with or without attached type maps). */
+  readonly contract: TContract;
+  /**
+   * The query executor.
+   *
+   * Any object with a compatible `execute()` signature satisfies this —
+   * most commonly an `IdbRuntime` created via `createIdbRuntime()`.
+   */
+  readonly executor: IdbQueryExecutor;
+}
+/**
+ * Create a typed IDB ORM client from a contract and executor.
+ *
+ * The client exposes one `IdbStoreAccessor` per entry in `contract.roots`.
+ * Only roots-declared stores are accessible at the top level — other stores
+ * can be reached via `.include()` on any accessor.
+ *
+ * @example
+ * ```ts
+ * import { idbOrm } from "@prisma-next-idb/client-idb/orm";
+ * import { createIdbRuntime } from "@prisma-next-idb/runtime-idb/runtime";
+ * import contract from "./prisma/idb-contract";
+ *
+ * const runtime = createIdbRuntime({ adapter, driver });
+ * const db = idbOrm({ contract, executor: runtime });
+ *
+ * // Typed query builder:
+ * const alice = await db.users.where({ email: "alice@example.com" }).first();
+ * const postsWithAuthor = await db.posts.include("author").all();
+ * ```
+ */
+declare function idbOrm<TContract extends IdbContract>(options: IdbOrmOptions<TContract>): IdbOrmClient<TContract>;
+//#endregion
+export { MutationUpdateInput as A, SelectedRow as B, IncludeFields as C, KeyType as D, IncludedRow as E, ReferenceRelKeys as F, WhereFilter as H, RelatedModelOf as I, RelationMutationConnect as L, NumericFieldNames as M, OrderBySpec as N, ModelKeyPath as O, PatchInput as P, RelationMutationCreate as R, IdbRelationMutator as S, IncludeSpec as T, SortDirection as V, IdbAggregateResult as _, IdbStoreAccessor as a, IdbContract as b, IdbGroupedAccessor as c, IdbModelAccessor as d, IdbQueryExecutor as f, IdbAggregateBuilder as g, DefaultModelRow as h, IdbIncludeRefinementAccessor as i, NoIncludes as j, MutationCreateInput as k, IdbIncludeScalar as l, CreateInput as m, IdbOrmOptions as n, WhereCallback as o, AggregateFn as p, idbOrm as r, GroupedResultRow as s, IdbOrmClient as t, IdbFieldAccessor as u, IdbAggregateSelector as v, IncludeMarker as w, IdbRelationMutation as x, IdbAggregateSpec as y, RelationMutationDisconnect as z };
+//# sourceMappingURL=idb-orm-B5H6xka-.d.mts.map