@prisma-idb/client-idb 0.11.0 → 0.13.0

package/dist/mutation-executor-SJqTuSbb.mjs

@@ -1,1196 +0,0 @@
-import { evaluateFilter, shorthandToFilterExpr } from "@prisma-idb/adapter-idb/runtime";
-import { domainModelsAtDefaultNamespace } from "@prisma/orm-framework/contract/types";
-import { fieldValueToken, fieldValuesEqual, keyEquals as keyEquals$1, 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.
-* 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/enum-validation.ts
-const rulesByContract = /* @__PURE__ */ new WeakMap();
-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: field.many === true
-	};
-}
-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})`;
-}
-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.
-*/
-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 (!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/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"]);
-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)}"`);
-	}
-}
-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.table !== storeName || !d.onCreate) continue;
-		if (result[d.ref.column] !== void 0) continue;
-		if (result === data) result = { ...data };
-		result[d.ref.column] = resolveGeneratedValue(d.onCreate, cache);
-	}
-	return result;
-}
-/**
-* 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.table !== storeName || !d.onUpdate) continue;
-		if (result[d.ref.column] !== void 0) continue;
-		if (result === patch) result = { ...patch };
-		result[d.ref.column] = resolveGeneratedValue(d.onUpdate, cache);
-	}
-	return result;
-}
-//#endregion
-//#region src/core/mutation-scope.ts
-/**
-* Run a callback inside a single multi-store IDB readwrite transaction.
-*
-* Opens the transaction, passes the `IdbTransactionScope` to `run`, then:
-* - On success: awaits `scope.commit()` (waits for `tx.oncomplete`).
-* - On error: calls `scope.rollback()` and rethrows.
-*
-* The callback receives the low-level scope, not the ORM accessor.
-* Use this for multi-store atomic writes that span several object stores.
-*/
-async function withMutationScope(executor, storeNames, run) {
-	const tx = await executor.transaction(storeNames, "readwrite");
-	try {
-		const result = await run(tx);
-		await tx.commit();
-		return result;
-	} catch (err) {
-		tx.rollback();
-		throw err;
-	}
-}
-//#endregion
-//#region src/core/relation-mutator.ts
-function createRelationMutator() {
-	return {
-		create(data) {
-			return {
-				kind: "create",
-				data: Array.isArray(data) ? [...data] : [data]
-			};
-		},
-		connect(criteria) {
-			return {
-				kind: "connect",
-				criteria: Array.isArray(criteria) ? [...criteria] : [criteria]
-			};
-		},
-		disconnect(criteria) {
-			if (!criteria) return { kind: "disconnect" };
-			return {
-				kind: "disconnect",
-				criteria: [...criteria]
-			};
-		}
-	};
-}
-function isRelationMutationDescriptor(value) {
-	if (!value || typeof value !== "object") return false;
-	const candidate = value;
-	return candidate.kind === "create" || candidate.kind === "connect" || candidate.kind === "disconnect";
-}
-function isRelationMutationCallback(value) {
-	return typeof value === "function";
-}
-//#endregion
-//#region src/core/mutation-executor.ts
-function makePlanMeta(contract) {
-	return {
-		target: "idb",
-		storageHash: contract.storage.storageHash,
-		lane: "idb-mutation-executor",
-		annotations: { groupingKey: "nested" }
-	};
-}
-const relationDefsCache = /* @__PURE__ */ new WeakMap();
-function getRelationDefinitions(contract, modelName) {
-	let perContract = relationDefsCache.get(contract);
-	if (!perContract) {
-		perContract = /* @__PURE__ */ new Map();
-		relationDefsCache.set(contract, perContract);
-	}
-	const cached = perContract.get(modelName);
-	if (cached) return cached;
-	const model = domainModelsAtDefaultNamespace(contract.domain)[modelName];
-	if (!model) {
-		perContract.set(modelName, []);
-		return [];
-	}
-	const defs = [];
-	for (const [relationName, rawRelation] of Object.entries(model.relations)) {
-		if (!rawRelation || typeof rawRelation !== "object" || !("on" in rawRelation)) continue;
-		const relation = rawRelation;
-		const relatedModelName = relation.to.model;
-		const relatedStoreName = getStoreName(contract, relatedModelName);
-		defs.push({
-			relationName,
-			relatedModelName,
-			relatedStoreName,
-			cardinality: relation.cardinality,
-			localFields: relation.on.localFields,
-			targetFields: relation.on.targetFields
-		});
-	}
-	perContract.set(modelName, defs);
-	return defs;
-}
-/**
-* Returns true if `data` contains at least one field that is both a known
-* relation name for `modelName` and a function (a mutation callback).
-*/
-function hasNestedMutationCallbacks(contract, modelName, data) {
-	const relationNames = new Set(getRelationDefinitions(contract, modelName).map((r) => r.relationName));
-	for (const [fieldName, value] of Object.entries(data)) if (relationNames.has(fieldName) && isRelationMutationCallback(value)) return true;
-	return false;
-}
-/**
-* Guards that the executor supports multi-store transactions.
-* Throws a clear error if `transaction()` is not available — the user must
-* use IdbRuntime (createIdbRuntime / createAutoMigratingIdbClient) rather than
-* a plain IdbQueryExecutor stub.
-*/
-function requireTransactionExecutor(executor) {
-	if (typeof executor.transaction !== "function") throw new Error("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;
-}
-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));
-}
-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);
-}
-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;
-}
-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);
-		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 = updated;
-	}
-	for (const item of childOwned) await applyChildOwnedMutation(scope, contract, modelName, parentRow, item.relation, item.mutation, defaultsCache);
-	return parentRow;
-}
-function parseMutationInput(contract, modelName, input) {
-	const scalarData = {};
-	const relationDefs = new Map(getRelationDefinitions(contract, modelName).map((r) => [r.relationName, r]));
-	const relationMutations = [];
-	for (const [fieldName, value] of Object.entries(input)) {
-		const relation = relationDefs.get(fieldName);
-		if (!relation) {
-			scalarData[fieldName] = value;
-			continue;
-		}
-		if (!isRelationMutationCallback(value)) throw new Error(`Relation field "${fieldName}" on model "${modelName}" expects a mutator callback`);
-		const mutation = value(createRelationMutator());
-		if (!isRelationMutationDescriptor(mutation)) throw new Error(`Relation field "${fieldName}" on model "${modelName}" returned an invalid mutation descriptor`);
-		relationMutations.push({
-			relation,
-			mutation
-		});
-	}
-	return {
-		scalarData,
-		relationMutations
-	};
-}
-function partitionByOwnership(mutations) {
-	const parentOwned = [];
-	const childOwned = [];
-	for (const item of mutations) {
-		if (item.relation.cardinality === "N:1") {
-			parentOwned.push(item);
-			continue;
-		}
-		if (item.relation.cardinality === "M:N") throw new Error("M:N nested mutations are not supported");
-		childOwned.push(item);
-	}
-	return {
-		parentOwned,
-		childOwned
-	};
-}
-async function applyParentOwnedMutation(scope, contract, 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);
-}
-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];
-	}
-}
-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 filter = buildCriterionFilter(criterion);
-			const meta = makePlanMeta(contract);
-			await scope.execute({
-				meta,
-				kind: "scan-write",
-				storeName: relation.relatedStoreName,
-				write: "put-merged",
-				patch,
-				filter
-			});
-		}
-		return;
-	}
-	const setValues = {};
-	for (const childField of parentValues.keys()) setValues[childField] = null;
-	const meta = makePlanMeta(contract);
-	if (!mutation.criteria || mutation.criteria.length === 0) {
-		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, relation.relatedStoreName, setValues, defaultsCache);
-		const parentJoinFilter = buildParentJoinFilter(parentValues);
-		await scope.execute({
-			meta,
-			kind: "scan-write",
-			storeName: relation.relatedStoreName,
-			write: "put-merged",
-			patch,
-			filter: parentJoinFilter
-		});
-		return;
-	}
-	for (const criterion of mutation.criteria) {
-		const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, relation.relatedStoreName, setValues, defaultsCache);
-		const criterionFilter = buildCriterionFilter(criterion);
-		const parentJoinFilter = buildParentJoinFilter(parentValues);
-		const combinedFilter = (row) => parentJoinFilter(row) && criterionFilter(row);
-		await scope.execute({
-			meta,
-			kind: "scan-write",
-			storeName: relation.relatedStoreName,
-			write: "put-merged",
-			patch,
-			filter: combinedFilter
-		});
-	}
-}
-function readParentColumnValues(parentModelName, relation, parentRow) {
-	const values = /* @__PURE__ */ new Map();
-	for (let i = 0; i < relation.localFields.length; i++) {
-		const localField = relation.localFields[i];
-		const targetField = relation.targetFields[i];
-		if (!localField || !targetField) continue;
-		const parentValue = parentRow[localField];
-		if (parentValue === void 0) throw new Error(`Nested mutation requires parent field "${localField}" to be present in "${parentModelName}" row`);
-		values.set(targetField, parentValue);
-	}
-	return values;
-}
-async function insertSingleRow(scope, contract, modelName, data, defaultsCache) {
-	assertNoNestedCallbacks(modelName, data);
-	const storeName = getStoreName(contract, modelName);
-	const meta = makePlanMeta(contract);
-	const record = applyCreateDefaults(contract.execution?.mutations.defaults, storeName, data, defaultsCache);
-	assertEnumValues(contract, modelName, 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 in Phase 6.4. Without this guard the callback function would be
-* handed to `store.put(...)`, where IDB's structured-clone throws an opaque
-* `DataCloneError` ("could not be cloned") that gives the developer no hint
-* about the real cause. Surface a precise error instead. (PLAN Issue #22.)
-*/
-function assertNoNestedCallbacks(modelName, data) {
-	for (const [field, value] of Object.entries(data)) if (typeof value === "function") throw new Error(`Recursive nested writes are not supported: field "${field}" on a nested "${modelName}" record is a relation callback. Only one level of relation nesting is supported — flatten the inner relation into a separate create/connect call.`);
-}
-async function findRowByCriterion(scope, contract, modelName, criterion) {
-	const expr = shorthandToFilterExpr(criterion);
-	if (!expr) throw new Error(`Nested connect for model "${modelName}" requires a non-empty criterion`);
-	const filter = (row) => evaluateFilter(expr, row);
-	return scanOneRow(scope, contract, modelName, filter);
-}
-async function findFirstByFilters(scope, contract, modelName, filters) {
-	if (filters.length === 0) return null;
-	const combined = filters.length === 1 ? filters[0] : {
-		kind: "and",
-		exprs: filters
-	};
-	const filter = (row) => evaluateFilter(combined, row);
-	return scanOneRow(scope, contract, modelName, filter);
-}
-async function scanOneRow(scope, contract, modelName, filter) {
-	const storeName = getStoreName(contract, modelName);
-	const plan = {
-		meta: makePlanMeta(contract),
-		kind: "cursor-scan",
-		storeName,
-		filter,
-		take: 1
-	};
-	return (await scope.execute(plan))[0] ?? null;
-}
-function buildCriterionFilter(criterion) {
-	const expr = shorthandToFilterExpr(criterion);
-	if (!expr) return () => true;
-	return (row) => evaluateFilter(expr, row);
-}
-function buildParentJoinFilter(parentValues) {
-	const pairs = [...parentValues.entries()];
-	return (row) => pairs.every(([childField, parentValue]) => fieldValuesEqual(row[childField], parentValue));
-}
-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));
-}
-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;
-}
-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`.
-*/
-async function childExists(scope, meta, def, parentRow) {
-	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`).
-*/
-function buildChildFilterFromRow(def, row) {
-	const pairs = def.localFields.map((lf, i) => ({
-		childField: def.targetFields[i],
-		parentValue: row[lf]
-	}));
-	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) {
-	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();
-	let enforces = false;
-	function walkCascadeChain(mName) {
-		if (visitedModels.has(mName)) return;
-		visitedModels.add(mName);
-		for (const def of getRelationDefinitions(contract, mName)) {
-			if (!isChildEnforcementRelation(contract, mName, def)) continue;
-			const action = getReferentialActionForRelation(contract, mName, def, "onUpdate");
-			stores.add(def.relatedStoreName);
-			if (action === "cascade") walkCascadeChain(def.relatedModelName);
-		}
-	}
-	visitedModels.add(modelName);
-	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") walkCascadeChain(def.relatedModelName);
-	}
-	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);
-	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 (!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 childFilter = buildChildFilterFromRow(def, oldRow);
-		if (action === "restrict") {
-			if (await childExists(scope, 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") {
-			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 scope.execute({
-				meta,
-				kind: "cursor-scan",
-				storeName: def.relatedStoreName,
-				filter: childFilter
-			});
-			for (const child of children) await applyReferentialActionsForRowOnUpdate(scope, contract, def.relatedModelName, child, childPatch, visited);
-			await scope.execute({
-				meta,
-				kind: "scan-write",
-				storeName: def.relatedStoreName,
-				write: "put-merged",
-				patch: childPatch,
-				filter: childFilter
-			});
-			continue;
-		}
-		if (action === "setNull") {
-			const childPatch = {};
-			for (const targetField of def.targetFields) childPatch[targetField] = null;
-			await scope.execute({
-				meta,
-				kind: "scan-write",
-				storeName: def.relatedStoreName,
-				write: "put-merged",
-				patch: childPatch,
-				filter: childFilter
-			});
-			continue;
-		}
-		if (action === "setDefault") {
-			const childPatch = buildSetDefaultPatch(contract, def);
-			await validateSetDefaultPatch(scope, contract, modelName, def, childPatch, extractKeyFromRow(oldRow, keyPath));
-			await scope.execute({
-				meta,
-				kind: "scan-write",
-				storeName: def.relatedStoreName,
-				write: "put-merged",
-				patch: childPatch,
-				filter: childFilter
-			});
-			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;
-}
-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?
-*
-* 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 filter = (row) => fields.every((f, i) => fieldValuesEqual(row[f], values[i])) && (excludeKey === void 0 || !keyEquals$1(extractKeyFromRow(row, keyPath), excludeKey));
-	return (await scope.execute({
-		meta,
-		kind: "cursor-scan",
-		storeName,
-		filter,
-		take: 1
-	})).length > 0;
-}
-/** `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;
-	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;
-	});
-}
-/**
-* 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);
-	const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, patch);
-	const needsRowForFks = fkCheckNeedsExistingRow(contract, modelName, patch);
-	return withMutationScope(executor, storeNames, async (scope) => {
-		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;
-		if (!enforcesOnUpdate && !needsRowForFks) return scope.execute({
-			meta,
-			kind: "scan-write",
-			storeName,
-			write: "put-merged",
-			patch,
-			...take !== void 0 ? { take } : {},
-			...filter !== void 0 ? { filter } : {}
-		});
-		const oldRows = await scope.execute({
-			meta,
-			kind: "cursor-scan",
-			storeName,
-			...take !== void 0 ? { take } : {},
-			...filter !== void 0 ? { filter } : {}
-		});
-		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;
-	});
-}
-/**
-* 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));
-}
-/**
-* 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();
-	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(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 childFilter = buildChildFilterFromRow(def, row);
-		if (action === "restrict") {
-			if (await childExists(scope, 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") {
-			const childKeyPath = getKeyPath(contract, def.relatedModelName);
-			const children = await scope.execute({
-				meta,
-				kind: "cursor-scan",
-				storeName: def.relatedStoreName,
-				filter: childFilter
-			});
-			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 scope.execute({
-				meta,
-				kind: "scan-write",
-				storeName: def.relatedStoreName,
-				write: "put-merged",
-				patch,
-				filter: childFilter
-			});
-			continue;
-		}
-		if (action === "setDefault") {
-			const patch = buildSetDefaultPatch(contract, def);
-			await validateSetDefaultPatch(scope, contract, modelName, def, patch, extractKeyFromRow(row, keyPath));
-			await scope.execute({
-				meta,
-				kind: "scan-write",
-				storeName: def.relatedStoreName,
-				write: "put-merged",
-				patch,
-				filter: childFilter
-			});
-			continue;
-		}
-	}
-}
-async function executeDeleteWithReferentialActions(options) {
-	const { executor, contract, modelName, key } = options;
-	await withMutationScope(executor, collectDeleteStoreNames(contract, modelName), async (scope) => {
-		const storeName = getStoreName(contract, modelName);
-		const meta = makePlanMeta(contract);
-		const row = (await scope.execute({
-			meta,
-			kind: "key-get",
-			storeName,
-			key
-		}))[0];
-		if (!row) return [];
-		await applyReferentialActionsForRow(scope, contract, modelName, row);
-		await scope.execute({
-			meta,
-			kind: "delete",
-			storeName,
-			key
-		});
-		return [];
-	});
-}
-async function executeDeleteAllWithReferentialActions(options) {
-	const { executor, contract, modelName, filter } = options;
-	return withMutationScope(executor, collectDeleteStoreNames(contract, modelName), async (scope) => {
-		const storeName = getStoreName(contract, modelName);
-		const meta = makePlanMeta(contract);
-		const keyPath = getKeyPath(contract, modelName);
-		const rows = await scope.execute({
-			meta,
-			kind: "cursor-scan",
-			storeName,
-			...filter !== void 0 ? { filter } : {}
-		});
-		for (const row of rows) {
-			await applyReferentialActionsForRow(scope, contract, modelName, row);
-			const key = extractKeyFromRow(row, keyPath);
-			await scope.execute({
-				meta,
-				kind: "delete",
-				storeName,
-				key
-			});
-		}
-		return rows;
-	});
-}
-//#endregion
-export { keyToken as A, assertEnumValues as C, getRelation as D, getKeyPath as E, getStoreName as O, createMutationDefaultsCache as S, fieldValueToken as T, requireTransactionExecutor as _, collectScalarFkStoreNames as a, applyCreateDefaults as b, executeDeleteWithReferentialActions as c, executeScalarCreateAllWithFkValidation as d, executeScalarCreateWithFkValidation as f, hasScalarFkFields as g, hasNestedMutationCallbacks as h, collectOnUpdateEnforcementStoreNames as i, keyEquals$1 as k, executeNestedCreateMutation as l, hasEnforceableChildRelations as m, applyReferentialActionsForRowOnUpdate as n, executeBulkUpdateWithFkValidation as o, executeScalarUpdateWithFkValidation as p, collectDeleteStoreNames as r, executeDeleteAllWithReferentialActions as s, applyReferentialActionsForRow as t, executeNestedUpdateMutation as u, validateScalarFks as v, extractKeyFromRow as w, applyUpdateDefaults as x, withMutationScope as y };
-
-//# sourceMappingURL=mutation-executor-SJqTuSbb.mjs.map