@nkzw/fate 1.3.2 → 1.4.0

package/lib/index.mjs

@@ -4,7 +4,8 @@ import { t as getListEntries } from "./list-_6fXYLtJ.mjs";
 import { n as graphqlMutation, t as createGraphQLTransport } from "./graphqlTransport-DSBVS2Fq.mjs";
 //#region src/cache.ts
 var ViewDataCache = class {
-	constructor() {
+	constructor(isEnabled = () => true) {
+		this.isEnabled = isEnabled;
 		this.cache = /* @__PURE__ */ new Map();
 		this.rootDependencies = /* @__PURE__ */ new Map();
 		this.dependencyIndex = /* @__PURE__ */ new Map();
@@ -15,9 +16,11 @@ var ViewDataCache = class {
 		this.dependencyIndex.clear();
 	}
 	get(entityId, view, ref) {
+		if (!this.isEnabled()) return null;
 		return this.cache.get(entityId)?.get(view)?.get(ref) ?? null;
 	}
 	set(entityId, view, ref, thenable, dependencies) {
+		if (!this.isEnabled()) return;
 		let entityMap = this.cache.get(entityId);
 		if (!entityMap) {
 			entityMap = /* @__PURE__ */ new WeakMap();
@@ -45,6 +48,7 @@ var ViewDataCache = class {
 		}
 	}
 	invalidate(entityId) {
+		if (!this.isEnabled()) return;
 		this.invalidateDependents(entityId, /* @__PURE__ */ new Set());
 	}
 	invalidateDependents(entityId, visited) {
@@ -351,94 +355,7 @@ const decodeClientHydrationState = (value, limits) => {
 	return decoded;
 };
 //#endregion
-//#region src/mask.ts
-function emptyMask() {
-	return {
-		all: false,
-		children: /* @__PURE__ */ new Map()
-	};
-}
-function cloneMask(m) {
-	const clone = {
-		all: m.all,
-		children: /* @__PURE__ */ new Map()
-	};
-	for (const [key, value] of m.children) clone.children.set(key, cloneMask(value));
-	return clone;
-}
-function addPath(mask, path) {
-	if (mask.all) return;
-	const parts = path.split(".");
-	let current = mask;
-	for (let i = 0; i < parts.length; i++) {
-		const seg = parts[i];
-		let child = current.children.get(seg);
-		if (!child) {
-			child = emptyMask();
-			current.children.set(seg, child);
-		}
-		current = child;
-	}
-	current.all = true;
-	current.children.clear();
-}
-function union(into, b) {
-	if (into.all || b.all) {
-		into.all = true;
-		into.children.clear();
-		return;
-	}
-	for (const [key, child] of b.children) {
-		const exist = into.children.get(key);
-		if (!exist) into.children.set(key, cloneMask(child));
-		else union(exist, child);
-	}
-}
-function fromPaths(paths) {
-	const mask = emptyMask();
-	for (const path of paths) addPath(mask, path);
-	return mask;
-}
-function toPaths(mask) {
-	const paths = [];
-	const visit = (current, prefix) => {
-		if (current.all) {
-			if (prefix) paths.push(prefix);
-			return;
-		}
-		for (const [key, child] of current.children) visit(child, prefix ? `${prefix}.${key}` : key);
-	};
-	visit(mask, null);
-	return paths;
-}
-function isCovered(mask, path) {
-	if (mask.all) return true;
-	const parts = path.split(".");
-	let current = mask;
-	for (let i = 0; i < parts.length; i++) {
-		if (!current) return false;
-		if (current.all) return true;
-		current = current.children.get(parts[i]);
-	}
-	return !!current && (current.all || current.children.size === 0);
-}
-function diffPaths(paths, mask) {
-	const missing = /* @__PURE__ */ new Set();
-	for (const path of paths) if (!isCovered(mask, path)) missing.add(path);
-	return missing;
-}
-function intersects(a, b) {
-	if (a.all || b.all) return true;
-	for (const [key, child] of a.children) {
-		const otherChild = b.children.get(key);
-		if (!otherChild) continue;
-		if (child.all || otherChild.all) return true;
-		if (intersects(child, otherChild)) return true;
-	}
-	return false;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@trpc+server@11.18.0_typescript@6.0.3/node_modules/@trpc/server/dist/getErrorShape-BPSzUA7W.mjs
+//#region ../../node_modules/.pnpm/@trpc+server@11.18.0_typescript@7.0.2/node_modules/@trpc/server/dist/getErrorShape-BPSzUA7W.mjs
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -828,38 +745,37 @@ function wrapMutation(client, identifier) {
 		} : optimistic : void 0;
 		const optimisticRecordId = optimisticRecord !== void 0 ? maybeGetId(config.getId, optimisticRecord) : null;
 		const optimisticEntityId = id != null ? toEntityId(identifier.entity, id) : optimisticRecordId != null ? toEntityId(identifier.entity, optimisticRecordId) : null;
-		const snapshots = /* @__PURE__ */ new Map();
-		const listSnapshots = deleteRecord || optimisticRecord ? /* @__PURE__ */ new Map() : void 0;
 		const optimisticSelection = optimisticRecord ? collectImplicitSelectedPaths(optimisticRecord) : void 0;
 		const selection = viewSelection || optimisticSelection ? /* @__PURE__ */ new Set([...viewSelection ? [...viewSelection] : [], ...optimisticSelection ? [...optimisticSelection] : []]) : /* @__PURE__ */ new Set();
 		if (deleteRecord && id == null) throw new Error(`fate: Mutation '${identifier.key}' requires an 'id' to delete.`);
-		const optimisticToken = optimisticEntityId ? client.registerOptimisticUpdate(optimisticEntityId, optimisticSelection ?? emptySet$1) : null;
-		if (optimisticRecord && optimisticEntityId) client.write(identifier.entity, optimisticRecord, optimisticSelection ?? emptySet$1, snapshots, plan, null, null, insert, listSnapshots);
-		if (deleteRecord && id != null) client.deleteRecord(identifier.entity, id, snapshots, listSnapshots);
+		const applyOptimistic = () => {
+			if (optimisticRecord && optimisticEntityId) client.write(identifier.entity, optimisticRecord, optimisticSelection ?? emptySet$1, plan, insert);
+			if (deleteRecord && id != null) client.deleteRecord(identifier.entity, id);
+		};
+		const settle = client.store.optimisticUpdate(applyOptimistic);
 		const performMutation = async () => {
 			try {
 				const result = await client.executeMutation(identifier.key, input, selection, {
 					args,
 					plan
 				});
-				if (result && typeof result === "object" && (!deleteRecord || Boolean(view))) {
-					const select = collectImplicitSelectedPaths(result);
-					const pendingMask = optimisticEntityId ? client.getPendingOptimisticMask(optimisticEntityId, { excludeToken: optimisticToken }) : null;
-					const filteredSelection = optimisticEntityId ? client.filterSelectionForPendingOptimistics(optimisticEntityId, select, { excludeToken: optimisticToken }) : select;
-					client.write(identifier.entity, result, filteredSelection, void 0, plan, null, pendingMask, insert);
+				const shouldWriteResult = result && typeof result === "object" && (!deleteRecord || Boolean(view));
+				settle(() => {
+					if (shouldWriteResult) {
+						const select = collectImplicitSelectedPaths(result);
+						client.write(identifier.entity, result, select, plan, insert);
+						const resultId = maybeGetId(config.getId, result);
+						if (optimisticEntityId && resultId != null) client.resolveOptimisticEntity(optimisticEntityId, toEntityId(identifier.entity, resultId));
+						if (optimisticRecordId != null && resultId != null && optimisticRecordId !== resultId) client.deleteRecord(identifier.entity, optimisticRecordId);
+					}
 					if (deleteRecord && id != null) client.deleteRecord(identifier.entity, id);
-					const resultId = maybeGetId(config.getId, result);
-					if (optimisticEntityId && resultId != null) client.resolveOptimisticEntity(optimisticEntityId, toEntityId(identifier.entity, resultId));
-					if (optimisticRecordId != null && resultId != null && optimisticRecordId !== resultId) client.deleteRecord(identifier.entity, optimisticRecordId);
-				}
+				});
 				return {
 					error: void 0,
 					result
 				};
 			} catch (error) {
-				client.clearOptimisticUpdate(optimisticToken);
-				if (snapshots.size > 0) for (const [id, snapshot] of snapshots) client.restore(id, snapshot);
-				if (listSnapshots && listSnapshots.size > 0) for (const [name, list] of listSnapshots) client.restoreList(name, list);
+				settle();
 				if (error instanceof Error) {
 					const statusCode = getErrorStatusCode(error);
 					if ((statusCode ? categorizeHTTPErrorStatus(statusCode) : "boundary") === "boundary") throw error;
@@ -867,9 +783,7 @@ function wrapMutation(client, identifier) {
 						error,
 						result: void 0
 					};
-				} else throw new Error(`fate: Mutation '${identifier.key}' failed.`);
-			} finally {
-				client.clearOptimisticUpdate(optimisticToken);
+				} else throw new Error(`fate: Mutation '${identifier.key}' failed.`, { cause: error });
 			}
 		};
 		const mutationPromise = client.trackPendingRequest(performMutation);
@@ -956,6 +870,93 @@ var OperationLifetime = class {
 	}
 };
 //#endregion
+//#region src/mask.ts
+function emptyMask() {
+	return {
+		all: false,
+		children: /* @__PURE__ */ new Map()
+	};
+}
+function cloneMask(m) {
+	const clone = {
+		all: m.all,
+		children: /* @__PURE__ */ new Map()
+	};
+	for (const [key, value] of m.children) clone.children.set(key, cloneMask(value));
+	return clone;
+}
+function addPath(mask, path) {
+	if (mask.all) return;
+	const parts = path.split(".");
+	let current = mask;
+	for (let i = 0; i < parts.length; i++) {
+		const seg = parts[i];
+		let child = current.children.get(seg);
+		if (!child) {
+			child = emptyMask();
+			current.children.set(seg, child);
+		}
+		current = child;
+	}
+	current.all = true;
+	current.children.clear();
+}
+function union(into, b) {
+	if (into.all || b.all) {
+		into.all = true;
+		into.children.clear();
+		return;
+	}
+	for (const [key, child] of b.children) {
+		const exist = into.children.get(key);
+		if (!exist) into.children.set(key, cloneMask(child));
+		else union(exist, child);
+	}
+}
+function fromPaths(paths) {
+	const mask = emptyMask();
+	for (const path of paths) addPath(mask, path);
+	return mask;
+}
+function toPaths(mask) {
+	const paths = [];
+	const visit = (current, prefix) => {
+		if (current.all) {
+			if (prefix) paths.push(prefix);
+			return;
+		}
+		for (const [key, child] of current.children) visit(child, prefix ? `${prefix}.${key}` : key);
+	};
+	visit(mask, null);
+	return paths;
+}
+function isCovered(mask, path) {
+	if (mask.all) return true;
+	const parts = path.split(".");
+	let current = mask;
+	for (let i = 0; i < parts.length; i++) {
+		if (!current) return false;
+		if (current.all) return true;
+		current = current.children.get(parts[i]);
+	}
+	return !!current && (current.all || current.children.size === 0);
+}
+function diffPaths(paths, mask) {
+	const missing = /* @__PURE__ */ new Set();
+	for (const path of paths) if (!isCovered(mask, path)) missing.add(path);
+	return missing;
+}
+function intersects(a, b) {
+	if (a.all || b.all) return true;
+	for (const [key, child] of a.children) {
+		const otherChild = b.children.get(key);
+		if (!otherChild) continue;
+		if (child.all || otherChild.all) return true;
+		if (intersects(child, otherChild)) return true;
+	}
+	return false;
+}
+//#endregion
 //#region src/store.ts
 const listKeySeparator = " __fate__ ";
 const decodeListKeyPart = (part) => {
@@ -977,16 +978,6 @@ const parseListKey = (key) => {
 		ownerId: decodeListKeyPart(ownerId)
 	};
 };
-const cloneValue = (value) => {
-	if (Array.isArray(value)) return value.map(cloneValue);
-	if (isNodeRef(value)) return value;
-	if (value != null && typeof value === "object") {
-		const result = {};
-		for (const [key, record] of Object.entries(value)) result[key] = cloneValue(record);
-		return result;
-	}
-	return value;
-};
 const isPlainRecord = (value) => {
 	if (value == null || typeof value !== "object" || Array.isArray(value) || isNodeRef(value)) return false;
 	const prototype = Object.getPrototypeOf(value);
@@ -1021,14 +1012,17 @@ const areHydrationValuesEqual = (left, right) => {
 	return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(right, key) && areHydrationValuesEqual(left[key], right[key]));
 };
 const areMasksEqual = (left, right) => {
-	if (!left || !right) return left === right;
-	const leftPaths = toPaths(left).sort();
-	const rightPaths = toPaths(right).sort();
-	return leftPaths.length === rightPaths.length && leftPaths.every((path, index) => path === rightPaths[index]);
+	if (left === right || left?.all && right?.all) return true;
+	if (!left || !right || left.all !== right.all || left.children.size !== right.children.size) return false;
+	for (const [key, child] of left.children) if (!areMasksEqual(child, right.children.get(key))) return false;
+	return true;
 };
 const emptyFunction = () => {};
+const hasReferences = (value) => isNodeRef(value) || Array.isArray(value) && value.some(isNodeRef);
+const areNormalizedValuesEqual = (left, right) => Object.is(left, right) || isNodeRef(left) && isNodeRef(right) && getNodeRefId(left) === getNodeRefId(right) || Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => areNormalizedValuesEqual(value, right[index]));
 var Store = class {
-	constructor() {
+	constructor(onRebase) {
+		this.onRebase = onRebase;
 		this.coverage = /* @__PURE__ */ new Map();
 		this.listKeysByOwnerField = /* @__PURE__ */ new Map();
 		this.listKeysByReferencedEntity = /* @__PURE__ */ new Map();
@@ -1038,6 +1032,142 @@ var Store = class {
 		this.records = /* @__PURE__ */ new Map();
 		this.subscriptions = /* @__PURE__ */ new Map();
 		this.listSubscriptions = /* @__PURE__ */ new Map();
+		this.optimisticLayers = /* @__PURE__ */ new Set();
+		this.optimisticBase = {
+			lists: /* @__PURE__ */ new Map(),
+			records: /* @__PURE__ */ new Map()
+		};
+	}
+	get hasOptimisticUpdates() {
+		return this.optimisticLayers.size > 0;
+	}
+	get isRebasing() {
+		return this.rebase !== void 0;
+	}
+	/** Apply a synchronous cache update beneath the pending optimistic layers. */
+	update(apply) {
+		if (this.rebase || this.optimisticLayers.size === 0) return apply();
+		const rebase = {
+			lists: /* @__PURE__ */ new Map(),
+			records: /* @__PURE__ */ new Map()
+		};
+		this.rebase = rebase;
+		try {
+			for (const [id, snapshot] of this.optimisticBase.records) this.restore(id, snapshot);
+			for (const [key, list] of this.optimisticBase.lists) this.restoreList(key, list);
+			this.optimisticBase.records.clear();
+			this.optimisticBase.lists.clear();
+			return apply();
+		} finally {
+			try {
+				for (const layer of this.optimisticLayers) {
+					layer.writes.clear();
+					this.recordingLayer = layer;
+					layer.apply();
+				}
+			} finally {
+				this.recordingLayer = void 0;
+				const records = this.getRebaseChanges(rebase);
+				const lists = /* @__PURE__ */ new Set();
+				for (const [key, before] of rebase.lists) if (!areHydrationValuesEqual(before, this.lists.get(key))) {
+					lists.add(key);
+					const owner = parseListKey(key);
+					if (owner) {
+						if (!records.has(owner.ownerId)) records.set(owner.ownerId, /* @__PURE__ */ new Set([owner.field]));
+						else records.get(owner.ownerId)?.add(owner.field);
+					}
+				} else if (before) this.lists.set(key, before);
+				this.rebase = void 0;
+				this.onRebase?.(new Set(records.keys()));
+				for (const [id, paths] of records) this.notify(id, paths);
+				for (const key of lists) this.notifyListSubscribers(key);
+			}
+		}
+	}
+	getRebaseChanges(rebase) {
+		const changes = /* @__PURE__ */ new Map();
+		for (const [id, before] of rebase.records) {
+			const after = this.records.get(id);
+			const mask = this.coverage.get(id);
+			if (Boolean(before.record) !== Boolean(after) || before.mask?.all !== mask?.all) {
+				changes.set(id, void 0);
+				continue;
+			}
+			const paths = /* @__PURE__ */ new Set();
+			for (const key of /* @__PURE__ */ new Set([...Object.keys(before.record ?? {}), ...Object.keys(after ?? {})])) if (Object.hasOwn(before.record ?? {}, key) !== Object.hasOwn(after ?? {}, key) || !areNormalizedValuesEqual(before.record?.[key], after?.[key])) paths.add(key);
+			if (!areMasksEqual(before.mask, mask)) {
+				for (const path of before.mask ? toPaths(before.mask) : []) if (!mask || !isCovered(mask, path)) paths.add(path);
+				for (const path of mask ? toPaths(mask) : []) if (!before.mask || !isCovered(before.mask, path)) paths.add(path);
+			}
+			if (paths.size > 0) changes.set(id, paths);
+			else if (before.record) this.records.set(id, before.record);
+		}
+		return changes;
+	}
+	/** Returns an idempotent settlement function; omit its update to roll back. */
+	optimisticUpdate(apply) {
+		const layer = {
+			apply,
+			writes: /* @__PURE__ */ new Map()
+		};
+		const settle = (commit) => {
+			if (!this.optimisticLayers.has(layer) || layer.settled) return;
+			this.update(() => {
+				const overlays = commit ? this.getPendingOverlap(layer, layer.writes) : /* @__PURE__ */ new Map();
+				if (overlays.size > 0) {
+					layer.settled = true;
+					layer.apply = () => {
+						for (const [id, { partial, paths }] of this.getPendingOverlap(layer, overlays)) this.merge(id, partial, paths);
+					};
+				} else this.optimisticLayers.delete(layer);
+				for (const pending of this.optimisticLayers) {
+					if (!pending.settled) break;
+					this.optimisticLayers.delete(pending);
+				}
+				commit?.();
+			});
+		};
+		this.optimisticLayers.add(layer);
+		try {
+			this.update(() => {});
+		} catch (error) {
+			settle();
+			throw error;
+		}
+		return settle;
+	}
+	getPendingOverlap(layer, writes) {
+		const earlier = [];
+		for (const pending of this.optimisticLayers) {
+			if (pending === layer) break;
+			if (!pending.settled) earlier.push(pending);
+		}
+		const overlaps = /* @__PURE__ */ new Map();
+		for (const [id, write] of writes) {
+			const partial = Object.fromEntries(Object.entries(write.partial).filter(([key, value]) => !hasReferences(value) && earlier.some(({ writes }) => {
+				const previous = writes.get(id)?.partial;
+				return previous && Object.hasOwn(previous, key) && !hasReferences(previous[key]);
+			})));
+			if (Object.keys(partial).length) overlaps.set(id, {
+				partial,
+				paths: new Set([...write.paths].filter((path) => Object.hasOwn(partial, path.split(".")[0])))
+			});
+		}
+		return overlaps;
+	}
+	captureRecord(id) {
+		if (!this.rebase) return;
+		for (const target of [this.rebase, this.recordingLayer && this.optimisticBase]) if (target && !target.records.has(id)) {
+			const mask = this.coverage.get(id);
+			target.records.set(id, {
+				mask: mask ? cloneMask(mask) : void 0,
+				record: this.records.get(id)
+			});
+		}
+	}
+	captureList(key) {
+		if (!this.rebase) return;
+		for (const target of [this.rebase, this.recordingLayer && this.optimisticBase]) if (target && !target.lists.has(key)) target.lists.set(key, this.lists.get(key));
 	}
 	dehydrate() {
 		return {
@@ -1095,10 +1225,23 @@ var Store = class {
 		return this.records.get(id);
 	}
 	merge(id, partial, paths) {
-		const changedPaths = this.mergeInternal(id, partial, paths);
-		if (changedPaths) this.notify(id, changedPaths);
+		return this.update(() => {
+			const changedPaths = this.mergeInternal(id, partial, paths);
+			if (changedPaths) this.notify(id, changedPaths);
+		});
 	}
 	mergeInternal(id, partial, paths) {
+		this.captureRecord(id);
+		const selectedPaths = this.recordingLayer ? new Set(paths) : paths;
+		if (this.recordingLayer) {
+			const write = this.recordingLayer.writes.get(id) ?? {
+				partial: {},
+				paths: /* @__PURE__ */ new Set()
+			};
+			Object.assign(write.partial, partial);
+			for (const path of selectedPaths) write.paths.add(path);
+			this.recordingLayer.writes.set(id, write);
+		}
 		const previous = this.records.get(id);
 		const changedPaths = /* @__PURE__ */ new Set();
 		let mask = this.coverage.get(id);
@@ -1106,7 +1249,7 @@ var Store = class {
 			mask = emptyMask();
 			this.coverage.set(id, mask);
 		}
-		union(mask, fromPaths(paths));
+		union(mask, fromPaths(selectedPaths));
 		if (previous) {
 			let hasChanges = false;
 			for (const [key, value] of Object.entries(partial)) if (previous[key] !== value) {
@@ -1128,10 +1271,13 @@ var Store = class {
 		return changedPaths;
 	}
 	deleteRecord(id) {
-		const record = this.records.get(id);
-		if (record) this.removeRecordReferenceIndexes(id, record);
-		this.records.delete(id);
-		this.coverage.delete(id);
+		return this.update(() => {
+			this.captureRecord(id);
+			const record = this.records.get(id);
+			if (record) this.removeRecordReferenceIndexes(id, record);
+			this.records.delete(id);
+			this.coverage.delete(id);
+		});
 	}
 	missingForSelection(id, paths) {
 		const requested = new Set(paths);
@@ -1166,6 +1312,7 @@ var Store = class {
 		};
 	}
 	notify(id, paths) {
+		if (this.rebase) return;
 		const set = this.subscriptions.get(id);
 		if (!set) return;
 		const changedPaths = paths ? [...paths] : [];
@@ -1178,6 +1325,7 @@ var Store = class {
 		}
 	}
 	notifyListSubscribers(key) {
+		if (this.rebase) return;
 		const set = this.listSubscriptions.get(key);
 		if (!set) return;
 		for (const fn of set) try {
@@ -1201,70 +1349,77 @@ var Store = class {
 		return entries;
 	}
 	setList(key, state) {
-		const previous = this.lists.get(key);
-		if (previous) this.removeListIndexes(key, previous);
-		this.lists.set(key, state);
-		this.addListIndexes(key, state);
-		this.notifyListSubscribers(key);
+		return this.update(() => {
+			this.captureList(key);
+			const previous = this.lists.get(key);
+			if (previous) this.removeListIndexes(key, previous);
+			this.lists.set(key, state);
+			this.addListIndexes(key, state);
+			this.notifyListSubscribers(key);
+		});
 	}
 	replaceListEntityId(previousId, nextId) {
-		const keys = [...this.listKeysByReferencedEntity.get(previousId) ?? []];
-		for (const key of keys) {
-			const list = this.lists.get(key);
-			if (!list) continue;
-			let changed = false;
-			let ids = list.ids;
-			let cursors = list.cursors;
-			if (list.ids.includes(previousId)) {
-				const nextIds = [];
-				const nextCursors = list.cursors ? [] : void 0;
-				const seenIds = /* @__PURE__ */ new Set();
-				list.ids.forEach((id, index) => {
-					const resolved = id === previousId ? nextId : id;
-					if (seenIds.has(resolved)) return;
-					seenIds.add(resolved);
-					nextIds.push(resolved);
-					if (nextCursors) nextCursors.push(list.cursors?.[index]);
+		return this.update(() => {
+			const keys = [...this.listKeysByReferencedEntity.get(previousId) ?? []];
+			for (const key of keys) {
+				const list = this.lists.get(key);
+				if (!list) continue;
+				let changed = false;
+				let ids = list.ids;
+				let cursors = list.cursors;
+				if (list.ids.includes(previousId)) {
+					const nextIds = [];
+					const nextCursors = list.cursors ? [] : void 0;
+					const seenIds = /* @__PURE__ */ new Set();
+					list.ids.forEach((id, index) => {
+						const resolved = id === previousId ? nextId : id;
+						if (seenIds.has(resolved)) return;
+						seenIds.add(resolved);
+						nextIds.push(resolved);
+						if (nextCursors) nextCursors.push(list.cursors?.[index]);
+					});
+					changed = true;
+					ids = nextIds;
+					cursors = nextCursors;
+				}
+				const dedupe = (values) => {
+					if (!values || !values.includes(previousId)) return;
+					const seen = /* @__PURE__ */ new Set();
+					const next = [];
+					for (const value of values) {
+						const resolved = value === previousId ? nextId : value;
+						if (seen.has(resolved)) continue;
+						seen.add(resolved);
+						next.push(resolved);
+					}
+					changed = true;
+					return next;
+				};
+				const pendingBeforeIds = dedupe(list.pendingBeforeIds) ?? list.pendingBeforeIds;
+				const pendingAfterIds = dedupe(list.pendingAfterIds) ?? list.pendingAfterIds;
+				const liveBeforeIds = dedupe(list.liveBeforeIds) ?? list.liveBeforeIds;
+				const liveAfterIds = dedupe(list.liveAfterIds) ?? list.liveAfterIds;
+				if (!changed) continue;
+				const canonicalIds = new Set(ids);
+				this.setList(key, {
+					backwardPageLimit: list.backwardPageLimit,
+					cursors,
+					forwardPageLimit: list.forwardPageLimit,
+					ids,
+					liveAfterIds: liveAfterIds?.filter((id) => !canonicalIds.has(id)),
+					liveBeforeIds: liveBeforeIds?.filter((id) => !canonicalIds.has(id)),
+					pagination: list.pagination,
+					pendingAfterIds: pendingAfterIds?.filter((id) => !canonicalIds.has(id)),
+					pendingBeforeIds: pendingBeforeIds?.filter((id) => !canonicalIds.has(id))
 				});
-				changed = true;
-				ids = nextIds;
-				cursors = nextCursors;
 			}
-			const dedupe = (values) => {
-				if (!values || !values.includes(previousId)) return;
-				const seen = /* @__PURE__ */ new Set();
-				const next = [];
-				for (const value of values) {
-					const resolved = value === previousId ? nextId : value;
-					if (seen.has(resolved)) continue;
-					seen.add(resolved);
-					next.push(resolved);
-				}
-				changed = true;
-				return next;
-			};
-			const pendingBeforeIds = dedupe(list.pendingBeforeIds) ?? list.pendingBeforeIds;
-			const pendingAfterIds = dedupe(list.pendingAfterIds) ?? list.pendingAfterIds;
-			const liveBeforeIds = dedupe(list.liveBeforeIds) ?? list.liveBeforeIds;
-			const liveAfterIds = dedupe(list.liveAfterIds) ?? list.liveAfterIds;
-			if (!changed) continue;
-			const canonicalIds = new Set(ids);
-			this.setList(key, {
-				backwardPageLimit: list.backwardPageLimit,
-				cursors,
-				forwardPageLimit: list.forwardPageLimit,
-				ids,
-				liveAfterIds: liveAfterIds?.filter((id) => !canonicalIds.has(id)),
-				liveBeforeIds: liveBeforeIds?.filter((id) => !canonicalIds.has(id)),
-				pagination: list.pagination,
-				pendingAfterIds: pendingAfterIds?.filter((id) => !canonicalIds.has(id)),
-				pendingBeforeIds: pendingBeforeIds?.filter((id) => !canonicalIds.has(id))
-			});
-		}
+		});
 	}
 	restoreList(key, list) {
-		if (list == null) this.deleteList(key);
-		else this.setList(key, list);
+		return this.update(() => {
+			if (list == null) this.deleteList(key);
+			else this.setList(key, list);
+		});
 	}
 	collectGarbage(markedRecords, markedLists, options = {}) {
 		const records = /* @__PURE__ */ new Set();
@@ -1291,10 +1446,13 @@ var Store = class {
 		};
 	}
 	deleteList(key) {
-		const previous = this.lists.get(key);
-		if (previous) this.removeListIndexes(key, previous);
-		this.lists.delete(key);
-		this.notifyListSubscribers(key);
+		return this.update(() => {
+			this.captureList(key);
+			const previous = this.lists.get(key);
+			if (previous) this.removeListIndexes(key, previous);
+			this.lists.delete(key);
+			this.notifyListSubscribers(key);
+		});
 	}
 	subscribeList(key, fn) {
 		let set = this.listSubscriptions.get(key);
@@ -1310,88 +1468,83 @@ var Store = class {
 			if (subscribers.size === 0) this.listSubscriptions.delete(key);
 		};
 	}
-	removeReferencesTo(targetId, viewDataCache, snapshots, listSnapshots) {
-		const listKeys = [...this.listKeysByReferencedEntity.get(targetId) ?? []];
-		for (const key of listKeys) {
-			const list = this.lists.get(key);
-			if (!list) continue;
-			const { ids } = list;
-			const hasLiveAfter = Boolean(list.liveAfterIds?.includes(targetId));
-			const hasLiveBefore = Boolean(list.liveBeforeIds?.includes(targetId));
-			const hasPendingAfter = Boolean(list.pendingAfterIds?.includes(targetId));
-			const hasPendingBefore = Boolean(list.pendingBeforeIds?.includes(targetId));
-			if (!ids.includes(targetId) && !hasLiveAfter && !hasLiveBefore && !hasPendingAfter && !hasPendingBefore) continue;
-			if (listSnapshots && !listSnapshots.has(key)) listSnapshots.set(key, list);
-			const entityIds = [];
-			const cursors = list.cursors ? [] : void 0;
-			for (let index = 0; index < ids.length; index++) {
-				const id = ids[index];
-				if (id === targetId) continue;
-				entityIds.push(id);
-				if (cursors) cursors.push(list.cursors?.[index]);
+	removeReferencesTo(targetId, viewDataCache) {
+		return this.update(() => {
+			const listKeys = [...this.listKeysByReferencedEntity.get(targetId) ?? []];
+			for (const key of listKeys) {
+				const list = this.lists.get(key);
+				if (!list) continue;
+				const { ids } = list;
+				const hasLiveAfter = Boolean(list.liveAfterIds?.includes(targetId));
+				const hasLiveBefore = Boolean(list.liveBeforeIds?.includes(targetId));
+				const hasPendingAfter = Boolean(list.pendingAfterIds?.includes(targetId));
+				const hasPendingBefore = Boolean(list.pendingBeforeIds?.includes(targetId));
+				if (!ids.includes(targetId) && !hasLiveAfter && !hasLiveBefore && !hasPendingAfter && !hasPendingBefore) continue;
+				const entityIds = [];
+				const cursors = list.cursors ? [] : void 0;
+				for (let index = 0; index < ids.length; index++) {
+					const id = ids[index];
+					if (id === targetId) continue;
+					entityIds.push(id);
+					if (cursors) cursors.push(list.cursors?.[index]);
+				}
+				this.setList(key, {
+					backwardPageLimit: list.backwardPageLimit,
+					cursors,
+					forwardPageLimit: list.forwardPageLimit,
+					ids: entityIds,
+					liveAfterIds: list.liveAfterIds?.filter((id) => id !== targetId),
+					liveBeforeIds: list.liveBeforeIds?.filter((id) => id !== targetId),
+					pagination: list.pagination,
+					pendingAfterIds: list.pendingAfterIds?.filter((id) => id !== targetId),
+					pendingBeforeIds: list.pendingBeforeIds?.filter((id) => id !== targetId)
+				});
 			}
-			this.setList(key, {
-				backwardPageLimit: list.backwardPageLimit,
-				cursors,
-				forwardPageLimit: list.forwardPageLimit,
-				ids: entityIds,
-				liveAfterIds: list.liveAfterIds?.filter((id) => id !== targetId),
-				liveBeforeIds: list.liveBeforeIds?.filter((id) => id !== targetId),
-				pagination: list.pagination,
-				pendingAfterIds: list.pendingAfterIds?.filter((id) => id !== targetId),
-				pendingBeforeIds: list.pendingBeforeIds?.filter((id) => id !== targetId)
-			});
-		}
-		const ids = /* @__PURE__ */ new Map();
-		const recordEntries = [...this.recordReferencesByTarget.get(targetId)?.entries() ?? []];
-		for (const [id, fields] of recordEntries) {
-			const record = this.records.get(id);
-			if (!record) continue;
-			let updated = false;
-			const next = {};
-			const paths = /* @__PURE__ */ new Set();
-			for (const key of fields) {
-				const value = record[key];
-				if (Array.isArray(value)) {
-					const filtered = value.filter((item) => !(isNodeRef(item) && getNodeRefId(item) === targetId));
-					if (filtered.length !== value.length) {
+			const ids = /* @__PURE__ */ new Map();
+			const recordEntries = [...this.recordReferencesByTarget.get(targetId)?.entries() ?? []];
+			for (const [id, fields] of recordEntries) {
+				const record = this.records.get(id);
+				if (!record) continue;
+				let updated = false;
+				const next = {};
+				const paths = /* @__PURE__ */ new Set();
+				for (const key of fields) {
+					const value = record[key];
+					if (Array.isArray(value)) {
+						const filtered = value.filter((item) => !(isNodeRef(item) && getNodeRefId(item) === targetId));
+						if (filtered.length !== value.length) {
+							updated = true;
+							paths.add(key);
+							next[key] = filtered;
+						}
+					} else if (isNodeRef(value) && getNodeRefId(value) === targetId) {
 						updated = true;
 						paths.add(key);
-						next[key] = filtered;
+						next[key] = null;
 					}
-				} else if (isNodeRef(value) && getNodeRefId(value) === targetId) {
-					updated = true;
-					paths.add(key);
-					next[key] = null;
 				}
+				if (!updated) continue;
+				viewDataCache.invalidate(id);
+				this.mergeInternal(id, next, paths);
+				ids.set(id, paths);
 			}
-			if (!updated) continue;
-			if (snapshots && !snapshots.has(id)) snapshots.set(id, this.snapshot(id));
-			viewDataCache.invalidate(id);
-			this.mergeInternal(id, next, paths);
-			ids.set(id, paths);
-		}
-		for (const [id, paths] of ids) this.notify(id, paths);
-	}
-	snapshot(id) {
-		const record = this.records.get(id);
-		const mask = this.coverage.get(id);
-		return {
-			mask: mask ? cloneMask(mask) : void 0,
-			record: record ? cloneValue(record) : void 0
-		};
+			for (const [id, paths] of ids) this.notify(id, paths);
+		});
 	}
 	restore(id, snapshot) {
-		const previous = this.records.get(id);
-		if (previous) this.removeRecordReferenceIndexes(id, previous);
-		if (snapshot.record === void 0) this.records.delete(id);
-		else {
-			this.records.set(id, snapshot.record);
-			this.addRecordReferenceIndexes(id, snapshot.record);
-		}
-		if (snapshot.mask === void 0) this.coverage.delete(id);
-		else this.coverage.set(id, snapshot.mask);
-		this.notify(id);
+		return this.update(() => {
+			this.captureRecord(id);
+			const previous = this.records.get(id);
+			if (previous) this.removeRecordReferenceIndexes(id, previous);
+			if (snapshot.record === void 0) this.records.delete(id);
+			else {
+				this.records.set(id, snapshot.record);
+				this.addRecordReferenceIndexes(id, snapshot.record);
+			}
+			if (snapshot.mask === void 0) this.coverage.delete(id);
+			else this.coverage.set(id, snapshot.mask);
+			this.notify(id);
+		});
 	}
 	addListIndexes(key, list) {
 		const parsed = parseListKey(key);
@@ -1826,10 +1979,7 @@ var FateClient = class {
 		this.pending = /* @__PURE__ */ new Map();
 		this.pendingDeferred = /* @__PURE__ */ new Map();
 		this.pendingOptimisticMutations = /* @__PURE__ */ new Map();
-		this.optimisticMasks = /* @__PURE__ */ new Map();
-		this.optimisticByEntity = /* @__PURE__ */ new Map();
 		this.optimisticEntityResolutions = /* @__PURE__ */ new Map();
-		this.optimisticTokenCounter = 0;
 		this.liveSubscriptions = /* @__PURE__ */ new Map();
 		this.liveConnectionInvalidations = /* @__PURE__ */ new Map();
 		this.stableRefs = /* @__PURE__ */ new Map();
@@ -1839,8 +1989,11 @@ var FateClient = class {
 		this.gcPending = false;
 		this.gcScheduled = false;
 		this.pendingNetworkRequests = 0;
-		this.store = new Store();
-		this.viewDataCache = new ViewDataCache();
+		this.store = new Store((ids) => {
+			for (const id of ids) this.viewDataCache.invalidate(id);
+			this.runPendingGarbageCollection();
+		});
+		this.viewDataCache = new ViewDataCache(() => !this.store.isRebasing);
 		this.liveConnectionInvalidationToken = 0;
 		this.actions = Object.create(null);
 		this.mutationMap = Object.create(null);
@@ -1953,11 +2106,6 @@ var FateClient = class {
 		}
 		lists.add(key);
 	}
-	snapshotList(key, listSnapshots) {
-		if (!listSnapshots || listSnapshots.has(key)) return;
-		const listState = this.store.getListState(key);
-		if (listState) listSnapshots.set(key, listState);
-	}
 	applyListInsert(listState, entityId, insert) {
 		const pendingBeforeIds = listState.pendingBeforeIds ?? [];
 		const pendingAfterIds = listState.pendingAfterIds ?? [];
@@ -1986,7 +2134,7 @@ var FateClient = class {
 			pending: false
 		};
 	}
-	insertIntoRootLists(type, entityId, insert, listSnapshots) {
+	insertIntoRootLists(type, entityId, insert) {
 		if (insert === "none") return;
 		const listNames = this.rootLists.get(type);
 		if (!listNames) return;
@@ -1995,7 +2143,6 @@ var FateClient = class {
 			if (!listState) continue;
 			const next = this.applyListInsert(listState, entityId, insert).list;
 			if (next === listState) continue;
-			this.snapshotList(key, listSnapshots);
 			this.store.setList(key, next);
 		}
 	}
@@ -2020,23 +2167,17 @@ var FateClient = class {
 		} : argsPayload ? { args: argsPayload } : input;
 		return await this.trackPendingRequest(() => this.transport.mutate(key, requestInput, select));
 	}
-	write(type, data, select, snapshots, plan, pathPrefix = null, blockedMask, insert, listSnapshots) {
-		return this.writeEntity(type, data, select, snapshots, plan, pathPrefix, blockedMask, insert, listSnapshots);
-	}
-	deleteRecord(type, id, snapshots, listSnapshots) {
-		const entityId = toEntityId(type, id);
-		if (snapshots && !snapshots.has(entityId)) snapshots.set(entityId, this.store.snapshot(entityId));
-		this.viewDataCache.invalidate(entityId);
-		this.stableRefs.delete(entityId);
-		this.store.deleteRecord(entityId);
-		this.store.removeReferencesTo(entityId, this.viewDataCache, snapshots, listSnapshots);
+	write(type, data, select, plan, insert) {
+		return this.writeEntity(type, data, select, plan, null, insert);
 	}
-	restore(id, snapshot) {
-		this.viewDataCache.invalidate(id);
-		this.store.restore(id, snapshot);
-	}
-	restoreList(name, list) {
-		this.store.restoreList(name, list);
+	deleteRecord(type, id) {
+		return this.store.update(() => {
+			const entityId = toEntityId(type, id);
+			this.viewDataCache.invalidate(entityId);
+			this.stableRefs.delete(entityId);
+			this.store.deleteRecord(entityId);
+			this.store.removeReferencesTo(entityId, this.viewDataCache);
+		});
 	}
 	stableRefWithViewNames(type, id, viewNames) {
 		const entityId = toEntityId(type, id);
@@ -2221,10 +2362,8 @@ var FateClient = class {
 			unsubscribe = this.transport.subscribeById(type, id, plan.paths, args, {
 				onData: (record, liveSelect) => {
 					if (!record || typeof record !== "object") return;
-					const pendingMask = this.getPendingOptimisticMask(entityId);
 					const select = new Set(liveSelect ?? plan.paths);
-					const selection = this.filterSelectionForPendingOptimistics(entityId, select);
-					this.write(type, record, selection, void 0, plan, null, pendingMask, "none");
+					this.write(type, record, select, plan, "none");
 				},
 				onDelete: (deletedId) => {
 					this.deleteRecord(type, deletedId ?? id);
@@ -2278,24 +2417,26 @@ var FateClient = class {
 		};
 	}
 	applyLiveConnectionEvent(view, connection, plan, event) {
-		if (event.type === "invalidate") {
-			this.invalidateLiveConnection(view, connection);
-			return;
-		}
-		if (event.type === "deleteEdge") {
-			this.deleteConnectionEdge(connection, toEntityId(event.nodeType, event.id));
-			return;
-		}
-		const node = event.edge.node;
-		if (!node || typeof node !== "object") return;
-		const nodeRecord = node;
-		const nodeType = event.nodeType;
-		if (!nodeType) {
-			this.reportLiveError(/* @__PURE__ */ new Error(`fate: Live connection event for '${connection.procedure}' did not include a node type.`));
-			return;
-		}
-		const entityId = this.write(nodeType, nodeRecord, plan.paths, void 0, plan, null, null, "none");
-		this.insertConnectionEdge(connection.key, entityId, event.edge.cursor, event.type, event.targetCursor, view, connection);
+		return this.store.update(() => {
+			if (event.type === "invalidate") {
+				this.invalidateLiveConnection(view, connection);
+				return;
+			}
+			if (event.type === "deleteEdge") {
+				this.deleteConnectionEdge(connection, toEntityId(event.nodeType, event.id));
+				return;
+			}
+			const node = event.edge.node;
+			if (!node || typeof node !== "object") return;
+			const nodeRecord = node;
+			const nodeType = event.nodeType;
+			if (!nodeType) {
+				this.reportLiveError(/* @__PURE__ */ new Error(`fate: Live connection event for '${connection.procedure}' did not include a node type.`));
+				return;
+			}
+			const entityId = this.write(nodeType, nodeRecord, plan.paths, plan, "none");
+			this.insertConnectionEdge(connection.key, entityId, event.edge.cursor, event.type, event.targetCursor, view, connection);
+		});
 	}
 	invalidateLiveConnection(view, connection) {
 		const token = ++this.liveConnectionInvalidationToken;
@@ -2524,11 +2665,14 @@ var FateClient = class {
 		const cursors = hasIncomingCursor || Boolean(previous?.cursors) || options.hasCursorArg ? ids.map((id) => cursorMap.get(id)) : void 0;
 		const previousPagination = previous?.pagination;
 		const newPagination = incomingPagination;
+		const extendsExistingList = options.hasCursorArg && existingIds.length > 0;
+		const leadingPagination = extendsExistingList && !isBackward ? previousPagination ?? newPagination : newPagination;
+		const trailingPagination = extendsExistingList && isBackward ? previousPagination ?? newPagination : newPagination;
 		const pagination = previousPagination || newPagination ? {
-			hasNext: !!(newPagination?.hasNext ?? previousPagination?.hasNext),
-			hasPrevious: !!(newPagination?.hasPrevious ?? previousPagination?.hasPrevious),
-			nextCursor: newPagination?.nextCursor ?? previousPagination?.nextCursor,
-			previousCursor: newPagination?.previousCursor ?? previousPagination?.previousCursor
+			hasNext: !!(trailingPagination?.hasNext ?? previousPagination?.hasNext),
+			hasPrevious: !!(leadingPagination?.hasPrevious ?? previousPagination?.hasPrevious),
+			nextCursor: trailingPagination?.nextCursor ?? previousPagination?.nextCursor,
+			previousCursor: leadingPagination?.previousCursor ?? previousPagination?.previousCursor
 		} : void 0;
 		return {
 			backwardPageLimit: !options.hasCursorArg && isBackward && options.pageLimit != null ? Math.max(previous?.backwardPageLimit ?? 0, options.pageLimit) : previous?.backwardPageLimit,
@@ -2562,60 +2706,10 @@ var FateClient = class {
 		this.optimisticEntityResolutions.set(optimisticEntityId, resolvedEntityId);
 		this.store.replaceListEntityId(optimisticEntityId, resolvedEntityId);
 	}
-	registerOptimisticUpdate(entityId, select) {
-		if (!entityId || select.size === 0) return null;
-		const mask = fromPaths(select);
-		const token = ++this.optimisticTokenCounter;
-		this.optimisticMasks.set(token, {
-			entityId,
-			mask
-		});
-		let entries = this.optimisticByEntity.get(entityId);
-		if (!entries) {
-			entries = /* @__PURE__ */ new Set();
-			this.optimisticByEntity.set(entityId, entries);
-		}
-		entries.add(token);
-		return token;
-	}
-	clearOptimisticUpdate(token) {
-		if (token == null) return;
-		const entry = this.optimisticMasks.get(token);
-		if (!entry) return;
-		this.optimisticMasks.delete(token);
-		const entityTokens = this.optimisticByEntity.get(entry.entityId);
-		if (entityTokens) {
-			entityTokens.delete(token);
-			if (entityTokens.size === 0) this.optimisticByEntity.delete(entry.entityId);
-		}
-		this.runPendingGarbageCollection();
-	}
-	getPendingOptimisticMask(entityId, options = {}) {
-		if (!entityId) return null;
-		const tokens = this.optimisticByEntity.get(entityId);
-		if (!tokens || tokens.size === 0) return null;
-		let mask = null;
-		for (const token of tokens) {
-			if (options.excludeToken != null && token === options.excludeToken) continue;
-			const entry = this.optimisticMasks.get(token);
-			if (!entry) continue;
-			if (!mask) mask = cloneMask(entry.mask);
-			else union(mask, entry.mask);
-		}
-		return mask;
-	}
 	getPendingOptimisticMutations(entityId) {
 		const pending = this.pendingOptimisticMutations.get(entityId);
 		return pending && pending.size > 0 ? [...pending] : null;
 	}
-	filterSelectionForPendingOptimistics(entityId, select, options = {}) {
-		if (!entityId || select.size === 0) return select;
-		const pendingMask = this.getPendingOptimisticMask(entityId, options);
-		if (!pendingMask) return select;
-		const filtered = /* @__PURE__ */ new Set();
-		for (const path of select) if (!isCovered(pendingMask, path)) filtered.add(path);
-		return filtered;
-	}
 	async loadConnection(view, connection, args, options = {}) {
 		return await this.trackPendingRequest(() => this.loadConnectionInternal(view, connection, args, options));
 	}
@@ -2630,21 +2724,23 @@ var FateClient = class {
 			const { argsPayload, plan } = resolveSelectionPlan(view, requestArgs);
 			const { items, pagination } = await this.transport.fetchList(connection.field, plan.paths, argsPayload);
 			if (!items) return this.store.getListState(connection.key);
-			const incomingIds = [];
-			const incomingCursors = [];
-			for (const entry of items) {
-				const id = this.write(connection.type, entry.node, plan.paths, void 0, plan, null, null, "none");
-				incomingIds.push(id);
-				incomingCursors.push(entry.cursor);
-			}
-			const previous = this.store.getListState(connection.key);
-			const nextListState = this.mergeListState(previous, incomingIds, incomingCursors, pagination, {
-				...getPaginationMergeInfo(requestArgs),
-				replace: true
+			this.store.update(() => {
+				const incomingIds = [];
+				const incomingCursors = [];
+				for (const entry of items) {
+					const id = this.write(connection.type, entry.node, plan.paths, plan, "none");
+					incomingIds.push(id);
+					incomingCursors.push(entry.cursor);
+				}
+				const previous = this.store.getListState(connection.key);
+				const nextListState = this.mergeListState(previous, incomingIds, incomingCursors, pagination, {
+					...getPaginationMergeInfo(requestArgs),
+					replace: true
+				});
+				if (!filterConnectionArgs(connection.args)) this.registerRootList(connection.type, connection.key);
+				this.store.setList(connection.key, nextListState);
 			});
-			if (!filterConnectionArgs(connection.args)) this.registerRootList(connection.type, connection.key);
-			this.store.setList(connection.key, nextListState);
-			return nextListState;
+			return this.store.getListState(connection.key);
 		}
 		const owner = parseEntityId(connection.owner);
 		const requestArgs = omitUndefinedValues({
@@ -2668,32 +2764,34 @@ var FateClient = class {
 			pagination: void 0
 		} : list;
 		if (!connectionPayload) return this.store.getListState(connection.key);
-		const incomingIds = [];
-		const incomingCursors = [];
-		const nodeType = this.getListNodeType(owner.type, connection.field);
-		for (const entry of connectionPayload.items) {
-			const { node } = entry;
-			const id = this.write(nodeType, node, nodeSelection, void 0, plan);
-			incomingIds.push(id);
-			incomingCursors.push(entry.cursor);
-		}
-		const previous = this.store.getListState(connection.key);
-		const previousIds = previous?.ids ?? [];
-		const previousSet = new Set(previousIds);
-		const newIds = incomingIds.filter((id) => !previousSet.has(id));
-		const nextListState = this.mergeListState(previous, incomingIds, incomingCursors, connectionPayload.pagination, {
-			...getPaginationMergeInfo(argsPayload),
-			direction,
-			hasCursorArg: true,
-			replace: true
+		this.store.update(() => {
+			const incomingIds = [];
+			const incomingCursors = [];
+			const nodeType = this.getListNodeType(owner.type, connection.field);
+			for (const entry of connectionPayload.items) {
+				const { node } = entry;
+				const id = this.write(nodeType, node, nodeSelection, plan);
+				incomingIds.push(id);
+				incomingCursors.push(entry.cursor);
+			}
+			const previous = this.store.getListState(connection.key);
+			const previousIds = previous?.ids ?? [];
+			const previousSet = new Set(previousIds);
+			const newIds = incomingIds.filter((id) => !previousSet.has(id));
+			const nextListState = this.mergeListState(previous, incomingIds, incomingCursors, connectionPayload.pagination, {
+				...getPaginationMergeInfo(argsPayload),
+				direction,
+				hasCursorArg: true,
+				replace: true
+			});
+			this.store.setList(connection.key, nextListState);
+			const current = this.store.read(connection.owner);
+			const existingField = Array.isArray(current?.[connection.field]) ? current?.[connection.field] || [] : [];
+			const nodeRefs = createNodeRefsForIds(newIds, void 0);
+			const nextField = direction === "forward" ? [...existingField, ...nodeRefs] : [...nodeRefs, ...existingField];
+			this.viewDataCache.invalidate(connection.owner);
+			this.store.merge(connection.owner, { [connection.field]: nextField }, [connection.field]);
 		});
-		this.store.setList(connection.key, nextListState);
-		const current = this.store.read(connection.owner);
-		const existingField = Array.isArray(current?.[connection.field]) ? current?.[connection.field] || [] : [];
-		const nodeRefs = createNodeRefsForIds(newIds, void 0);
-		const nextField = direction === "forward" ? [...existingField, ...nodeRefs] : [...nodeRefs, ...existingField];
-		this.viewDataCache.invalidate(connection.owner);
-		this.store.merge(connection.owner, { [connection.field]: nextField }, [connection.field]);
 		return this.store.getListState(connection.key);
 	}
 	request(request, options) {
@@ -2836,9 +2934,7 @@ var FateClient = class {
 			case "stale-while-revalidate":
 				execution = this.handleStoreAndNetworkRequest(handle.descriptor);
 				break;
-			default:
-				execution = this.executeRequest(handle.descriptor, mode === "network-only" ? { fetchAll: true } : void 0).then(() => this.getRequestResultFromDescriptor(handle.descriptor));
-				break;
+			default: execution = this.executeRequest(handle.descriptor, mode === "network-only" ? { fetchAll: true } : void 0).then(() => this.getRequestResultFromDescriptor(handle.descriptor));
 		}
 		handle.start(execution);
 	}
@@ -2861,7 +2957,7 @@ var FateClient = class {
 		walk(record);
 	}
 	hasActiveOptimisticUpdates() {
-		return this.optimisticMasks.size > 0 || this.optimisticByEntity.size > 0 || this.pendingOptimisticMutations.size > 0;
+		return this.store.hasOptimisticUpdates || this.pendingOptimisticMutations.size > 0;
 	}
 	hasPendingRequests() {
 		return this.pendingNetworkRequests > 0;
@@ -3028,7 +3124,7 @@ var FateClient = class {
 		const resolvedArgs = resolvedArgsFromPlan(plan);
 		await this.trackPendingRequest(async () => {
 			const records = await this.transport.fetchById(type, ids, select, resolvedArgs);
-			for (const record of records) this.writeEntity(type, record, select, void 0, plan, prefix);
+			for (const record of records) this.writeEntity(type, record, select, plan, prefix);
 		});
 	}
 	async fetchQueryAndNormalize(item) {
@@ -3039,7 +3135,7 @@ var FateClient = class {
 				this.rootRequests.set(item.queryKey, null);
 				return;
 			}
-			const entityId = this.writeEntity(item.type, record, item.plan.paths, void 0, item.plan);
+			const entityId = this.writeEntity(item.type, record, item.plan.paths, item.plan);
 			this.rootRequests.set(item.queryKey, entityId);
 		});
 	}
@@ -3047,133 +3143,130 @@ var FateClient = class {
 		if (!this.transport.fetchList) throw new Error(`fate: 'transport.fetchList' is not configured but request includes a list for key '${item.name}'.`);
 		await this.trackPendingRequest(async () => {
 			const { items, pagination } = await this.transport.fetchList(item.name, item.plan.paths, item.argsPayload);
-			const ids = [];
-			const cursors = [];
-			for (const entry of items) {
-				const id = this.writeEntity(item.type, entry.node, item.plan.paths, void 0, item.plan);
-				ids.push(id);
-				cursors.push(entry.cursor);
-			}
-			if (!filterConnectionArgs(item.argsPayload)) this.registerRootList(item.type, item.listKey);
-			const previous = this.store.getListState(item.listKey);
-			this.store.setList(item.listKey, this.mergeListState(previous, ids, cursors, pagination, {
-				...getPaginationMergeInfo(item.argsPayload),
-				replace: true
-			}));
+			this.store.update(() => {
+				const ids = [];
+				const cursors = [];
+				for (const entry of items) {
+					const id = this.writeEntity(item.type, entry.node, item.plan.paths, item.plan);
+					ids.push(id);
+					cursors.push(entry.cursor);
+				}
+				if (!filterConnectionArgs(item.argsPayload)) this.registerRootList(item.type, item.listKey);
+				const previous = this.store.getListState(item.listKey);
+				this.store.setList(item.listKey, this.mergeListState(previous, ids, cursors, pagination, {
+					...getPaginationMergeInfo(item.argsPayload),
+					replace: true
+				}));
+			});
 		});
 	}
-	writeEntity(type, record, select, snapshots, plan, pathPrefix = null, blockedMask, insert, listSnapshots) {
-		const config = this.types.get(type);
-		if (!config) throw new Error(`fate: Found unknown entity type '${type}' in normalization.`);
-		const entityId = toEntityId(type, config.getId(record));
-		const result = {};
-		const selectionTree = groupSelectionByPrefix(select);
-		if (config.fields) for (const [key, relationDescriptor] of Object.entries(config.fields)) {
-			const value = record[key];
-			const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
-			const fieldArgs = plan?.args.get(fieldPath);
-			const isFieldBlocked = blockedMask ? isCovered(blockedMask, fieldPath) : false;
-			if (relationDescriptor === "scalar") {
-				if (isFieldBlocked || !Object.prototype.hasOwnProperty.call(record, key)) continue;
-				result[key] = value;
-			} else if (relationDescriptor && typeof relationDescriptor === "object" && "type" in relationDescriptor) {
-				if (isFieldBlocked) continue;
-				const childPaths = selectionTree.get(key) ?? emptySet;
-				if (value === null) {
-					result[key] = null;
-					continue;
-				}
-				if (value && typeof value === "object" && !isNodeRef(value)) {
-					const childType = relationDescriptor.type;
+	writeEntity(type, record, select, plan, pathPrefix = null, insert) {
+		return this.store.update(() => {
+			const config = this.types.get(type);
+			if (!config) throw new Error(`fate: Found unknown entity type '${type}' in normalization.`);
+			const id = config.getId(record);
+			const entityId = toEntityId(type, id);
+			const result = {};
+			const selectionTree = groupSelectionByPrefix(select);
+			if (config.fields) for (const [key, relationDescriptor] of Object.entries(config.fields)) {
+				const value = record[key];
+				const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+				const fieldArgs = plan?.args.get(fieldPath);
+				if (relationDescriptor === "scalar") {
+					if (!Object.hasOwn(record, key)) continue;
+					result[key] = value;
+				} else if (relationDescriptor && typeof relationDescriptor === "object" && "type" in relationDescriptor) {
+					const childPaths = selectionTree.get(key) ?? emptySet;
+					if (value === null) {
+						result[key] = null;
+						continue;
+					}
+					if (value && typeof value === "object" && !isNodeRef(value)) {
+						const childType = relationDescriptor.type;
+						const childConfig = this.types.get(childType);
+						if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${type}.${key}').`);
+						result[key] = createNodeRef(toEntityId(childType, childConfig.getId(value)));
+						this.writeEntity(childType, value, childPaths, plan, fieldPath);
+					}
+				} else if (relationDescriptor && typeof relationDescriptor === "object" && "listOf" in relationDescriptor) {
+					const childPaths = selectionTree.get(key) ?? emptySet;
+					if (value === null) {
+						result[key] = null;
+						continue;
+					}
+					const childType = relationDescriptor.listOf;
 					const childConfig = this.types.get(childType);
 					if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${type}.${key}').`);
-					result[key] = createNodeRef(toEntityId(childType, childConfig.getId(value)));
-					this.writeEntity(childType, value, childPaths, snapshots, plan, fieldPath, blockedMask, void 0, listSnapshots);
-				}
-			} else if (relationDescriptor && typeof relationDescriptor === "object" && "listOf" in relationDescriptor) {
-				if (isFieldBlocked) continue;
-				const childPaths = selectionTree.get(key) ?? emptySet;
-				if (value === null) {
-					result[key] = null;
-					continue;
-				}
-				const childType = relationDescriptor.listOf;
-				const childConfig = this.types.get(childType);
-				if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${type}.${key}').`);
-				const connection = (() => {
-					if (Array.isArray(value)) return { items: value.map((item) => ({ node: item })) };
-					if (value && typeof value === "object") {
-						const record = value;
-						if (Array.isArray(record.items)) return {
-							items: record.items.map((node) => {
-								if (node && typeof node === "object" && "node" in node) {
-									const itemRecord = node;
-									return {
-										cursor: itemRecord.cursor,
-										node: itemRecord.node
-									};
-								}
-								return { node };
-							}),
-							pagination: record.pagination
-						};
-					}
-					return null;
-				})();
-				if (connection) {
-					const ids = [];
-					const cursors = [];
-					const nodeSelection = childPaths.size > 0 ? /* @__PURE__ */ new Set() : childPaths;
-					if (childPaths.size > 0) for (const path of childPaths) {
-						if (path.startsWith("items.node.")) {
-							nodeSelection.add(path.slice(11));
-							continue;
-						}
-						if (path.startsWith("node.")) {
-							nodeSelection.add(path.slice(5));
-							continue;
+					const connection = (() => {
+						if (Array.isArray(value)) return { items: value.map((item) => ({ node: item })) };
+						if (value && typeof value === "object") {
+							const record = value;
+							if (Array.isArray(record.items)) return {
+								items: record.items.map((node) => {
+									if (node && typeof node === "object" && "node" in node) {
+										const itemRecord = node;
+										return {
+											cursor: itemRecord.cursor,
+											node: itemRecord.node
+										};
+									}
+									return { node };
+								}),
+								pagination: record.pagination
+							};
 						}
-						if (path === "items.node" || path.startsWith("items.")) continue;
-						nodeSelection.add(path);
-					}
-					for (const entry of connection.items) {
-						const node = entry.node;
-						const cursor = "cursor" in entry ? entry.cursor : void 0;
-						cursors.push(cursor);
-						if (isNodeRef(node)) {
-							ids.push(getNodeRefId(node));
-							continue;
+						return null;
+					})();
+					if (connection) {
+						const ids = [];
+						const cursors = [];
+						const nodeSelection = childPaths.size > 0 ? /* @__PURE__ */ new Set() : childPaths;
+						if (childPaths.size > 0) for (const path of childPaths) {
+							if (path.startsWith("items.node.")) {
+								nodeSelection.add(path.slice(11));
+								continue;
+							}
+							if (path.startsWith("node.")) {
+								nodeSelection.add(path.slice(5));
+								continue;
+							}
+							if (path === "items.node" || path.startsWith("items.")) continue;
+							nodeSelection.add(path);
 						}
-						if (node && typeof node === "object") {
-							const childId = toEntityId(childType, childConfig.getId(node));
-							this.writeEntity(childType, node, nodeSelection, snapshots, plan, fieldPath, blockedMask, void 0, listSnapshots);
-							ids.push(childId);
-							continue;
+						for (const entry of connection.items) {
+							const node = entry.node;
+							const cursor = "cursor" in entry ? entry.cursor : void 0;
+							cursors.push(cursor);
+							if (isNodeRef(node)) {
+								ids.push(getNodeRefId(node));
+								continue;
+							}
+							if (node && typeof node === "object") {
+								const childId = toEntityId(childType, childConfig.getId(node));
+								this.writeEntity(childType, node, nodeSelection, plan, fieldPath);
+								ids.push(childId);
+								continue;
+							}
 						}
+						const listKey = getListKey(entityId, key, fieldArgs?.hash);
+						const previousList = this.store.getListState(listKey);
+						const argsValue = fieldArgs?.value;
+						const nextListState = this.mergeListState(previousList, ids, cursors, connection.pagination, getPaginationMergeInfo(argsValue));
+						const listChanged = !areListStatesEqual(previousList, nextListState);
+						result[key] = createNodeRefsForIds(nextListState.ids, this.store.read(entityId)?.[key], { reuseCurrentArray: !listChanged });
+						this.store.setList(listKey, nextListState);
 					}
-					const listKey = getListKey(entityId, key, fieldArgs?.hash);
-					const previousList = this.store.getListState(listKey);
-					const argsValue = fieldArgs?.value;
-					const nextListState = this.mergeListState(previousList, ids, cursors, connection.pagination, getPaginationMergeInfo(argsValue));
-					const listChanged = !areListStatesEqual(previousList, nextListState);
-					result[key] = createNodeRefsForIds(nextListState.ids, this.store.read(entityId)?.[key], { reuseCurrentArray: !listChanged });
-					this.store.setList(listKey, nextListState);
-				}
-			} else result[key] = value;
-		}
-		for (const [key, value] of Object.entries(record)) if (!(key in (config.fields ?? {}))) {
-			const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
-			if (blockedMask && isCovered(blockedMask, fieldPath)) continue;
-			result[key] = value;
-		}
-		if (snapshots && !snapshots.has(entityId)) snapshots.set(entityId, this.store.snapshot(entityId));
-		this.viewDataCache.invalidate(entityId);
-		this.store.merge(entityId, result, select);
-		this.linkParentLists(type, entityId, result, snapshots, listSnapshots, insert ?? "after");
-		if (!pathPrefix && insert) this.insertIntoRootLists(type, entityId, insert, listSnapshots);
-		return entityId;
+				} else result[key] = value;
+			}
+			for (const [key, value] of Object.entries(record)) if (!(key in (config.fields ?? {}))) result[key] = value;
+			this.viewDataCache.invalidate(entityId);
+			this.store.merge(entityId, result, select);
+			this.linkParentLists(type, entityId, result, insert ?? "after");
+			if (!pathPrefix && insert) this.insertIntoRootLists(type, entityId, insert);
+			return entityId;
+		});
 	}
-	linkParentLists(type, entityId, record, snapshots, listSnapshots, insert) {
+	linkParentLists(type, entityId, record, insert) {
 		if (insert === "none") return;
 		const parents = this.parentLists.get(type);
 		if (!parents) return;
@@ -3186,23 +3279,18 @@ var FateClient = class {
 			if (!existing) continue;
 			const current = Array.isArray(existing[parent.field]) ? existing[parent.field] : [];
 			if (current.some((item) => isNodeRef(item) && getNodeRefId(item) === entityId)) continue;
-			if (snapshots && !snapshots.has(parentId)) snapshots.set(parentId, this.store.snapshot(parentId));
 			this.viewDataCache.invalidate(parentId);
 			const defaultListKey = getListKey(parentId, parent.field);
 			const defaultListState = this.store.getListState(defaultListKey);
 			let nextField = current;
 			if (defaultListState) {
 				const { list: nextDefaultListState, pending } = this.applyListInsert(defaultListState, entityId, insert);
-				if (nextDefaultListState !== defaultListState) {
-					this.snapshotList(defaultListKey, listSnapshots);
-					this.store.setList(defaultListKey, nextDefaultListState);
-				}
+				if (nextDefaultListState !== defaultListState) this.store.setList(defaultListKey, nextDefaultListState);
 				const nextFieldIds = pending ? getListEntries(nextDefaultListState).map(({ id }) => id) : nextDefaultListState.ids;
 				nextField = createNodeRefsForIds(nextFieldIds, current);
 			} else {
 				const currentIds = current.map((item) => isNodeRef(item) ? getNodeRefId(item) : null).filter((id) => id != null);
 				const nextDefaultListState = { ids: insert === "before" ? [entityId, ...currentIds] : [...currentIds, entityId] };
-				this.snapshotList(defaultListKey, listSnapshots);
 				this.store.setList(defaultListKey, nextDefaultListState);
 				nextField = createNodeRefsForIds(nextDefaultListState.ids, current);
 			}
@@ -3210,7 +3298,6 @@ var FateClient = class {
 			for (const [listKey, listState] of registeredLists) {
 				const nextListState = this.applyListInsert(listState, entityId, insert).list;
 				if (nextListState === listState) continue;
-				this.snapshotList(listKey, listSnapshots);
 				this.store.setList(listKey, nextListState);
 			}
 			this.store.merge(parentId, { [parent.field]: nextField }, [parent.field]);
@@ -3258,92 +3345,93 @@ var FateClient = class {
 						target[key] = null;
 						continue;
 					}
-					if (Array.isArray(value)) if (nextSelection.items && typeof nextSelection.items === "object") {
-						const selection = nextSelection.items;
-						const fieldArgs = plan.args.get(fieldPath);
-						const listKey = getListKey(parentId, key, fieldArgs?.hash);
-						const listState = this.store.getListState(listKey);
-						const connection = { items: (listState ? getListEntries(listState) : value.map((item) => ({
-							cursor: void 0,
-							id: isNodeRef(item) ? getNodeRefId(item) : null
-						}))).map((entry, index) => {
-							const entityId = entry.id;
-							if (!entityId) return {
-								cursor: listState?.cursors?.[index],
-								node: null
-							};
+					if (Array.isArray(value)) {
+						if (nextSelection.items && typeof nextSelection.items === "object") {
+							const selection = nextSelection.items;
+							const fieldArgs = plan.args.get(fieldPath);
+							const listKey = getListKey(parentId, key, fieldArgs?.hash);
+							const listState = this.store.getListState(listKey);
+							const connection = { items: (listState ? getListEntries(listState) : value.map((item) => ({
+								cursor: void 0,
+								id: isNodeRef(item) ? getNodeRefId(item) : null
+							}))).map((entry, index) => {
+								const entityId = entry.id;
+								if (!entityId) return {
+									cursor: listState?.cursors?.[index],
+									node: null
+								};
+								ids.add(entityId);
+								const record = this.store.read(entityId);
+								const { id, type } = parseEntityId(entityId);
+								const node = {
+									__typename: type,
+									id
+								};
+								if (record) walk(selection.node, record, node, entityId, fieldPath);
+								const itemResult = { node: record ? node : null };
+								if (selection.cursor === true) itemResult.cursor = entry.cursor;
+								return itemResult;
+							}) };
+							if ("pagination" in nextSelection && nextSelection.pagination) {
+								const paginationSelection = nextSelection.pagination;
+								const storedPagination = listState?.pagination;
+								if (storedPagination) {
+									const pagination = {};
+									if (paginationSelection.nextCursor === true) {
+										if (storedPagination.nextCursor !== void 0) pagination.nextCursor = storedPagination.nextCursor;
+									}
+									if (paginationSelection.previousCursor === true) {
+										if (storedPagination.previousCursor !== void 0) pagination.previousCursor = storedPagination.previousCursor;
+									}
+									if (paginationSelection.hasNext === true) pagination.hasNext = storedPagination.hasNext;
+									if (paginationSelection.hasPrevious === true) pagination.hasPrevious = storedPagination.hasPrevious;
+									if (Object.keys(pagination).length > 0) connection.pagination = pagination;
+								} else connection.pagination = void 0;
+							}
+							const { id: ownerRawId, type: parentType } = parseEntityId(parentId);
+							if (parentType) {
+								const childType = this.getListNodeType(parentType, key);
+								const metadata = {
+									args: (() => {
+										if (!fieldArgs?.value && ownerRawId === void 0) return;
+										const value = fieldArgs?.value ? { ...fieldArgs.value } : {};
+										if (ownerRawId !== void 0) value.id = ownerRawId;
+										return value;
+									})(),
+									field: key,
+									hash: fieldArgs?.hash,
+									key: listKey,
+									live: plan.live.get(fieldPath),
+									owner: parentId,
+									procedure: `${parentType}.${key}`,
+									root: false,
+									type: childType
+								};
+								Object.defineProperty(connection, ConnectionTag, {
+									configurable: false,
+									enumerable: false,
+									value: metadata,
+									writable: false
+								});
+							}
+							target[key] = connection;
+						} else target[key] = value.map((item) => {
+							const entityId = isNodeRef(item) ? getNodeRefId(item) : null;
+							if (!entityId) return item;
 							ids.add(entityId);
 							const record = this.store.read(entityId);
 							const { id, type } = parseEntityId(entityId);
-							const node = {
-								__typename: type,
-								id
-							};
-							if (record) walk(selection.node, record, node, entityId, fieldPath);
-							const itemResult = { node: record ? node : null };
-							if (selection.cursor === true) itemResult.cursor = entry.cursor;
-							return itemResult;
-						}) };
-						if ("pagination" in nextSelection && nextSelection.pagination) {
-							const paginationSelection = nextSelection.pagination;
-							const storedPagination = listState?.pagination;
-							if (storedPagination) {
-								const pagination = {};
-								if (paginationSelection.nextCursor === true) {
-									if (storedPagination.nextCursor !== void 0) pagination.nextCursor = storedPagination.nextCursor;
-								}
-								if (paginationSelection.previousCursor === true) {
-									if (storedPagination.previousCursor !== void 0) pagination.previousCursor = storedPagination.previousCursor;
-								}
-								if (paginationSelection.hasNext === true) pagination.hasNext = storedPagination.hasNext;
-								if (paginationSelection.hasPrevious === true) pagination.hasPrevious = storedPagination.hasPrevious;
-								if (Object.keys(pagination).length > 0) connection.pagination = pagination;
-							} else connection.pagination = void 0;
-						}
-						const { id: ownerRawId, type: parentType } = parseEntityId(parentId);
-						if (parentType) {
-							const childType = this.getListNodeType(parentType, key);
-							const metadata = {
-								args: (() => {
-									if (!fieldArgs?.value && ownerRawId === void 0) return;
-									const value = fieldArgs?.value ? { ...fieldArgs.value } : {};
-									if (ownerRawId !== void 0) value.id = ownerRawId;
-									return value;
-								})(),
-								field: key,
-								hash: fieldArgs?.hash,
-								key: listKey,
-								live: plan.live.get(fieldPath),
-								owner: parentId,
-								procedure: `${parentType}.${key}`,
-								root: false,
-								type: childType
-							};
-							Object.defineProperty(connection, ConnectionTag, {
-								configurable: false,
-								enumerable: false,
-								value: metadata,
-								writable: false
-							});
-						}
-						target[key] = connection;
-					} else target[key] = value.map((item) => {
-						const entityId = isNodeRef(item) ? getNodeRefId(item) : null;
-						if (!entityId) return item;
-						ids.add(entityId);
-						const record = this.store.read(entityId);
-						const { id, type } = parseEntityId(entityId);
-						if (record) {
-							const node = {
-								__typename: type,
-								id
-							};
-							walk(nextSelection, record, node, entityId, fieldPath);
-							return node;
-						}
-						return null;
-					});
-					else if (isNodeRef(value)) {
+							if (record) {
+								const node = {
+									__typename: type,
+									id
+								};
+								walk(nextSelection, record, node, entityId, fieldPath);
+								return node;
+							}
+							return null;
+						});
+					} else if (isNodeRef(value)) {
 						const entityId = getNodeRefId(value);
 						ids.add(entityId);
 						const relatedRecord = this.store.read(entityId);