@prisma-idb/client-idb 0.10.0 → 0.11.0

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

@@ -1,9 +1,8 @@
-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 { C as assertEnumValues, D as getRelation, E as getKeyPath, O as getStoreName, S as createMutationDefaultsCache, T as fieldValueToken, _ 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, 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 extractKeyFromRow, x as applyUpdateDefaults, y as withMutationScope } from "./mutation-executor-SJqTuSbb.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";
+import { compareFieldValues, isValidIdbKey, keyEquals } from "@prisma-idb/target-idb/runtime";
 //#region src/core/model-accessor.ts
 /**
 * Proxy-based typed accessor handed to `where(fn)` callbacks.
@@ -108,119 +107,6 @@ function combineFilterExprs(filters) {
 	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).
 *
@@ -240,44 +126,6 @@ function buildRowComparator(orderBy) {
 		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
 /**
@@ -434,16 +282,469 @@ function createGroupedAccessor(init) {
 	} };
 }
 //#endregion
+//#region src/core/planner/catalog.ts
+const catalogs = /* @__PURE__ */ new WeakMap();
+/** Build a catalog once per contract identity and store name. Contracts are immutable. */
+function buildCatalog(contract, storeName) {
+	const cached = catalogs.get(contract)?.get(storeName);
+	if (cached) return cached;
+	const store = contract.storage.stores[storeName];
+	if (!store) throw new Error(`Store "${storeName}" is not in the contract`);
+	const fields = {};
+	for (const model of Object.values(domainModelsAtDefaultNamespace(contract.domain))) {
+		if (model.storage.storeName !== storeName) continue;
+		for (const [name, field] of Object.entries(model.fields)) fields[name] = Object.freeze({
+			codecId: field.type.kind === "scalar" ? field.type.codecId : void 0,
+			nullable: field.nullable,
+			collection: field.many === true || field.dict === true
+		});
+	}
+	const catalog = Object.freeze({
+		storeName,
+		primaryKey: source(store.keyPath, true, false),
+		indexes: Object.freeze(Object.entries(store.indexes ?? {}).map(([name, index]) => source(index.keyPath, index.unique, index.multiEntry ?? false, name))),
+		fields: Object.freeze(fields)
+	});
+	let byStore = catalogs.get(contract);
+	if (!byStore) {
+		byStore = /* @__PURE__ */ new Map();
+		catalogs.set(contract, byStore);
+	}
+	byStore.set(storeName, catalog);
+	return catalog;
+}
+function source(keyPath, unique, multiEntry, indexName) {
+	const path = typeof keyPath === "string" ? keyPath : Object.freeze([...keyPath]);
+	return Object.freeze({
+		keyPath: path,
+		fields: Object.freeze(typeof path === "string" ? [path] : [...path]),
+		unique,
+		multiEntry,
+		...indexName === void 0 ? {} : { indexName }
+	});
+}
+//#endregion
+//#region src/core/planner/plan.ts
+const COST = {
+	UNIQUE_POINT: 0,
+	PRIMARY_POINT: 1,
+	INDEX_POINT: 2,
+	PREFIX_POINT: 3,
+	TWO_SIDED_RANGE: 4,
+	ONE_SIDED_RANGE: 5,
+	ORDER_ONLY_SCAN: 6
+};
+const KEY_PARTIAL_CODECS = /* @__PURE__ */ new Set(["idb/double@1", "idb/date@1"]);
+const KEY_CODECS = /* @__PURE__ */ new Set([
+	"idb/string@1",
+	"idb/int32@1",
+	"idb/double@1",
+	"idb/date@1",
+	"idb/decimal@1",
+	"idb/bytes@1"
+]);
+/** Choose the cheapest safe access without opening IndexedDB or probing cardinality. */
+function planQuery(catalog, request) {
+	const normalized = normalize(request.where);
+	if (normalized.empty) return {
+		access: { kind: "empty" },
+		exact: true
+	};
+	const orders = Object.entries(request.orderBy ?? {});
+	if (normalized.excluded || request.hasRelationFilter || orders.length > 1) return full(false);
+	const constraints = /* @__PURE__ */ new Map();
+	for (const atom of normalized.atoms) {
+		let constraint = constraints.get(atom.field);
+		if (!constraint) {
+			constraint = { consumed: 0 };
+			constraints.set(atom.field, constraint);
+		}
+		addAtom(constraint, atom, catalog.fields[atom.field]);
+	}
+	for (const [name, constraint] of constraints) {
+		if (keyPartial(catalog.fields[name]) && !constraint.rejectsNonKeys) {
+			delete constraint.lower;
+			delete constraint.upper;
+			constraint.consumed = 0;
+		}
+		if (contradictory(constraint)) return {
+			access: { kind: "empty" },
+			exact: true
+		};
+	}
+	const sources = [catalog.primaryKey, ...catalog.indexes];
+	const candidates = sources.flatMap((source, declaration) => {
+		const candidate = filteringCandidate(catalog, source, constraints, declaration);
+		return candidate ? [candidate] : [];
+	});
+	candidates.sort((a, b) => a.cost - b.cost || a.ranges.length - b.ranges.length || Number(a.source.indexName !== void 0) - Number(b.source.indexName !== void 0) || a.declaration - b.declaration);
+	let selected = candidates[0];
+	let direction;
+	if (orders.length === 1 && request.take !== void 0) {
+		const [field, order] = orders[0];
+		if (selected) {
+			if (singleFieldSource(selected.source, field)) direction = order === "asc" ? "next" : "prev";
+		} else {
+			const ordering = sources.find((source) => !source.multiEntry && singleFieldSource(source, field) && completeKeyField(catalog.fields[field]));
+			if (ordering) {
+				selected = {
+					source: ordering,
+					ranges: [void 0],
+					cost: COST.ORDER_ONLY_SCAN,
+					consumed: 0,
+					declaration: sources.indexOf(ordering)
+				};
+				direction = order === "asc" ? "next" : "prev";
+			}
+		}
+	}
+	if (!selected) {
+		const partialOrder = orders.length === 1 && request.take !== void 0 && keyPartial(catalog.fields[orders[0][0]]);
+		return full(normalized.atoms.length + normalized.residual === 0 && !partialOrder);
+	}
+	return {
+		access: {
+			kind: "ranges",
+			source: selected.source,
+			ranges: selected.ranges
+		},
+		exact: selected.consumed === normalized.atoms.length && normalized.residual === 0,
+		...direction === void 0 ? {} : { direction }
+	};
+}
+function full(exact) {
+	return {
+		access: { kind: "full" },
+		exact
+	};
+}
+function normalize(where) {
+	const result = {
+		atoms: [],
+		residual: 0,
+		excluded: false,
+		empty: false
+	};
+	function visit(expr) {
+		switch (expr.kind) {
+			case "field":
+				if (expr.op === "in" && (!Array.isArray(expr.value) || expr.value.length === 0)) result.empty = true;
+				result.atoms.push(expr);
+				break;
+			case "and":
+				expr.exprs.forEach(visit);
+				break;
+			case "or": {
+				if (expr.exprs.length === 0) {
+					result.empty = true;
+					break;
+				}
+				const branches = expr.exprs;
+				const first = branches[0];
+				if (first.kind !== "field" || !branches.every((branch) => branch.kind === "field" && branch.field === first.field && (branch.op === "eq" || branch.op === "in"))) {
+					result.excluded = true;
+					break;
+				}
+				const values = branches.flatMap((branch) => {
+					const atom = branch;
+					return atom.op === "eq" ? [atom.value] : Array.isArray(atom.value) ? atom.value : [];
+				});
+				visit({
+					kind: "field",
+					field: first.field,
+					op: "in",
+					value: values
+				});
+				break;
+			}
+			case "not":
+				result.excluded = true;
+				break;
+			case "null-check": result.residual++;
+		}
+	}
+	if (where) visit(where);
+	return result;
+}
+function keyTyped(field) {
+	return field !== void 0 && !field.collection && KEY_CODECS.has(field.codecId ?? "");
+}
+function keyPartial(field) {
+	return KEY_PARTIAL_CODECS.has(field?.codecId ?? "");
+}
+function completeKeyField(field, constraint) {
+	return keyTyped(field) && field?.nullable === false && (!keyPartial(field) || constraint?.rejectsNonKeys === true);
+}
+function singleFieldSource(source, field) {
+	return source.fields.length === 1 && source.fields[0] === field;
+}
+function addAtom(constraint, atom, field) {
+	if (atom.op === "eq" || atom.op === "in") {
+		const values = atom.op === "eq" ? [atom.value] : Array.isArray(atom.value) ? atom.value : [];
+		if (!values.every(isValidIdbKey)) return;
+		const points = uniqueKeys(values);
+		constraint.points = constraint.points === void 0 ? points : constraint.points.filter((point) => points.some((value) => keyEquals(point, value)));
+		constraint.rejectsNonKeys = true;
+		constraint.consumed++;
+		return;
+	}
+	if (!keyTyped(field)) return;
+	if (atom.op === "startsWith") {
+		if (field?.codecId !== "idb/string@1" || typeof atom.value !== "string") return;
+		intersectBound(constraint, "lower", {
+			value: atom.value,
+			open: false
+		});
+		const upper = stringSuccessor(atom.value);
+		if (upper !== void 0) intersectBound(constraint, "upper", {
+			value: upper,
+			open: true
+		});
+		constraint.startsWith = true;
+		constraint.consumed++;
+	} else if ([
+		"gt",
+		"gte",
+		"lt",
+		"lte"
+	].includes(atom.op) && isValidIdbKey(atom.value)) {
+		const side = atom.op === "gt" || atom.op === "gte" ? "lower" : "upper";
+		const strict = atom.op === "gt" || atom.op === "lt";
+		intersectBound(constraint, side, {
+			value: atom.value,
+			open: strict
+		});
+		if (strict) constraint.rejectsNonKeys = true;
+		constraint.consumed++;
+	}
+}
+function uniqueKeys(values) {
+	const sorted = [...values].sort(compareFieldValues);
+	return sorted.filter((value, i) => i === 0 || compareFieldValues(sorted[i - 1], value) !== 0);
+}
+function intersectBound(constraint, side, bound) {
+	const previous = constraint[side];
+	const comparison = previous === void 0 ? 0 : compareFieldValues(bound.value, previous.value);
+	if (!previous || (side === "lower" ? comparison > 0 : comparison < 0) || comparison === 0 && bound.open) constraint[side] = bound;
+}
+function insideBounds(value, constraint) {
+	const lower = constraint.lower;
+	const upper = constraint.upper;
+	if (lower && (compareFieldValues(value, lower.value) < 0 || lower.open && keyEquals(value, lower.value))) return false;
+	if (upper && (compareFieldValues(value, upper.value) > 0 || upper.open && keyEquals(value, upper.value))) return false;
+	return true;
+}
+function contradictory(constraint) {
+	if (constraint.points) {
+		constraint.points = constraint.points.filter((value) => insideBounds(value, constraint));
+		return constraint.points.length === 0;
+	}
+	if (!constraint.lower || !constraint.upper) return false;
+	const comparison = compareFieldValues(constraint.lower.value, constraint.upper.value);
+	return comparison > 0 || comparison === 0 && (constraint.lower.open || constraint.upper.open);
+}
+function filteringCandidate(catalog, source, constraints, declaration) {
+	if (source.multiEntry || source.fields.length === 0) return void 0;
+	if (source.fields.some((name) => keyPartial(catalog.fields[name]) && !constraints.get(name)?.rejectsNonKeys)) return void 0;
+	let prefixes = [[]];
+	let consumed = 0;
+	let position = 0;
+	while (position < source.fields.length) {
+		const constraint = constraints.get(source.fields[position]);
+		if (constraint?.points === void 0) break;
+		if (prefixes.length * constraint.points.length > 1024) return void 0;
+		prefixes = prefixes.flatMap((prefix) => constraint.points.map((point) => [...prefix, point]));
+		consumed += constraint.consumed;
+		position++;
+	}
+	const constraint = constraints.get(source.fields[position] ?? "");
+	const hasRange = constraint !== void 0 && (constraint.lower !== void 0 || constraint.upper !== void 0);
+	if (position === 0 && !hasRange) return void 0;
+	const used = position + Number(hasRange);
+	if (!source.fields.slice(used).every((field) => completeKeyField(catalog.fields[field], constraints.get(field)))) return void 0;
+	const compound = typeof source.keyPath !== "string";
+	if (position === source.fields.length) return {
+		source,
+		ranges: prefixes.map((prefix) => ({
+			kind: "only",
+			key: compound ? prefix : prefix[0]
+		})),
+		cost: source.indexName !== void 0 && source.unique ? COST.UNIQUE_POINT : source.indexName === void 0 ? COST.PRIMARY_POINT : COST.INDEX_POINT,
+		consumed,
+		declaration
+	};
+	if (hasRange) consumed += constraint.consumed;
+	const ranges = prefixes.map((prefix) => compound ? compoundRange(prefix, constraint, source.fields.length - used) : scalarRange(constraint));
+	if (ranges.some((range) => range.kind === "bound" && (compareFieldValues(range.lower, range.upper) > 0 || keyEquals(range.lower, range.upper) && (range.lowerOpen || range.upperOpen)))) return void 0;
+	return {
+		source,
+		ranges,
+		cost: hasRange ? constraint.lower && constraint.upper && !constraint.startsWith ? COST.TWO_SIDED_RANGE : COST.ONE_SIDED_RANGE : COST.PREFIX_POINT,
+		consumed,
+		declaration
+	};
+}
+function scalarRange(constraint) {
+	if (constraint.lower && constraint.upper) return {
+		kind: "bound",
+		lower: constraint.lower.value,
+		upper: constraint.upper.value,
+		lowerOpen: constraint.lower.open,
+		upperOpen: constraint.upper.open
+	};
+	if (constraint.lower) return {
+		kind: "lower",
+		key: constraint.lower.value,
+		open: constraint.lower.open
+	};
+	return {
+		kind: "upper",
+		key: constraint.upper.value,
+		open: constraint.upper.open
+	};
+}
+function compoundRange(prefix, constraint, trailing) {
+	const lower = constraint?.lower;
+	const upper = constraint?.upper;
+	return {
+		kind: "bound",
+		lower: lower ? [
+			...prefix,
+			lower.value,
+			...lower.open && trailing > 0 ? [[]] : []
+		] : prefix.length ? prefix : [-Infinity],
+		upper: upper ? [
+			...prefix,
+			upper.value,
+			...!upper.open && trailing > 0 ? [[]] : []
+		] : [...prefix, []],
+		lowerOpen: lower?.open ?? false,
+		upperOpen: upper ? upper.open || trailing > 0 : true
+	};
+}
+function stringSuccessor(prefix) {
+	for (let i = prefix.length - 1; i >= 0; i--) {
+		const code = prefix.charCodeAt(i);
+		if (code < 65535) return prefix.slice(0, i) + String.fromCharCode(code + 1);
+	}
+}
+//#endregion
+//#region src/core/planner/lower.ts
+/**
+* Lower row access without creating IDBKeyRange objects or awaiting work.
+* Run `finish` after the executor has materialized all returned rows.
+* Without `orderBy`, row order and pagination selection are unspecified.
+* Rows tied on every ordering field may appear in any order, including at
+* pagination boundaries. Add a unique ordering field for deterministic pages.
+*/
+function lowerRows(catalog, logical, meta, request, additionalFilter) {
+	const filter = (row) => (request.where === void 0 || evaluateFilter(request.where, row)) && (additionalFilter === void 0 || additionalFilter(row));
+	const comparator = logical.direction === void 0 ? buildRowComparator(request.orderBy) : void 0;
+	const base = {
+		meta,
+		storeName: catalog.storeName
+	};
+	const pagination = {
+		...request.skip === void 0 ? {} : { skip: request.skip },
+		...request.take === void 0 ? {} : { take: request.take }
+	};
+	let shapedByDriver = false;
+	let idbPlan;
+	switch (logical.access.kind) {
+		case "empty":
+			idbPlan = {
+				meta,
+				kind: "batch",
+				storeNames: [catalog.storeName],
+				ops: []
+			};
+			break;
+		case "full":
+			idbPlan = {
+				...base,
+				kind: "cursor-scan",
+				filter,
+				...comparator === void 0 ? {} : { comparator },
+				...pagination
+			};
+			shapedByDriver = true;
+			break;
+		case "ranges": {
+			const { source } = logical.access;
+			const ranges = [...logical.access.ranges];
+			if (logical.direction === "prev") ranges.reverse();
+			const single = ranges.length === 1;
+			const ops = ranges.map((range) => {
+				if (range?.kind === "only" && source.indexName === void 0) return {
+					...base,
+					kind: "key-get",
+					key: range.key
+				};
+				const access = {
+					...base,
+					...source.indexName === void 0 ? {} : { indexName: source.indexName },
+					...range === void 0 ? {} : { range }
+				};
+				if (!single && logical.direction !== void 0 && request.take !== void 0) return {
+					...access,
+					kind: "cursor-scan",
+					direction: logical.direction,
+					filter,
+					take: (request.skip ?? 0) + request.take
+				};
+				if (single && request.take !== void 0) {
+					shapedByDriver = true;
+					return {
+						...access,
+						kind: "cursor-scan",
+						filter,
+						...logical.direction === void 0 ? {} : { direction: logical.direction },
+						...comparator === void 0 ? {} : { comparator },
+						...pagination
+					};
+				}
+				if (logical.direction === "prev") return {
+					...access,
+					kind: "cursor-scan",
+					direction: "prev",
+					filter
+				};
+				return {
+					...access,
+					kind: "get-all"
+				};
+			});
+			idbPlan = single ? ops[0] : {
+				meta,
+				kind: "batch",
+				storeNames: [catalog.storeName],
+				ops
+			};
+			break;
+		}
+	}
+	return {
+		idbPlan,
+		finish(rows) {
+			let result = rows.filter(filter);
+			if (!shapedByDriver) {
+				if (comparator !== void 0) result.sort(comparator);
+				const skip = request.skip ?? 0;
+				result = result.slice(skip, request.take === void 0 ? void 0 : skip + request.take);
+			}
+			return result;
+		}
+	};
+}
+//#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.
+* 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 +794,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 +868,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 +928,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 +952,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 +1002,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)) {
@@ -1003,29 +1237,18 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		return this.#countTerminal();
 	}
 	async #countTerminal() {
-		const groupingKey = this.#newGroupingKey();
+		const scan = this.#buildScanPlan(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 } : {}
+			...combined !== void 0 ? { where: combined } : {}
 		};
-		const nativeTotal = await this.#executeNativeCount(scanPlan, ast);
-		if (nativeTotal !== null) return clampCount(nativeTotal, this.#state.skip, this.#state.take);
-		const plan = {
-			...scanPlan,
+		const rows = await this.#executor.query({
+			...scan.plan,
 			ast
-		};
-		let n = 0;
-		for await (const _ of this.#executor.query(plan)) n++;
-		return n;
+		}).toArray();
+		return scan.finish(rows).length;
 	}
 	/**
 	* Resolve an `include()` argument pair into an {@link IncludeEntry}: run the
@@ -1055,50 +1278,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 +1308,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 +1398,4 @@ function idbOrm(options) {
 //#endregion
 export { idbOrm as t };
 
-//# sourceMappingURL=idb-orm-DsfllvzD.mjs.map
+//# sourceMappingURL=idb-orm-BitJ-EMq.mjs.map