@prisma-idb/client-idb 0.10.0 → 0.12.0

package/dist/{idb-orm-DsfllvzD.mjs → idb-orm-B1Br1C0F.mjs}

@@ -1,9 +1,7 @@
-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 { A as combineFilterExprs, C as planQuery, D as createMutationDefaultsCache, E as applyUpdateDefaults, F as getStoreName, M as fieldValueToken, N as getKeyPath, O as assertEnumValues, P as getRelation, S as lowerRows, T as applyCreateDefaults, _ as readMutationRows, a as collectScalarFkStoreNames, b as withMutationScope, c as executeDeleteWithReferentialActions, d as executeScalarCreateAllWithFkValidation, f as executeScalarCreateWithFkValidation, g as hasScalarFkFields, h as hasNestedMutationCallbacks, i as collectOnUpdateEnforcementStoreNames, j as extractKeyFromRow, k as buildRowComparator, l as executeNestedCreateMutation, m as hasEnforceableChildRelations, n as applyReferentialActionsForRowOnUpdate, o as executeBulkUpdateWithFkValidation, p as executeScalarUpdateWithFkValidation, s as executeDeleteAllWithReferentialActions, u as executeNestedUpdateMutation, v as requireTransactionExecutor, w as buildCatalog, x as lowerCount, y as validateScalarFks } from "./mutation-executor-inLFb0TE.mjs";
 import { AsyncIterableResult } from "@prisma/orm-framework/components/runtime";
-import { andExpr, evaluateFilter, fieldFilter, nullCheckExpr, shorthandToFilterExpr } from "@prisma-idb/adapter-idb/runtime";
+import { andExpr, 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.
@@ -95,190 +93,6 @@ function mergeAccessorState(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
@@ -440,10 +254,8 @@ function createGroupedAccessor(init) {
 * 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.
+* on the whole tuple. It plans one batch lookup for all parents, then groups
+* the rows in memory, which avoids N+1 queries.
 *
 * The `entry` carries any `include()` refinement:
 *
@@ -493,50 +305,19 @@ async function loadRelation(relName, entry, rows, contract, modelName, executor,
 		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);
+	const joinWhere = andExpr(targetFields.map((field, i) => fieldFilter(field, "in", [...localTuples.values()].map((tuple) => tuple[i]))));
+	const where = refinedWhere === void 0 ? joinWhere : andExpr([joinWhere, refinedWhere]);
+	const request = { ...refinedWhere === void 0 ? {} : { where: refinedWhere } };
+	const catalog = buildCatalog(contract, relatedStoreName);
+	const lowered = lowerRows(catalog, planQuery(catalog, { where }), planMeta, request, (row) => {
+		const token = tupleToken(row, targetFields);
+		return token !== null && localTuples.has(token);
+	});
+	const plan = {
+		meta: planMeta,
+		idbPlan: lowered.idbPlan
+	};
+	return attachRelatedRows(relName, entry, rows, lowered.finish(await executor.query(plan).toArray()), relation);
 }
 /** Attach related rows by their join tuple, shaping each parent's collection independently. */
 function attachRelatedRows(relName, entry, rows, relatedRows, relation) {
@@ -598,25 +379,6 @@ function tupleToken(row, fields) {
 	}
 	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
 /**
@@ -677,30 +439,14 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	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);
+			const scan = buildScanPlan(groupingKey);
+			const rows = [];
+			for await (const row of executorQuery(scan.plan)) rows.push(row);
+			const withIncludes = await applyIncludes(scan.finish(rows), groupingKey);
 			for (const row of projectRows(withIncludes)) yield row;
 		})());
 	}
@@ -717,17 +463,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			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));
+		return computeAggregateSpec(spec, await this.#materialize(this.#newGroupingKey(), ast));
 	}
 	groupBy(...fields) {
 		const combined = this.#combinedFilterExpr();
@@ -777,22 +513,31 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	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
-			}
+		const ast = {
+			kind: "findUnique",
+			modelName: this.#modelName,
+			key
 		};
-		for await (const row of this.#executor.query(plan)) return row;
-		return null;
+		const keyPath = getKeyPath(this.#contract, this.#modelName);
+		const fields = typeof keyPath === "string" ? [keyPath] : keyPath;
+		const values = typeof keyPath === "string" ? [key] : key;
+		const where = combineFilterExprs(fields.map((field, i) => ({
+			kind: "field",
+			field,
+			op: "eq",
+			value: values[i]
+		})));
+		const request = {
+			...where === void 0 ? {} : { where },
+			take: 1
+		};
+		const lowered = this.#lowerRows(meta, request);
+		const rows = await this.#executor.query({
+			meta,
+			ast,
+			idbPlan: lowered.idbPlan
+		}).toArray();
+		return lowered.finish(rows)[0] ?? null;
 	}
 	async delete(key) {
 		if (hasEnforceableChildRelations(this.#contract, this.#modelName)) {
@@ -872,7 +617,6 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	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;
@@ -891,13 +635,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			...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];
+			const existing = (await readMutationRows(scope, this.#contract, this.#modelName, whereExpr, 1))[0];
 			if (existing === void 0) {
 				await validateScalarFks(scope, this.#contract, this.#modelName, createWithDefaults);
 				return (await scope.execute({
@@ -981,7 +719,6 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	*/
 	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);
@@ -990,7 +727,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 				executor,
 				contract,
 				modelName,
-				...filter !== void 0 ? { filter } : {}
+				...combined === void 0 ? {} : { where: combined }
 			});
 			for (const row of rows) yield row;
 		})());
@@ -1003,29 +740,27 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		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 { skip, take } = this.#state;
+		const request = {
+			...combined === void 0 ? {} : { where: combined },
+			...skip === void 0 ? {} : { skip },
+			...take === void 0 ? {} : { take }
+		};
+		const meta = this.#planMeta(this.#newGroupingKey());
+		const catalog = buildCatalog(this.#contract, this.#storeName);
+		const lowered = lowerCount(catalog, planQuery(catalog, request), meta, request);
 		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
+			...combined !== void 0 ? { where: combined } : {}
 		};
-		let n = 0;
-		for await (const _ of this.#executor.query(plan)) n++;
-		return n;
+		const rows = await this.#executor.query({
+			meta,
+			ast,
+			idbPlan: lowered.idbPlan
+		}).toArray();
+		return lowered.finish(rows);
 	}
 	/**
 	* Resolve an `include()` argument pair into an {@link IncludeEntry}: run the
@@ -1055,50 +790,27 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		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.
+	* row 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 = {
+		const lowered = this.#lowerRows(meta, { ...combined === void 0 ? {} : { where: combined } });
+		const rows = await this.#executor.query({
 			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;
+			idbPlan: lowered.idbPlan
+		}).toArray();
+		return lowered.finish(rows);
+	}
+	#lowerRows(meta, request) {
+		const catalog = buildCatalog(this.#contract, this.#storeName);
+		return lowerRows(catalog, planQuery(catalog, request), meta, request);
 	}
-	#buildScanPlan(groupingKey, fieldToIndexMap) {
+	#buildScanPlan(groupingKey) {
 		const combined = this.#combinedFilterExpr();
-		const comparator = buildRowComparator(this.#state.orderBy);
 		const meta = this.#planMeta(groupingKey);
 		const ast = {
 			kind: "findMany",
@@ -1108,76 +820,21 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			...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;
+		const lowered = this.#lowerRows(meta, ast);
 		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 = {
+			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));
+				idbPlan: lowered.idbPlan
+			},
+			finish: lowered.finish
+		};
 	}
 	/**
 	* 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}.
+	* Returns `undefined` when no filter has been installed so the planner sees
+	* an unfiltered request. Delegates to the shared {@link combineFilterExprs}.
 	*/
 	#combinedFilterExpr() {
 		return combineFilterExprs(this.#state.filters);
@@ -1253,4 +910,4 @@ function idbOrm(options) {
 //#endregion
 export { idbOrm as t };
 
-//# sourceMappingURL=idb-orm-DsfllvzD.mjs.map
+//# sourceMappingURL=idb-orm-B1Br1C0F.mjs.map