@prisma-idb/client-idb 0.9.1 → 0.11.0

package/dist/idb-orm-BitJ-EMq.mjs

@@ -0,0 +1,1401 @@
+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, isValidIdbKey, keyEquals } from "@prisma-idb/target-idb/runtime";
+//#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);
+}
+/**
+* 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;
+	};
+}
+//#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/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 plans one batch lookup for all parents, then groups
+* the rows 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 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) {
+	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);
+}
+//#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 executorQuery = this.#executor.query.bind(this.#executor);
+		const applyIncludes = this.#applyIncludes.bind(this);
+		const projectRows = this.#projectRows.bind(this);
+		return new AsyncIterableResult((async function* () {
+			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;
+		})());
+	}
+	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 } : {}
+		};
+		return computeAggregateSpec(spec, await this.#materialize(this.#newGroupingKey(), 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 ast = {
+			kind: "findUnique",
+			modelName: this.#modelName,
+			key
+		};
+		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)) {
+			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 scan = this.#buildScanPlan(this.#newGroupingKey());
+		const combined = this.#combinedFilterExpr();
+		const ast = {
+			kind: "count",
+			modelName: this.#modelName,
+			...combined !== void 0 ? { where: combined } : {}
+		};
+		const rows = await this.#executor.query({
+			...scan.plan,
+			ast
+		}).toArray();
+		return scan.finish(rows).length;
+	}
+	/**
+	* 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`);
+	}
+	/**
+	* Materialise all rows matching the accumulated filters with no pagination —
+	* used by `aggregate()` / `groupBy()`. The supplied `ast` is attached to the
+	* row plan so middleware can observe the aggregate intent.
+	*/
+	async #materialize(groupingKey, ast) {
+		const combined = this.#combinedFilterExpr();
+		const meta = this.#planMeta(groupingKey);
+		const lowered = this.#lowerRows(meta, { ...combined === void 0 ? {} : { where: combined } });
+		const rows = await this.#executor.query({
+			meta,
+			ast,
+			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) {
+		const combined = this.#combinedFilterExpr();
+		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 } : {}
+		};
+		const lowered = this.#lowerRows(meta, ast);
+		return {
+			plan: {
+				meta,
+				ast,
+				idbPlan: lowered.idbPlan
+			},
+			finish: lowered.finish
+		};
+	}
+	/**
+	* Combine all accumulated filter expressions with AND.
+	*
+	* 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);
+	}
+	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-BitJ-EMq.mjs.map