@prisma-idb/client-idb 0.9.0 → 0.10.0

package/dist/{idb-orm-C8yXJp6R.mjs → mutation-executor-CD5n_kKT.mjs}

@@ -1,7 +1,6 @@
-import { AsyncIterableResult } from "@prisma/orm-framework/components/runtime";
-import { andExpr, evaluateFilter, fieldFilter, nullCheckExpr, shorthandToFilterExpr } from "@prisma-idb/adapter-idb/runtime";
+import { evaluateFilter, shorthandToFilterExpr } from "@prisma-idb/adapter-idb/runtime";
 import { domainModelsAtDefaultNamespace } from "@prisma/orm-framework/contract/types";
-import { compareFieldValues, fieldValueToken, fieldValuesEqual, isValidIdbKey, keyEquals, keyToken } from "@prisma-idb/target-idb/runtime";
+import { fieldValueToken, fieldValuesEqual, isValidIdbKey, keyEquals, keyToken } from "@prisma-idb/target-idb/runtime";
 import { generateId } from "@prisma/orm-framework/ids/runtime";
 import { keyPathFields } from "@prisma-idb/target-idb/pack";
 //#region src/core/types.ts
@@ -41,9 +40,9 @@ function extractKeyFromRow(row, keyPath) {
 }
 /**
 * Build a field → indexName lookup for every single-field, non-multi-entry
-* index on `storeName`. Shared by {@link getIndexForField} (relation loader,
-* single-field lookups) and {@link IdbStoreAccessorImpl} (top-level scans,
-* which need the whole map to probe combined filter expressions).
+* index on `storeName`. Top-level scans use this map to find indexed equality
+* conditions in combined filter expressions. Compound and multi-entry indexes
+* cannot serve these single-field point lookups.
 */
 function buildFieldToIndexMap(contract, storeName) {
 	const storeDef = contract.storage.stores[storeName];
@@ -64,446 +63,6 @@ function getRelation(contract, modelName, relName) {
 	return relation;
 }
 //#endregion
-//#region src/core/model-accessor.ts
-/**
-* Proxy-based typed accessor handed to `where(fn)` callbacks.
-*
-* Mirrors `createModelAccessor()` from
-* Prisma ORM's SQL client, but without
-* the codec-trait gating — IDB stores native JS values, so every operator
-* is available on every field. The runtime accessor object is a Proxy
-* that materialises an `IdbFieldAccessor` on demand for whichever field
-* name is read; the type-level surface narrows that to the model's
-* actual field set so callbacks get autocomplete.
-*/
-/**
-* Build an {@link IdbFieldAccessor} for a single field. The accessor is
-* shared via the proxy below, but each accessor instance is bound to its
-* own field name so the produced AST nodes carry the right field.
-*/
-function createFieldAccessor(field) {
-	return {
-		eq: (value) => fieldFilter(field, "eq", value),
-		neq: (value) => fieldFilter(field, "neq", value),
-		gt: (value) => fieldFilter(field, "gt", value),
-		lt: (value) => fieldFilter(field, "lt", value),
-		gte: (value) => fieldFilter(field, "gte", value),
-		lte: (value) => fieldFilter(field, "lte", value),
-		in: (values) => fieldFilter(field, "in", values),
-		notIn: (values) => fieldFilter(field, "notIn", values),
-		contains: (sub) => fieldFilter(field, "contains", sub),
-		startsWith: (sub) => fieldFilter(field, "startsWith", sub),
-		endsWith: (sub) => fieldFilter(field, "endsWith", sub),
-		isNull: () => nullCheckExpr(field, true),
-		isNotNull: () => nullCheckExpr(field, false)
-	};
-}
-/**
-* Create the typed model accessor used by `where(fn)` callbacks.
-*
-* Implemented as a Proxy keyed on field names — every read returns an
-* {@link IdbFieldAccessor} bound to that field. The accessor cache means
-* `m.name.eq(...)` and `m.name.startsWith(...)` reuse the same per-field
-* accessor object across the same `where()` invocation.
-*
-* The type parameter is structural — no contract is consulted at
-* runtime, because TS already gates the visible field set at compile
-* time. (Misspelled fields surface as accessor calls on names that
-* don't exist in stored rows, which is consistent with how the
-* shorthand form behaves today.)
-*/
-function createModelAccessor() {
-	const cache = /* @__PURE__ */ new Map();
-	return new Proxy({}, { get(_target, prop) {
-		if (typeof prop !== "string") return void 0;
-		let acc = cache.get(prop);
-		if (acc === void 0) {
-			acc = createFieldAccessor(prop);
-			cache.set(prop, acc);
-		}
-		return acc;
-	} });
-}
-//#endregion
-//#region src/core/store-state.ts
-/** Build an {@link IdbIncludeScalar} marker for a `count()` reducer. */
-function createIncludeScalar(state) {
-	return {
-		kind: "includeScalar",
-		fn: "count",
-		state
-	};
-}
-/** Type guard: is `value` an {@link IdbIncludeScalar} marker? */
-function isIncludeScalar(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const candidate = value;
-	return candidate.kind === "includeScalar" && candidate.fn === "count";
-}
-/** Create a fresh, empty accessor state (no filters, no ordering, no includes). */
-function emptyAccessorState() {
-	return {
-		filters: [],
-		includes: {}
-	};
-}
-/** Return a shallow-merged copy of `state` with the given overrides applied. */
-function mergeAccessorState(state, overrides) {
-	return {
-		...state,
-		...overrides
-	};
-}
-//#endregion
-//#region src/core/query-shaping.ts
-/**
-* Combine accumulated filter expressions with AND.
-*
-* Returns `undefined` when no filter is present so callers can skip building a
-* row-filter closure. Shared by {@link IdbStoreAccessorImpl} (top-level scans)
-* and the relation loader (refined `include()` child scans).
-*/
-function combineFilterExprs(filters) {
-	if (filters.length === 0) return void 0;
-	if (filters.length === 1) return filters[0];
-	return andExpr(filters);
-}
-/** Recursively flatten nested AND nodes into a single array of children. */
-function flattenAnd(filter) {
-	if (filter.kind !== "and") return [filter];
-	return filter.exprs.flatMap(flattenAnd);
-}
-/** Fold the leftover AND children (after peeling an indexed condition) back into a single filter, or `undefined` if none remain. */
-function foldRemainder(rest) {
-	if (rest.length === 0) return void 0;
-	if (rest.length === 1) return rest[0];
-	return andExpr(rest);
-}
-/**
-* `IDBKeyRange.only()` throws `DataError` for values that aren't valid
-* IndexedDB keys (`null`/`undefined`, booleans, `NaN`, `BigInt`, plain
-* objects, or arrays containing any of those) — an `eq` condition on such a
-* value can't be served by an index point-range scan and must fall back to
-* a full scan. Delegates to the shared {@link isValidIdbKey} check.
-*/
-function isIndexableEqValue(value) {
-	return isValidIdbKey(value);
-}
-/**
-* `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)) && isIndexableEqValue(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)) && isIndexableEqValue(expr.value)) {
-					const rest = flat.filter((_, j) => j !== i);
-					return {
-						indexName,
-						value: expr.value,
-						remainingFilter: foldRemainder(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) || !isIndexableEqValue(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, foldRemainder(flat.filter((_, j) => j !== orIdx)));
-	}
-	return null;
-}
-/**
-* Build an in-memory comparator from an `orderBy` spec (field → direction).
-*
-* Returns `undefined` when there is nothing to sort by. Compares fields in
-* declaration order, with {@link compareFieldValues}: the same order an
-* IndexedDB index uses, so equal `Date`s tie and fall through to the next
-* field, and `null`s sort last (first when descending).
-*/
-function buildRowComparator(orderBy) {
-	if (orderBy === void 0) return void 0;
-	return (a, b) => {
-		for (const [field, dir] of Object.entries(orderBy)) {
-			const cmp = compareFieldValues(a[field], b[field]);
-			if (cmp === 0) continue;
-			return dir === "desc" ? -cmp : cmp;
-		}
-		return 0;
-	};
-}
-/**
-* `true` when a `cursor-scan` plan's result *cardinality* is fully determined
-* by its store/index + key range — i.e. there is no in-memory `filter` that
-* would need each row's value. Only then can `count()` be answered natively
-* (`store.count(range)` / `index.count(range)`) without deserializing rows.
-*
-* `comparator` (ORDER BY), `direction`, `skip` and `take` don't change *which*
-* rows match, so they don't disqualify a plan — `skip`/`take` are applied to
-* the native total afterwards via {@link clampCount}.
-*
-* Safe for index scans because the equality hint that builds `range` never
-* selects a `multiEntry` (or compound) index — `buildFieldToIndexMap` excludes
-* them — so one record maps to at most one index entry and entries == rows.
-*/
-function isNativelyCountable(plan) {
-	return plan.filter === void 0;
-}
-/** Rewrites a natively-countable `cursor-scan` as the equivalent native `count` plan. */
-function toCountPlan(plan) {
-	return {
-		meta: plan.meta,
-		kind: "count",
-		storeName: plan.storeName,
-		...plan.indexName !== void 0 ? { indexName: plan.indexName } : {},
-		...plan.range !== void 0 ? { range: plan.range } : {}
-	};
-}
-/**
-* Applies `skip`/`take` to an *unpaginated* total. A paginated count is pure
-* arithmetic on the unpaginated count — `max(0, total - skip)`, capped at
-* `take` — so this is exact, not an approximation.
-*/
-function clampCount(total, skip, take) {
-	let n = total;
-	if (skip !== void 0) n = Math.max(0, n - skip);
-	if (take !== void 0) n = Math.min(take, n);
-	return n;
-}
-//#endregion
-//#region src/core/aggregate-builder.ts
-/**
-* Build the aggregate selector factory handed to `.aggregate(agg => …)` and
-* `groupBy(...).aggregate(agg => …)`.
-*
-* Each method returns a frozen {@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 the composite group key for a row. Uses a JSON encoding of the ordered
-* key-field values so multi-field groups and primitive value types (string,
-* number, boolean, null) partition correctly.
-*/
-function groupKeyOf(by, row) {
-	return JSON.stringify(by.map((field) => row[field] ?? null));
-}
-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/enum-validation.ts
 const rulesByContract = /* @__PURE__ */ new WeakMap();
 function resolveEnumRule(contract, field) {
@@ -632,186 +191,6 @@ function applyUpdateDefaults(defaults, storeName, patch, cache) {
 	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.
-*
-* 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;
-	const relatedModel = models[relatedModelName];
-	if (relatedModel === void 0) return rows;
-	const relatedStoreName = typeof relatedModel.storage === "object" && relatedModel.storage !== null && "storeName" in relatedModel.storage ? String(relatedModel.storage["storeName"]) : relatedModelName;
-	const isScalar = entry.kind === "scalar";
-	const localTuples = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const token = tupleToken(row, localFields);
-		if (token !== null) localTuples.set(token, localFields.map((f) => row[f]));
-	}
-	if (localTuples.size === 0) return rows.map((row) => ({
-		...row,
-		[relName]: isScalar ? 0 : cardinality === "1:N" ? [] : null
-	}));
-	const refinedWhere = combineFilterExprs(entry.state.filters);
-	const planMeta = {
-		target: "idb",
-		storageHash: contract.storage.storageHash,
-		lane: "idb-orm",
-		annotations: { groupingKey }
-	};
-	const rangeSource = findRangeSource(contract, relatedStoreName, relatedModelName, targetFields);
-	let relatedRows;
-	if (rangeSource !== void 0) {
-		const refinedFilter = refinedWhere !== void 0 ? (row) => evaluateFilter(refinedWhere, row) : void 0;
-		const ranges = [];
-		for (const values of localTuples.values()) {
-			const ordered = keyPathFields(rangeSource.keyPath).map((f) => values[targetFields.indexOf(f)]);
-			if (!ordered.every((v) => isValidIdbKey(v))) continue;
-			ranges.push(IDBKeyRange.only(typeof rangeSource.keyPath === "string" ? ordered[0] : ordered));
-		}
-		relatedRows = (await Promise.all(ranges.map(async (range) => {
-			const plan = {
-				meta: planMeta,
-				idbPlan: {
-					meta: planMeta,
-					kind: "cursor-scan",
-					storeName: relatedStoreName,
-					...rangeSource.indexName !== void 0 ? { indexName: rangeSource.indexName } : {},
-					range,
-					...refinedFilter !== void 0 ? { filter: refinedFilter } : {}
-				}
-			};
-			const rows = [];
-			for await (const row of executor.query(plan)) rows.push(row);
-			return rows;
-		}))).flat();
-	} else {
-		relatedRows = [];
-		const filter = (row) => {
-			const token = tupleToken(row, targetFields);
-			return token !== null && localTuples.has(token) && (refinedWhere === void 0 || evaluateFilter(refinedWhere, row));
-		};
-		const plan = {
-			meta: planMeta,
-			idbPlan: {
-				meta: planMeta,
-				kind: "cursor-scan",
-				storeName: relatedStoreName,
-				filter
-			}
-		};
-		for await (const row of executor.query(plan)) relatedRows.push(row);
-	}
-	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 (isScalar) return rows.map((row) => ({
-			...row,
-			[relName]: groupFor(row).length
-		}));
-		const comparator = buildRowComparator(entry.state.orderBy);
-		const skip = entry.state.skip ?? 0;
-		const take = entry.state.take;
-		return rows.map((row) => {
-			let group = groupFor(row);
-			if (comparator !== void 0) group = [...group].sort(comparator);
-			if (skip > 0 || take !== void 0) group = group.slice(skip, take !== void 0 ? skip + take : void 0);
-			return {
-				...row,
-				[relName]: group
-			};
-		});
-	}
-	const indexed = /* @__PURE__ */ new Map();
-	for (const rrow of relatedRows) {
-		const token = tupleToken(rrow, targetFields);
-		if (token !== null) indexed.set(token, rrow);
-	}
-	return rows.map((row) => {
-		const token = tupleToken(row, localFields);
-		return {
-			...row,
-			[relName]: (token === null ? void 0 : indexed.get(token)) ?? null
-		};
-	});
-}
-/**
-* A `Map` key for the values of `fields` in `row`, or `null` when any of them
-* is null or undefined. Equal `Date`s and binary values give equal tokens.
-*/
-function tupleToken(row, fields) {
-	const parts = [];
-	for (const field of fields) {
-		const value = row[field];
-		if (value === null || value === void 0) return null;
-		const token = fieldValueToken(value);
-		parts.push([typeof token, String(token)]);
-	}
-	return JSON.stringify(parts);
-}
-/**
-* Finds an index, or else the store's primary key, whose key path has exactly
-* `fields` (in any order), so a lookup on those fields can use a key range.
-* Returns `undefined` when there is none, or when `IDBKeyRange` isn't available.
-*/
-function findRangeSource(contract, storeName, modelName, fields) {
-	if (typeof IDBKeyRange === "undefined") return void 0;
-	const coversFields = (keyPath) => {
-		const keyFields = keyPathFields(keyPath);
-		return keyFields.length === fields.length && keyFields.every((f) => fields.includes(f));
-	};
-	const indexes = contract.storage.stores[storeName]?.indexes ?? {};
-	for (const [indexName, indexDef] of Object.entries(indexes)) if (indexDef.multiEntry !== true && coversFields(indexDef.keyPath)) return {
-		indexName,
-		keyPath: indexDef.keyPath
-	};
-	const primaryKey = getKeyPath(contract, modelName);
-	return coversFields(primaryKey) ? { keyPath: primaryKey } : void 0;
-}
-//#endregion
 //#region src/core/mutation-scope.ts
 /**
 * Run a callback inside a single multi-store IDB readwrite transaction.
@@ -980,7 +359,7 @@ async function createGraph(scope, contract, modelName, input, defaultsCache) {
 	const scalarData = { ...parsed.scalarData };
 	for (const item of parentOwned) {
 		if (item.mutation.kind === "disconnect") throw new Error("disconnect() is only supported in update() nested mutations");
-		await applyParentOwnedMutation(scope, contract, modelName, scalarData, item.relation, item.mutation, defaultsCache);
+		await applyParentOwnedMutation(scope, contract, scalarData, item.relation, item.mutation, defaultsCache);
 	}
 	const parentRow = await insertSingleRow(scope, contract, modelName, scalarData, defaultsCache);
 	for (const item of childOwned) {
@@ -995,7 +374,7 @@ async function updateFirstGraph(scope, contract, modelName, filters, input, defa
 	const parsed = parseMutationInput(contract, modelName, input);
 	const { parentOwned, childOwned } = partitionByOwnership(parsed.relationMutations);
 	const scalarData = { ...parsed.scalarData };
-	for (const item of parentOwned) await applyParentOwnedMutation(scope, contract, modelName, scalarData, item.relation, item.mutation, defaultsCache);
+	for (const item of parentOwned) await applyParentOwnedMutation(scope, contract, scalarData, item.relation, item.mutation, defaultsCache);
 	let parentRow = existingRow;
 	if (Object.keys(scalarData).length > 0) {
 		const storeName = getStoreName(contract, modelName);
@@ -1056,7 +435,7 @@ function partitionByOwnership(mutations) {
 		childOwned
 	};
 }
-async function applyParentOwnedMutation(scope, contract, parentModelName, scalarData, relation, mutation, defaultsCache) {
+async function applyParentOwnedMutation(scope, contract, scalarData, relation, mutation, defaultsCache) {
 	if (mutation.kind === "disconnect") {
 		for (const localField of relation.localFields) scalarData[localField] = null;
 		return;
@@ -1064,16 +443,16 @@ async function applyParentOwnedMutation(scope, contract, parentModelName, scalar
 	if (mutation.kind === "create") {
 		const row = mutation.data[0];
 		if (!row) throw new Error(`create() nested mutation for relation "${relation.relationName}" requires data`);
-		copyRelatedValuesToParent(relation, scalarData, await insertSingleRow(scope, contract, relation.relatedModelName, row, defaultsCache), parentModelName, contract);
+		copyRelatedValuesToParent(relation, scalarData, await insertSingleRow(scope, contract, relation.relatedModelName, row, defaultsCache));
 		return;
 	}
 	const criterion = mutation.criteria[0];
 	if (!criterion) throw new Error(`connect() nested mutation for relation "${relation.relationName}" requires a criterion`);
 	const relatedRow = await findRowByCriterion(scope, contract, relation.relatedModelName, criterion);
 	if (!relatedRow) throw new Error(`connect() nested mutation for relation "${relation.relationName}" did not find a matching row`);
-	copyRelatedValuesToParent(relation, scalarData, relatedRow, parentModelName, contract);
+	copyRelatedValuesToParent(relation, scalarData, relatedRow);
 }
-function copyRelatedValuesToParent(relation, scalarData, relatedRow, _parentModelName, _contract) {
+function copyRelatedValuesToParent(relation, scalarData, relatedRow) {
 	for (let i = 0; i < relation.localFields.length; i++) {
 		const localField = relation.localFields[i];
 		const targetField = relation.targetFields[i];
@@ -1262,13 +641,7 @@ function findDeclaredAction(contract, modelName, def, kind) {
 function enforcedAction(declared) {
 	return declared === void 0 || declared === "noAction" ? "restrict" : declared;
 }
-function getOnDeleteForDeleteRelation(contract, modelName, def) {
-	return getReferentialActionForRelation(contract, modelName, def, "onDelete");
-}
-function getOnUpdateForRelation(contract, modelName, def) {
-	return getReferentialActionForRelation(contract, modelName, def, "onUpdate");
-}
-function isDeleteEnforcementRelation(contract, modelName, def) {
+function isChildEnforcementRelation(contract, modelName, def) {
 	if (def.cardinality === "1:N") return true;
 	if (def.cardinality === "1:1") {
 		const keyPath = getKeyPath(contract, modelName);
@@ -1418,17 +791,17 @@ function collectOnUpdateEnforcementStoreNames(contract, modelName, data) {
 		if (visitedModels.has(mName)) return;
 		visitedModels.add(mName);
 		for (const def of getRelationDefinitions(contract, mName)) {
-			if (!isDeleteEnforcementRelation(contract, mName, def)) continue;
-			const action = getOnUpdateForRelation(contract, mName, def);
+			if (!isChildEnforcementRelation(contract, mName, def)) continue;
+			const action = getReferentialActionForRelation(contract, mName, def, "onUpdate");
 			stores.add(def.relatedStoreName);
 			if (action === "cascade") walkCascadeChain(def.relatedModelName);
 		}
 	}
 	visitedModels.add(modelName);
 	for (const def of getRelationDefinitions(contract, modelName)) {
-		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
+		if (!isChildEnforcementRelation(contract, modelName, def)) continue;
 		if (!def.localFields.some((f) => f in data)) continue;
-		const action = getOnUpdateForRelation(contract, modelName, def);
+		const action = getReferentialActionForRelation(contract, modelName, def, "onUpdate");
 		enforces = true;
 		stores.add(def.relatedStoreName);
 		if (action === "cascade") walkCascadeChain(def.relatedModelName);
@@ -1455,11 +828,8 @@ function collectOnUpdateEnforcementStoreNames(contract, modelName, data) {
 * `setNull`/`setDefault` are leaf actions: the child's FK field changes but
 * its own key doesn't, so nothing below it needs re-enforcement.
 *
-* Unlike `validateScalarFks`'s compound-FK restriction, a compound (multi-
-* field) relation is safe to cascade here: both `localFields` values come
-* from the same `oldRow`/`patch`, so there's no risk of assembling a value
-* from two unrelated rows the way independently-validated FK-existence
-* checks could.
+* Compound relations use values from the same `oldRow`/`patch`, so every
+* child is matched against the full pre-change tuple.
 */
 async function applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch, visited = /* @__PURE__ */ new Set()) {
 	const keyPath = getKeyPath(contract, modelName);
@@ -1468,10 +838,10 @@ async function applyReferentialActionsForRowOnUpdate(scope, contract, modelName,
 	visited.add(rowKey);
 	const meta = makePlanMeta(contract);
 	for (const def of getRelationDefinitions(contract, modelName)) {
-		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
+		if (!isChildEnforcementRelation(contract, modelName, def)) continue;
 		const changedFields = def.localFields.filter((f) => f in patch && !fieldValuesEqual(patch[f], oldRow[f]));
 		if (changedFields.length === 0) continue;
-		const action = getOnUpdateForRelation(contract, modelName, def);
+		const action = getReferentialActionForRelation(contract, modelName, def, "onUpdate");
 		const childFilter = buildChildFilterFromRow(def, oldRow);
 		if (action === "restrict") {
 			if (await childExists(scope, contract, meta, def, oldRow)) throw new Error(`Cannot update ${modelName} '${keyToken(extractKeyFromRow(oldRow, keyPath))}': changing field(s) ${changedFields.join(", ")} would orphan child records on relation '${def.relationName}'. Update or remove those children first, or declare onUpdate: Cascade, SetNull or SetDefault on the relation.`);
@@ -1650,8 +1020,8 @@ async function executeScalarCreateAllWithFkValidation(options) {
 * Combines FK-existence store scope (this model's own N:1 relations) with
 * `onUpdate` enforcement store scope (this model's child relations) for a
 * single write. Returns the union alongside whether `onUpdate` enforcement
-* actually applies (i.e. the `onUpdate` collector found more than just the
-* model's own store) — callers use that flag to choose between the existing
+* actually applies, including self-relations that touch only this model's
+* own store. Callers use that flag to choose between the existing
 * fast blind-write path and the read-before-write enforcement path.
 */
 function collectUpdateStoreNames(contract, modelName, data) {
@@ -1662,68 +1032,25 @@ function collectUpdateStoreNames(contract, modelName, data) {
 		enforcesOnUpdate: enforces
 	};
 }
+/** Updates the first matching row with FK validation and referential actions. */
 async function executeScalarUpdateWithFkValidation(options) {
-	const { executor, contract, modelName, filters, data } = options;
-	const storeName = getStoreName(contract, modelName);
-	const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, data, createMutationDefaultsCache());
-	assertEnumValues(contract, modelName, patch);
-	const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, patch);
-	const needsRowForFks = fkCheckNeedsExistingRow(contract, modelName, patch);
-	return withMutationScope(executor, storeNames, async (scope) => {
-		if (!needsRowForFks) await validateScalarFks(scope, contract, modelName, patch);
-		const meta = makePlanMeta(contract);
-		const combined = filters.length === 0 ? void 0 : filters.length === 1 ? filters[0] : {
-			kind: "and",
-			exprs: filters
-		};
-		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
-		if (!enforcesOnUpdate && !needsRowForFks) return (await scope.execute({
-			meta,
-			kind: "scan-write",
-			storeName,
-			write: "put-merged",
-			patch,
-			take: 1,
-			...filter !== void 0 ? { filter } : {}
-		}))[0] ?? null;
-		const oldRow = (await scope.execute({
-			meta,
-			kind: "cursor-scan",
-			storeName,
-			take: 1,
-			...filter !== void 0 ? { filter } : {}
-		}))[0];
-		if (!oldRow) return null;
-		if (needsRowForFks) await validateScalarFks(scope, contract, modelName, patch, oldRow);
-		if (enforcesOnUpdate) await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch);
-		const key = extractKeyFromRow(oldRow, getKeyPath(contract, modelName));
-		return (await scope.execute({
-			meta,
-			kind: "update",
-			storeName,
-			key,
-			patch
-		}))[0] ?? null;
-	});
+	return (await executeScalarUpdates(options, 1))[0] ?? null;
 }
 /**
 * Bulk counterpart to {@link executeScalarUpdateWithFkValidation}: same FK
 * validation and `onUpdate` enforcement, but applies the patch to every row
 * the filter matches (no `take: 1`) and returns all of them.
 *
-* Always goes through the transaction scope — unlike single-row `update()`,
-* which only needs one when there's a scalar FK field or `onUpdate`
-* enforcement to apply. A bulk scan-write's affected row SET isn't knowable
-* until it actually runs, and observing that result INSIDE the same
-* transaction is exactly what the sync interceptor needs to track the write
-* correctly: its transaction-scope hook (`SyncInterceptingTransactionScope#maybeTrack`'s
-* `scan-write`/`update` cases) writes one outbox event per row it's handed,
-* atomically with the write itself. The plan-level path `update()` falls
-* back to for a non-enforced single row has no equivalent hook — a plan is
-* extended with outbox ops BEFORE it runs, which only works when the
-* affected key is knowable up front.
+* The transaction scope lets the sync interceptor observe the affected rows
+* and write one outbox event per row in the same transaction. A bulk write's
+* affected keys are only known after it runs, so tracking cannot happen by
+* extending the plan before execution.
 */
 async function executeBulkUpdateWithFkValidation(options) {
+	return executeScalarUpdates(options);
+}
+/** Shares validation and atomic writes; only single-row updates limit the scan. */
+async function executeScalarUpdates(options, take) {
 	const { executor, contract, modelName, filters, data } = options;
 	const storeName = getStoreName(contract, modelName);
 	const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, data, createMutationDefaultsCache());
@@ -1744,12 +1071,14 @@ async function executeBulkUpdateWithFkValidation(options) {
 			storeName,
 			write: "put-merged",
 			patch,
+			...take !== void 0 ? { take } : {},
 			...filter !== void 0 ? { filter } : {}
 		});
 		const oldRows = await scope.execute({
 			meta,
 			kind: "cursor-scan",
 			storeName,
+			...take !== void 0 ? { take } : {},
 			...filter !== void 0 ? { filter } : {}
 		});
 		const keyPath = getKeyPath(contract, modelName);
@@ -1776,7 +1105,7 @@ async function executeBulkUpdateWithFkValidation(options) {
 * behaves like `restrict`, which is also the default.
 */
 function hasEnforceableChildRelations(contract, modelName) {
-	return getRelationDefinitions(contract, modelName).some((def) => isDeleteEnforcementRelation(contract, modelName, def));
+	return getRelationDefinitions(contract, modelName).some((def) => isChildEnforcementRelation(contract, modelName, def));
 }
 /**
 * Transitively walks the `onDelete` cascade graph from `modelName`, collecting
@@ -1797,8 +1126,8 @@ function collectDeleteStoreNames(contract, modelName) {
 		visitedModels.add(mName);
 		stores.add(getStoreName(contract, mName));
 		for (const def of getRelationDefinitions(contract, mName)) {
-			if (!isDeleteEnforcementRelation(contract, mName, def)) continue;
-			const action = getOnDeleteForDeleteRelation(contract, mName, def);
+			if (!isChildEnforcementRelation(contract, mName, def)) continue;
+			const action = getReferentialActionForRelation(contract, mName, def, "onDelete");
 			stores.add(def.relatedStoreName);
 			if (action === "cascade") walk(def.relatedModelName);
 		}
@@ -1831,8 +1160,8 @@ async function applyReferentialActionsForRow(scope, contract, modelName, row, vi
 	visited.add(rowKey);
 	const meta = makePlanMeta(contract);
 	for (const def of getRelationDefinitions(contract, modelName)) {
-		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
-		const action = getOnDeleteForDeleteRelation(contract, modelName, def);
+		if (!isChildEnforcementRelation(contract, modelName, def)) continue;
+		const action = getReferentialActionForRelation(contract, modelName, def, "onDelete");
 		const childFilter = buildChildFilterFromRow(def, row);
 		if (action === "restrict") {
 			if (await childExists(scope, contract, meta, def, row)) throw new Error(`Cannot delete ${modelName} '${keyToken(extractKeyFromRow(row, keyPath))}': child records exist on relation '${def.relationName}'. Delete those children first, or declare onDelete: Cascade, SetNull or SetDefault on the relation.`);
@@ -1933,655 +1262,6 @@ async function executeDeleteAllWithReferentialActions(options) {
 	});
 }
 //#endregion
-//#region src/core/store-accessor.ts
-/**
-* Concrete immutable query builder.
-*
-* Internal details:
-* - All state is in `#state` (filters, orderBy, skip, take, includes, selectedFields).
-* - Builder methods clone via `#clone()` — O(1) copies since state is
-*   structurally shared.
-* - `all()` materialises the main rows first, then batch-loads each included
-*   relation, then applies any `.select()` projection before yielding.
-* - `#includeRefinementMode` flips `count()` from an async terminal to an
-*   {@link IdbIncludeScalar} marker so it can be used inside `include()`.
-*/
-var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
-	#contract;
-	#modelName;
-	#executor;
-	#storeName;
-	#state;
-	#newGroupingKey;
-	#includeRefinementMode;
-	constructor(contract, modelName, executor, state, newGroupingKey, includeRefinementMode = false) {
-		this.#contract = contract;
-		this.#modelName = modelName;
-		this.#executor = executor;
-		this.#storeName = getStoreName(contract, modelName);
-		this.#state = state ?? emptyAccessorState();
-		let _key = 0;
-		this.#newGroupingKey = newGroupingKey ?? (() => `idb-op-${++_key}`);
-		this.#includeRefinementMode = includeRefinementMode;
-	}
-	where(filter) {
-		const expr = typeof filter === "function" ? filter(createModelAccessor()) : shorthandToFilterExpr(filter);
-		if (expr === void 0) return this.#clone({});
-		return this.#clone({ filters: [...this.#state.filters, expr] });
-	}
-	orderBy(spec) {
-		return this.#clone({ orderBy: spec });
-	}
-	take(n) {
-		return this.#clone({ take: n });
-	}
-	skip(n) {
-		return this.#clone({ skip: n });
-	}
-	include(relation, refineFn) {
-		const entry = this.#resolveIncludeEntry(relation, refineFn);
-		const newState = mergeAccessorState(this.#state, { includes: {
-			...this.#state.includes,
-			[relation]: entry
-		} });
-		return new IdbStoreAccessorImpl(this.#contract, this.#modelName, this.#executor, newState, this.#newGroupingKey, this.#includeRefinementMode);
-	}
-	select(...fields) {
-		return this.#clone({ selectedFields: fields });
-	}
-	all() {
-		const groupingKey = this.#newGroupingKey();
-		const buildScanPlan = this.#buildScanPlan.bind(this);
-		const executeOrRows = this.#executeOrRows.bind(this);
-		const executorQuery = this.#executor.query.bind(this.#executor);
-		const applyIncludes = this.#applyIncludes.bind(this);
-		const projectRows = this.#projectRows.bind(this);
-		const combined = this.#combinedFilterExpr();
-		const fieldToIndexMap = typeof IDBKeyRange !== "undefined" ? buildFieldToIndexMap(this.#contract, this.#storeName) : void 0;
-		const keyPath = getKeyPath(this.#contract, this.#modelName);
-		const comparator = buildRowComparator(this.#state.orderBy);
-		const skip = this.#state.skip;
-		const take = this.#state.take;
-		return new AsyncIterableResult((async function* () {
-			let rows;
-			const orHint = fieldToIndexMap !== void 0 ? extractIndexOrHint(combined, fieldToIndexMap, keyPath) : null;
-			if (orHint !== null) {
-				rows = await executeOrRows(orHint, groupingKey, combined);
-				if (comparator !== void 0) rows.sort(comparator);
-				if (skip !== void 0) rows = rows.slice(skip);
-				if (take !== void 0) rows = rows.slice(0, take);
-			} else {
-				const scanPlan = buildScanPlan(groupingKey, fieldToIndexMap);
-				rows = [];
-				for await (const row of executorQuery(scanPlan)) rows.push(row);
-			}
-			const withIncludes = await applyIncludes(rows, groupingKey);
-			for (const row of projectRows(withIncludes)) yield row;
-		})());
-	}
-	async first() {
-		return this.take(1).all().first();
-	}
-	async aggregate(fn) {
-		const spec = fn(createAggregateBuilder());
-		assertValidAggregateSpec(spec, "aggregate()");
-		const combined = this.#combinedFilterExpr();
-		const ast = {
-			kind: "aggregate",
-			modelName: this.#modelName,
-			aggregates: toAggregateRequests(spec),
-			...combined !== void 0 ? { where: combined } : {}
-		};
-		const groupingKey = this.#newGroupingKey();
-		if (Object.values(spec).every((selector) => selector.fn === "count")) {
-			const scanPlan = this.#buildScanPlan(groupingKey);
-			const total = await this.#executeNativeCount(scanPlan, ast);
-			if (total !== null) {
-				const result = {};
-				for (const alias of Object.keys(spec)) result[alias] = total;
-				return result;
-			}
-		}
-		return computeAggregateSpec(spec, await this.#materialize(groupingKey, ast));
-	}
-	groupBy(...fields) {
-		const combined = this.#combinedFilterExpr();
-		const materialize = (ast) => this.#materialize(this.#newGroupingKey(), ast);
-		return createGroupedAccessor({
-			modelName: this.#modelName,
-			by: fields,
-			where: combined,
-			materialize
-		});
-	}
-	async create(data) {
-		const record = data;
-		if (hasNestedMutationCallbacks(this.#contract, this.#modelName, record)) return await executeNestedCreateMutation({
-			executor: requireTransactionExecutor(this.#executor),
-			contract: this.#contract,
-			modelName: this.#modelName,
-			data: record
-		});
-		const withDefaults = applyCreateDefaults(this.#contract.execution?.mutations.defaults, this.#storeName, record, createMutationDefaultsCache());
-		assertEnumValues(this.#contract, this.#modelName, withDefaults);
-		if (hasScalarFkFields(this.#contract, this.#modelName, withDefaults)) return await executeScalarCreateWithFkValidation({
-			executor: requireTransactionExecutor(this.#executor),
-			contract: this.#contract,
-			modelName: this.#modelName,
-			data: withDefaults
-		});
-		const groupingKey = this.#newGroupingKey();
-		const meta = this.#planMeta(groupingKey);
-		const plan = {
-			meta,
-			ast: {
-				kind: "create",
-				modelName: this.#modelName,
-				data: withDefaults
-			},
-			idbPlan: {
-				meta,
-				kind: "add",
-				storeName: this.#storeName,
-				record: withDefaults
-			}
-		};
-		for await (const row of this.#executor.query(plan)) return row;
-		return withDefaults;
-	}
-	async findUnique(key) {
-		const groupingKey = this.#newGroupingKey();
-		const meta = this.#planMeta(groupingKey);
-		const plan = {
-			meta,
-			ast: {
-				kind: "findUnique",
-				modelName: this.#modelName,
-				key
-			},
-			idbPlan: {
-				meta,
-				kind: "key-get",
-				storeName: this.#storeName,
-				key
-			}
-		};
-		for await (const row of this.#executor.query(plan)) return row;
-		return null;
-	}
-	async delete(key) {
-		if (hasEnforceableChildRelations(this.#contract, this.#modelName)) {
-			await executeDeleteWithReferentialActions({
-				executor: requireTransactionExecutor(this.#executor),
-				contract: this.#contract,
-				modelName: this.#modelName,
-				key
-			});
-			return;
-		}
-		const groupingKey = this.#newGroupingKey();
-		const meta = this.#planMeta(groupingKey);
-		const plan = {
-			meta,
-			ast: {
-				kind: "delete",
-				modelName: this.#modelName,
-				key
-			},
-			idbPlan: {
-				meta,
-				kind: "delete",
-				storeName: this.#storeName,
-				key
-			}
-		};
-		await this.#executor.query(plan).toArray();
-	}
-	async update(patch) {
-		const patchRecord = patch;
-		if (hasNestedMutationCallbacks(this.#contract, this.#modelName, patchRecord)) return await executeNestedUpdateMutation({
-			executor: requireTransactionExecutor(this.#executor),
-			contract: this.#contract,
-			modelName: this.#modelName,
-			filters: this.#state.filters,
-			data: patchRecord
-		});
-		return await executeScalarUpdateWithFkValidation({
-			executor: requireTransactionExecutor(this.#executor),
-			contract: this.#contract,
-			modelName: this.#modelName,
-			filters: this.#state.filters,
-			data: patchRecord
-		});
-	}
-	/**
-	* Always routes through the transaction scope (`executeBulkUpdateWithFkValidation`),
-	* unlike single-row `update()`'s plan-level fallback for the no-FK-field
-	* case. A bulk scan-write's affected row set isn't knowable until it
-	* actually runs — going through the transaction scope is what lets the
-	* sync interceptor observe the real affected rows and write one outbox
-	* event per row (see `SyncInterceptingTransactionScope#maybeTrack`'s
-	* `scan-write` case), atomically with the write itself, instead of one
-	* event for the whole batch with no way to recover which rows it covered.
-	*/
-	updateAll(patch) {
-		const contract = this.#contract;
-		const modelName = this.#modelName;
-		const filters = this.#state.filters;
-		const patchRecord = patch;
-		const executor = requireTransactionExecutor(this.#executor);
-		return new AsyncIterableResult((async function* () {
-			const rows = await executeBulkUpdateWithFkValidation({
-				executor,
-				contract,
-				modelName,
-				filters,
-				data: patchRecord
-			});
-			for (const row of rows) yield row;
-		})());
-	}
-	async updateCount(patch) {
-		return (await this.updateAll(patch).toArray()).length;
-	}
-	async upsert(args) {
-		const keyPath = getKeyPath(this.#contract, this.#modelName);
-		const whereExpr = shorthandToFilterExpr(args.where);
-		const matches = (row) => whereExpr === void 0 || evaluateFilter(whereExpr, row);
-		const meta = this.#planMeta(this.#newGroupingKey());
-		const createRecord = args.create;
-		const patchRecord = args.update;
-		const storeName = this.#storeName;
-		const executionDefaults = this.#contract.execution?.mutations.defaults;
-		const exec = requireTransactionExecutor(this.#executor);
-		const effectivePatch = applyUpdateDefaults(executionDefaults, storeName, patchRecord, createMutationDefaultsCache());
-		const createWithDefaults = applyCreateDefaults(executionDefaults, storeName, createRecord, createMutationDefaultsCache());
-		assertEnumValues(this.#contract, this.#modelName, effectivePatch);
-		assertEnumValues(this.#contract, this.#modelName, createWithDefaults);
-		const { storeNames: onUpdateStoreNames } = collectOnUpdateEnforcementStoreNames(this.#contract, this.#modelName, effectivePatch);
-		return withMutationScope(exec, [.../* @__PURE__ */ new Set([
-			storeName,
-			...onUpdateStoreNames,
-			...collectScalarFkStoreNames(this.#contract, this.#modelName, createWithDefaults),
-			...collectScalarFkStoreNames(this.#contract, this.#modelName, effectivePatch)
-		])], async (scope) => {
-			const existing = (await scope.execute({
-				meta,
-				kind: "cursor-scan",
-				storeName,
-				filter: matches,
-				take: 1
-			}))[0];
-			if (existing === void 0) {
-				await validateScalarFks(scope, this.#contract, this.#modelName, createWithDefaults);
-				return (await scope.execute({
-					meta,
-					kind: "add",
-					storeName,
-					record: createWithDefaults
-				}))[0] ?? createWithDefaults;
-			}
-			await validateScalarFks(scope, this.#contract, this.#modelName, effectivePatch, existing);
-			const key = extractKeyFromRow(existing, keyPath);
-			await applyReferentialActionsForRowOnUpdate(scope, this.#contract, this.#modelName, existing, effectivePatch);
-			return (await scope.execute({
-				meta,
-				kind: "update",
-				storeName,
-				key,
-				patch: effectivePatch
-			}))[0] ?? existing;
-		});
-	}
-	createAll(data) {
-		const defaultsCache = createMutationDefaultsCache();
-		const executionDefaults = this.#contract.execution?.mutations.defaults;
-		const records = data.map((d) => applyCreateDefaults(executionDefaults, this.#storeName, d, defaultsCache));
-		if (records.some((row) => hasScalarFkFields(this.#contract, this.#modelName, row))) {
-			const executor = requireTransactionExecutor(this.#executor);
-			const contract = this.#contract;
-			const modelName = this.#modelName;
-			return new AsyncIterableResult((async function* () {
-				const rows = await executeScalarCreateAllWithFkValidation({
-					executor,
-					contract,
-					modelName,
-					data: records
-				});
-				for (const row of rows) yield row;
-			})());
-		}
-		const groupingKey = this.#newGroupingKey();
-		const meta = this.#planMeta(groupingKey);
-		const plan = {
-			meta,
-			ast: {
-				kind: "createAll",
-				modelName: this.#modelName,
-				data: records
-			},
-			idbPlan: {
-				meta,
-				kind: "batch",
-				storeNames: [this.#storeName],
-				ops: records.map((record) => ({
-					meta,
-					kind: "add",
-					storeName: this.#storeName,
-					record
-				}))
-			}
-		};
-		const executorQuery = this.#executor.query.bind(this.#executor);
-		const contract = this.#contract;
-		const modelName = this.#modelName;
-		return new AsyncIterableResult((async function* () {
-			for (const record of records) assertEnumValues(contract, modelName, record);
-			for await (const row of executorQuery(plan)) yield row;
-		})());
-	}
-	async createCount(data) {
-		return (await this.createAll(data).toArray()).length;
-	}
-	/**
-	* Always routes through the transaction scope (`executeDeleteAllWithReferentialActions`),
-	* not just when there are enforceable child relations to cascade — that
-	* function already handles the no-relations case correctly (an empty
-	* relation list is a no-op loop), and going through it unconditionally is
-	* what lets the sync interceptor's transaction-scope tracking write one
-	* outbox event per actually-deleted row instead of one lump event for
-	* the whole batch with no way to know which rows it covered. See
-	* `updateAll()`'s doc comment for the same reasoning.
-	*/
-	deleteAll() {
-		const combined = this.#combinedFilterExpr();
-		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
-		const contract = this.#contract;
-		const modelName = this.#modelName;
-		const executor = requireTransactionExecutor(this.#executor);
-		return new AsyncIterableResult((async function* () {
-			const rows = await executeDeleteAllWithReferentialActions({
-				executor,
-				contract,
-				modelName,
-				...filter !== void 0 ? { filter } : {}
-			});
-			for (const row of rows) yield row;
-		})());
-	}
-	async deleteCount() {
-		return (await this.deleteAll().toArray()).length;
-	}
-	count() {
-		if (this.#includeRefinementMode) return createIncludeScalar(this.#state);
-		return this.#countTerminal();
-	}
-	async #countTerminal() {
-		const groupingKey = this.#newGroupingKey();
-		const combined = this.#combinedFilterExpr();
-		const fieldToIndexMap = typeof IDBKeyRange !== "undefined" ? buildFieldToIndexMap(this.#contract, this.#storeName) : void 0;
-		if (fieldToIndexMap !== void 0) {
-			const orHint = extractIndexOrHint(combined, fieldToIndexMap, getKeyPath(this.#contract, this.#modelName));
-			if (orHint !== null) return clampCount((await this.#executeOrRows(orHint, groupingKey, combined)).length, this.#state.skip, this.#state.take);
-		}
-		const scanPlan = this.#buildScanPlan(groupingKey, fieldToIndexMap);
-		const scanAst = scanPlan.ast;
-		const ast = {
-			kind: "count",
-			modelName: this.#modelName,
-			...scanAst?.kind === "findMany" && scanAst.where !== void 0 ? { where: scanAst.where } : {}
-		};
-		const nativeTotal = await this.#executeNativeCount(scanPlan, ast);
-		if (nativeTotal !== null) return clampCount(nativeTotal, this.#state.skip, this.#state.take);
-		const plan = {
-			...scanPlan,
-			ast
-		};
-		let n = 0;
-		for await (const _ of this.#executor.query(plan)) n++;
-		return n;
-	}
-	/**
-	* Resolve an `include()` argument pair into an {@link IncludeEntry}: run the
-	* optional refinement against a fresh refinement-mode child accessor, then
-	* classify the result as a scalar count or a refined collection.
-	*/
-	#resolveIncludeEntry(relation, refineFn) {
-		if (refineFn === void 0) return {
-			kind: "collection",
-			state: emptyAccessorState()
-		};
-		const rel = getRelation(this.#contract, this.#modelName, relation);
-		const relatedModelName = rel?.to.model ?? relation;
-		const refined = refineFn(new IdbStoreAccessorImpl(this.#contract, relatedModelName, this.#executor, emptyAccessorState(), this.#newGroupingKey, true));
-		if (isIncludeScalar(refined)) {
-			if (rel !== void 0 && rel.cardinality !== "1:N") throw new Error(`include('${relation}'): count() is only supported for to-many (1:N) relations`);
-			return {
-				kind: "scalar",
-				fn: refined.fn,
-				state: refined.state
-			};
-		}
-		if (refined instanceof IdbStoreAccessorImpl) return {
-			kind: "collection",
-			state: refined.#state
-		};
-		throw new Error(`include('${relation}') refinement must return the collection (for where/orderBy/take/skip) or a count() selector`);
-	}
-	/**
-	* Runs `scanPlan` as a native `count` plan when its cardinality is fully
-	* determined by a key range (no in-memory filter) — returning the
-	* *unpaginated* total — or `null` when it can't (the caller then falls back
-	* to materializing). `ast` is attached so middleware sees the caller's
-	* intent (`count` / `aggregate`) regardless of the physical plan.
-	*/
-	async #executeNativeCount(scanPlan, ast) {
-		const body = scanPlan.idbPlan;
-		if (body.kind !== "cursor-scan" || !isNativelyCountable(body)) return null;
-		const nativePlan = {
-			...scanPlan,
-			ast,
-			idbPlan: toCountPlan(body)
-		};
-		let total = 0;
-		for await (const row of this.#executor.query(nativePlan)) total = row.count;
-		return total;
-	}
-	/**
-	* Materialise all rows matching the accumulated filters with no pagination —
-	* used by `aggregate()` / `groupBy()`. The supplied `ast` is attached to the
-	* scan plan so middleware can observe the aggregate intent.
-	*/
-	async #materialize(groupingKey, ast) {
-		const combined = this.#combinedFilterExpr();
-		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
-		const meta = this.#planMeta(groupingKey);
-		const plan = {
-			meta,
-			ast,
-			idbPlan: {
-				meta,
-				kind: "cursor-scan",
-				storeName: this.#storeName,
-				...filter !== void 0 ? { filter } : {}
-			}
-		};
-		const rows = [];
-		for await (const row of this.#executor.query(plan)) rows.push(row);
-		return rows;
-	}
-	#buildScanPlan(groupingKey, fieldToIndexMap) {
-		const combined = this.#combinedFilterExpr();
-		const comparator = buildRowComparator(this.#state.orderBy);
-		const meta = this.#planMeta(groupingKey);
-		const ast = {
-			kind: "findMany",
-			modelName: this.#modelName,
-			...combined !== void 0 ? { where: combined } : {},
-			...this.#state.orderBy !== void 0 ? { orderBy: this.#state.orderBy } : {},
-			...this.#state.skip !== void 0 ? { skip: this.#state.skip } : {},
-			...this.#state.take !== void 0 ? { take: this.#state.take } : {}
-		};
-		if (typeof IDBKeyRange !== "undefined") {
-			const hint = extractIndexEqualityHint(combined, fieldToIndexMap ?? buildFieldToIndexMap(this.#contract, this.#storeName), getKeyPath(this.#contract, this.#modelName));
-			if (hint !== null) {
-				const { indexName, value, remainingFilter } = hint;
-				const filter = remainingFilter !== void 0 ? (row) => evaluateFilter(remainingFilter, row) : void 0;
-				return {
-					meta,
-					ast,
-					idbPlan: {
-						meta,
-						kind: "cursor-scan",
-						storeName: this.#storeName,
-						...indexName !== void 0 ? { indexName } : {},
-						range: IDBKeyRange.only(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 } : {}
-					}
-				};
-			}
-		}
-		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
-		return {
-			meta,
-			ast,
-			idbPlan: {
-				meta,
-				kind: "cursor-scan",
-				storeName: this.#storeName,
-				...filter !== void 0 ? { filter } : {},
-				...comparator !== void 0 ? { comparator } : {},
-				...this.#state.skip !== void 0 ? { skip: this.#state.skip } : {},
-				...this.#state.take !== void 0 ? { take: this.#state.take } : {}
-			}
-		};
-	}
-	/**
-	* Execute one cursor-scan per OR branch, union the results, deduplicate by
-	* primary key, and apply `hint.remainingFilter` in-memory. Skip/take are
-	* NOT applied here — the caller slices the array after union so pagination
-	* is correct across branches.
-	*/
-	async #executeOrRows(hint, groupingKey, combined) {
-		const meta = this.#planMeta(groupingKey);
-		const storeName = this.#storeName;
-		const keyPath = getKeyPath(this.#contract, this.#modelName);
-		const seen = /* @__PURE__ */ new Set();
-		const rows = [];
-		const ast = {
-			kind: "findMany",
-			modelName: this.#modelName,
-			...combined !== void 0 ? { where: combined } : {}
-		};
-		const branchResults = await Promise.all(hint.branches.map(async (branch) => {
-			const plan = {
-				meta,
-				ast,
-				idbPlan: {
-					meta,
-					kind: "cursor-scan",
-					storeName,
-					...branch.indexName !== void 0 ? { indexName: branch.indexName } : {},
-					range: IDBKeyRange.only(branch.value)
-				}
-			};
-			const branchRows = [];
-			for await (const row of this.#executor.query(plan)) branchRows.push(row);
-			return branchRows;
-		}));
-		for (const branchRows of branchResults) for (const row of branchRows) {
-			const pk = keyToken(extractKeyFromRow(row, keyPath));
-			if (!seen.has(pk)) {
-				seen.add(pk);
-				rows.push(row);
-			}
-		}
-		if (hint.remainingFilter === void 0) return rows;
-		const { remainingFilter } = hint;
-		return rows.filter((row) => evaluateFilter(remainingFilter, row));
-	}
-	/**
-	* Combine all accumulated filter expressions with AND.
-	*
-	* Returns `undefined` when no filter has been installed so the driver can
-	* skip building a row filter closure (a small perf and readability win on
-	* `.all()` paths). Delegates to the shared {@link combineFilterExprs}.
-	*/
-	#combinedFilterExpr() {
-		return combineFilterExprs(this.#state.filters);
-	}
-	async #applyIncludes(rows, groupingKey) {
-		const relNames = Object.keys(this.#state.includes);
-		if (relNames.length === 0) return rows;
-		let result = rows;
-		for (const relName of relNames) {
-			const entry = this.#state.includes[relName];
-			result = await loadRelation(relName, entry, result, this.#contract, this.#modelName, this.#executor, groupingKey);
-		}
-		return result;
-	}
-	/**
-	* Apply a `.select()` projection (if any) to materialised rows. Keeps the
-	* selected scalar fields plus every included relation key (which `include()`
-	* attached during {@link #applyIncludes}); a no-op when nothing is selected.
-	*/
-	#projectRows(rows) {
-		const selected = this.#state.selectedFields;
-		if (selected === void 0) return rows;
-		const keep = [...selected, ...Object.keys(this.#state.includes)];
-		return rows.map((row) => {
-			const out = {};
-			for (const field of keep) if (field in row) out[field] = row[field];
-			return out;
-		});
-	}
-	#planMeta(groupingKey) {
-		return {
-			target: "idb",
-			storageHash: this.#contract.storage.storageHash,
-			lane: "idb-orm",
-			annotations: { groupingKey }
-		};
-	}
-	#clone(overrides) {
-		return new IdbStoreAccessorImpl(this.#contract, this.#modelName, this.#executor, mergeAccessorState(this.#state, overrides), this.#newGroupingKey, this.#includeRefinementMode);
-	}
-};
-//#endregion
-//#region src/core/idb-orm.ts
-/**
-* Create a typed IDB ORM client from a contract and executor.
-*
-* The client exposes one `IdbStoreAccessor` per entry in `contract.roots`.
-* Only roots-declared stores are accessible at the top level — other stores
-* can be reached via `.include()` on any accessor.
-*
-* @example
-* ```ts
-* import { idbOrm } from "@prisma-idb/client-idb/orm";
-* import { createIdbRuntime } from "@prisma-idb/runtime-idb/runtime";
-* import contract from "./prisma/idb-contract";
-*
-* const runtime = createIdbRuntime({ adapter, driver });
-* const db = idbOrm({ contract, executor: runtime });
-*
-* // Typed query builder:
-* const alice = await db.users.where({ email: "alice@example.com" }).first();
-* const postsWithAuthor = await db.posts.include("author").all();
-* ```
-*/
-function idbOrm(options) {
-	const { contract, executor } = options;
-	let _key = 0;
-	const newGroupingKey = () => `idb-op-${++_key}`;
-	const client = {};
-	for (const [rootKey, ref] of Object.entries(contract.roots)) client[rootKey] = new IdbStoreAccessorImpl(contract, ref.model, executor, void 0, newGroupingKey);
-	return client;
-}
-//#endregion
-export { createRelationMutator as a, withMutationScope as c, getStoreName as d, keyEquals as f, hasNestedMutationCallbacks as i, extractKeyFromRow as l, applyReferentialActionsForRow as n, isRelationMutationCallback as o, keyToken as p, collectDeleteStoreNames as r, isRelationMutationDescriptor as s, idbOrm as t, getKeyPath as u };
+export { isValidIdbKey as A, assertEnumValues as C, getKeyPath as D, fieldValueToken as E, keyToken as M, getRelation as O, createMutationDefaultsCache as S, extractKeyFromRow as T, requireTransactionExecutor as _, collectScalarFkStoreNames as a, applyCreateDefaults as b, executeDeleteWithReferentialActions as c, executeScalarCreateAllWithFkValidation as d, executeScalarCreateWithFkValidation as f, hasScalarFkFields as g, hasNestedMutationCallbacks as h, collectOnUpdateEnforcementStoreNames as i, keyEquals as j, getStoreName as k, executeNestedCreateMutation as l, hasEnforceableChildRelations as m, applyReferentialActionsForRowOnUpdate as n, executeBulkUpdateWithFkValidation as o, executeScalarUpdateWithFkValidation as p, collectDeleteStoreNames as r, executeDeleteAllWithReferentialActions as s, applyReferentialActionsForRow as t, executeNestedUpdateMutation as u, validateScalarFks as v, buildFieldToIndexMap as w, applyUpdateDefaults as x, withMutationScope as y };
 
-//# sourceMappingURL=idb-orm-C8yXJp6R.mjs.map
+//# sourceMappingURL=mutation-executor-CD5n_kKT.mjs.map