@mearie/core 0.5.1 → 0.6.0

package/dist/index.cjs

@@ -360,15 +360,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).
@@ -445,65 +436,48 @@ const isEqual = (a, b) => {
 	}
 	return false;
 };
+const NormalizedKey = Symbol("mearie.normalized");
 /**
-* 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.
+* Marks a record as a normalized cache object so that {@link mergeFields}
+* can distinguish it from opaque scalar values (e.g. JSON scalars).
+* Only normalized records are deep-merged; unmarked objects are treated as
+* atomic values and replaced entirely on write.
 * @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 markNormalized = (obj) => {
+	Object.defineProperty(obj, NormalizedKey, { value: true });
+};
+const isNormalizedRecord = (value) => {
+	return typeof value === "object" && value !== null && NormalizedKey in value;
 };
 /**
-* Deeply merges two values. Objects are recursively merged, arrays are element-wise merged,
-* entity links and primitives use last-write-wins.
+* Deeply merges two values. When {@link deep} is false (default), only
+* {@link markNormalized normalized} cache objects are recursively merged;
+* unmarked plain objects (e.g. JSON scalars) are atomically replaced.
+* When {@link deep} is true, all objects are recursively merged unconditionally.
+* Arrays are element-wise merged, entity links and primitives use last-write-wins.
 * @internal
 */
-const mergeFieldValue = (existing, incoming) => {
+const mergeFieldValue = (existing, incoming, deep) => {
 	if (isNullish(existing) || isNullish(incoming)) return incoming;
 	if (typeof existing !== "object" || typeof incoming !== "object") return incoming;
 	if (isEntityLink(existing) || isEntityLink(incoming)) return incoming;
-	if (Array.isArray(existing) && Array.isArray(incoming)) return incoming.map((item, i) => i < existing.length ? mergeFieldValue(existing[i], item) : item);
+	if (Array.isArray(existing) && Array.isArray(incoming)) return incoming.map((item, i) => i < existing.length ? mergeFieldValue(existing[i], item, deep) : item);
 	if (Array.isArray(existing) || Array.isArray(incoming)) return incoming;
-	mergeFields(existing, incoming);
+	if (!deep && !isNormalizedRecord(incoming)) return incoming;
+	mergeFields(existing, incoming, deep);
 	return existing;
 };
 /**
-* Deeply merges source fields into target. Objects are recursively merged,
-* arrays are element-wise merged, entity links and primitives use last-write-wins.
+* Deeply merges source fields into target.
+* When {@link deep} is false (default), only {@link markNormalized normalized}
+* objects are recursively merged; unmarked objects are atomically replaced.
+* When {@link deep} is true, all objects are recursively merged unconditionally.
 * @internal
 */
-const mergeFields = (target, source) => {
+const mergeFields = (target, source, deep) => {
 	if (isNullish(source) || typeof source !== "object" || Array.isArray(source)) return;
-	for (const key of Object.keys(source)) target[key] = mergeFieldValue(target[key], source[key]);
+	for (const key of Object.keys(source)) target[key] = mergeFieldValue(target[key], source[key], deep ?? false);
 };
 /**
 * Creates a FieldKey from a raw field name and optional arguments.
@@ -515,6 +489,48 @@ const mergeFields = (target, source) => {
 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
@@ -531,29 +547,31 @@ const normalize = (schemaMeta, selections, storage, data, variables, accessor) =
 		if (keys.every((k) => k !== void 0 && k !== null)) return makeEntityKey(typename, keys);
 		return null;
 	};
-	const normalizeField = (storageKey, selections, value) => {
+	const normalizeField = (storageKey, selections, value, parentType) => {
 		if (isNullish(value)) return value;
-		if (Array.isArray(value)) return value.map((item) => normalizeField(storageKey, selections, item));
+		if (Array.isArray(value)) return value.map((item) => normalizeField(storageKey, selections, item, parentType));
 		const data = value;
-		const typename = resolveTypename(selections, data);
+		const typename = resolveTypename(selections, data) ?? (parentType && schemaMeta.entities[parentType] ? parentType : void 0);
 		const entityKey = resolveEntityKey(typename, data);
 		if (entityKey) storageKey = entityKey;
 		const fields = {};
 		for (const selection of selections) if (selection.kind === "Field") {
 			const fieldKey = makeFieldKey(selection, variables);
-			const fieldValue = data[selection.alias ?? selection.name];
+			let fieldValue = data[selection.alias ?? selection.name];
+			if (selection.name === "__typename" && fieldValue === void 0 && typename) fieldValue = typename;
 			if (storageKey !== null && selection.selections && typeof fieldValue === "object" && fieldValue !== null && !Array.isArray(fieldValue)) {
-				const fieldTypename = resolveTypename(selection.selections, fieldValue);
+				const fieldTypename = resolveTypename(selection.selections, fieldValue) ?? (selection.type && schemaMeta.entities[selection.type] ? selection.type : void 0);
 				if (fieldTypename && schemaMeta.entities[fieldTypename] && !resolveEntityKey(fieldTypename, fieldValue) && isEntityLink(storage[storageKey]?.[fieldKey])) continue;
 			}
 			const oldValue = storageKey === null ? void 0 : storage[storageKey]?.[fieldKey];
 			if (storageKey !== null && (!selection.selections || isNullish(oldValue) || isNullish(fieldValue))) accessor?.(storageKey, fieldKey, oldValue, fieldValue);
-			fields[fieldKey] = selection.selections ? normalizeField(null, selection.selections, fieldValue) : fieldValue;
+			fields[fieldKey] = selection.selections ? normalizeField(null, selection.selections, fieldValue, selection.type) : fieldValue;
 			if (storageKey !== null && selection.selections && !isNullish(oldValue) && !isNullish(fieldValue) && !isEntityLink(fields[fieldKey]) && !isEqual(oldValue, fields[fieldKey])) accessor?.(storageKey, fieldKey, oldValue, fields[fieldKey]);
 		} else if (selection.kind === "FragmentSpread" || selection.kind === "InlineFragment" && selection.on === typename) {
 			const inner = normalizeField(storageKey, selection.selections, value);
 			if (!isEntityLink(inner)) mergeFields(fields, inner);
 		}
+		markNormalized(fields);
 		if (entityKey) {
 			const existing = storage[entityKey];
 			if (existing) mergeFields(existing, fields);
@@ -576,59 +594,494 @@ 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 });
-			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));
-		else if (selection.kind === "InlineFragment" && selection.on === data[typenameFieldKey]) mergeFields(fields, denormalizeField(storageKey, selection.selections, value));
+		} 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) {
+			const existing = patchesBySubscription.get(entry.subscription) ?? [];
+			existing.push({
+				type: "set",
+				path: entry.path,
+				value: newValue
+			});
+			patchesBySubscription.set(entry.subscription, existing);
+		}
+	}
+	return patchesBySubscription;
+};
+
 //#endregion
 //#region src/cache/cache.ts
 /**
@@ -639,7 +1092,6 @@ var Cache = class {
 	#schemaMeta;
 	#storage = { [RootFieldKey]: {} };
 	#subscriptions = /* @__PURE__ */ new Map();
-	#memo = /* @__PURE__ */ new Map();
 	#stale = /* @__PURE__ */ new Set();
 	#optimisticKeys = [];
 	#optimisticLayers = /* @__PURE__ */ new Map();
@@ -674,22 +1126,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.
@@ -699,42 +1164,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.
@@ -749,74 +1243,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 = [];
@@ -830,42 +1420,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;
@@ -875,10 +1458,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}:`;
@@ -887,15 +1470,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);
@@ -903,48 +1501,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;
 	}
 	/**
@@ -953,7 +1546,6 @@ var Cache = class {
 	clear() {
 		this.#storage = { [RootFieldKey]: {} };
 		this.#subscriptions.clear();
-		this.#memo.clear();
 		this.#stale.clear();
 		this.#optimisticKeys = [];
 		this.#optimisticLayers.clear();
@@ -989,6 +1581,9 @@ const cacheExchange = (options = {}) => {
 				clear: () => cache.clear()
 			},
 			io: (ops$) => {
+				const subscriptionHasData = /* @__PURE__ */ new Map();
+				const resubscribe$ = require_make.makeSubject();
+				const refetch$ = require_make.makeSubject();
 				const fragment$ = require_make.pipe(ops$, require_make.filter((op) => op.variant === "request" && op.artifact.kind === "fragment"), require_make.mergeMap((op) => {
 					const fragmentRef = op.metadata?.fragment?.ref;
 					if (!fragmentRef) return require_make.fromValue({
@@ -996,77 +1591,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 = require_make.makeSubject();
-						const teardown$ = require_make.pipe(ops$, require_make.filter((operation) => operation.variant === "teardown" && operation.key === op.key), require_make.tap(() => trigger.complete()));
-						return require_make.pipe(require_make.merge(require_make.fromValue(void 0), trigger.source), require_make.switchMap(() => require_make.fromSubscription(() => cache.readFragments(op.artifact, fragmentRef), () => cache.subscribeFragments(op.artifact, fragmentRef, async () => {
-							await Promise.resolve();
-							trigger.next();
-						}))), require_make.takeUntil(teardown$), require_make.map(({ data, stale }) => ({
+						const results = require_make.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$ = require_make.pipe(ops$, require_make.filter((operation) => operation.variant === "teardown" && operation.key === op.key), require_make.tap(() => {
+							for (const unsub of unsubscribes) unsub();
+							results.complete();
+						}));
+						return require_make.pipe(require_make.merge(require_make.fromValue({
 							operation: op,
-							data,
-							...stale && { metadata: { cache: { stale: true } } },
+							data: initialData,
+							...initialStale && { metadata: { cache: { stale: true } } },
 							errors: []
-						})));
+						}), results.source), require_make.takeUntil(teardown$));
 					}
 					if (!isFragmentRef(fragmentRef)) return require_make.fromValue({
 						operation: op,
 						data: fragmentRef,
 						errors: []
 					});
-					const trigger = require_make.makeSubject();
-					const teardown$ = require_make.pipe(ops$, require_make.filter((operation) => operation.variant === "teardown" && operation.key === op.key), require_make.tap(() => trigger.complete()));
-					return require_make.pipe(require_make.merge(require_make.fromValue(void 0), trigger.source), require_make.switchMap(() => require_make.fromSubscription(() => cache.readFragment(op.artifact, fragmentRef), () => cache.subscribeFragment(op.artifact, fragmentRef, async () => {
-						await Promise.resolve();
-						trigger.next();
-					}))), require_make.takeUntil(teardown$), require_make.map(({ data, stale }) => ({
+					const results = require_make.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$ = require_make.pipe(ops$, require_make.filter((operation) => operation.variant === "teardown" && operation.key === op.key), require_make.tap(() => {
+						if (currentUnsubscribe) currentUnsubscribe();
+						results.complete();
+					}));
+					return require_make.pipe(require_make.merge(data === null ? empty() : require_make.fromValue({
 						operation: op,
 						data,
 						...stale && { metadata: { cache: { stale: true } } },
 						errors: []
-					})));
+					}), results.source), require_make.takeUntil(teardown$));
 				}));
 				const nonCache$ = require_make.pipe(ops$, require_make.filter((op) => op.variant === "request" && (op.artifact.kind === "mutation" || op.artifact.kind === "subscription" || op.artifact.kind === "query" && fetchPolicy === "network-only")), require_make.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$ = require_make.pipe(ops$, require_make.filter((op) => op.variant === "request" && op.artifact.kind === "query" && fetchPolicy !== "network-only"), require_make.share());
-				const refetch$ = require_make.makeSubject();
 				return require_make.merge(fragment$, require_make.pipe(query$, require_make.mergeMap((op) => {
-					const trigger = require_make.makeSubject();
-					let hasData = false;
-					const teardown$ = require_make.pipe(ops$, require_make.filter((operation) => operation.variant === "teardown" && operation.key === op.key), require_make.tap(() => trigger.complete()));
-					return require_make.pipe(require_make.merge(require_make.fromValue(void 0), trigger.source), require_make.switchMap(() => require_make.fromSubscription(() => cache.readQuery(op.artifact, op.variables), () => cache.subscribeQuery(op.artifact, op.variables, async () => {
-						await Promise.resolve();
-						trigger.next();
-					}))), require_make.takeUntil(teardown$), require_make.mergeMap(({ data, stale }) => {
-						if (data !== null && !stale) {
-							hasData = true;
-							return require_make.fromValue({
-								operation: op,
-								data,
-								errors: []
-							});
-						}
-						if (data !== null && stale) {
-							hasData = true;
-							refetch$.next(op);
-							return require_make.fromValue({
-								operation: op,
-								data,
-								metadata: { cache: { stale: true } },
-								errors: []
-							});
-						}
-						if (hasData) {
-							refetch$.next(op);
-							return empty();
-						}
-						if (fetchPolicy === "cache-only") return require_make.fromValue({
-							operation: op,
-							data: null,
-							errors: []
-						});
+					const results = require_make.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$ = require_make.pipe(ops$, require_make.filter((o) => o.variant === "teardown" && o.key === op.key), require_make.tap(() => {
+						if (currentUnsubscribe) currentUnsubscribe();
+						subscriptionHasData.delete(op.key);
+						results.complete();
+					}));
+					const resubStream$ = require_make.pipe(resubscribe$.source, require_make.filter((key) => key === op.key), require_make.mergeMap(() => {
+						doSubscribe();
+						initialized = true;
 						return empty();
 					}));
+					const stream$ = require_make.pipe(require_make.merge(data === null ? fetchPolicy === "cache-only" ? require_make.fromValue({
+						operation: op,
+						data: null,
+						errors: []
+					}) : empty() : require_make.fromValue({
+						operation: op,
+						data,
+						...stale && { metadata: { cache: { stale: true } } },
+						errors: []
+					}), results.source, resubStream$), require_make.takeUntil(teardown$));
+					if (stale) refetch$.next(op);
+					return stream$;
 				}), require_make.filter(() => fetchPolicy === "cache-only" || fetchPolicy === "cache-and-network" || fetchPolicy === "cache-first")), require_make.pipe(require_make.merge(nonCache$, require_make.pipe(query$, require_make.filter((op) => {
 					const { data } = cache.readQuery(op.artifact, op.variables);
 					return fetchPolicy === "cache-and-network" || data === null;
@@ -1074,8 +1744,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 require_make.fromValue(result);
+					if (subscriptionHasData.get(result.operation.key)) {
+						const { data } = cache.readQuery(result.operation.artifact, result.operation.variables);
+						if (data !== null) return empty();
+						return require_make.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 require_make.fromValue({
+						...result,
+						data
+					});
 					return require_make.fromValue({
 						operation: result.operation,
 						data: void 0,
@@ -1087,6 +1771,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;
@@ -1563,15 +2340,19 @@ exports.Client = Client;
 exports.ExchangeError = ExchangeError;
 exports.GraphQLError = GraphQLError;
 exports.RequiredFieldError = RequiredFieldError;
+exports.applyPatchesImmutable = applyPatchesImmutable;
+exports.applyPatchesMutable = applyPatchesMutable;
 exports.cacheExchange = cacheExchange;
 exports.createClient = createClient;
 exports.dedupExchange = dedupExchange;
 exports.fragmentExchange = fragmentExchange;
+exports.getPath = getPath;
 exports.httpExchange = httpExchange;
 exports.isAggregatedError = isAggregatedError;
 exports.isExchangeError = isExchangeError;
 exports.isGraphQLError = isGraphQLError;
 exports.requiredExchange = requiredExchange;
 exports.retryExchange = retryExchange;
+exports.setPath = setPath;
 exports.stringify = stringify;
 exports.subscriptionExchange = subscriptionExchange;