@prisma-idb/client-idb 0.11.0 → 0.13.0

package/dist/mutation-executor-IuJmyWEG.mjs

@@ -0,0 +1,2132 @@
+import { AsyncIterableResult } from "@prisma/orm-framework/components/runtime";
+import { domainModelsAtDefaultNamespace } from "@prisma/orm-framework/contract/types";
+import { IdbExecuteError } from "@prisma-idb/driver-idb/runtime";
+import { absentAsNull, compareDecimalValues, compareFieldValues, fieldValueToken, fieldValuesEqual, isValidIdbKey, keyEquals, keyEquals as keyEquals$1, keyToken, keyToken as keyToken$1, validateRecord } from "@prisma-idb/target-idb/runtime";
+import { andExpr, assertValidDecimalFilter, evaluateFilter, fieldFilter, shorthandToFilterExpr } from "@prisma-idb/adapter-idb/runtime";
+import { generateId } from "@prisma/orm-framework/ids/runtime";
+import { keyPathFields } from "@prisma-idb/target-idb/pack";
+//#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.
+* A single field name for the common case; an ordered array of field names
+* for a compound primary key.
+*
+* @throws if the model is unknown or its storage has no `keyPath` — a
+* validated contract always has one, so this only fires on a malformed or
+* hand-built contract, where guessing a key name would silently read/write
+* the wrong key.
+*/
+function getKeyPath(contract, modelName) {
+	const keyPath = (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.keyPath;
+	if (keyPath === void 0) throw new Error(`Model "${modelName}" has no storage.keyPath in the contract.`);
+	return keyPath;
+}
+/**
+* Extracts a row's primary key as an {@link IDBValidKey} — the scalar value
+* at `row[keyPath]` for a single-field key, or an ordered array of the
+* compound key's member field values (matching the array form IDB itself
+* expects for a compound `keyPath`). The one construction site every
+* key-get/put/delete/update call should route through, so compound-key field
+* order stays consistent everywhere.
+*/
+function extractKeyFromRow(row, keyPath) {
+	if (typeof keyPath === "string") return row[keyPath];
+	return keyPath.map((field) => row[field]);
+}
+/**
+* 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/planner/catalog.ts
+const catalogs = /* @__PURE__ */ new WeakMap();
+/**
+* Build a catalog once per contract identity, store name and model name.
+* Contracts are immutable.
+*
+* Several models can share one store, and each reads the rows differently.
+* Pass the model that owns the request. Omit `modelName` for a store that no
+* app model owns, such as an extension's own store: it has no fields to fill.
+*/
+function buildCatalog(contract, storeName, modelName) {
+	const cacheKey = `${storeName}\0${modelName ?? ""}`;
+	const cached = catalogs.get(contract)?.get(cacheKey);
+	if (cached) return cached;
+	const store = contract.storage.stores[storeName];
+	if (!store) throw new Error(`Store "${storeName}" is not in the contract`);
+	const fields = {};
+	let normalize = (row) => row;
+	if (modelName !== void 0) {
+		const model = domainModelsAtDefaultNamespace(contract.domain)[modelName];
+		if (model === void 0) throw new Error(`Model "${modelName}" is not in the contract`);
+		if (getStoreName(contract, modelName) !== storeName) throw new Error(`Model "${modelName}" is not stored in "${storeName}"`);
+		normalize = absentAsNull(contract, modelName);
+		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: Boolean(field.many) || 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),
+		absentAsNull: normalize
+	});
+	let byStore = catalogs.get(contract);
+	if (!byStore) {
+		byStore = /* @__PURE__ */ new Map();
+		catalogs.set(contract, byStore);
+	}
+	byStore.set(cacheKey, catalog);
+	return catalog;
+}
+/** Freeze a key source and its field order for deterministic access selection. */
+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/decimal-identity.ts
+/** A legacy store or sync metadata set contains several spellings of one Decimal key. */
+var IdbDecimalIdentityConflictError = class extends Error {
+	code = "DECIMAL_IDENTITY_CONFLICT";
+	constructor(modelName) {
+		super(`Several stored keys identify the same Decimal value in model "${modelName}". Resolve the conflicting records before retrying.`);
+		this.name = "IdbDecimalIdentityConflictError";
+	}
+};
+/** Whether a primary key contains a contract-declared Decimal field. */
+function hasDecimalPrimaryKey(contract, modelName) {
+	const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);
+	return hasDecimalFields(catalog, catalog.primaryKey);
+}
+/** Compare scalar or compound primary keys using Decimal codecs and native IDB equality elsewhere. */
+function decimalKeysEqual(contract, modelName, left, right) {
+	const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);
+	const leftParts = typeof catalog.primaryKey.keyPath === "string" ? [left] : left;
+	const rightParts = typeof catalog.primaryKey.keyPath === "string" ? [right] : right;
+	if (!Array.isArray(leftParts) || !Array.isArray(rightParts) || leftParts.length !== catalog.primaryKey.fields.length || rightParts.length !== leftParts.length) return false;
+	return catalog.primaryKey.fields.every((field, i) => valuesEqual(catalog, field, leftParts[i], rightParts[i]));
+}
+/** Keep an existing Decimal primary-key spelling when the supplied value identifies the same row. */
+function preserveDecimalKeySpelling(contract, modelName, record, storedKey) {
+	const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);
+	const parts = typeof catalog.primaryKey.keyPath === "string" ? [storedKey] : storedKey;
+	if (!Array.isArray(parts) || parts.length !== catalog.primaryKey.fields.length) return record;
+	const result = { ...record };
+	catalog.primaryKey.fields.forEach((field, i) => {
+		if (catalog.fields[field]?.codecId === "idb/decimal@1" && result[field] !== void 0 && valuesEqual(catalog, field, result[field], parts[i])) result[field] = parts[i];
+	});
+	return result;
+}
+/** Read the physical key first, then check Decimal aliases without choosing a legacy duplicate. */
+async function resolveDecimalKey(scope, contract, modelName, key, snapshot) {
+	if (!isValidIdbKey(key)) return void 0;
+	const storeName = getStoreName(contract, modelName);
+	const decimal = hasDecimalPrimaryKey(contract, modelName);
+	if (decimal && !decimalKeysEqual(contract, modelName, key, key)) return void 0;
+	if (!snapshot) {
+		const [exact] = await scope.execute({
+			kind: "key-get",
+			storeName,
+			key
+		});
+		if (!decimal) return exact;
+	}
+	const matches = (snapshot ?? await scope.execute({
+		kind: "cursor-scan",
+		storeName
+	})).filter((row) => decimalKeysEqual(contract, modelName, extractKeyFromRow(row, buildCatalog(contract, storeName, modelName).primaryKey.keyPath), key));
+	if (matches.length > 1) throw new IdbDecimalIdentityConflictError(modelName);
+	return matches[0];
+}
+/** Whether this key source needs numeric equality instead of the native string index. */
+function hasDecimalFields(catalog, source) {
+	return source.fields.some((field) => catalog.fields[field]?.codecId === "idb/decimal@1");
+}
+/** Compare one declared scalar without converting Decimal text through Number. */
+function valuesEqual(catalog, field, left, right) {
+	return catalog.fields[field]?.codecId === "idb/decimal@1" ? typeof left === "string" && typeof right === "string" && compareDecimalValues(left, right) === 0 : isValidIdbKey(left) && isValidIdbKey(right) && keyEquals(left, right);
+}
+/** Numeric unique sources only; ordinary native indexes continue to enforce their own constraints. */
+function decimalUniqueSources(catalog) {
+	return [catalog.primaryKey, ...catalog.indexes].filter((source) => source.unique && hasDecimalFields(catalog, source));
+}
+/** Match one index entry, excluding absent/null keys just as IndexedDB does. */
+function sourceCollides(catalog, source, left, right) {
+	if (source.multiEntry && source.fields.length === 1) {
+		const field = source.fields[0];
+		const a = Array.isArray(left[field]) ? left[field] : [left[field]];
+		const b = Array.isArray(right[field]) ? right[field] : [right[field]];
+		return a.some((x) => b.some((y) => valuesEqual(catalog, field, x, y)));
+	}
+	return source.fields.every((field) => valuesEqual(catalog, field, left[field], right[field]));
+}
+/** Check new values against every other physical row inside the write transaction. */
+async function assertUnique(scope, catalog, record, previousKey, kind, modelName, snapshot) {
+	const rows = snapshot ?? await scope.execute({
+		kind: "cursor-scan",
+		storeName: catalog.storeName
+	});
+	const previous = rows.find((row) => previousKey !== void 0 && keyEquals(extractKeyFromRow(row, catalog.primaryKey.keyPath), previousKey));
+	for (const source of decimalUniqueSources(catalog)) {
+		const matches = rows.filter((row) => sourceCollides(catalog, source, row, record));
+		if (matches.length > 1 || previous && rows.filter((row) => sourceCollides(catalog, source, row, previous)).length > 1) throw new IdbDecimalIdentityConflictError(modelName);
+		if (matches.some((row) => previousKey === void 0 || !keyEquals(extractKeyFromRow(row, catalog.primaryKey.keyPath), previousKey))) throw new IdbExecuteError({
+			code: kind === "add" ? "ADD_FAILED" : "PUT_FAILED",
+			planKind: kind,
+			storeName: catalog.storeName,
+			cause: new DOMException("Numerically equal Decimal key already exists", "ConstraintError")
+		}, "Unique constraint failed for a Decimal key");
+	}
+}
+const decimalModelCache = /* @__PURE__ */ new WeakMap();
+/** Cache the contract models whose uniqueness needs more than native string indexes. */
+function decimalModels(contract) {
+	const cached = decimalModelCache.get(contract);
+	if (cached) return cached;
+	const models = /* @__PURE__ */ new Map();
+	for (const modelName of Object.keys(domainModelsAtDefaultNamespace(contract.domain))) {
+		const store = getStoreName(contract, modelName);
+		if (decimalUniqueSources(buildCatalog(contract, store, modelName)).length > 0) models.set(store, modelName);
+	}
+	decimalModelCache.set(contract, models);
+	return models;
+}
+/** Wrap the transaction seam so nested, bulk and raw sync writes share the same identity rules. */
+function withDecimalIdentityScope(scope, contract) {
+	const models = decimalModels(contract);
+	if (models.size === 0) return scope;
+	return {
+		commit: () => scope.commit(),
+		rollback: () => scope.rollback(),
+		async execute(plan) {
+			const modelName = models.get(plan.storeName);
+			if (modelName === void 0) return scope.execute(plan);
+			try {
+				return await executeDecimalWrite(scope, contract, modelName, plan);
+			} catch (error) {
+				scope.rollback();
+				throw error;
+			}
+		}
+	};
+}
+/** Resolve a keyed write or materialize a scan before enforcing its numeric constraints. */
+async function executeDecimalWrite(scope, contract, modelName, plan, snapshot) {
+	const catalog = buildCatalog(contract, plan.storeName, modelName);
+	if (plan.kind === "scan-write") return executeDecimalScanWrite(scope, contract, modelName, plan);
+	if (plan.kind === "delete") {
+		if (!isValidIdbKey(plan.key)) return scope.execute(plan);
+		const row = await resolveDecimalKey(scope, contract, modelName, plan.key, snapshot);
+		return scope.execute({
+			...plan,
+			key: row ? extractKeyFromRow(row, catalog.primaryKey.keyPath) : plan.key
+		});
+	}
+	if (plan.kind !== "add" && plan.kind !== "put" && plan.kind !== "update") return scope.execute(plan);
+	const key = plan.kind === "update" ? plan.key : extractKeyFromRow(plan.record, catalog.primaryKey.keyPath);
+	const previous = plan.kind === "add" ? void 0 : await resolveDecimalKey(scope, contract, modelName, key, snapshot);
+	const previousKey = previous && extractKeyFromRow(previous, catalog.primaryKey.keyPath);
+	const record = preserveDecimalKeySpelling(contract, modelName, plan.kind === "update" ? {
+		...previous,
+		...plan.patch
+	} : plan.record, previousKey);
+	await assertUnique(scope, catalog, record, previousKey, plan.kind, modelName, snapshot);
+	return scope.execute(plan.kind === "update" ? {
+		...plan,
+		key: previousKey ?? plan.key,
+		patch: preserveDecimalKeySpelling(contract, modelName, plan.patch, previousKey)
+	} : {
+		...plan,
+		record
+	});
+}
+/** Materialize preimages once so moving indexed fields cannot revisit a row. */
+async function executeDecimalScanWrite(scope, contract, modelName, plan) {
+	const catalog = buildCatalog(contract, plan.storeName, modelName);
+	const { take, ...scan } = plan;
+	const rows = await scope.execute({
+		...scan,
+		kind: "cursor-scan"
+	});
+	const seen = /* @__PURE__ */ new Set();
+	const matches = rows.filter((row) => {
+		const token = keyToken(extractKeyFromRow(row, catalog.primaryKey.keyPath));
+		if (seen.has(token)) return false;
+		seen.add(token);
+		return true;
+	}).slice(0, take);
+	if (matches.length === 0) return [];
+	const snapshot = !plan.indexName && !plan.range && !plan.filter ? [...rows] : await scope.execute({
+		kind: "cursor-scan",
+		storeName: plan.storeName
+	});
+	const result = [];
+	for (const row of matches) {
+		const key = extractKeyFromRow(row, catalog.primaryKey.keyPath);
+		const written = await executeDecimalWrite(scope, contract, modelName, plan.write === "delete" ? {
+			...plan,
+			kind: "delete",
+			key
+		} : {
+			...plan,
+			kind: "update",
+			key,
+			patch: plan.patch ?? {}
+		}, snapshot);
+		result.push(...written);
+		const index = snapshot.findIndex((stored) => keyEquals(extractKeyFromRow(stored, catalog.primaryKey.keyPath), key));
+		if (index >= 0) snapshot.splice(index, 1, ...plan.write === "delete" ? [] : written);
+		else if (plan.write !== "delete") snapshot.push(...written);
+	}
+	return result;
+}
+/** Decorate only Decimal-key mutations; all other queries retain their existing execution path. */
+function withDecimalIdentityExecutor(contract, executor) {
+	const models = decimalModels(contract);
+	if (models.size === 0) return executor;
+	const inner = executor;
+	/** Only mutations of declared Decimal key sources need a transaction wrapper. */
+	const needsCheck = (plan) => {
+		if (![
+			"add",
+			"put",
+			"update",
+			"delete",
+			"scan-write"
+		].includes(plan.kind)) return false;
+		return models.has(plan.storeName);
+	};
+	/** Keep validation and the write under the caller's transaction and sync interceptor. */
+	const transaction = async (stores, mode) => {
+		if (typeof inner.transaction !== "function") throw new Error("Decimal key mutations require a transaction-capable executor");
+		return withDecimalIdentityScope(await inner.transaction(stores, mode), contract);
+	};
+	return {
+		...typeof inner.transaction === "function" ? { transaction } : {},
+		query(plan) {
+			const body = plan.idbPlan;
+			const ops = body.kind === "batch" ? body.ops : [body];
+			if (!ops.some(needsCheck)) return executor.query(plan);
+			return new AsyncIterableResult((async function* () {
+				const scope = await transaction(body.kind === "batch" ? [...body.storeNames] : [body.storeName], "readwrite");
+				try {
+					const rows = [];
+					for (const op of ops) rows.push(...await scope.execute(op));
+					await scope.commit();
+					for (const row of rows) yield row;
+				} catch (error) {
+					scope.rollback();
+					throw error;
+				}
+			})());
+		}
+	};
+}
+//#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. Decimal fields use exact numeric order; other fields
+* use {@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, fields = {}) {
+	if (orderBy === void 0) return void 0;
+	return (a, b) => {
+		for (const [field, dir] of Object.entries(orderBy)) {
+			const metadata = fields[field];
+			const decimal = metadata?.codecId === "idb/decimal@1" && !metadata.collection;
+			const present = a[field] != null && b[field] != null;
+			const cmp = decimal && present ? compareDecimalValues(a[field], b[field]) : compareFieldValues(a[field], b[field]);
+			if (cmp === 0) continue;
+			return dir === "desc" ? -cmp : cmp;
+		}
+		return 0;
+	};
+}
+//#endregion
+//#region src/core/enum-validation.ts
+const rulesByContract = /* @__PURE__ */ new WeakMap();
+/** Resolve an enum reference against its declared namespace before validating writes. */
+function resolveEnumRule(contract, field) {
+	const ref = field.valueSet;
+	if (ref === void 0 || ref.plane !== "domain" || ref.entityKind !== "enum") return void 0;
+	const contractEnum = contract.domain.namespaces[ref.namespaceId]?.enum?.[ref.entityName];
+	if (contractEnum === void 0) throw new Error(`Enum "${ref.entityName}" referenced by the contract is not declared in its domain.`);
+	return {
+		enumName: ref.entityName,
+		values: new Set(contractEnum.members.map((member) => member.value)),
+		nullable: field.nullable,
+		many: Boolean(field.many),
+		elementNullable: typeof field.many === "object" && field.many.elementNullable === true
+	};
+}
+/** Cache enum rules by contract identity and model to avoid rebuilding them for each write. */
+function getModelEnumRules(contract, modelName) {
+	let byModel = rulesByContract.get(contract);
+	if (byModel === void 0) {
+		byModel = /* @__PURE__ */ new Map();
+		rulesByContract.set(contract, byModel);
+	}
+	const cached = byModel.get(modelName);
+	if (cached !== void 0) return cached;
+	const rules = /* @__PURE__ */ new Map();
+	const fields = domainModelsAtDefaultNamespace(contract.domain)[modelName]?.fields ?? {};
+	for (const [fieldName, field] of Object.entries(fields)) {
+		const rule = resolveEnumRule(contract, field);
+		if (rule !== void 0) rules.set(fieldName, rule);
+	}
+	byModel.set(modelName, rules);
+	return rules;
+}
+function describe(value) {
+	return typeof value === "string" ? JSON.stringify(value) : `${String(value)} (${typeof value})`;
+}
+/** Describe an invalid enum value together with the declared alternatives. */
+function invalidValueError(modelName, fieldName, rule, value) {
+	const expected = [...rule.values].map((v) => JSON.stringify(v)).join(", ");
+	return /* @__PURE__ */ new Error(`Invalid value ${describe(value)} for enum field "${modelName}.${fieldName}". Expected one of enum "${rule.enumName}": ${expected}.`);
+}
+/**
+* Throws if `data` sets an enum field to a value its enum doesn't declare.
+* Fields left `undefined` are not checked. `null` is accepted only on an
+* optional (`Role?`) field; a list (`Role[]`) field must be an array whose
+* every element is a declared value, or `null` when the list allows nullable elements.
+*/
+function assertEnumValues(contract, modelName, data) {
+	const rules = getModelEnumRules(contract, modelName);
+	if (rules.size === 0) return;
+	for (const [fieldName, rule] of rules) {
+		const value = data[fieldName];
+		if (value === void 0) continue;
+		if (value === null) {
+			if (rule.nullable) continue;
+			throw new Error(`Enum field "${modelName}.${fieldName}" is required and cannot be null.`);
+		}
+		if (rule.many) {
+			if (!Array.isArray(value)) throw new Error(`Enum list field "${modelName}.${fieldName}" expects an array of "${rule.enumName}" values, got ${describe(value)}.`);
+			for (const element of value) {
+				if (element === null && rule.elementNullable) continue;
+				if (!rule.values.has(element)) throw invalidValueError(modelName, fieldName, rule, element);
+			}
+			continue;
+		}
+		if (!rule.values.has(value)) throw invalidValueError(modelName, fieldName, rule, value);
+	}
+}
+//#endregion
+//#region src/core/record-validation.ts
+/** A local ORM create or update failed the contract's native record validation. */
+var IdbRecordValidationError = class extends Error {
+	modelName;
+	operation;
+	issues;
+	constructor(modelName, operation, issues) {
+		super(`Invalid ${operation} record for "${modelName}": ${issues.join("; ")}`);
+		this.modelName = modelName;
+		this.operation = operation;
+		this.issues = issues;
+		this.name = "IdbRecordValidationError";
+	}
+};
+/** Validate final write data, after defaults and relation scalar values are resolved. */
+function assertValidRecord(contract, modelName, operation, data) {
+	const keyPath = getKeyPath(contract, modelName);
+	const store = contract.storage.stores[getStoreName(contract, modelName)];
+	const optionalFields = operation === "create" && store?.autoIncrement && typeof keyPath === "string" && !Object.hasOwn(data, keyPath) ? [keyPath] : [];
+	const result = validateRecord(contract, modelName, data, {
+		partial: operation === "update",
+		optionalFields
+	});
+	if (!result.ok) throw new IdbRecordValidationError(modelName, operation, result.issues);
+}
+//#endregion
+//#region src/core/mutation-defaults.ts
+function createMutationDefaultsCache() {
+	return /* @__PURE__ */ new Map();
+}
+/** Generator ids whose value is shared across an entire top-level call. Every other id always regenerates. */
+const CACHEABLE_GENERATOR_IDS = /* @__PURE__ */ new Set(["timestampNow"]);
+/** Resolve one declared default with the same generator IDs as the SQL execution layer. */
+function computeGeneratedValue(spec) {
+	const id = spec.id;
+	switch (id) {
+		case "timestampNow": return /* @__PURE__ */ new Date();
+		case "literal": return spec.params?.["value"];
+		case "uuidv4":
+		case "uuidv7":
+		case "cuid2": return generateId(spec.params !== void 0 ? {
+			id,
+			params: spec.params
+		} : { id });
+		default: throw new Error(`Unknown mutation-default generator id "${String(id)}"`);
+	}
+}
+/** Share query-stable defaults across one mutation while generating fresh IDs for each field. */
+function resolveGeneratedValue(spec, cache) {
+	const id = spec.id;
+	if (!CACHEABLE_GENERATOR_IDS.has(id)) return computeGeneratedValue(spec);
+	const cached = cache.get(id);
+	if (cached !== void 0) return cached;
+	const value = computeGeneratedValue(spec);
+	cache.set(id, value);
+	return value;
+}
+/**
+* Fills in every column with an `onCreate` default that `data` doesn't
+* already set. Returns `data` unchanged (same reference) if there's nothing
+* to apply.
+*/
+function applyCreateDefaults(defaults, storeName, data, cache) {
+	if (!defaults || defaults.length === 0) return data;
+	let result = data;
+	for (const d of defaults) {
+		if (d.ref.entry !== storeName || !d.onCreate) continue;
+		if (result[d.ref.field] !== void 0) continue;
+		if (result === data) result = { ...data };
+		result[d.ref.field] = resolveGeneratedValue(d.onCreate, cache);
+	}
+	return result;
+}
+/**
+* Completes a create record: applies the `onCreate` defaults, then stores
+* `null` for every nullable field the record still lacks. IndexedDB has no
+* column defaults, so this is what keeps stored rows complete while the create
+* input leaves nullable fields optional, as Prisma's does. Call it after any
+* relation values are resolved into `data`, and validate the result.
+*/
+function completeCreateRecord(contract, modelName, data, cache) {
+	const withDefaults = applyCreateDefaults(contract.execution?.mutations.defaults, getStoreName(contract, modelName), data, cache);
+	return absentAsNull(contract, modelName)(withDefaults);
+}
+/**
+* Fills in every column with an `onUpdate` default that `patch` doesn't
+* already set. A patch with no defined values (empty, or every field
+* explicitly `undefined`) is returned unchanged — no write means no default
+* should fire either (matches SQL's "empty update payloads skip onUpdate
+* defaults" rule).
+*/
+function applyUpdateDefaults(defaults, storeName, patch, cache) {
+	if (Object.values(patch).every((v) => v === void 0)) return patch;
+	if (!defaults || defaults.length === 0) return patch;
+	let result = patch;
+	for (const d of defaults) {
+		if (d.ref.entry !== storeName || !d.onUpdate) continue;
+		if (result[d.ref.field] !== void 0) continue;
+		if (result === patch) result = { ...patch };
+		result[d.ref.field] = resolveGeneratedValue(d.onUpdate, cache);
+	}
+	return result;
+}
+//#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/bytes@1"
+]);
+/** Choose the cheapest safe access without opening IndexedDB or probing cardinality. */
+function planQuery(catalog, request) {
+	if (request.where !== void 0) assertValidDecimalFilter(request.where, catalog.fields);
+	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 (catalog.fields[field]?.codecId !== "idb/decimal@1" && sourceOrdersField(selected.source, field, constraints)) 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
+	};
+}
+/** Flatten supported conjunctions and same-field unions while retaining unsupported predicates. */
+function normalize(where) {
+	const result = {
+		atoms: [],
+		residual: 0,
+		excluded: false,
+		empty: false
+	};
+	/** Collect usable atoms and mark filters that require the full-row path. */
+	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);
+}
+/** A compound cursor orders a suffix only within one fixed preceding key. */
+function sourceOrdersField(source, field, constraints) {
+	const position = source.fields.indexOf(field);
+	return position >= 0 && source.fields.slice(0, position).every((name) => constraints.get(name)?.points?.length === 1);
+}
+function singleFieldSource(source, field) {
+	return source.fields.length === 1 && source.fields[0] === field;
+}
+/** Intersect one supported predicate with a field constraint without narrowing unsafe values. */
+function addAtom(constraint, atom, field) {
+	if (field?.codecId === "idb/decimal@1") return;
+	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);
+}
+/** Keep the tighter endpoint when several comparisons constrain the same field. */
+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;
+}
+/** Check a point against both endpoints, including open-bound equality. */
+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;
+}
+/** Discard points outside the bounds and detect ranges that cannot match. */
+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);
+}
+/** Build a safe source range only when its index contains every possible match. */
+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
+	};
+}
+/** Convert scalar endpoints into the matching driver range descriptor. */
+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
+	};
+}
+/** Bound a compound prefix and suffix using IndexedDB key ordering. */
+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
+	};
+}
+/** Find the exclusive upper bound of a UTF-16 prefix, if one exists. */
+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);
+	}
+}
+//#endregion
+//#region src/core/planner/lower.ts
+/**
+* The row filter shared by every lowered read and write. The driver runs it on stored rows, so it
+* reads each row as the contract describes it first: a filter on `null` matches a row that
+* lacks the field.
+*/
+function rowFilter(catalog, request, additionalFilter) {
+	return (stored) => {
+		const row = catalog.absentAsNull(stored);
+		return (request.where === void 0 || evaluateFilter(request.where, row, catalog.fields)) && (additionalFilter === void 0 || additionalFilter(row));
+	};
+}
+/**
+* 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.
+*/
+function lowerRows(catalog, logical, meta, request, additionalFilter) {
+	const filter = request.where === void 0 && additionalFilter === void 0 ? void 0 : rowFilter(catalog, request, additionalFilter);
+	const comparator = logical.direction === void 0 ? buildRowComparator(request.orderBy, catalog.fields) : 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 === void 0 ? {} : { 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 === void 0 ? {} : { filter },
+					take: (request.skip ?? 0) + request.take
+				};
+				if (single && request.take !== void 0) {
+					shapedByDriver = true;
+					return {
+						...access,
+						kind: "cursor-scan",
+						...filter === void 0 ? {} : { 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 === void 0 ? {} : { filter }
+				};
+				return {
+					...access,
+					kind: "get-all"
+				};
+			});
+			idbPlan = single ? ops[0] : {
+				meta,
+				kind: "batch",
+				storeNames: [catalog.storeName],
+				ops
+			};
+			break;
+		}
+	}
+	return {
+		idbPlan,
+		/** Normalize returned rows and apply filtering and shaping not already handled by the driver. */
+		finish(rows) {
+			let result = rows.map(catalog.absentAsNull);
+			if (filter !== void 0) result = result.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;
+		}
+	};
+}
+/**
+* Lower a row count. An `exact` plan counts index entries and loads no rows.
+* The planner emits disjoint ranges on a non-multi-entry source, so each row
+* is counted once. Anything else counts the rows that pass the filter.
+* Pagination and `additionalFilter` always take the row path.
+*/
+function lowerCount(catalog, logical, meta, request, additionalFilter) {
+	const paginated = request.skip !== void 0 || request.take !== void 0;
+	if (!logical.exact || paginated || additionalFilter !== void 0) {
+		const lowered = lowerRows(catalog, logical, meta, request, additionalFilter);
+		return {
+			idbPlan: lowered.idbPlan,
+			finish: (rows) => lowered.finish(rows).length
+		};
+	}
+	return {
+		idbPlan: combine(catalog, meta, accessOps(catalog, meta, logical, (target) => ({
+			...target,
+			kind: "count"
+		}))),
+		finish: (rows) => rows.reduce((total, row) => total + row["count"], 0)
+	};
+}
+/**
+* Lower an existence check. An `exact` plan reads one primary key per range
+* and loads no rows. Anything else stops each range at its first row that
+* passes the filter.
+*/
+function lowerExists(catalog, logical, meta, request, additionalFilter) {
+	if (logical.exact && additionalFilter === void 0) return {
+		idbPlan: combine(catalog, meta, accessOps(catalog, meta, logical, (target) => ({
+			...target,
+			kind: "keys",
+			take: 1
+		}))),
+		finish: (rows) => rows.length > 0
+	};
+	const filter = rowFilter(catalog, request, additionalFilter);
+	return {
+		idbPlan: combine(catalog, meta, accessOps(catalog, meta, logical, (target) => ({
+			...target,
+			kind: "cursor-scan",
+			filter,
+			take: 1
+		}))),
+		finish: (rows) => rows.some(filter)
+	};
+}
+/**
+* Lower writes through the same access paths as reads. If the patch touches
+* the walked key, collect every range first so moved rows cannot enter a
+* later range or change the cursor's position. Multiple ranges with a limit
+* also collect first, because the limit applies to their combined matches.
+*/
+function lowerWrite(catalog, logical, meta, request, additionalFilter) {
+	const { access } = logical;
+	const walkedFields = access.kind === "ranges" ? access.source.fields : catalog.primaryKey.fields;
+	const movesKey = request.write === "put-merged" && walkedFields.some((field) => field in (request.patch ?? {}));
+	const limitedRanges = access.kind === "ranges" && access.ranges.length > 1 && request.take !== void 0;
+	if (movesKey || limitedRanges) return {
+		kind: "collect",
+		rows: lowerRows(catalog, logical, meta, request, additionalFilter)
+	};
+	const filter = rowFilter(catalog, request, additionalFilter);
+	return {
+		kind: "scan",
+		idbPlan: combine(catalog, meta, accessOps(catalog, meta, logical, (target) => ({
+			...target,
+			kind: "scan-write",
+			write: request.write,
+			filter,
+			...request.patch === void 0 ? {} : { patch: request.patch },
+			...request.take === void 0 ? {} : { take: request.take }
+		})))
+	};
+}
+/** One operation per planned range, in ascending key order. */
+function accessOps(catalog, meta, logical, build) {
+	const { access } = logical;
+	const base = {
+		meta,
+		storeName: catalog.storeName
+	};
+	switch (access.kind) {
+		case "empty": return [];
+		case "full": return [build(base)];
+		case "ranges": {
+			const { indexName } = access.source;
+			return access.ranges.map((range) => build({
+				...base,
+				...indexName === void 0 ? {} : { indexName },
+				...range === void 0 ? {} : { range }
+			}));
+		}
+	}
+}
+function combine(catalog, meta, ops) {
+	return ops.length === 1 ? ops[0] : {
+		meta,
+		kind: "batch",
+		storeNames: [catalog.storeName],
+		ops
+	};
+}
+//#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
+/** Build the relation descriptors consumed by the nested-write executor. */
+function createRelationMutator() {
+	return {
+		/** Normalize a single nested record or a list into one create descriptor. */
+		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
+/** Plan metadata for the raw plans the mutation executor issues itself, outside any accessor's grouping key. */
+function makePlanMeta(contract) {
+	return {
+		target: "idb",
+		storageHash: contract.storage.storageHash,
+		lane: "idb-mutation-executor",
+		annotations: { groupingKey: "nested" }
+	};
+}
+const relationDefsCache = /* @__PURE__ */ new WeakMap();
+/** Cache reference-relation metadata by contract identity and model. */
+function getRelationDefinitions(contract, modelName) {
+	let perContract = relationDefsCache.get(contract);
+	if (!perContract) {
+		perContract = /* @__PURE__ */ new Map();
+		relationDefsCache.set(contract, perContract);
+	}
+	const cached = perContract.get(modelName);
+	if (cached) return cached;
+	const model = domainModelsAtDefaultNamespace(contract.domain)[modelName];
+	if (!model) {
+		perContract.set(modelName, []);
+		return [];
+	}
+	const defs = [];
+	for (const [relationName, rawRelation] of Object.entries(model.relations)) {
+		if (!rawRelation || typeof rawRelation !== "object" || !("on" in rawRelation)) continue;
+		const relation = rawRelation;
+		const relatedModelName = relation.to.model;
+		const relatedStoreName = getStoreName(contract, relatedModelName);
+		defs.push({
+			relationName,
+			relatedModelName,
+			relatedStoreName,
+			cardinality: relation.cardinality,
+			localFields: relation.on.localFields,
+			targetFields: relation.on.targetFields
+		});
+	}
+	perContract.set(modelName, defs);
+	return defs;
+}
+/**
+* Returns true if `data` contains at least one field that is both a known
+* relation name for `modelName` and a function (a mutation callback).
+*/
+function hasNestedMutationCallbacks(contract, modelName, data) {
+	const relationNames = new Set(getRelationDefinitions(contract, modelName).map((r) => r.relationName));
+	for (const [fieldName, value] of Object.entries(data)) if (relationNames.has(fieldName) && isRelationMutationCallback(value)) return true;
+	return false;
+}
+/**
+* Guards that the executor supports multi-store transactions.
+* Throws a clear error if `transaction()` is not available — the user must
+* use IdbRuntime (createIdbRuntime / createAutoMigratingIdbClient) rather than
+* a plain IdbQueryExecutor stub.
+*/
+function requireTransactionExecutor(executor) {
+	if (typeof executor.transaction !== "function") throw new Error("This operation requires an executor with transaction support (nested relation writes, FK-validated create/update, and referential-action delete all need it). Use IdbRuntime (createIdbRuntime or createAutoMigratingIdbClient) instead of a plain IdbQueryExecutor.");
+	return executor;
+}
+/** Create a parent and its nested related rows in one transaction. */
+async function executeNestedCreateMutation(options) {
+	const { executor, contract, modelName, data } = options;
+	const record = data;
+	const storeNames = collectStoreNames(contract, modelName, record, "create");
+	const defaultsCache = createMutationDefaultsCache();
+	return withMutationScope(executor, storeNames, (scope) => createGraph(scope, contract, modelName, record, defaultsCache));
+}
+/** Update the first filtered parent and its nested relations in one transaction. */
+async function executeNestedUpdateMutation(options) {
+	const { executor, contract, modelName, filters, data } = options;
+	const record = data;
+	const storeNames = collectStoreNames(contract, modelName, record, "update");
+	const defaultsCache = createMutationDefaultsCache();
+	return withMutationScope(executor, storeNames, (scope) => updateFirstGraph(scope, contract, modelName, filters, record, defaultsCache));
+}
+/**
+* Every store a nested write may touch: the model's own store, each related
+* store a relation callback writes to, and the parent stores that foreign-key
+* checks read, for the model and for each related model. An update also
+* declares the stores its `onUpdate` referential actions may touch.
+*
+* Parent stores are declared for every foreign key, not only the ones `data`
+* sets, because a nested write can set foreign keys through `connect()` or
+* through a default.
+*/
+function collectStoreNames(contract, modelName, data, kind) {
+	const stores = /* @__PURE__ */ new Set([getStoreName(contract, modelName), ...fkParentStoreNames(contract, modelName)]);
+	const scalarData = {};
+	const relationNames = /* @__PURE__ */ new Set();
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		relationNames.add(def.relationName);
+		if (def.relationName in data && isRelationMutationCallback(data[def.relationName])) {
+			stores.add(def.relatedStoreName);
+			for (const store of fkParentStoreNames(contract, def.relatedModelName)) stores.add(store);
+		}
+	}
+	if (kind === "update") {
+		for (const [field, value] of Object.entries(data)) if (!relationNames.has(field)) scalarData[field] = value;
+		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, getStoreName(contract, modelName), scalarData, createMutationDefaultsCache());
+		for (const store of collectOnUpdateEnforcementStoreNames(contract, modelName, patch).storeNames) stores.add(store);
+	}
+	return [...stores];
+}
+/** The stores of every parent `modelName` has a foreign key to. */
+function fkParentStoreNames(contract, modelName) {
+	return getRelationDefinitions(contract, modelName).filter((def) => def.cardinality === "N:1").map((def) => def.relatedStoreName);
+}
+/** Resolve parent-owned references before inserting the parent, then write its children. */
+async function createGraph(scope, contract, modelName, input, defaultsCache) {
+	const parsed = parseMutationInput(contract, modelName, input);
+	const { parentOwned, childOwned } = partitionByOwnership(parsed.relationMutations);
+	const scalarData = { ...parsed.scalarData };
+	for (const item of parentOwned) {
+		if (item.mutation.kind === "disconnect") throw new Error("disconnect() is only supported in update() nested mutations");
+		await applyParentOwnedMutation(scope, contract, scalarData, item.relation, item.mutation, defaultsCache);
+	}
+	const parentRow = await insertSingleRow(scope, contract, modelName, scalarData, defaultsCache);
+	for (const item of childOwned) {
+		if (item.mutation.kind === "disconnect") throw new Error("disconnect() is only supported in update() nested mutations");
+		await applyChildOwnedMutation(scope, contract, modelName, parentRow, item.relation, item.mutation, defaultsCache);
+	}
+	return parentRow;
+}
+/** Read the parent before resolving relation mutations and validating its scalar patch. */
+async function updateFirstGraph(scope, contract, modelName, filters, input, defaultsCache) {
+	const existingRow = await findFirstByFilters(scope, contract, modelName, filters);
+	if (!existingRow) return null;
+	const parsed = parseMutationInput(contract, modelName, input);
+	const { parentOwned, childOwned } = partitionByOwnership(parsed.relationMutations);
+	const scalarData = { ...parsed.scalarData };
+	for (const item of parentOwned) await applyParentOwnedMutation(scope, contract, scalarData, item.relation, item.mutation, defaultsCache);
+	let parentRow = existingRow;
+	if (Object.keys(scalarData).length > 0) {
+		const storeName = getStoreName(contract, modelName);
+		const key = extractKeyFromRow(existingRow, getKeyPath(contract, modelName));
+		const meta = makePlanMeta(contract);
+		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, scalarData, defaultsCache);
+		assertEnumValues(contract, modelName, patch);
+		assertValidRecord(contract, modelName, "update", patch);
+		await validateScalarFks(scope, contract, modelName, patch, existingRow);
+		await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, existingRow, patch);
+		const updated = (await scope.execute({
+			meta,
+			kind: "update",
+			storeName,
+			key,
+			patch
+		}))[0];
+		if (updated) parentRow = absentAsNull(contract, modelName)(updated);
+	}
+	for (const item of childOwned) await applyChildOwnedMutation(scope, contract, modelName, parentRow, item.relation, item.mutation, defaultsCache);
+	return parentRow;
+}
+/** Separate scalar values from validated relation callback results. */
+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
+	};
+}
+/** Separate relations whose foreign keys belong to the parent from those owned by children. */
+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
+	};
+}
+/** Resolve a to-one mutation into scalar foreign-key values on the parent. */
+async function applyParentOwnedMutation(scope, contract, scalarData, relation, mutation, defaultsCache) {
+	if (mutation.kind === "disconnect") {
+		for (const localField of relation.localFields) scalarData[localField] = null;
+		return;
+	}
+	if (mutation.kind === "create") {
+		const row = mutation.data[0];
+		if (!row) throw new Error(`create() nested mutation for relation "${relation.relationName}" requires data`);
+		copyRelatedValuesToParent(relation, scalarData, await insertSingleRow(scope, contract, relation.relatedModelName, row, defaultsCache));
+		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);
+}
+/** Copy each referenced value into the matching local foreign-key field. */
+function copyRelatedValuesToParent(relation, scalarData, relatedRow) {
+	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];
+	}
+}
+/** Create, connect, or disconnect children using the persisted parent join values. */
+async function applyChildOwnedMutation(scope, contract, parentModelName, parentRow, relation, mutation, defaultsCache) {
+	const parentValues = readParentColumnValues(parentModelName, relation, parentRow);
+	if (mutation.kind === "create") {
+		for (const childInput of mutation.data) {
+			const payload = { ...childInput };
+			for (const [childField, parentValue] of parentValues.entries()) payload[childField] = parentValue;
+			await insertSingleRow(scope, contract, relation.relatedModelName, payload, defaultsCache);
+		}
+		return;
+	}
+	if (mutation.kind === "connect") {
+		for (const criterion of mutation.criteria) {
+			const setValues = {};
+			for (const [childField, parentValue] of parentValues.entries()) setValues[childField] = parentValue;
+			const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, relation.relatedStoreName, setValues, defaultsCache);
+			const where = shorthandToFilterExpr(criterion);
+			await writeMutationRows(scope, contract, relation.relatedModelName, {
+				write: "put-merged",
+				patch,
+				...where === void 0 ? {} : { where }
+			});
+		}
+		return;
+	}
+	const setValues = {};
+	for (const childField of parentValues.keys()) setValues[childField] = null;
+	if (!mutation.criteria || mutation.criteria.length === 0) {
+		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, relation.relatedStoreName, setValues, defaultsCache);
+		const parentJoinWhere = buildParentJoinWhere(parentValues);
+		await writeMutationRows(scope, contract, relation.relatedModelName, {
+			write: "put-merged",
+			patch,
+			where: parentJoinWhere
+		});
+		return;
+	}
+	for (const criterion of mutation.criteria) {
+		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, relation.relatedStoreName, setValues, defaultsCache);
+		const criterionWhere = shorthandToFilterExpr(criterion);
+		const parentJoinWhere = buildParentJoinWhere(parentValues);
+		const where = criterionWhere === void 0 ? parentJoinWhere : andExpr([parentJoinWhere, criterionWhere]);
+		await writeMutationRows(scope, contract, relation.relatedModelName, {
+			write: "put-merged",
+			patch,
+			where
+		});
+	}
+}
+/** Resolve parent join values before writing children; missing values cannot form a relation. */
+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;
+}
+/** Complete and validate a nested record, then insert it with foreign-key checks. */
+async function insertSingleRow(scope, contract, modelName, data, defaultsCache) {
+	assertNoNestedCallbacks(modelName, data);
+	const storeName = getStoreName(contract, modelName);
+	const meta = makePlanMeta(contract);
+	const record = completeCreateRecord(contract, modelName, data, defaultsCache);
+	assertEnumValues(contract, modelName, record);
+	assertValidRecord(contract, modelName, "create", record);
+	await validateScalarFks(scope, contract, modelName, record);
+	return (await scope.execute({
+		meta,
+		kind: "add",
+		storeName,
+		record
+	}))[0] ?? record;
+}
+/**
+* Recursive nesting (a relation callback inside an already-nested create) is
+* not supported. 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.
+*/
+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.`);
+}
+/** Require a non-empty connect criterion and return its first matching row. */
+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`);
+	return (await readMutationRows(scope, contract, modelName, expr, 1))[0] ?? null;
+}
+/** Find the first parent selected by the nested-update filters. */
+async function findFirstByFilters(scope, contract, modelName, filters) {
+	if (filters.length === 0) return null;
+	return (await readMutationRows(scope, contract, modelName, andExpr(filters), 1))[0] ?? null;
+}
+/** Execute lowered atomic operations without leaving the transaction's microtask chain. */
+async function executeMutationPlan(scope, plan) {
+	const plans = plan.kind === "batch" ? plan.ops : [plan];
+	const rows = [];
+	for (const op of plans) rows.push(...await scope.execute(op));
+	return rows;
+}
+/** Read mutation preimages through the planner, then reapply the original filter. */
+async function readMutationRows(scope, contract, modelName, where, take) {
+	const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);
+	const request = {
+		...where === void 0 ? {} : { where },
+		...take === void 0 ? {} : { take }
+	};
+	const lowered = lowerRows(catalog, planQuery(catalog, request), makePlanMeta(contract), request);
+	return lowered.finish(await executeMutationPlan(scope, lowered.idbPlan));
+}
+/** Write planned matches, collecting preimages first when changing the walked index key. */
+async function writeMutationRows(scope, contract, modelName, request) {
+	if (request.write !== "delete") assertValidRecord(contract, modelName, "update", request.patch ?? {});
+	const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);
+	const meta = makePlanMeta(contract);
+	const lowered = lowerWrite(catalog, planQuery(catalog, request), meta, request);
+	if (lowered.kind === "scan") return executeMutationPlan(scope, lowered.idbPlan);
+	const oldRows = lowered.rows.finish(await executeMutationPlan(scope, lowered.rows.idbPlan));
+	const results = [];
+	for (const row of oldRows) {
+		const key = extractKeyFromRow(row, catalog.primaryKey.keyPath);
+		const rows = await scope.execute({
+			meta,
+			storeName: catalog.storeName,
+			...request.write === "delete" ? {
+				kind: "delete",
+				key
+			} : {
+				kind: "update",
+				key,
+				patch: request.patch ?? {}
+			}
+		});
+		results.push(...rows);
+	}
+	return results;
+}
+function buildParentJoinWhere(parentValues) {
+	return andExpr([...parentValues].map(([field, value]) => fieldFilter(field, "eq", value)));
+}
+/** Read an explicitly declared referential action from model storage metadata. */
+function getStoredAction(contract, modelName, relationName, kind) {
+	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.relations?.[relationName]?.[kind];
+}
+function sameFields(a, b) {
+	return a.length === b.length && a.every((field, index) => field === b[index]);
+}
+/**
+* Resolves the referential action for a child-enforcement relation: prefers
+* the action stored directly on this side, falls back to the same action
+* stored on the inverse (FK-owning) side of the relation, and finally to
+* `defaultAction` when neither side declares one.
+*
+* Both branches are live, for different authoring paths. PSL only ever
+* stores the action on the `N:1` (FK-owning) side — enforcement always walks
+* from the parent (`1:N`/non-owning-`1:1`) side, which PSL leaves bare, so
+* the fallback is what actually finds it. TS-DSL relation entries are
+* self-contained (no PSL-style pairing requirement) and typically declare
+* the action directly on the side this function is called for, so the direct
+* check is what fires there — see `contract-builder.ts`'s
+* `validateNoConflictingRelationActions`, which rejects declaring the same
+* action kind on both sides so this fallback never has to arbitrate a real
+* conflict.
+*/
+function getReferentialActionForRelation(contract, modelName, def, kind) {
+	return enforcedAction(findDeclaredAction(contract, modelName, def, kind));
+}
+/** Find an action on the enforcement side or on its matching inverse relation. */
+function findDeclaredAction(contract, modelName, def, kind) {
+	const direct = getStoredAction(contract, modelName, def.relationName, kind);
+	if (direct !== void 0) return direct;
+	for (const inverse of getRelationDefinitions(contract, def.relatedModelName)) {
+		if (inverse.relatedModelName !== modelName) continue;
+		if (!sameFields(inverse.localFields, def.targetFields)) continue;
+		if (!sameFields(inverse.targetFields, def.localFields)) continue;
+		const inverseAction = getStoredAction(contract, def.relatedModelName, inverse.relationName, kind);
+		if (inverseAction !== void 0) return inverseAction;
+	}
+}
+/**
+* Applies the default and resolves `noAction`, matching what Postgres does
+* with the same schema, so a synced app behaves the same on both sides:
+*
+* - An undeclared action defaults to `restrict`, for `onDelete` and
+*   `onUpdate` alike. Prisma 8 emits no `ON DELETE`/`ON UPDATE` clause for an
+*   undeclared action, and the database default is `NO ACTION`.
+* - `noAction` behaves like `restrict`. In SQL, `NO ACTION` also rejects the
+*   change; it only defers the check to the end of the statement, which makes
+*   no difference here.
+*/
+function enforcedAction(declared) {
+	return declared === void 0 || declared === "noAction" ? "restrict" : declared;
+}
+/** Identify relations that need child checks when this model changes. */
+function isChildEnforcementRelation(contract, modelName, def) {
+	if (def.cardinality === "1:N") return true;
+	if (def.cardinality === "1:1") {
+		const keyPath = getKeyPath(contract, modelName);
+		return sameFields(def.localFields, keyPathFields(keyPath));
+	}
+	return false;
+}
+/**
+* `true` if any child row matches the relation against `parentRow`'s values —
+* the existence check behind `restrict`. A null value references no child.
+*/
+async function childExists(scope, contract, meta, def, parentRow) {
+	const values = def.localFields.map((field) => parentRow[field]);
+	if (values.some((value) => value === null || value === void 0)) return false;
+	return rowExists(scope, contract, meta, def.relatedModelName, def.targetFields, values);
+}
+/**
+* Does `modelName` have a row whose `fields` equal `values`, pairwise?
+* Compares values the way IndexedDB compares keys. `additionalFilter` narrows
+* the match in memory; it makes the check read rows instead of keys.
+*/
+async function rowExists(scope, contract, meta, modelName, fields, values, additionalFilter) {
+	const where = andExpr(fields.map((field, i) => fieldFilter(field, "eq", values[i])));
+	const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);
+	const lowered = lowerExists(catalog, planQuery(catalog, { where }), meta, { where }, additionalFilter);
+	return lowered.finish(await executeMutationPlan(scope, lowered.idbPlan));
+}
+/**
+* Builds a filter matching a relation's children against one specific parent
+* row's values. Shared by `onDelete` cascade (`applyReferentialActionsForRow`)
+* and `onUpdate` cascade (`applyReferentialActionsForRowOnUpdate`).
+*/
+function buildChildWhereFromRow(def, row) {
+	return andExpr(def.targetFields.map((field, i) => fieldFilter(field, "eq", row[def.localFields[i]])));
+}
+/** Reads a field's literal `@default(...)` value from `IdbModelStorage.fieldDefaults`, if declared. */
+function getFieldDefault(contract, modelName, fieldName) {
+	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.fieldDefaults?.[fieldName];
+}
+/**
+* Builds the patch for a `setDefault` referential action: each of the
+* relation's `targetFields` (the child's FK fields) reset to its own
+* declared literal default — not the parent's. Throws when any target field
+* has no declared default; `setDefault` is only meaningful when every FK
+* field it resets has somewhere to reset to.
+*/
+function buildSetDefaultPatch(contract, def) {
+	const patch = {};
+	for (const targetField of def.targetFields) {
+		const value = getFieldDefault(contract, def.relatedModelName, targetField);
+		if (value === void 0) throw new Error(`setDefault referential action on relation '${def.relationName}' requires field '${def.relatedModelName}.${targetField}' to declare a literal @default(...) value — no default is registered for that field.`);
+		patch[targetField] = value;
+	}
+	return patch;
+}
+/**
+* Validates that a `setDefault` patch actually references a real row before
+* it's written — without this, `setDefault` would silently reintroduce the
+* exact dangling-FK problem the rest of this file exists to prevent. A real
+* SQL database only makes `SET DEFAULT` safe because its FK constraint
+* re-checks the new value transactionally at write time; IDB has no such
+* engine to delegate to, so this check is IDB's equivalent.
+*
+* Checks against `modelName`'s own store (the parent being deleted/updated)
+* using `def.localFields` — the relation's own semantics ("child.targetField
+* references parent.localField") mean that's exactly what a default value
+* written to the child's FK field must match. That store is always already
+* part of the transaction (it's the model literally being written), so no
+* store-list changes are needed to call this.
+*
+* A compound relation is checked as one tuple: a single parent row must
+* match every field's default.
+*
+* `excludeKey`, when given, excludes the parent row currently being
+* deleted/updated from the existence scan. That row is still physically
+* present in the store at this point (its own write/delete hasn't happened
+* yet — this check runs first, before the enforcement loop's caller applies
+* it), so without the exclusion, a default value equal to that row's *old*
+* `localField` value would false-positive: the scan would find the row about
+* to disappear (or change away from that value) and wrongly conclude the
+* default references a real row, when after the transaction nothing will.
+*/
+async function validateSetDefaultPatch(scope, contract, modelName, def, patch, excludeKey) {
+	const values = def.targetFields.map((f) => patch[f]);
+	if (values.some((v) => v === null || v === void 0)) return;
+	if (!await parentExists(scope, contract, makePlanMeta(contract), modelName, def.localFields, values, excludeKey)) throw new Error(`setDefault referential action on relation '${def.relationName}' would set ${def.relatedModelName} to ${describeTuple(def.targetFields, values)}, but no ${modelName} with ${describeTuple(def.localFields, values)} exists — the declared default does not reference a real row.`);
+}
+/**
+* Collects every store an `onUpdate`-enforced write to `modelName` might
+* touch: the model's own store, plus the related store of any 1:N/1:1-
+* parent-side relation whose `localFields` appear in the raw patch —
+* pessimistic (checks field *presence*, not whether the resolved value will
+* actually change, since the current row isn't read yet when this runs).
+* Once a `cascade` edge is entered, the walk continues transitively (mirrors
+* `collectDeleteStoreNames`'s cascade-only recursion), since a propagated
+* value change may itself need to cascade further.
+*
+* Returns `enforces: false` when no `onUpdate` enforcement can apply to this
+* write — callers use that to keep the existing fast blind-write path
+* instead of paying for a read-before-write. This is tracked as an explicit
+* flag rather than inferred from `storeNames.length > 1`: for a
+* self-referential relation, `def.relatedStoreName` equals `modelName`'s own
+* store (already the seed of the `Set`), so the store count alone can't tell
+* "no enforcement" apart from "enforces, but only against this same store".
+*/
+function collectOnUpdateEnforcementStoreNames(contract, modelName, data) {
+	const stores = /* @__PURE__ */ new Set([getStoreName(contract, modelName)]);
+	const visitedModels = /* @__PURE__ */ new Set([modelName]);
+	let enforces = false;
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (!isChildEnforcementRelation(contract, modelName, def)) continue;
+		if (!def.localFields.some((f) => f in data)) continue;
+		const action = getReferentialActionForRelation(contract, modelName, def, "onUpdate");
+		enforces = true;
+		stores.add(def.relatedStoreName);
+		if (action === "cascade") addOnUpdateCascadeStores(contract, def.relatedModelName, stores, visitedModels);
+	}
+	return {
+		storeNames: [...stores],
+		enforces
+	};
+}
+/**
+* Enforces every `onUpdate` action declared on `modelName`'s child relations
+* against one specific `oldRow` about to be patched with `patch`. Only
+* relations whose `localFields` are both present in `patch` and differ from
+* `oldRow`'s current value are enforced — a patch that sets a field to its
+* existing value, or never touches a locally-referenced field, is a no-op
+* here. Children are matched against `oldRow`'s pre-change values.
+*
+* `cascade` propagates the new value(s) onto the matched children's FK
+* fields and recurses into each child's own `onUpdate` relations before
+* writing (the propagated change may itself need to cascade further) —
+* mirrors `applyReferentialActionsForRow`'s recursive shape, including the
+* `visited` row-level cycle guard (see that function's doc comment for the
+* fresh-per-top-level-row / shared-across-one-row's-descent contract).
+* `setNull`/`setDefault` are leaf actions: the child's FK field changes but
+* its own key doesn't, so nothing below it needs re-enforcement.
+*
+* Compound relations use values from the same `oldRow`/`patch`, so every
+* child is matched against the full pre-change tuple.
+*/
+async function applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch, visited = /* @__PURE__ */ new Set()) {
+	const keyPath = getKeyPath(contract, modelName);
+	patch = preserveDecimalKeySpelling(contract, modelName, patch, extractKeyFromRow(oldRow, keyPath));
+	const rowKey = `${getStoreName(contract, modelName)}::${keyToken$1(extractKeyFromRow(oldRow, keyPath))}`;
+	if (visited.has(rowKey)) return;
+	visited.add(rowKey);
+	const meta = makePlanMeta(contract);
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (!isChildEnforcementRelation(contract, modelName, def)) continue;
+		const changedFields = def.localFields.filter((f) => f in patch && !fieldValuesEqual(patch[f], oldRow[f]));
+		if (changedFields.length === 0) continue;
+		const action = getReferentialActionForRelation(contract, modelName, def, "onUpdate");
+		const childWhere = buildChildWhereFromRow(def, oldRow);
+		if (action === "restrict") {
+			if (await childExists(scope, contract, meta, def, oldRow)) throw new Error(`Cannot update ${modelName} '${keyToken$1(extractKeyFromRow(oldRow, keyPath))}': changing field(s) ${changedFields.join(", ")} would orphan child records on relation '${def.relationName}'. Update or remove those children first, or declare onUpdate: Cascade, SetNull or SetDefault on the relation.`);
+			continue;
+		}
+		if (action === "cascade") {
+			const childPatch = {};
+			for (let i = 0; i < def.localFields.length; i++) {
+				const lf = def.localFields[i];
+				const tf = def.targetFields[i];
+				if (changedFields.includes(lf)) childPatch[tf] = patch[lf];
+			}
+			const children = await readMutationRows(scope, contract, def.relatedModelName, childWhere);
+			for (const child of children) await applyReferentialActionsForRowOnUpdate(scope, contract, def.relatedModelName, child, childPatch, visited);
+			await writeMutationRows(scope, contract, def.relatedModelName, {
+				write: "put-merged",
+				patch: childPatch,
+				where: childWhere
+			});
+			continue;
+		}
+		if (action === "setNull") {
+			const childPatch = {};
+			for (const targetField of def.targetFields) childPatch[targetField] = null;
+			await writeMutationRows(scope, contract, def.relatedModelName, {
+				write: "put-merged",
+				patch: childPatch,
+				where: childWhere
+			});
+			continue;
+		}
+		if (action === "setDefault") {
+			const childPatch = buildSetDefaultPatch(contract, def);
+			await validateSetDefaultPatch(scope, contract, modelName, def, childPatch, extractKeyFromRow(oldRow, keyPath));
+			await writeMutationRows(scope, contract, def.relatedModelName, {
+				write: "put-merged",
+				patch: childPatch,
+				where: childWhere
+			});
+			continue;
+		}
+	}
+}
+/**
+* Returns true if `data` contains at least one non-null value for a localField
+* of a N:1 relation — indicating scalar FK fields that need existence validation.
+*/
+function hasScalarFkFields(contract, modelName, data) {
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (def.cardinality !== "N:1") continue;
+		for (const localField of def.localFields) if (localField in data && data[localField] !== null && data[localField] !== void 0) return true;
+	}
+	return false;
+}
+/** Include parent stores for the non-null foreign keys supplied by this write. */
+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];
+}
+/**
+* Checks that every foreign key `data` sets points at an existing parent row,
+* inside the write's transaction.
+*
+* A compound foreign key is checked as one tuple: a single parent row must
+* match every field. Checking the fields one at a time could pass with each
+* value taken from a different parent. When `data` sets only some fields of a
+* compound key, the rest come from `existingRow`, the row being updated.
+* Callers must pass it in that case; see {@link fkCheckNeedsExistingRow}.
+*
+* A key with any `null` field isn't checked, like SQL's default `MATCH SIMPLE`.
+*/
+async function validateScalarFks(scope, contract, modelName, data, existingRow) {
+	const meta = makePlanMeta(contract);
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (def.cardinality !== "N:1") continue;
+		if (!def.localFields.some((f) => f in data)) continue;
+		const values = def.localFields.map((f) => f in data ? data[f] : existingRow?.[f]);
+		if (values.some((v) => v === null || v === void 0)) continue;
+		if (!await parentExists(scope, contract, meta, def.relatedModelName, def.targetFields, values)) throw new Error(`FK violation on relation '${def.relationName}': no ${def.relatedModelName} with ${describeTuple(def.targetFields, values)}`);
+	}
+}
+/**
+* `true` when `data` sets some, but not all, fields of a compound foreign
+* key. Checking it then needs the rest of the key from the row being
+* updated, so the update has to read each row before writing it.
+*/
+function fkCheckNeedsExistingRow(contract, modelName, data) {
+	return getRelationDefinitions(contract, modelName).some((def) => {
+		if (def.cardinality !== "N:1") return false;
+		const set = def.localFields.filter((f) => f in data).length;
+		return set > 0 && set < def.localFields.length;
+	});
+}
+/**
+* Does `parentModel` have a row whose `fields` equal `values`, pairwise?
+*
+* `excludeKey` leaves out one parent row, for checks that run while that row
+* is being deleted or changed.
+*/
+async function parentExists(scope, contract, meta, parentModel, fields, values, excludeKey) {
+	const keyPath = getKeyPath(contract, parentModel);
+	return rowExists(scope, contract, meta, parentModel, fields, values, excludeKey === void 0 ? void 0 : (row) => !keyEquals$1(extractKeyFromRow(row, keyPath), excludeKey));
+}
+/** `id='u1'`, or `orgId='a', id='u1'` for a compound key. */
+function describeTuple(fields, values) {
+	return fields.map((f, i) => `${f}='${String(values[i])}'`).join(", ");
+}
+/** Create one completed record and check its foreign keys in the same transaction. */
+async function executeScalarCreateWithFkValidation(options) {
+	const { executor, contract, modelName, data } = options;
+	const defaultsCache = createMutationDefaultsCache();
+	const record = completeCreateRecord(contract, modelName, data, defaultsCache);
+	return withMutationScope(executor, collectScalarFkStoreNames(contract, modelName, record), (scope) => insertSingleRow(scope, contract, modelName, record, defaultsCache));
+}
+/**
+* `createAll()` for rows that set foreign keys: checks every row's foreign
+* keys and inserts it, all in one transaction, so one bad row writes nothing.
+* The batch shares one defaults cache, like the plain `createAll()` path.
+*/
+async function executeScalarCreateAllWithFkValidation(options) {
+	const { executor, contract, modelName, data } = options;
+	const defaultsCache = createMutationDefaultsCache();
+	const records = data.map((row) => completeCreateRecord(contract, modelName, row, defaultsCache));
+	return withMutationScope(executor, [...new Set(records.flatMap((row) => collectScalarFkStoreNames(contract, modelName, row)))], async (scope) => {
+		const inserted = [];
+		for (const record of records) inserted.push(await insertSingleRow(scope, contract, modelName, record, defaultsCache));
+		return inserted;
+	});
+}
+/**
+* Adds the stores an `onUpdate` cascade reaches from `modelName`: every child
+* relation's store, walking further through `cascade` edges only.
+*/
+function addOnUpdateCascadeStores(contract, modelName, stores, visitedModels) {
+	if (visitedModels.has(modelName)) return;
+	visitedModels.add(modelName);
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (!isChildEnforcementRelation(contract, modelName, def)) continue;
+		stores.add(def.relatedStoreName);
+		if (getReferentialActionForRelation(contract, modelName, def, "onUpdate") === "cascade") addOnUpdateCascadeStores(contract, def.relatedModelName, stores, visitedModels);
+	}
+}
+/**
+* Every store an `onUpdate` enforcement on `modelName` could touch, whichever
+* fields the write sets. Use it to open a transaction before the write's
+* fields are known.
+*/
+function collectOnUpdateClosureStoreNames(contract, modelName) {
+	const stores = /* @__PURE__ */ new Set([getStoreName(contract, modelName)]);
+	addOnUpdateCascadeStores(contract, modelName, stores, /* @__PURE__ */ new Set());
+	return [...stores];
+}
+/**
+* Combines FK-existence store scope (this model's own N:1 relations) with
+* `onUpdate` enforcement store scope (this model's child relations) for a
+* single write. Returns the union alongside whether `onUpdate` enforcement
+* actually applies, including self-relations that touch only this model's
+* own store. Callers use that flag to choose between the existing
+* fast blind-write path and the read-before-write enforcement path.
+*/
+function collectUpdateStoreNames(contract, modelName, data) {
+	const fkStoreNames = collectScalarFkStoreNames(contract, modelName, data);
+	const { storeNames: onUpdateStoreNames, enforces } = collectOnUpdateEnforcementStoreNames(contract, modelName, data);
+	return {
+		storeNames: [.../* @__PURE__ */ new Set([...fkStoreNames, ...onUpdateStoreNames])],
+		enforcesOnUpdate: enforces
+	};
+}
+/** Updates the first matching row with FK validation and referential actions. */
+async function executeScalarUpdateWithFkValidation(options) {
+	return (await executeScalarUpdates(options, 1))[0] ?? null;
+}
+/**
+* Bulk counterpart to {@link executeScalarUpdateWithFkValidation}: same FK
+* validation and `onUpdate` enforcement, but applies the patch to every row
+* the filter matches (no `take: 1`) and returns all of them.
+*
+* The transaction scope lets the sync interceptor observe the affected rows
+* and write one outbox event per row in the same transaction. A bulk write's
+* affected keys are only known after it runs, so tracking cannot happen by
+* extending the plan before execution.
+*/
+async function executeBulkUpdateWithFkValidation(options) {
+	return executeScalarUpdates(options);
+}
+/** Shares validation and atomic writes; only single-row updates limit the scan. */
+async function executeScalarUpdates(options, take) {
+	const { executor, contract, modelName, filters, data } = options;
+	const storeName = getStoreName(contract, modelName);
+	const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, data, createMutationDefaultsCache());
+	assertEnumValues(contract, modelName, patch);
+	assertValidRecord(contract, modelName, "update", patch);
+	const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, patch);
+	const needsRowForFks = fkCheckNeedsExistingRow(contract, modelName, patch);
+	return (await withMutationScope(executor, storeNames, async (scope) => {
+		if (!needsRowForFks) await validateScalarFks(scope, contract, modelName, patch);
+		const meta = makePlanMeta(contract);
+		const where = filters.length === 0 ? void 0 : andExpr(filters);
+		if (!enforcesOnUpdate && !needsRowForFks) return writeMutationRows(scope, contract, modelName, {
+			write: "put-merged",
+			patch,
+			...take === void 0 ? {} : { take },
+			...where === void 0 ? {} : { where }
+		});
+		const oldRows = await readMutationRows(scope, contract, modelName, where, take);
+		const keyPath = getKeyPath(contract, modelName);
+		const results = [];
+		for (const oldRow of oldRows) {
+			if (needsRowForFks) await validateScalarFks(scope, contract, modelName, patch, oldRow);
+			if (enforcesOnUpdate) await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch);
+			const key = extractKeyFromRow(oldRow, keyPath);
+			const updated = (await scope.execute({
+				meta,
+				kind: "update",
+				storeName,
+				key,
+				patch
+			}))[0];
+			if (updated) results.push(updated);
+		}
+		return results;
+	})).map(absentAsNull(contract, modelName));
+}
+/**
+* Returns true if the model has at least one child relation (1:N or parent-side
+* 1:1). Every such relation has an `onDelete` action to enforce: `noAction`
+* behaves like `restrict`, which is also the default.
+*/
+function hasEnforceableChildRelations(contract, modelName) {
+	return getRelationDefinitions(contract, modelName).some((def) => isChildEnforcementRelation(contract, modelName, def));
+}
+/** The store of `modelName` plus the store of every model it has a relation to, in either direction. */
+function collectRelatedStoreNames(contract, modelName) {
+	const stores = /* @__PURE__ */ new Set([getStoreName(contract, modelName)]);
+	for (const def of getRelationDefinitions(contract, modelName)) stores.add(def.relatedStoreName);
+	return [...stores];
+}
+/**
+* Transitively walks the `onDelete` cascade graph from `modelName`, collecting
+* every store a recursive delete might touch. `cascade` edges are walked
+* further (a cascaded child's own children may themselves cascade);
+* `restrict`/`setNull`/`setDefault` edges still need their store added (each
+* is read or written once) but don't recurse further, since none of them
+* delete the child row. Guarded by a model-level visited set — required
+* because IDB must declare every store a transaction might touch before it
+* opens, so this static walk must terminate even on a self-referential model
+* or a cycle of mutually-cascading models.
+*/
+function collectDeleteStoreNames(contract, modelName) {
+	const stores = /* @__PURE__ */ new Set();
+	const visitedModels = /* @__PURE__ */ new Set();
+	/** Collect cascade stores once per model so cyclic relations cannot recurse indefinitely. */
+	function walk(mName) {
+		if (visitedModels.has(mName)) return;
+		visitedModels.add(mName);
+		stores.add(getStoreName(contract, mName));
+		for (const def of getRelationDefinitions(contract, mName)) {
+			if (!isChildEnforcementRelation(contract, mName, def)) continue;
+			const action = getReferentialActionForRelation(contract, mName, def, "onDelete");
+			stores.add(def.relatedStoreName);
+			if (action === "cascade") walk(def.relatedModelName);
+		}
+	}
+	walk(modelName);
+	return [...stores];
+}
+/**
+* Enforces every `onDelete` action declared on `modelName`'s child relations
+* against one specific `row` about to be deleted. `cascade` recurses into
+* each matched child's own `onDelete` relations *before* deleting it — so a
+* multi-hop chain (`User --cascade--> Post --cascade--> Comment`) is fully
+* torn down, and a `restrict` several hops deep still aborts the whole
+* transaction (recursing before deleting means the delete never happens if a
+* deeper hop throws). `setNull`/`setDefault` are leaf actions: the child row
+* survives, so recursion never continues past them.
+*
+* `visited` (keyed by `storeName::key`) guards against row-level cycles — two
+* specific rows whose FKs point at each other through a self-referential or
+* mutually-cascading relation graph. Callers should leave it at its default
+* (a fresh `Set` per top-level call) so independent rows deleted in the same
+* `deleteAll()` batch don't cross-suppress each other's cascades; it's only
+* ever passed explicitly by this function's own recursive calls, to keep one
+* shared guard across a single row's full recursive descent.
+*/
+async function applyReferentialActionsForRow(scope, contract, modelName, row, visited = /* @__PURE__ */ new Set()) {
+	const keyPath = getKeyPath(contract, modelName);
+	const rowKey = `${getStoreName(contract, modelName)}::${keyToken$1(extractKeyFromRow(row, keyPath))}`;
+	if (visited.has(rowKey)) return;
+	visited.add(rowKey);
+	const meta = makePlanMeta(contract);
+	for (const def of getRelationDefinitions(contract, modelName)) {
+		if (!isChildEnforcementRelation(contract, modelName, def)) continue;
+		const action = getReferentialActionForRelation(contract, modelName, def, "onDelete");
+		const childWhere = buildChildWhereFromRow(def, row);
+		if (action === "restrict") {
+			if (await childExists(scope, contract, meta, def, row)) throw new Error(`Cannot delete ${modelName} '${keyToken$1(extractKeyFromRow(row, keyPath))}': child records exist on relation '${def.relationName}'. Delete those children first, or declare onDelete: Cascade, SetNull or SetDefault on the relation.`);
+			continue;
+		}
+		if (action === "cascade") {
+			const childKeyPath = getKeyPath(contract, def.relatedModelName);
+			const children = await readMutationRows(scope, contract, def.relatedModelName, childWhere);
+			for (const child of children) {
+				await applyReferentialActionsForRow(scope, contract, def.relatedModelName, child, visited);
+				await scope.execute({
+					meta,
+					kind: "delete",
+					storeName: def.relatedStoreName,
+					key: extractKeyFromRow(child, childKeyPath)
+				});
+			}
+			continue;
+		}
+		if (action === "setNull") {
+			const patch = {};
+			for (const targetField of def.targetFields) patch[targetField] = null;
+			await writeMutationRows(scope, contract, def.relatedModelName, {
+				write: "put-merged",
+				patch,
+				where: childWhere
+			});
+			continue;
+		}
+		if (action === "setDefault") {
+			const patch = buildSetDefaultPatch(contract, def);
+			await validateSetDefaultPatch(scope, contract, modelName, def, patch, extractKeyFromRow(row, keyPath));
+			await writeMutationRows(scope, contract, def.relatedModelName, {
+				write: "put-merged",
+				patch,
+				where: childWhere
+			});
+			continue;
+		}
+	}
+}
+/** Load a keyed row, apply its child actions, and delete it in one transaction. */
+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 keyPath = getKeyPath(contract, modelName);
+		const fields = keyPathFields(keyPath);
+		const values = typeof keyPath === "string" ? [key] : key;
+		const where = andExpr(fields.map((field, i) => fieldFilter(field, "eq", values[i])));
+		const row = (await readMutationRows(scope, contract, modelName, where, 1))[0];
+		if (!row) return [];
+		await applyReferentialActionsForRow(scope, contract, modelName, row);
+		await scope.execute({
+			meta,
+			kind: "delete",
+			storeName,
+			key
+		});
+		return [];
+	});
+}
+/** Delete filtered rows with all child actions inside the same transaction. */
+async function executeDeleteAllWithReferentialActions(options) {
+	const { executor, contract, modelName, where } = options;
+	return withMutationScope(executor, collectDeleteStoreNames(contract, modelName), async (scope) => {
+		const storeName = getStoreName(contract, modelName);
+		const meta = makePlanMeta(contract);
+		const keyPath = getKeyPath(contract, modelName);
+		if (!hasEnforceableChildRelations(contract, modelName)) return (await writeMutationRows(scope, contract, modelName, {
+			write: "delete",
+			...where === void 0 ? {} : { where }
+		})).map(absentAsNull(contract, modelName));
+		const rows = await readMutationRows(scope, contract, modelName, where);
+		for (const row of rows) {
+			await applyReferentialActionsForRow(scope, contract, modelName, row);
+			const key = extractKeyFromRow(row, keyPath);
+			await scope.execute({
+				meta,
+				kind: "delete",
+				storeName,
+				key
+			});
+		}
+		return rows;
+	});
+}
+//#endregion
+export { createMutationDefaultsCache as A, resolveDecimalKey as B, validateScalarFks as C, planQuery as D, lowerRows as E, combineFilterExprs as F, fieldValueToken as G, withDecimalIdentityScope as H, IdbDecimalIdentityConflictError as I, getStoreName as J, getKeyPath as K, decimalKeysEqual as L, assertValidRecord as M, assertEnumValues as N, applyUpdateDefaults as O, buildRowComparator as P, hasDecimalPrimaryKey as R, requireTransactionExecutor as S, lowerCount as T, buildCatalog as U, withDecimalIdentityExecutor as V, extractKeyFromRow as W, keyToken$1 as X, keyEquals$1 as Y, hasEnforceableChildRelations as _, collectOnUpdateEnforcementStoreNames as a, makePlanMeta as b, executeBulkUpdateWithFkValidation as c, executeMutationPlan as d, executeNestedCreateMutation as f, executeScalarUpdateWithFkValidation as g, executeScalarCreateWithFkValidation as h, collectOnUpdateClosureStoreNames as i, IdbRecordValidationError as j, completeCreateRecord as k, executeDeleteAllWithReferentialActions as l, executeScalarCreateAllWithFkValidation as m, applyReferentialActionsForRowOnUpdate as n, collectRelatedStoreNames as o, executeNestedUpdateMutation as p, getRelation as q, collectDeleteStoreNames as r, collectScalarFkStoreNames as s, applyReferentialActionsForRow as t, executeDeleteWithReferentialActions as u, hasNestedMutationCallbacks as v, withMutationScope as w, readMutationRows as x, hasScalarFkFields as y, preserveDecimalKeySpelling as z };
+
+//# sourceMappingURL=mutation-executor-IuJmyWEG.mjs.map