@prisma-idb/client-idb 0.12.0 → 0.13.0

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

@@ -1,7 +1,9 @@
-import { A as combineFilterExprs, C as planQuery, D as createMutationDefaultsCache, E as applyUpdateDefaults, F as getStoreName, M as fieldValueToken, N as getKeyPath, O as assertEnumValues, P as getRelation, S as lowerRows, T as applyCreateDefaults, _ as readMutationRows, a as collectScalarFkStoreNames, b as withMutationScope, c as executeDeleteWithReferentialActions, d as executeScalarCreateAllWithFkValidation, f as executeScalarCreateWithFkValidation, g as hasScalarFkFields, h as hasNestedMutationCallbacks, i as collectOnUpdateEnforcementStoreNames, j as extractKeyFromRow, k as buildRowComparator, l as executeNestedCreateMutation, m as hasEnforceableChildRelations, n as applyReferentialActionsForRowOnUpdate, o as executeBulkUpdateWithFkValidation, p as executeScalarUpdateWithFkValidation, s as executeDeleteAllWithReferentialActions, u as executeNestedUpdateMutation, v as requireTransactionExecutor, w as buildCatalog, x as lowerCount, y as validateScalarFks } from "./mutation-executor-inLFb0TE.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, fieldFilter, nullCheckExpr, shorthandToFilterExpr } from "@prisma-idb/adapter-idb/runtime";
 import { domainModelsAtDefaultNamespace } from "@prisma/orm-framework/contract/types";
+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.
@@ -52,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) {
@@ -145,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;
 }
 /**
@@ -189,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
@@ -215,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,
@@ -243,11 +265,30 @@ 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/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;
+}
+/**
+* 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 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
 /**
 * Batch-load a single named relation for all rows in `rows` and attach the
@@ -308,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);
@@ -317,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();
@@ -339,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) => {
@@ -411,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({});
@@ -425,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: {
@@ -433,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);
@@ -453,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",
@@ -463,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({
@@ -483,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,
@@ -507,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({
@@ -567,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({
@@ -614,9 +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 whereExpr = shorthandToFilterExpr(where);
 		const meta = this.#planMeta(this.#newGroupingKey());
 		const createRecord = args.create;
 		const patchRecord = args.update;
@@ -624,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,
@@ -648,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;
@@ -700,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;
 		})());
 	}
@@ -735,10 +787,12 @@ 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 combined = this.#combinedFilterExpr();
 		const { skip, take } = this.#state;
@@ -748,7 +802,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			...take === void 0 ? {} : { take }
 		};
 		const meta = this.#planMeta(this.#newGroupingKey());
-		const catalog = buildCatalog(this.#contract, this.#storeName);
+		const catalog = buildCatalog(this.#contract, this.#storeName, this.#modelName);
 		const lowered = lowerCount(catalog, planQuery(catalog, request), meta, request);
 		const ast = {
 			kind: "count",
@@ -806,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);
@@ -839,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;
@@ -864,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",
@@ -872,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);
 	}
@@ -891,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:
@@ -900,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 = {};
@@ -908,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-B1Br1C0F.mjs.map
+//# sourceMappingURL=orm-transaction-BGx1eukw.mjs.map