@mearie/core 0.6.1 → 0.6.3

package/dist/index.mjs

@@ -588,7 +588,7 @@ const normalize = (schemaMeta, selections, storage, data, variables, accessor) =
 
 //#endregion
 //#region src/cache/denormalize.ts
-const typenameFieldKey = makeFieldKey({
+const typenameFieldKey$1 = makeFieldKey({
 	kind: "Field",
 	name: "__typename",
 	type: "String"
@@ -603,7 +603,7 @@ const denormalize = (selections, storage, value, variables, accessor, options) =
 			const entityKey = data[EntityLinkKey];
 			const entity = storage[entityKey];
 			if (!entity) {
-				accessor?.(entityKey, typenameFieldKey, path);
+				accessor?.(entityKey, typenameFieldKey$1, path);
 				partial = true;
 				return null;
 			}
@@ -650,7 +650,7 @@ const denormalize = (selections, storage, value, variables, accessor, options) =
 				if (denormalize(selection.selections, storage, storage[RootFieldKey], variables, options?.trackFragmentDeps === false ? void 0 : accessor, options).partial) partial = true;
 			}
 		} else mergeFields(fields, denormalizeField(storageKey, selection.selections, value, path), true);
-		else if (selection.kind === "InlineFragment" && selection.on === data[typenameFieldKey]) mergeFields(fields, denormalizeField(storageKey, selection.selections, value, path), true);
+		else if (selection.kind === "InlineFragment" && selection.on === data[typenameFieldKey$1]) mergeFields(fields, denormalizeField(storageKey, selection.selections, value, path), true);
 		return fields;
 	};
 	return {
@@ -660,159 +660,142 @@ const denormalize = (selections, storage, value, variables, accessor, options) =
 };
 
 //#endregion
-//#region src/cache/tree.ts
+//#region src/cache/cursor.ts
 /**
+* Reverse index mapping dependency keys to cursor entries.
 * @internal
 */
-const buildEntryTree = (tuples, rootDepKey) => {
-	const root = {
-		depKey: rootDepKey ?? "__root",
-		children: /* @__PURE__ */ new Map()
-	};
-	for (const { storageKey, fieldKey, path, selections } of tuples) {
-		let current = root;
-		for (const element of path) {
-			const key = String(element);
-			let child = current.children.get(key);
-			if (!child) {
-				child = {
-					depKey: "",
-					children: /* @__PURE__ */ new Map()
-				};
-				current.children.set(key, child);
-			}
-			current = child;
+var CursorRegistry = class {
+	#index = /* @__PURE__ */ new Map();
+	add(depKey, entry) {
+		let set = this.#index.get(depKey);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.#index.set(depKey, set);
 		}
-		current.depKey = makeDependencyKey(storageKey, fieldKey);
-		if (selections) current.selections = selections;
+		set.add(entry);
 	}
-	return root;
-};
-/**
-* @internal
-*/
-const findEntryTreeNode = (root, path) => {
-	let current = root;
-	for (const segment of path) {
-		if (!current) return void 0;
-		current = current.children.get(String(segment));
+	get(depKey) {
+		return this.#index.get(depKey);
 	}
-	return current;
-};
-/**
-* Removes all subscription entries for a given subscription from the subtree rooted at {@link node},
-* and clears the node's children map. Both the subscription entries and the tree structure
-* are cleaned up atomically to avoid stale references.
-* @internal
-*/
-const removeSubtreeEntries = (node, subscription, subscriptions) => {
-	const entries = subscriptions.get(node.depKey);
-	if (entries) {
-		for (const entry of entries) if (entry.subscription === subscription) {
-			entries.delete(entry);
-			break;
+	remove(depKey, entry) {
+		const set = this.#index.get(depKey);
+		if (set) {
+			set.delete(entry);
+			if (set.size === 0) this.#index.delete(depKey);
 		}
-		if (entries.size === 0) subscriptions.delete(node.depKey);
 	}
-	for (const child of node.children.values()) removeSubtreeEntries(child, subscription, subscriptions);
-	node.children.clear();
-};
-/**
-* @internal
-*/
-const snapshotFields = (node, storage) => {
-	const result = /* @__PURE__ */ new Map();
-	for (const [fieldName, child] of node.children) {
-		const { storageKey, fieldKey } = parseDependencyKey(child.depKey);
-		const fields = storage[storageKey];
-		if (fields) result.set(fieldName, fields[fieldKey]);
+	removeAll(cursors) {
+		for (const [depKey, set] of this.#index) {
+			for (const cursor of cursors) if (set.has(cursor)) set.delete(cursor);
+			if (set.size === 0) this.#index.delete(depKey);
+		}
+	}
+	forEachByPrefix(prefix, callback) {
+		for (const [depKey, set] of this.#index) if (depKey.startsWith(prefix)) for (const entry of set) callback(entry);
+	}
+	clear() {
+		this.#index.clear();
 	}
-	return result;
 };
+const typenameFieldKey = makeFieldKey({
+	kind: "Field",
+	name: "__typename",
+	type: "String"
+}, {});
 /**
+* Walks selections against storage to produce cursor entries, check completeness,
+* and build denormalized data.
 * @internal
 */
-const partialDenormalize = (node, entity, basePath, rebuiltDepKeys, storage, subscriptions, subscription) => {
-	if (!node.selections) return {
-		data: null,
-		fieldValues: /* @__PURE__ */ new Map()
-	};
-	const tuples = [];
-	const { data } = denormalize(node.selections, storage, entity, subscription.variables, (storageKey, fieldKey, path, sels) => {
-		tuples.push({
-			storageKey,
-			fieldKey,
-			path: [...basePath, ...path],
-			selections: sels
-		});
-	}, { trackFragmentDeps: false });
-	node.children.clear();
-	const fieldValues = /* @__PURE__ */ new Map();
-	for (const tuple of tuples) {
-		const depKey = makeDependencyKey(tuple.storageKey, tuple.fieldKey);
-		rebuiltDepKeys.add(depKey);
-		const relativePath = tuple.path.slice(basePath.length);
-		let current = node;
-		for (const element of relativePath) {
-			const key = String(element);
-			let child = current.children.get(key);
-			if (!child) {
-				child = {
-					depKey: "",
-					children: /* @__PURE__ */ new Map()
-				};
-				current.children.set(key, child);
-			}
-			current = child;
-		}
-		current.depKey = depKey;
-		if (tuple.selections) current.selections = tuple.selections;
-		const entry = {
-			path: tuple.path,
-			subscription
+const traceSelections = (selections, storage, value, variables, storageKey, basePath, subscriptionId) => {
+	const cursors = [];
+	const missingDeps = /* @__PURE__ */ new Set();
+	let complete = true;
+	const traceFragmentSpread = (selection, refKey, value, traceKey, fields, path) => {
+		fields[FragmentRefKey] = refKey;
+		const merged = selection.args ? {
+			...variables,
+			...resolveArguments(selection.args, variables)
+		} : { ...variables };
+		fields[FragmentVarsKey] = {
+			...fields[FragmentVarsKey],
+			[selection.name]: merged
 		};
-		let entrySet = subscriptions.get(depKey);
-		if (!entrySet) {
-			entrySet = /* @__PURE__ */ new Set();
-			subscriptions.set(depKey, entrySet);
+		const inner = traceSelections(selection.selections, storage, value, variables, traceKey, path, subscriptionId);
+		for (const cursor of inner.cursors) cursors.push({
+			depKey: cursor.depKey,
+			entry: cursor.entry.dependency === "transitive" ? cursor.entry : {
+				...cursor.entry,
+				dependency: "transitive"
+			}
+		});
+		if (!inner.complete) {
+			complete = false;
+			for (const dep of inner.missingDeps) missingDeps.add(dep);
 		}
-		entrySet.add(entry);
-		if (relativePath.length === 1) {
-			const fieldName = String(relativePath[0]);
-			if (data && typeof data === "object") fieldValues.set(fieldName, data[fieldName]);
+	};
+	const traceField = (sk, sels, val, path, trackCursors) => {
+		if (isNullish(val)) return val;
+		if (Array.isArray(val)) return val.map((item, i) => traceField(sk, sels, item, [...path, i], trackCursors));
+		const data = val;
+		if (isEntityLink(data)) {
+			const entityKey = data[EntityLinkKey];
+			const entity = storage[entityKey];
+			if (!entity) {
+				if (trackCursors) {
+					const depKey = makeDependencyKey(entityKey, typenameFieldKey);
+					missingDeps.add(depKey);
+				}
+				complete = false;
+				return null;
+			}
+			return traceField(entityKey, sels, entity, path, trackCursors);
 		}
-	}
+		const fields = {};
+		for (const selection of sels) if (selection.kind === "Field") {
+			const fieldKey = makeFieldKey(selection, variables);
+			const fieldValue = data[fieldKey];
+			const fieldPath = [...path, selection.alias ?? selection.name];
+			if (sk !== null && trackCursors) {
+				const depKey = makeDependencyKey(sk, fieldKey);
+				const entry = {
+					subscriptionId,
+					path: fieldPath,
+					dependency: "direct",
+					...selection.selections && { selections: selection.selections }
+				};
+				cursors.push({
+					depKey,
+					entry
+				});
+			}
+			if (fieldValue === void 0) {
+				if (sk !== null) {
+					const depKey = makeDependencyKey(sk, fieldKey);
+					missingDeps.add(depKey);
+				}
+				complete = false;
+				continue;
+			}
+			const name = selection.alias ?? selection.name;
+			const resolvedValue = selection.selections ? traceField(null, selection.selections, fieldValue, fieldPath, trackCursors) : fieldValue;
+			if (name in fields) mergeFields(fields, { [name]: resolvedValue }, true);
+			else fields[name] = resolvedValue;
+		} else if (selection.kind === "FragmentSpread") if (sk !== null && sk !== RootFieldKey) traceFragmentSpread(selection, sk, storage[sk], sk, fields, path);
+		else if (sk === RootFieldKey) traceFragmentSpread(selection, RootFieldKey, storage[RootFieldKey], RootFieldKey, fields, path);
+		else mergeFields(fields, traceField(sk, selection.selections, val, path, trackCursors), true);
+		else if (selection.kind === "InlineFragment" && selection.on === data[typenameFieldKey]) mergeFields(fields, traceField(sk, selection.selections, val, path, trackCursors), true);
+		return fields;
+	};
+	const data = traceField(storageKey, selections, value, basePath, true);
 	return {
-		data,
-		fieldValues
+		complete,
+		cursors,
+		missingDeps,
+		data
 	};
 };
-const updateSubtreePaths = (node, basePath, newIndex, baseLen, subscription, subscriptions) => {
-	const entries = subscriptions.get(node.depKey);
-	if (entries) {
-		for (const entry of entries) if (entry.subscription === subscription && entry.path.length > baseLen) entry.path = [
-			...basePath,
-			newIndex,
-			...entry.path.slice(baseLen + 1)
-		];
-	}
-	for (const child of node.children.values()) updateSubtreePaths(child, basePath, newIndex, baseLen, subscription, subscriptions);
-};
-/**
-* @internal
-*/
-const rebuildArrayIndices = (node, entry, subscriptions) => {
-	const basePath = entry.path;
-	const baseLen = basePath.length;
-	const children = [...node.children.entries()].toSorted(([a], [b]) => Number(a) - Number(b));
-	node.children.clear();
-	for (const [newIdx, child_] of children.entries()) {
-		const [, child] = child_;
-		const newKey = String(newIdx);
-		node.children.set(newKey, child);
-		updateSubtreePaths(child, basePath, newIdx, baseLen, entry.subscription, subscriptions);
-	}
-};
 
 //#endregion
 //#region src/cache/diff.ts
@@ -854,27 +837,139 @@ const computeSwaps = (oldKeys, newKeys) => {
 	}
 	return swaps;
 };
+/**
+* @internal
+*/
+const extractEntityKey = (item) => {
+	if (item !== null && item !== void 0 && typeof item === "object" && EntityLinkKey in item) return String(item[EntityLinkKey]);
+	return null;
+};
+/**
+* @internal
+*/
+const computeEntityArrayPatches = (oldValue, newValue, path, denormalizedArray) => {
+	const patches = [];
+	const oldKeys = oldValue.map((item) => extractEntityKey(item));
+	const newKeys = newValue.map((item) => extractEntityKey(item));
+	const { start, oldEnd, newEnd } = findCommonBounds(oldKeys, newKeys);
+	const oldMiddle = oldKeys.slice(start, oldEnd);
+	const newMiddle = newKeys.slice(start, newEnd);
+	const oldMiddleSet = new Set(oldMiddle.filter((k) => k !== null));
+	const newMiddleSet = new Set(newMiddle.filter((k) => k !== null));
+	for (let i = oldMiddle.length - 1; i >= 0; i--) if (oldMiddle[i] !== null && !newMiddleSet.has(oldMiddle[i])) patches.push({
+		type: "splice",
+		path,
+		index: start + i,
+		deleteCount: 1,
+		items: []
+	});
+	const retainedOld = oldMiddle.filter((k) => k !== null && newMiddleSet.has(k));
+	const retainedNew = newMiddle.filter((k) => k !== null && oldMiddleSet.has(k));
+	if (retainedOld.length > 0) {
+		const swaps = computeSwaps(retainedOld, retainedNew);
+		for (const { i, j } of swaps) patches.push({
+			type: "swap",
+			path,
+			i: start + i,
+			j: start + j
+		});
+	}
+	const addedKeys = newMiddle.filter((k) => k !== null && !oldMiddleSet.has(k));
+	for (const key of addedKeys) {
+		const idx = start + newMiddle.indexOf(key);
+		const data = denormalizedArray[idx] ?? null;
+		patches.push({
+			type: "splice",
+			path,
+			index: idx,
+			deleteCount: 0,
+			items: [data]
+		});
+	}
+	return patches;
+};
+const pathToKey = (path) => path.map(String).join("\0");
+/**
+* Diffs two denormalized data snapshots to produce patches.
+* Handles entity link arrays with identity-aware splice/swap patches.
+* @internal
+*/
+const diffSnapshots = (oldData, newData, entityArrayChanges) => {
+	const patches = [];
+	const diff = (old, cur, path) => {
+		if (isEqual(old, cur)) return;
+		if (cur === null || cur === void 0 || old === null || old === void 0 || typeof cur !== "object" || typeof old !== "object") {
+			patches.push({
+				type: "set",
+				path,
+				value: cur
+			});
+			return;
+		}
+		if (Array.isArray(cur)) {
+			if (entityArrayChanges && Array.isArray(old)) {
+				const key = pathToKey(path);
+				const change = entityArrayChanges.get(key);
+				if (change) {
+					diffEntityArray(old, cur, path, change);
+					return;
+				}
+			}
+			patches.push({
+				type: "set",
+				path,
+				value: cur
+			});
+			return;
+		}
+		if (Array.isArray(old)) {
+			patches.push({
+				type: "set",
+				path,
+				value: cur
+			});
+			return;
+		}
+		const oldObj = old;
+		const curObj = cur;
+		for (const key of Object.keys(curObj)) {
+			if (key === "__fragmentRef" || key === "__fragmentVars") continue;
+			diff(oldObj[key], curObj[key], [...path, key]);
+		}
+	};
+	const diffEntityArray = (old, cur, path, change) => {
+		const { oldKeys, newKeys } = change;
+		const oldByKey = /* @__PURE__ */ new Map();
+		for (const [i, key] of oldKeys.entries()) if (key) oldByKey.set(key, old[i]);
+		const arrayPatches = computeEntityArrayPatches(oldKeys.map((k) => k ? { [EntityLinkKey]: k } : null), newKeys.map((k) => k ? { [EntityLinkKey]: k } : null), path, cur);
+		patches.push(...arrayPatches);
+		for (const [i, item] of cur.entries()) {
+			const entityKey = newKeys[i];
+			diff(entityKey ? oldByKey.get(entityKey) : void 0, item, [...path, i]);
+		}
+	};
+	diff(oldData, newData, []);
+	return patches;
+};
+/**
+* @internal
+*/
+const pathToKeyFn = pathToKey;
 
 //#endregion
 //#region src/cache/change.ts
 /**
 * @internal
 */
-const classifyChanges = (changedKeys) => {
+const classifyChanges = (changes) => {
 	const structural = [];
 	const scalar = [];
-	for (const [depKey, { oldValue, newValue }] of changedKeys) {
+	for (const change of changes) {
+		const { oldValue, newValue } = change;
 		if (isEntityLink(oldValue) && isEntityLink(newValue) && oldValue[EntityLinkKey] === newValue[EntityLinkKey]) continue;
 		if (isEntityLinkArray(oldValue) && isEntityLinkArray(newValue) && isEntityLinkArrayEqual(oldValue, newValue)) continue;
-		if (isEntityLink(oldValue) || isEntityLink(newValue) || isEntityLinkArray(oldValue) || isEntityLinkArray(newValue)) structural.push({
-			depKey,
-			oldValue,
-			newValue
-		});
-		else scalar.push({
-			depKey,
-			newValue
-		});
+		if (isEntityLink(oldValue) || isEntityLink(newValue) || isEntityLinkArray(oldValue) || isEntityLinkArray(newValue)) structural.push(change);
+		else scalar.push(change);
 	}
 	return {
 		structural,
@@ -884,207 +979,230 @@ const classifyChanges = (changedKeys) => {
 /**
 * @internal
 */
-const processStructuralChange = (entry, node, oldValue, newValue, rebuiltDepKeys, storage, subscriptions) => {
-	const patches = [];
-	if (isEntityLink(oldValue) || isEntityLink(newValue)) {
-		if (isNullish(newValue)) {
-			removeSubtreeEntries(node, entry.subscription, subscriptions);
+const processScalarChanges = (changes, registry, subscriptions) => {
+	const result = /* @__PURE__ */ new Map();
+	for (const change of changes) {
+		const entries = registry.get(change.depKey);
+		if (!entries) continue;
+		for (const entry of entries) {
+			if (entry.dependency === "transitive") continue;
+			const sub = subscriptions.get(entry.subscriptionId);
+			if (!sub) continue;
+			let patchValue = change.newValue;
+			if (entry.selections && isNormalizedRecord(change.newValue)) {
+				const { data } = denormalize(entry.selections, {}, change.newValue, sub.variables);
+				patchValue = data;
+			}
+			const patches = result.get(entry.subscriptionId) ?? [];
 			patches.push({
 				type: "set",
 				path: entry.path,
-				value: null
+				value: patchValue
 			});
-			return patches;
+			result.set(entry.subscriptionId, patches);
 		}
-		if (isNullish(oldValue)) {
-			const entity = storage[newValue[EntityLinkKey]];
-			if (entity) {
-				const { data } = partialDenormalize(node, entity, entry.path, rebuiltDepKeys, storage, subscriptions, entry.subscription);
-				patches.push({
-					type: "set",
-					path: entry.path,
-					value: data
-				});
-			} else patches.push({
-				type: "set",
-				path: entry.path,
-				value: null
+	}
+	return result;
+};
+/**
+* @internal
+*/
+const buildEntityArrayContext = (changes, cursors) => {
+	const result = /* @__PURE__ */ new Map();
+	for (const change of changes) {
+		if (!isEntityLinkArray(change.oldValue) && !isEntityLinkArray(change.newValue)) continue;
+		for (const { depKey, entry } of cursors) if (depKey === change.depKey) {
+			const oldArr = Array.isArray(change.oldValue) ? change.oldValue : [];
+			const newArr = Array.isArray(change.newValue) ? change.newValue : [];
+			const key = pathToKeyFn(entry.path);
+			result.set(key, {
+				oldKeys: oldArr.map((item) => extractEntityKey(item)),
+				newKeys: newArr.map((item) => extractEntityKey(item))
 			});
-			return patches;
+			break;
 		}
-		const oldFields = snapshotFields(node, storage);
-		removeSubtreeEntries(node, entry.subscription, subscriptions);
-		const newEntity = storage[newValue[EntityLinkKey]];
-		if (!newEntity) {
-			patches.push({
-				type: "set",
-				path: entry.path,
-				value: null
+	}
+	return result.size > 0 ? result : void 0;
+};
+/**
+* @internal
+*/
+const processStructuralChanges = (changes, registry, subscriptions, storage, stalled) => {
+	const result = /* @__PURE__ */ new Map();
+	const processedSubs = /* @__PURE__ */ new Set();
+	for (const change of changes) {
+		const entries = registry.get(change.depKey);
+		if (!entries) continue;
+		for (const entry of entries) {
+			const subId = entry.subscriptionId;
+			if (processedSubs.has(subId)) continue;
+			const sub = subscriptions.get(subId);
+			if (!sub) continue;
+			processedSubs.add(subId);
+			registry.removeAll(sub.cursors);
+			const rootStorageKey = sub.entityKey ?? "__root";
+			const rootValue = storage[rootStorageKey];
+			if (!rootValue) continue;
+			const traceResult = traceSelections(sub.artifact.selections, storage, rootValue, sub.variables, rootStorageKey, [], sub.id);
+			sub.cursors = new Set(traceResult.cursors.map((c) => c.entry));
+			for (const { depKey, entry: cursorEntry } of traceResult.cursors) registry.add(depKey, cursorEntry);
+			if (traceResult.complete) {
+				stalled.delete(subId);
+				const entityArrayChanges = buildEntityArrayContext(changes, traceResult.cursors);
+				const patches = diffSnapshots(sub.data, traceResult.data, entityArrayChanges);
+				sub.data = traceResult.data;
+				if (patches.length > 0) result.set(subId, patches);
+			} else stalled.set(subId, {
+				subscription: sub,
+				missingDeps: traceResult.missingDeps
 			});
-			return patches;
 		}
-		const { fieldValues: newFields } = partialDenormalize(node, newEntity, entry.path, rebuiltDepKeys, storage, subscriptions, entry.subscription);
-		for (const [fieldName, newVal] of newFields) if (!isEqual(oldFields.get(fieldName), newVal)) patches.push({
-			type: "set",
-			path: [...entry.path, fieldName],
-			value: newVal
-		});
-		for (const [fieldName] of oldFields) if (!newFields.has(fieldName)) patches.push({
-			type: "set",
-			path: [...entry.path, fieldName],
-			value: null
+	}
+	return result;
+};
+
+//#endregion
+//#region src/cache/optimistic.ts
+/**
+* CoW optimistic stack that tracks field-level changes for rollback.
+* @internal
+*/
+var OptimisticStack = class {
+	#stack = [];
+	push(key, changes) {
+		this.#stack.push({
+			key,
+			changes
 		});
-		return patches;
-	}
-	if (isEntityLinkArray(oldValue) || isEntityLinkArray(newValue)) {
-		const oldArr = Array.isArray(oldValue) ? oldValue : [];
-		const newArr = Array.isArray(newValue) ? newValue : [];
-		const oldKeys = oldArr.map((item) => item !== null && item !== void 0 && typeof item === "object" && EntityLinkKey in item ? item[EntityLinkKey] : null);
-		const newKeys = newArr.map((item) => item !== null && item !== void 0 && typeof item === "object" && EntityLinkKey in item ? item[EntityLinkKey] : null);
-		const { start, oldEnd, newEnd } = findCommonBounds(oldKeys, newKeys);
-		const oldMiddle = oldKeys.slice(start, oldEnd);
-		const newMiddle = newKeys.slice(start, newEnd);
-		const newMiddleSet = new Set(newMiddle.filter((k) => k !== null));
-		const oldMiddleSet = new Set(oldMiddle.filter((k) => k !== null));
-		const removedIndices = [];
-		for (let i = oldMiddle.length - 1; i >= 0; i--) {
-			const key = oldMiddle[i];
-			if (key !== null && !newMiddleSet.has(key)) removedIndices.push(start + i);
-		}
-		for (const idx of removedIndices) {
-			const childKey = String(idx);
-			const child = node.children.get(childKey);
-			if (child) {
-				removeSubtreeEntries(child, entry.subscription, subscriptions);
-				node.children.delete(childKey);
+	}
+	has(key) {
+		return this.#stack.some((e) => e.key === key);
+	}
+	rollback(key) {
+		const idx = this.#stack.findIndex((e) => e.key === key);
+		if (idx === -1) return [];
+		const entry = this.#stack[idx];
+		this.#stack.splice(idx, 1);
+		const restorations = [];
+		for (const [depKey, { old: oldVal, new: newVal }] of entry.changes) {
+			const laterIdx = this.#stack.slice(idx).findIndex((later) => later.changes.has(depKey));
+			if (laterIdx !== -1) {
+				const laterChange = this.#stack[idx + laterIdx].changes.get(depKey);
+				laterChange.old = oldVal;
+				continue;
 			}
-			patches.push({
-				type: "splice",
-				path: entry.path,
-				index: idx,
-				deleteCount: 1,
-				items: []
+			const earlierEntry = this.#findClosestEarlier(depKey, idx);
+			const restoreValue = earlierEntry === void 0 ? oldVal : earlierEntry;
+			const { storageKey, fieldKey } = parseDependencyKey(depKey);
+			restorations.push({
+				depKey,
+				storageKey,
+				fieldKey,
+				oldValue: newVal,
+				newValue: restoreValue
 			});
 		}
-		compactChildren(node);
-		const retainedOld = oldMiddle.filter((k) => k !== null && newMiddleSet.has(k));
-		const retainedNew = newMiddle.filter((k) => k !== null && oldMiddleSet.has(k));
-		if (retainedOld.length > 0) {
-			const swaps = computeSwaps(retainedOld, retainedNew);
-			for (const { i, j } of swaps) {
-				const absI = start + i;
-				const absJ = start + j;
-				patches.push({
-					type: "swap",
-					path: entry.path,
-					i: absI,
-					j: absJ
-				});
-				const childI = node.children.get(String(absI));
-				const childJ = node.children.get(String(absJ));
-				if (childI && childJ) {
-					node.children.set(String(absI), childJ);
-					node.children.set(String(absJ), childI);
-				}
-			}
-		}
-		const siblingSelections = findSiblingSelections(node);
-		const addedKeys = newMiddle.filter((k) => k !== null && !oldMiddleSet.has(k));
-		for (const key of addedKeys) {
-			const idx = start + newMiddle.indexOf(key);
-			shiftChildrenRight(node, idx);
-			const entity = storage[key];
-			const insertNode = {
-				depKey: "",
-				children: /* @__PURE__ */ new Map(),
-				...siblingSelections && { selections: siblingSelections }
-			};
-			if (entity) {
-				const { data } = partialDenormalize(insertNode, entity, [...entry.path, idx], rebuiltDepKeys, storage, subscriptions, entry.subscription);
-				node.children.set(String(idx), insertNode);
-				patches.push({
-					type: "splice",
-					path: entry.path,
-					index: idx,
-					deleteCount: 0,
-					items: [data]
-				});
-			} else {
-				node.children.set(String(idx), insertNode);
-				patches.push({
-					type: "splice",
-					path: entry.path,
-					index: idx,
-					deleteCount: 0,
-					items: [null]
-				});
-			}
+		return restorations;
+	}
+	#findClosestEarlier(depKey, beforeIdx) {
+		for (let i = beforeIdx - 1; i >= 0; i--) {
+			const entry = this.#stack[i];
+			if (entry.changes.has(depKey)) return entry.changes.get(depKey).new;
 		}
-		rebuildArrayIndices(node, entry, subscriptions);
-		return patches;
 	}
-	return patches;
 };
-const compactChildren = (node) => {
-	const sorted = [...node.children.entries()].toSorted(([a], [b]) => Number(a) - Number(b));
-	node.children.clear();
-	for (const [i, element] of sorted.entries()) node.children.set(String(i), element[1]);
+
+//#endregion
+//#region src/cache/patch.ts
+const copyNode = (node) => Array.isArray(node) ? [...node] : { ...node };
+const shallowCopyPath = (root, path) => {
+	if (path.length === 0) return root;
+	let result = copyNode(root);
+	const top = result;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = path[i];
+		result[key] = copyNode(result[key]);
+		result = result[key];
+	}
+	return top;
 };
-const findSiblingSelections = (node) => {
-	for (const child of node.children.values()) if (child.selections) return child.selections;
-	return node.selections;
+/**
+* Sets a value at a nested path within an object.
+* @param obj - The object to modify.
+* @param path - The path to the target location.
+* @param value - The value to set.
+*/
+const setPath = (obj, path, value) => {
+	let current = obj;
+	for (let i = 0; i < path.length - 1; i++) current = current[path[i]];
+	current[path.at(-1)] = value;
 };
-const shiftChildrenRight = (node, fromIndex) => {
-	const entries = [...node.children.entries()].toSorted(([a], [b]) => Number(a) - Number(b));
-	node.children.clear();
-	for (const [key, child] of entries) {
-		const idx = Number(key);
-		if (idx >= fromIndex) node.children.set(String(idx + 1), child);
-		else node.children.set(key, child);
+/**
+* Gets a value at a nested path within an object.
+* @param obj - The object to read from.
+* @param path - The path to the target location.
+* @returns The value at the path, or the object itself if path is empty.
+*/
+const getPath = (obj, path) => {
+	let current = obj;
+	for (const segment of path) {
+		if (current === void 0 || current === null) return void 0;
+		current = current[segment];
 	}
+	return current;
 };
 /**
-* @internal
+* Applies cache patches to data immutably, shallow-copying only along changed paths.
 */
-const generatePatches = (changedKeys, subscriptions, storage) => {
-	const patchesBySubscription = /* @__PURE__ */ new Map();
-	const rebuiltDepKeys = /* @__PURE__ */ new Set();
-	const { structural, scalar } = classifyChanges(changedKeys);
-	for (const { depKey, oldValue, newValue } of structural) {
-		const entries = subscriptions.get(depKey);
-		if (!entries) continue;
-		for (const entry of entries) {
-			const node = findEntryTreeNode(entry.subscription.entryTree, entry.path);
-			if (!node) continue;
-			const patches = processStructuralChange(entry, node, oldValue, newValue, rebuiltDepKeys, storage, subscriptions);
-			if (patches.length > 0) {
-				const existing = patchesBySubscription.get(entry.subscription) ?? [];
-				existing.push(...patches);
-				patchesBySubscription.set(entry.subscription, existing);
-			}
+const applyPatchesImmutable = (data, patches) => {
+	if (patches.length === 0) return data;
+	let result = data;
+	for (const patch of patches) if (patch.type === "set") {
+		if (patch.path.length === 0) {
+			result = patch.value;
+			continue;
 		}
+		result = shallowCopyPath(result, patch.path);
+		let target = result;
+		for (let i = 0; i < patch.path.length - 1; i++) target = target[patch.path[i]];
+		target[patch.path.at(-1)] = patch.value;
+	} else if (patch.type === "splice") {
+		result = shallowCopyPath(result, patch.path);
+		let target = result;
+		for (const segment of patch.path) target = target[segment];
+		const arr = [...target];
+		arr.splice(patch.index, patch.deleteCount, ...patch.items);
+		let parent = result;
+		for (let i = 0; i < patch.path.length - 1; i++) parent = parent[patch.path[i]];
+		parent[patch.path.at(-1)] = arr;
+	} else if (patch.type === "swap") {
+		result = shallowCopyPath(result, patch.path);
+		let target = result;
+		for (const segment of patch.path) target = target[segment];
+		const arr = [...target];
+		[arr[patch.i], arr[patch.j]] = [arr[patch.j], arr[patch.i]];
+		let parent = result;
+		for (let i = 0; i < patch.path.length - 1; i++) parent = parent[patch.path[i]];
+		parent[patch.path.at(-1)] = arr;
 	}
-	for (const { depKey, newValue } of scalar) {
-		if (rebuiltDepKeys.has(depKey)) continue;
-		const entries = subscriptions.get(depKey);
-		if (!entries) continue;
-		for (const entry of entries) {
-			let patchValue = newValue;
-			const node = findEntryTreeNode(entry.subscription.entryTree, entry.path);
-			if (node?.selections && isNormalizedRecord(newValue)) {
-				const { data } = denormalize(node.selections, storage, newValue, entry.subscription.variables);
-				patchValue = data;
-			}
-			const existing = patchesBySubscription.get(entry.subscription) ?? [];
-			existing.push({
-				type: "set",
-				path: entry.path,
-				value: patchValue
-			});
-			patchesBySubscription.set(entry.subscription, existing);
-		}
+	return result;
+};
+/**
+* Applies cache patches to a mutable target object in place.
+* @param target - The mutable object to apply patches to.
+* @param patches - The patches to apply.
+* @returns The new root value if a root-level set patch was applied, otherwise undefined.
+*/
+const applyPatchesMutable = (target, patches) => {
+	let root;
+	for (const patch of patches) if (patch.type === "set") if (patch.path.length === 0) root = patch.value;
+	else setPath(target, patch.path, patch.value);
+	else if (patch.type === "splice") getPath(target, patch.path).splice(patch.index, patch.deleteCount, ...patch.items);
+	else if (patch.type === "swap") {
+		const arr = getPath(target, patch.path);
+		[arr[patch.i], arr[patch.j]] = [arr[patch.j], arr[patch.i]];
 	}
-	return patchesBySubscription;
+	return root;
 };
 
 //#endregion
@@ -1096,141 +1214,39 @@ const generatePatches = (changedKeys, subscriptions, storage) => {
 var Cache = class {
 	#schemaMeta;
 	#storage = { [RootFieldKey]: {} };
+	#registry = new CursorRegistry();
 	#subscriptions = /* @__PURE__ */ new Map();
+	#stalled = /* @__PURE__ */ new Map();
+	#optimistic = new OptimisticStack();
+	#nextId = 1;
 	#stale = /* @__PURE__ */ new Set();
-	#optimisticKeys = [];
-	#optimisticLayers = /* @__PURE__ */ new Map();
-	#storageView = null;
 	constructor(schemaMetadata) {
 		this.#schemaMeta = schemaMetadata;
 	}
-	#getStorageView() {
-		if (this.#optimisticKeys.length === 0) return this.#storage;
-		if (this.#storageView) return this.#storageView;
-		const merged = { ...this.#storage };
-		for (const storageKey of Object.keys(this.#storage)) merged[storageKey] = { ...this.#storage[storageKey] };
-		for (const key of this.#optimisticKeys) {
-			const layer = this.#optimisticLayers.get(key);
-			if (!layer) continue;
-			for (const storageKey of Object.keys(layer.storage)) merged[storageKey] = merged[storageKey] ? {
-				...merged[storageKey],
-				...layer.storage[storageKey]
-			} : { ...layer.storage[storageKey] };
-		}
-		this.#storageView = merged;
-		return merged;
-	}
-	/**
-	* Writes an optimistic response to a separate cache layer.
-	* The optimistic data is immediately visible in reads but does not affect the base storage.
-	* @internal
-	* @param key - Unique key identifying this optimistic mutation (typically the operation key).
-	* @param artifact - GraphQL document artifact.
-	* @param variables - Operation variables.
-	* @param data - The optimistic response data.
-	*/
-	writeOptimistic(key, artifact, variables, data) {
-		const layerStorage = { [RootFieldKey]: {} };
-		const layerDependencies = /* @__PURE__ */ new Set();
-		normalize(this.#schemaMeta, artifact.selections, layerStorage, data, variables, (storageKey, fieldKey) => {
-			layerDependencies.add(makeDependencyKey(storageKey, fieldKey));
-		});
-		const oldValues = /* @__PURE__ */ new Map();
-		const currentView = this.#getStorageView();
-		for (const depKey of layerDependencies) {
-			const { storageKey: sk, fieldKey: fk } = this.#parseDepKey(depKey);
-			oldValues.set(depKey, currentView[sk]?.[fk]);
-		}
-		this.#optimisticKeys.push(key);
-		this.#optimisticLayers.set(key, {
-			storage: layerStorage,
-			dependencies: layerDependencies
-		});
-		this.#storageView = null;
-		const newView = this.#getStorageView();
-		const changedKeys = /* @__PURE__ */ new Map();
-		for (const depKey of layerDependencies) {
-			const { storageKey: sk, fieldKey: fk } = this.#parseDepKey(depKey);
-			const newVal = newView[sk]?.[fk];
-			const oldVal = oldValues.get(depKey);
-			if (oldVal !== newVal) changedKeys.set(depKey, {
-				oldValue: oldVal,
-				newValue: newVal
-			});
-		}
-		const patchesBySubscription = generatePatches(changedKeys, this.#subscriptions, newView);
-		for (const [subscription, patches] of patchesBySubscription) subscription.listener(patches);
-	}
-	/**
-	* Removes an optimistic layer and notifies affected subscribers.
-	* @internal
-	* @param key - The key of the optimistic layer to remove.
-	*/
-	removeOptimistic(key) {
-		const layer = this.#optimisticLayers.get(key);
-		if (!layer) return;
-		const currentView = this.#getStorageView();
-		const oldValues = /* @__PURE__ */ new Map();
-		for (const depKey of layer.dependencies) {
-			const { storageKey: sk, fieldKey: fk } = this.#parseDepKey(depKey);
-			oldValues.set(depKey, currentView[sk]?.[fk]);
-		}
-		this.#optimisticLayers.delete(key);
-		this.#optimisticKeys = this.#optimisticKeys.filter((k) => k !== key);
-		this.#storageView = null;
-		const newView = this.#getStorageView();
-		const changedKeys = /* @__PURE__ */ new Map();
-		for (const depKey of layer.dependencies) {
-			const { storageKey: sk, fieldKey: fk } = this.#parseDepKey(depKey);
-			const newVal = newView[sk]?.[fk];
-			const oldVal = oldValues.get(depKey);
-			if (oldVal !== newVal) changedKeys.set(depKey, {
-				oldValue: oldVal,
-				newValue: newVal
-			});
-		}
-		const patchesBySubscription = generatePatches(changedKeys, this.#subscriptions, newView);
-		for (const [subscription, patches] of patchesBySubscription) subscription.listener(patches);
-	}
 	/**
 	* Writes a query result to the cache, normalizing entities.
-	* In addition to field-level stale clearing, this also clears entity-level stale entries
-	* (e.g., `"User:1"`) when any field of that entity is written, because {@link invalidate}
-	* supports entity-level invalidation without specifying a field.
 	* @param artifact - GraphQL document artifact.
 	* @param variables - Query variables.
 	* @param data - Query result data.
 	*/
 	writeQuery(artifact, variables, data) {
-		const changedKeys = /* @__PURE__ */ new Map();
+		const changes = [];
 		const staleClearedKeys = /* @__PURE__ */ new Set();
 		const entityStaleCleared = /* @__PURE__ */ new Set();
 		normalize(this.#schemaMeta, artifact.selections, this.#storage, data, variables, (storageKey, fieldKey, oldValue, newValue) => {
 			const depKey = makeDependencyKey(storageKey, fieldKey);
 			if (this.#stale.delete(depKey)) staleClearedKeys.add(depKey);
 			if (!entityStaleCleared.has(storageKey) && this.#stale.delete(storageKey)) entityStaleCleared.add(storageKey);
-			if (oldValue !== newValue) changedKeys.set(depKey, {
+			if (!isEqual(oldValue, newValue)) changes.push({
+				depKey,
+				storageKey,
+				fieldKey,
 				oldValue,
 				newValue
 			});
 		});
-		const patchesBySubscription = generatePatches(changedKeys, this.#subscriptions, this.#storage);
-		for (const [subscription, patches] of patchesBySubscription) subscription.listener(patches);
-		const staleOnlySubscriptions = /* @__PURE__ */ new Set();
-		for (const depKey of staleClearedKeys) {
-			if (changedKeys.has(depKey)) continue;
-			const entries = this.#subscriptions.get(depKey);
-			if (entries) {
-				for (const entry of entries) if (!patchesBySubscription.has(entry.subscription)) staleOnlySubscriptions.add(entry.subscription);
-			}
-		}
-		for (const entityKey of entityStaleCleared) {
-			const prefix = `${entityKey}.`;
-			for (const [depKey, entries] of this.#subscriptions) if (depKey.startsWith(prefix)) {
-				for (const entry of entries) if (!patchesBySubscription.has(entry.subscription)) staleOnlySubscriptions.add(entry.subscription);
-			}
-		}
-		for (const subscription of staleOnlySubscriptions) subscription.listener(null);
+		this.#notifySubscribers(changes);
+		this.#notifyStaleCleared(staleClearedKeys, entityStaleCleared, changes);
 	}
 	/**
 	* Reads a query result from the cache, denormalizing entities if available.
@@ -1240,8 +1256,7 @@ var Cache = class {
 	*/
 	readQuery(artifact, variables) {
 		let stale = false;
-		const storage = this.#getStorageView();
-		const { data, partial } = denormalize(artifact.selections, storage, storage[RootFieldKey], variables, (storageKey, fieldKey) => {
+		const { data, partial } = denormalize(artifact.selections, this.#storage, this.#storage[RootFieldKey], variables, (storageKey, fieldKey) => {
 			if (this.#stale.has(storageKey) || this.#stale.has(makeDependencyKey(storageKey, fieldKey))) stale = true;
 		});
 		if (partial) return {
@@ -1258,49 +1273,46 @@ var Cache = class {
 	* @param artifact - GraphQL document artifact.
 	* @param variables - Query variables.
 	* @param listener - Callback function to invoke on cache changes.
-	* @returns Object containing initial data, stale status, unsubscribe function, and subscription.
+	* @returns Object containing initial data, stale status, and unsubscribe function.
 	*/
 	subscribeQuery(artifact, variables, listener) {
+		const id = this.#nextId++;
+		const vars = variables;
 		let stale = false;
-		const tuples = [];
-		const storageView = this.#getStorageView();
-		const { data, partial } = denormalize(artifact.selections, storageView, storageView[RootFieldKey], variables, (storageKey, fieldKey, path, selections) => {
-			tuples.push({
-				storageKey,
-				fieldKey,
-				path,
-				selections
-			});
-			if (this.#stale.has(storageKey) || this.#stale.has(makeDependencyKey(storageKey, fieldKey))) stale = true;
-		}, { trackFragmentDeps: false });
-		const entryTree = buildEntryTree(tuples);
+		const traceResult = traceSelections(artifact.selections, this.#storage, this.#storage[RootFieldKey], vars, RootFieldKey, [], id);
+		for (const { depKey } of traceResult.cursors) {
+			const { storageKey, fieldKey } = parseDependencyKey(depKey);
+			if (this.#stale.has(storageKey) || this.#stale.has(makeDependencyKey(storageKey, fieldKey))) {
+				stale = true;
+				break;
+			}
+		}
 		const subscription = {
+			id,
+			kind: "query",
+			artifact,
+			variables: vars,
 			listener,
-			selections: artifact.selections,
-			variables,
-			entryTree
+			data: traceResult.complete ? traceResult.data : null,
+			stale,
+			cursors: new Set(traceResult.cursors.map((c) => c.entry))
 		};
-		for (const tuple of tuples) {
-			const depKey = makeDependencyKey(tuple.storageKey, tuple.fieldKey);
-			const entry = {
-				path: tuple.path,
-				subscription
-			};
-			let entrySet = this.#subscriptions.get(depKey);
-			if (!entrySet) {
-				entrySet = /* @__PURE__ */ new Set();
-				this.#subscriptions.set(depKey, entrySet);
-			}
-			entrySet.add(entry);
-		}
+		this.#subscriptions.set(id, subscription);
+		for (const { depKey, entry } of traceResult.cursors) this.#registry.add(depKey, entry);
+		if (!traceResult.complete) this.#stalled.set(id, {
+			subscription,
+			missingDeps: traceResult.missingDeps
+		});
 		const unsubscribe = () => {
-			this.#removeSubscriptionFromTree(entryTree, subscription);
+			this.#registry.removeAll(subscription.cursors);
+			this.#subscriptions.delete(id);
+			this.#stalled.delete(id);
 		};
 		return {
-			data: partial ? null : data,
+			data: subscription.data,
 			stale,
-			unsubscribe,
-			subscription
+			subId: id,
+			unsubscribe
 		};
 	}
 	/**
@@ -1312,14 +1324,13 @@ var Cache = class {
 	readFragment(artifact, fragmentRef) {
 		const storageKey = fragmentRef[FragmentRefKey];
 		const fragmentVars = getFragmentVars(fragmentRef, artifact.name);
-		const storageView = this.#getStorageView();
 		let stale = false;
-		const value = storageView[storageKey];
+		const value = this.#storage[storageKey];
 		if (!value) return {
 			data: null,
 			stale: false
 		};
-		const { data, partial } = denormalize(artifact.selections, storageView, storageKey === RootFieldKey ? value : { [EntityLinkKey]: storageKey }, fragmentVars, (sk, fieldKey) => {
+		const { data, partial } = denormalize(artifact.selections, this.#storage, storageKey === RootFieldKey ? value : { [EntityLinkKey]: storageKey }, fragmentVars, (sk, fieldKey) => {
 			if (this.#stale.has(sk) || this.#stale.has(makeDependencyKey(sk, fieldKey))) stale = true;
 		});
 		if (partial) return {
@@ -1336,81 +1347,86 @@ var Cache = class {
 	* @param artifact - GraphQL fragment artifact.
 	* @param fragmentRef - Fragment reference containing entity key.
 	* @param listener - Callback function to invoke on cache changes.
-	* @returns Object containing initial data, stale status, unsubscribe function, and subscription.
+	* @returns Object containing initial data, stale status, and unsubscribe function.
 	*/
 	subscribeFragment(artifact, fragmentRef, listener) {
 		const storageKey = fragmentRef[FragmentRefKey];
 		const fragmentVars = getFragmentVars(fragmentRef, artifact.name);
-		const storageView = this.#getStorageView();
-		const value = storageKey === RootFieldKey ? storageView[RootFieldKey] : storageView[storageKey];
+		const id = this.#nextId++;
+		const value = storageKey === RootFieldKey ? this.#storage[RootFieldKey] : this.#storage[storageKey];
 		if (!value) {
-			const entryTree = buildEntryTree([]);
+			const subscription = {
+				id,
+				kind: "fragment",
+				artifact,
+				variables: fragmentVars,
+				listener,
+				entityKey: storageKey,
+				data: null,
+				stale: false,
+				cursors: /* @__PURE__ */ new Set()
+			};
+			this.#subscriptions.set(id, subscription);
 			return {
 				data: null,
 				stale: false,
-				unsubscribe: () => {},
-				subscription: {
-					listener,
-					selections: artifact.selections,
-					variables: fragmentVars,
-					entryTree
-				}
+				subId: id,
+				unsubscribe: () => this.#subscriptions.delete(id)
 			};
 		}
 		let stale = false;
-		const tuples = [];
-		const denormalizeValue = storageKey === RootFieldKey ? value : { [EntityLinkKey]: storageKey };
-		const { data, partial } = denormalize(artifact.selections, storageView, denormalizeValue, fragmentVars, (sk, fieldKey, path, selections) => {
-			tuples.push({
-				storageKey: sk,
-				fieldKey,
-				path,
-				selections
-			});
-			if (this.#stale.has(sk) || this.#stale.has(makeDependencyKey(sk, fieldKey))) stale = true;
-		}, { trackFragmentDeps: false });
-		if (partial) {
-			const entryTree = buildEntryTree([]);
+		const denormalizeValue = storageKey === RootFieldKey ? value : value;
+		const traceResult = traceSelections(artifact.selections, this.#storage, denormalizeValue, fragmentVars, storageKey, [], id);
+		for (const { depKey } of traceResult.cursors) {
+			const { storageKey: sk, fieldKey } = parseDependencyKey(depKey);
+			if (this.#stale.has(sk) || this.#stale.has(makeDependencyKey(sk, fieldKey))) {
+				stale = true;
+				break;
+			}
+		}
+		if (!traceResult.complete) {
+			const subscription = {
+				id,
+				kind: "fragment",
+				artifact,
+				variables: fragmentVars,
+				listener,
+				entityKey: storageKey,
+				data: null,
+				stale: false,
+				cursors: /* @__PURE__ */ new Set()
+			};
+			this.#subscriptions.set(id, subscription);
 			return {
 				data: null,
 				stale: false,
-				unsubscribe: () => {},
-				subscription: {
-					listener,
-					selections: artifact.selections,
-					variables: fragmentVars,
-					entryTree
-				}
+				subId: id,
+				unsubscribe: () => this.#subscriptions.delete(id)
 			};
 		}
-		const entryTree = buildEntryTree(tuples, storageKey === RootFieldKey ? void 0 : storageKey);
 		const subscription = {
-			listener,
-			selections: artifact.selections,
+			id,
+			kind: "fragment",
+			artifact,
 			variables: fragmentVars,
-			entryTree
+			listener,
+			entityKey: storageKey,
+			data: traceResult.data,
+			stale,
+			cursors: new Set(traceResult.cursors.map((c) => c.entry))
 		};
-		for (const tuple of tuples) {
-			const depKey = makeDependencyKey(tuple.storageKey, tuple.fieldKey);
-			const entry = {
-				path: tuple.path,
-				subscription
-			};
-			let entrySet = this.#subscriptions.get(depKey);
-			if (!entrySet) {
-				entrySet = /* @__PURE__ */ new Set();
-				this.#subscriptions.set(depKey, entrySet);
-			}
-			entrySet.add(entry);
-		}
+		this.#subscriptions.set(id, subscription);
+		for (const { depKey, entry } of traceResult.cursors) this.#registry.add(depKey, entry);
 		const unsubscribe = () => {
-			this.#removeSubscriptionFromTree(entryTree, subscription);
+			this.#registry.removeAll(subscription.cursors);
+			this.#subscriptions.delete(id);
+			this.#stalled.delete(id);
 		};
 		return {
-			data: partial ? null : data,
+			data: traceResult.data,
 			stale,
-			unsubscribe,
-			subscription
+			subId: id,
+			unsubscribe
 		};
 	}
 	readFragments(artifact, fragmentRefs) {
@@ -1441,6 +1457,45 @@ var Cache = class {
 		};
 	}
 	/**
+	* Writes an optimistic response to the cache.
+	* @internal
+	*/
+	writeOptimistic(key, artifact, variables, data) {
+		const changes = [];
+		const optimisticChanges = /* @__PURE__ */ new Map();
+		normalize(this.#schemaMeta, artifact.selections, this.#storage, data, variables, (storageKey, fieldKey, oldValue, newValue) => {
+			const depKey = makeDependencyKey(storageKey, fieldKey);
+			if (!isEqual(oldValue, newValue)) {
+				changes.push({
+					depKey,
+					storageKey,
+					fieldKey,
+					oldValue,
+					newValue
+				});
+				optimisticChanges.set(depKey, {
+					old: oldValue,
+					new: newValue
+				});
+			}
+		});
+		this.#optimistic.push(key, optimisticChanges);
+		this.#notifySubscribers(changes);
+	}
+	/**
+	* Removes an optimistic layer and notifies affected subscribers.
+	* @internal
+	*/
+	removeOptimistic(key) {
+		const restorations = this.#optimistic.rollback(key);
+		for (const restoration of restorations) {
+			const { storageKey, fieldKey, newValue } = restoration;
+			const fields = this.#storage[storageKey];
+			if (fields) fields[fieldKey] = newValue;
+		}
+		this.#notifySubscribers(restorations);
+	}
+	/**
 	* Invalidates one or more cache entries and notifies affected subscribers.
 	* @param targets - Cache entries to invalidate.
 	*/
@@ -1450,10 +1505,10 @@ var Cache = class {
 			const fieldKey = makeFieldKeyFromArgs(target.$field, target.$args);
 			const depKey = makeDependencyKey(RootFieldKey, fieldKey);
 			this.#stale.add(depKey);
-			this.#collectSubscriptions(RootFieldKey, fieldKey, affectedSubscriptions);
+			this.#collectAffectedSubscriptions(RootFieldKey, fieldKey, affectedSubscriptions);
 		} else {
 			this.#stale.add(RootFieldKey);
-			this.#collectSubscriptions(RootFieldKey, void 0, affectedSubscriptions);
+			this.#collectAffectedSubscriptions(RootFieldKey, void 0, affectedSubscriptions);
 		}
 		else {
 			const keyFields = this.#schemaMeta.entities[target.__typename]?.keyFields;
@@ -1463,10 +1518,10 @@ var Cache = class {
 				if ("$field" in target) {
 					const fieldKey = makeFieldKeyFromArgs(target.$field, target.$args);
 					this.#stale.add(makeDependencyKey(entityKey, fieldKey));
-					this.#collectSubscriptions(entityKey, fieldKey, affectedSubscriptions);
+					this.#collectAffectedSubscriptions(entityKey, fieldKey, affectedSubscriptions);
 				} else {
 					this.#stale.add(entityKey);
-					this.#collectSubscriptions(entityKey, void 0, affectedSubscriptions);
+					this.#collectAffectedSubscriptions(entityKey, void 0, affectedSubscriptions);
 				}
 			} else {
 				const prefix = `${target.__typename}:`;
@@ -1475,61 +1530,33 @@ var Cache = class {
 					if ("$field" in target) {
 						const fieldKey = makeFieldKeyFromArgs(target.$field, target.$args);
 						this.#stale.add(makeDependencyKey(entityKey, fieldKey));
-						this.#collectSubscriptions(entityKey, fieldKey, affectedSubscriptions);
+						this.#collectAffectedSubscriptions(entityKey, fieldKey, affectedSubscriptions);
 					} else {
 						this.#stale.add(entityKey);
-						this.#collectSubscriptions(entityKey, void 0, affectedSubscriptions);
+						this.#collectAffectedSubscriptions(entityKey, void 0, affectedSubscriptions);
 					}
 				}
 			}
 		}
-		for (const subscription of affectedSubscriptions) subscription.listener(null);
+		const subsToNotify = [];
+		for (const subId of affectedSubscriptions) {
+			const sub = this.#subscriptions.get(subId);
+			if (sub) {
+				sub.stale = true;
+				subsToNotify.push(sub);
+			}
+		}
+		for (const sub of subsToNotify) if (sub.stale) sub.listener({ type: "stale" });
 	}
 	/**
 	* Checks if a subscription has stale data.
 	* @internal
 	*/
-	isStale(subscription) {
-		const check = (node) => {
-			if (node.depKey.includes("@")) {
-				const { storageKey } = parseDependencyKey(node.depKey);
-				if (this.#stale.has(storageKey) || this.#stale.has(node.depKey)) return true;
-			}
-			for (const child of node.children.values()) if (check(child)) return true;
-			return false;
-		};
-		return check(subscription.entryTree);
-	}
-	#hasKeyFields(target, keyFields) {
-		return keyFields.every((f) => f in target);
-	}
-	#collectSubscriptions(storageKey, fieldKey, out) {
-		if (fieldKey === void 0) {
-			const prefix = `${storageKey}.`;
-			for (const [depKey, entries] of this.#subscriptions) if (depKey.startsWith(prefix)) for (const entry of entries) out.add(entry.subscription);
-		} else {
-			const depKey = makeDependencyKey(storageKey, fieldKey);
-			const entries = this.#subscriptions.get(depKey);
-			if (entries) for (const entry of entries) out.add(entry.subscription);
-		}
-	}
-	#removeSubscriptionFromTree(node, subscription) {
-		const entries = this.#subscriptions.get(node.depKey);
-		if (entries) {
-			for (const entry of entries) if (entry.subscription === subscription) {
-				entries.delete(entry);
-				break;
-			}
-			if (entries.size === 0) this.#subscriptions.delete(node.depKey);
-		}
-		for (const child of node.children.values()) this.#removeSubscriptionFromTree(child, subscription);
-	}
-	#parseDepKey(depKey) {
-		return parseDependencyKey(depKey);
+	isStale(subId) {
+		return this.#subscriptions.get(subId)?.stale ?? false;
 	}
 	/**
 	* Extracts a serializable snapshot of the cache storage.
-	* Optimistic layers are excluded because they represent transient in-flight state.
 	*/
 	extract() {
 		return { storage: structuredClone(this.#storage) };
@@ -1543,18 +1570,100 @@ var Cache = class {
 			...this.#storage[key],
 			...fields
 		};
-		this.#storageView = null;
 	}
 	/**
 	* Clears all cache data.
 	*/
 	clear() {
 		this.#storage = { [RootFieldKey]: {} };
+		this.#registry.clear();
 		this.#subscriptions.clear();
+		this.#stalled.clear();
 		this.#stale.clear();
-		this.#optimisticKeys = [];
-		this.#optimisticLayers.clear();
-		this.#storageView = null;
+	}
+	#notifySubscribers(changes) {
+		if (changes.length === 0) return;
+		const unstalledPatches = this.#checkStalled(changes);
+		const { scalar, structural } = classifyChanges(changes);
+		const scalarPatches = processScalarChanges(scalar, this.#registry, this.#subscriptions);
+		const structuralPatches = processStructuralChanges(structural, this.#registry, this.#subscriptions, this.#storage, this.#stalled);
+		const allPatches = /* @__PURE__ */ new Map();
+		for (const [subId, patches] of unstalledPatches) allPatches.set(subId, patches);
+		for (const [subId, patches] of scalarPatches) {
+			if (unstalledPatches.has(subId)) continue;
+			allPatches.set(subId, [...allPatches.get(subId) ?? [], ...patches]);
+		}
+		for (const [subId, patches] of structuralPatches) {
+			if (unstalledPatches.has(subId)) continue;
+			allPatches.set(subId, [...allPatches.get(subId) ?? [], ...patches]);
+		}
+		for (const [subId, patches] of allPatches) {
+			const sub = this.#subscriptions.get(subId);
+			if (sub && patches.length > 0) {
+				if (!structuralPatches.has(subId) && !unstalledPatches.has(subId)) sub.data = applyPatchesImmutable(sub.data, patches);
+				sub.listener({
+					type: "patch",
+					patches
+				});
+			}
+		}
+	}
+	#checkStalled(changes) {
+		const result = /* @__PURE__ */ new Map();
+		const writtenDepKeys = new Set(changes.map((c) => c.depKey));
+		for (const [subId, info] of this.#stalled) {
+			if (![...info.missingDeps].some((dep) => writtenDepKeys.has(dep))) continue;
+			const sub = info.subscription;
+			const rootStorageKey = sub.entityKey ?? RootFieldKey;
+			const rootValue = this.#storage[rootStorageKey];
+			if (!rootValue) continue;
+			const traceResult = traceSelections(sub.artifact.selections, this.#storage, rootValue, sub.variables, rootStorageKey, [], sub.id);
+			if (traceResult.complete) {
+				this.#registry.removeAll(sub.cursors);
+				sub.cursors = new Set(traceResult.cursors.map((c) => c.entry));
+				for (const { depKey, entry } of traceResult.cursors) this.#registry.add(depKey, entry);
+				this.#stalled.delete(subId);
+				const entityArrayChanges = buildEntityArrayContext(changes, traceResult.cursors);
+				const patches = diffSnapshots(sub.data, traceResult.data, entityArrayChanges);
+				if (patches.length > 0) {
+					sub.data = traceResult.data;
+					result.set(subId, patches);
+				}
+			} else info.missingDeps = traceResult.missingDeps;
+		}
+		return result;
+	}
+	#notifyStaleCleared(staleClearedKeys, entityStaleCleared, changes) {
+		const changedDepKeys = new Set(changes.map((c) => c.depKey));
+		const notifiedSubs = /* @__PURE__ */ new Set();
+		for (const depKey of staleClearedKeys) {
+			if (changedDepKeys.has(depKey)) continue;
+			const entries = this.#registry.get(depKey);
+			if (entries) for (const entry of entries) notifiedSubs.add(entry.subscriptionId);
+		}
+		for (const entityKey of entityStaleCleared) this.#registry.forEachByPrefix(`${entityKey}.`, (entry) => {
+			notifiedSubs.add(entry.subscriptionId);
+		});
+		for (const subId of notifiedSubs) {
+			const sub = this.#subscriptions.get(subId);
+			if (sub?.stale) {
+				sub.stale = false;
+				sub.listener({ type: "stale" });
+			}
+		}
+	}
+	#hasKeyFields(target, keyFields) {
+		return keyFields.every((f) => f in target);
+	}
+	#collectAffectedSubscriptions(storageKey, fieldKey, out) {
+		if (fieldKey === void 0) this.#registry.forEachByPrefix(`${storageKey}.`, (entry) => {
+			out.add(entry.subscriptionId);
+		});
+		else {
+			const depKey = makeDependencyKey(storageKey, fieldKey);
+			const entries = this.#registry.get(depKey);
+			if (entries) for (const entry of entries) out.add(entry.subscriptionId);
+		}
 	}
 };
 
@@ -1587,7 +1696,6 @@ const cacheExchange = (options = {}) => {
 			},
 			io: (ops$) => {
 				const subscriptionHasData = /* @__PURE__ */ new Map();
-				const resubscribe$ = makeSubject();
 				const refetch$ = makeSubject();
 				const fragment$ = pipe(ops$, filter((op) => op.variant === "request" && op.artifact.kind === "fragment"), mergeMap((op) => {
 					const fragmentRef = op.metadata?.fragment?.ref;
@@ -1598,11 +1706,10 @@ const cacheExchange = (options = {}) => {
 					if (isFragmentRefArray(fragmentRef)) {
 						const results = makeSubject();
 						const unsubscribes = [];
-						const fragmentSubscriptions = [];
 						for (const [index, ref] of fragmentRef.entries()) {
-							const patchListener = (patches) => {
-								if (patches) {
-									const indexedPatches = patches.map((patch) => ({
+							const listener = (notification) => {
+								if (notification.type === "patch") {
+									const indexedPatches = notification.patches.map((patch) => ({
 										...patch,
 										path: [index, ...patch.path]
 									}));
@@ -1612,21 +1719,17 @@ const cacheExchange = (options = {}) => {
 										errors: []
 									});
 								} else {
-									const sub = fragmentSubscriptions[index];
-									if (sub && cache.isStale(sub)) {
-										const { data, stale } = cache.readFragments(op.artifact, fragmentRef);
-										if (data !== null) results.next({
-											operation: op,
-											data,
-											...stale && { metadata: { cache: { stale: true } } },
-											errors: []
-										});
-									}
+									const { data, stale } = cache.readFragments(op.artifact, fragmentRef);
+									if (data !== null && stale) results.next({
+										operation: op,
+										data,
+										metadata: { cache: { stale: true } },
+										errors: []
+									});
 								}
 							};
-							const { unsubscribe, subscription } = cache.subscribeFragment(op.artifact, ref, patchListener);
+							const { unsubscribe } = cache.subscribeFragment(op.artifact, ref, listener);
 							unsubscribes.push(unsubscribe);
-							fragmentSubscriptions.push(subscription);
 						}
 						const { data: initialData, stale: initialStale } = cache.readFragments(op.artifact, fragmentRef);
 						const teardown$ = pipe(ops$, filter((operation) => operation.variant === "teardown" && operation.key === op.key), tap(() => {
@@ -1646,31 +1749,25 @@ const cacheExchange = (options = {}) => {
 						errors: []
 					});
 					const results = makeSubject();
-					let currentUnsubscribe = null;
-					let currentSubscription = null;
-					const patchListener = (patches) => {
-						if (patches) results.next({
+					const listener = (notification) => {
+						if (notification.type === "patch") results.next({
 							operation: op,
-							metadata: { cache: { patches } },
+							metadata: { cache: { patches: notification.patches } },
 							errors: []
 						});
-						else if (currentSubscription) {
-							if (cache.isStale(currentSubscription)) {
-								const { data: staleData } = cache.readFragment(op.artifact, fragmentRef);
-								if (staleData !== null) results.next({
-									operation: op,
-									data: staleData,
-									metadata: { cache: { stale: true } },
-									errors: []
-								});
-							}
+						else {
+							const { data: staleData, stale: isStale } = cache.readFragment(op.artifact, fragmentRef);
+							if (staleData !== null && isStale) results.next({
+								operation: op,
+								data: staleData,
+								metadata: { cache: { stale: true } },
+								errors: []
+							});
 						}
 					};
-					const { data, stale, unsubscribe, subscription } = cache.subscribeFragment(op.artifact, fragmentRef, patchListener);
-					currentUnsubscribe = unsubscribe;
-					currentSubscription = subscription;
+					const { data, stale, unsubscribe } = cache.subscribeFragment(op.artifact, fragmentRef, listener);
 					const teardown$ = pipe(ops$, filter((operation) => operation.variant === "teardown" && operation.key === op.key), tap(() => {
-						if (currentUnsubscribe) currentUnsubscribe();
+						unsubscribe();
 						results.complete();
 					}));
 					return pipe(merge(data === null ? empty() : fromValue({
@@ -1686,50 +1783,34 @@ const cacheExchange = (options = {}) => {
 				const query$ = pipe(ops$, filter((op) => op.variant === "request" && op.artifact.kind === "query" && fetchPolicy !== "network-only"), share());
 				return merge(fragment$, pipe(query$, mergeMap((op) => {
 					const results = makeSubject();
-					let currentUnsubscribe = null;
-					let currentSubscription = null;
-					let initialized = false;
-					const doSubscribe = () => {
-						if (currentUnsubscribe) currentUnsubscribe();
-						const patchListener = (patches) => {
-							if (patches) {
-								if (!initialized) return;
-								results.next({
+					const listener = (notification) => {
+						if (notification.type === "patch") {
+							if (!subscriptionHasData.get(op.key)) return;
+							results.next({
+								operation: op,
+								metadata: { cache: { patches: notification.patches } },
+								errors: []
+							});
+						} else {
+							const { data: staleData, stale: isStale } = cache.readQuery(op.artifact, op.variables);
+							if (isStale) {
+								if (staleData !== null) results.next({
 									operation: op,
-									metadata: { cache: { patches } },
+									data: staleData,
+									metadata: { cache: { stale: true } },
 									errors: []
 								});
-							} else if (currentSubscription) {
-								if (cache.isStale(currentSubscription)) {
-									const { data: staleData } = cache.readQuery(op.artifact, op.variables);
-									if (staleData !== null) results.next({
-										operation: op,
-										data: staleData,
-										metadata: { cache: { stale: true } },
-										errors: []
-									});
-									refetch$.next(op);
-								}
+								refetch$.next(op);
 							}
-						};
-						const result = cache.subscribeQuery(op.artifact, op.variables, patchListener);
-						currentUnsubscribe = result.unsubscribe;
-						currentSubscription = result.subscription;
-						return result;
+						}
 					};
-					const { data, stale } = doSubscribe();
+					const { data, stale, unsubscribe } = cache.subscribeQuery(op.artifact, op.variables, listener);
 					subscriptionHasData.set(op.key, data !== null);
-					if (data !== null) initialized = true;
 					const teardown$ = pipe(ops$, filter((o) => o.variant === "teardown" && o.key === op.key), tap(() => {
-						if (currentUnsubscribe) currentUnsubscribe();
+						unsubscribe();
 						subscriptionHasData.delete(op.key);
 						results.complete();
 					}));
-					const resubStream$ = pipe(resubscribe$.source, filter((key) => key === op.key), mergeMap(() => {
-						doSubscribe();
-						initialized = true;
-						return empty();
-					}));
 					const stream$ = pipe(merge(data === null ? fetchPolicy === "cache-only" ? fromValue({
 						operation: op,
 						data: null,
@@ -1739,7 +1820,7 @@ const cacheExchange = (options = {}) => {
 						data,
 						...stale && { metadata: { cache: { stale: true } } },
 						errors: []
-					}), results.source, resubStream$), takeUntil(teardown$));
+					}), results.source), takeUntil(teardown$));
 					if (stale) refetch$.next(op);
 					return stream$;
 				}), filter(() => fetchPolicy === "cache-only" || fetchPolicy === "cache-and-network" || fetchPolicy === "cache-first")), pipe(merge(nonCache$, pipe(query$, filter((op) => {
@@ -1759,7 +1840,6 @@ const cacheExchange = (options = {}) => {
 						});
 					}
 					subscriptionHasData.set(result.operation.key, true);
-					resubscribe$.next(result.operation.key);
 					const { data } = cache.readQuery(result.operation.artifact, result.operation.variables);
 					if (data !== null) return fromValue({
 						...result,
@@ -1776,99 +1856,6 @@ const cacheExchange = (options = {}) => {
 	};
 };
 
-//#endregion
-//#region src/cache/patch.ts
-const copyNode = (node) => Array.isArray(node) ? [...node] : { ...node };
-const shallowCopyPath = (root, path) => {
-	if (path.length === 0) return root;
-	let result = copyNode(root);
-	const top = result;
-	for (let i = 0; i < path.length - 1; i++) {
-		const key = path[i];
-		result[key] = copyNode(result[key]);
-		result = result[key];
-	}
-	return top;
-};
-/**
-* Sets a value at a nested path within an object.
-* @param obj - The object to modify.
-* @param path - The path to the target location.
-* @param value - The value to set.
-*/
-const setPath = (obj, path, value) => {
-	let current = obj;
-	for (let i = 0; i < path.length - 1; i++) current = current[path[i]];
-	current[path.at(-1)] = value;
-};
-/**
-* Gets a value at a nested path within an object.
-* @param obj - The object to read from.
-* @param path - The path to the target location.
-* @returns The value at the path, or the object itself if path is empty.
-*/
-const getPath = (obj, path) => {
-	let current = obj;
-	for (const segment of path) {
-		if (current === void 0 || current === null) return void 0;
-		current = current[segment];
-	}
-	return current;
-};
-/**
-* Applies cache patches to data immutably, shallow-copying only along changed paths.
-*/
-const applyPatchesImmutable = (data, patches) => {
-	if (patches.length === 0) return data;
-	let result = data;
-	for (const patch of patches) if (patch.type === "set") {
-		if (patch.path.length === 0) {
-			result = patch.value;
-			continue;
-		}
-		result = shallowCopyPath(result, patch.path);
-		let target = result;
-		for (let i = 0; i < patch.path.length - 1; i++) target = target[patch.path[i]];
-		target[patch.path.at(-1)] = patch.value;
-	} else if (patch.type === "splice") {
-		result = shallowCopyPath(result, patch.path);
-		let target = result;
-		for (const segment of patch.path) target = target[segment];
-		const arr = [...target];
-		arr.splice(patch.index, patch.deleteCount, ...patch.items);
-		let parent = result;
-		for (let i = 0; i < patch.path.length - 1; i++) parent = parent[patch.path[i]];
-		parent[patch.path.at(-1)] = arr;
-	} else if (patch.type === "swap") {
-		result = shallowCopyPath(result, patch.path);
-		let target = result;
-		for (const segment of patch.path) target = target[segment];
-		const arr = [...target];
-		[arr[patch.i], arr[patch.j]] = [arr[patch.j], arr[patch.i]];
-		let parent = result;
-		for (let i = 0; i < patch.path.length - 1; i++) parent = parent[patch.path[i]];
-		parent[patch.path.at(-1)] = arr;
-	}
-	return result;
-};
-/**
-* Applies cache patches to a mutable target object in place.
-* @param target - The mutable object to apply patches to.
-* @param patches - The patches to apply.
-* @returns The new root value if a root-level set patch was applied, otherwise undefined.
-*/
-const applyPatchesMutable = (target, patches) => {
-	let root;
-	for (const patch of patches) if (patch.type === "set") if (patch.path.length === 0) root = patch.value;
-	else setPath(target, patch.path, patch.value);
-	else if (patch.type === "splice") getPath(target, patch.path).splice(patch.index, patch.deleteCount, ...patch.items);
-	else if (patch.type === "swap") {
-		const arr = getPath(target, patch.path);
-		[arr[patch.i], arr[patch.j]] = [arr[patch.j], arr[patch.i]];
-	}
-	return root;
-};
-
 //#endregion
 //#region src/exchanges/retry.ts
 const defaultShouldRetry = (error) => isExchangeError(error, "http") && error.extensions?.statusCode !== void 0 && error.extensions.statusCode >= 500;
@@ -2059,7 +2046,7 @@ const subscriptionExchange = (options) => {
 				return pipe(make((observer) => {
 					let unsubscribe;
 					let completed = false;
-					Promise.resolve().then(() => {
+					const doSubscribe = () => {
 						if (completed) return;
 						unsubscribe = client.subscribe({
 							operationName: op.artifact.name,
@@ -2068,16 +2055,28 @@ const subscriptionExchange = (options) => {
 						}, {
 							next: (result) => {
 								const response = result;
-								observer.next({
-									operation: op,
-									data: response.data,
-									errors: response.errors?.map((err) => new GraphQLError(err.message, {
-										path: err.path,
-										locations: err.locations,
-										extensions: err.extensions
-									})),
-									extensions: response.extensions
-								});
+								try {
+									observer.next({
+										operation: op,
+										data: response.data,
+										errors: response.errors?.map((err) => new GraphQLError(err.message, {
+											path: err.path,
+											locations: err.locations,
+											extensions: err.extensions
+										})),
+										extensions: response.extensions
+									});
+								} catch (error) {
+									try {
+										observer.next({
+											operation: op,
+											errors: [new ExchangeError(error instanceof Error ? error.message : String(error), {
+												exchangeName: "subscription",
+												cause: error
+											})]
+										});
+									} catch {}
+								}
 							},
 							error: (error) => {
 								observer.next({
@@ -2087,11 +2086,13 @@ const subscriptionExchange = (options) => {
 										cause: error
 									})]
 								});
-								observer.complete();
+								unsubscribe = void 0;
+								Promise.resolve().then(doSubscribe);
 							},
 							complete: observer.complete
 						});
-					});
+					};
+					Promise.resolve().then(doSubscribe);
 					return () => {
 						completed = true;
 						unsubscribe?.();