@prisma-next-idb/client-idb 0.1.0

package/dist/idb-orm-NHIZ3oNt.mjs

@@ -0,0 +1,1526 @@
+import { AsyncIterableResult } from "@prisma-next/framework-components/runtime";
+import { andExpr, evaluateFilter, fieldFilter, nullCheckExpr, shorthandToFilterExpr } from "@prisma-next-idb/adapter-idb/runtime";
+import { domainModelsAtDefaultNamespace } from "@prisma-next/contract/types";
+//#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";
+}
+/**
+* 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
+* `vendor/prisma-next/packages/3-extensions/sql-orm-client` but without
+* the codec-trait gating — IDB stores native JS values, so every operator
+* is available on every field. The runtime accessor object is a Proxy
+* that materialises an `IdbFieldAccessor` on demand for whichever field
+* name is read; the type-level surface narrows that to the model's
+* actual field set so callbacks get autocomplete.
+*/
+/**
+* Build an {@link IdbFieldAccessor} for a single field. The accessor is
+* shared via the proxy below, but each accessor instance is bound to its
+* own field name so the produced AST nodes carry the right field.
+*/
+function createFieldAccessor(field) {
+	return {
+		eq: (value) => fieldFilter(field, "eq", value),
+		neq: (value) => fieldFilter(field, "neq", value),
+		gt: (value) => fieldFilter(field, "gt", value),
+		lt: (value) => fieldFilter(field, "lt", value),
+		gte: (value) => fieldFilter(field, "gte", value),
+		lte: (value) => fieldFilter(field, "lte", value),
+		in: (values) => fieldFilter(field, "in", values),
+		notIn: (values) => fieldFilter(field, "notIn", values),
+		contains: (sub) => fieldFilter(field, "contains", sub),
+		startsWith: (sub) => fieldFilter(field, "startsWith", sub),
+		endsWith: (sub) => fieldFilter(field, "endsWith", sub),
+		isNull: () => nullCheckExpr(field, true),
+		isNotNull: () => nullCheckExpr(field, false)
+	};
+}
+/**
+* Create the typed model accessor used by `where(fn)` callbacks.
+*
+* Implemented as a Proxy keyed on field names — every read returns an
+* {@link IdbFieldAccessor} bound to that field. The accessor cache means
+* `m.name.eq(...)` and `m.name.startsWith(...)` reuse the same per-field
+* accessor object across the same `where()` invocation.
+*
+* The type parameter is structural — no contract is consulted at
+* runtime, because TS already gates the visible field set at compile
+* time. (Misspelled fields surface as accessor calls on names that
+* don't exist in stored rows, which is consistent with how the
+* shorthand form behaves today.)
+*/
+function createModelAccessor() {
+	const cache = /* @__PURE__ */ new Map();
+	return new Proxy({}, { get(_target, prop) {
+		if (typeof prop !== "string") return void 0;
+		let acc = cache.get(prop);
+		if (acc === void 0) {
+			acc = createFieldAccessor(prop);
+			cache.set(prop, acc);
+		}
+		return acc;
+	} });
+}
+//#endregion
+//#region src/core/store-state.ts
+/** Build an {@link IdbIncludeScalar} marker for a `count()` reducer. */
+function createIncludeScalar(state) {
+	return {
+		kind: "includeScalar",
+		fn: "count",
+		state
+	};
+}
+/** Type guard: is `value` an {@link IdbIncludeScalar} marker? */
+function isIncludeScalar(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return candidate.kind === "includeScalar" && candidate.fn === "count";
+}
+/** Create a fresh, empty accessor state (no filters, no ordering, no includes). */
+function emptyAccessorState() {
+	return {
+		filters: [],
+		includes: {}
+	};
+}
+/** Return a shallow-merged copy of `state` with the given overrides applied. */
+function mergeAccessorState(state, overrides) {
+	return {
+		...state,
+		...overrides
+	};
+}
+//#endregion
+//#region src/core/query-shaping.ts
+/**
+* Combine accumulated filter expressions with AND.
+*
+* Returns `undefined` when no filter is present so callers can skip building a
+* row-filter closure. Shared by {@link IdbStoreAccessorImpl} (top-level scans)
+* and the relation loader (refined `include()` child scans).
+*/
+function combineFilterExprs(filters) {
+	if (filters.length === 0) return void 0;
+	if (filters.length === 1) return filters[0];
+	return andExpr(filters);
+}
+/**
+* Build an in-memory comparator from an `orderBy` spec (field → direction).
+*
+* Returns `undefined` when there is nothing to sort by. Compares fields in
+* declaration order; 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/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 filter = (row) => localValues.has(row[capturedForeignField]) && (refinedWhere === void 0 || evaluateFilter(refinedWhere, row));
+	const planMeta = {
+		target: "idb",
+		storageHash: contract.storage.storageHash,
+		lane: "idb-orm",
+		annotations: { groupingKey }
+	};
+	const plan = {
+		meta: planMeta,
+		idbPlan: {
+			meta: planMeta,
+			kind: "cursor-scan",
+			storeName: relatedStoreName,
+			filter
+		}
+	};
+	const relatedRows = [];
+	for await (const row of executor.execute(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("Nested relation writes require an executor with transaction support. 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;
+	return withMutationScope(executor, collectStoreNames(contract, modelName, record), (scope) => createGraph(scope, contract, modelName, record));
+}
+async function executeNestedUpdateMutation(options) {
+	const { executor, contract, modelName, filters, data } = options;
+	const record = data;
+	return withMutationScope(executor, collectStoreNames(contract, modelName, record), (scope) => updateFirstGraph(scope, contract, modelName, filters, record));
+}
+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) {
+	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);
+	}
+	const parentRow = await insertSingleRow(scope, contract, modelName, scalarData);
+	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);
+	}
+	return parentRow;
+}
+async function updateFirstGraph(scope, contract, modelName, filters, input) {
+	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);
+	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 updated = (await scope.execute({
+			meta,
+			kind: "update",
+			storeName,
+			key,
+			patch: scalarData
+		}))[0];
+		if (updated) parentRow = updated;
+	}
+	for (const item of childOwned) await applyChildOwnedMutation(scope, contract, modelName, parentRow, item.relation, item.mutation);
+	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) {
+	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), 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) {
+	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);
+		}
+		return;
+	}
+	if (mutation.kind === "connect") {
+		for (const criterion of mutation.criteria) {
+			const setValues = {};
+			for (const [childField, parentValue] of parentValues.entries()) setValues[childField] = parentValue;
+			const filter = buildCriterionFilter(criterion);
+			const meta = makePlanMeta(contract);
+			await scope.execute({
+				meta,
+				kind: "scan-write",
+				storeName: relation.relatedStoreName,
+				write: "put-merged",
+				patch: setValues,
+				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 parentJoinFilter = buildParentJoinFilter(parentValues);
+		await scope.execute({
+			meta,
+			kind: "scan-write",
+			storeName: relation.relatedStoreName,
+			write: "put-merged",
+			patch: setValues,
+			filter: parentJoinFilter
+		});
+		return;
+	}
+	for (const criterion of mutation.criteria) {
+		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: setValues,
+			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) {
+	assertNoNestedCallbacks(modelName, data);
+	const storeName = getStoreName(contract, modelName);
+	const meta = makePlanMeta(contract);
+	return (await scope.execute({
+		meta,
+		kind: "put",
+		storeName,
+		record: data
+	}))[0] ?? data;
+}
+/**
+* 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 getOnDelete(contract, modelName, relationName) {
+	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.relations?.[relationName]?.onDelete ?? "restrict";
+}
+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;
+}
+/**
+* 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;
+		for (let i = 0; i < def.localFields.length; i++) {
+			const localField = def.localFields[i];
+			const targetField = def.targetFields[i];
+			const value = data[localField];
+			if (!(localField in data) || value === null || value === void 0) continue;
+			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);
+	});
+}
+async function executeScalarUpdateWithFkValidation(options) {
+	const { executor, contract, modelName, filters, data } = options;
+	return withMutationScope(executor, collectScalarFkStoreNames(contract, modelName, data), 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;
+		return (await scope.execute({
+			meta,
+			kind: "scan-write",
+			storeName,
+			write: "put-merged",
+			patch: data,
+			take: 1,
+			...filter !== void 0 ? { filter } : {}
+		}))[0] ?? null;
+	});
+}
+/**
+* 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 (getOnDelete(contract, modelName, def.relationName) !== "noAction") return true;
+	}
+	return false;
+}
+function collectDeleteStoreNames(contract, modelName) {
+	const stores = /* @__PURE__ */ new Set([getStoreName(contract, modelName)]);
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
+		if (getOnDelete(contract, modelName, def.relationName) !== "noAction") stores.add(def.relatedStoreName);
+	}
+	return [...stores];
+}
+async function applyReferentialActionsForRow(scope, contract, modelName, row) {
+	const meta = makePlanMeta(contract);
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
+		const action = getOnDelete(contract, modelName, def.relationName);
+		if (action === "noAction") continue;
+		const pairs = def.localFields.map((lf, i) => ({
+			childField: def.targetFields[i],
+			parentValue: row[lf]
+		}));
+		const childFilter = (child) => pairs.every(({ childField, parentValue }) => child[childField] === parentValue);
+		if (action === "restrict") {
+			if ((await scope.execute({
+				meta,
+				kind: "cursor-scan",
+				storeName: def.relatedStoreName,
+				filter: childFilter,
+				take: 1
+			})).length > 0) {
+				const keyPath = getKeyPath(contract, modelName);
+				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") {
+			await scope.execute({
+				meta,
+				kind: "scan-write",
+				storeName: def.relatedStoreName,
+				write: "delete",
+				filter: childFilter
+			});
+			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") throw new Error(`setDefault referential action is not supported on relation '${def.relationName}': IDB contracts do not track field defaults. Use 'cascade', 'setNull', or 'noAction' instead.`);
+	}
+}
+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 executorExecute = this.#executor.execute.bind(this.#executor);
+		const applyIncludes = this.#applyIncludes.bind(this);
+		const projectRows = this.#projectRows.bind(this);
+		return new AsyncIterableResult((async function* () {
+			const scanPlan = buildScanPlan(groupingKey);
+			const rows = [];
+			for await (const row of executorExecute(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 plan = {
+			meta,
+			ast: {
+				kind: "create",
+				modelName: this.#modelName,
+				data: record
+			},
+			idbPlan: {
+				meta,
+				kind: "put",
+				storeName: this.#storeName,
+				record
+			}
+		};
+		for await (const row of this.#executor.execute(plan)) return row;
+		return record;
+	}
+	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.execute(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.execute(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
+		});
+		if (hasScalarFkFields(this.#contract, this.#modelName, patchRecord)) return await executeScalarUpdateWithFkValidation({
+			executor: requireTransactionExecutor(this.#executor),
+			contract: this.#contract,
+			modelName: this.#modelName,
+			filters: this.#state.filters,
+			data: patchRecord
+		});
+		const groupingKey = this.#newGroupingKey();
+		const combined = this.#combinedFilterExpr();
+		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
+		const meta = this.#planMeta(groupingKey);
+		const plan = {
+			meta,
+			ast: {
+				kind: "update",
+				modelName: this.#modelName,
+				patch: patchRecord,
+				...combined !== void 0 ? { where: combined } : {}
+			},
+			idbPlan: {
+				meta,
+				kind: "scan-write",
+				storeName: this.#storeName,
+				write: "put-merged",
+				patch: patchRecord,
+				take: 1,
+				...filter !== void 0 ? { filter } : {}
+			}
+		};
+		for await (const row of this.#executor.execute(plan)) return row;
+		return null;
+	}
+	updateAll(patch) {
+		const groupingKey = this.#newGroupingKey();
+		const combined = this.#combinedFilterExpr();
+		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
+		const meta = this.#planMeta(groupingKey);
+		const storeName = this.#storeName;
+		const modelName = this.#modelName;
+		const patchRecord = patch;
+		const executorExecute = this.#executor.execute.bind(this.#executor);
+		return new AsyncIterableResult((async function* () {
+			const plan = {
+				meta,
+				ast: {
+					kind: "updateAll",
+					modelName,
+					patch: patchRecord,
+					...combined !== void 0 ? { where: combined } : {}
+				},
+				idbPlan: {
+					meta,
+					kind: "scan-write",
+					storeName,
+					write: "put-merged",
+					patch: patchRecord,
+					...filter !== void 0 ? { filter } : {}
+				}
+			};
+			for await (const row of executorExecute(plan)) 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 exec = this.#executor;
+		if (typeof exec.transaction === "function") return withMutationScope(exec, [storeName], async (scope) => {
+			const existing = (await scope.execute({
+				meta,
+				kind: "cursor-scan",
+				storeName,
+				filter: matches,
+				take: 1
+			}))[0];
+			if (existing === void 0) return (await scope.execute({
+				meta,
+				kind: "put",
+				storeName,
+				record: createRecord
+			}))[0] ?? createRecord;
+			const key = existing[keyPath];
+			return (await scope.execute({
+				meta,
+				kind: "update",
+				storeName,
+				key,
+				patch: patchRecord
+			}))[0] ?? existing;
+		});
+		const existing = await this.where(args.where).first();
+		if (!existing) return this.create(args.create);
+		const key = existing[keyPath];
+		const plan = {
+			meta,
+			ast: {
+				kind: "upsert",
+				modelName: this.#modelName,
+				create: createRecord,
+				update: patchRecord,
+				where: args.where
+			},
+			idbPlan: {
+				meta,
+				kind: "update",
+				storeName,
+				key,
+				patch: patchRecord
+			}
+		};
+		for await (const row of this.#executor.execute(plan)) return row;
+		return existing;
+	}
+	createAll(data) {
+		const groupingKey = this.#newGroupingKey();
+		const meta = this.#planMeta(groupingKey);
+		const records = data.map((d) => d);
+		const plan = {
+			meta,
+			ast: {
+				kind: "createAll",
+				modelName: this.#modelName,
+				data: records
+			},
+			idbPlan: {
+				meta,
+				kind: "batch",
+				storeNames: [this.#storeName],
+				ops: records.map((record) => ({
+					meta,
+					kind: "put",
+					storeName: this.#storeName,
+					record
+				}))
+			}
+		};
+		const executorExecute = this.#executor.execute.bind(this.#executor);
+		return new AsyncIterableResult((async function* () {
+			for await (const row of executorExecute(plan)) yield row;
+		})());
+	}
+	async createCount(data) {
+		return (await this.createAll(data).toArray()).length;
+	}
+	deleteAll() {
+		const combined = this.#combinedFilterExpr();
+		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
+		if (hasEnforceableChildRelations(this.#contract, this.#modelName)) {
+			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;
+			})());
+		}
+		const groupingKey = this.#newGroupingKey();
+		const meta = this.#planMeta(groupingKey);
+		const ast = {
+			kind: "deleteAll",
+			modelName: this.#modelName,
+			...combined !== void 0 ? { where: combined } : {}
+		};
+		const storeName = this.#storeName;
+		const executorExecute = this.#executor.execute.bind(this.#executor);
+		return new AsyncIterableResult((async function* () {
+			const plan = {
+				meta,
+				ast,
+				idbPlan: {
+					meta,
+					kind: "scan-write",
+					storeName,
+					write: "delete",
+					...filter !== void 0 ? { filter } : {}
+				}
+			};
+			for await (const row of executorExecute(plan)) 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 scanPlan = this.#buildScanPlan(groupingKey);
+		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.execute(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.execute(plan)) rows.push(row);
+		return rows;
+	}
+	#buildScanPlan(groupingKey) {
+		const combined = this.#combinedFilterExpr();
+		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
+		const comparator = buildRowComparator(this.#state.orderBy);
+		const meta = this.#planMeta(groupingKey);
+		return {
+			meta,
+			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 } : {}
+			},
+			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 } : {}
+			}
+		};
+	}
+	/**
+	* 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-next-idb/client-idb/orm";
+* import { createIdbRuntime } from "@prisma-next-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 { isRelationMutationDescriptor as a, isRelationMutationCallback as i, hasNestedMutationCallbacks as n, withMutationScope as o, createRelationMutator as r, idbOrm as t };
+
+//# sourceMappingURL=idb-orm-NHIZ3oNt.mjs.map