@prisma-idb/client-idb 0.0.0

package/dist/idb-orm-Cupnnwum.mjs

@@ -0,0 +1,2245 @@
+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 { generateId } from "@prisma/orm-framework/ids/runtime";
+//#region src/core/types.ts
+/**
+* Extract the `storeName` from a model's storage metadata at runtime.
+* Falls back to the model name if `storeName` is absent.
+*/
+function getStoreName(contract, modelName) {
+	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.storeName ?? modelName;
+}
+/**
+* Extract the `keyPath` from a model's storage metadata at runtime.
+* Falls back to `"id"` (the invariant key name for all syncable IDB models).
+*/
+function getKeyPath$1(contract, modelName) {
+	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.keyPath ?? "id";
+}
+/**
+* Find the IDB index name for `fieldName` on the given object store, searching
+* `contract.storage.stores[storeName].indexes` by `keyPath` equality.
+*
+* Returns the index name (e.g. `"byEmail"`) when a single-field index whose
+* `keyPath` equals `fieldName` exists, or `undefined` otherwise.
+* Multi-entry and composite indexes (`keyPath` is an array) are skipped —
+* equality semantics on those are unsupported.
+*/
+function getIndexForField(contract, storeName, fieldName) {
+	return buildFieldToIndexMap(contract, storeName)[fieldName];
+}
+/**
+* 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).
+*/
+function buildFieldToIndexMap(contract, storeName) {
+	const storeDef = contract.storage.stores[storeName];
+	const result = {};
+	if (storeDef?.indexes === void 0) return result;
+	for (const [indexName, indexDef] of Object.entries(storeDef.indexes)) if (typeof indexDef.keyPath === "string" && indexDef.multiEntry !== true) result[indexDef.keyPath] = indexName;
+	return result;
+}
+/**
+* Returns `true` when `value` is a valid {@link IDBValidKey} — i.e. a value
+* that can be passed to `IDBKeyRange.only()` without throwing a DataError.
+* Booleans, `NaN`, `BigInt`, plain objects, and `null`/`undefined` are not
+* valid IDB keys (only number/string/Date/binary/Array are, per the
+* IndexedDB spec). Arrays are validated recursively — an array containing
+* any invalid element (e.g. a nested boolean) is itself not a valid key.
+*
+* Shared by the relation loader (filtering FK values before building
+* `IDBKeyRange.only()` plans) and query-shaping (gating `eq` conditions for
+* index/PK point-range acceleration).
+*/
+function isValidIdbKey(value) {
+	if (typeof value === "number") return !Number.isNaN(value);
+	if (typeof value === "string") return true;
+	if (value instanceof Date) return true;
+	if (value instanceof ArrayBuffer) return true;
+	if (ArrayBuffer.isView(value)) return true;
+	if (Array.isArray(value)) return value.every((v) => isValidIdbKey(v));
+	return false;
+}
+/**
+* Resolve a model's named relation to a {@link ContractReferenceRelation} at
+* runtime, or `undefined` when the relation is absent or an embedded relation
+* (no `on` join block). Used by `include()` to find the related model name and
+* cardinality before building the child-accessor refinement.
+*/
+function getRelation(contract, modelName, relName) {
+	const relation = domainModelsAtDefaultNamespace(contract.domain)[modelName]?.relations?.[relName];
+	if (relation === void 0 || !("on" in relation)) return void 0;
+	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);
+}
+/**
+* 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 || 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 || 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 && 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; values are primitives (strings, numbers, dates) in
+* practice, so JS relational comparison is sufficient.
+*/
+function buildRowComparator(orderBy) {
+	if (orderBy === void 0) return void 0;
+	return (a, b) => {
+		for (const [field, dir] of Object.entries(orderBy)) {
+			const av = a[field];
+			const bv = b[field];
+			if (av === bv) continue;
+			const cmp = av < bv ? -1 : 1;
+			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 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/mutation-defaults.ts
+function createMutationDefaultsCache() {
+	return /* @__PURE__ */ new Map();
+}
+/** Generator ids whose value is shared across an entire top-level call. Every other id always regenerates. */
+const CACHEABLE_GENERATOR_IDS = /* @__PURE__ */ new Set(["timestampNow"]);
+function computeGeneratedValue(spec) {
+	const id = spec.id;
+	switch (id) {
+		case "timestampNow": return /* @__PURE__ */ new Date();
+		case "literal": return spec.params?.["value"];
+		case "uuidv4":
+		case "uuidv7":
+		case "cuid2": return generateId(spec.params !== void 0 ? {
+			id,
+			params: spec.params
+		} : { id });
+		default: throw new Error(`Unknown mutation-default generator id "${String(id)}"`);
+	}
+}
+function resolveGeneratedValue(spec, cache) {
+	const id = spec.id;
+	if (!CACHEABLE_GENERATOR_IDS.has(id)) return computeGeneratedValue(spec);
+	const cached = cache.get(id);
+	if (cached !== void 0) return cached;
+	const value = computeGeneratedValue(spec);
+	cache.set(id, value);
+	return value;
+}
+/**
+* Fills in every column with an `onCreate` default that `data` doesn't
+* already set. Returns `data` unchanged (same reference) if there's nothing
+* to apply.
+*/
+function applyCreateDefaults(defaults, storeName, data, cache) {
+	if (!defaults || defaults.length === 0) return data;
+	let result = data;
+	for (const d of defaults) {
+		if (d.ref.table !== storeName || !d.onCreate) continue;
+		if (result[d.ref.column] !== void 0) continue;
+		if (result === data) result = { ...data };
+		result[d.ref.column] = resolveGeneratedValue(d.onCreate, cache);
+	}
+	return result;
+}
+/**
+* Fills in every column with an `onUpdate` default that `patch` doesn't
+* already set. A patch with no defined values (empty, or every field
+* explicitly `undefined`) is returned unchanged — no write means no default
+* should fire either (matches SQL's "empty update payloads skip onUpdate
+* defaults" rule).
+*/
+function applyUpdateDefaults(defaults, storeName, patch, cache) {
+	if (Object.values(patch).every((v) => v === void 0)) return patch;
+	if (!defaults || defaults.length === 0) return patch;
+	let result = patch;
+	for (const d of defaults) {
+		if (d.ref.table !== storeName || !d.onUpdate) continue;
+		if (result[d.ref.column] !== void 0) continue;
+		if (result === patch) result = { ...patch };
+		result[d.ref.column] = resolveGeneratedValue(d.onUpdate, 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 is done with one cursor scan over the related store (with an
+* in-memory filter), then grouped/indexed in memory — avoiding 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 localField = on.localFields[0];
+	const foreignField = on.targetFields[0];
+	if (localField === void 0 || foreignField === void 0) 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 localValues = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		const v = row[localField];
+		if (v !== void 0 && v !== null) localValues.add(v);
+	}
+	if (localValues.size === 0) return rows.map((row) => ({
+		...row,
+		[relName]: isScalar ? 0 : cardinality === "1:N" ? [] : null
+	}));
+	const capturedForeignField = foreignField;
+	const refinedWhere = combineFilterExprs(entry.state.filters);
+	const planMeta = {
+		target: "idb",
+		storageHash: contract.storage.storageHash,
+		lane: "idb-orm",
+		annotations: { groupingKey }
+	};
+	const fkIndexName = typeof IDBKeyRange !== "undefined" ? getIndexForField(contract, relatedStoreName, capturedForeignField) : void 0;
+	const targetsRelatedPk = fkIndexName === void 0 && typeof IDBKeyRange !== "undefined" && capturedForeignField === getKeyPath$1(contract, relatedModelName);
+	let relatedRows;
+	if (fkIndexName !== void 0 || targetsRelatedPk) {
+		const refinedFilter = refinedWhere !== void 0 ? (row) => evaluateFilter(refinedWhere, row) : void 0;
+		const validValues = Array.from(localValues).filter(isValidIdbKey);
+		relatedRows = (await Promise.all(validValues.map(async (value) => {
+			const plan = {
+				meta: planMeta,
+				idbPlan: {
+					meta: planMeta,
+					kind: "cursor-scan",
+					storeName: relatedStoreName,
+					...fkIndexName !== void 0 ? { indexName: fkIndexName } : {},
+					range: IDBKeyRange.only(value),
+					...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) => localValues.has(row[capturedForeignField]) && (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 = rrow[capturedForeignField];
+			const group = grouped.get(gk) ?? [];
+			group.push(rrow);
+			grouped.set(gk, group);
+		}
+		if (isScalar) return rows.map((row) => ({
+			...row,
+			[relName]: (grouped.get(row[localField]) ?? []).length
+		}));
+		const comparator = buildRowComparator(entry.state.orderBy);
+		const skip = entry.state.skip ?? 0;
+		const take = entry.state.take;
+		return rows.map((row) => {
+			let group = grouped.get(row[localField]) ?? [];
+			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) indexed.set(rrow[capturedForeignField], rrow);
+	return rows.map((row) => ({
+		...row,
+		[relName]: indexed.get(row[localField]) ?? null
+	}));
+}
+//#endregion
+//#region src/core/mutation-scope.ts
+/**
+* Run a callback inside a single multi-store IDB readwrite transaction.
+*
+* Opens the transaction, passes the `IdbTransactionScope` to `run`, then:
+* - On success: awaits `scope.commit()` (waits for `tx.oncomplete`).
+* - On error: calls `scope.rollback()` and rethrows.
+*
+* The callback receives the low-level scope, not the ORM accessor.
+* Use this for multi-store atomic writes that span several object stores.
+*/
+async function withMutationScope(executor, storeNames, run) {
+	const tx = await executor.transaction(storeNames, "readwrite");
+	try {
+		const result = await run(tx);
+		await tx.commit();
+		return result;
+	} catch (err) {
+		tx.rollback();
+		throw err;
+	}
+}
+//#endregion
+//#region src/core/relation-mutator.ts
+function createRelationMutator() {
+	return {
+		create(data) {
+			return {
+				kind: "create",
+				data: Array.isArray(data) ? [...data] : [data]
+			};
+		},
+		connect(criteria) {
+			return {
+				kind: "connect",
+				criteria: Array.isArray(criteria) ? [...criteria] : [criteria]
+			};
+		},
+		disconnect(criteria) {
+			if (!criteria) return { kind: "disconnect" };
+			return {
+				kind: "disconnect",
+				criteria: [...criteria]
+			};
+		}
+	};
+}
+function isRelationMutationDescriptor(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return candidate.kind === "create" || candidate.kind === "connect" || candidate.kind === "disconnect";
+}
+function isRelationMutationCallback(value) {
+	return typeof value === "function";
+}
+//#endregion
+//#region src/core/mutation-executor.ts
+function makePlanMeta(contract) {
+	return {
+		target: "idb",
+		storageHash: contract.storage.storageHash,
+		lane: "idb-mutation-executor",
+		annotations: { groupingKey: "nested" }
+	};
+}
+const relationDefsCache = /* @__PURE__ */ new WeakMap();
+function getRelationDefinitions(contract, modelName) {
+	let perContract = relationDefsCache.get(contract);
+	if (!perContract) {
+		perContract = /* @__PURE__ */ new Map();
+		relationDefsCache.set(contract, perContract);
+	}
+	const cached = perContract.get(modelName);
+	if (cached) return cached;
+	const model = domainModelsAtDefaultNamespace(contract.domain)[modelName];
+	if (!model) {
+		perContract.set(modelName, []);
+		return [];
+	}
+	const defs = [];
+	for (const [relationName, rawRelation] of Object.entries(model.relations)) {
+		if (!rawRelation || typeof rawRelation !== "object" || !("on" in rawRelation)) continue;
+		const relation = rawRelation;
+		const relatedModelName = relation.to.model;
+		const relatedStoreName = getStoreName(contract, relatedModelName);
+		defs.push({
+			relationName,
+			relatedModelName,
+			relatedStoreName,
+			cardinality: relation.cardinality,
+			localFields: relation.on.localFields,
+			targetFields: relation.on.targetFields
+		});
+	}
+	perContract.set(modelName, defs);
+	return defs;
+}
+/**
+* Returns true if `data` contains at least one field that is both a known
+* relation name for `modelName` and a function (a mutation callback).
+*/
+function hasNestedMutationCallbacks(contract, modelName, data) {
+	const relationNames = new Set(getRelationDefinitions(contract, modelName).map((r) => r.relationName));
+	for (const [fieldName, value] of Object.entries(data)) if (relationNames.has(fieldName) && isRelationMutationCallback(value)) return true;
+	return false;
+}
+/**
+* Guards that the executor supports multi-store transactions.
+* Throws a clear error if `transaction()` is not available — the user must
+* use IdbRuntime (createIdbRuntime / createAutoMigratingIdbClient) rather than
+* a plain IdbQueryExecutor stub.
+*/
+function requireTransactionExecutor(executor) {
+	if (typeof executor.transaction !== "function") throw new Error("This operation requires an executor with transaction support (nested relation writes, FK-validated create/update, and referential-action delete all need it). Use IdbRuntime (createIdbRuntime or createAutoMigratingIdbClient) instead of a plain IdbQueryExecutor.");
+	return executor;
+}
+async function executeNestedCreateMutation(options) {
+	const { executor, contract, modelName, data } = options;
+	const record = data;
+	const storeNames = collectStoreNames(contract, modelName, record);
+	const defaultsCache = createMutationDefaultsCache();
+	return withMutationScope(executor, storeNames, (scope) => createGraph(scope, contract, modelName, record, defaultsCache));
+}
+async function executeNestedUpdateMutation(options) {
+	const { executor, contract, modelName, filters, data } = options;
+	const record = data;
+	const storeNames = collectStoreNames(contract, modelName, record);
+	const defaultsCache = createMutationDefaultsCache();
+	return withMutationScope(executor, storeNames, (scope) => updateFirstGraph(scope, contract, modelName, filters, record, defaultsCache));
+}
+function collectStoreNames(contract, modelName, data) {
+	const stores = /* @__PURE__ */ new Set([getStoreName(contract, modelName)]);
+	for (const def of getRelationDefinitions(contract, modelName)) if (def.relationName in data && isRelationMutationCallback(data[def.relationName])) stores.add(def.relatedStoreName);
+	return [...stores];
+}
+async function createGraph(scope, contract, modelName, input, defaultsCache) {
+	const parsed = parseMutationInput(contract, modelName, input);
+	const { parentOwned, childOwned } = partitionByOwnership(parsed.relationMutations);
+	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);
+	}
+	const parentRow = await insertSingleRow(scope, contract, modelName, scalarData, defaultsCache);
+	for (const item of childOwned) {
+		if (item.mutation.kind === "disconnect") throw new Error("disconnect() is only supported in update() nested mutations");
+		await applyChildOwnedMutation(scope, contract, modelName, parentRow, item.relation, item.mutation, defaultsCache);
+	}
+	return parentRow;
+}
+async function updateFirstGraph(scope, contract, modelName, filters, input, defaultsCache) {
+	const existingRow = await findFirstByFilters(scope, contract, modelName, filters);
+	if (!existingRow) return null;
+	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);
+	let parentRow = existingRow;
+	if (Object.keys(scalarData).length > 0) {
+		const storeName = getStoreName(contract, modelName);
+		const key = existingRow[getKeyPath(contract, modelName)];
+		const meta = makePlanMeta(contract);
+		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, scalarData, defaultsCache);
+		const updated = (await scope.execute({
+			meta,
+			kind: "update",
+			storeName,
+			key,
+			patch
+		}))[0];
+		if (updated) parentRow = updated;
+	}
+	for (const item of childOwned) await applyChildOwnedMutation(scope, contract, modelName, parentRow, item.relation, item.mutation, defaultsCache);
+	return parentRow;
+}
+function parseMutationInput(contract, modelName, input) {
+	const scalarData = {};
+	const relationDefs = new Map(getRelationDefinitions(contract, modelName).map((r) => [r.relationName, r]));
+	const relationMutations = [];
+	for (const [fieldName, value] of Object.entries(input)) {
+		const relation = relationDefs.get(fieldName);
+		if (!relation) {
+			scalarData[fieldName] = value;
+			continue;
+		}
+		if (!isRelationMutationCallback(value)) throw new Error(`Relation field "${fieldName}" on model "${modelName}" expects a mutator callback`);
+		const mutation = value(createRelationMutator());
+		if (!isRelationMutationDescriptor(mutation)) throw new Error(`Relation field "${fieldName}" on model "${modelName}" returned an invalid mutation descriptor`);
+		relationMutations.push({
+			relation,
+			mutation
+		});
+	}
+	return {
+		scalarData,
+		relationMutations
+	};
+}
+function partitionByOwnership(mutations) {
+	const parentOwned = [];
+	const childOwned = [];
+	for (const item of mutations) {
+		if (item.relation.cardinality === "N:1") {
+			parentOwned.push(item);
+			continue;
+		}
+		if (item.relation.cardinality === "M:N") throw new Error("M:N nested mutations are not supported");
+		childOwned.push(item);
+	}
+	return {
+		parentOwned,
+		childOwned
+	};
+}
+async function applyParentOwnedMutation(scope, contract, parentModelName, scalarData, relation, mutation, defaultsCache) {
+	if (mutation.kind === "disconnect") {
+		for (const localField of relation.localFields) scalarData[localField] = null;
+		return;
+	}
+	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);
+		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);
+}
+function copyRelatedValuesToParent(relation, scalarData, relatedRow, _parentModelName, _contract) {
+	for (let i = 0; i < relation.localFields.length; i++) {
+		const localField = relation.localFields[i];
+		const targetField = relation.targetFields[i];
+		if (!localField || !targetField) continue;
+		scalarData[localField] = relatedRow[targetField];
+	}
+}
+async function applyChildOwnedMutation(scope, contract, parentModelName, parentRow, relation, mutation, defaultsCache) {
+	const parentValues = readParentColumnValues(parentModelName, relation, parentRow);
+	if (mutation.kind === "create") {
+		for (const childInput of mutation.data) {
+			const payload = { ...childInput };
+			for (const [childField, parentValue] of parentValues.entries()) payload[childField] = parentValue;
+			await insertSingleRow(scope, contract, relation.relatedModelName, payload, defaultsCache);
+		}
+		return;
+	}
+	if (mutation.kind === "connect") {
+		for (const criterion of mutation.criteria) {
+			const setValues = {};
+			for (const [childField, parentValue] of parentValues.entries()) setValues[childField] = parentValue;
+			const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, relation.relatedStoreName, setValues, defaultsCache);
+			const filter = buildCriterionFilter(criterion);
+			const meta = makePlanMeta(contract);
+			await scope.execute({
+				meta,
+				kind: "scan-write",
+				storeName: relation.relatedStoreName,
+				write: "put-merged",
+				patch,
+				filter
+			});
+		}
+		return;
+	}
+	const setValues = {};
+	for (const childField of parentValues.keys()) setValues[childField] = null;
+	const meta = makePlanMeta(contract);
+	if (!mutation.criteria || mutation.criteria.length === 0) {
+		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, relation.relatedStoreName, setValues, defaultsCache);
+		const parentJoinFilter = buildParentJoinFilter(parentValues);
+		await scope.execute({
+			meta,
+			kind: "scan-write",
+			storeName: relation.relatedStoreName,
+			write: "put-merged",
+			patch,
+			filter: parentJoinFilter
+		});
+		return;
+	}
+	for (const criterion of mutation.criteria) {
+		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, relation.relatedStoreName, setValues, defaultsCache);
+		const criterionFilter = buildCriterionFilter(criterion);
+		const parentJoinFilter = buildParentJoinFilter(parentValues);
+		const combinedFilter = (row) => parentJoinFilter(row) && criterionFilter(row);
+		await scope.execute({
+			meta,
+			kind: "scan-write",
+			storeName: relation.relatedStoreName,
+			write: "put-merged",
+			patch,
+			filter: combinedFilter
+		});
+	}
+}
+function readParentColumnValues(parentModelName, relation, parentRow) {
+	const values = /* @__PURE__ */ new Map();
+	for (let i = 0; i < relation.localFields.length; i++) {
+		const localField = relation.localFields[i];
+		const targetField = relation.targetFields[i];
+		if (!localField || !targetField) continue;
+		const parentValue = parentRow[localField];
+		if (parentValue === void 0) throw new Error(`Nested mutation requires parent field "${localField}" to be present in "${parentModelName}" row`);
+		values.set(targetField, parentValue);
+	}
+	return values;
+}
+async function insertSingleRow(scope, contract, modelName, data, defaultsCache) {
+	assertNoNestedCallbacks(modelName, data);
+	const storeName = getStoreName(contract, modelName);
+	const meta = makePlanMeta(contract);
+	const record = applyCreateDefaults(contract.execution?.mutations.defaults, storeName, data, defaultsCache);
+	return (await scope.execute({
+		meta,
+		kind: "add",
+		storeName,
+		record
+	}))[0] ?? record;
+}
+/**
+* Recursive nesting (a relation callback inside an already-nested create) is
+* not supported in Phase 6.4. Without this guard the callback function would be
+* handed to `store.put(...)`, where IDB's structured-clone throws an opaque
+* `DataCloneError` ("could not be cloned") that gives the developer no hint
+* about the real cause. Surface a precise error instead. (PLAN Issue #22.)
+*/
+function assertNoNestedCallbacks(modelName, data) {
+	for (const [field, value] of Object.entries(data)) if (typeof value === "function") throw new Error(`Recursive nested writes are not supported: field "${field}" on a nested "${modelName}" record is a relation callback. Only one level of relation nesting is supported — flatten the inner relation into a separate create/connect call.`);
+}
+async function findRowByCriterion(scope, contract, modelName, criterion) {
+	const expr = shorthandToFilterExpr(criterion);
+	if (!expr) throw new Error(`Nested connect for model "${modelName}" requires a non-empty criterion`);
+	const filter = (row) => evaluateFilter(expr, row);
+	return scanOneRow(scope, contract, modelName, filter);
+}
+async function findFirstByFilters(scope, contract, modelName, filters) {
+	if (filters.length === 0) return null;
+	const combined = filters.length === 1 ? filters[0] : {
+		kind: "and",
+		exprs: filters
+	};
+	const filter = (row) => evaluateFilter(combined, row);
+	return scanOneRow(scope, contract, modelName, filter);
+}
+async function scanOneRow(scope, contract, modelName, filter) {
+	const storeName = getStoreName(contract, modelName);
+	const plan = {
+		meta: makePlanMeta(contract),
+		kind: "cursor-scan",
+		storeName,
+		filter,
+		take: 1
+	};
+	return (await scope.execute(plan))[0] ?? null;
+}
+function buildCriterionFilter(criterion) {
+	const expr = shorthandToFilterExpr(criterion);
+	if (!expr) return () => true;
+	return (row) => evaluateFilter(expr, row);
+}
+function buildParentJoinFilter(parentValues) {
+	const pairs = [...parentValues.entries()];
+	return (row) => pairs.every(([childField, parentValue]) => row[childField] === parentValue);
+}
+function getKeyPath(contract, modelName) {
+	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.keyPath ?? "id";
+}
+function getStoredAction(contract, modelName, relationName, kind) {
+	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.relations?.[relationName]?.[kind];
+}
+function sameFields(a, b) {
+	return a.length === b.length && a.every((field, index) => field === b[index]);
+}
+/**
+* Resolves the referential action for a child-enforcement relation: prefers
+* the action stored directly on this side, falls back to the same action
+* stored on the inverse (FK-owning) side of the relation, and finally to
+* `defaultAction` when neither side declares one.
+*
+* Both branches are live, for different authoring paths. PSL only ever
+* stores the action on the `N:1` (FK-owning) side — enforcement always walks
+* from the parent (`1:N`/non-owning-`1:1`) side, which PSL leaves bare, so
+* the fallback is what actually finds it. TS-DSL relation entries are
+* self-contained (no PSL-style pairing requirement) and typically declare
+* the action directly on the side this function is called for, so the direct
+* check is what fires there — see `contract-builder.ts`'s
+* `validateNoConflictingRelationActions`, which rejects declaring the same
+* action kind on both sides so this fallback never has to arbitrate a real
+* conflict.
+*/
+function getReferentialActionForRelation(contract, modelName, def, kind, defaultAction) {
+	const direct = getStoredAction(contract, modelName, def.relationName, kind);
+	if (direct !== void 0) return direct;
+	for (const inverse of getRelationDefinitions(contract, def.relatedModelName)) {
+		if (inverse.relatedModelName !== modelName) continue;
+		if (!sameFields(inverse.localFields, def.targetFields)) continue;
+		if (!sameFields(inverse.targetFields, def.localFields)) continue;
+		const inverseAction = getStoredAction(contract, def.relatedModelName, inverse.relationName, kind);
+		if (inverseAction !== void 0) return inverseAction;
+	}
+	return defaultAction;
+}
+function getOnDeleteForDeleteRelation(contract, modelName, def) {
+	return getReferentialActionForRelation(contract, modelName, def, "onDelete", "restrict");
+}
+/**
+* `onUpdate`'s default (when neither side declares one) is `cascade`, unlike
+* `onDelete`'s `restrict` default — this matches Prisma's own documented
+* behavior: propagating a changed referenced value to children is normally
+* safe, unlike deleting the row those children point to.
+*/
+function getOnUpdateForRelation(contract, modelName, def) {
+	return getReferentialActionForRelation(contract, modelName, def, "onUpdate", "cascade");
+}
+function isDeleteEnforcementRelation(contract, modelName, def) {
+	if (def.cardinality === "1:N") return true;
+	if (def.cardinality === "1:1") {
+		const keyPath = getKeyPath(contract, modelName);
+		return def.localFields.length > 0 && def.localFields[0] === keyPath;
+	}
+	return false;
+}
+/**
+* Builds a filter matching a relation's children against one specific parent
+* row's values. Shared by `onDelete` cascade (`applyReferentialActionsForRow`)
+* and `onUpdate` cascade (`applyReferentialActionsForRowOnUpdate`).
+*/
+function buildChildFilterFromRow(def, row) {
+	const pairs = def.localFields.map((lf, i) => ({
+		childField: def.targetFields[i],
+		parentValue: row[lf]
+	}));
+	return (child) => pairs.every(({ childField, parentValue }) => child[childField] === parentValue);
+}
+/** Reads a field's literal `@default(...)` value from `IdbModelStorage.fieldDefaults`, if declared. */
+function getFieldDefault(contract, modelName, fieldName) {
+	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.fieldDefaults?.[fieldName];
+}
+/**
+* Builds the patch for a `setDefault` referential action: each of the
+* relation's `targetFields` (the child's FK fields) reset to its own
+* declared literal default — not the parent's. Throws when any target field
+* has no declared default; `setDefault` is only meaningful when every FK
+* field it resets has somewhere to reset to.
+*/
+function buildSetDefaultPatch(contract, def) {
+	const patch = {};
+	for (const targetField of def.targetFields) {
+		const value = getFieldDefault(contract, def.relatedModelName, targetField);
+		if (value === void 0) throw new Error(`setDefault referential action on relation '${def.relationName}' requires field '${def.relatedModelName}.${targetField}' to declare a literal @default(...) value — no default is registered for that field.`);
+		patch[targetField] = value;
+	}
+	return patch;
+}
+/**
+* Validates that a `setDefault` patch actually references a real row before
+* it's written — without this, `setDefault` would silently reintroduce the
+* exact dangling-FK problem the rest of this file exists to prevent. A real
+* SQL database only makes `SET DEFAULT` safe because its FK constraint
+* re-checks the new value transactionally at write time; IDB has no such
+* engine to delegate to, so this check is IDB's equivalent.
+*
+* Checks against `modelName`'s own store (the parent being deleted/updated)
+* using `def.localFields` — the relation's own semantics ("child.targetField
+* references parent.localField") mean that's exactly what a default value
+* written to the child's FK field must match. That store is always already
+* part of the transaction (it's the model literally being written), so no
+* store-list changes are needed to call this.
+*
+* Refuses (throws) rather than validates incorrectly for compound (multi-
+* field) relations, for the same reason `validateScalarFks` does: each
+* field's default is resolved independently, so there's no guarantee the
+* combination corresponds to a single real row.
+*
+* `excludeKey`, when given, excludes the parent row currently being
+* deleted/updated from the existence scan. That row is still physically
+* present in the store at this point (its own write/delete hasn't happened
+* yet — this check runs first, before the enforcement loop's caller applies
+* it), so without the exclusion, a default value equal to that row's *old*
+* `localField` value would false-positive: the scan would find the row about
+* to disappear (or change away from that value) and wrongly conclude the
+* default references a real row, when after the transaction nothing will.
+*/
+async function validateSetDefaultPatch(scope, contract, modelName, def, patch, excludeKey) {
+	if (def.localFields.length > 1) throw new Error(`setDefault referential action on relation '${def.relationName}' cannot validate a compound (multi-field) default: each field's default is resolved independently, so there is no guarantee the combination corresponds to a single real row.`);
+	const meta = makePlanMeta(contract);
+	const parentStoreName = getStoreName(contract, modelName);
+	const parentKeyPath = getKeyPath(contract, modelName);
+	const localField = def.localFields[0];
+	const targetField = def.targetFields[0];
+	const value = patch[targetField];
+	const filter = (row) => row[localField] === value && (excludeKey === void 0 || row[parentKeyPath] !== excludeKey);
+	if ((await scope.execute({
+		meta,
+		kind: "cursor-scan",
+		storeName: parentStoreName,
+		filter,
+		take: 1
+	})).length === 0) throw new Error(`setDefault referential action on relation '${def.relationName}' would set '${def.relatedModelName}.${targetField}' to '${String(value)}', but no ${modelName} with ${localField}='${String(value)}' exists — the declared default does not reference a real row.`);
+}
+/**
+* Collects every store an `onUpdate`-enforced write to `modelName` might
+* touch: the model's own store, plus the related store of any 1:N/1:1-
+* parent-side relation whose `localFields` appear in the raw patch —
+* pessimistic (checks field *presence*, not whether the resolved value will
+* actually change, since the current row isn't read yet when this runs).
+* Once a `cascade` edge is entered, the walk continues transitively (mirrors
+* `collectDeleteStoreNames`'s cascade-only recursion), since a propagated
+* value change may itself need to cascade further.
+*
+* Returns `enforces: false` when no `onUpdate` enforcement can apply to this
+* write — callers use that to keep the existing fast blind-write path
+* instead of paying for a read-before-write. This is tracked as an explicit
+* flag rather than inferred from `storeNames.length > 1`: for a
+* self-referential relation, `def.relatedStoreName` equals `modelName`'s own
+* store (already the seed of the `Set`), so the store count alone can't tell
+* "no enforcement" apart from "enforces, but only against this same store".
+*/
+function collectOnUpdateEnforcementStoreNames(contract, modelName, data) {
+	const stores = /* @__PURE__ */ new Set([getStoreName(contract, modelName)]);
+	const visitedModels = /* @__PURE__ */ new Set();
+	let enforces = false;
+	function walkCascadeChain(mName) {
+		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 (action === "noAction") continue;
+			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 (!def.localFields.some((f) => f in data)) continue;
+		const action = getOnUpdateForRelation(contract, modelName, def);
+		if (action === "noAction") continue;
+		enforces = true;
+		stores.add(def.relatedStoreName);
+		if (action === "cascade") walkCascadeChain(def.relatedModelName);
+	}
+	return {
+		storeNames: [...stores],
+		enforces
+	};
+}
+/**
+* Enforces every `onUpdate` action declared on `modelName`'s child relations
+* against one specific `oldRow` about to be patched with `patch`. Only
+* relations whose `localFields` are both present in `patch` and differ from
+* `oldRow`'s current value are enforced — a patch that sets a field to its
+* existing value, or never touches a locally-referenced field, is a no-op
+* here. Children are matched against `oldRow`'s pre-change values.
+*
+* `cascade` propagates the new value(s) onto the matched children's FK
+* fields and recurses into each child's own `onUpdate` relations before
+* writing (the propagated change may itself need to cascade further) —
+* mirrors `applyReferentialActionsForRow`'s recursive shape, including the
+* `visited` row-level cycle guard (see that function's doc comment for the
+* fresh-per-top-level-row / shared-across-one-row's-descent contract).
+* `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.
+*/
+async function applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch, visited = /* @__PURE__ */ new Set()) {
+	const keyPath = getKeyPath(contract, modelName);
+	const rowKey = `${getStoreName(contract, modelName)}::${String(oldRow[keyPath])}`;
+	if (visited.has(rowKey)) return;
+	visited.add(rowKey);
+	const meta = makePlanMeta(contract);
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
+		const changedFields = def.localFields.filter((f) => f in patch && patch[f] !== oldRow[f]);
+		if (changedFields.length === 0) continue;
+		const action = getOnUpdateForRelation(contract, modelName, def);
+		if (action === "noAction") continue;
+		const childFilter = buildChildFilterFromRow(def, oldRow);
+		if (action === "restrict") {
+			if ((await scope.execute({
+				meta,
+				kind: "cursor-scan",
+				storeName: def.relatedStoreName,
+				filter: childFilter,
+				take: 1
+			})).length > 0) throw new Error(`Cannot update ${modelName} '${String(oldRow[keyPath])}': changing field(s) ${changedFields.join(", ")} would orphan child records on relation '${def.relationName}'. Use onUpdate: 'cascade', 'setNull', 'setDefault', or 'noAction'.`);
+			continue;
+		}
+		if (action === "cascade") {
+			const childPatch = {};
+			for (let i = 0; i < def.localFields.length; i++) {
+				const lf = def.localFields[i];
+				const tf = def.targetFields[i];
+				if (changedFields.includes(lf)) childPatch[tf] = patch[lf];
+			}
+			const children = await scope.execute({
+				meta,
+				kind: "cursor-scan",
+				storeName: def.relatedStoreName,
+				filter: childFilter
+			});
+			for (const child of children) await applyReferentialActionsForRowOnUpdate(scope, contract, def.relatedModelName, child, childPatch, visited);
+			await scope.execute({
+				meta,
+				kind: "scan-write",
+				storeName: def.relatedStoreName,
+				write: "put-merged",
+				patch: childPatch,
+				filter: childFilter
+			});
+			continue;
+		}
+		if (action === "setNull") {
+			const childPatch = {};
+			for (const targetField of def.targetFields) childPatch[targetField] = null;
+			await scope.execute({
+				meta,
+				kind: "scan-write",
+				storeName: def.relatedStoreName,
+				write: "put-merged",
+				patch: childPatch,
+				filter: childFilter
+			});
+			continue;
+		}
+		if (action === "setDefault") {
+			const childPatch = buildSetDefaultPatch(contract, def);
+			await validateSetDefaultPatch(scope, contract, modelName, def, childPatch, oldRow[keyPath]);
+			await scope.execute({
+				meta,
+				kind: "scan-write",
+				storeName: def.relatedStoreName,
+				write: "put-merged",
+				patch: childPatch,
+				filter: childFilter
+			});
+			continue;
+		}
+	}
+}
+/**
+* Returns true if `data` contains at least one non-null value for a localField
+* of a N:1 relation — indicating scalar FK fields that need existence validation.
+*/
+function hasScalarFkFields(contract, modelName, data) {
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (def.cardinality !== "N:1") continue;
+		for (const localField of def.localFields) if (localField in data && data[localField] !== null && data[localField] !== void 0) return true;
+	}
+	return false;
+}
+function collectScalarFkStoreNames(contract, modelName, data) {
+	const stores = /* @__PURE__ */ new Set([getStoreName(contract, modelName)]);
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (def.cardinality !== "N:1") continue;
+		if (def.localFields.some((f) => f in data && data[f] !== null && data[f] !== void 0)) stores.add(def.relatedStoreName);
+	}
+	return [...stores];
+}
+async function validateScalarFks(scope, contract, modelName, data) {
+	const meta = makePlanMeta(contract);
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (def.cardinality !== "N:1") continue;
+		if (!def.localFields.some((f) => f in data && data[f] !== null && data[f] !== void 0)) continue;
+		if (def.localFields.length > 1) throw new Error(`FK violation on relation '${def.relationName}': compound (multi-field) scalar FK validation is not supported`);
+		const localField = def.localFields[0];
+		const targetField = def.targetFields[0];
+		const value = data[localField];
+		const filter = (row) => row[targetField] === value;
+		const plan = {
+			meta,
+			kind: "cursor-scan",
+			storeName: def.relatedStoreName,
+			filter,
+			take: 1
+		};
+		if ((await scope.execute(plan)).length === 0) throw new Error(`FK violation on relation '${def.relationName}': no ${def.relatedModelName} with ${targetField}='${String(value)}'`);
+	}
+}
+async function executeScalarCreateWithFkValidation(options) {
+	const { executor, contract, modelName, data } = options;
+	return withMutationScope(executor, collectScalarFkStoreNames(contract, modelName, data), async (scope) => {
+		await validateScalarFks(scope, contract, modelName, data);
+		return insertSingleRow(scope, contract, modelName, data, createMutationDefaultsCache());
+	});
+}
+/**
+* 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
+* fast blind-write path and the read-before-write enforcement path.
+*/
+function collectUpdateStoreNames(contract, modelName, data) {
+	const fkStoreNames = collectScalarFkStoreNames(contract, modelName, data);
+	const { storeNames: onUpdateStoreNames, enforces } = collectOnUpdateEnforcementStoreNames(contract, modelName, data);
+	return {
+		storeNames: [.../* @__PURE__ */ new Set([...fkStoreNames, ...onUpdateStoreNames])],
+		enforcesOnUpdate: enforces
+	};
+}
+async function executeScalarUpdateWithFkValidation(options) {
+	const { executor, contract, modelName, filters, data } = options;
+	const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, data);
+	return withMutationScope(executor, storeNames, async (scope) => {
+		await validateScalarFks(scope, contract, modelName, data);
+		const storeName = getStoreName(contract, modelName);
+		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;
+		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, data, createMutationDefaultsCache());
+		if (!enforcesOnUpdate) 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;
+		await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch);
+		const key = oldRow[getKeyPath(contract, modelName)];
+		return (await scope.execute({
+			meta,
+			kind: "update",
+			storeName,
+			key,
+			patch
+		}))[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.
+*/
+async function executeBulkUpdateWithFkValidation(options) {
+	const { executor, contract, modelName, filters, data } = options;
+	const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, data);
+	return withMutationScope(executor, storeNames, async (scope) => {
+		await validateScalarFks(scope, contract, modelName, data);
+		const storeName = getStoreName(contract, modelName);
+		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;
+		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, data, createMutationDefaultsCache());
+		if (!enforcesOnUpdate) return scope.execute({
+			meta,
+			kind: "scan-write",
+			storeName,
+			write: "put-merged",
+			patch,
+			...filter !== void 0 ? { filter } : {}
+		});
+		const oldRows = await scope.execute({
+			meta,
+			kind: "cursor-scan",
+			storeName,
+			...filter !== void 0 ? { filter } : {}
+		});
+		const keyPath = getKeyPath(contract, modelName);
+		const results = [];
+		for (const oldRow of oldRows) {
+			await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch);
+			const key = oldRow[keyPath];
+			const updated = (await scope.execute({
+				meta,
+				kind: "update",
+				storeName,
+				key,
+				patch
+			}))[0];
+			if (updated) results.push(updated);
+		}
+		return results;
+	});
+}
+/**
+* Returns true if the model has at least one child relation (1:N or parent-side
+* 1:1) whose `onDelete` action requires enforcement (anything except `noAction`).
+* Since the default is `restrict`, any model with 1:N/1:1 relations that do not
+* explicitly set `noAction` returns true.
+*/
+function hasEnforceableChildRelations(contract, modelName) {
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
+		if (getOnDeleteForDeleteRelation(contract, modelName, def) !== "noAction") return true;
+	}
+	return false;
+}
+/**
+* Transitively walks the `onDelete` cascade graph from `modelName`, collecting
+* every store a recursive delete might touch. `cascade` edges are walked
+* further (a cascaded child's own children may themselves cascade);
+* `restrict`/`setNull`/`setDefault` edges still need their store added (each
+* is read or written once) but don't recurse further, since none of them
+* delete the child row. Guarded by a model-level visited set — required
+* because IDB must declare every store a transaction might touch before it
+* opens, so this static walk must terminate even on a self-referential model
+* or a cycle of mutually-cascading models.
+*/
+function collectDeleteStoreNames(contract, modelName) {
+	const stores = /* @__PURE__ */ new Set();
+	const visitedModels = /* @__PURE__ */ new Set();
+	function walk(mName) {
+		if (visitedModels.has(mName)) return;
+		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 (action === "noAction") continue;
+			stores.add(def.relatedStoreName);
+			if (action === "cascade") walk(def.relatedModelName);
+		}
+	}
+	walk(modelName);
+	return [...stores];
+}
+/**
+* Enforces every `onDelete` action declared on `modelName`'s child relations
+* against one specific `row` about to be deleted. `cascade` recurses into
+* each matched child's own `onDelete` relations *before* deleting it — so a
+* multi-hop chain (`User --cascade--> Post --cascade--> Comment`) is fully
+* torn down, and a `restrict` several hops deep still aborts the whole
+* transaction (recursing before deleting means the delete never happens if a
+* deeper hop throws). `setNull`/`setDefault` are leaf actions: the child row
+* survives, so recursion never continues past them.
+*
+* `visited` (keyed by `storeName::key`) guards against row-level cycles — two
+* specific rows whose FKs point at each other through a self-referential or
+* mutually-cascading relation graph. Callers should leave it at its default
+* (a fresh `Set` per top-level call) so independent rows deleted in the same
+* `deleteAll()` batch don't cross-suppress each other's cascades; it's only
+* ever passed explicitly by this function's own recursive calls, to keep one
+* shared guard across a single row's full recursive descent.
+*/
+async function applyReferentialActionsForRow(scope, contract, modelName, row, visited = /* @__PURE__ */ new Set()) {
+	const keyPath = getKeyPath(contract, modelName);
+	const rowKey = `${getStoreName(contract, modelName)}::${String(row[keyPath])}`;
+	if (visited.has(rowKey)) return;
+	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 (action === "noAction") continue;
+		const childFilter = buildChildFilterFromRow(def, row);
+		if (action === "restrict") {
+			if ((await scope.execute({
+				meta,
+				kind: "cursor-scan",
+				storeName: def.relatedStoreName,
+				filter: childFilter,
+				take: 1
+			})).length > 0) throw new Error(`Cannot delete ${modelName} '${String(row[keyPath])}': child records exist on relation '${def.relationName}'. Use onDelete: 'cascade', 'setNull', or 'noAction'.`);
+			continue;
+		}
+		if (action === "cascade") {
+			const childKeyPath = getKeyPath(contract, def.relatedModelName);
+			const children = await scope.execute({
+				meta,
+				kind: "cursor-scan",
+				storeName: def.relatedStoreName,
+				filter: childFilter
+			});
+			for (const child of children) {
+				await applyReferentialActionsForRow(scope, contract, def.relatedModelName, child, visited);
+				await scope.execute({
+					meta,
+					kind: "delete",
+					storeName: def.relatedStoreName,
+					key: child[childKeyPath]
+				});
+			}
+			continue;
+		}
+		if (action === "setNull") {
+			const patch = {};
+			for (const targetField of def.targetFields) patch[targetField] = null;
+			await scope.execute({
+				meta,
+				kind: "scan-write",
+				storeName: def.relatedStoreName,
+				write: "put-merged",
+				patch,
+				filter: childFilter
+			});
+			continue;
+		}
+		if (action === "setDefault") {
+			const patch = buildSetDefaultPatch(contract, def);
+			await validateSetDefaultPatch(scope, contract, modelName, def, patch, row[keyPath]);
+			await scope.execute({
+				meta,
+				kind: "scan-write",
+				storeName: def.relatedStoreName,
+				write: "put-merged",
+				patch,
+				filter: childFilter
+			});
+			continue;
+		}
+	}
+}
+async function executeDeleteWithReferentialActions(options) {
+	const { executor, contract, modelName, key } = options;
+	await withMutationScope(executor, collectDeleteStoreNames(contract, modelName), async (scope) => {
+		const storeName = getStoreName(contract, modelName);
+		const meta = makePlanMeta(contract);
+		const row = (await scope.execute({
+			meta,
+			kind: "key-get",
+			storeName,
+			key
+		}))[0];
+		if (!row) return [];
+		await applyReferentialActionsForRow(scope, contract, modelName, row);
+		await scope.execute({
+			meta,
+			kind: "delete",
+			storeName,
+			key
+		});
+		return [];
+	});
+}
+async function executeDeleteAllWithReferentialActions(options) {
+	const { executor, contract, modelName, filter } = options;
+	return withMutationScope(executor, collectDeleteStoreNames(contract, modelName), async (scope) => {
+		const storeName = getStoreName(contract, modelName);
+		const meta = makePlanMeta(contract);
+		const keyPath = getKeyPath(contract, modelName);
+		const rows = await scope.execute({
+			meta,
+			kind: "cursor-scan",
+			storeName,
+			...filter !== void 0 ? { filter } : {}
+		});
+		for (const row of rows) {
+			await applyReferentialActionsForRow(scope, contract, modelName, row);
+			const key = row[keyPath];
+			await scope.execute({
+				meta,
+				kind: "delete",
+				storeName,
+				key
+			});
+		}
+		return rows;
+	});
+}
+//#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$1(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 } : {}
+		};
+		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
+		});
+		if (hasScalarFkFields(this.#contract, this.#modelName, record)) return await executeScalarCreateWithFkValidation({
+			executor: requireTransactionExecutor(this.#executor),
+			contract: this.#contract,
+			modelName: this.#modelName,
+			data: record
+		});
+		const groupingKey = this.#newGroupingKey();
+		const meta = this.#planMeta(groupingKey);
+		const withDefaults = applyCreateDefaults(this.#contract.execution?.mutations.defaults, this.#storeName, record, createMutationDefaultsCache());
+		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$1(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 { storeNames: onUpdateStoreNames } = collectOnUpdateEnforcementStoreNames(this.#contract, this.#modelName, effectivePatch);
+		return withMutationScope(exec, [.../* @__PURE__ */ new Set([storeName, ...onUpdateStoreNames])], async (scope) => {
+			const existing = (await scope.execute({
+				meta,
+				kind: "cursor-scan",
+				storeName,
+				filter: matches,
+				take: 1
+			}))[0];
+			if (existing === void 0) {
+				const record = applyCreateDefaults(executionDefaults, storeName, createRecord, createMutationDefaultsCache());
+				return (await scope.execute({
+					meta,
+					kind: "add",
+					storeName,
+					record
+				}))[0] ?? record;
+			}
+			const key = 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 groupingKey = this.#newGroupingKey();
+		const meta = this.#planMeta(groupingKey);
+		const defaultsCache = createMutationDefaultsCache();
+		const executionDefaults = this.#contract.execution?.mutations.defaults;
+		const records = data.map((d) => applyCreateDefaults(executionDefaults, this.#storeName, d, defaultsCache));
+		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);
+		return new AsyncIterableResult((async function* () {
+			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$1(this.#contract, this.#modelName));
+			if (orHint !== null) {
+				let n = (await this.#executeOrRows(orHint, groupingKey, combined)).length;
+				if (this.#state.skip !== void 0) n = Math.max(0, n - this.#state.skip);
+				if (this.#state.take !== void 0) n = Math.min(this.#state.take, n);
+				return n;
+			}
+		}
+		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 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`);
+	}
+	/**
+	* 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$1(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$1(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 = 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, hasNestedMutationCallbacks as i, getKeyPath$1 as l, applyReferentialActionsForRow as n, isRelationMutationCallback as o, collectDeleteStoreNames as r, isRelationMutationDescriptor as s, idbOrm as t, getStoreName as u };
+
+//# sourceMappingURL=idb-orm-Cupnnwum.mjs.map