@mearie/core 0.5.2 → 0.6.1

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { C as mergeMap, S as filter, a as finalize, b as merge, c as share, d as map, i as fromValue, l as takeUntil, m as collect, n as fromSubscription, o as initialize, r as makeSubject, s as switchMap, t as make, u as take, v as fromArray, w as pipe, x as fromPromise, y as tap } from "./make-C7I1YIXm.mjs";
+import { C as mergeMap, S as filter, a as finalize, b as merge, c as share, d as map, i as fromValue, l as takeUntil, m as collect, o as initialize, r as makeSubject, t as make, u as take, v as fromArray, w as pipe, x as fromPromise, y as tap } from "./make-C7I1YIXm.mjs";
 
 //#region src/errors.ts
 /**
@@ -359,15 +359,6 @@ const makeFieldKey = (selection, variables) => {
 	return `${selection.name}@${args}`;
 };
 /**
-* Generates a unique key for tracking memoized denormalized results for structural sharing.
-* @internal
-* @param kind - The operation kind ('query', 'fragment', 'fragments').
-* @param name - The artifact name.
-* @param id - Serialized identifier (variables, entity key, etc.).
-* @returns A unique memo key.
-*/
-const makeMemoKey = (kind, name, id) => `${kind}:${name}:${id}`;
-/**
 * Gets a unique key for tracking a field dependency.
 * @internal
 * @param storageKey Storage key (entity or root query key).
@@ -444,43 +435,6 @@ const isEqual = (a, b) => {
 	}
 	return false;
 };
-/**
-* Recursively replaces a new value tree with the previous one wherever structurally equal,
-* preserving referential identity for unchanged subtrees.
-*
-* Returns `prev` (same reference) when the entire subtree is structurally equal.
-* @internal
-*/
-const replaceEqualDeep = (prev, next) => {
-	if (prev === next) return prev;
-	if (typeof prev !== typeof next || prev === null || next === null || typeof prev !== "object") return next;
-	if (Array.isArray(prev)) {
-		if (!Array.isArray(next)) return next;
-		let allSame = prev.length === next.length;
-		const result = [];
-		for (const [i, item] of next.entries()) {
-			const shared = i < prev.length ? replaceEqualDeep(prev[i], item) : item;
-			result.push(shared);
-			if (shared !== prev[i]) allSame = false;
-		}
-		return allSame ? prev : result;
-	}
-	if (Array.isArray(next)) return next;
-	const prevObj = prev;
-	const nextObj = next;
-	const nextKeys = Object.keys(nextObj);
-	const prevKeys = Object.keys(prevObj);
-	let allSame = nextKeys.length === prevKeys.length;
-	const result = {};
-	for (const key of nextKeys) if (key in prevObj) {
-		result[key] = replaceEqualDeep(prevObj[key], nextObj[key]);
-		if (result[key] !== prevObj[key]) allSame = false;
-	} else {
-		result[key] = nextObj[key];
-		allSame = false;
-	}
-	return allSame ? prev : result;
-};
 const NormalizedKey = Symbol("mearie.normalized");
 /**
 * Marks a record as a normalized cache object so that {@link mergeFields}
@@ -534,6 +488,48 @@ const mergeFields = (target, source, deep) => {
 const makeFieldKeyFromArgs = (field, args) => {
 	return `${field}@${args && Object.keys(args).length > 0 ? stringify(args) : "{}"}`;
 };
+/**
+* Type guard to check if a value is an array containing entity links.
+* @internal
+* @param value - Value to check.
+* @returns True if the value is an array containing at least one entity link.
+*/
+const isEntityLinkArray = (value) => {
+	if (!Array.isArray(value) || value.length === 0) return false;
+	for (const item of value) {
+		if (item === null || item === void 0) continue;
+		if (typeof item === "object" && !Array.isArray(item) && EntityLinkKey in item) return true;
+		if (Array.isArray(item) && isEntityLinkArray(item)) return true;
+		return false;
+	}
+	return false;
+};
+/**
+* Compares two entity link arrays by their entity keys.
+* @internal
+* @param a - First entity link array.
+* @param b - Second entity link array.
+* @returns True if both arrays have the same entity keys at each position.
+*/
+const isEntityLinkArrayEqual = (a, b) => {
+	if (a.length !== b.length) return false;
+	for (const [i, element] of a.entries()) if ((element?.[EntityLinkKey] ?? null) !== (b[i]?.[EntityLinkKey] ?? null)) return false;
+	return true;
+};
+/**
+* Parses a dependency key into its storage key and field key components.
+* @internal
+* @param depKey - The dependency key to parse.
+* @returns The storage key and field key.
+*/
+const parseDependencyKey = (depKey) => {
+	const atIdx = depKey.indexOf("@");
+	const dotIdx = depKey.lastIndexOf(".", atIdx);
+	return {
+		storageKey: depKey.slice(0, dotIdx),
+		fieldKey: depKey.slice(dotIdx + 1)
+	};
+};
 
 //#endregion
 //#region src/cache/normalize.ts
@@ -597,59 +593,500 @@ const typenameFieldKey = makeFieldKey({
 	name: "__typename",
 	type: "String"
 }, {});
-const denormalize = (selections, storage, value, variables, accessor) => {
+const denormalize = (selections, storage, value, variables, accessor, options) => {
 	let partial = false;
-	const denormalizeField = (storageKey, selections, value) => {
+	const denormalizeField = (storageKey, selections, value, path) => {
 		if (isNullish(value)) return value;
-		if (Array.isArray(value)) return value.map((item) => denormalizeField(storageKey, selections, item));
+		if (Array.isArray(value)) return value.map((item, i) => denormalizeField(storageKey, selections, item, [...path, i]));
 		const data = value;
 		if (isEntityLink(data)) {
 			const entityKey = data[EntityLinkKey];
 			const entity = storage[entityKey];
 			if (!entity) {
-				accessor?.(entityKey, typenameFieldKey);
+				accessor?.(entityKey, typenameFieldKey, path);
 				partial = true;
 				return null;
 			}
-			return denormalizeField(entityKey, selections, entity);
+			return denormalizeField(entityKey, selections, entity, path);
 		}
 		const fields = {};
 		for (const selection of selections) if (selection.kind === "Field") {
 			const fieldKey = makeFieldKey(selection, variables);
 			const fieldValue = data[fieldKey];
-			if (storageKey !== null) accessor?.(storageKey, fieldKey);
+			const fieldPath = [...path, selection.alias ?? selection.name];
+			if (storageKey !== null) accessor?.(storageKey, fieldKey, fieldPath, selection.selections);
 			if (fieldValue === void 0) {
 				partial = true;
 				continue;
 			}
 			const name = selection.alias ?? selection.name;
-			const value = selection.selections ? denormalizeField(null, selection.selections, fieldValue) : fieldValue;
-			if (name in fields) mergeFields(fields, { [name]: value }, true);
-			else fields[name] = value;
+			const resolvedValue = selection.selections ? denormalizeField(null, selection.selections, fieldValue, fieldPath) : fieldValue;
+			if (name in fields) mergeFields(fields, { [name]: resolvedValue }, true);
+			else fields[name] = resolvedValue;
 		} else if (selection.kind === "FragmentSpread") if (storageKey !== null && storageKey !== RootFieldKey) {
 			fields[FragmentRefKey] = storageKey;
-			if (selection.args) {
-				const resolvedArgs = resolveArguments(selection.args, variables);
-				const mergedVars = {
-					...variables,
-					...resolvedArgs
-				};
-				fields[FragmentVarsKey] = {
-					...fields[FragmentVarsKey],
-					[selection.name]: mergedVars
-				};
+			const merged = selection.args ? {
+				...variables,
+				...resolveArguments(selection.args, variables)
+			} : { ...variables };
+			fields[FragmentVarsKey] = {
+				...fields[FragmentVarsKey],
+				[selection.name]: merged
+			};
+			if (accessor) {
+				if (denormalize(selection.selections, storage, { [EntityLinkKey]: storageKey }, variables, options?.trackFragmentDeps === false ? void 0 : accessor, options).partial) partial = true;
+			}
+		} else if (storageKey === RootFieldKey) {
+			fields[FragmentRefKey] = RootFieldKey;
+			const merged = selection.args ? {
+				...variables,
+				...resolveArguments(selection.args, variables)
+			} : { ...variables };
+			fields[FragmentVarsKey] = {
+				...fields[FragmentVarsKey],
+				[selection.name]: merged
+			};
+			if (accessor) {
+				if (denormalize(selection.selections, storage, storage[RootFieldKey], variables, options?.trackFragmentDeps === false ? void 0 : accessor, options).partial) partial = true;
 			}
-			if (accessor) denormalize(selection.selections, storage, { [EntityLinkKey]: storageKey }, variables, accessor);
-		} else mergeFields(fields, denormalizeField(storageKey, selection.selections, value), true);
-		else if (selection.kind === "InlineFragment" && selection.on === data[typenameFieldKey]) mergeFields(fields, denormalizeField(storageKey, selection.selections, value), 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);
 		return fields;
 	};
 	return {
-		data: denormalizeField(RootFieldKey, selections, value),
+		data: denormalizeField(RootFieldKey, selections, value, []),
 		partial
 	};
 };
 
+//#endregion
+//#region src/cache/tree.ts
+/**
+* @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;
+		}
+		current.depKey = makeDependencyKey(storageKey, fieldKey);
+		if (selections) current.selections = selections;
+	}
+	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));
+	}
+	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;
+		}
+		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]);
+	}
+	return result;
+};
+/**
+* @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
+		};
+		let entrySet = subscriptions.get(depKey);
+		if (!entrySet) {
+			entrySet = /* @__PURE__ */ new Set();
+			subscriptions.set(depKey, entrySet);
+		}
+		entrySet.add(entry);
+		if (relativePath.length === 1) {
+			const fieldName = String(relativePath[0]);
+			if (data && typeof data === "object") fieldValues.set(fieldName, data[fieldName]);
+		}
+	}
+	return {
+		data,
+		fieldValues
+	};
+};
+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
+/**
+* Finds the common prefix and suffix boundaries between two key arrays.
+* @internal
+*/
+const findCommonBounds = (oldKeys, newKeys) => {
+	let start = 0;
+	while (start < oldKeys.length && start < newKeys.length && oldKeys[start] === newKeys[start]) start++;
+	let oldEnd = oldKeys.length;
+	let newEnd = newKeys.length;
+	while (oldEnd > start && newEnd > start && oldKeys[oldEnd - 1] === newKeys[newEnd - 1]) {
+		oldEnd--;
+		newEnd--;
+	}
+	return {
+		start,
+		oldEnd,
+		newEnd
+	};
+};
+/**
+* Computes swap operations to reorder oldKeys into newKeys order using selection sort.
+* @internal
+*/
+const computeSwaps = (oldKeys, newKeys) => {
+	const working = [...oldKeys];
+	const swaps = [];
+	for (const [i, newKey] of newKeys.entries()) {
+		if (working[i] === newKey) continue;
+		const j = working.indexOf(newKey, i + 1);
+		if (j === -1) continue;
+		[working[i], working[j]] = [working[j], working[i]];
+		swaps.push({
+			i,
+			j
+		});
+	}
+	return swaps;
+};
+
+//#endregion
+//#region src/cache/change.ts
+/**
+* @internal
+*/
+const classifyChanges = (changedKeys) => {
+	const structural = [];
+	const scalar = [];
+	for (const [depKey, { oldValue, newValue }] of changedKeys) {
+		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
+		});
+	}
+	return {
+		structural,
+		scalar
+	};
+};
+/**
+* @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);
+			patches.push({
+				type: "set",
+				path: entry.path,
+				value: null
+			});
+			return 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 patches;
+		}
+		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 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 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);
+			}
+			patches.push({
+				type: "splice",
+				path: entry.path,
+				index: idx,
+				deleteCount: 1,
+				items: []
+			});
+		}
+		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]
+				});
+			}
+		}
+		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]);
+};
+const findSiblingSelections = (node) => {
+	for (const child of node.children.values()) if (child.selections) return child.selections;
+	return node.selections;
+};
+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);
+	}
+};
+/**
+* @internal
+*/
+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);
+			}
+		}
+	}
+	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 patchesBySubscription;
+};
+
 //#endregion
 //#region src/cache/cache.ts
 /**
@@ -660,7 +1097,6 @@ var Cache = class {
 	#schemaMeta;
 	#storage = { [RootFieldKey]: {} };
 	#subscriptions = /* @__PURE__ */ new Map();
-	#memo = /* @__PURE__ */ new Map();
 	#stale = /* @__PURE__ */ new Set();
 	#optimisticKeys = [];
 	#optimisticLayers = /* @__PURE__ */ new Map();
@@ -695,22 +1131,35 @@ var Cache = class {
 	*/
 	writeOptimistic(key, artifact, variables, data) {
 		const layerStorage = { [RootFieldKey]: {} };
-		const dependencies = /* @__PURE__ */ new Set();
+		const layerDependencies = /* @__PURE__ */ new Set();
 		normalize(this.#schemaMeta, artifact.selections, layerStorage, data, variables, (storageKey, fieldKey) => {
-			dependencies.add(makeDependencyKey(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
+			dependencies: layerDependencies
 		});
 		this.#storageView = null;
-		const subscriptions = /* @__PURE__ */ new Set();
-		for (const depKey of dependencies) {
-			const ss = this.#subscriptions.get(depKey);
-			if (ss) for (const s of ss) subscriptions.add(s);
+		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
+			});
 		}
-		for (const subscription of subscriptions) subscription.listener();
+		const patchesBySubscription = generatePatches(changedKeys, this.#subscriptions, newView);
+		for (const [subscription, patches] of patchesBySubscription) subscription.listener(patches);
 	}
 	/**
 	* Removes an optimistic layer and notifies affected subscribers.
@@ -720,42 +1169,71 @@ var Cache = class {
 	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 subscriptions = /* @__PURE__ */ new Set();
+		const newView = this.#getStorageView();
+		const changedKeys = /* @__PURE__ */ new Map();
 		for (const depKey of layer.dependencies) {
-			const ss = this.#subscriptions.get(depKey);
-			if (ss) for (const s of ss) subscriptions.add(s);
+			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
+			});
 		}
-		for (const subscription of subscriptions) subscription.listener();
+		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 dependencies = /* @__PURE__ */ new Set();
-		const subscriptions = /* @__PURE__ */ new Set();
+		const changedKeys = /* @__PURE__ */ new Map();
+		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)) dependencies.add(depKey);
+			if (this.#stale.delete(depKey)) staleClearedKeys.add(depKey);
 			if (!entityStaleCleared.has(storageKey) && this.#stale.delete(storageKey)) entityStaleCleared.add(storageKey);
-			if (oldValue !== newValue) dependencies.add(depKey);
+			if (oldValue !== newValue) changedKeys.set(depKey, {
+				oldValue,
+				newValue
+			});
 		});
-		for (const entityKey of entityStaleCleared) this.#collectSubscriptions(entityKey, void 0, subscriptions);
-		for (const dependency of dependencies) {
-			const ss = this.#subscriptions.get(dependency);
-			if (ss) for (const s of ss) subscriptions.add(s);
+		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 subscriptions) subscription.listener();
+		for (const subscription of staleOnlySubscriptions) subscription.listener(null);
 	}
 	/**
 	* Reads a query result from the cache, denormalizing entities if available.
-	* Uses structural sharing to preserve referential identity for unchanged subtrees.
 	* @param artifact - GraphQL document artifact.
 	* @param variables - Query variables.
 	* @returns Denormalized query result or null if not found.
@@ -770,74 +1248,170 @@ var Cache = class {
 			data: null,
 			stale: false
 		};
-		const key = makeMemoKey("query", artifact.name, stringify(variables));
-		const prev = this.#memo.get(key);
-		const result = prev === void 0 ? data : replaceEqualDeep(prev, data);
-		this.#memo.set(key, result);
 		return {
-			data: result,
+			data,
 			stale
 		};
 	}
 	/**
-	* Subscribes to cache invalidations for a specific query.
+	* Subscribes to cache changes for a specific query.
 	* @param artifact - GraphQL document artifact.
 	* @param variables - Query variables.
-	* @param listener - Callback function to invoke on cache invalidation.
-	* @returns Unsubscribe function.
+	* @param listener - Callback function to invoke on cache changes.
+	* @returns Object containing initial data, stale status, unsubscribe function, and subscription.
 	*/
 	subscribeQuery(artifact, variables, listener) {
-		const dependencies = /* @__PURE__ */ new Set();
+		let stale = false;
+		const tuples = [];
 		const storageView = this.#getStorageView();
-		denormalize(artifact.selections, storageView, storageView[RootFieldKey], variables, (storageKey, fieldKey) => {
-			const dependencyKey = makeDependencyKey(storageKey, fieldKey);
-			dependencies.add(dependencyKey);
-		});
-		return this.#subscribe(dependencies, listener);
+		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 subscription = {
+			listener,
+			selections: artifact.selections,
+			variables,
+			entryTree
+		};
+		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);
+		}
+		const unsubscribe = () => {
+			this.#removeSubscriptionFromTree(entryTree, subscription);
+		};
+		return {
+			data: partial ? null : data,
+			stale,
+			unsubscribe,
+			subscription
+		};
 	}
 	/**
 	* Reads a fragment from the cache for a specific entity.
-	* Uses structural sharing to preserve referential identity for unchanged subtrees.
 	* @param artifact - GraphQL fragment artifact.
 	* @param fragmentRef - Fragment reference containing entity key.
 	* @returns Denormalized fragment data or null if not found or invalid.
 	*/
 	readFragment(artifact, fragmentRef) {
-		const entityKey = fragmentRef[FragmentRefKey];
+		const storageKey = fragmentRef[FragmentRefKey];
 		const fragmentVars = getFragmentVars(fragmentRef, artifact.name);
 		const storageView = this.#getStorageView();
-		if (!storageView[entityKey]) return {
+		let stale = false;
+		const value = storageView[storageKey];
+		if (!value) return {
 			data: null,
 			stale: false
 		};
-		let stale = false;
-		const { data, partial } = denormalize(artifact.selections, storageView, { [EntityLinkKey]: entityKey }, fragmentVars, (storageKey, fieldKey) => {
-			if (this.#stale.has(storageKey) || this.#stale.has(makeDependencyKey(storageKey, fieldKey))) stale = true;
+		const { data, partial } = denormalize(artifact.selections, storageView, storageKey === RootFieldKey ? value : { [EntityLinkKey]: storageKey }, fragmentVars, (sk, fieldKey) => {
+			if (this.#stale.has(sk) || this.#stale.has(makeDependencyKey(sk, fieldKey))) stale = true;
 		});
 		if (partial) return {
 			data: null,
 			stale: false
 		};
-		const argsId = Object.keys(fragmentVars).length > 0 ? entityKey + stringify(fragmentVars) : entityKey;
-		const key = makeMemoKey("fragment", artifact.name, argsId);
-		const prev = this.#memo.get(key);
-		const result = prev === void 0 ? data : replaceEqualDeep(prev, data);
-		this.#memo.set(key, result);
 		return {
-			data: result,
+			data,
 			stale
 		};
 	}
+	/**
+	* Subscribes to cache changes for a specific fragment.
+	* @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.
+	*/
 	subscribeFragment(artifact, fragmentRef, listener) {
-		const entityKey = fragmentRef[FragmentRefKey];
+		const storageKey = fragmentRef[FragmentRefKey];
 		const fragmentVars = getFragmentVars(fragmentRef, artifact.name);
-		const dependencies = /* @__PURE__ */ new Set();
 		const storageView = this.#getStorageView();
-		denormalize(artifact.selections, storageView, { [EntityLinkKey]: entityKey }, fragmentVars, (storageKey, fieldKey) => {
-			const dependencyKey = makeDependencyKey(storageKey, fieldKey);
-			dependencies.add(dependencyKey);
-		});
-		return this.#subscribe(dependencies, listener);
+		const value = storageKey === RootFieldKey ? storageView[RootFieldKey] : storageView[storageKey];
+		if (!value) {
+			const entryTree = buildEntryTree([]);
+			return {
+				data: null,
+				stale: false,
+				unsubscribe: () => {},
+				subscription: {
+					listener,
+					selections: artifact.selections,
+					variables: fragmentVars,
+					entryTree
+				}
+			};
+		}
+		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([]);
+			return {
+				data: null,
+				stale: false,
+				unsubscribe: () => {},
+				subscription: {
+					listener,
+					selections: artifact.selections,
+					variables: fragmentVars,
+					entryTree
+				}
+			};
+		}
+		const entryTree = buildEntryTree(tuples, storageKey === RootFieldKey ? void 0 : storageKey);
+		const subscription = {
+			listener,
+			selections: artifact.selections,
+			variables: fragmentVars,
+			entryTree
+		};
+		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);
+		}
+		const unsubscribe = () => {
+			this.#removeSubscriptionFromTree(entryTree, subscription);
+		};
+		return {
+			data: partial ? null : data,
+			stale,
+			unsubscribe,
+			subscription
+		};
 	}
 	readFragments(artifact, fragmentRefs) {
 		const results = [];
@@ -851,42 +1425,35 @@ var Cache = class {
 			if (result.stale) stale = true;
 			results.push(result.data);
 		}
-		const entityKeys = fragmentRefs.map((ref) => ref[FragmentRefKey]);
-		const key = makeMemoKey("fragments", artifact.name, entityKeys.join(","));
-		const prev = this.#memo.get(key);
-		const result = prev === void 0 ? results : replaceEqualDeep(prev, results);
-		this.#memo.set(key, result);
 		return {
-			data: result,
+			data: results,
 			stale
 		};
 	}
 	subscribeFragments(artifact, fragmentRefs, listener) {
-		const dependencies = /* @__PURE__ */ new Set();
-		const storageView = this.#getStorageView();
+		const unsubscribes = [];
 		for (const ref of fragmentRefs) {
-			const entityKey = ref[FragmentRefKey];
-			const fragmentVars = getFragmentVars(ref, artifact.name);
-			denormalize(artifact.selections, storageView, { [EntityLinkKey]: entityKey }, fragmentVars, (storageKey, fieldKey) => {
-				dependencies.add(makeDependencyKey(storageKey, fieldKey));
-			});
+			const { unsubscribe } = this.subscribeFragment(artifact, ref, listener);
+			unsubscribes.push(unsubscribe);
 		}
-		return this.#subscribe(dependencies, listener);
+		return () => {
+			for (const unsub of unsubscribes) unsub();
+		};
 	}
 	/**
 	* Invalidates one or more cache entries and notifies affected subscribers.
 	* @param targets - Cache entries to invalidate.
 	*/
 	invalidate(...targets) {
-		const subscriptions = /* @__PURE__ */ new Set();
+		const affectedSubscriptions = /* @__PURE__ */ new Set();
 		for (const target of targets) if (target.__typename === "Query") if ("$field" in target) {
 			const fieldKey = makeFieldKeyFromArgs(target.$field, target.$args);
 			const depKey = makeDependencyKey(RootFieldKey, fieldKey);
 			this.#stale.add(depKey);
-			this.#collectSubscriptions(RootFieldKey, fieldKey, subscriptions);
+			this.#collectSubscriptions(RootFieldKey, fieldKey, affectedSubscriptions);
 		} else {
 			this.#stale.add(RootFieldKey);
-			this.#collectSubscriptions(RootFieldKey, void 0, subscriptions);
+			this.#collectSubscriptions(RootFieldKey, void 0, affectedSubscriptions);
 		}
 		else {
 			const keyFields = this.#schemaMeta.entities[target.__typename]?.keyFields;
@@ -896,10 +1463,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, subscriptions);
+					this.#collectSubscriptions(entityKey, fieldKey, affectedSubscriptions);
 				} else {
 					this.#stale.add(entityKey);
-					this.#collectSubscriptions(entityKey, void 0, subscriptions);
+					this.#collectSubscriptions(entityKey, void 0, affectedSubscriptions);
 				}
 			} else {
 				const prefix = `${target.__typename}:`;
@@ -908,15 +1475,30 @@ var Cache = class {
 					if ("$field" in target) {
 						const fieldKey = makeFieldKeyFromArgs(target.$field, target.$args);
 						this.#stale.add(makeDependencyKey(entityKey, fieldKey));
-						this.#collectSubscriptions(entityKey, fieldKey, subscriptions);
+						this.#collectSubscriptions(entityKey, fieldKey, affectedSubscriptions);
 					} else {
 						this.#stale.add(entityKey);
-						this.#collectSubscriptions(entityKey, void 0, subscriptions);
+						this.#collectSubscriptions(entityKey, void 0, affectedSubscriptions);
 					}
 				}
 			}
 		}
-		for (const subscription of subscriptions) subscription.listener();
+		for (const subscription of affectedSubscriptions) subscription.listener(null);
+	}
+	/**
+	* 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);
@@ -924,48 +1506,43 @@ var Cache = class {
 	#collectSubscriptions(storageKey, fieldKey, out) {
 		if (fieldKey === void 0) {
 			const prefix = `${storageKey}.`;
-			for (const [depKey, ss] of this.#subscriptions) if (depKey.startsWith(prefix)) for (const s of ss) out.add(s);
+			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 ss = this.#subscriptions.get(depKey);
-			if (ss) for (const s of ss) out.add(s);
+			const entries = this.#subscriptions.get(depKey);
+			if (entries) for (const entry of entries) out.add(entry.subscription);
 		}
 	}
-	#subscribe(dependencies, listener) {
-		const subscription = { listener };
-		for (const dependency of dependencies) {
-			const subscriptions = this.#subscriptions.get(dependency) ?? /* @__PURE__ */ new Set();
-			subscriptions.add(subscription);
-			this.#subscriptions.set(dependency, subscriptions);
-		}
-		return () => {
-			for (const dependency of dependencies) {
-				const subscriptions = this.#subscriptions.get(dependency);
-				subscriptions?.delete(subscription);
-				if (subscriptions?.size === 0) this.#subscriptions.delete(dependency);
+	#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);
 	}
 	/**
-	* Extracts a serializable snapshot of the cache storage and structural sharing state.
+	* 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),
-			memo: Object.fromEntries(this.#memo)
-		};
+		return { storage: structuredClone(this.#storage) };
 	}
 	/**
 	* Hydrates the cache with a previously extracted snapshot.
 	*/
 	hydrate(snapshot) {
-		const { storage, memo } = snapshot;
+		const { storage } = snapshot;
 		for (const [key, fields] of Object.entries(storage)) this.#storage[key] = {
 			...this.#storage[key],
 			...fields
 		};
-		for (const [key, value] of Object.entries(memo)) this.#memo.set(key, value);
 		this.#storageView = null;
 	}
 	/**
@@ -974,7 +1551,6 @@ var Cache = class {
 	clear() {
 		this.#storage = { [RootFieldKey]: {} };
 		this.#subscriptions.clear();
-		this.#memo.clear();
 		this.#stale.clear();
 		this.#optimisticKeys = [];
 		this.#optimisticLayers.clear();
@@ -1010,6 +1586,9 @@ const cacheExchange = (options = {}) => {
 				clear: () => cache.clear()
 			},
 			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;
 					if (!fragmentRef) return fromValue({
@@ -1017,77 +1596,152 @@ const cacheExchange = (options = {}) => {
 						errors: [new ExchangeError("Fragment operation missing fragment.ref in metadata. This usually happens when the wrong fragment reference was passed.", { exchangeName: "cache" })]
 					});
 					if (isFragmentRefArray(fragmentRef)) {
-						const trigger = makeSubject();
-						const teardown$ = pipe(ops$, filter((operation) => operation.variant === "teardown" && operation.key === op.key), tap(() => trigger.complete()));
-						return pipe(merge(fromValue(void 0), trigger.source), switchMap(() => fromSubscription(() => cache.readFragments(op.artifact, fragmentRef), () => cache.subscribeFragments(op.artifact, fragmentRef, async () => {
-							await Promise.resolve();
-							trigger.next();
-						}))), takeUntil(teardown$), map(({ data, stale }) => ({
+						const results = makeSubject();
+						const unsubscribes = [];
+						const fragmentSubscriptions = [];
+						for (const [index, ref] of fragmentRef.entries()) {
+							const patchListener = (patches) => {
+								if (patches) {
+									const indexedPatches = patches.map((patch) => ({
+										...patch,
+										path: [index, ...patch.path]
+									}));
+									results.next({
+										operation: op,
+										metadata: { cache: { patches: indexedPatches } },
+										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 { unsubscribe, subscription } = cache.subscribeFragment(op.artifact, ref, patchListener);
+							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(() => {
+							for (const unsub of unsubscribes) unsub();
+							results.complete();
+						}));
+						return pipe(merge(fromValue({
 							operation: op,
-							data,
-							...stale && { metadata: { cache: { stale: true } } },
+							data: initialData,
+							...initialStale && { metadata: { cache: { stale: true } } },
 							errors: []
-						})));
+						}), results.source), takeUntil(teardown$));
 					}
 					if (!isFragmentRef(fragmentRef)) return fromValue({
 						operation: op,
 						data: fragmentRef,
 						errors: []
 					});
-					const trigger = makeSubject();
-					const teardown$ = pipe(ops$, filter((operation) => operation.variant === "teardown" && operation.key === op.key), tap(() => trigger.complete()));
-					return pipe(merge(fromValue(void 0), trigger.source), switchMap(() => fromSubscription(() => cache.readFragment(op.artifact, fragmentRef), () => cache.subscribeFragment(op.artifact, fragmentRef, async () => {
-						await Promise.resolve();
-						trigger.next();
-					}))), takeUntil(teardown$), map(({ data, stale }) => ({
+					const results = makeSubject();
+					let currentUnsubscribe = null;
+					let currentSubscription = null;
+					const patchListener = (patches) => {
+						if (patches) results.next({
+							operation: op,
+							metadata: { cache: { 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: []
+								});
+							}
+						}
+					};
+					const { data, stale, unsubscribe, subscription } = cache.subscribeFragment(op.artifact, fragmentRef, patchListener);
+					currentUnsubscribe = unsubscribe;
+					currentSubscription = subscription;
+					const teardown$ = pipe(ops$, filter((operation) => operation.variant === "teardown" && operation.key === op.key), tap(() => {
+						if (currentUnsubscribe) currentUnsubscribe();
+						results.complete();
+					}));
+					return pipe(merge(data === null ? empty() : fromValue({
 						operation: op,
 						data,
 						...stale && { metadata: { cache: { stale: true } } },
 						errors: []
-					})));
+					}), results.source), takeUntil(teardown$));
 				}));
 				const nonCache$ = pipe(ops$, filter((op) => op.variant === "request" && (op.artifact.kind === "mutation" || op.artifact.kind === "subscription" || op.artifact.kind === "query" && fetchPolicy === "network-only")), tap((op) => {
 					if (op.artifact.kind === "mutation" && op.metadata?.cache?.optimisticResponse) cache.writeOptimistic(op.key, op.artifact, op.variables, op.metadata.cache.optimisticResponse);
 				}));
 				const query$ = pipe(ops$, filter((op) => op.variant === "request" && op.artifact.kind === "query" && fetchPolicy !== "network-only"), share());
-				const refetch$ = makeSubject();
 				return merge(fragment$, pipe(query$, mergeMap((op) => {
-					const trigger = makeSubject();
-					let hasData = false;
-					const teardown$ = pipe(ops$, filter((operation) => operation.variant === "teardown" && operation.key === op.key), tap(() => trigger.complete()));
-					return pipe(merge(fromValue(void 0), trigger.source), switchMap(() => fromSubscription(() => cache.readQuery(op.artifact, op.variables), () => cache.subscribeQuery(op.artifact, op.variables, async () => {
-						await Promise.resolve();
-						trigger.next();
-					}))), takeUntil(teardown$), mergeMap(({ data, stale }) => {
-						if (data !== null && !stale) {
-							hasData = true;
-							return fromValue({
-								operation: op,
-								data,
-								errors: []
-							});
-						}
-						if (data !== null && stale) {
-							hasData = true;
-							refetch$.next(op);
-							return fromValue({
-								operation: op,
-								data,
-								metadata: { cache: { stale: true } },
-								errors: []
-							});
-						}
-						if (hasData) {
-							refetch$.next(op);
-							return empty();
-						}
-						if (fetchPolicy === "cache-only") return fromValue({
-							operation: op,
-							data: null,
-							errors: []
-						});
+					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({
+									operation: op,
+									metadata: { cache: { patches } },
+									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);
+								}
+							}
+						};
+						const result = cache.subscribeQuery(op.artifact, op.variables, patchListener);
+						currentUnsubscribe = result.unsubscribe;
+						currentSubscription = result.subscription;
+						return result;
+					};
+					const { data, stale } = doSubscribe();
+					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();
+						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,
+						errors: []
+					}) : empty() : fromValue({
+						operation: op,
+						data,
+						...stale && { metadata: { cache: { stale: true } } },
+						errors: []
+					}), results.source, resubStream$), 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) => {
 					const { data } = cache.readQuery(op.artifact, op.variables);
 					return fetchPolicy === "cache-and-network" || data === null;
@@ -1095,8 +1749,22 @@ const cacheExchange = (options = {}) => {
 					if (result.operation.variant === "request" && result.operation.artifact.kind === "mutation" && result.operation.metadata?.cache?.optimisticResponse) cache.removeOptimistic(result.operation.key);
 					if (result.operation.variant === "request" && result.data) cache.writeQuery(result.operation.artifact, result.operation.variables, result.data);
 					if (result.operation.variant !== "request" || result.operation.artifact.kind !== "query" || fetchPolicy === "network-only" || !!(result.errors && result.errors.length > 0)) return fromValue(result);
+					if (subscriptionHasData.get(result.operation.key)) {
+						const { data } = cache.readQuery(result.operation.artifact, result.operation.variables);
+						if (data !== null) return empty();
+						return fromValue({
+							operation: result.operation,
+							data: void 0,
+							errors: [new ExchangeError("Cache failed to denormalize the network response. This is likely a bug in the cache normalizer.", { exchangeName: "cache" })]
+						});
+					}
+					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 empty();
+					if (data !== null) return fromValue({
+						...result,
+						data
+					});
 					return fromValue({
 						operation: result.operation,
 						data: void 0,
@@ -1108,6 +1776,99 @@ 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;
@@ -1579,4 +2340,4 @@ const createClient = (config) => {
 };
 
 //#endregion
-export { AggregatedError, Client, ExchangeError, GraphQLError, RequiredFieldError, cacheExchange, createClient, dedupExchange, fragmentExchange, httpExchange, isAggregatedError, isExchangeError, isGraphQLError, requiredExchange, retryExchange, stringify, subscriptionExchange };
+export { AggregatedError, Client, ExchangeError, GraphQLError, RequiredFieldError, applyPatchesImmutable, applyPatchesMutable, cacheExchange, createClient, dedupExchange, fragmentExchange, getPath, httpExchange, isAggregatedError, isExchangeError, isGraphQLError, requiredExchange, retryExchange, setPath, stringify, subscriptionExchange };