@prisma-idb/client-idb 0.0.0 → 0.7.0

package/dist/{idb-orm-Cupnnwum.mjs → idb-orm-JBg6si7u.mjs}

@@ -1,7 +1,9 @@
 import { AsyncIterableResult } from "@prisma/orm-framework/components/runtime";
 import { andExpr, evaluateFilter, fieldFilter, nullCheckExpr, shorthandToFilterExpr } from "@prisma-idb/adapter-idb/runtime";
 import { domainModelsAtDefaultNamespace } from "@prisma/orm-framework/contract/types";
+import { compareFieldValues, fieldValueToken, fieldValuesEqual, isValidIdbKey, keyEquals, keyToken } from "@prisma-idb/target-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.
@@ -12,22 +14,30 @@ function getStoreName(contract, modelName) {
 }
 /**
 * Extract the `keyPath` from a model's storage metadata at runtime.
-* Falls back to `"id"` (the invariant key name for all syncable IDB models).
+* 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$1(contract, modelName) {
-	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.keyPath ?? "id";
+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;
 }
 /**
-* Find the IDB index name for `fieldName` on the given object store, searching
-* `contract.storage.stores[storeName].indexes` by `keyPath` equality.
-*
-* Returns the index name (e.g. `"byEmail"`) when a single-field index whose
-* `keyPath` equals `fieldName` exists, or `undefined` otherwise.
-* Multi-entry and composite indexes (`keyPath` is an array) are skipped —
-* equality semantics on those are unsupported.
+* 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 getIndexForField(contract, storeName, fieldName) {
-	return buildFieldToIndexMap(contract, storeName)[fieldName];
+function extractKeyFromRow(row, keyPath) {
+	if (typeof keyPath === "string") return row[keyPath];
+	return keyPath.map((field) => row[field]);
 }
 /**
 * Build a field → indexName lookup for every single-field, non-multi-entry
@@ -43,27 +53,6 @@ function buildFieldToIndexMap(contract, storeName) {
 	return result;
 }
 /**
-* Returns `true` when `value` is a valid {@link IDBValidKey} — i.e. a value
-* that can be passed to `IDBKeyRange.only()` without throwing a DataError.
-* Booleans, `NaN`, `BigInt`, plain objects, and `null`/`undefined` are not
-* valid IDB keys (only number/string/Date/binary/Array are, per the
-* IndexedDB spec). Arrays are validated recursively — an array containing
-* any invalid element (e.g. a nested boolean) is itself not a valid key.
-*
-* Shared by the relation loader (filtering FK values before building
-* `IDBKeyRange.only()` plans) and query-shaping (gating `eq` conditions for
-* index/PK point-range acceleration).
-*/
-function isValidIdbKey(value) {
-	if (typeof value === "number") return !Number.isNaN(value);
-	if (typeof value === "string") return true;
-	if (value instanceof Date) return true;
-	if (value instanceof ArrayBuffer) return true;
-	if (ArrayBuffer.isView(value)) return true;
-	if (Array.isArray(value)) return value.every((v) => isValidIdbKey(v));
-	return false;
-}
-/**
 * Resolve a model's named relation to a {@link ContractReferenceRelation} at
 * runtime, or `undefined` when the relation is absent or an embedded relation
 * (no `on` join block). Used by `include()` to find the related model name and
@@ -201,6 +190,21 @@ function isIndexableEqValue(value) {
 	return isValidIdbKey(value);
 }
 /**
+* `true` when `field` is a *single-field* primary key that a lone `eq`
+* condition can directly point-range-query (`store.get`/`openCursor(range)`
+* against the store's own keyPath, no named index required).
+*
+* Deliberately `false` for a compound (array) `keyPath`, even if `field`
+* happens to be one of its member fields — a single `eq` condition can only
+* pin one member, not the whole compound key, so it can't drive a PK
+* point-range scan on its own. Accelerating that case needs *all* member
+* fields ANDed together, which is a cost-based multi-field planner decision
+* (Phase 10 §3.2), not this peephole optimizer's job.
+*/
+function isPrimaryKeyField(field, keyPath) {
+	return typeof keyPath === "string" && field === keyPath;
+}
+/**
 * Scan the combined filter expression for the first `eq` field condition whose
 * field either has a matching IDB index (`fieldToIndexName[field]` is set) or
 * *is* the store's own primary key (`keyPath`) — a store's keyPath is always
@@ -219,7 +223,7 @@ function extractIndexEqualityHint(filter, fieldToIndexName, keyPath) {
 	if (filter === void 0) return null;
 	if (filter.kind === "field" && filter.op === "eq") {
 		const indexName = fieldToIndexName[filter.field];
-		if ((indexName !== void 0 || filter.field === keyPath) && isIndexableEqValue(filter.value)) return {
+		if ((indexName !== void 0 || isPrimaryKeyField(filter.field, keyPath)) && isIndexableEqValue(filter.value)) return {
 			indexName,
 			value: filter.value,
 			remainingFilter: void 0
@@ -232,7 +236,7 @@ function extractIndexEqualityHint(filter, fieldToIndexName, keyPath) {
 			const expr = flat[i];
 			if (expr.kind === "field" && expr.op === "eq") {
 				const indexName = fieldToIndexName[expr.field];
-				if ((indexName !== void 0 || expr.field === keyPath) && isIndexableEqValue(expr.value)) {
+				if ((indexName !== void 0 || isPrimaryKeyField(expr.field, keyPath)) && isIndexableEqValue(expr.value)) {
 					const rest = flat.filter((_, j) => j !== i);
 					return {
 						indexName,
@@ -257,7 +261,7 @@ function tryExtractOrBranches(orNode, fieldToIndexName, keyPath, remainingFilter
 	for (const expr of orNode.exprs) {
 		if (expr.kind !== "field" || expr.op !== "eq") return null;
 		const indexName = fieldToIndexName[expr.field];
-		if (indexName === void 0 && expr.field !== keyPath || !isIndexableEqValue(expr.value)) return null;
+		if (indexName === void 0 && !isPrimaryKeyField(expr.field, keyPath) || !isIndexableEqValue(expr.value)) return null;
 		branches.push({
 			indexName,
 			value: expr.value
@@ -297,22 +301,59 @@ function extractIndexOrHint(filter, fieldToIndexName, keyPath) {
 * Build an in-memory comparator from an `orderBy` spec (field → direction).
 *
 * Returns `undefined` when there is nothing to sort by. Compares fields in
-* declaration order; values are primitives (strings, numbers, dates) in
-* practice, so JS relational comparison is sufficient.
+* declaration order, with {@link compareFieldValues}: the same order an
+* IndexedDB index uses, so equal `Date`s tie and fall through to the next
+* field, and `null`s sort last (first when descending).
 */
 function buildRowComparator(orderBy) {
 	if (orderBy === void 0) return void 0;
 	return (a, b) => {
 		for (const [field, dir] of Object.entries(orderBy)) {
-			const av = a[field];
-			const bv = b[field];
-			if (av === bv) continue;
-			const cmp = av < bv ? -1 : 1;
+			const cmp = compareFieldValues(a[field], b[field]);
+			if (cmp === 0) continue;
 			return dir === "desc" ? -cmp : cmp;
 		}
 		return 0;
 	};
 }
+/**
+* `true` when a `cursor-scan` plan's result *cardinality* is fully determined
+* by its store/index + key range — i.e. there is no in-memory `filter` that
+* would need each row's value. Only then can `count()` be answered natively
+* (`store.count(range)` / `index.count(range)`) without deserializing rows.
+*
+* `comparator` (ORDER BY), `direction`, `skip` and `take` don't change *which*
+* rows match, so they don't disqualify a plan — `skip`/`take` are applied to
+* the native total afterwards via {@link clampCount}.
+*
+* Safe for index scans because the equality hint that builds `range` never
+* selects a `multiEntry` (or compound) index — `buildFieldToIndexMap` excludes
+* them — so one record maps to at most one index entry and entries == rows.
+*/
+function isNativelyCountable(plan) {
+	return plan.filter === void 0;
+}
+/** Rewrites a natively-countable `cursor-scan` as the equivalent native `count` plan. */
+function toCountPlan(plan) {
+	return {
+		meta: plan.meta,
+		kind: "count",
+		storeName: plan.storeName,
+		...plan.indexName !== void 0 ? { indexName: plan.indexName } : {},
+		...plan.range !== void 0 ? { range: plan.range } : {}
+	};
+}
+/**
+* Applies `skip`/`take` to an *unpaginated* total. A paginated count is pure
+* arithmetic on the unpaginated count — `max(0, total - skip)`, capped at
+* `take` — so this is exact, not an approximation.
+*/
+function clampCount(total, skip, take) {
+	let n = total;
+	if (skip !== void 0) n = Math.max(0, n - skip);
+	if (take !== void 0) n = Math.min(take, n);
+	return n;
+}
 //#endregion
 //#region src/core/aggregate-builder.ts
 /**
@@ -533,8 +574,11 @@ function applyUpdateDefaults(defaults, storeName, patch, cache) {
 * Batch-load a single named relation for all rows in `rows` and attach the
 * result to each row under the `relName` key.
 *
-* The join is done with one cursor scan over the related store (with an
-* in-memory filter), then grouped/indexed in memory — avoiding N+1 queries.
+* The join matches every field of the relation, so compound foreign keys join
+* on the whole tuple. It uses one key-range scan per distinct tuple when an
+* index or the related primary key covers the target fields, and otherwise
+* one full scan with an in-memory filter. Rows are then grouped in memory,
+* which avoids N+1 queries.
 *
 * The `entry` carries any `include()` refinement:
 *
@@ -562,23 +606,22 @@ async function loadRelation(relName, entry, rows, contract, modelName, executor,
 	const relation = rawRelation;
 	const { cardinality, on } = relation;
 	const relatedModelName = relation.to.model;
-	const localField = on.localFields[0];
-	const foreignField = on.targetFields[0];
-	if (localField === void 0 || foreignField === void 0) return rows;
+	const localFields = on.localFields;
+	const targetFields = on.targetFields;
+	if (localFields.length === 0 || localFields.length !== targetFields.length) return rows;
 	const relatedModel = models[relatedModelName];
 	if (relatedModel === void 0) return rows;
 	const relatedStoreName = typeof relatedModel.storage === "object" && relatedModel.storage !== null && "storeName" in relatedModel.storage ? String(relatedModel.storage["storeName"]) : relatedModelName;
 	const isScalar = entry.kind === "scalar";
-	const localValues = /* @__PURE__ */ new Set();
+	const localTuples = /* @__PURE__ */ new Map();
 	for (const row of rows) {
-		const v = row[localField];
-		if (v !== void 0 && v !== null) localValues.add(v);
+		const token = tupleToken(row, localFields);
+		if (token !== null) localTuples.set(token, localFields.map((f) => row[f]));
 	}
-	if (localValues.size === 0) return rows.map((row) => ({
+	if (localTuples.size === 0) return rows.map((row) => ({
 		...row,
 		[relName]: isScalar ? 0 : cardinality === "1:N" ? [] : null
 	}));
-	const capturedForeignField = foreignField;
 	const refinedWhere = combineFilterExprs(entry.state.filters);
 	const planMeta = {
 		target: "idb",
@@ -586,21 +629,25 @@ async function loadRelation(relName, entry, rows, contract, modelName, executor,
 		lane: "idb-orm",
 		annotations: { groupingKey }
 	};
-	const fkIndexName = typeof IDBKeyRange !== "undefined" ? getIndexForField(contract, relatedStoreName, capturedForeignField) : void 0;
-	const targetsRelatedPk = fkIndexName === void 0 && typeof IDBKeyRange !== "undefined" && capturedForeignField === getKeyPath$1(contract, relatedModelName);
+	const rangeSource = findRangeSource(contract, relatedStoreName, relatedModelName, targetFields);
 	let relatedRows;
-	if (fkIndexName !== void 0 || targetsRelatedPk) {
+	if (rangeSource !== void 0) {
 		const refinedFilter = refinedWhere !== void 0 ? (row) => evaluateFilter(refinedWhere, row) : void 0;
-		const validValues = Array.from(localValues).filter(isValidIdbKey);
-		relatedRows = (await Promise.all(validValues.map(async (value) => {
+		const ranges = [];
+		for (const values of localTuples.values()) {
+			const ordered = keyPathFields(rangeSource.keyPath).map((f) => values[targetFields.indexOf(f)]);
+			if (!ordered.every((v) => isValidIdbKey(v))) continue;
+			ranges.push(IDBKeyRange.only(typeof rangeSource.keyPath === "string" ? ordered[0] : ordered));
+		}
+		relatedRows = (await Promise.all(ranges.map(async (range) => {
 			const plan = {
 				meta: planMeta,
 				idbPlan: {
 					meta: planMeta,
 					kind: "cursor-scan",
 					storeName: relatedStoreName,
-					...fkIndexName !== void 0 ? { indexName: fkIndexName } : {},
-					range: IDBKeyRange.only(value),
+					...rangeSource.indexName !== void 0 ? { indexName: rangeSource.indexName } : {},
+					range,
 					...refinedFilter !== void 0 ? { filter: refinedFilter } : {}
 				}
 			};
@@ -610,7 +657,10 @@ async function loadRelation(relName, entry, rows, contract, modelName, executor,
 		}))).flat();
 	} else {
 		relatedRows = [];
-		const filter = (row) => localValues.has(row[capturedForeignField]) && (refinedWhere === void 0 || evaluateFilter(refinedWhere, row));
+		const filter = (row) => {
+			const token = tupleToken(row, targetFields);
+			return token !== null && localTuples.has(token) && (refinedWhere === void 0 || evaluateFilter(refinedWhere, row));
+		};
 		const plan = {
 			meta: planMeta,
 			idbPlan: {
@@ -625,20 +675,25 @@ async function loadRelation(relName, entry, rows, contract, modelName, executor,
 	if (cardinality === "1:N") {
 		const grouped = /* @__PURE__ */ new Map();
 		for (const rrow of relatedRows) {
-			const gk = rrow[capturedForeignField];
+			const gk = tupleToken(rrow, targetFields);
+			if (gk === null) continue;
 			const group = grouped.get(gk) ?? [];
 			group.push(rrow);
 			grouped.set(gk, group);
 		}
+		const groupFor = (row) => {
+			const token = tupleToken(row, localFields);
+			return token === null ? [] : grouped.get(token) ?? [];
+		};
 		if (isScalar) return rows.map((row) => ({
 			...row,
-			[relName]: (grouped.get(row[localField]) ?? []).length
+			[relName]: groupFor(row).length
 		}));
 		const comparator = buildRowComparator(entry.state.orderBy);
 		const skip = entry.state.skip ?? 0;
 		const take = entry.state.take;
 		return rows.map((row) => {
-			let group = grouped.get(row[localField]) ?? [];
+			let group = groupFor(row);
 			if (comparator !== void 0) group = [...group].sort(comparator);
 			if (skip > 0 || take !== void 0) group = group.slice(skip, take !== void 0 ? skip + take : void 0);
 			return {
@@ -648,11 +703,50 @@ async function loadRelation(relName, entry, rows, contract, modelName, executor,
 		});
 	}
 	const indexed = /* @__PURE__ */ new Map();
-	for (const rrow of relatedRows) indexed.set(rrow[capturedForeignField], rrow);
-	return rows.map((row) => ({
-		...row,
-		[relName]: indexed.get(row[localField]) ?? null
-	}));
+	for (const rrow of relatedRows) {
+		const token = tupleToken(rrow, targetFields);
+		if (token !== null) indexed.set(token, rrow);
+	}
+	return rows.map((row) => {
+		const token = tupleToken(row, localFields);
+		return {
+			...row,
+			[relName]: (token === null ? void 0 : indexed.get(token)) ?? null
+		};
+	});
+}
+/**
+* A `Map` key for the values of `fields` in `row`, or `null` when any of them
+* is null or undefined. Equal `Date`s and binary values give equal tokens.
+*/
+function tupleToken(row, fields) {
+	const parts = [];
+	for (const field of fields) {
+		const value = row[field];
+		if (value === null || value === void 0) return null;
+		const token = fieldValueToken(value);
+		parts.push([typeof token, String(token)]);
+	}
+	return JSON.stringify(parts);
+}
+/**
+* Finds an index, or else the store's primary key, whose key path has exactly
+* `fields` (in any order), so a lookup on those fields can use a key range.
+* Returns `undefined` when there is none, or when `IDBKeyRange` isn't available.
+*/
+function findRangeSource(contract, storeName, modelName, fields) {
+	if (typeof IDBKeyRange === "undefined") return void 0;
+	const coversFields = (keyPath) => {
+		const keyFields = keyPathFields(keyPath);
+		return keyFields.length === fields.length && keyFields.every((f) => fields.includes(f));
+	};
+	const indexes = contract.storage.stores[storeName]?.indexes ?? {};
+	for (const [indexName, indexDef] of Object.entries(indexes)) if (indexDef.multiEntry !== true && coversFields(indexDef.keyPath)) return {
+		indexName,
+		keyPath: indexDef.keyPath
+	};
+	const primaryKey = getKeyPath(contract, modelName);
+	return coversFields(primaryKey) ? { keyPath: primaryKey } : void 0;
 }
 //#endregion
 //#region src/core/mutation-scope.ts
@@ -774,22 +868,49 @@ function requireTransactionExecutor(executor) {
 async function executeNestedCreateMutation(options) {
 	const { executor, contract, modelName, data } = options;
 	const record = data;
-	const storeNames = collectStoreNames(contract, modelName, record);
+	const storeNames = collectStoreNames(contract, modelName, record, "create");
 	const defaultsCache = createMutationDefaultsCache();
 	return withMutationScope(executor, storeNames, (scope) => createGraph(scope, contract, modelName, record, defaultsCache));
 }
 async function executeNestedUpdateMutation(options) {
 	const { executor, contract, modelName, filters, data } = options;
 	const record = data;
-	const storeNames = collectStoreNames(contract, modelName, record);
+	const storeNames = collectStoreNames(contract, modelName, record, "update");
 	const defaultsCache = createMutationDefaultsCache();
 	return withMutationScope(executor, storeNames, (scope) => updateFirstGraph(scope, contract, modelName, filters, record, defaultsCache));
 }
-function collectStoreNames(contract, modelName, data) {
-	const stores = /* @__PURE__ */ new Set([getStoreName(contract, modelName)]);
-	for (const def of getRelationDefinitions(contract, modelName)) if (def.relationName in data && isRelationMutationCallback(data[def.relationName])) stores.add(def.relatedStoreName);
+/**
+* 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);
+}
 async function createGraph(scope, contract, modelName, input, defaultsCache) {
 	const parsed = parseMutationInput(contract, modelName, input);
 	const { parentOwned, childOwned } = partitionByOwnership(parsed.relationMutations);
@@ -815,9 +936,11 @@ async function updateFirstGraph(scope, contract, modelName, filters, input, defa
 	let parentRow = existingRow;
 	if (Object.keys(scalarData).length > 0) {
 		const storeName = getStoreName(contract, modelName);
-		const key = existingRow[getKeyPath(contract, modelName)];
+		const key = extractKeyFromRow(existingRow, getKeyPath(contract, modelName));
 		const meta = makePlanMeta(contract);
 		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, scalarData, defaultsCache);
+		await validateScalarFks(scope, contract, modelName, patch, existingRow);
+		await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, existingRow, patch);
 		const updated = (await scope.execute({
 			meta,
 			kind: "update",
@@ -970,6 +1093,7 @@ async function insertSingleRow(scope, contract, modelName, data, defaultsCache)
 	const storeName = getStoreName(contract, modelName);
 	const meta = makePlanMeta(contract);
 	const record = applyCreateDefaults(contract.execution?.mutations.defaults, storeName, data, defaultsCache);
+	await validateScalarFks(scope, contract, modelName, record);
 	return (await scope.execute({
 		meta,
 		kind: "add",
@@ -1020,10 +1144,7 @@ function buildCriterionFilter(criterion) {
 }
 function buildParentJoinFilter(parentValues) {
 	const pairs = [...parentValues.entries()];
-	return (row) => pairs.every(([childField, parentValue]) => row[childField] === parentValue);
-}
-function getKeyPath(contract, modelName) {
-	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.keyPath ?? "id";
+	return (row) => pairs.every(([childField, parentValue]) => fieldValuesEqual(row[childField], parentValue));
 }
 function getStoredAction(contract, modelName, relationName, kind) {
 	return (domainModelsAtDefaultNamespace(contract.domain)[modelName]?.storage)?.relations?.[relationName]?.[kind];
@@ -1048,7 +1169,10 @@ function sameFields(a, b) {
 * action kind on both sides so this fallback never has to arbitrate a real
 * conflict.
 */
-function getReferentialActionForRelation(contract, modelName, def, kind, defaultAction) {
+function getReferentialActionForRelation(contract, modelName, def, kind) {
+	return enforcedAction(findDeclaredAction(contract, modelName, def, kind));
+}
+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)) {
@@ -1058,29 +1182,88 @@ function getReferentialActionForRelation(contract, modelName, def, kind, default
 		const inverseAction = getStoredAction(contract, def.relatedModelName, inverse.relationName, kind);
 		if (inverseAction !== void 0) return inverseAction;
 	}
-	return defaultAction;
-}
-function getOnDeleteForDeleteRelation(contract, modelName, def) {
-	return getReferentialActionForRelation(contract, modelName, def, "onDelete", "restrict");
 }
 /**
-* `onUpdate`'s default (when neither side declares one) is `cascade`, unlike
-* `onDelete`'s `restrict` default — this matches Prisma's own documented
-* behavior: propagating a changed referenced value to children is normally
-* safe, unlike deleting the row those children point to.
+* 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;
+}
+function getOnDeleteForDeleteRelation(contract, modelName, def) {
+	return getReferentialActionForRelation(contract, modelName, def, "onDelete");
+}
 function getOnUpdateForRelation(contract, modelName, def) {
-	return getReferentialActionForRelation(contract, modelName, def, "onUpdate", "cascade");
+	return getReferentialActionForRelation(contract, modelName, def, "onUpdate");
 }
 function isDeleteEnforcementRelation(contract, modelName, def) {
 	if (def.cardinality === "1:N") return true;
 	if (def.cardinality === "1:1") {
 		const keyPath = getKeyPath(contract, modelName);
-		return def.localFields.length > 0 && def.localFields[0] === keyPath;
+		return sameFields(def.localFields, keyPathFields(keyPath));
 	}
 	return false;
 }
 /**
+* An `IDBKeyRange` for the lookup "does `modelName` have a row whose `field`
+* equals `value`?" — but ONLY when `field` is that model's own single-field
+* primary key (so the answer is a pure key lookup that needs no row value)
+* and `value` is a legal IDB key. `null` otherwise, and the caller keeps its
+* value-materializing `cursor-scan`.
+*
+* Deliberately `null` for a compound primary key even if `field` is one of its
+* members (one member can't pin the whole key), and for any non-key field
+* (that needs an index-resolution step — Phase 10.5's shared primitive, not
+* this helper's job). `IDBKeyRange.only` throws `DataError` on invalid keys
+* (`null`, `NaN`, booleans, …), hence the guard.
+*/
+function pkEqualityRange(contract, modelName, field, value) {
+	if (typeof IDBKeyRange === "undefined") return null;
+	const keyPath = getKeyPath(contract, modelName);
+	if (typeof keyPath !== "string" || keyPath !== field) return null;
+	if (!isValidIdbKey(value)) return null;
+	return IDBKeyRange.only(value);
+}
+/**
+* Resolves to the first primary key in `storeName` within `range`, or
+* `undefined` — one `getKey` request, no row deserialized.
+*/
+async function firstKeyInRange(scope, meta, storeName, range) {
+	return (await scope.execute({
+		meta,
+		kind: "keys",
+		storeName,
+		range,
+		take: 1
+	}))[0]?.["key"];
+}
+/**
+* `true` if any child row matches the relation against `parentRow`'s values —
+* the existence check behind `restrict`. Key-only when the relation's single
+* child field is the child model's own primary key (a shared-PK 1:1); a
+* value-materializing `cursor-scan` (`take: 1`) otherwise.
+*/
+async function childExists(scope, contract, meta, def, parentRow) {
+	if (def.targetFields.length === 1) {
+		const range = pkEqualityRange(contract, def.relatedModelName, def.targetFields[0], parentRow[def.localFields[0]]);
+		if (range !== null) return await firstKeyInRange(scope, meta, def.relatedStoreName, range) !== void 0;
+	}
+	return (await scope.execute({
+		meta,
+		kind: "cursor-scan",
+		storeName: def.relatedStoreName,
+		filter: buildChildFilterFromRow(def, parentRow),
+		take: 1
+	})).length > 0;
+}
+/**
 * Builds a filter matching a relation's children against one specific parent
 * row's values. Shared by `onDelete` cascade (`applyReferentialActionsForRow`)
 * and `onUpdate` cascade (`applyReferentialActionsForRowOnUpdate`).
@@ -1090,7 +1273,7 @@ function buildChildFilterFromRow(def, row) {
 		childField: def.targetFields[i],
 		parentValue: row[lf]
 	}));
-	return (child) => pairs.every(({ childField, parentValue }) => child[childField] === parentValue);
+	return (child) => pairs.every(({ childField, parentValue }) => fieldValuesEqual(child[childField], parentValue));
 }
 /** Reads a field's literal `@default(...)` value from `IdbModelStorage.fieldDefaults`, if declared. */
 function getFieldDefault(contract, modelName, fieldName) {
@@ -1127,10 +1310,8 @@ function buildSetDefaultPatch(contract, def) {
 * part of the transaction (it's the model literally being written), so no
 * store-list changes are needed to call this.
 *
-* Refuses (throws) rather than validates incorrectly for compound (multi-
-* field) relations, for the same reason `validateScalarFks` does: each
-* field's default is resolved independently, so there's no guarantee the
-* combination corresponds to a single real row.
+* 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
@@ -1142,21 +1323,9 @@ function buildSetDefaultPatch(contract, def) {
 * default references a real row, when after the transaction nothing will.
 */
 async function validateSetDefaultPatch(scope, contract, modelName, def, patch, excludeKey) {
-	if (def.localFields.length > 1) throw new Error(`setDefault referential action on relation '${def.relationName}' cannot validate a compound (multi-field) default: each field's default is resolved independently, so there is no guarantee the combination corresponds to a single real row.`);
-	const meta = makePlanMeta(contract);
-	const parentStoreName = getStoreName(contract, modelName);
-	const parentKeyPath = getKeyPath(contract, modelName);
-	const localField = def.localFields[0];
-	const targetField = def.targetFields[0];
-	const value = patch[targetField];
-	const filter = (row) => row[localField] === value && (excludeKey === void 0 || row[parentKeyPath] !== excludeKey);
-	if ((await scope.execute({
-		meta,
-		kind: "cursor-scan",
-		storeName: parentStoreName,
-		filter,
-		take: 1
-	})).length === 0) throw new Error(`setDefault referential action on relation '${def.relationName}' would set '${def.relatedModelName}.${targetField}' to '${String(value)}', but no ${modelName} with ${localField}='${String(value)}' exists — the declared default does not reference a real row.`);
+	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
@@ -1186,7 +1355,6 @@ function collectOnUpdateEnforcementStoreNames(contract, modelName, data) {
 		for (const def of getRelationDefinitions(contract, mName)) {
 			if (!isDeleteEnforcementRelation(contract, mName, def)) continue;
 			const action = getOnUpdateForRelation(contract, mName, def);
-			if (action === "noAction") continue;
 			stores.add(def.relatedStoreName);
 			if (action === "cascade") walkCascadeChain(def.relatedModelName);
 		}
@@ -1196,7 +1364,6 @@ function collectOnUpdateEnforcementStoreNames(contract, modelName, data) {
 		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
 		if (!def.localFields.some((f) => f in data)) continue;
 		const action = getOnUpdateForRelation(contract, modelName, def);
-		if (action === "noAction") continue;
 		enforces = true;
 		stores.add(def.relatedStoreName);
 		if (action === "cascade") walkCascadeChain(def.relatedModelName);
@@ -1231,25 +1398,18 @@ function collectOnUpdateEnforcementStoreNames(contract, modelName, data) {
 */
 async function applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch, visited = /* @__PURE__ */ new Set()) {
 	const keyPath = getKeyPath(contract, modelName);
-	const rowKey = `${getStoreName(contract, modelName)}::${String(oldRow[keyPath])}`;
+	const rowKey = `${getStoreName(contract, modelName)}::${keyToken(extractKeyFromRow(oldRow, keyPath))}`;
 	if (visited.has(rowKey)) return;
 	visited.add(rowKey);
 	const meta = makePlanMeta(contract);
 	for (const def of getRelationDefinitions(contract, modelName)) {
 		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
-		const changedFields = def.localFields.filter((f) => f in patch && patch[f] !== oldRow[f]);
+		const changedFields = def.localFields.filter((f) => f in patch && !fieldValuesEqual(patch[f], oldRow[f]));
 		if (changedFields.length === 0) continue;
 		const action = getOnUpdateForRelation(contract, modelName, def);
-		if (action === "noAction") continue;
 		const childFilter = buildChildFilterFromRow(def, oldRow);
 		if (action === "restrict") {
-			if ((await scope.execute({
-				meta,
-				kind: "cursor-scan",
-				storeName: def.relatedStoreName,
-				filter: childFilter,
-				take: 1
-			})).length > 0) throw new Error(`Cannot update ${modelName} '${String(oldRow[keyPath])}': changing field(s) ${changedFields.join(", ")} would orphan child records on relation '${def.relationName}'. Use onUpdate: 'cascade', 'setNull', 'setDefault', or 'noAction'.`);
+			if (await childExists(scope, contract, meta, def, oldRow)) throw new Error(`Cannot update ${modelName} '${keyToken(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") {
@@ -1291,7 +1451,7 @@ async function applyReferentialActionsForRowOnUpdate(scope, contract, modelName,
 		}
 		if (action === "setDefault") {
 			const childPatch = buildSetDefaultPatch(contract, def);
-			await validateSetDefaultPatch(scope, contract, modelName, def, childPatch, oldRow[keyPath]);
+			await validateSetDefaultPatch(scope, contract, modelName, def, childPatch, extractKeyFromRow(oldRow, keyPath));
 			await scope.execute({
 				meta,
 				kind: "scan-write",
@@ -1323,31 +1483,102 @@ function collectScalarFkStoreNames(contract, modelName, data) {
 	}
 	return [...stores];
 }
-async function validateScalarFks(scope, contract, modelName, data) {
+/**
+* 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 && data[f] !== null && data[f] !== void 0)) continue;
-		if (def.localFields.length > 1) throw new Error(`FK violation on relation '${def.relationName}': compound (multi-field) scalar FK validation is not supported`);
-		const localField = def.localFields[0];
-		const targetField = def.targetFields[0];
-		const value = data[localField];
-		const filter = (row) => row[targetField] === value;
-		const plan = {
-			meta,
-			kind: "cursor-scan",
-			storeName: def.relatedStoreName,
-			filter,
-			take: 1
-		};
-		if ((await scope.execute(plan)).length === 0) throw new Error(`FK violation on relation '${def.relationName}': no ${def.relatedModelName} with ${targetField}='${String(value)}'`);
+		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?
+*
+* When `fields` are exactly the parent's primary key (in any order), this is
+* one key-only lookup. Otherwise it scans the parent store, comparing values
+* the way IndexedDB compares keys. `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 storeName = getStoreName(contract, parentModel);
+	const keyPath = getKeyPath(contract, parentModel);
+	const range = primaryKeyRange(keyPath, fields, values);
+	if (range !== null) {
+		const foundKey = await firstKeyInRange(scope, meta, storeName, range);
+		return foundKey !== void 0 && (excludeKey === void 0 || !keyEquals(foundKey, excludeKey));
+	}
+	const filter = (row) => fields.every((f, i) => fieldValuesEqual(row[f], values[i])) && (excludeKey === void 0 || !keyEquals(extractKeyFromRow(row, keyPath), excludeKey));
+	return (await scope.execute({
+		meta,
+		kind: "cursor-scan",
+		storeName,
+		filter,
+		take: 1
+	})).length > 0;
+}
+/**
+* An `IDBKeyRange` for "the row whose primary key is `values`", when `fields`
+* are exactly the key's fields (in any order) and every value is a valid
+* IndexedDB key. `null` otherwise, and the caller scans instead.
+*/
+function primaryKeyRange(keyPath, fields, values) {
+	if (typeof IDBKeyRange === "undefined") return null;
+	const keyFields = keyPathFields(keyPath);
+	if (keyFields.length !== fields.length || !keyFields.every((f) => fields.includes(f))) return null;
+	const ordered = keyFields.map((f) => values[fields.indexOf(f)]);
+	if (!ordered.every((v) => isValidIdbKey(v))) return null;
+	return IDBKeyRange.only(typeof keyPath === "string" ? ordered[0] : ordered);
+}
+/** `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(", ");
+}
 async function executeScalarCreateWithFkValidation(options) {
 	const { executor, contract, modelName, data } = options;
-	return withMutationScope(executor, collectScalarFkStoreNames(contract, modelName, data), async (scope) => {
-		await validateScalarFks(scope, contract, modelName, data);
-		return insertSingleRow(scope, contract, modelName, data, createMutationDefaultsCache());
+	const defaultsCache = createMutationDefaultsCache();
+	const record = applyCreateDefaults(contract.execution?.mutations.defaults, getStoreName(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 storeName = getStoreName(contract, modelName);
+	const records = data.map((row) => applyCreateDefaults(contract.execution?.mutations.defaults, storeName, 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;
 	});
 }
 /**
@@ -1368,18 +1599,19 @@ function collectUpdateStoreNames(contract, modelName, data) {
 }
 async function executeScalarUpdateWithFkValidation(options) {
 	const { executor, contract, modelName, filters, data } = options;
-	const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, data);
+	const storeName = getStoreName(contract, modelName);
+	const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, data, createMutationDefaultsCache());
+	const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, patch);
+	const needsRowForFks = fkCheckNeedsExistingRow(contract, modelName, patch);
 	return withMutationScope(executor, storeNames, async (scope) => {
-		await validateScalarFks(scope, contract, modelName, data);
-		const storeName = getStoreName(contract, modelName);
+		if (!needsRowForFks) await validateScalarFks(scope, contract, modelName, patch);
 		const meta = makePlanMeta(contract);
 		const combined = filters.length === 0 ? void 0 : filters.length === 1 ? filters[0] : {
 			kind: "and",
 			exprs: filters
 		};
 		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
-		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, data, createMutationDefaultsCache());
-		if (!enforcesOnUpdate) return (await scope.execute({
+		if (!enforcesOnUpdate && !needsRowForFks) return (await scope.execute({
 			meta,
 			kind: "scan-write",
 			storeName,
@@ -1396,8 +1628,9 @@ async function executeScalarUpdateWithFkValidation(options) {
 			...filter !== void 0 ? { filter } : {}
 		}))[0];
 		if (!oldRow) return null;
-		await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch);
-		const key = oldRow[getKeyPath(contract, modelName)];
+		if (needsRowForFks) await validateScalarFks(scope, contract, modelName, patch, oldRow);
+		if (enforcesOnUpdate) await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch);
+		const key = extractKeyFromRow(oldRow, getKeyPath(contract, modelName));
 		return (await scope.execute({
 			meta,
 			kind: "update",
@@ -1426,18 +1659,19 @@ async function executeScalarUpdateWithFkValidation(options) {
 */
 async function executeBulkUpdateWithFkValidation(options) {
 	const { executor, contract, modelName, filters, data } = options;
-	const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, data);
+	const storeName = getStoreName(contract, modelName);
+	const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, data, createMutationDefaultsCache());
+	const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, patch);
+	const needsRowForFks = fkCheckNeedsExistingRow(contract, modelName, patch);
 	return withMutationScope(executor, storeNames, async (scope) => {
-		await validateScalarFks(scope, contract, modelName, data);
-		const storeName = getStoreName(contract, modelName);
+		if (!needsRowForFks) await validateScalarFks(scope, contract, modelName, patch);
 		const meta = makePlanMeta(contract);
 		const combined = filters.length === 0 ? void 0 : filters.length === 1 ? filters[0] : {
 			kind: "and",
 			exprs: filters
 		};
 		const filter = combined !== void 0 ? (row) => evaluateFilter(combined, row) : void 0;
-		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, data, createMutationDefaultsCache());
-		if (!enforcesOnUpdate) return scope.execute({
+		if (!enforcesOnUpdate && !needsRowForFks) return scope.execute({
 			meta,
 			kind: "scan-write",
 			storeName,
@@ -1454,8 +1688,9 @@ async function executeBulkUpdateWithFkValidation(options) {
 		const keyPath = getKeyPath(contract, modelName);
 		const results = [];
 		for (const oldRow of oldRows) {
-			await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch);
-			const key = oldRow[keyPath];
+			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",
@@ -1470,16 +1705,11 @@ async function executeBulkUpdateWithFkValidation(options) {
 }
 /**
 * Returns true if the model has at least one child relation (1:N or parent-side
-* 1:1) whose `onDelete` action requires enforcement (anything except `noAction`).
-* Since the default is `restrict`, any model with 1:N/1:1 relations that do not
-* explicitly set `noAction` returns true.
+* 1:1). Every such relation has an `onDelete` action to enforce: `noAction`
+* behaves like `restrict`, which is also the default.
 */
 function hasEnforceableChildRelations(contract, modelName) {
-	for (const def of getRelationDefinitions(contract, modelName)) {
-		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
-		if (getOnDeleteForDeleteRelation(contract, modelName, def) !== "noAction") return true;
-	}
-	return false;
+	return getRelationDefinitions(contract, modelName).some((def) => isDeleteEnforcementRelation(contract, modelName, def));
 }
 /**
 * Transitively walks the `onDelete` cascade graph from `modelName`, collecting
@@ -1502,7 +1732,6 @@ function collectDeleteStoreNames(contract, modelName) {
 		for (const def of getRelationDefinitions(contract, mName)) {
 			if (!isDeleteEnforcementRelation(contract, mName, def)) continue;
 			const action = getOnDeleteForDeleteRelation(contract, mName, def);
-			if (action === "noAction") continue;
 			stores.add(def.relatedStoreName);
 			if (action === "cascade") walk(def.relatedModelName);
 		}
@@ -1530,23 +1759,16 @@ function collectDeleteStoreNames(contract, modelName) {
 */
 async function applyReferentialActionsForRow(scope, contract, modelName, row, visited = /* @__PURE__ */ new Set()) {
 	const keyPath = getKeyPath(contract, modelName);
-	const rowKey = `${getStoreName(contract, modelName)}::${String(row[keyPath])}`;
+	const rowKey = `${getStoreName(contract, modelName)}::${keyToken(extractKeyFromRow(row, keyPath))}`;
 	if (visited.has(rowKey)) return;
 	visited.add(rowKey);
 	const meta = makePlanMeta(contract);
 	for (const def of getRelationDefinitions(contract, modelName)) {
 		if (!isDeleteEnforcementRelation(contract, modelName, def)) continue;
 		const action = getOnDeleteForDeleteRelation(contract, modelName, def);
-		if (action === "noAction") continue;
 		const childFilter = buildChildFilterFromRow(def, row);
 		if (action === "restrict") {
-			if ((await scope.execute({
-				meta,
-				kind: "cursor-scan",
-				storeName: def.relatedStoreName,
-				filter: childFilter,
-				take: 1
-			})).length > 0) throw new Error(`Cannot delete ${modelName} '${String(row[keyPath])}': child records exist on relation '${def.relationName}'. Use onDelete: 'cascade', 'setNull', or 'noAction'.`);
+			if (await childExists(scope, contract, meta, def, row)) throw new Error(`Cannot delete ${modelName} '${keyToken(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") {
@@ -1563,7 +1785,7 @@ async function applyReferentialActionsForRow(scope, contract, modelName, row, vi
 					meta,
 					kind: "delete",
 					storeName: def.relatedStoreName,
-					key: child[childKeyPath]
+					key: extractKeyFromRow(child, childKeyPath)
 				});
 			}
 			continue;
@@ -1583,7 +1805,7 @@ async function applyReferentialActionsForRow(scope, contract, modelName, row, vi
 		}
 		if (action === "setDefault") {
 			const patch = buildSetDefaultPatch(contract, def);
-			await validateSetDefaultPatch(scope, contract, modelName, def, patch, row[keyPath]);
+			await validateSetDefaultPatch(scope, contract, modelName, def, patch, extractKeyFromRow(row, keyPath));
 			await scope.execute({
 				meta,
 				kind: "scan-write",
@@ -1632,7 +1854,7 @@ async function executeDeleteAllWithReferentialActions(options) {
 		});
 		for (const row of rows) {
 			await applyReferentialActionsForRow(scope, contract, modelName, row);
-			const key = row[keyPath];
+			const key = extractKeyFromRow(row, keyPath);
 			await scope.execute({
 				meta,
 				kind: "delete",
@@ -1709,7 +1931,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		const projectRows = this.#projectRows.bind(this);
 		const combined = this.#combinedFilterExpr();
 		const fieldToIndexMap = typeof IDBKeyRange !== "undefined" ? buildFieldToIndexMap(this.#contract, this.#storeName) : void 0;
-		const keyPath = getKeyPath$1(this.#contract, this.#modelName);
+		const keyPath = getKeyPath(this.#contract, this.#modelName);
 		const comparator = buildRowComparator(this.#state.orderBy);
 		const skip = this.#state.skip;
 		const take = this.#state.take;
@@ -1743,7 +1965,17 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			aggregates: toAggregateRequests(spec),
 			...combined !== void 0 ? { where: combined } : {}
 		};
-		return computeAggregateSpec(spec, await this.#materialize(this.#newGroupingKey(), ast));
+		const groupingKey = this.#newGroupingKey();
+		if (Object.values(spec).every((selector) => selector.fn === "count")) {
+			const scanPlan = this.#buildScanPlan(groupingKey);
+			const total = await this.#executeNativeCount(scanPlan, ast);
+			if (total !== null) {
+				const result = {};
+				for (const alias of Object.keys(spec)) result[alias] = total;
+				return result;
+			}
+		}
+		return computeAggregateSpec(spec, await this.#materialize(groupingKey, ast));
 	}
 	groupBy(...fields) {
 		const combined = this.#combinedFilterExpr();
@@ -1763,15 +1995,15 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			modelName: this.#modelName,
 			data: record
 		});
-		if (hasScalarFkFields(this.#contract, this.#modelName, record)) return await executeScalarCreateWithFkValidation({
+		const withDefaults = applyCreateDefaults(this.#contract.execution?.mutations.defaults, this.#storeName, record, createMutationDefaultsCache());
+		if (hasScalarFkFields(this.#contract, this.#modelName, withDefaults)) return await executeScalarCreateWithFkValidation({
 			executor: requireTransactionExecutor(this.#executor),
 			contract: this.#contract,
 			modelName: this.#modelName,
-			data: record
+			data: withDefaults
 		});
 		const groupingKey = this.#newGroupingKey();
 		const meta = this.#planMeta(groupingKey);
-		const withDefaults = applyCreateDefaults(this.#contract.execution?.mutations.defaults, this.#storeName, record, createMutationDefaultsCache());
 		const plan = {
 			meta,
 			ast: {
@@ -1885,7 +2117,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		return (await this.updateAll(patch).toArray()).length;
 	}
 	async upsert(args) {
-		const keyPath = getKeyPath$1(this.#contract, this.#modelName);
+		const keyPath = getKeyPath(this.#contract, this.#modelName);
 		const whereExpr = shorthandToFilterExpr(args.where);
 		const matches = (row) => whereExpr === void 0 || evaluateFilter(whereExpr, row);
 		const meta = this.#planMeta(this.#newGroupingKey());
@@ -1895,8 +2127,14 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		const executionDefaults = this.#contract.execution?.mutations.defaults;
 		const exec = requireTransactionExecutor(this.#executor);
 		const effectivePatch = applyUpdateDefaults(executionDefaults, storeName, patchRecord, createMutationDefaultsCache());
+		const createWithDefaults = applyCreateDefaults(executionDefaults, storeName, createRecord, createMutationDefaultsCache());
 		const { storeNames: onUpdateStoreNames } = collectOnUpdateEnforcementStoreNames(this.#contract, this.#modelName, effectivePatch);
-		return withMutationScope(exec, [.../* @__PURE__ */ new Set([storeName, ...onUpdateStoreNames])], async (scope) => {
+		return withMutationScope(exec, [.../* @__PURE__ */ new Set([
+			storeName,
+			...onUpdateStoreNames,
+			...collectScalarFkStoreNames(this.#contract, this.#modelName, createWithDefaults),
+			...collectScalarFkStoreNames(this.#contract, this.#modelName, effectivePatch)
+		])], async (scope) => {
 			const existing = (await scope.execute({
 				meta,
 				kind: "cursor-scan",
@@ -1905,15 +2143,16 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 				take: 1
 			}))[0];
 			if (existing === void 0) {
-				const record = applyCreateDefaults(executionDefaults, storeName, createRecord, createMutationDefaultsCache());
+				await validateScalarFks(scope, this.#contract, this.#modelName, createWithDefaults);
 				return (await scope.execute({
 					meta,
 					kind: "add",
 					storeName,
-					record
-				}))[0] ?? record;
+					record: createWithDefaults
+				}))[0] ?? createWithDefaults;
 			}
-			const key = existing[keyPath];
+			await validateScalarFks(scope, this.#contract, this.#modelName, effectivePatch, existing);
+			const key = extractKeyFromRow(existing, keyPath);
 			await applyReferentialActionsForRowOnUpdate(scope, this.#contract, this.#modelName, existing, effectivePatch);
 			return (await scope.execute({
 				meta,
@@ -1925,11 +2164,25 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		});
 	}
 	createAll(data) {
-		const groupingKey = this.#newGroupingKey();
-		const meta = this.#planMeta(groupingKey);
 		const defaultsCache = createMutationDefaultsCache();
 		const executionDefaults = this.#contract.execution?.mutations.defaults;
 		const records = data.map((d) => applyCreateDefaults(executionDefaults, this.#storeName, d, defaultsCache));
+		if (records.some((row) => hasScalarFkFields(this.#contract, this.#modelName, row))) {
+			const executor = requireTransactionExecutor(this.#executor);
+			const contract = this.#contract;
+			const modelName = this.#modelName;
+			return new AsyncIterableResult((async function* () {
+				const rows = await executeScalarCreateAllWithFkValidation({
+					executor,
+					contract,
+					modelName,
+					data: records
+				});
+				for (const row of rows) yield row;
+			})());
+		}
+		const groupingKey = this.#newGroupingKey();
+		const meta = this.#planMeta(groupingKey);
 		const plan = {
 			meta,
 			ast: {
@@ -1995,13 +2248,8 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		const combined = this.#combinedFilterExpr();
 		const fieldToIndexMap = typeof IDBKeyRange !== "undefined" ? buildFieldToIndexMap(this.#contract, this.#storeName) : void 0;
 		if (fieldToIndexMap !== void 0) {
-			const orHint = extractIndexOrHint(combined, fieldToIndexMap, getKeyPath$1(this.#contract, this.#modelName));
-			if (orHint !== null) {
-				let n = (await this.#executeOrRows(orHint, groupingKey, combined)).length;
-				if (this.#state.skip !== void 0) n = Math.max(0, n - this.#state.skip);
-				if (this.#state.take !== void 0) n = Math.min(this.#state.take, n);
-				return n;
-			}
+			const orHint = extractIndexOrHint(combined, fieldToIndexMap, getKeyPath(this.#contract, this.#modelName));
+			if (orHint !== null) return clampCount((await this.#executeOrRows(orHint, groupingKey, combined)).length, this.#state.skip, this.#state.take);
 		}
 		const scanPlan = this.#buildScanPlan(groupingKey, fieldToIndexMap);
 		const scanAst = scanPlan.ast;
@@ -2010,6 +2258,8 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			modelName: this.#modelName,
 			...scanAst?.kind === "findMany" && scanAst.where !== void 0 ? { where: scanAst.where } : {}
 		};
+		const nativeTotal = await this.#executeNativeCount(scanPlan, ast);
+		if (nativeTotal !== null) return clampCount(nativeTotal, this.#state.skip, this.#state.take);
 		const plan = {
 			...scanPlan,
 			ast
@@ -2046,6 +2296,25 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 		throw new Error(`include('${relation}') refinement must return the collection (for where/orderBy/take/skip) or a count() selector`);
 	}
 	/**
+	* Runs `scanPlan` as a native `count` plan when its cardinality is fully
+	* determined by a key range (no in-memory filter) — returning the
+	* *unpaginated* total — or `null` when it can't (the caller then falls back
+	* to materializing). `ast` is attached so middleware sees the caller's
+	* intent (`count` / `aggregate`) regardless of the physical plan.
+	*/
+	async #executeNativeCount(scanPlan, ast) {
+		const body = scanPlan.idbPlan;
+		if (body.kind !== "cursor-scan" || !isNativelyCountable(body)) return null;
+		const nativePlan = {
+			...scanPlan,
+			ast,
+			idbPlan: toCountPlan(body)
+		};
+		let total = 0;
+		for await (const row of this.#executor.query(nativePlan)) total = row.count;
+		return total;
+	}
+	/**
 	* Materialise all rows matching the accumulated filters with no pagination —
 	* used by `aggregate()` / `groupBy()`. The supplied `ast` is attached to the
 	* scan plan so middleware can observe the aggregate intent.
@@ -2081,7 +2350,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			...this.#state.take !== void 0 ? { take: this.#state.take } : {}
 		};
 		if (typeof IDBKeyRange !== "undefined") {
-			const hint = extractIndexEqualityHint(combined, fieldToIndexMap ?? buildFieldToIndexMap(this.#contract, this.#storeName), getKeyPath$1(this.#contract, this.#modelName));
+			const hint = extractIndexEqualityHint(combined, fieldToIndexMap ?? buildFieldToIndexMap(this.#contract, this.#storeName), getKeyPath(this.#contract, this.#modelName));
 			if (hint !== null) {
 				const { indexName, value, remainingFilter } = hint;
 				const filter = remainingFilter !== void 0 ? (row) => evaluateFilter(remainingFilter, row) : void 0;
@@ -2126,7 +2395,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 	async #executeOrRows(hint, groupingKey, combined) {
 		const meta = this.#planMeta(groupingKey);
 		const storeName = this.#storeName;
-		const keyPath = getKeyPath$1(this.#contract, this.#modelName);
+		const keyPath = getKeyPath(this.#contract, this.#modelName);
 		const seen = /* @__PURE__ */ new Set();
 		const rows = [];
 		const ast = {
@@ -2151,7 +2420,7 @@ var IdbStoreAccessorImpl = class IdbStoreAccessorImpl {
 			return branchRows;
 		}));
 		for (const branchRows of branchResults) for (const row of branchRows) {
-			const pk = row[keyPath];
+			const pk = keyToken(extractKeyFromRow(row, keyPath));
 			if (!seen.has(pk)) {
 				seen.add(pk);
 				rows.push(row);
@@ -2240,6 +2509,6 @@ function idbOrm(options) {
 	return client;
 }
 //#endregion
-export { createRelationMutator as a, withMutationScope as c, hasNestedMutationCallbacks as i, getKeyPath$1 as l, applyReferentialActionsForRow as n, isRelationMutationCallback as o, collectDeleteStoreNames as r, isRelationMutationDescriptor as s, idbOrm as t, getStoreName as u };
+export { createRelationMutator as a, withMutationScope as c, getStoreName as d, keyEquals as f, hasNestedMutationCallbacks as i, extractKeyFromRow as l, applyReferentialActionsForRow as n, isRelationMutationCallback as o, keyToken as p, collectDeleteStoreNames as r, isRelationMutationDescriptor as s, idbOrm as t, getKeyPath as u };
 
-//# sourceMappingURL=idb-orm-Cupnnwum.mjs.map
+//# sourceMappingURL=idb-orm-JBg6si7u.mjs.map