@prisma-idb/client-idb 0.9.1 → 0.10.0

package/dist/idb-orm-DsfllvzD.mjs

@@ -0,0 +1,1256 @@
+import { A as isValidIdbKey, C as assertEnumValues, D as getKeyPath, E as fieldValueToken, M as keyToken, O as getRelation, S as createMutationDefaultsCache, T as extractKeyFromRow, _ as requireTransactionExecutor, a as collectScalarFkStoreNames, b as applyCreateDefaults, c as executeDeleteWithReferentialActions, d as executeScalarCreateAllWithFkValidation, f as executeScalarCreateWithFkValidation, g as hasScalarFkFields, h as hasNestedMutationCallbacks, i as collectOnUpdateEnforcementStoreNames, k as getStoreName, l as executeNestedCreateMutation, m as hasEnforceableChildRelations, n as applyReferentialActionsForRowOnUpdate, o as executeBulkUpdateWithFkValidation, p as executeScalarUpdateWithFkValidation, s as executeDeleteAllWithReferentialActions, u as executeNestedUpdateMutation, v as validateScalarFks, w as buildFieldToIndexMap, x as applyUpdateDefaults, y as withMutationScope } from "./mutation-executor-CD5n_kKT.mjs";
+import { AsyncIterableResult } from "@prisma/orm-framework/components/runtime";
+import { andExpr, evaluateFilter, fieldFilter, nullCheckExpr, shorthandToFilterExpr } from "@prisma-idb/adapter-idb/runtime";
+import { domainModelsAtDefaultNamespace } from "@prisma/orm-framework/contract/types";
+import { compareFieldValues } from "@prisma-idb/target-idb/runtime";
+import { keyPathFields } from "@prisma-idb/target-idb/pack";
+//#region src/core/model-accessor.ts
+/**
+* Proxy-based typed accessor handed to `where(fn)` callbacks.
+*
+* Mirrors `createModelAccessor()` from
+* Prisma ORM's SQL client, but without
+* the codec-trait gating — IDB stores native JS values, so every operator
+* is available on every field. The runtime accessor object is a Proxy
+* that materialises an `IdbFieldAccessor` on demand for whichever field
+* name is read; the type-level surface narrows that to the model's
+* actual field set so callbacks get autocomplete.
+*/
+/**
+* Build an {@link IdbFieldAccessor} for a single field. The accessor is
+* shared via the proxy below, but each accessor instance is bound to its
+* own field name so the produced AST nodes carry the right field.
+*/
+function createFieldAccessor(field) {
+	return {
+		eq: (value) => fieldFilter(field, "eq", value),
+		neq: (value) => fieldFilter(field, "neq", value),
+		gt: (value) => fieldFilter(field, "gt", value),
+		lt: (value) => fieldFilter(field, "lt", value),
+		gte: (value) => fieldFilter(field, "gte", value),
+		lte: (value) => fieldFilter(field, "lte", value),
+		in: (values) => fieldFilter(field, "in", values),
+		notIn: (values) => fieldFilter(field, "notIn", values),
+		contains: (sub) => fieldFilter(field, "contains", sub),
+		startsWith: (sub) => fieldFilter(field, "startsWith", sub),
+		endsWith: (sub) => fieldFilter(field, "endsWith", sub),
+		isNull: () => nullCheckExpr(field, true),
+		isNotNull: () => nullCheckExpr(field, false)
+	};
+}
+/**
+* Create the typed model accessor used by `where(fn)` callbacks.
+*
+* Implemented as a Proxy keyed on field names — every read returns an
+* {@link IdbFieldAccessor} bound to that field. The accessor cache means
+* `m.name.eq(...)` and `m.name.startsWith(...)` reuse the same per-field
+* accessor object across the same `where()` invocation.
+*
+* The type parameter is structural — no contract is consulted at
+* runtime, because TS already gates the visible field set at compile
+* time. (Misspelled fields surface as accessor calls on names that
+* don't exist in stored rows, which is consistent with how the
+* shorthand form behaves today.)
+*/
+function createModelAccessor() {
+	const cache = /* @__PURE__ */ new Map();
+	return new Proxy({}, { get(_target, prop) {
+		if (typeof prop !== "string") return void 0;
+		let acc = cache.get(prop);
+		if (acc === void 0) {
+			acc = createFieldAccessor(prop);
+			cache.set(prop, acc);
+		}
+		return acc;
+	} });
+}
+//#endregion
+//#region src/core/store-state.ts
+/** Build an {@link IdbIncludeScalar} marker for a `count()` reducer. */
+function createIncludeScalar(state) {
+	return {
+		kind: "includeScalar",
+		fn: "count",
+		state
+	};
+}
+/** Type guard: is `value` an {@link IdbIncludeScalar} marker? */
+function isIncludeScalar(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return candidate.kind === "includeScalar" && candidate.fn === "count";
+}
+/** Create a fresh, empty accessor state (no filters, no ordering, no includes). */
+function emptyAccessorState() {
+	return {
+		filters: [],
+		includes: {}
+	};
+}
+/** Return a shallow-merged copy of `state` with the given overrides applied. */
+function mergeAccessorState(state, overrides) {
+	return {
+		...state,
+		...overrides
+	};
+}
+//#endregion
+//#region src/core/query-shaping.ts
+/**
+* Combine accumulated filter expressions with AND.
+*
+* Returns `undefined` when no filter is present so callers can skip building a
+* row-filter closure. Shared by {@link IdbStoreAccessorImpl} (top-level scans)
+* and the relation loader (refined `include()` child scans).
+*/
+function combineFilterExprs(filters) {
+	if (filters.length === 0) return void 0;
+	if (filters.length === 1) return filters[0];
+	return andExpr(filters);
+}
+/** Recursively flatten nested AND nodes into a single array of children. */
+function flattenAnd(filter) {
+	if (filter.kind !== "and") return [filter];
+	return filter.exprs.flatMap(flattenAnd);
+}
+/**
+* `true` when `field` is a *single-field* primary key that a lone `eq`
+* condition can directly point-range-query (`store.get`/`openCursor(range)`
+* against the store's own keyPath, no named index required).
+*
+* Deliberately `false` for a compound (array) `keyPath`, even if `field`
+* happens to be one of its member fields — a single `eq` condition can only
+* pin one member, not the whole compound key, so it can't drive a PK
+* point-range scan on its own. Accelerating that case needs *all* member
+* fields ANDed together, which is a cost-based multi-field planner decision
+* (Phase 10 §3.2), not this peephole optimizer's job.
+*/
+function isPrimaryKeyField(field, keyPath) {
+	return typeof keyPath === "string" && field === keyPath;
+}
+/**
+* Scan the combined filter expression for the first `eq` field condition whose
+* field either has a matching IDB index (`fieldToIndexName[field]` is set) or
+* *is* the store's own primary key (`keyPath`) — a store's keyPath is always
+* point-range-queryable directly, no named index required.
+*
+* When found, the indexed condition is peeled off and returned as an
+* {@link IndexEqualityHint}; any remaining conditions are preserved in
+* `remainingFilter`. Returns `null` when no usable index can be found.
+*
+* Nested AND nodes are flattened before scanning, so deeply-composed filters
+* are handled correctly. Only `eq` conditions are considered — range operators
+* (`gt`, `lt`, etc.) could also use an index range but that optimization is
+* not yet implemented.
+*/
+function extractIndexEqualityHint(filter, fieldToIndexName, keyPath) {
+	if (filter === void 0) return null;
+	if (filter.kind === "field" && filter.op === "eq") {
+		const indexName = fieldToIndexName[filter.field];
+		if ((indexName !== void 0 || isPrimaryKeyField(filter.field, keyPath)) && isValidIdbKey(filter.value)) return {
+			indexName,
+			value: filter.value,
+			remainingFilter: void 0
+		};
+		return null;
+	}
+	if (filter.kind === "and") {
+		const flat = flattenAnd(filter);
+		for (let i = 0; i < flat.length; i++) {
+			const expr = flat[i];
+			if (expr.kind === "field" && expr.op === "eq") {
+				const indexName = fieldToIndexName[expr.field];
+				if ((indexName !== void 0 || isPrimaryKeyField(expr.field, keyPath)) && isValidIdbKey(expr.value)) {
+					const rest = flat.filter((_, j) => j !== i);
+					return {
+						indexName,
+						value: expr.value,
+						remainingFilter: combineFilterExprs(rest)
+					};
+				}
+			}
+		}
+	}
+	return null;
+}
+/**
+* Check whether every branch of an OR node is a single `field eq value`
+* condition whose field has a matching index. Returns an {@link IndexOrHint}
+* when the whole OR can be satisfied by N point-range cursor scans, `null`
+* otherwise.
+*/
+function tryExtractOrBranches(orNode, fieldToIndexName, keyPath, remainingFilter) {
+	if (orNode.exprs.length === 0) return null;
+	const branches = [];
+	for (const expr of orNode.exprs) {
+		if (expr.kind !== "field" || expr.op !== "eq") return null;
+		const indexName = fieldToIndexName[expr.field];
+		if (indexName === void 0 && !isPrimaryKeyField(expr.field, keyPath) || !isValidIdbKey(expr.value)) return null;
+		branches.push({
+			indexName,
+			value: expr.value
+		});
+	}
+	return {
+		branches,
+		remainingFilter
+	};
+}
+/**
+* Attempt to extract an {@link IndexOrHint} from `filter`.
+*
+* Handles two shapes:
+* - Top-level `or` where every branch is `field eq value` on an indexed field.
+* - Top-level `and` (with nested ANDs flattened) that contains exactly one `or`
+*   child fitting the above pattern; the remaining AND children become
+*   `remainingFilter` applied in-memory after the union.
+*
+* Returns `null` when the filter cannot be accelerated via OR index scans.
+*/
+function extractIndexOrHint(filter, fieldToIndexName, keyPath) {
+	if (filter === void 0) return null;
+	if (filter.kind === "or") return tryExtractOrBranches(filter, fieldToIndexName, keyPath, void 0);
+	if (filter.kind === "and") {
+		const flat = flattenAnd(filter);
+		const orIndices = [];
+		for (let i = 0; i < flat.length; i++) if (flat[i].kind === "or") orIndices.push(i);
+		if (orIndices.length !== 1) return null;
+		const orIdx = orIndices[0];
+		const orNode = flat[orIdx];
+		return tryExtractOrBranches(orNode, fieldToIndexName, keyPath, combineFilterExprs(flat.filter((_, j) => j !== orIdx)));
+	}
+	return null;
+}
+/**
+* Build an in-memory comparator from an `orderBy` spec (field → direction).
+*
+* Returns `undefined` when there is nothing to sort by. Compares fields in
+* declaration order, with {@link compareFieldValues}: the same order an
+* IndexedDB index uses, so equal `Date`s tie and fall through to the next
+* field, and `null`s sort last (first when descending).
+*/
+function buildRowComparator(orderBy) {
+	if (orderBy === void 0) return void 0;
+	return (a, b) => {
+		for (const [field, dir] of Object.entries(orderBy)) {
+			const cmp = compareFieldValues(a[field], b[field]);
+			if (cmp === 0) continue;
+			return dir === "desc" ? -cmp : cmp;
+		}
+		return 0;
+	};
+}
+/**
+* `true` when a `cursor-scan` plan's result *cardinality* is fully determined
+* by its store/index + key range — i.e. there is no in-memory `filter` that
+* would need each row's value. Only then can `count()` be answered natively
+* (`store.count(range)` / `index.count(range)`) without deserializing rows.
+*
+* `comparator` (ORDER BY), `direction`, `skip` and `take` don't change *which*
+* rows match, so they don't disqualify a plan — `skip`/`take` are applied to
+* the native total afterwards via {@link clampCount}.
+*
+* Safe for index scans because the equality hint that builds `range` never
+* selects a `multiEntry` (or compound) index — `buildFieldToIndexMap` excludes
+* them — so one record maps to at most one index entry and entries == rows.
+*/
+function isNativelyCountable(plan) {
+	return plan.filter === void 0;
+}
+/** Rewrites a natively-countable `cursor-scan` as the equivalent native `count` plan. */
+function toCountPlan(plan) {
+	return {
+		meta: plan.meta,
+		kind: "count",
+		storeName: plan.storeName,
+		...plan.indexName !== void 0 ? { indexName: plan.indexName } : {},
+		...plan.range !== void 0 ? { range: plan.range } : {}
+	};
+}
+/**
+* Applies `skip`/`take` to an *unpaginated* total. A paginated count is pure
+* arithmetic on the unpaginated count — `max(0, total - skip)`, capped at
+* `take` — so this is exact, not an approximation.
+*/
+function clampCount(total, skip, take) {
+	let n = total;
+	if (skip !== void 0) n = Math.max(0, n - skip);
+	if (take !== void 0) n = Math.min(take, n);
+	return n;
+}
+//#endregion
+//#region src/core/aggregate-builder.ts
+/**
+* Build the aggregate selector factory handed to `.aggregate(agg => …)` and
+* `groupBy(...).aggregate(agg => …)`.
+*
+* Each method returns an {@link IdbAggregateSelector} marker; the actual
+* reduction happens in {@link reduceAggregate} once the matching rows are
+* materialised in memory. Mirrors `createAggregateBuilder` from the vendor
+* `sql-orm-client/aggregate-builder.ts`, minus the field→column mapping (IDB
+* stores native field names).
+*/
+function createAggregateBuilder() {
+	return {
+		count: () => ({
+			kind: "aggregate",
+			fn: "count"
+		}),
+		sum: (field) => ({
+			kind: "aggregate",
+			fn: "sum",
+			field
+		}),
+		avg: (field) => ({
+			kind: "aggregate",
+			fn: "avg",
+			field
+		}),
+		min: (field) => ({
+			kind: "aggregate",
+			fn: "min",
+			field
+		}),
+		max: (field) => ({
+			kind: "aggregate",
+			fn: "max",
+			field
+		})
+	};
+}
+/** Type guard: is `value` an {@link IdbAggregateSelector}? */
+function isAggregateSelector(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return candidate.kind === "aggregate" && (candidate.fn === "count" || candidate.fn === "sum" || candidate.fn === "avg" || candidate.fn === "min" || candidate.fn === "max");
+}
+/**
+* Reduce a set of materialised rows to a single aggregate value.
+*
+* - `count` → the number of rows (always a number, never null).
+* - `sum`/`avg`/`min`/`max` → computed over the non-null numeric values of
+*   `field`; `null` when no row has a non-null value (matching Prisma's
+*   "aggregate of an empty set is null" and the vendor `coerceAggregateValue`
+*   null handling). String-encoded numbers are coerced via `Number()`.
+*/
+function reduceAggregate(fn, field, rows) {
+	if (fn === "count") return rows.length;
+	if (field === void 0) return null;
+	const values = [];
+	for (const row of rows) {
+		const raw = row[field];
+		if (raw === null || raw === void 0) continue;
+		const n = typeof raw === "bigint" ? Number(raw) : Number(raw);
+		if (!Number.isNaN(n)) values.push(n);
+	}
+	if (values.length === 0) return null;
+	switch (fn) {
+		case "sum": return values.reduce((acc, n) => acc + n, 0);
+		case "avg": return values.reduce((acc, n) => acc + n, 0) / values.length;
+		case "min": return Math.min(...values);
+		case "max": return Math.max(...values);
+	}
+}
+/**
+* Run every selector in an aggregate spec against `rows`, producing the
+* result object keyed by the spec's aliases.
+*/
+function computeAggregateSpec(spec, rows) {
+	const result = {};
+	for (const [alias, selector] of Object.entries(spec)) result[alias] = reduceAggregate(selector.fn, selector.field, rows);
+	return result;
+}
+/**
+* Project an aggregate spec down to the plain `{ fn, field? }` shape carried by
+* the query AST (`IdbAggregateAst.aggregates` / `IdbGroupByAst.aggregates`), so
+* middleware can observe the requested aggregations.
+*/
+function toAggregateRequests(spec) {
+	const out = {};
+	for (const [alias, selector] of Object.entries(spec)) out[alias] = selector.field !== void 0 ? {
+		fn: selector.fn,
+		field: selector.field
+	} : { fn: selector.fn };
+	return out;
+}
+/**
+* Validate a user-supplied aggregate spec: it must be non-empty and every
+* value must be a real selector. Throws a descriptive error otherwise, so a
+* typo (e.g. returning a plain object) fails loudly rather than silently
+* producing `NaN`/`undefined` results.
+*/
+function assertValidAggregateSpec(spec, context) {
+	const entries = Object.entries(spec);
+	if (entries.length === 0) throw new Error(`${context} requires at least one aggregation selector`);
+	for (const [alias, selector] of entries) if (!isAggregateSelector(selector)) throw new Error(`${context} selector "${alias}" is invalid`);
+}
+//#endregion
+//#region src/core/grouped-accessor.ts
+/**
+* Build a composite group key from type-tagged field tokens. Equal Date, binary,
+* array and JSON object values share a group; null and undefined also share a group.
+*/
+function groupKeyOf(by, row) {
+	return JSON.stringify(by.map((field) => groupToken(row[field])));
+}
+/** Keep `1n`, `1` and `"1"` apart while preserving structural grouping for JSON objects. */
+function groupToken(value) {
+	if (value instanceof Date && Number.isNaN(value.getTime())) return ["date", "invalid"];
+	const token = fieldValueToken(value ?? null);
+	return [typeof token, typeof token === "object" ? token : String(token)];
+}
+/** Build a grouped accessor that reduces materialized rows from the source accessor. */
+function createGroupedAccessor(init) {
+	return { async aggregate(fn) {
+		const spec = fn(createAggregateBuilder());
+		assertValidAggregateSpec(spec, "groupBy().aggregate()");
+		const ast = {
+			kind: "groupBy",
+			modelName: init.modelName,
+			by: init.by,
+			aggregates: toAggregateRequests(spec),
+			...init.where !== void 0 ? { where: init.where } : {}
+		};
+		const rows = await init.materialize(ast);
+		const groups = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const gk = groupKeyOf(init.by, row);
+			let group = groups.get(gk);
+			if (group === void 0) {
+				const key = {};
+				for (const field of init.by) key[field] = row[field];
+				group = {
+					key,
+					rows: []
+				};
+				groups.set(gk, group);
+			}
+			group.rows.push(row);
+		}
+		return Array.from(groups.values()).map((group) => ({
+			...group.key,
+			...computeAggregateSpec(spec, group.rows)
+		}));
+	} };
+}
+//#endregion
+//#region src/core/relation-loader.ts
+/**
+* Batch-load a single named relation for all rows in `rows` and attach the
+* result to each row under the `relName` key.
+*
+* The join matches every field of the relation, so compound foreign keys join
+* on the whole tuple. It uses one key-range scan per distinct tuple when an
+* index or the related primary key covers the target fields, and otherwise
+* one full scan with an in-memory filter. Rows are then grouped in memory,
+* which avoids N+1 queries.
+*
+* The `entry` carries any `include()` refinement:
+*
+* - `collection` — the refined `where` further filters the child scan;
+*   `orderBy` / `skip` / `take` are applied **per parent group** for `1:N`
+*   relations (each parent's children are independently sorted and paginated).
+* - `scalar` — the relation field becomes the `count` of matching children
+*   (to-many only; `include()` rejects scalar refinements on to-one relations).
+*
+* @param relName    - The relation key to load (e.g. `"posts"`, `"author"`).
+* @param entry      - How to materialise the relation (collection vs scalar + refinement state).
+* @param rows       - The parent rows to attach related data to.
+* @param contract   - The resolved IDB contract.
+* @param modelName  - The source model name (owner of the relation).
+* @param executor   - The query executor used to run the related-store scan.
+*/
+async function loadRelation(relName, entry, rows, contract, modelName, executor, groupingKey) {
+	if (rows.length === 0) return rows;
+	const models = domainModelsAtDefaultNamespace(contract.domain);
+	const model = models[modelName];
+	if (model === void 0) return rows;
+	const rawRelation = model.relations[relName];
+	if (rawRelation === void 0) return rows;
+	if (!("on" in rawRelation)) return rows;
+	const relation = rawRelation;
+	const { cardinality, on } = relation;
+	const relatedModelName = relation.to.model;
+	const localFields = on.localFields;
+	const targetFields = on.targetFields;
+	if (localFields.length === 0 || localFields.length !== targetFields.length) return rows;
+	if (models[relatedModelName] === void 0) return rows;
+	const relatedStoreName = getStoreName(contract, relatedModelName);
+	const isScalar = entry.kind === "scalar";
+	const localTuples = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const token = tupleToken(row, localFields);
+		if (token !== null) localTuples.set(token, localFields.map((f) => row[f]));
+	}
+	if (localTuples.size === 0) return rows.map((row) => ({
+		...row,
+		[relName]: isScalar ? 0 : cardinality === "1:N" ? [] : null
+	}));
+	const refinedWhere = combineFilterExprs(entry.state.filters);
+	const planMeta = {
+		target: "idb",
+		storageHash: contract.storage.storageHash,
+		lane: "idb-orm",
+		annotations: { groupingKey }
+	};
+	const rangeSource = findRangeSource(contract, relatedStoreName, relatedModelName, targetFields);
+	let relatedRows;
+	if (rangeSource !== void 0) {
+		const refinedFilter = refinedWhere !== void 0 ? (row) => evaluateFilter(refinedWhere, row) : void 0;
+		const ranges = [];
+		for (const values of localTuples.values()) {
+			const ordered = keyPathFields(rangeSource.keyPath).map((f) => values[targetFields.indexOf(f)]);
+			if (!ordered.every((v) => isValidIdbKey(v))) continue;
+			ranges.push(IDBKeyRange.only(typeof rangeSource.keyPath === "string" ? ordered[0] : ordered));
+		}
+		relatedRows = (await Promise.all(ranges.map(async (range) => {
+			const plan = {
+				meta: planMeta,
+				idbPlan: {
+					meta: planMeta,
+					kind: "cursor-scan",
+					storeName: relatedStoreName,
+					...rangeSource.indexName !== void 0 ? { indexName: rangeSource.indexName } : {},
+					range,
+					...refinedFilter !== void 0 ? { filter: refinedFilter } : {}
+				}
+			};
+			const rows = [];
+			for await (const row of executor.query(plan)) rows.push(row);
+			return rows;
+		}))).flat();
+	} else {
+		relatedRows = [];
+		const filter = (row) => {
+			const token = tupleToken(row, targetFields);
+			return token !== null && localTuples.has(token) && (refinedWhere === void 0 || evaluateFilter(refinedWhere, row));
+		};
+		const plan = {
+			meta: planMeta,
+			idbPlan: {
+				meta: planMeta,
+				kind: "cursor-scan",
+				storeName: relatedStoreName,
+				filter
+			}
+		};
+		for await (const row of executor.query(plan)) relatedRows.push(row);
+	}
+	return attachRelatedRows(relName, entry, rows, relatedRows, relation);
+}
+/** Attach related rows by their join tuple, shaping each parent's collection independently. */
+function attachRelatedRows(relName, entry, rows, relatedRows, relation) {
+	const { cardinality, on: { localFields, targetFields } } = relation;
+	if (cardinality === "1:N") {
+		const grouped = /* @__PURE__ */ new Map();
+		for (const rrow of relatedRows) {
+			const gk = tupleToken(rrow, targetFields);
+			if (gk === null) continue;
+			const group = grouped.get(gk) ?? [];
+			group.push(rrow);
+			grouped.set(gk, group);
+		}
+		const groupFor = (row) => {
+			const token = tupleToken(row, localFields);
+			return token === null ? [] : grouped.get(token) ?? [];
+		};
+		if (entry.kind === "scalar") return rows.map((row) => ({
+			...row,
+			[relName]: groupFor(row).length
+		}));
+		const comparator = buildRowComparator(entry.state.orderBy);
+		const skip = entry.state.skip ?? 0;
+		const take = entry.state.take;
+		return rows.map((row) => {
+			let group = groupFor(row);
+			if (comparator !== void 0) group = [...group].sort(comparator);
+			if (skip > 0 || take !== void 0) group = group.slice(skip, take !== void 0 ? skip + take : void 0);
+			return {
+				...row,
+				[relName]: group
+			};
+		});
+	}
+	const indexed = /* @__PURE__ */ new Map();
+	for (const rrow of relatedRows) {
+		const token = tupleToken(rrow, targetFields);
+		if (token !== null) indexed.set(token, rrow);
+	}
+	return rows.map((row) => {
+		const token = tupleToken(row, localFields);
+		return {
+			...row,
+			[relName]: (token === null ? void 0 : indexed.get(token)) ?? null
+		};
+	});
+}
+/**
+* A `Map` key for the values of `fields` in `row`, or `null` when any of them
+* is null or undefined. Equal `Date`s and binary values give equal tokens.
+*/
+function tupleToken(row, fields) {
+	const parts = [];
+	for (const field of fields) {
+		const value = row[field];
+		if (value === null || value === void 0) return null;
+		const token = fieldValueToken(value);
+		parts.push([typeof token, String(token)]);
+	}
+	return JSON.stringify(parts);
+}
+/**
+* Finds an index, or else the store's primary key, whose key path has exactly
+* `fields` (in any order), so a lookup on those fields can use a key range.
+* Returns `undefined` when there is none, or when `IDBKeyRange` isn't available.
+*/
+function findRangeSource(contract, storeName, modelName, fields) {
+	if (typeof IDBKeyRange === "undefined") return void 0;
+	const coversFields = (keyPath) => {
+		const keyFields = keyPathFields(keyPath);
+		return keyFields.length === fields.length && keyFields.every((f) => fields.includes(f));
+	};
+	const indexes = contract.storage.stores[storeName]?.indexes ?? {};
+	for (const [indexName, indexDef] of Object.entries(indexes)) if (indexDef.multiEntry !== true && coversFields(indexDef.keyPath)) return {
+		indexName,
+		keyPath: indexDef.keyPath
+	};
+	const primaryKey = getKeyPath(contract, modelName);
+	return coversFields(primaryKey) ? { keyPath: primaryKey } : void 0;
+}
+//#endregion
+//#region src/core/store-accessor.ts
+/**
+* Concrete immutable query builder.
+*
+* Internal details:
+* - All state is in `#state` (filters, orderBy, skip, take, includes, selectedFields).
+* - Builder methods clone via `#clone()` — O(1) copies since state is
+*   structurally shared.
+* - `all()` materialises the main rows first, then batch-loads each included
+*   relation, then applies any `.select()` projection before yielding.
+* - `#includeRefinementMode` flips `count()` from an async terminal to an
+*   {@link IdbIncludeScalar} marker so it can be used inside `include()`.
+*/
+var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
+	#contract;
+	#modelName;
+	#executor;
+	#storeName;
+	#state;
+	#newGroupingKey;
+	#includeRefinementMode;
+	constructor(contract, modelName, executor, state, newGroupingKey, includeRefinementMode = false) {
+		this.#contract = contract;
+		this.#modelName = modelName;
+		this.#executor = executor;
+		this.#storeName = getStoreName(contract, modelName);
+		this.#state = state ?? emptyAccessorState();
+		let _key = 0;
+		this.#newGroupingKey = newGroupingKey ?? (() => `idb-op-${++_key}`);
+		this.#includeRefinementMode = includeRefinementMode;
+	}
+	where(filter) {
+		const expr = typeof filter === "function" ? filter(createModelAccessor()) : shorthandToFilterExpr(filter);
+		if (expr === void 0) return this.#clone({});
+		return this.#clone({ filters: [...this.#state.filters, expr] });
+	}
+	orderBy(spec) {
+		return this.#clone({ orderBy: spec });
+	}
+	take(n) {
+		return this.#clone({ take: n });
+	}
+	skip(n) {
+		return this.#clone({ skip: n });
+	}
+	include(relation, refineFn) {
+		const entry = this.#resolveIncludeEntry(relation, refineFn);
+		const newState = mergeAccessorState(this.#state, { includes: {
+			...this.#state.includes,
+			[relation]: entry
+		} });
+		return new IdbStoreAccessorImpl(this.#contract, this.#modelName, this.#executor, newState, this.#newGroupingKey, this.#includeRefinementMode);
+	}
+	select(...fields) {
+		return this.#clone({ selectedFields: fields });
+	}
+	all() {
+		const groupingKey = this.#newGroupingKey();
+		const buildScanPlan = this.#buildScanPlan.bind(this);
+		const executeOrRows = this.#executeOrRows.bind(this);
+		const executorQuery = this.#executor.query.bind(this.#executor);
+		const applyIncludes = this.#applyIncludes.bind(this);
+		const projectRows = this.#projectRows.bind(this);
+		const combined = this.#combinedFilterExpr();
+		const fieldToIndexMap = typeof IDBKeyRange !== "undefined" ? buildFieldToIndexMap(this.#contract, this.#storeName) : void 0;
+		const keyPath = getKeyPath(this.#contract, this.#modelName);
+		const comparator = buildRowComparator(this.#state.orderBy);
+		const skip = this.#state.skip;
+		const take = this.#state.take;
+		return new AsyncIterableResult((async function* () {
+			let rows;
+			const orHint = fieldToIndexMap !== void 0 ? extractIndexOrHint(combined, fieldToIndexMap, keyPath) : null;
+			if (orHint !== null) {
+				rows = await executeOrRows(orHint, groupingKey, combined);
+				if (comparator !== void 0) rows.sort(comparator);
+				if (skip !== void 0) rows = rows.slice(skip);
+				if (take !== void 0) rows = rows.slice(0, take);
+			} else {
+				const scanPlan = buildScanPlan(groupingKey, fieldToIndexMap);
+				rows = [];
+				for await (const row of executorQuery(scanPlan)) rows.push(row);
+			}
+			const withIncludes = await applyIncludes(rows, groupingKey);
+			for (const row of projectRows(withIncludes)) yield row;
+		})());
+	}
+	async first() {
+		return this.take(1).all().first();
+	}
+	async aggregate(fn) {
+		const spec = fn(createAggregateBuilder());
+		assertValidAggregateSpec(spec, "aggregate()");
+		const combined = this.#combinedFilterExpr();
+		const ast = {
+			kind: "aggregate",
+			modelName: this.#modelName,
+			aggregates: toAggregateRequests(spec),
+			...combined !== void 0 ? { where: combined } : {}
+		};
+		const groupingKey = this.#newGroupingKey();
+		if (Object.values(spec).every((selector) => selector.fn === "count")) {
+			const scanPlan = this.#buildScanPlan(groupingKey);
+			const total = await this.#executeNativeCount(scanPlan, ast);
+			if (total !== null) {
+				const result = {};
+				for (const alias of Object.keys(spec)) result[alias] = total;
+				return result;
+			}
+		}
+		return computeAggregateSpec(spec, await this.#materialize(groupingKey, ast));
+	}
+	groupBy(...fields) {
+		const combined = this.#combinedFilterExpr();
+		const materialize = (ast) => this.#materialize(this.#newGroupingKey(), ast);
+		return createGroupedAccessor({
+			modelName: this.#modelName,
+			by: fields,
+			where: combined,
+			materialize
+		});
+	}
+	async create(data) {
+		const record = data;
+		if (hasNestedMutationCallbacks(this.#contract, this.#modelName, record)) return await executeNestedCreateMutation({
+			executor: requireTransactionExecutor(this.#executor),
+			contract: this.#contract,
+			modelName: this.#modelName,
+			data: record
+		});
+		const withDefaults = applyCreateDefaults(this.#contract.execution?.mutations.defaults, this.#storeName, record, createMutationDefaultsCache());
+		assertEnumValues(this.#contract, this.#modelName, withDefaults);
+		if (hasScalarFkFields(this.#contract, this.#modelName, withDefaults)) return await executeScalarCreateWithFkValidation({
+			executor: requireTransactionExecutor(this.#executor),
+			contract: this.#contract,
+			modelName: this.#modelName,
+			data: withDefaults
+		});
+		const groupingKey = this.#newGroupingKey();
+		const meta = this.#planMeta(groupingKey);
+		const plan = {
+			meta,
+			ast: {
+				kind: "create",
+				modelName: this.#modelName,
+				data: withDefaults
+			},
+			idbPlan: {
+				meta,
+				kind: "add",
+				storeName: this.#storeName,
+				record: withDefaults
+			}
+		};
+		for await (const row of this.#executor.query(plan)) return row;
+		return withDefaults;
+	}
+	async findUnique(key) {
+		const groupingKey = this.#newGroupingKey();
+		const meta = this.#planMeta(groupingKey);
+		const plan = {
+			meta,
+			ast: {
+				kind: "findUnique",
+				modelName: this.#modelName,
+				key
+			},
+			idbPlan: {
+				meta,
+				kind: "key-get",
+				storeName: this.#storeName,
+				key
+			}
+		};
+		for await (const row of this.#executor.query(plan)) return row;
+		return null;
+	}
+	async delete(key) {
+		if (hasEnforceableChildRelations(this.#contract, this.#modelName)) {
+			await executeDeleteWithReferentialActions({
+				executor: requireTransactionExecutor(this.#executor),
+				contract: this.#contract,
+				modelName: this.#modelName,
+				key
+			});
+			return;
+		}
+		const groupingKey = this.#newGroupingKey();
+		const meta = this.#planMeta(groupingKey);
+		const plan = {
+			meta,
+			ast: {
+				kind: "delete",
+				modelName: this.#modelName,
+				key
+			},
+			idbPlan: {
+				meta,
+				kind: "delete",
+				storeName: this.#storeName,
+				key
+			}
+		};
+		await this.#executor.query(plan).toArray();
+	}
+	async update(patch) {
+		const patchRecord = patch;
+		if (hasNestedMutationCallbacks(this.#contract, this.#modelName, patchRecord)) return await executeNestedUpdateMutation({
+			executor: requireTransactionExecutor(this.#executor),
+			contract: this.#contract,
+			modelName: this.#modelName,
+			filters: this.#state.filters,
+			data: patchRecord
+		});
+		return await executeScalarUpdateWithFkValidation({
+			executor: requireTransactionExecutor(this.#executor),
+			contract: this.#contract,
+			modelName: this.#modelName,
+			filters: this.#state.filters,
+			data: patchRecord
+		});
+	}
+	/**
+	* Always routes through the transaction scope (`executeBulkUpdateWithFkValidation`),
+	* unlike single-row `update()`'s plan-level fallback for the no-FK-field
+	* case. A bulk scan-write's affected row set isn't knowable until it
+	* actually runs — going through the transaction scope is what lets the
+	* sync interceptor observe the real affected rows and write one outbox
+	* event per row (see `SyncInterceptingTransactionScope#maybeTrack`'s
+	* `scan-write` case), atomically with the write itself, instead of one
+	* event for the whole batch with no way to recover which rows it covered.
+	*/
+	updateAll(patch) {
+		const contract = this.#contract;
+		const modelName = this.#modelName;
+		const filters = this.#state.filters;
+		const patchRecord = patch;
+		const executor = requireTransactionExecutor(this.#executor);
+		return new AsyncIterableResult((async function* () {
+			const rows = await executeBulkUpdateWithFkValidation({
+				executor,
+				contract,
+				modelName,
+				filters,
+				data: patchRecord
+			});
+			for (const row of rows) yield row;
+		})());
+	}
+	async updateCount(patch) {
+		return (await this.updateAll(patch).toArray()).length;
+	}
+	async upsert(args) {
+		const keyPath = getKeyPath(this.#contract, this.#modelName);
+		const whereExpr = shorthandToFilterExpr(args.where);
+		const matches = (row) => whereExpr === void 0 || evaluateFilter(whereExpr, row);
+		const meta = this.#planMeta(this.#newGroupingKey());
+		const createRecord = args.create;
+		const patchRecord = args.update;
+		const storeName = this.#storeName;
+		const executionDefaults = this.#contract.execution?.mutations.defaults;
+		const exec = requireTransactionExecutor(this.#executor);
+		const effectivePatch = applyUpdateDefaults(executionDefaults, storeName, patchRecord, createMutationDefaultsCache());
+		const createWithDefaults = applyCreateDefaults(executionDefaults, storeName, createRecord, createMutationDefaultsCache());
+		assertEnumValues(this.#contract, this.#modelName, effectivePatch);
+		assertEnumValues(this.#contract, this.#modelName, createWithDefaults);
+		const { storeNames: onUpdateStoreNames } = collectOnUpdateEnforcementStoreNames(this.#contract, this.#modelName, effectivePatch);
+		const storeNames = [.../* @__PURE__ */ new Set([
+			storeName,
+			...onUpdateStoreNames,
+			...collectScalarFkStoreNames(this.#contract, this.#modelName, createWithDefaults),
+			...collectScalarFkStoreNames(this.#contract, this.#modelName, effectivePatch)
+		])];
+		return withMutationScope(exec, storeNames, async (scope) => {
+			const existing = (await scope.execute({
+				meta,
+				kind: "cursor-scan",
+				storeName,
+				filter: matches,
+				take: 1
+			}))[0];
+			if (existing === void 0) {
+				await validateScalarFks(scope, this.#contract, this.#modelName, createWithDefaults);
+				return (await scope.execute({
+					meta,
+					kind: "add",
+					storeName,
+					record: createWithDefaults
+				}))[0] ?? createWithDefaults;
+			}
+			await validateScalarFks(scope, this.#contract, this.#modelName, effectivePatch, existing);
+			const key = extractKeyFromRow(existing, keyPath);
+			await applyReferentialActionsForRowOnUpdate(scope, this.#contract, this.#modelName, existing, effectivePatch);
+			return (await scope.execute({
+				meta,
+				kind: "update",
+				storeName,
+				key,
+				patch: effectivePatch
+			}))[0] ?? existing;
+		});
+	}
+	createAll(data) {
+		const defaultsCache = createMutationDefaultsCache();
+		const executionDefaults = this.#contract.execution?.mutations.defaults;
+		const records = data.map((d) => applyCreateDefaults(executionDefaults, this.#storeName, d, defaultsCache));
+		if (records.some((row) => hasScalarFkFields(this.#contract, this.#modelName, row))) {
+			const executor = requireTransactionExecutor(this.#executor);
+			const contract = this.#contract;
+			const modelName = this.#modelName;
+			return new AsyncIterableResult((async function* () {
+				const rows = await executeScalarCreateAllWithFkValidation({
+					executor,
+					contract,
+					modelName,
+					data: records
+				});
+				for (const row of rows) yield row;
+			})());
+		}
+		const groupingKey = this.#newGroupingKey();
+		const meta = this.#planMeta(groupingKey);
+		const plan = {
+			meta,
+			ast: {
+				kind: "createAll",
+				modelName: this.#modelName,
+				data: records
+			},
+			idbPlan: {
+				meta,
+				kind: "batch",
+				storeNames: [this.#storeName],
+				ops: records.map((record) => ({
+					meta,
+					kind: "add",
+					storeName: this.#storeName,
+					record
+				}))
+			}
+		};
+		const executorQuery = this.#executor.query.bind(this.#executor);
+		const contract = this.#contract;
+		const modelName = this.#modelName;
+		return new AsyncIterableResult((async function* () {
+			for (const record of records) assertEnumValues(contract, modelName, record);
+			for await (const row of executorQuery(plan)) yield row;
+		})());
+	}
+	async createCount(data) {
+		return (await this.createAll(data).toArray()).length;
+	}
+	/**
+	* Always routes through the transaction scope (`executeDeleteAllWithReferentialActions`),
+	* not just when there are enforceable child relations to cascade — that
+	* function already handles the no-relations case correctly (an empty
+	* relation list is a no-op loop), and going through it unconditionally is
+	* what lets the sync interceptor's transaction-scope tracking write one
+	* outbox event per actually-deleted row instead of one lump event for
+	* the whole batch with no way to know which rows it covered. See
+	* `updateAll()`'s doc comment for the same reasoning.
+	*/
+	deleteAll() {
+		const combined = this.#combinedFilterExpr();
+		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
+		const contract = this.#contract;
+		const modelName = this.#modelName;
+		const executor = requireTransactionExecutor(this.#executor);
+		return new AsyncIterableResult((async function* () {
+			const rows = await executeDeleteAllWithReferentialActions({
+				executor,
+				contract,
+				modelName,
+				...filter !== void 0 ? { filter } : {}
+			});
+			for (const row of rows) yield row;
+		})());
+	}
+	async deleteCount() {
+		return (await this.deleteAll().toArray()).length;
+	}
+	count() {
+		if (this.#includeRefinementMode) return createIncludeScalar(this.#state);
+		return this.#countTerminal();
+	}
+	async #countTerminal() {
+		const groupingKey = this.#newGroupingKey();
+		const combined = this.#combinedFilterExpr();
+		const fieldToIndexMap = typeof IDBKeyRange !== "undefined" ? buildFieldToIndexMap(this.#contract, this.#storeName) : void 0;
+		if (fieldToIndexMap !== void 0) {
+			const orHint = extractIndexOrHint(combined, fieldToIndexMap, getKeyPath(this.#contract, this.#modelName));
+			if (orHint !== null) return clampCount((await this.#executeOrRows(orHint, groupingKey, combined)).length, this.#state.skip, this.#state.take);
+		}
+		const scanPlan = this.#buildScanPlan(groupingKey, fieldToIndexMap);
+		const scanAst = scanPlan.ast;
+		const ast = {
+			kind: "count",
+			modelName: this.#modelName,
+			...scanAst?.kind === "findMany" && scanAst.where !== void 0 ? { where: scanAst.where } : {}
+		};
+		const nativeTotal = await this.#executeNativeCount(scanPlan, ast);
+		if (nativeTotal !== null) return clampCount(nativeTotal, this.#state.skip, this.#state.take);
+		const plan = {
+			...scanPlan,
+			ast
+		};
+		let n = 0;
+		for await (const _ of this.#executor.query(plan)) n++;
+		return n;
+	}
+	/**
+	* Resolve an `include()` argument pair into an {@link IncludeEntry}: run the
+	* optional refinement against a fresh refinement-mode child accessor, then
+	* classify the result as a scalar count or a refined collection.
+	*/
+	#resolveIncludeEntry(relation, refineFn) {
+		if (refineFn === void 0) return {
+			kind: "collection",
+			state: emptyAccessorState()
+		};
+		const rel = getRelation(this.#contract, this.#modelName, relation);
+		const relatedModelName = rel?.to.model ?? relation;
+		const refined = refineFn(new IdbStoreAccessorImpl(this.#contract, relatedModelName, this.#executor, emptyAccessorState(), this.#newGroupingKey, true));
+		if (isIncludeScalar(refined)) {
+			if (rel !== void 0 && rel.cardinality !== "1:N") throw new Error(`include('${relation}'): count() is only supported for to-many (1:N) relations`);
+			return {
+				kind: "scalar",
+				fn: refined.fn,
+				state: refined.state
+			};
+		}
+		if (refined instanceof IdbStoreAccessorImpl) return {
+			kind: "collection",
+			state: refined.#state
+		};
+		throw new Error(`include('${relation}') refinement must return the collection (for where/orderBy/take/skip) or a count() selector`);
+	}
+	/**
+	* Runs `scanPlan` as a native `count` plan when its cardinality is fully
+	* determined by a key range (no in-memory filter) — returning the
+	* *unpaginated* total — or `null` when it can't (the caller then falls back
+	* to materializing). `ast` is attached so middleware sees the caller's
+	* intent (`count` / `aggregate`) regardless of the physical plan.
+	*/
+	async #executeNativeCount(scanPlan, ast) {
+		const body = scanPlan.idbPlan;
+		if (body.kind !== "cursor-scan" || !isNativelyCountable(body)) return null;
+		const nativePlan = {
+			...scanPlan,
+			ast,
+			idbPlan: toCountPlan(body)
+		};
+		let total = 0;
+		for await (const row of this.#executor.query(nativePlan)) total = row.count;
+		return total;
+	}
+	/**
+	* Materialise all rows matching the accumulated filters with no pagination —
+	* used by `aggregate()` / `groupBy()`. The supplied `ast` is attached to the
+	* scan plan so middleware can observe the aggregate intent.
+	*/
+	async #materialize(groupingKey, ast) {
+		const combined = this.#combinedFilterExpr();
+		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
+		const meta = this.#planMeta(groupingKey);
+		const plan = {
+			meta,
+			ast,
+			idbPlan: {
+				meta,
+				kind: "cursor-scan",
+				storeName: this.#storeName,
+				...filter !== void 0 ? { filter } : {}
+			}
+		};
+		const rows = [];
+		for await (const row of this.#executor.query(plan)) rows.push(row);
+		return rows;
+	}
+	#buildScanPlan(groupingKey, fieldToIndexMap) {
+		const combined = this.#combinedFilterExpr();
+		const comparator = buildRowComparator(this.#state.orderBy);
+		const meta = this.#planMeta(groupingKey);
+		const ast = {
+			kind: "findMany",
+			modelName: this.#modelName,
+			...combined !== void 0 ? { where: combined } : {},
+			...this.#state.orderBy !== void 0 ? { orderBy: this.#state.orderBy } : {},
+			...this.#state.skip !== void 0 ? { skip: this.#state.skip } : {},
+			...this.#state.take !== void 0 ? { take: this.#state.take } : {}
+		};
+		let hint = null;
+		if (typeof IDBKeyRange !== "undefined") hint = extractIndexEqualityHint(combined, fieldToIndexMap ?? buildFieldToIndexMap(this.#contract, this.#storeName), getKeyPath(this.#contract, this.#modelName));
+		const remainingFilter = hint !== null ? hint.remainingFilter : combined;
+		const filter = remainingFilter !== void 0 ? (row) => evaluateFilter(remainingFilter, row) : void 0;
+		return {
+			meta,
+			ast,
+			idbPlan: {
+				meta,
+				kind: "cursor-scan",
+				storeName: this.#storeName,
+				...hint?.indexName !== void 0 ? { indexName: hint.indexName } : {},
+				...hint !== null ? { range: IDBKeyRange.only(hint.value) } : {},
+				...filter !== void 0 ? { filter } : {},
+				...comparator !== void 0 ? { comparator } : {},
+				...this.#state.skip !== void 0 ? { skip: this.#state.skip } : {},
+				...this.#state.take !== void 0 ? { take: this.#state.take } : {}
+			}
+		};
+	}
+	/**
+	* Execute one cursor-scan per OR branch, union the results, deduplicate by
+	* primary key, and apply `hint.remainingFilter` in-memory. Skip/take are
+	* NOT applied here — the caller slices the array after union so pagination
+	* is correct across branches.
+	*/
+	async #executeOrRows(hint, groupingKey, combined) {
+		const meta = this.#planMeta(groupingKey);
+		const storeName = this.#storeName;
+		const keyPath = getKeyPath(this.#contract, this.#modelName);
+		const seen = /* @__PURE__ */ new Set();
+		const rows = [];
+		const ast = {
+			kind: "findMany",
+			modelName: this.#modelName,
+			...combined !== void 0 ? { where: combined } : {}
+		};
+		const branchResults = await Promise.all(hint.branches.map(async (branch) => {
+			const plan = {
+				meta,
+				ast,
+				idbPlan: {
+					meta,
+					kind: "cursor-scan",
+					storeName,
+					...branch.indexName !== void 0 ? { indexName: branch.indexName } : {},
+					range: IDBKeyRange.only(branch.value)
+				}
+			};
+			const branchRows = [];
+			for await (const row of this.#executor.query(plan)) branchRows.push(row);
+			return branchRows;
+		}));
+		for (const branchRows of branchResults) for (const row of branchRows) {
+			const pk = keyToken(extractKeyFromRow(row, keyPath));
+			if (!seen.has(pk)) {
+				seen.add(pk);
+				rows.push(row);
+			}
+		}
+		if (hint.remainingFilter === void 0) return rows;
+		const { remainingFilter } = hint;
+		return rows.filter((row) => evaluateFilter(remainingFilter, row));
+	}
+	/**
+	* Combine all accumulated filter expressions with AND.
+	*
+	* Returns `undefined` when no filter has been installed so the driver can
+	* skip building a row filter closure (a small perf and readability win on
+	* `.all()` paths). Delegates to the shared {@link combineFilterExprs}.
+	*/
+	#combinedFilterExpr() {
+		return combineFilterExprs(this.#state.filters);
+	}
+	async #applyIncludes(rows, groupingKey) {
+		const relNames = Object.keys(this.#state.includes);
+		if (relNames.length === 0) return rows;
+		let result = rows;
+		for (const relName of relNames) {
+			const entry = this.#state.includes[relName];
+			result = await loadRelation(relName, entry, result, this.#contract, this.#modelName, this.#executor, groupingKey);
+		}
+		return result;
+	}
+	/**
+	* Apply a `.select()` projection (if any) to materialised rows. Keeps the
+	* selected scalar fields plus every included relation key (which `include()`
+	* attached during {@link #applyIncludes}); a no-op when nothing is selected.
+	*/
+	#projectRows(rows) {
+		const selected = this.#state.selectedFields;
+		if (selected === void 0) return rows;
+		const keep = [...selected, ...Object.keys(this.#state.includes)];
+		return rows.map((row) => {
+			const out = {};
+			for (const field of keep) if (field in row) out[field] = row[field];
+			return out;
+		});
+	}
+	#planMeta(groupingKey) {
+		return {
+			target: "idb",
+			storageHash: this.#contract.storage.storageHash,
+			lane: "idb-orm",
+			annotations: { groupingKey }
+		};
+	}
+	#clone(overrides) {
+		return new IdbStoreAccessorImpl(this.#contract, this.#modelName, this.#executor, mergeAccessorState(this.#state, overrides), this.#newGroupingKey, this.#includeRefinementMode);
+	}
+};
+//#endregion
+//#region src/core/idb-orm.ts
+/**
+* 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-idb/client-idb/orm";
+* import { createIdbRuntime } from "@prisma-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();
+* ```
+*/
+function idbOrm(options) {
+	const { contract, executor } = options;
+	let _key = 0;
+	const newGroupingKey = () => `idb-op-${++_key}`;
+	const client = {};
+	for (const [rootKey, ref] of Object.entries(contract.roots)) client[rootKey] = new IdbStoreAccessorImpl(contract, ref.model, executor, void 0, newGroupingKey);
+	return client;
+}
+//#endregion
+export { idbOrm as t };
+
+//# sourceMappingURL=idb-orm-DsfllvzD.mjs.map