@prisma-idb/client-idb 0.11.0 → 0.13.0

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

@@ -1,8 +1,9 @@
-import { C as assertEnumValues, D as getRelation, E as getKeyPath, O as getStoreName, S as createMutationDefaultsCache, T as fieldValueToken, _ as requireTransactionExecutor, a as collectScalarFkStoreNames, b as applyCreateDefaults, c as executeDeleteWithReferentialActions, d as executeScalarCreateAllWithFkValidation, f as executeScalarCreateWithFkValidation, g as hasScalarFkFields, h as hasNestedMutationCallbacks, i as collectOnUpdateEnforcementStoreNames, l as executeNestedCreateMutation, m as hasEnforceableChildRelations, n as applyReferentialActionsForRowOnUpdate, o as executeBulkUpdateWithFkValidation, p as executeScalarUpdateWithFkValidation, s as executeDeleteAllWithReferentialActions, u as executeNestedUpdateMutation, v as validateScalarFks, w as extractKeyFromRow, x as applyUpdateDefaults, y as withMutationScope } from "./mutation-executor-SJqTuSbb.mjs";
+import { A as createMutationDefaultsCache, B as resolveDecimalKey, C as validateScalarFks, D as planQuery, E as lowerRows, F as combineFilterExprs, G as fieldValueToken, J as getStoreName, K as getKeyPath, M as assertValidRecord, N as assertEnumValues, O as applyUpdateDefaults, P as buildRowComparator, S as requireTransactionExecutor, T as lowerCount, U as buildCatalog, V as withDecimalIdentityExecutor, W as extractKeyFromRow, _ as hasEnforceableChildRelations, a as collectOnUpdateEnforcementStoreNames, b as makePlanMeta, c as executeBulkUpdateWithFkValidation, d as executeMutationPlan, f as executeNestedCreateMutation, g as executeScalarUpdateWithFkValidation, h as executeScalarCreateWithFkValidation, i as collectOnUpdateClosureStoreNames, k as completeCreateRecord, l as executeDeleteAllWithReferentialActions, m as executeScalarCreateAllWithFkValidation, n as applyReferentialActionsForRowOnUpdate, o as collectRelatedStoreNames, p as executeNestedUpdateMutation, q as getRelation, r as collectDeleteStoreNames, s as collectScalarFkStoreNames, u as executeDeleteWithReferentialActions, v as hasNestedMutationCallbacks, w as withMutationScope, x as readMutationRows, y as hasScalarFkFields } from "./mutation-executor-IuJmyWEG.mjs";
 import { AsyncIterableResult } from "@prisma/orm-framework/components/runtime";
-import { andExpr, evaluateFilter, fieldFilter, nullCheckExpr, shorthandToFilterExpr } from "@prisma-idb/adapter-idb/runtime";
 import { domainModelsAtDefaultNamespace } from "@prisma/orm-framework/contract/types";
-import { compareFieldValues, isValidIdbKey, keyEquals } from "@prisma-idb/target-idb/runtime";
+import { IdbExecuteError } from "@prisma-idb/driver-idb/runtime";
+import { absentAsNull, isValidIdbKey } from "@prisma-idb/target-idb/runtime";
+import { andExpr, fieldFilter, nullCheckExpr, shorthandToFilterExpr } from "@prisma-idb/adapter-idb/runtime";
 //#region src/core/model-accessor.ts
 /**
 * Proxy-based typed accessor handed to `where(fn)` callbacks.
@@ -53,7 +54,9 @@ function createFieldAccessor(field) {
 */
 function createModelAccessor() {
 	const cache = /* @__PURE__ */ new Map();
-	return new Proxy({}, { get(_target, prop) {
+	return new Proxy({}, { 
+	/** Reuse the field accessor within one filter callback so repeated reads share its operator surface. */
+get(_target, prop) {
 		if (typeof prop !== "string") return void 0;
 		let acc = cache.get(prop);
 		if (acc === void 0) {
@@ -94,39 +97,6 @@ function mergeAccessorState(state, overrides) {
 	};
 }
 //#endregion
-//#region src/core/query-shaping.ts
-/**
-* Combine accumulated filter expressions with AND.
-*
-* Returns `undefined` when no filter is present so callers can skip building a
-* row-filter closure. Shared by {@link IdbStoreAccessorImpl} (top-level scans)
-* and the relation loader (refined `include()` child scans).
-*/
-function combineFilterExprs(filters) {
-	if (filters.length === 0) return void 0;
-	if (filters.length === 1) return filters[0];
-	return andExpr(filters);
-}
-/**
-* Build an in-memory comparator from an `orderBy` spec (field → direction).
-*
-* Returns `undefined` when there is nothing to sort by. Compares fields in
-* declaration order, with {@link compareFieldValues}: the same order an
-* IndexedDB index uses, so equal `Date`s tie and fall through to the next
-* field, and `null`s sort last (first when descending).
-*/
-function buildRowComparator(orderBy) {
-	if (orderBy === void 0) return void 0;
-	return (a, b) => {
-		for (const [field, dir] of Object.entries(orderBy)) {
-			const cmp = compareFieldValues(a[field], b[field]);
-			if (cmp === 0) continue;
-			return dir === "desc" ? -cmp : cmp;
-		}
-		return 0;
-	};
-}
-//#endregion
 //#region src/core/aggregate-builder.ts
 /**
 * Build the aggregate selector factory handed to `.aggregate(agg => …)` and
@@ -179,33 +149,43 @@ function isAggregateSelector(value) {
 * - `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()`.
+*   null handling). Values must match the declared number codec.
 */
-function reduceAggregate(fn, field, rows) {
+function reduceAggregate(fn, field, rows, codecId) {
 	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 (typeof raw !== "number" || !Number.isFinite(raw)) throw new TypeError(`${fn}("${field}") requires finite number values`);
+		if (codecId === "idb/int32@1" && (!Number.isInteger(raw) || raw < -2147483648 || raw > 2147483647)) throw new TypeError(`${fn}("${field}") requires Int values in the signed 32-bit range`);
+		values.push(raw);
 	}
 	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);
+		case "sum": return sumValues(values, field, codecId === "idb/int32@1");
+		case "avg": return sumValues(values, field, codecId === "idb/int32@1") / values.length;
+		case "min": return values.reduce((acc, n) => Math.min(acc, n));
+		case "max": return values.reduce((acc, n) => Math.max(acc, n));
+	}
+}
+/** Reject overflow before a rounded or nonfinite intermediate total can reach the result. */
+function sumValues(values, field, integer) {
+	let total = 0;
+	for (const value of values) {
+		total += value;
+		if (!Number.isFinite(total) || integer && !Number.isSafeInteger(total)) throw new RangeError(`Aggregate total for "${field}" exceeds the ${integer ? "safe integer" : "finite number"} range`);
 	}
+	return total;
 }
 /**
 * Run every selector in an aggregate spec against `rows`, producing the
 * result object keyed by the spec's aliases.
 */
-function computeAggregateSpec(spec, rows) {
+function computeAggregateSpec(spec, rows, fields = {}) {
 	const result = {};
-	for (const [alias, selector] of Object.entries(spec)) result[alias] = reduceAggregate(selector.fn, selector.field, rows);
+	for (const [alias, selector] of Object.entries(spec)) result[alias] = reduceAggregate(selector.fn, selector.field, rows, fields[selector.field ?? ""]?.codecId);
 	return result;
 }
 /**
@@ -223,14 +203,20 @@ function toAggregateRequests(spec) {
 }
 /**
 * 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
+* value must be a real selector over a declared scalar number field (except
+* count, which has no field). 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) {
+function assertValidAggregateSpec(spec, context, fields) {
 	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`);
+	for (const [alias, selector] of entries) {
+		if (!isAggregateSelector(selector)) throw new Error(`${context} selector "${alias}" is invalid`);
+		if (selector.fn === "count") continue;
+		const field = typeof selector.field === "string" ? fields[selector.field] : void 0;
+		if (!field || field.collection || field.codecId !== "idb/int32@1" && field.codecId !== "idb/double@1") throw new TypeError(`${context} selector "${alias}" requires a declared number field (Int or Float)`);
+	}
 }
 //#endregion
 //#region src/core/grouped-accessor.ts
@@ -249,9 +235,11 @@ function groupToken(value) {
 }
 /** Build a grouped accessor that reduces materialized rows from the source accessor. */
 function createGroupedAccessor(init) {
-	return { async aggregate(fn) {
+	return { 
+	/** Materialize matching rows, partition them by group key, and reduce each group. */
+async aggregate(fn) {
 		const spec = fn(createAggregateBuilder());
-		assertValidAggregateSpec(spec, "groupBy().aggregate()");
+		assertValidAggregateSpec(spec, "groupBy().aggregate()", init.fields);
 		const ast = {
 			kind: "groupBy",
 			modelName: init.modelName,
@@ -277,464 +265,28 @@ function createGroupedAccessor(init) {
 		}
 		return Array.from(groups.values()).map((group) => ({
 			...group.key,
-			...computeAggregateSpec(spec, group.rows)
+			...computeAggregateSpec(spec, group.rows, init.fields)
 		}));
 	} };
 }
 //#endregion
-//#region src/core/planner/catalog.ts
-const catalogs = /* @__PURE__ */ new WeakMap();
-/** Build a catalog once per contract identity and store name. Contracts are immutable. */
-function buildCatalog(contract, storeName) {
-	const cached = catalogs.get(contract)?.get(storeName);
-	if (cached) return cached;
-	const store = contract.storage.stores[storeName];
-	if (!store) throw new Error(`Store "${storeName}" is not in the contract`);
-	const fields = {};
-	for (const model of Object.values(domainModelsAtDefaultNamespace(contract.domain))) {
-		if (model.storage.storeName !== storeName) continue;
-		for (const [name, field] of Object.entries(model.fields)) fields[name] = Object.freeze({
-			codecId: field.type.kind === "scalar" ? field.type.codecId : void 0,
-			nullable: field.nullable,
-			collection: field.many === true || field.dict === true
-		});
-	}
-	const catalog = Object.freeze({
-		storeName,
-		primaryKey: source(store.keyPath, true, false),
-		indexes: Object.freeze(Object.entries(store.indexes ?? {}).map(([name, index]) => source(index.keyPath, index.unique, index.multiEntry ?? false, name))),
-		fields: Object.freeze(fields)
-	});
-	let byStore = catalogs.get(contract);
-	if (!byStore) {
-		byStore = /* @__PURE__ */ new Map();
-		catalogs.set(contract, byStore);
-	}
-	byStore.set(storeName, catalog);
-	return catalog;
-}
-function source(keyPath, unique, multiEntry, indexName) {
-	const path = typeof keyPath === "string" ? keyPath : Object.freeze([...keyPath]);
-	return Object.freeze({
-		keyPath: path,
-		fields: Object.freeze(typeof path === "string" ? [path] : [...path]),
-		unique,
-		multiEntry,
-		...indexName === void 0 ? {} : { indexName }
-	});
-}
-//#endregion
-//#region src/core/planner/plan.ts
-const COST = {
-	UNIQUE_POINT: 0,
-	PRIMARY_POINT: 1,
-	INDEX_POINT: 2,
-	PREFIX_POINT: 3,
-	TWO_SIDED_RANGE: 4,
-	ONE_SIDED_RANGE: 5,
-	ORDER_ONLY_SCAN: 6
-};
-const KEY_PARTIAL_CODECS = /* @__PURE__ */ new Set(["idb/double@1", "idb/date@1"]);
-const KEY_CODECS = /* @__PURE__ */ new Set([
-	"idb/string@1",
-	"idb/int32@1",
-	"idb/double@1",
-	"idb/date@1",
-	"idb/decimal@1",
-	"idb/bytes@1"
-]);
-/** Choose the cheapest safe access without opening IndexedDB or probing cardinality. */
-function planQuery(catalog, request) {
-	const normalized = normalize(request.where);
-	if (normalized.empty) return {
-		access: { kind: "empty" },
-		exact: true
-	};
-	const orders = Object.entries(request.orderBy ?? {});
-	if (normalized.excluded || request.hasRelationFilter || orders.length > 1) return full(false);
-	const constraints = /* @__PURE__ */ new Map();
-	for (const atom of normalized.atoms) {
-		let constraint = constraints.get(atom.field);
-		if (!constraint) {
-			constraint = { consumed: 0 };
-			constraints.set(atom.field, constraint);
-		}
-		addAtom(constraint, atom, catalog.fields[atom.field]);
-	}
-	for (const [name, constraint] of constraints) {
-		if (keyPartial(catalog.fields[name]) && !constraint.rejectsNonKeys) {
-			delete constraint.lower;
-			delete constraint.upper;
-			constraint.consumed = 0;
-		}
-		if (contradictory(constraint)) return {
-			access: { kind: "empty" },
-			exact: true
-		};
-	}
-	const sources = [catalog.primaryKey, ...catalog.indexes];
-	const candidates = sources.flatMap((source, declaration) => {
-		const candidate = filteringCandidate(catalog, source, constraints, declaration);
-		return candidate ? [candidate] : [];
-	});
-	candidates.sort((a, b) => a.cost - b.cost || a.ranges.length - b.ranges.length || Number(a.source.indexName !== void 0) - Number(b.source.indexName !== void 0) || a.declaration - b.declaration);
-	let selected = candidates[0];
-	let direction;
-	if (orders.length === 1 && request.take !== void 0) {
-		const [field, order] = orders[0];
-		if (selected) {
-			if (singleFieldSource(selected.source, field)) direction = order === "asc" ? "next" : "prev";
-		} else {
-			const ordering = sources.find((source) => !source.multiEntry && singleFieldSource(source, field) && completeKeyField(catalog.fields[field]));
-			if (ordering) {
-				selected = {
-					source: ordering,
-					ranges: [void 0],
-					cost: COST.ORDER_ONLY_SCAN,
-					consumed: 0,
-					declaration: sources.indexOf(ordering)
-				};
-				direction = order === "asc" ? "next" : "prev";
-			}
-		}
-	}
-	if (!selected) {
-		const partialOrder = orders.length === 1 && request.take !== void 0 && keyPartial(catalog.fields[orders[0][0]]);
-		return full(normalized.atoms.length + normalized.residual === 0 && !partialOrder);
-	}
-	return {
-		access: {
-			kind: "ranges",
-			source: selected.source,
-			ranges: selected.ranges
-		},
-		exact: selected.consumed === normalized.atoms.length && normalized.residual === 0,
-		...direction === void 0 ? {} : { direction }
-	};
-}
-function full(exact) {
-	return {
-		access: { kind: "full" },
-		exact
-	};
-}
-function normalize(where) {
-	const result = {
-		atoms: [],
-		residual: 0,
-		excluded: false,
-		empty: false
-	};
-	function visit(expr) {
-		switch (expr.kind) {
-			case "field":
-				if (expr.op === "in" && (!Array.isArray(expr.value) || expr.value.length === 0)) result.empty = true;
-				result.atoms.push(expr);
-				break;
-			case "and":
-				expr.exprs.forEach(visit);
-				break;
-			case "or": {
-				if (expr.exprs.length === 0) {
-					result.empty = true;
-					break;
-				}
-				const branches = expr.exprs;
-				const first = branches[0];
-				if (first.kind !== "field" || !branches.every((branch) => branch.kind === "field" && branch.field === first.field && (branch.op === "eq" || branch.op === "in"))) {
-					result.excluded = true;
-					break;
-				}
-				const values = branches.flatMap((branch) => {
-					const atom = branch;
-					return atom.op === "eq" ? [atom.value] : Array.isArray(atom.value) ? atom.value : [];
-				});
-				visit({
-					kind: "field",
-					field: first.field,
-					op: "in",
-					value: values
-				});
-				break;
-			}
-			case "not":
-				result.excluded = true;
-				break;
-			case "null-check": result.residual++;
-		}
-	}
-	if (where) visit(where);
-	return result;
-}
-function keyTyped(field) {
-	return field !== void 0 && !field.collection && KEY_CODECS.has(field.codecId ?? "");
-}
-function keyPartial(field) {
-	return KEY_PARTIAL_CODECS.has(field?.codecId ?? "");
-}
-function completeKeyField(field, constraint) {
-	return keyTyped(field) && field?.nullable === false && (!keyPartial(field) || constraint?.rejectsNonKeys === true);
-}
-function singleFieldSource(source, field) {
-	return source.fields.length === 1 && source.fields[0] === field;
-}
-function addAtom(constraint, atom, field) {
-	if (atom.op === "eq" || atom.op === "in") {
-		const values = atom.op === "eq" ? [atom.value] : Array.isArray(atom.value) ? atom.value : [];
-		if (!values.every(isValidIdbKey)) return;
-		const points = uniqueKeys(values);
-		constraint.points = constraint.points === void 0 ? points : constraint.points.filter((point) => points.some((value) => keyEquals(point, value)));
-		constraint.rejectsNonKeys = true;
-		constraint.consumed++;
-		return;
-	}
-	if (!keyTyped(field)) return;
-	if (atom.op === "startsWith") {
-		if (field?.codecId !== "idb/string@1" || typeof atom.value !== "string") return;
-		intersectBound(constraint, "lower", {
-			value: atom.value,
-			open: false
-		});
-		const upper = stringSuccessor(atom.value);
-		if (upper !== void 0) intersectBound(constraint, "upper", {
-			value: upper,
-			open: true
-		});
-		constraint.startsWith = true;
-		constraint.consumed++;
-	} else if ([
-		"gt",
-		"gte",
-		"lt",
-		"lte"
-	].includes(atom.op) && isValidIdbKey(atom.value)) {
-		const side = atom.op === "gt" || atom.op === "gte" ? "lower" : "upper";
-		const strict = atom.op === "gt" || atom.op === "lt";
-		intersectBound(constraint, side, {
-			value: atom.value,
-			open: strict
-		});
-		if (strict) constraint.rejectsNonKeys = true;
-		constraint.consumed++;
-	}
-}
-function uniqueKeys(values) {
-	const sorted = [...values].sort(compareFieldValues);
-	return sorted.filter((value, i) => i === 0 || compareFieldValues(sorted[i - 1], value) !== 0);
-}
-function intersectBound(constraint, side, bound) {
-	const previous = constraint[side];
-	const comparison = previous === void 0 ? 0 : compareFieldValues(bound.value, previous.value);
-	if (!previous || (side === "lower" ? comparison > 0 : comparison < 0) || comparison === 0 && bound.open) constraint[side] = bound;
-}
-function insideBounds(value, constraint) {
-	const lower = constraint.lower;
-	const upper = constraint.upper;
-	if (lower && (compareFieldValues(value, lower.value) < 0 || lower.open && keyEquals(value, lower.value))) return false;
-	if (upper && (compareFieldValues(value, upper.value) > 0 || upper.open && keyEquals(value, upper.value))) return false;
-	return true;
-}
-function contradictory(constraint) {
-	if (constraint.points) {
-		constraint.points = constraint.points.filter((value) => insideBounds(value, constraint));
-		return constraint.points.length === 0;
-	}
-	if (!constraint.lower || !constraint.upper) return false;
-	const comparison = compareFieldValues(constraint.lower.value, constraint.upper.value);
-	return comparison > 0 || comparison === 0 && (constraint.lower.open || constraint.upper.open);
-}
-function filteringCandidate(catalog, source, constraints, declaration) {
-	if (source.multiEntry || source.fields.length === 0) return void 0;
-	if (source.fields.some((name) => keyPartial(catalog.fields[name]) && !constraints.get(name)?.rejectsNonKeys)) return void 0;
-	let prefixes = [[]];
-	let consumed = 0;
-	let position = 0;
-	while (position < source.fields.length) {
-		const constraint = constraints.get(source.fields[position]);
-		if (constraint?.points === void 0) break;
-		if (prefixes.length * constraint.points.length > 1024) return void 0;
-		prefixes = prefixes.flatMap((prefix) => constraint.points.map((point) => [...prefix, point]));
-		consumed += constraint.consumed;
-		position++;
-	}
-	const constraint = constraints.get(source.fields[position] ?? "");
-	const hasRange = constraint !== void 0 && (constraint.lower !== void 0 || constraint.upper !== void 0);
-	if (position === 0 && !hasRange) return void 0;
-	const used = position + Number(hasRange);
-	if (!source.fields.slice(used).every((field) => completeKeyField(catalog.fields[field], constraints.get(field)))) return void 0;
-	const compound = typeof source.keyPath !== "string";
-	if (position === source.fields.length) return {
-		source,
-		ranges: prefixes.map((prefix) => ({
-			kind: "only",
-			key: compound ? prefix : prefix[0]
-		})),
-		cost: source.indexName !== void 0 && source.unique ? COST.UNIQUE_POINT : source.indexName === void 0 ? COST.PRIMARY_POINT : COST.INDEX_POINT,
-		consumed,
-		declaration
-	};
-	if (hasRange) consumed += constraint.consumed;
-	const ranges = prefixes.map((prefix) => compound ? compoundRange(prefix, constraint, source.fields.length - used) : scalarRange(constraint));
-	if (ranges.some((range) => range.kind === "bound" && (compareFieldValues(range.lower, range.upper) > 0 || keyEquals(range.lower, range.upper) && (range.lowerOpen || range.upperOpen)))) return void 0;
-	return {
-		source,
-		ranges,
-		cost: hasRange ? constraint.lower && constraint.upper && !constraint.startsWith ? COST.TWO_SIDED_RANGE : COST.ONE_SIDED_RANGE : COST.PREFIX_POINT,
-		consumed,
-		declaration
-	};
-}
-function scalarRange(constraint) {
-	if (constraint.lower && constraint.upper) return {
-		kind: "bound",
-		lower: constraint.lower.value,
-		upper: constraint.upper.value,
-		lowerOpen: constraint.lower.open,
-		upperOpen: constraint.upper.open
-	};
-	if (constraint.lower) return {
-		kind: "lower",
-		key: constraint.lower.value,
-		open: constraint.lower.open
-	};
-	return {
-		kind: "upper",
-		key: constraint.upper.value,
-		open: constraint.upper.open
-	};
-}
-function compoundRange(prefix, constraint, trailing) {
-	const lower = constraint?.lower;
-	const upper = constraint?.upper;
-	return {
-		kind: "bound",
-		lower: lower ? [
-			...prefix,
-			lower.value,
-			...lower.open && trailing > 0 ? [[]] : []
-		] : prefix.length ? prefix : [-Infinity],
-		upper: upper ? [
-			...prefix,
-			upper.value,
-			...!upper.open && trailing > 0 ? [[]] : []
-		] : [...prefix, []],
-		lowerOpen: lower?.open ?? false,
-		upperOpen: upper ? upper.open || trailing > 0 : true
-	};
-}
-function stringSuccessor(prefix) {
-	for (let i = prefix.length - 1; i >= 0; i--) {
-		const code = prefix.charCodeAt(i);
-		if (code < 65535) return prefix.slice(0, i) + String.fromCharCode(code + 1);
-	}
+//#region src/core/unique-lookup.ts
+/**
+* Copy the own enumerable properties of an upsert `where` once. Validation and
+* filter parsing then see the same values even when a property is a getter.
+* Non-object inputs pass through so `assertUniqueLookup` can reject them.
+*/
+function snapshotLookup(where) {
+	return typeof where === "object" && where !== null && !Array.isArray(where) ? Object.fromEntries(Object.entries(where)) : where;
 }
-//#endregion
-//#region src/core/planner/lower.ts
 /**
-* Lower row access without creating IDBKeyRange objects or awaiting work.
-* Run `finish` after the executor has materialized all returned rows.
-* Without `orderBy`, row order and pagination selection are unspecified.
-* Rows tied on every ordering field may appear in any order, including at
-* pagination boundaries. Add a unique ordering field for deterministic pages.
+* Require equality on a complete native unique key before upsert can mutate.
+* Null and other non-key values are absent from IndexedDB indexes, so even a
+* declared unique index cannot make those filters identify at most one row.
 */
-function lowerRows(catalog, logical, meta, request, additionalFilter) {
-	const filter = (row) => (request.where === void 0 || evaluateFilter(request.where, row)) && (additionalFilter === void 0 || additionalFilter(row));
-	const comparator = logical.direction === void 0 ? buildRowComparator(request.orderBy) : void 0;
-	const base = {
-		meta,
-		storeName: catalog.storeName
-	};
-	const pagination = {
-		...request.skip === void 0 ? {} : { skip: request.skip },
-		...request.take === void 0 ? {} : { take: request.take }
-	};
-	let shapedByDriver = false;
-	let idbPlan;
-	switch (logical.access.kind) {
-		case "empty":
-			idbPlan = {
-				meta,
-				kind: "batch",
-				storeNames: [catalog.storeName],
-				ops: []
-			};
-			break;
-		case "full":
-			idbPlan = {
-				...base,
-				kind: "cursor-scan",
-				filter,
-				...comparator === void 0 ? {} : { comparator },
-				...pagination
-			};
-			shapedByDriver = true;
-			break;
-		case "ranges": {
-			const { source } = logical.access;
-			const ranges = [...logical.access.ranges];
-			if (logical.direction === "prev") ranges.reverse();
-			const single = ranges.length === 1;
-			const ops = ranges.map((range) => {
-				if (range?.kind === "only" && source.indexName === void 0) return {
-					...base,
-					kind: "key-get",
-					key: range.key
-				};
-				const access = {
-					...base,
-					...source.indexName === void 0 ? {} : { indexName: source.indexName },
-					...range === void 0 ? {} : { range }
-				};
-				if (!single && logical.direction !== void 0 && request.take !== void 0) return {
-					...access,
-					kind: "cursor-scan",
-					direction: logical.direction,
-					filter,
-					take: (request.skip ?? 0) + request.take
-				};
-				if (single && request.take !== void 0) {
-					shapedByDriver = true;
-					return {
-						...access,
-						kind: "cursor-scan",
-						filter,
-						...logical.direction === void 0 ? {} : { direction: logical.direction },
-						...comparator === void 0 ? {} : { comparator },
-						...pagination
-					};
-				}
-				if (logical.direction === "prev") return {
-					...access,
-					kind: "cursor-scan",
-					direction: "prev",
-					filter
-				};
-				return {
-					...access,
-					kind: "get-all"
-				};
-			});
-			idbPlan = single ? ops[0] : {
-				meta,
-				kind: "batch",
-				storeNames: [catalog.storeName],
-				ops
-			};
-			break;
-		}
-	}
-	return {
-		idbPlan,
-		finish(rows) {
-			let result = rows.filter(filter);
-			if (!shapedByDriver) {
-				if (comparator !== void 0) result.sort(comparator);
-				const skip = request.skip ?? 0;
-				result = result.slice(skip, request.take === void 0 ? void 0 : skip + request.take);
-			}
-			return result;
-		}
-	};
+function assertUniqueLookup(catalog, where) {
+	const sources = [catalog.primaryKey, ...catalog.indexes];
+	if (!(typeof where === "object" && where !== null && !Array.isArray(where) && sources.some((source) => source.unique && !source.multiEntry && source.fields.length > 0 && source.fields.every((field) => Object.prototype.propertyIsEnumerable.call(where, field) && isValidIdbKey(where[field]))))) throw new Error(`Invalid upsert where for "${catalog.storeName}": provide a complete primary key or unique index with non-null IndexedDB key values`);
 }
 //#endregion
 //#region src/core/relation-loader.ts
@@ -797,7 +349,7 @@ async function loadRelation(relName, entry, rows, contract, modelName, executor,
 	const joinWhere = andExpr(targetFields.map((field, i) => fieldFilter(field, "in", [...localTuples.values()].map((tuple) => tuple[i]))));
 	const where = refinedWhere === void 0 ? joinWhere : andExpr([joinWhere, refinedWhere]);
 	const request = { ...refinedWhere === void 0 ? {} : { where: refinedWhere } };
-	const catalog = buildCatalog(contract, relatedStoreName);
+	const catalog = buildCatalog(contract, relatedStoreName, relatedModelName);
 	const lowered = lowerRows(catalog, planQuery(catalog, { where }), planMeta, request, (row) => {
 		const token = tupleToken(row, targetFields);
 		return token !== null && localTuples.has(token);
@@ -806,10 +358,10 @@ async function loadRelation(relName, entry, rows, contract, modelName, executor,
 		meta: planMeta,
 		idbPlan: lowered.idbPlan
 	};
-	return attachRelatedRows(relName, entry, rows, lowered.finish(await executor.query(plan).toArray()), relation);
+	return attachRelatedRows(relName, entry, rows, lowered.finish(await executor.query(plan).toArray()), relation, catalog.fields);
 }
 /** Attach related rows by their join tuple, shaping each parent's collection independently. */
-function attachRelatedRows(relName, entry, rows, relatedRows, relation) {
+function attachRelatedRows(relName, entry, rows, relatedRows, relation, fields) {
 	const { cardinality, on: { localFields, targetFields } } = relation;
 	if (cardinality === "1:N") {
 		const grouped = /* @__PURE__ */ new Map();
@@ -828,7 +380,7 @@ function attachRelatedRows(relName, entry, rows, relatedRows, relation) {
 			...row,
 			[relName]: groupFor(row).length
 		}));
-		const comparator = buildRowComparator(entry.state.orderBy);
+		const comparator = buildRowComparator(entry.state.orderBy, fields);
 		const skip = entry.state.skip ?? 0;
 		const take = entry.state.take;
 		return rows.map((row) => {
@@ -900,6 +452,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		this.#newGroupingKey = newGroupingKey ?? (() => `idb-op-${++_key}`);
 		this.#includeRefinementMode = includeRefinementMode;
 	}
+	/** Add a callback or shorthand predicate to a new accessor without mutating this one. */
 	where(filter) {
 		const expr = typeof filter === "function" ? filter(createModelAccessor()) : shorthandToFilterExpr(filter);
 		if (expr === void 0) return this.#clone({});
@@ -914,6 +467,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	skip(n) {
 		return this.#clone({ skip: n });
 	}
+	/** Add a collection or count refinement while preserving this accessor state. */
 	include(relation, refineFn) {
 		const entry = this.#resolveIncludeEntry(relation, refineFn);
 		const newState = mergeAccessorState(this.#state, { includes: {
@@ -922,9 +476,11 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		} });
 		return new IdbStoreAccessorImpl(this.#contract, this.#modelName, this.#executor, newState, this.#newGroupingKey, this.#includeRefinementMode);
 	}
+	/** Narrow scalar output fields while retaining included relations. */
 	select(...fields) {
 		return this.#clone({ selectedFields: fields });
 	}
+	/** Read matching rows, load includes, and project fields before yielding. */
 	all() {
 		const groupingKey = this.#newGroupingKey();
 		const buildScanPlan = this.#buildScanPlan.bind(this);
@@ -942,9 +498,11 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	async first() {
 		return this.take(1).all().first();
 	}
+	/** Reduce all filtered rows; query pagination does not constrain aggregates. */
 	async aggregate(fn) {
 		const spec = fn(createAggregateBuilder());
-		assertValidAggregateSpec(spec, "aggregate()");
+		const { fields } = buildCatalog(this.#contract, this.#storeName, this.#modelName);
+		assertValidAggregateSpec(spec, "aggregate()", fields);
 		const combined = this.#combinedFilterExpr();
 		const ast = {
 			kind: "aggregate",
@@ -952,18 +510,21 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			aggregates: toAggregateRequests(spec),
 			...combined !== void 0 ? { where: combined } : {}
 		};
-		return computeAggregateSpec(spec, await this.#materialize(this.#newGroupingKey(), ast));
+		return computeAggregateSpec(spec, await this.#materialize(this.#newGroupingKey(), ast), fields);
 	}
+	/** Carry this filter into a grouped accessor whose materialization is owned here. */
 	groupBy(...fields) {
 		const combined = this.#combinedFilterExpr();
 		const materialize = (ast) => this.#materialize(this.#newGroupingKey(), ast);
 		return createGroupedAccessor({
 			modelName: this.#modelName,
 			by: fields,
+			fields: buildCatalog(this.#contract, this.#storeName, this.#modelName).fields,
 			where: combined,
 			materialize
 		});
 	}
+	/** Complete and validate one record, using a transaction when relations need checks. */
 	async create(data) {
 		const record = data;
 		if (hasNestedMutationCallbacks(this.#contract, this.#modelName, record)) return await executeNestedCreateMutation({
@@ -972,8 +533,9 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			modelName: this.#modelName,
 			data: record
 		});
-		const withDefaults = applyCreateDefaults(this.#contract.execution?.mutations.defaults, this.#storeName, record, createMutationDefaultsCache());
+		const withDefaults = completeCreateRecord(this.#contract, this.#modelName, record, createMutationDefaultsCache());
 		assertEnumValues(this.#contract, this.#modelName, withDefaults);
+		assertValidRecord(this.#contract, this.#modelName, "create", withDefaults);
 		if (hasScalarFkFields(this.#contract, this.#modelName, withDefaults)) return await executeScalarCreateWithFkValidation({
 			executor: requireTransactionExecutor(this.#executor),
 			contract: this.#contract,
@@ -996,38 +558,29 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 				record: withDefaults
 			}
 		};
-		for await (const row of this.#executor.query(plan)) return row;
-		return withDefaults;
+		const [row] = await this.#executor.query(plan).toArray();
+		return row ?? withDefaults;
 	}
+	/** Resolve a primary key numerically for Decimal fields while retaining its stored spelling. */
 	async findUnique(key) {
-		const groupingKey = this.#newGroupingKey();
-		const meta = this.#planMeta(groupingKey);
+		if (!isValidIdbKey(key)) return null;
+		const meta = this.#planMeta(this.#newGroupingKey());
 		const ast = {
 			kind: "findUnique",
 			modelName: this.#modelName,
 			key
 		};
-		const keyPath = getKeyPath(this.#contract, this.#modelName);
-		const fields = typeof keyPath === "string" ? [keyPath] : keyPath;
-		const values = typeof keyPath === "string" ? [key] : key;
-		const where = combineFilterExprs(fields.map((field, i) => ({
-			kind: "field",
-			field,
-			op: "eq",
-			value: values[i]
-		})));
-		const request = {
-			...where === void 0 ? {} : { where },
-			take: 1
-		};
-		const lowered = this.#lowerRows(meta, request);
-		const rows = await this.#executor.query({
+		const row = await resolveDecimalKey({ execute: (body) => this.#executor.query({
 			meta,
 			ast,
-			idbPlan: lowered.idbPlan
-		}).toArray();
-		return lowered.finish(rows)[0] ?? null;
+			idbPlan: {
+				...body,
+				meta
+			}
+		}).toArray() }, this.#contract, this.#modelName, key);
+		return row === void 0 ? null : absentAsNull(this.#contract, this.#modelName)(row);
 	}
+	/** Delete a keyed row with child actions when its relations require them. */
 	async delete(key) {
 		if (hasEnforceableChildRelations(this.#contract, this.#modelName)) {
 			await executeDeleteWithReferentialActions({
@@ -1056,6 +609,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		};
 		await this.#executor.query(plan).toArray();
 	}
+	/** Update the first matching row with scalar or nested relation validation. */
 	async update(patch) {
 		const patchRecord = patch;
 		if (hasNestedMutationCallbacks(this.#contract, this.#modelName, patchRecord)) return await executeNestedUpdateMutation({
@@ -1103,10 +657,12 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	async updateCount(patch) {
 		return (await this.updateAll(patch).toArray()).length;
 	}
+	/** Select and apply the create or update arm inside one transaction. */
 	async upsert(args) {
+		const where = snapshotLookup(args.where);
+		assertUniqueLookup(buildCatalog(this.#contract, this.#storeName, this.#modelName), where);
 		const keyPath = getKeyPath(this.#contract, this.#modelName);
-		const whereExpr = shorthandToFilterExpr(args.where);
-		const matches = (row) => whereExpr === void 0 || evaluateFilter(whereExpr, row);
+		const whereExpr = shorthandToFilterExpr(where);
 		const meta = this.#planMeta(this.#newGroupingKey());
 		const createRecord = args.create;
 		const patchRecord = args.update;
@@ -1114,9 +670,11 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		const executionDefaults = this.#contract.execution?.mutations.defaults;
 		const exec = requireTransactionExecutor(this.#executor);
 		const effectivePatch = applyUpdateDefaults(executionDefaults, storeName, patchRecord, createMutationDefaultsCache());
-		const createWithDefaults = applyCreateDefaults(executionDefaults, storeName, createRecord, createMutationDefaultsCache());
+		const createWithDefaults = completeCreateRecord(this.#contract, this.#modelName, createRecord, createMutationDefaultsCache());
 		assertEnumValues(this.#contract, this.#modelName, effectivePatch);
 		assertEnumValues(this.#contract, this.#modelName, createWithDefaults);
+		assertValidRecord(this.#contract, this.#modelName, "update", effectivePatch);
+		assertValidRecord(this.#contract, this.#modelName, "create", createWithDefaults);
 		const { storeNames: onUpdateStoreNames } = collectOnUpdateEnforcementStoreNames(this.#contract, this.#modelName, effectivePatch);
 		const storeNames = [.../* @__PURE__ */ new Set([
 			storeName,
@@ -1125,13 +683,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			...collectScalarFkStoreNames(this.#contract, this.#modelName, effectivePatch)
 		])];
 		return withMutationScope(exec, storeNames, async (scope) => {
-			const existing = (await scope.execute({
-				meta,
-				kind: "cursor-scan",
-				storeName,
-				filter: matches,
-				take: 1
-			}))[0];
+			const existing = (await readMutationRows(scope, this.#contract, this.#modelName, whereExpr, 1))[0];
 			if (existing === void 0) {
 				await validateScalarFks(scope, this.#contract, this.#modelName, createWithDefaults);
 				return (await scope.execute({
@@ -1144,19 +696,20 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			await validateScalarFks(scope, this.#contract, this.#modelName, effectivePatch, existing);
 			const key = extractKeyFromRow(existing, keyPath);
 			await applyReferentialActionsForRowOnUpdate(scope, this.#contract, this.#modelName, existing, effectivePatch);
-			return (await scope.execute({
+			const rows = await scope.execute({
 				meta,
 				kind: "update",
 				storeName,
 				key,
 				patch: effectivePatch
-			}))[0] ?? existing;
+			});
+			return absentAsNull(this.#contract, this.#modelName)(rows[0] ?? existing);
 		});
 	}
+	/** Complete a batch with shared query defaults and insert it atomically. */
 	createAll(data) {
 		const defaultsCache = createMutationDefaultsCache();
-		const executionDefaults = this.#contract.execution?.mutations.defaults;
-		const records = data.map((d) => applyCreateDefaults(executionDefaults, this.#storeName, d, defaultsCache));
+		const records = data.map((d) => completeCreateRecord(this.#contract, this.#modelName, d, defaultsCache));
 		if (records.some((row) => hasScalarFkFields(this.#contract, this.#modelName, row))) {
 			const executor = requireTransactionExecutor(this.#executor);
 			const contract = this.#contract;
@@ -1196,7 +749,10 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		const contract = this.#contract;
 		const modelName = this.#modelName;
 		return new AsyncIterableResult((async function* () {
-			for (const record of records) assertEnumValues(contract, modelName, record);
+			for (const record of records) {
+				assertEnumValues(contract, modelName, record);
+				assertValidRecord(contract, modelName, "create", record);
+			}
 			for await (const row of executorQuery(plan)) yield row;
 		})());
 	}
@@ -1215,7 +771,6 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	*/
 	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);
@@ -1224,7 +779,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 				executor,
 				contract,
 				modelName,
-				...filter !== void 0 ? { filter } : {}
+				...combined === void 0 ? {} : { where: combined }
 			});
 			for (const row of rows) yield row;
 		})());
@@ -1232,23 +787,34 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	async deleteCount() {
 		return (await this.deleteAll().toArray()).length;
 	}
+	/** Return an include-count descriptor during refinement, or execute a top-level count. */
 	count() {
 		if (this.#includeRefinementMode) return createIncludeScalar(this.#state);
 		return this.#countTerminal();
 	}
+	/** Count this filtered page through the planner, without applying select or include. */
 	async #countTerminal() {
-		const scan = this.#buildScanPlan(this.#newGroupingKey());
 		const combined = this.#combinedFilterExpr();
+		const { skip, take } = this.#state;
+		const request = {
+			...combined === void 0 ? {} : { where: combined },
+			...skip === void 0 ? {} : { skip },
+			...take === void 0 ? {} : { take }
+		};
+		const meta = this.#planMeta(this.#newGroupingKey());
+		const catalog = buildCatalog(this.#contract, this.#storeName, this.#modelName);
+		const lowered = lowerCount(catalog, planQuery(catalog, request), meta, request);
 		const ast = {
 			kind: "count",
 			modelName: this.#modelName,
 			...combined !== void 0 ? { where: combined } : {}
 		};
 		const rows = await this.#executor.query({
-			...scan.plan,
-			ast
+			meta,
+			ast,
+			idbPlan: lowered.idbPlan
 		}).toArray();
-		return scan.finish(rows).length;
+		return lowered.finish(rows);
 	}
 	/**
 	* Resolve an `include()` argument pair into an {@link IncludeEntry}: run the
@@ -1294,9 +860,10 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		return lowered.finish(rows);
 	}
 	#lowerRows(meta, request) {
-		const catalog = buildCatalog(this.#contract, this.#storeName);
+		const catalog = buildCatalog(this.#contract, this.#storeName, this.#modelName);
 		return lowerRows(catalog, planQuery(catalog, request), meta, request);
 	}
+	/** Pair the query intent with its planned driver operation and result shaping. */
 	#buildScanPlan(groupingKey) {
 		const combined = this.#combinedFilterExpr();
 		const meta = this.#planMeta(groupingKey);
@@ -1327,6 +894,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	#combinedFilterExpr() {
 		return combineFilterExprs(this.#state.filters);
 	}
+	/** Batch-load each requested relation using the unprojected parent rows. */
 	async #applyIncludes(rows, groupingKey) {
 		const relNames = Object.keys(this.#state.includes);
 		if (relNames.length === 0) return rows;
@@ -1352,6 +920,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			return out;
 		});
 	}
+	/** Attach the contract hash and grouping key shared by this operation. */
 	#planMeta(groupingKey) {
 		return {
 			target: "idb",
@@ -1360,6 +929,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			annotations: { groupingKey }
 		};
 	}
+	/** Preserve shared runtime wiring while replacing only the accessor state. */
 	#clone(overrides) {
 		return new IdbStoreAccessorImpl(this.#contract, this.#modelName, this.#executor, mergeAccessorState(this.#state, overrides), this.#newGroupingKey, this.#includeRefinementMode);
 	}
@@ -1379,7 +949,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 * import { createIdbRuntime } from "@prisma-idb/runtime-idb/runtime";
 * import contract from "./prisma/idb-contract";
 *
-* const runtime = createIdbRuntime({ adapter, driver });
+* const runtime = createIdbRuntime({ adapter, driver, contract });
 * const db = idbOrm({ contract, executor: runtime });
 *
 * // Typed query builder:
@@ -1388,7 +958,8 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 * ```
 */
 function idbOrm(options) {
-	const { contract, executor } = options;
+	const { contract } = options;
+	const executor = withDecimalIdentityExecutor(contract, options.executor);
 	let _key = 0;
 	const newGroupingKey = () => `idb-op-${++_key}`;
 	const client = {};
@@ -1396,6 +967,243 @@ function idbOrm(options) {
 	return client;
 }
 //#endregion
-export { idbOrm as t };
+//#region src/core/open-transaction.ts
+/**
+* An executor bound to one already-open IDB transaction.
+*
+* `db.transaction()` hands its callback ORM accessors built on this executor.
+* Every query the accessors issue runs on the open transaction instead of
+* opening a new one. Operations that normally open their own mutation scope
+* (FK-checked writes, cascade deletes) get a view of the same transaction:
+* `commit()` on the view does nothing, so an inner operation cannot commit the
+* outer transaction, and `rollback()` aborts it.
+*
+* The executor also records how the transaction ended, so the runner can tell
+* a rolled-back transaction from one that IndexedDB auto-committed early
+* (ADR 005).
+*/
+function isTransactionInactive(error) {
+	return error instanceof IdbExecuteError && error.code === "TRANSACTION_INACTIVE";
+}
+/** Bind ORM operations to one scope and record aborts or early commits. */
+var OpenTransaction = class {
+	#scope;
+	#storeNames;
+	#meta;
+	#state = "open";
+	#autoCommitCause;
+	#ended = false;
+	constructor(scope, storeNames, meta) {
+		this.#scope = scope;
+		this.#storeNames = new Set(storeNames);
+		this.#meta = meta;
+	}
+	/** Stop accepting operations. Called once the callback has settled. */
+	end() {
+		this.#ended = true;
+	}
+	/** The error of the first operation that found the transaction already finished, if any. */
+	get autoCommitCause() {
+		return this.#autoCommitCause;
+	}
+	/**
+	* Whether IndexedDB has already finished this transaction on its own, so a
+	* rollback can no longer undo its writes. Probes the transaction when no
+	* operation has failed yet, and records the probe error as the cause, so call
+	* it before rolling back or committing.
+	*/
+	async hasAutoCommitted() {
+		if (this.#state !== "open") return this.#state === "auto-committed";
+		const [storeName] = this.#storeNames;
+		try {
+			await this.#scope.execute({
+				meta: this.#meta,
+				kind: "key-get",
+				storeName,
+				key: ""
+			});
+			return false;
+		} catch (error) {
+			if (!isTransactionInactive(error)) return false;
+			this.#state = "auto-committed";
+			this.#autoCommitCause = error;
+			return true;
+		}
+	}
+	/** Expose rows from the existing scope through the ORM query-result interface. */
+	query(plan) {
+		const run = executeMutationPlan.bind(null, this);
+		return new AsyncIterableResult((async function* () {
+			for (const row of await run(plan.idbPlan)) yield row;
+		})());
+	}
+	/** Reuse the outer scope after verifying that the requested stores were declared. */
+	async transaction(storeNames) {
+		this.#assertNotEnded();
+		try {
+			this.#assertStoresListed(storeNames);
+		} catch (error) {
+			this.#recordFailure(error);
+			throw error;
+		}
+		return this;
+	}
+	/** Run one operation in the scope and abort the transaction when it fails. */
+	async execute(plan) {
+		this.#assertNotEnded();
+		try {
+			this.#assertStoresListed([plan.storeName]);
+			return await this.#scope.execute(plan);
+		} catch (error) {
+			this.#recordFailure(error);
+			throw error;
+		}
+	}
+	async commit() {}
+	rollback() {
+		this.#recordFailure(void 0);
+	}
+	/**
+	* Wrap an ORM accessor so that any call that fails aborts the transaction.
+	*
+	* Some failures, such as enum validation, happen before an operation reaches
+	* this executor. Without this wrapper the callback could catch them and
+	* commit the writes made before. The wrapper covers errors thrown
+	* synchronously, rejected promises, and rejections of a result that is
+	* awaited directly (`AsyncIterableResult`). Objects the accessor returns,
+	* such as `where()` builders, are wrapped too.
+	*/
+	abortOnFailure(target) {
+		return new Proxy(target, { get: (object, property) => {
+			const value = Reflect.get(object, property, object);
+			if (typeof value !== "function") return value;
+			if (property === "then") return this.#observeThen(object, value);
+			return (...args) => {
+				const result = this.#recordThrown(() => value.apply(object, args));
+				if (result instanceof Promise) {
+					result.catch((error) => this.#recordFailure(error));
+					return result;
+				}
+				return typeof result === "object" && result !== null ? this.abortOnFailure(result) : result;
+			};
+		} });
+	}
+	/**
+	* `await result` passes its own rejection handler to `then()`, which turns the
+	* rejection into a fulfilled promise. Record the failure before that handler runs.
+	*/
+	#observeThen(object, then) {
+		return (onFulfilled, onRejected) => then.call(object, onFulfilled, (error) => {
+			this.#recordFailure(error);
+			if (typeof onRejected !== "function") throw error;
+			return onRejected(error);
+		});
+	}
+	/** Record synchronous accessor failures before propagating them to the callback. */
+	#recordThrown(call) {
+		try {
+			return call();
+		} catch (error) {
+			this.#recordFailure(error);
+			throw error;
+		}
+	}
+	#assertNotEnded() {
+		if (this.#ended) throw new Error("This transaction has ended. Do not use `tx` after the db.transaction() callback finishes.");
+	}
+	/** Reject undeclared stores before an operation can escape the transaction scope. */
+	#assertStoresListed(storeNames) {
+		const missing = storeNames.filter((name) => !this.#storeNames.has(name));
+		if (missing.length > 0) throw new Error(`Stores ${missing.map((name) => `"${name}"`).join(", ")} are not part of this transaction. List the models that own them in the first argument of db.transaction().`);
+	}
+	/** Any failed operation aborts the whole transaction, even if the callback catches the error. */
+	#recordFailure(error) {
+		if (this.#state !== "open") return;
+		if (isTransactionInactive(error)) {
+			this.#state = "auto-committed";
+			this.#autoCommitCause = error;
+			return;
+		}
+		this.#state = "aborted";
+		this.#scope.rollback();
+	}
+};
+//#endregion
+//#region src/core/orm-transaction.ts
+/**
+* Thrown when IndexedDB finished the transaction before the callback did, so
+* writes made before that point were committed and could not be rolled back.
+*
+* IndexedDB commits a transaction as soon as it has no pending request. That
+* happens when the callback awaits something other than a `tx` operation, such
+* as a timer or a network call (ADR 005). `cause` holds the original error.
+*/
+var IdbTransactionCommittedEarlyError = class extends Error {
+	constructor(cause) {
+		super("The transaction was committed before the db.transaction() callback finished, so writes made earlier in the callback were saved and not rolled back. Await only `tx` operations inside the callback; do not await timers or network calls.", { cause });
+		this.name = "IdbTransactionCommittedEarlyError";
+	}
+};
+/**
+* Run `fn` inside one readwrite transaction over the models behind `rootKeys`.
+*
+* Besides the listed models, the transaction opens the stores their operations
+* need: parents for foreign-key checks, children for referential actions, and
+* related models for `include`. An operation that needs any other store fails
+* with an error that names it.
+*/
+async function runOrmTransaction(options, rootKeys, fn) {
+	const { contract, executor } = options;
+	if (rootKeys.length === 0) throw new Error("db.transaction() needs at least one model to open the transaction on.");
+	const modelNames = rootKeys.map((key) => {
+		const root = contract.roots[key];
+		if (root === void 0) throw new Error(`db.transaction(): "${key}" is not a root of the contract.`);
+		return root.model;
+	});
+	const storeNames = [...new Set(modelNames.flatMap((model) => storeNamesNeededBy(contract, model)))];
+	const scope = await executor.transaction(storeNames, "readwrite");
+	const open = new OpenTransaction(scope, storeNames, makePlanMeta(contract));
+	let result;
+	try {
+		result = await fn(pickRoots(idbOrm({
+			contract,
+			executor: open
+		}), rootKeys, open));
+	} catch (error) {
+		open.end();
+		if (await open.hasAutoCommitted()) await failCommittedEarly(scope, error);
+		scope.rollback();
+		throw error;
+	}
+	open.end();
+	if (await open.hasAutoCommitted()) await failCommittedEarly(scope, open.autoCommitCause);
+	await scope.commit();
+	return result;
+}
+/**
+* Reports a transaction that IndexedDB committed before the callback ended. The writes
+* persisted, so the scope is committed rather than rolled back: a tracked scope only
+* announces its writes (for example, sync outbox notifications) when it commits.
+*/
+async function failCommittedEarly(scope, cause) {
+	await scope.commit().catch(() => {});
+	throw new IdbTransactionCommittedEarlyError(cause);
+}
+/** Collect stores used by relation reads, child actions, and cascading updates. */
+function storeNamesNeededBy(contract, modelName) {
+	return [
+		...collectRelatedStoreNames(contract, modelName),
+		...collectDeleteStoreNames(contract, modelName),
+		...collectOnUpdateClosureStoreNames(contract, modelName)
+	];
+}
+/** Expose only the requested roots and abort the scope on any accessor failure. */
+function pickRoots(orm, rootKeys, open) {
+	const picked = {};
+	for (const key of rootKeys) picked[key] = open.abortOnFailure(orm[key]);
+	return picked;
+}
+//#endregion
+export { runOrmTransaction as n, idbOrm as r, IdbTransactionCommittedEarlyError as t };
 
-//# sourceMappingURL=idb-orm-BitJ-EMq.mjs.map
+//# sourceMappingURL=orm-transaction-BGx1eukw.mjs.map