@nkzw/fate 1.3.3 → 1.5.0

package/lib/index.mjs

@@ -1,10 +1,15 @@
 import { t as isRecord } from "./record-B07VwXd-.mjs";
-import { a as errorCodeFromStatus, c as cloneArgs, d as hashArgs, f as paginationArgKeys, i as FateRequestError, l as combineArgsPayload, m as scopeArgsPayload, n as liveEntityTopic, p as resolvedArgsFromPlan, r as liveGlobalConnectionTopic, s as applyArgsPayloadToPlan, t as liveConnectionTopic, u as filterConnectionArgs } from "./liveTopics-uVP0LG-Q.mjs";
+import { a as hashArgs, c as scopeArgsPayload, i as filterConnectionArgs, r as combineArgsPayload, s as resolvedArgsFromPlan, t as applyArgsPayloadToPlan } from "./args-CRLIRl_v.mjs";
+import { _ as isNodesItem, a as createNodeRef, c as ConnectionTag, f as RootKind, g as isNodeItem, i as resolveHydrationLimits, l as DeferTag, m as ViewsTag, o as getNodeRefId, r as encodeHydrationValue, s as isNodeRef, t as decodeClientHydrationState, u as DeferredTag, v as isQueryItem, y as isViewTag } from "./hydration-DPZRJgnu.mjs";
+import { C as isDeferredSelection, S as isDeferred, _ as view, a as mutation, b as getDeferredMetadata, c as getDeferredSelectionPlan, d as createRefWithViewNames, f as getRootViewNames, g as getViewPayloads, h as getViewNames, l as getSelectionPlan, m as toEntityId, n as getListKey, p as parseEntityId, r as mergePreservingExisting, s as wrapMutation, t as Store, u as assignViewTag, v as createDeferred, x as getDeferredSelection, y as defer } from "./store-CeatPJeK.mjs";
 import { t as getListEntries } from "./list-_6fXYLtJ.mjs";
-import { n as graphqlMutation, t as createGraphQLTransport } from "./graphqlTransport-DSBVS2Fq.mjs";
+import { n as errorCodeFromStatus, t as FateRequestError } from "./protocol-DS5sf6sd.mjs";
+import { n as graphqlMutation, t as createGraphQLTransport } from "./graphqlTransport-DmheG3AO.mjs";
+import { n as liveEntityTopic, r as liveGlobalConnectionTopic, t as liveConnectionTopic } from "./liveTopics-DuFkDZQm.mjs";
 //#region src/cache.ts
 var ViewDataCache = class {
-	constructor() {
+	constructor(isEnabled = () => true) {
+		this.isEnabled = isEnabled;
 		this.cache = /* @__PURE__ */ new Map();
 		this.rootDependencies = /* @__PURE__ */ new Map();
 		this.dependencyIndex = /* @__PURE__ */ new Map();
@@ -15,9 +20,11 @@ var ViewDataCache = class {
 		this.dependencyIndex.clear();
 	}
 	get(entityId, view, ref) {
+		if (!this.isEnabled()) return null;
 		return this.cache.get(entityId)?.get(view)?.get(ref) ?? null;
 	}
 	set(entityId, view, ref, thenable, dependencies) {
+		if (!this.isEnabled()) return;
 		let entityMap = this.cache.get(entityId);
 		if (!entityMap) {
 			entityMap = /* @__PURE__ */ new WeakMap();
@@ -45,6 +52,7 @@ var ViewDataCache = class {
 		}
 	}
 	invalidate(entityId) {
+		if (!this.isEnabled()) return;
 		this.invalidateDependents(entityId, /* @__PURE__ */ new Set());
 	}
 	invalidateDependents(entityId, visited) {
@@ -69,837 +77,6 @@ var ViewDataCache = class {
 	}
 };
 //#endregion
-//#region src/types.ts
-/** Internal marker added to objects that represent a view payload. */
-const ViewKind = Symbol("__fate__view");
-/** Symbol used to attach the set of view tags that were spread into a ref or masked record. */
-const ViewsTag = Symbol("__fate__views");
-/** Symbol used to brand a value as a node reference inside the cache. */
-const NodeRefTag = Symbol("__fate__node-ref");
-/** Symbol attached to connection results so pagination helpers can find their metadata. */
-const ConnectionTag = Symbol("__fate__connection");
-/** Symbol used to mark a selection as deferred. */
-const DeferTag = Symbol("__fate__defer");
-/** Symbol attached to deferred values returned from masked views. */
-const DeferredTag = Symbol("__fate__deferred");
-const viewTag = "__fate-view__";
-/** Generates a stable view tag for a view definition. */
-function getViewTag(id) {
-	return `${viewTag}${id}`;
-}
-/** Determines whether a property key is a fate view tag. */
-function isViewTag(key) {
-	return key.startsWith(viewTag);
-}
-/** Indicates whether a request item represents an explicit node ID. */
-function isNodeItem(item) {
-	return "id" in item;
-}
-/** Indicates whether a request item represents explicit node IDs. */
-function isNodesItem(item) {
-	return "ids" in item;
-}
-/** Indicates whether a request item represents a root query. */
-function isQueryItem(item) {
-	return "view" in item && !("id" in item) && !("ids" in item);
-}
-/** Brand used on root definitions to mark their identity in the d.ts output. */
-const RootKind = "__fate__root";
-/** Brand used on mutation definitions to mark their identity in the d.ts output. */
-const MutationKind = "__fate__mutation";
-//#endregion
-//#region src/defer.ts
-function defer(selection) {
-	return Object.freeze({ [DeferTag]: selection });
-}
-const isDeferredSelection = (value) => typeof value === "object" && value !== null && DeferTag in value;
-const getDeferredSelection = (selection) => selection[DeferTag];
-const createDeferred = (metadata) => Object.freeze({ [DeferredTag]: metadata });
-const isDeferred = (value) => typeof value === "object" && value !== null && DeferredTag in value;
-const getDeferredMetadata = (deferred) => deferred[DeferredTag];
-//#endregion
-//#region src/node-ref.ts
-function createNodeRef(id) {
-	const ref = {};
-	Object.defineProperty(ref, NodeRefTag, {
-		configurable: false,
-		enumerable: false,
-		value: id,
-		writable: false
-	});
-	return Object.freeze(ref);
-}
-function isNodeRef(value) {
-	return !value || typeof value !== "object" ? false : NodeRefTag in value;
-}
-function getNodeRefId(ref) {
-	return ref[NodeRefTag];
-}
-//#endregion
-//#region src/hydration.ts
-const maxDepth = 64;
-const defaultHydrationLimits = {
-	maxCollectionLength: 1e5,
-	maxNodes: 25e4,
-	maxStringLength: 1e6
-};
-const resolveHydrationLimits = (limits) => {
-	const result = {
-		...defaultHydrationLimits,
-		...limits
-	};
-	for (const [key, value] of Object.entries(result)) if (!Number.isInteger(value) || value < 1) throw new Error(`fate: Hydration limit '${key}' must be a positive integer.`);
-	return result;
-};
-const error = (path, message) => /* @__PURE__ */ new Error(`fate: Cannot serialize hydration value at '${path}': ${message}`);
-const isPlainObject = (value) => {
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-};
-const isDenseArray = (value) => {
-	for (let index = 0; index < value.length; index += 1) if (!Object.hasOwn(value, index)) return false;
-	return true;
-};
-const isDate$1 = (value) => Object.prototype.toString.call(value) === "[object Date]" && typeof value.getTime === "function" && typeof value.toISOString === "function";
-const encodeHydrationValue = (value, limits) => {
-	const resolvedLimits = resolveHydrationLimits(limits);
-	const seen = /* @__PURE__ */ new Set();
-	let nodes = 0;
-	const encode = (entry, path, depth) => {
-		nodes += 1;
-		if (nodes > resolvedLimits.maxNodes) throw error(path, `Maximum node count of ${String(resolvedLimits.maxNodes)} exceeded.`);
-		if (depth > maxDepth) throw error(path, `Maximum depth of ${String(maxDepth)} exceeded.`);
-		if (entry === null) return ["null"];
-		const type = typeof entry;
-		if (typeof entry === "string" || typeof entry === "boolean") {
-			if (typeof entry === "string" && entry.length > resolvedLimits.maxStringLength) throw error(path, `Maximum string length of ${String(resolvedLimits.maxStringLength)} exceeded.`);
-			return [typeof entry, entry];
-		}
-		if (type === "number") {
-			if (Number.isNaN(entry)) return ["number", "NaN"];
-			if (entry === Infinity) return ["number", "Infinity"];
-			if (entry === -Infinity) return ["number", "-Infinity"];
-			if (Object.is(entry, -0)) return ["number", "-0"];
-			return ["number", entry];
-		}
-		if (type === "undefined") return ["undefined"];
-		if (type === "bigint") {
-			const bigint = String(entry);
-			if (bigint.length > resolvedLimits.maxStringLength) throw error(path, `Maximum string length of ${String(resolvedLimits.maxStringLength)} exceeded.`);
-			return ["bigint", bigint];
-		}
-		if (type === "function" || type === "symbol") throw error(path, `Received unsupported '${type}' value.`);
-		if (!entry || typeof entry !== "object") throw error(path, `Received unsupported '${type}' value.`);
-		if (isNodeRef(entry)) {
-			const id = getNodeRefId(entry);
-			if (id.length > resolvedLimits.maxStringLength) throw error(path, `Maximum string length of ${String(resolvedLimits.maxStringLength)} exceeded.`);
-			return ["ref", id];
-		}
-		if (isDate$1(entry)) {
-			if (Number.isNaN(entry.getTime())) throw error(path, `Received an invalid Date.`);
-			return ["date", entry.toISOString()];
-		}
-		if (seen.has(entry)) throw error(path, `Circular references are not supported.`);
-		seen.add(entry);
-		try {
-			if (Array.isArray(entry)) {
-				if (!isDenseArray(entry)) throw error(path, `Sparse arrays are not supported.`);
-				if (entry.length > resolvedLimits.maxCollectionLength) throw error(path, `Maximum collection length of ${String(resolvedLimits.maxCollectionLength)} exceeded.`);
-				return ["array", entry.map((item, index) => encode(item, `${path}[${String(index)}]`, depth + 1))];
-			}
-			if (!isPlainObject(entry)) throw error(path, `Received unsupported '${entry.constructor?.name ?? "object"}' value.`);
-			if (Object.getOwnPropertySymbols(entry).length > 0) throw error(path, `Received an unsupported symbol-keyed property.`);
-			const entries = Object.entries(entry);
-			if (entries.length > resolvedLimits.maxCollectionLength) throw error(path, `Maximum collection length of ${String(resolvedLimits.maxCollectionLength)} exceeded.`);
-			return ["object", entries.map(([key, item]) => {
-				if (key.length > resolvedLimits.maxStringLength) throw error(path, `Maximum string length of ${String(resolvedLimits.maxStringLength)} exceeded.`);
-				return [key, encode(item, `${path}.${key}`, depth + 1)];
-			})];
-		} finally {
-			seen.delete(entry);
-		}
-	};
-	return encode(value, "data", 0);
-};
-const invalidPayload = (path) => /* @__PURE__ */ new Error(`fate: Invalid hydration payload at '${path}'.`);
-const tagLengths = {
-	array: 2,
-	bigint: 2,
-	boolean: 2,
-	date: 2,
-	null: 1,
-	number: 2,
-	object: 2,
-	ref: 2,
-	string: 2,
-	undefined: 1
-};
-const decodeHydrationValue = (value, limits) => {
-	const resolvedLimits = resolveHydrationLimits(limits);
-	let nodes = 0;
-	const decode = (entry, path, depth) => {
-		nodes += 1;
-		if (nodes > resolvedLimits.maxNodes || depth > maxDepth || !Array.isArray(entry) || typeof entry[0] !== "string") throw invalidPayload(path);
-		const [tag, payload] = entry;
-		if (entry.length !== tagLengths[tag]) throw invalidPayload(path);
-		switch (tag) {
-			case "null": return null;
-			case "undefined": return;
-			case "string":
-				if (typeof payload !== "string" || payload.length > resolvedLimits.maxStringLength) throw invalidPayload(path);
-				return payload;
-			case "boolean":
-				if (typeof payload !== "boolean") throw invalidPayload(path);
-				return payload;
-			case "number":
-				if (typeof payload === "number") {
-					if (!Number.isFinite(payload) || Object.is(payload, -0)) throw invalidPayload(path);
-					return payload;
-				}
-				if (payload === "NaN") return NaN;
-				if (payload === "Infinity") return Infinity;
-				if (payload === "-Infinity") return -Infinity;
-				if (payload === "-0") return -0;
-				throw invalidPayload(path);
-			case "bigint":
-				if (typeof payload !== "string" || payload.length > resolvedLimits.maxStringLength) throw invalidPayload(path);
-				try {
-					const bigint = BigInt(payload);
-					if (String(bigint) !== payload) throw invalidPayload(path);
-					return bigint;
-				} catch {
-					throw invalidPayload(path);
-				}
-			case "date": {
-				if (typeof payload !== "string" || payload.length > resolvedLimits.maxStringLength) throw invalidPayload(path);
-				const date = new Date(payload);
-				if (Number.isNaN(date.getTime()) || date.toISOString() !== payload) throw invalidPayload(path);
-				return date;
-			}
-			case "ref":
-				if (typeof payload !== "string" || payload.length > resolvedLimits.maxStringLength) throw invalidPayload(path);
-				return createNodeRef(payload);
-			case "array":
-				if (!Array.isArray(payload) || !isDenseArray(payload) || payload.length > resolvedLimits.maxCollectionLength) throw invalidPayload(path);
-				return payload.map((item, index) => decode(item, `${path}[${String(index)}]`, depth + 1));
-			case "object": {
-				if (!Array.isArray(payload) || payload.length > resolvedLimits.maxCollectionLength) throw invalidPayload(path);
-				const result = Object.create(null);
-				for (const item of payload) {
-					if (!Array.isArray(item) || item.length !== 2 || typeof item[0] !== "string" || item[0].length > resolvedLimits.maxStringLength) throw invalidPayload(path);
-					if (item[0] in result) throw invalidPayload(path);
-					result[item[0]] = decode(item[1], `${path}.${item[0]}`, depth + 1);
-				}
-				return result;
-			}
-			default: throw invalidPayload(path);
-		}
-	};
-	return decode(value, "data", 0);
-};
-const isRecord$1 = (value) => {
-	if (!value || typeof value !== "object" || Array.isArray(value) || isNodeRef(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-};
-const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
-const hasDuplicates = (values) => new Set(values).size !== values.length;
-const isUniqueStringArray = (value) => isStringArray(value) && !hasDuplicates(value);
-const hasOnlyKeys = (value, keys) => Object.keys(value).every((key) => keys.has(key));
-const listKeys = /* @__PURE__ */ new Set([
-	"backwardPageLimit",
-	"cursors",
-	"forwardPageLimit",
-	"ids",
-	"liveAfterIds",
-	"liveBeforeIds",
-	"pagination",
-	"pendingAfterIds",
-	"pendingBeforeIds"
-]);
-const paginationKeys = /* @__PURE__ */ new Set([
-	"hasNext",
-	"hasPrevious",
-	"nextCursor",
-	"previousCursor"
-]);
-const clientStateKeys = /* @__PURE__ */ new Set([
-	"rootLists",
-	"rootRequests",
-	"store"
-]);
-const storeStateKeys = /* @__PURE__ */ new Set([
-	"coverage",
-	"lists",
-	"records"
-]);
-const isEntry = (value) => Array.isArray(value) && value.length === 2 && typeof value[0] === "string";
-const isOptionalLimit = (value) => value === void 0 || typeof value === "number" && Number.isInteger(value) && value >= 0;
-const isPagination = (value) => value === void 0 || isRecord$1(value) && hasOnlyKeys(value, paginationKeys) && typeof value.hasNext === "boolean" && typeof value.hasPrevious === "boolean" && (value.nextCursor === void 0 || typeof value.nextCursor === "string") && (value.previousCursor === void 0 || typeof value.previousCursor === "string");
-const isList = (value) => {
-	if (!isRecord$1(value) || !hasOnlyKeys(value, listKeys) || !isStringArray(value.ids) || hasDuplicates(value.ids) || value.cursors !== void 0 && (!Array.isArray(value.cursors) || value.cursors.length !== value.ids.length)) return false;
-	return (value.cursors === void 0 || Array.isArray(value.cursors) && value.cursors.every((entry) => entry === void 0 || typeof entry === "string")) && (value.liveAfterIds === void 0 || isUniqueStringArray(value.liveAfterIds)) && (value.liveBeforeIds === void 0 || isUniqueStringArray(value.liveBeforeIds)) && isOptionalLimit(value.backwardPageLimit) && isOptionalLimit(value.forwardPageLimit) && isPagination(value.pagination) && (value.pendingAfterIds === void 0 || isUniqueStringArray(value.pendingAfterIds)) && (value.pendingBeforeIds === void 0 || isUniqueStringArray(value.pendingBeforeIds));
-};
-const isFieldPath = (value) => value.length > 0 && value.split(".").every((segment) => segment.length > 0);
-const isFieldPathArray = (value) => isUniqueStringArray(value) && value.every(isFieldPath);
-const hasDuplicateEntries = (entries) => hasDuplicates(entries.map((entry) => entry[0]));
-const decodeClientHydrationState = (value, limits) => {
-	const decoded = decodeHydrationValue(value, limits);
-	if (!isRecord$1(decoded) || !hasOnlyKeys(decoded, clientStateKeys) || !Array.isArray(decoded.rootLists) || !Array.isArray(decoded.rootRequests) || !isRecord$1(decoded.store) || !hasOnlyKeys(decoded.store, storeStateKeys) || !Array.isArray(decoded.store.coverage) || !Array.isArray(decoded.store.lists) || !Array.isArray(decoded.store.records)) throw invalidPayload("data");
-	if (decoded.rootLists.some((entry) => !isEntry(entry) || !isStringArray(entry[1])) || decoded.rootRequests.some((entry) => !isEntry(entry) || entry[1] !== null && typeof entry[1] !== "string") || decoded.store.coverage.some((entry) => !isEntry(entry) || !isFieldPathArray(entry[1])) || decoded.store.lists.some((entry) => !isEntry(entry) || !isList(entry[1])) || decoded.store.records.some((entry) => !isEntry(entry) || !isRecord$1(entry[1]))) throw invalidPayload("data");
-	if (hasDuplicateEntries(decoded.rootLists) || hasDuplicateEntries(decoded.rootRequests) || hasDuplicateEntries(decoded.store.coverage) || hasDuplicateEntries(decoded.store.lists) || hasDuplicateEntries(decoded.store.records) || decoded.rootLists.some(([, keys]) => hasDuplicates(keys))) throw invalidPayload("data");
-	return decoded;
-};
-//#endregion
-//#region src/mask.ts
-function emptyMask() {
-	return {
-		all: false,
-		children: /* @__PURE__ */ new Map()
-	};
-}
-function cloneMask(m) {
-	const clone = {
-		all: m.all,
-		children: /* @__PURE__ */ new Map()
-	};
-	for (const [key, value] of m.children) clone.children.set(key, cloneMask(value));
-	return clone;
-}
-function addPath(mask, path) {
-	if (mask.all) return;
-	const parts = path.split(".");
-	let current = mask;
-	for (let i = 0; i < parts.length; i++) {
-		const seg = parts[i];
-		let child = current.children.get(seg);
-		if (!child) {
-			child = emptyMask();
-			current.children.set(seg, child);
-		}
-		current = child;
-	}
-	current.all = true;
-	current.children.clear();
-}
-function union(into, b) {
-	if (into.all || b.all) {
-		into.all = true;
-		into.children.clear();
-		return;
-	}
-	for (const [key, child] of b.children) {
-		const exist = into.children.get(key);
-		if (!exist) into.children.set(key, cloneMask(child));
-		else union(exist, child);
-	}
-}
-function fromPaths(paths) {
-	const mask = emptyMask();
-	for (const path of paths) addPath(mask, path);
-	return mask;
-}
-function toPaths(mask) {
-	const paths = [];
-	const visit = (current, prefix) => {
-		if (current.all) {
-			if (prefix) paths.push(prefix);
-			return;
-		}
-		for (const [key, child] of current.children) visit(child, prefix ? `${prefix}.${key}` : key);
-	};
-	visit(mask, null);
-	return paths;
-}
-function isCovered(mask, path) {
-	if (mask.all) return true;
-	const parts = path.split(".");
-	let current = mask;
-	for (let i = 0; i < parts.length; i++) {
-		if (!current) return false;
-		if (current.all) return true;
-		current = current.children.get(parts[i]);
-	}
-	return !!current && (current.all || current.children.size === 0);
-}
-function diffPaths(paths, mask) {
-	const missing = /* @__PURE__ */ new Set();
-	for (const path of paths) if (!isCovered(mask, path)) missing.add(path);
-	return missing;
-}
-function intersects(a, b) {
-	if (a.all || b.all) return true;
-	for (const [key, child] of a.children) {
-		const otherChild = b.children.get(key);
-		if (!otherChild) continue;
-		if (child.all || otherChild.all) return true;
-		if (intersects(child, otherChild)) return true;
-	}
-	return false;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@trpc+server@11.18.0_typescript@6.0.3/node_modules/@trpc/server/dist/getErrorShape-BPSzUA7W.mjs
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-const JSONRPC2_TO_HTTP_CODE = {
-	PARSE_ERROR: 400,
-	BAD_REQUEST: 400,
-	UNAUTHORIZED: 401,
-	PAYMENT_REQUIRED: 402,
-	FORBIDDEN: 403,
-	NOT_FOUND: 404,
-	METHOD_NOT_SUPPORTED: 405,
-	TIMEOUT: 408,
-	CONFLICT: 409,
-	PRECONDITION_FAILED: 412,
-	PAYLOAD_TOO_LARGE: 413,
-	UNSUPPORTED_MEDIA_TYPE: 415,
-	UNPROCESSABLE_CONTENT: 422,
-	PRECONDITION_REQUIRED: 428,
-	TOO_MANY_REQUESTS: 429,
-	CLIENT_CLOSED_REQUEST: 499,
-	INTERNAL_SERVER_ERROR: 500,
-	NOT_IMPLEMENTED: 501,
-	BAD_GATEWAY: 502,
-	SERVICE_UNAVAILABLE: 503,
-	GATEWAY_TIMEOUT: 504
-};
-function getStatusCodeFromKey(code) {
-	var _JSONRPC2_TO_HTTP_COD;
-	return (_JSONRPC2_TO_HTTP_COD = JSONRPC2_TO_HTTP_CODE[code]) !== null && _JSONRPC2_TO_HTTP_COD !== void 0 ? _JSONRPC2_TO_HTTP_COD : 500;
-}
-function getHTTPStatusCodeFromError(error) {
-	return getStatusCodeFromKey(error.code);
-}
-var require_typeof = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
-	function _typeof$2(o) {
-		"@babel/helpers - typeof";
-		return module.exports = _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
-			return typeof o$1;
-		} : function(o$1) {
-			return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
-		}, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
-	}
-	module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} });
-var require_toPrimitive = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(exports, module) {
-	var _typeof$1 = require_typeof()["default"];
-	function toPrimitive$1(t, r) {
-		if ("object" != _typeof$1(t) || !t) return t;
-		var e = t[Symbol.toPrimitive];
-		if (void 0 !== e) {
-			var i = e.call(t, r || "default");
-			if ("object" != _typeof$1(i)) return i;
-			throw new TypeError("@@toPrimitive must return a primitive value.");
-		}
-		return ("string" === r ? String : Number)(t);
-	}
-	module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} });
-var require_toPropertyKey = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(exports, module) {
-	var _typeof = require_typeof()["default"];
-	var toPrimitive = require_toPrimitive();
-	function toPropertyKey$1(t) {
-		var i = toPrimitive(t, "string");
-		return "symbol" == _typeof(i) ? i : i + "";
-	}
-	module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} });
-var require_defineProperty = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
-	var toPropertyKey = require_toPropertyKey();
-	function _defineProperty(e, r, t) {
-		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-			value: t,
-			enumerable: !0,
-			configurable: !0,
-			writable: !0
-		}) : e[r] = t, e;
-	}
-	module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} });
-__toESM(__commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
-	var defineProperty = require_defineProperty();
-	function ownKeys(e, r) {
-		var t = Object.keys(e);
-		if (Object.getOwnPropertySymbols) {
-			var o = Object.getOwnPropertySymbols(e);
-			r && (o = o.filter(function(r$1) {
-				return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
-			})), t.push.apply(t, o);
-		}
-		return t;
-	}
-	function _objectSpread2(e) {
-		for (var r = 1; r < arguments.length; r++) {
-			var t = null != arguments[r] ? arguments[r] : {};
-			r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
-				defineProperty(e, r$1, t[r$1]);
-			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
-				Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
-			});
-		}
-		return e;
-	}
-	module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} })(), 1);
-//#endregion
-//#region src/view.ts
-/**
-* Collects all view payloads that apply to the given ref.
-*/
-const getViewPayloads = (view, ref) => {
-	const result = [];
-	for (const [key, value] of Object.entries(view)) if (isViewTag(key) && (!ref || ref[ViewsTag]?.has(key))) result.push(value);
-	return result;
-};
-/**
-* Returns the set of view tags defined on a view composition.
-*/
-const getViewNames = (view) => {
-	const result = /* @__PURE__ */ new Set();
-	for (const key of Object.keys(view)) if (isViewTag(key)) result.add(key);
-	return result;
-};
-/**
-* Extracts view tags from a nested selection object.
-*/
-const getSelectionViewNames = (selection) => {
-	return getViewNames(selection);
-};
-let id = 0;
-const importMetaEnvironment = import.meta.env;
-const isDevelopment = typeof importMetaEnvironment?.DEV === "boolean" ? importMetaEnvironment.DEV : typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : false;
-let viewModulePath = null;
-const getStableId = () => {
-	if (isDevelopment) try {
-		if (viewModulePath == null) viewModulePath = new URL(import.meta.url).pathname;
-		const stack = (/* @__PURE__ */ new Error()).stack?.split("\n");
-		if (stack) for (let i = 1; i < stack.length; i++) {
-			const match = stack[i].trim().match(/\(?([^()]+):(\d+):(\d+)\)?$/);
-			if (!match) continue;
-			const [, source, line, column] = match;
-			if (!source.includes(viewModulePath)) {
-				const file = source.startsWith("at ") ? source.slice(3) : source;
-				return `${/^[A-Za-z][\d+.A-Za-z-]*:/.test(file) ? new URL(file).pathname : file}:${line}:${column}`;
-			}
-		}
-	} catch {}
-	return String(id++);
-};
-/**
-* Creates a reusable view for an object using the declared selection.
-*
-* @example
-* const PostView = view<Post>()({
-*   id: true,
-*   title: true,
-* });
-*/
-function view() {
-	const viewId = getStableId();
-	return (select) => {
-		const payload = Object.freeze({
-			select,
-			[ViewKind]: true
-		});
-		const viewComposition = Object.defineProperty({}, getViewTag(viewId), {
-			configurable: false,
-			enumerable: true,
-			value: payload,
-			writable: false
-		});
-		return Object.freeze(viewComposition);
-	};
-}
-//#endregion
-//#region src/ref.ts
-/**
-* Builds the canonical cache ID for an entity.
-*/
-const toEntityId = (type, rawId) => `${type}:${String(rawId)}`;
-/**
-* Splits a cache entity ID back into its type and raw identifier.
-*/
-function parseEntityId(id) {
-	const idx = id.indexOf(":");
-	return idx < 0 ? {
-		id,
-		type: ""
-	} : {
-		id: id.slice(idx + 1),
-		type: id.slice(0, idx)
-	};
-}
-/**
-* Attaches view tags to a ref without leaking the symbol.
-*/
-function assignViewTag(target, value) {
-	Object.defineProperty(target, ViewsTag, {
-		configurable: false,
-		enumerable: false,
-		value,
-		writable: false
-	});
-}
-const getRootViewNames = (view) => {
-	const names = new Set(getViewNames(view));
-	const payloads = getViewPayloads(view, null);
-	for (const payload of payloads) for (const name of getSelectionViewNames(payload.select)) names.add(name);
-	return names;
-};
-function createRefWithViewNames(__typename, id, names) {
-	const ref = {
-		__typename,
-		id
-	};
-	assignViewTag(ref, names);
-	return Object.freeze(ref);
-}
-//#endregion
-//#region src/selection.ts
-const isConnectionSelection = (value) => isRecord(value.items) && "node" in value.items;
-/**
-* Flattens a view into a `SelectionPlan`, expanding composed views and
-* partitioning nested args so the client can fetch exactly what is declared.
-*/
-const getSelectionPlan = (viewComposition, ref) => {
-	const args = /* @__PURE__ */ new Map();
-	const live = /* @__PURE__ */ new Map();
-	const paths = /* @__PURE__ */ new Set();
-	const assignArgs = (path, value, ignoreKeys) => {
-		const hash = hashArgs(value, { ignoreKeys });
-		args.set(path, {
-			hash,
-			ignoreKeys,
-			value
-		});
-	};
-	const walk = (selection, prefix, context = "default") => {
-		if (prefix === null && context !== "connection" && isConnectionSelection(selection)) {
-			if (selection.live && isRecord(selection.live)) live.set("", {
-				append: selection.live.append === "visible" ? "visible" : "edge",
-				prepend: selection.live.prepend === "visible" ? "visible" : "edge"
-			});
-			if (selection.args && isRecord(selection.args)) {
-				const clonedArgs = cloneArgs(selection.args, "args");
-				const ignoreKeys = isRecord(selection.items) && isRecord(selection.items.node) ? paginationArgKeys : void 0;
-				assignArgs("", clonedArgs, ignoreKeys);
-			}
-			const { args: _args, live: _live, ...withoutArgs } = selection;
-			walk(withoutArgs, prefix, "connection");
-			return;
-		}
-		for (const [key, value] of Object.entries(selection)) {
-			const valueType = typeof value;
-			const path = prefix ? `${prefix}.${key}` : key;
-			if (context === "connection") {
-				if (key === "args" || key === "live" || key === "pagination") continue;
-				if (key === "items" && isRecord(value)) {
-					if (isRecord(value.node)) walk(value.node, prefix);
-					continue;
-				}
-			}
-			if (valueType === "boolean") {
-				if (value) paths.add(path);
-				continue;
-			}
-			if (isDeferredSelection(value)) continue;
-			if (isViewTag(key)) {
-				if (!ref || ref[ViewsTag] && ref[ViewsTag].has(key)) walk(value.select, prefix);
-				continue;
-			}
-			if (isRecord(value)) {
-				const selectionObject = value;
-				if (isConnectionSelection(selectionObject)) {
-					if (selectionObject.live && isRecord(selectionObject.live)) live.set(path, {
-						append: selectionObject.live.append === "visible" ? "visible" : "edge",
-						prepend: selectionObject.live.prepend === "visible" ? "visible" : "edge"
-					});
-					if (selectionObject.args && isRecord(selectionObject.args)) {
-						const clonedArgs = cloneArgs(selectionObject.args, path);
-						const ignoreKeys = isRecord(selectionObject.items) && isRecord(selectionObject.items.node) ? paginationArgKeys : void 0;
-						assignArgs(path, clonedArgs, ignoreKeys);
-					}
-					const { args: _ignored, live: _live, ...withoutArgs } = selectionObject;
-					walk(withoutArgs, path, "connection");
-					continue;
-				}
-				const hasArgs = selectionObject.args && isRecord(selectionObject.args);
-				let selectionWithoutArgs = selectionObject;
-				if (hasArgs) {
-					const clonedArgs = cloneArgs(selectionObject.args, path);
-					const ignoreKeys = isRecord(selectionObject.items) && isRecord(selectionObject.items?.node) ? paginationArgKeys : void 0;
-					assignArgs(path, clonedArgs, ignoreKeys);
-					const { args: _args, ...rest } = selectionObject;
-					selectionWithoutArgs = rest;
-				}
-				if (Object.keys(selectionWithoutArgs).length > 0) walk(selectionWithoutArgs, path);
-				else if (hasArgs) paths.add(path);
-			}
-		}
-	};
-	const payloads = getViewPayloads(viewComposition, ref);
-	if (payloads.length === 0 && isRecord(viewComposition)) walk(viewComposition, null);
-	else for (const payload of payloads) walk(payload.select, null);
-	return {
-		args,
-		live,
-		paths
-	};
-};
-const getDeferredSelectionPlan = (field, selection) => {
-	return getSelectionPlan({ [field]: selection }, null);
-};
-//#endregion
-//#region src/mutation.ts
-/**
-* Defines a mutation for a given entity type, preserving the input and output
-* types for transports.
-*/
-function mutation(entity) {
-	return Object.freeze({
-		entity,
-		[MutationKind]: true
-	});
-}
-const collectImplicitSelectedPaths = (value) => {
-	const paths = /* @__PURE__ */ new Set();
-	const walk = (current, prefix) => {
-		if (!current || typeof current !== "object") {
-			if (prefix) paths.add(prefix);
-			return;
-		}
-		if (Array.isArray(current)) {
-			if (prefix) paths.add(prefix);
-			for (const child of current) walk(child, prefix);
-			return;
-		}
-		for (const [key, child] of Object.entries(current)) {
-			const next = prefix ? `${prefix}.${key}` : key;
-			paths.add(next);
-			walk(child, next);
-		}
-	};
-	walk(value, null);
-	return paths;
-};
-const maybeGetId = (getId, input) => {
-	try {
-		return getId(input);
-	} catch {
-		return null;
-	}
-};
-const emptySet$1 = /* @__PURE__ */ new Set();
-/**
-* Binds a mutation definition to a `FateClient`, wiring up optimistic updates,
-* cache writes, and error handling.
-*/
-function wrapMutation(client, identifier) {
-	const config = client.getTypeConfig(identifier.entity);
-	return async ({ args, delete: deleteRecord, input, insert = "after", optimistic, view }) => {
-		const id = maybeGetId(config.getId, input);
-		const plan = view ? getSelectionPlan(view, null) : void 0;
-		const viewSelection = plan?.paths;
-		const optimisticRecord = optimistic ? id != null ? {
-			id,
-			...optimistic
-		} : optimistic : void 0;
-		const optimisticRecordId = optimisticRecord !== void 0 ? maybeGetId(config.getId, optimisticRecord) : null;
-		const optimisticEntityId = id != null ? toEntityId(identifier.entity, id) : optimisticRecordId != null ? toEntityId(identifier.entity, optimisticRecordId) : null;
-		const snapshots = /* @__PURE__ */ new Map();
-		const listSnapshots = deleteRecord || optimisticRecord ? /* @__PURE__ */ new Map() : void 0;
-		const optimisticSelection = optimisticRecord ? collectImplicitSelectedPaths(optimisticRecord) : void 0;
-		const selection = viewSelection || optimisticSelection ? /* @__PURE__ */ new Set([...viewSelection ? [...viewSelection] : [], ...optimisticSelection ? [...optimisticSelection] : []]) : /* @__PURE__ */ new Set();
-		if (deleteRecord && id == null) throw new Error(`fate: Mutation '${identifier.key}' requires an 'id' to delete.`);
-		const optimisticToken = optimisticEntityId ? client.registerOptimisticUpdate(optimisticEntityId, optimisticSelection ?? emptySet$1) : null;
-		if (optimisticRecord && optimisticEntityId) client.write(identifier.entity, optimisticRecord, optimisticSelection ?? emptySet$1, snapshots, plan, null, null, insert, listSnapshots);
-		if (deleteRecord && id != null) client.deleteRecord(identifier.entity, id, snapshots, listSnapshots);
-		const performMutation = async () => {
-			try {
-				const result = await client.executeMutation(identifier.key, input, selection, {
-					args,
-					plan
-				});
-				if (result && typeof result === "object" && (!deleteRecord || Boolean(view))) {
-					const select = collectImplicitSelectedPaths(result);
-					const pendingMask = optimisticEntityId ? client.getPendingOptimisticMask(optimisticEntityId, { excludeToken: optimisticToken }) : null;
-					const filteredSelection = optimisticEntityId ? client.filterSelectionForPendingOptimistics(optimisticEntityId, select, { excludeToken: optimisticToken }) : select;
-					client.write(identifier.entity, result, filteredSelection, void 0, plan, null, pendingMask, insert);
-					if (deleteRecord && id != null) client.deleteRecord(identifier.entity, id);
-					const resultId = maybeGetId(config.getId, result);
-					if (optimisticEntityId && resultId != null) client.resolveOptimisticEntity(optimisticEntityId, toEntityId(identifier.entity, resultId));
-					if (optimisticRecordId != null && resultId != null && optimisticRecordId !== resultId) client.deleteRecord(identifier.entity, optimisticRecordId);
-				}
-				return {
-					error: void 0,
-					result
-				};
-			} catch (error) {
-				client.clearOptimisticUpdate(optimisticToken);
-				if (snapshots.size > 0) for (const [id, snapshot] of snapshots) client.restore(id, snapshot);
-				if (listSnapshots && listSnapshots.size > 0) for (const [name, list] of listSnapshots) client.restoreList(name, list);
-				if (error instanceof Error) {
-					const statusCode = getErrorStatusCode(error);
-					if ((statusCode ? categorizeHTTPErrorStatus(statusCode) : "boundary") === "boundary") throw error;
-					return {
-						error,
-						result: void 0
-					};
-				} else throw new Error(`fate: Mutation '${identifier.key}' failed.`);
-			} finally {
-				client.clearOptimisticUpdate(optimisticToken);
-			}
-		};
-		const mutationPromise = client.trackPendingRequest(performMutation);
-		if (optimisticEntityId) client.registerPendingOptimisticMutation(optimisticEntityId, mutationPromise);
-		return mutationPromise;
-	};
-}
-const getErrorStatusCode = (error) => {
-	if (error instanceof FateRequestError) return error.status;
-	const { data } = error;
-	if (!data || typeof data !== "object") return;
-	return getHTTPStatusCodeFromError(data);
-};
-const categorizeHTTPErrorStatus = (statusCode) => {
-	switch (statusCode) {
-		case 400:
-		case 402:
-		case 404:
-		case 408:
-		case 409:
-		case 412:
-		case 413:
-		case 415:
-		case 422:
-		case 429:
-		case 499: return "callSite";
-		default: return "boundary";
-	}
-};
-//#endregion
 //#region src/operation-lifetime.ts
 var OperationLifetime = class {
 	constructor(releaseBufferSize) {
@@ -928,6 +105,15 @@ var OperationLifetime = class {
 	getDescriptors() {
 		return [...this.operations.values()].map((operation) => operation.descriptor);
 	}
+	restore(descriptors) {
+		for (const descriptor of descriptors.slice(-Math.max(1, this.releaseBufferSize))) if (!this.operations.has(descriptor.key)) {
+			this.operations.set(descriptor.key, {
+				descriptor,
+				refCount: 0
+			});
+			this.releaseBuffer.push(descriptor.key);
+		}
+	}
 	release(key) {
 		const operation = this.operations.get(key);
 		if (!operation) return false;
@@ -956,554 +142,6 @@ var OperationLifetime = class {
 	}
 };
 //#endregion
-//#region src/store.ts
-const listKeySeparator = " __fate__ ";
-const decodeListKeyPart = (part) => {
-	try {
-		return decodeURIComponent(part);
-	} catch {
-		return part;
-	}
-};
-const encodeListKeyPart = (part) => encodeURIComponent(part);
-const getListKey = (ownerId, field, hash = "default") => `${encodeListKeyPart(ownerId)}${listKeySeparator}${encodeListKeyPart(field)}${listKeySeparator}${encodeListKeyPart(hash)}`;
-const getOwnerFieldKey = (ownerId, field) => JSON.stringify([ownerId, field]);
-const parseListKey = (key) => {
-	const parts = key.split(listKeySeparator);
-	if (parts.length !== 3) return null;
-	const [ownerId, field] = parts;
-	return {
-		field: decodeListKeyPart(field),
-		ownerId: decodeListKeyPart(ownerId)
-	};
-};
-const cloneValue = (value) => {
-	if (Array.isArray(value)) return value.map(cloneValue);
-	if (isNodeRef(value)) return value;
-	if (value != null && typeof value === "object") {
-		const result = {};
-		for (const [key, record] of Object.entries(value)) result[key] = cloneValue(record);
-		return result;
-	}
-	return value;
-};
-const isPlainRecord = (value) => {
-	if (value == null || typeof value !== "object" || Array.isArray(value) || isNodeRef(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-};
-const isDate = (value) => value != null && typeof value === "object" && Object.prototype.toString.call(value) === "[object Date]" && typeof value.getTime === "function";
-const mergePreservingExisting = (incoming, existing) => {
-	if (!isPlainRecord(incoming) || !isPlainRecord(existing)) return existing;
-	const result = Object.create(null);
-	for (const [key, value] of Object.entries(incoming)) Object.defineProperty(result, key, {
-		configurable: true,
-		enumerable: true,
-		value,
-		writable: true
-	});
-	for (const [key, value] of Object.entries(existing)) Object.defineProperty(result, key, {
-		configurable: true,
-		enumerable: true,
-		value: Object.hasOwn(result, key) ? mergePreservingExisting(result[key], value) : value,
-		writable: true
-	});
-	return result;
-};
-const areHydrationValuesEqual = (left, right) => {
-	if (Object.is(left, right)) return true;
-	if (isNodeRef(left) || isNodeRef(right)) return isNodeRef(left) && isNodeRef(right) && getNodeRefId(left) === getNodeRefId(right);
-	if (isDate(left) || isDate(right)) return isDate(left) && isDate(right) && left.getTime() === right.getTime();
-	if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => areHydrationValuesEqual(value, right[index]));
-	if (!isPlainRecord(left) || !isPlainRecord(right)) return false;
-	const leftKeys = Object.keys(left);
-	const rightKeys = Object.keys(right);
-	return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(right, key) && areHydrationValuesEqual(left[key], right[key]));
-};
-const areMasksEqual = (left, right) => {
-	if (!left || !right) return left === right;
-	const leftPaths = toPaths(left).sort();
-	const rightPaths = toPaths(right).sort();
-	return leftPaths.length === rightPaths.length && leftPaths.every((path, index) => path === rightPaths[index]);
-};
-const emptyFunction = () => {};
-var Store = class {
-	constructor() {
-		this.coverage = /* @__PURE__ */ new Map();
-		this.listKeysByOwnerField = /* @__PURE__ */ new Map();
-		this.listKeysByReferencedEntity = /* @__PURE__ */ new Map();
-		this.lists = /* @__PURE__ */ new Map();
-		this.recordReferenceFields = /* @__PURE__ */ new Map();
-		this.recordReferencesByTarget = /* @__PURE__ */ new Map();
-		this.records = /* @__PURE__ */ new Map();
-		this.subscriptions = /* @__PURE__ */ new Map();
-		this.listSubscriptions = /* @__PURE__ */ new Map();
-	}
-	dehydrate() {
-		return {
-			coverage: [...this.coverage].map(([id, mask]) => [id, toPaths(mask)]),
-			lists: [...this.lists],
-			records: [...this.records]
-		};
-	}
-	hydrate(state, mode, options = {}) {
-		const previousCoverage = this.coverage;
-		const previousLists = this.lists;
-		const previousRecords = this.records;
-		const coverage = mode === "replace" ? /* @__PURE__ */ new Map() : new Map([...previousCoverage].map(([id, mask]) => [id, cloneMask(mask)]));
-		const lists = mode === "replace" ? /* @__PURE__ */ new Map() : new Map(previousLists);
-		const records = mode === "replace" ? /* @__PURE__ */ new Map() : new Map(previousRecords);
-		for (const [id, incoming] of state.records) {
-			const previous = records.get(id);
-			const next = previous && mode === "preserve-existing" ? mergePreservingExisting(incoming, previous) : incoming;
-			records.set(id, previous && areHydrationValuesEqual(previous, next) ? previous : next);
-		}
-		for (const [id, paths] of state.coverage) {
-			const incoming = fromPaths(paths);
-			const previous = coverage.get(id);
-			if (previous && mode === "preserve-existing") union(previous, incoming);
-			else coverage.set(id, incoming);
-		}
-		for (const [key, list] of state.lists) {
-			const previous = lists.get(key);
-			if (mode === "replace" || !previous) lists.set(key, previous && areHydrationValuesEqual(previous, list) ? previous : list);
-		}
-		this.coverage = coverage;
-		this.lists = lists;
-		this.records = records;
-		this.rebuildIndexes();
-		const changedRecordIds = /* @__PURE__ */ new Set();
-		for (const id of /* @__PURE__ */ new Set([...previousRecords.keys(), ...records.keys()])) if (!areHydrationValuesEqual(previousRecords.get(id), records.get(id)) || !areMasksEqual(previousCoverage.get(id), coverage.get(id))) changedRecordIds.add(id);
-		const changedListKeys = /* @__PURE__ */ new Set();
-		for (const key of /* @__PURE__ */ new Set([...previousLists.keys(), ...lists.keys()])) if (!areHydrationValuesEqual(previousLists.get(key), lists.get(key))) changedListKeys.add(key);
-		const notify = () => {
-			for (const id of changedRecordIds) this.notify(id);
-			for (const key of changedListKeys) this.notifyListSubscribers(key);
-		};
-		if (!options.deferNotifications) notify();
-		return notify;
-	}
-	rebuildIndexes() {
-		this.listKeysByOwnerField.clear();
-		this.listKeysByReferencedEntity.clear();
-		this.recordReferenceFields.clear();
-		this.recordReferencesByTarget.clear();
-		for (const [id, record] of this.records) this.addRecordReferenceIndexes(id, record);
-		for (const [key, list] of this.lists) this.addListIndexes(key, list);
-	}
-	read(id) {
-		return this.records.get(id);
-	}
-	merge(id, partial, paths) {
-		const changedPaths = this.mergeInternal(id, partial, paths);
-		if (changedPaths) this.notify(id, changedPaths);
-	}
-	mergeInternal(id, partial, paths) {
-		const previous = this.records.get(id);
-		const changedPaths = /* @__PURE__ */ new Set();
-		let mask = this.coverage.get(id);
-		if (!mask) {
-			mask = emptyMask();
-			this.coverage.set(id, mask);
-		}
-		union(mask, fromPaths(paths));
-		if (previous) {
-			let hasChanges = false;
-			for (const [key, value] of Object.entries(partial)) if (previous[key] !== value) {
-				hasChanges = true;
-				changedPaths.add(key);
-			}
-			if (!hasChanges) return null;
-			const nextRecord = {
-				...previous,
-				...partial
-			};
-			this.records.set(id, nextRecord);
-			this.updateRecordReferenceIndexes(id, previous, nextRecord, changedPaths);
-		} else {
-			const nextRecord = { ...partial };
-			this.records.set(id, nextRecord);
-			this.updateRecordReferenceIndexes(id, void 0, nextRecord, Object.keys(nextRecord));
-		}
-		return changedPaths;
-	}
-	deleteRecord(id) {
-		const record = this.records.get(id);
-		if (record) this.removeRecordReferenceIndexes(id, record);
-		this.records.delete(id);
-		this.coverage.delete(id);
-	}
-	missingForSelection(id, paths) {
-		const requested = new Set(paths);
-		if (!this.records.has(id)) return requested;
-		const mask = this.coverage.get(id);
-		if (!mask) return requested;
-		return diffPaths(requested, mask);
-	}
-	subscribe(id, selectionOrFn, callback) {
-		let mask = null;
-		let fn = emptyFunction;
-		if (typeof selectionOrFn === "function") fn = selectionOrFn;
-		else if (callback) {
-			mask = selectionOrFn ? fromPaths(selectionOrFn) : null;
-			fn = callback;
-		}
-		let subscribers = this.subscriptions.get(id);
-		if (!subscribers) {
-			subscribers = /* @__PURE__ */ new Set();
-			this.subscriptions.set(id, subscribers);
-		}
-		const subscription = {
-			fn,
-			mask
-		};
-		subscribers.add(subscription);
-		return () => {
-			const set = this.subscriptions.get(id);
-			if (!set) return;
-			set.delete(subscription);
-			if (set.size === 0) this.subscriptions.delete(id);
-		};
-	}
-	notify(id, paths) {
-		const set = this.subscriptions.get(id);
-		if (!set) return;
-		const changedPaths = paths ? [...paths] : [];
-		const changedMask = changedPaths.length > 0 ? fromPaths(changedPaths) : null;
-		for (const { fn, mask } of set) {
-			if (mask && changedMask && !intersects(changedMask, mask)) continue;
-			try {
-				fn();
-			} catch {}
-		}
-	}
-	notifyListSubscribers(key) {
-		const set = this.listSubscriptions.get(key);
-		if (!set) return;
-		for (const fn of set) try {
-			fn();
-		} catch {}
-	}
-	getList(key) {
-		return this.lists.get(key)?.ids;
-	}
-	getListState(key) {
-		return this.lists.get(key);
-	}
-	getListsForField(ownerId, field) {
-		const entries = [];
-		const keys = this.listKeysByOwnerField.get(getOwnerFieldKey(ownerId, field));
-		if (!keys) return entries;
-		for (const key of keys) {
-			const list = this.lists.get(key);
-			if (list) entries.push([key, list]);
-		}
-		return entries;
-	}
-	setList(key, state) {
-		const previous = this.lists.get(key);
-		if (previous) this.removeListIndexes(key, previous);
-		this.lists.set(key, state);
-		this.addListIndexes(key, state);
-		this.notifyListSubscribers(key);
-	}
-	replaceListEntityId(previousId, nextId) {
-		const keys = [...this.listKeysByReferencedEntity.get(previousId) ?? []];
-		for (const key of keys) {
-			const list = this.lists.get(key);
-			if (!list) continue;
-			let changed = false;
-			let ids = list.ids;
-			let cursors = list.cursors;
-			if (list.ids.includes(previousId)) {
-				const nextIds = [];
-				const nextCursors = list.cursors ? [] : void 0;
-				const seenIds = /* @__PURE__ */ new Set();
-				list.ids.forEach((id, index) => {
-					const resolved = id === previousId ? nextId : id;
-					if (seenIds.has(resolved)) return;
-					seenIds.add(resolved);
-					nextIds.push(resolved);
-					if (nextCursors) nextCursors.push(list.cursors?.[index]);
-				});
-				changed = true;
-				ids = nextIds;
-				cursors = nextCursors;
-			}
-			const dedupe = (values) => {
-				if (!values || !values.includes(previousId)) return;
-				const seen = /* @__PURE__ */ new Set();
-				const next = [];
-				for (const value of values) {
-					const resolved = value === previousId ? nextId : value;
-					if (seen.has(resolved)) continue;
-					seen.add(resolved);
-					next.push(resolved);
-				}
-				changed = true;
-				return next;
-			};
-			const pendingBeforeIds = dedupe(list.pendingBeforeIds) ?? list.pendingBeforeIds;
-			const pendingAfterIds = dedupe(list.pendingAfterIds) ?? list.pendingAfterIds;
-			const liveBeforeIds = dedupe(list.liveBeforeIds) ?? list.liveBeforeIds;
-			const liveAfterIds = dedupe(list.liveAfterIds) ?? list.liveAfterIds;
-			if (!changed) continue;
-			const canonicalIds = new Set(ids);
-			this.setList(key, {
-				backwardPageLimit: list.backwardPageLimit,
-				cursors,
-				forwardPageLimit: list.forwardPageLimit,
-				ids,
-				liveAfterIds: liveAfterIds?.filter((id) => !canonicalIds.has(id)),
-				liveBeforeIds: liveBeforeIds?.filter((id) => !canonicalIds.has(id)),
-				pagination: list.pagination,
-				pendingAfterIds: pendingAfterIds?.filter((id) => !canonicalIds.has(id)),
-				pendingBeforeIds: pendingBeforeIds?.filter((id) => !canonicalIds.has(id))
-			});
-		}
-	}
-	restoreList(key, list) {
-		if (list == null) this.deleteList(key);
-		else this.setList(key, list);
-	}
-	collectGarbage(markedRecords, markedLists, options = {}) {
-		const records = /* @__PURE__ */ new Set();
-		const lists = /* @__PURE__ */ new Set();
-		for (const id of this.records.keys()) {
-			if (markedRecords.has(id)) continue;
-			records.add(id);
-		}
-		for (const key of this.lists.keys()) {
-			if (markedLists.has(key)) continue;
-			lists.add(key);
-		}
-		for (const id of records) {
-			const record = this.records.get(id);
-			if (record) this.removeRecordReferenceIndexes(id, record);
-			this.records.delete(id);
-			this.coverage.delete(id);
-			options.onRecordDeleted?.(id);
-		}
-		for (const key of lists) this.deleteList(key);
-		return {
-			lists,
-			records
-		};
-	}
-	deleteList(key) {
-		const previous = this.lists.get(key);
-		if (previous) this.removeListIndexes(key, previous);
-		this.lists.delete(key);
-		this.notifyListSubscribers(key);
-	}
-	subscribeList(key, fn) {
-		let set = this.listSubscriptions.get(key);
-		if (!set) {
-			set = /* @__PURE__ */ new Set();
-			this.listSubscriptions.set(key, set);
-		}
-		set.add(fn);
-		return () => {
-			const subscribers = this.listSubscriptions.get(key);
-			if (!subscribers) return;
-			subscribers.delete(fn);
-			if (subscribers.size === 0) this.listSubscriptions.delete(key);
-		};
-	}
-	removeReferencesTo(targetId, viewDataCache, snapshots, listSnapshots) {
-		const listKeys = [...this.listKeysByReferencedEntity.get(targetId) ?? []];
-		for (const key of listKeys) {
-			const list = this.lists.get(key);
-			if (!list) continue;
-			const { ids } = list;
-			const hasLiveAfter = Boolean(list.liveAfterIds?.includes(targetId));
-			const hasLiveBefore = Boolean(list.liveBeforeIds?.includes(targetId));
-			const hasPendingAfter = Boolean(list.pendingAfterIds?.includes(targetId));
-			const hasPendingBefore = Boolean(list.pendingBeforeIds?.includes(targetId));
-			if (!ids.includes(targetId) && !hasLiveAfter && !hasLiveBefore && !hasPendingAfter && !hasPendingBefore) continue;
-			if (listSnapshots && !listSnapshots.has(key)) listSnapshots.set(key, list);
-			const entityIds = [];
-			const cursors = list.cursors ? [] : void 0;
-			for (let index = 0; index < ids.length; index++) {
-				const id = ids[index];
-				if (id === targetId) continue;
-				entityIds.push(id);
-				if (cursors) cursors.push(list.cursors?.[index]);
-			}
-			this.setList(key, {
-				backwardPageLimit: list.backwardPageLimit,
-				cursors,
-				forwardPageLimit: list.forwardPageLimit,
-				ids: entityIds,
-				liveAfterIds: list.liveAfterIds?.filter((id) => id !== targetId),
-				liveBeforeIds: list.liveBeforeIds?.filter((id) => id !== targetId),
-				pagination: list.pagination,
-				pendingAfterIds: list.pendingAfterIds?.filter((id) => id !== targetId),
-				pendingBeforeIds: list.pendingBeforeIds?.filter((id) => id !== targetId)
-			});
-		}
-		const ids = /* @__PURE__ */ new Map();
-		const recordEntries = [...this.recordReferencesByTarget.get(targetId)?.entries() ?? []];
-		for (const [id, fields] of recordEntries) {
-			const record = this.records.get(id);
-			if (!record) continue;
-			let updated = false;
-			const next = {};
-			const paths = /* @__PURE__ */ new Set();
-			for (const key of fields) {
-				const value = record[key];
-				if (Array.isArray(value)) {
-					const filtered = value.filter((item) => !(isNodeRef(item) && getNodeRefId(item) === targetId));
-					if (filtered.length !== value.length) {
-						updated = true;
-						paths.add(key);
-						next[key] = filtered;
-					}
-				} else if (isNodeRef(value) && getNodeRefId(value) === targetId) {
-					updated = true;
-					paths.add(key);
-					next[key] = null;
-				}
-			}
-			if (!updated) continue;
-			if (snapshots && !snapshots.has(id)) snapshots.set(id, this.snapshot(id));
-			viewDataCache.invalidate(id);
-			this.mergeInternal(id, next, paths);
-			ids.set(id, paths);
-		}
-		for (const [id, paths] of ids) this.notify(id, paths);
-	}
-	snapshot(id) {
-		const record = this.records.get(id);
-		const mask = this.coverage.get(id);
-		return {
-			mask: mask ? cloneMask(mask) : void 0,
-			record: record ? cloneValue(record) : void 0
-		};
-	}
-	restore(id, snapshot) {
-		const previous = this.records.get(id);
-		if (previous) this.removeRecordReferenceIndexes(id, previous);
-		if (snapshot.record === void 0) this.records.delete(id);
-		else {
-			this.records.set(id, snapshot.record);
-			this.addRecordReferenceIndexes(id, snapshot.record);
-		}
-		if (snapshot.mask === void 0) this.coverage.delete(id);
-		else this.coverage.set(id, snapshot.mask);
-		this.notify(id);
-	}
-	addListIndexes(key, list) {
-		const parsed = parseListKey(key);
-		if (parsed) {
-			const ownerFieldKey = getOwnerFieldKey(parsed.ownerId, parsed.field);
-			let keys = this.listKeysByOwnerField.get(ownerFieldKey);
-			if (!keys) {
-				keys = /* @__PURE__ */ new Set();
-				this.listKeysByOwnerField.set(ownerFieldKey, keys);
-			}
-			keys.add(key);
-		}
-		for (const id of this.getListReferencedEntityIds(list)) {
-			let keys = this.listKeysByReferencedEntity.get(id);
-			if (!keys) {
-				keys = /* @__PURE__ */ new Set();
-				this.listKeysByReferencedEntity.set(id, keys);
-			}
-			keys.add(key);
-		}
-	}
-	removeListIndexes(key, list) {
-		const parsed = parseListKey(key);
-		if (parsed) {
-			const ownerFieldKey = getOwnerFieldKey(parsed.ownerId, parsed.field);
-			const keys = this.listKeysByOwnerField.get(ownerFieldKey);
-			if (keys) {
-				keys.delete(key);
-				if (keys.size === 0) this.listKeysByOwnerField.delete(ownerFieldKey);
-			}
-		}
-		for (const id of this.getListReferencedEntityIds(list)) {
-			const keys = this.listKeysByReferencedEntity.get(id);
-			if (!keys) continue;
-			keys.delete(key);
-			if (keys.size === 0) this.listKeysByReferencedEntity.delete(id);
-		}
-	}
-	getListReferencedEntityIds(list) {
-		const ids = /* @__PURE__ */ new Set();
-		for (const id of list.ids) ids.add(id);
-		for (const id of list.liveAfterIds ?? []) ids.add(id);
-		for (const id of list.liveBeforeIds ?? []) ids.add(id);
-		for (const id of list.pendingAfterIds ?? []) ids.add(id);
-		for (const id of list.pendingBeforeIds ?? []) ids.add(id);
-		return ids;
-	}
-	getRecordFieldReferences(value) {
-		if (Array.isArray(value)) {
-			let ids = null;
-			for (const item of value) {
-				if (!isNodeRef(item)) continue;
-				if (!ids) ids = /* @__PURE__ */ new Set();
-				ids.add(getNodeRefId(item));
-			}
-			return ids;
-		}
-		if (isNodeRef(value)) return /* @__PURE__ */ new Set([getNodeRefId(value)]);
-		return null;
-	}
-	addRecordFieldReferenceIndex(id, field, value) {
-		const targets = this.getRecordFieldReferences(value);
-		if (!targets || targets.size === 0) return;
-		let fields = this.recordReferenceFields.get(id);
-		if (!fields) {
-			fields = /* @__PURE__ */ new Map();
-			this.recordReferenceFields.set(id, fields);
-		}
-		fields.set(field, targets);
-		for (const targetId of targets) {
-			let records = this.recordReferencesByTarget.get(targetId);
-			if (!records) {
-				records = /* @__PURE__ */ new Map();
-				this.recordReferencesByTarget.set(targetId, records);
-			}
-			let targetFields = records.get(id);
-			if (!targetFields) {
-				targetFields = /* @__PURE__ */ new Set();
-				records.set(id, targetFields);
-			}
-			targetFields.add(field);
-		}
-	}
-	removeRecordFieldReferenceIndex(id, field) {
-		const fields = this.recordReferenceFields.get(id);
-		const targets = fields?.get(field);
-		if (!fields || !targets) return;
-		for (const targetId of targets) {
-			const records = this.recordReferencesByTarget.get(targetId);
-			const targetFields = records?.get(id);
-			if (!records || !targetFields) continue;
-			targetFields.delete(field);
-			if (targetFields.size === 0) records.delete(id);
-			if (records.size === 0) this.recordReferencesByTarget.delete(targetId);
-		}
-		fields.delete(field);
-		if (fields.size === 0) this.recordReferenceFields.delete(id);
-	}
-	addRecordReferenceIndexes(id, record) {
-		for (const [field, value] of Object.entries(record)) this.addRecordFieldReferenceIndex(id, field, value);
-	}
-	removeRecordReferenceIndexes(id, record) {
-		for (const field of Object.keys(record)) this.removeRecordFieldReferenceIndex(id, field);
-	}
-	updateRecordReferenceIndexes(id, previous, next, fields) {
-		for (const field of fields) {
-			if (previous) this.removeRecordFieldReferenceIndex(id, field);
-			this.addRecordFieldReferenceIndex(id, field, next[field]);
-		}
-	}
-};
-//#endregion
 //#region src/request-descriptor.ts
 const serializeId = (value) => `${typeof value}:${String(value)}`;
 const getViewSignature = (view) => {
@@ -1826,24 +464,27 @@ var FateClient = class {
 		this.pending = /* @__PURE__ */ new Map();
 		this.pendingDeferred = /* @__PURE__ */ new Map();
 		this.pendingOptimisticMutations = /* @__PURE__ */ new Map();
-		this.optimisticMasks = /* @__PURE__ */ new Map();
-		this.optimisticByEntity = /* @__PURE__ */ new Map();
 		this.optimisticEntityResolutions = /* @__PURE__ */ new Map();
-		this.optimisticTokenCounter = 0;
 		this.liveSubscriptions = /* @__PURE__ */ new Map();
 		this.liveConnectionInvalidations = /* @__PURE__ */ new Map();
 		this.stableRefs = /* @__PURE__ */ new Map();
 		this.requests = /* @__PURE__ */ new Map();
+		this.requestExecutionOptions = /* @__PURE__ */ new WeakMap();
 		this.rootRequests = /* @__PURE__ */ new Map();
 		this.stalledRequests = /* @__PURE__ */ new Set();
 		this.gcPending = false;
 		this.gcScheduled = false;
 		this.pendingNetworkRequests = 0;
-		this.store = new Store();
-		this.viewDataCache = new ViewDataCache();
+		this.store = new Store((ids) => {
+			for (const id of ids) this.viewDataCache.invalidate(id);
+			this.runPendingGarbageCollection();
+		}, (kind, key, paths, previousList) => this.persistence?.changed(kind, key, paths, previousList));
+		this.viewDataCache = new ViewDataCache(() => !this.store.isRebasing);
 		this.liveConnectionInvalidationToken = 0;
+		this.persistenceDisposal = options.persistence ? new AbortController() : void 0;
 		this.actions = Object.create(null);
 		this.mutationMap = Object.create(null);
+		if (options.persistence) this.mutationEntities = new Map(Object.entries(options.mutations ?? {}).map(([key, definition]) => [key, definition.entity]));
 		this.mutations = Object.create(null);
 		this.onLiveError = options.onLiveError;
 		this.operationLifetime = new OperationLifetime(options.gcReleaseBufferSize ?? 10);
@@ -1867,6 +508,7 @@ var FateClient = class {
 			setNestedValue(this.actions, key, async (_previousState, data) => data === "reset" ? null : await this.mutationMap[key](data));
 		}
 		this.initializeParentLists();
+		this.persistence = options.persistence?.attach(this);
 	}
 	initializeParentLists() {
 		for (const config of this.types.values()) {
@@ -1945,6 +587,60 @@ var FateClient = class {
 		this.viewDataCache.clear();
 		notify();
 	}
+	/** @internal */
+	exportPersistenceState() {
+		return {
+			data: encodeHydrationValue({
+				rootLists: [...this.rootLists].map(([type, keys]) => [type, [...keys]]),
+				rootRequests: [...this.rootRequests],
+				store: this.store.dehydrateConfirmed()
+			}, this.hydrationLimits),
+			scope: this.hydrationScope,
+			version: 1
+		};
+	}
+	/** @internal */
+	retainPersistenceRequest(request) {
+		return this.operationLifetime.retain(request, () => this.scheduleGarbageCollection());
+	}
+	/** @internal */
+	getPersistenceScope() {
+		return this.hydrationScope;
+	}
+	/** @internal */
+	getPersistenceRootLists(type) {
+		return this.rootLists.get(type) ?? /* @__PURE__ */ new Set();
+	}
+	/** @internal */
+	getPersistenceQuery(key) {
+		return this.rootRequests.get(key);
+	}
+	/** @internal Merge a small disk read beneath optimistic layers. */
+	restorePersistenceData(state) {
+		this.store.update(() => {
+			const coverage = new Map(state.store.coverage);
+			for (const [id, record] of state.store.records) {
+				const existing = this.store.read(id);
+				const paths = coverage.get(id) ?? [];
+				this.store.merge(id, existing ? mergePreservingExisting(record, existing) : record, paths);
+			}
+			for (const [key, list] of state.store.lists) if (!this.store.getListState(key)) this.store.setList(key, list);
+			for (const [key, id] of state.rootRequests) if (!this.rootRequests.has(key)) this.rootRequests.set(key, id);
+			for (const [type, keys] of state.rootLists) for (const key of keys) this.registerRootList(type, key);
+		});
+	}
+	/** @internal */
+	getRetainedRequests() {
+		return this.operationLifetime.getDescriptors();
+	}
+	/** @internal */
+	restoreRetainedRequests(requests) {
+		this.operationLifetime.restore(requests);
+	}
+	/** @internal */
+	hasMutation(key, entity) {
+		return this.mutationEntities?.get(key) === entity && this.types.has(entity);
+	}
 	registerRootList(type, key) {
 		let lists = this.rootLists.get(type);
 		if (!lists) {
@@ -1953,11 +649,6 @@ var FateClient = class {
 		}
 		lists.add(key);
 	}
-	snapshotList(key, listSnapshots) {
-		if (!listSnapshots || listSnapshots.has(key)) return;
-		const listState = this.store.getListState(key);
-		if (listState) listSnapshots.set(key, listState);
-	}
 	applyListInsert(listState, entityId, insert) {
 		const pendingBeforeIds = listState.pendingBeforeIds ?? [];
 		const pendingAfterIds = listState.pendingAfterIds ?? [];
@@ -1986,7 +677,7 @@ var FateClient = class {
 			pending: false
 		};
 	}
-	insertIntoRootLists(type, entityId, insert, listSnapshots) {
+	insertIntoRootLists(type, entityId, insert) {
 		if (insert === "none") return;
 		const listNames = this.rootLists.get(type);
 		if (!listNames) return;
@@ -1995,7 +686,6 @@ var FateClient = class {
 			if (!listState) continue;
 			const next = this.applyListInsert(listState, entityId, insert).list;
 			if (next === listState) continue;
-			this.snapshotList(key, listSnapshots);
 			this.store.setList(key, next);
 		}
 	}
@@ -2009,8 +699,28 @@ var FateClient = class {
 		if (!descriptor || descriptor === "scalar" || !("listOf" in descriptor)) throw new Error(`fate: Could not find node type for '${type}.${field}'.`);
 		return descriptor.listOf;
 	}
+	/** @internal Validates local wiring without requiring network connectivity. */
+	validatePersistence() {
+		if (this.mutationEntities?.size) this.requireDurableMutationTransport();
+	}
+	/** @internal */
+	assertPersistenceActive() {
+		if (this.persistenceDisposal?.signal.aborted || this.persistence?.getSnapshot().status === "disposed") throw new Error("fate: Persistence was disposed.");
+	}
+	/** @internal */
+	disposePersistence() {
+		this.persistenceDisposal?.abort();
+		for (const { unsubscribe } of this.liveSubscriptions.values()) try {
+			unsubscribe();
+		} catch {}
+		this.liveSubscriptions.clear();
+	}
+	requireDurableMutationTransport() {
+		if (!this.transport.mutateDurably) throw new FateRequestError("BAD_REQUEST", "fate: Persisted mutations require transport.mutateDurably connected to a server idempotency handler. Configure that adapter, or use persist: false for immediate calls. Cache persistence remains available.");
+	}
 	async executeMutation(key, input, select, options = {}) {
-		if (!this.transport.mutate) throw new Error(`fate: transport does not support mutations. Please provide a 'mutate' implementation in your transport.`);
+		if (options.identity) this.requireDurableMutationTransport();
+		else if (!this.transport.mutate) throw new Error(`fate: transport does not support mutations. Please provide a 'mutate' implementation in your transport.`);
 		const baseRecord = input && typeof input === "object" ? input : void 0;
 		const inputArgs = baseRecord && typeof baseRecord.args === "object" ? baseRecord.args : void 0;
 		const argsPayload = combineArgsPayload(options.plan ? resolvedArgsFromPlan(options.plan) : void 0, combineArgsPayload(inputArgs, options.args));
@@ -2018,25 +728,19 @@ var FateClient = class {
 			...baseRecord,
 			args: argsPayload
 		} : argsPayload ? { args: argsPayload } : input;
-		return await this.trackPendingRequest(() => this.transport.mutate(key, requestInput, select));
-	}
-	write(type, data, select, snapshots, plan, pathPrefix = null, blockedMask, insert, listSnapshots) {
-		return this.writeEntity(type, data, select, snapshots, plan, pathPrefix, blockedMask, insert, listSnapshots);
-	}
-	deleteRecord(type, id, snapshots, listSnapshots) {
-		const entityId = toEntityId(type, id);
-		if (snapshots && !snapshots.has(entityId)) snapshots.set(entityId, this.store.snapshot(entityId));
-		this.viewDataCache.invalidate(entityId);
-		this.stableRefs.delete(entityId);
-		this.store.deleteRecord(entityId);
-		this.store.removeReferencesTo(entityId, this.viewDataCache, snapshots, listSnapshots);
-	}
-	restore(id, snapshot) {
-		this.viewDataCache.invalidate(id);
-		this.store.restore(id, snapshot);
-	}
-	restoreList(name, list) {
-		this.store.restoreList(name, list);
+		return await this.trackPendingRequest(() => options.identity ? this.transport.mutateDurably(key, requestInput, select, options.identity) : this.transport.mutate(key, requestInput, select));
+	}
+	write(type, data, select, plan, insert) {
+		return this.writeEntity(type, data, select, plan, null, insert);
+	}
+	deleteRecord(type, id) {
+		return this.store.update(() => {
+			const entityId = toEntityId(type, id);
+			this.viewDataCache.invalidate(entityId);
+			this.stableRefs.delete(entityId);
+			this.store.deleteRecord(entityId);
+			this.store.removeReferencesTo(entityId, this.viewDataCache);
+		});
 	}
 	stableRefWithViewNames(type, id, viewNames) {
 		const entityId = toEntityId(type, id);
@@ -2060,6 +764,18 @@ var FateClient = class {
 		return this.stableRefWithViewNames(type, id, getRootViewNames(rootView));
 	}
 	readView(view, ref) {
+		if (this.persistence && this.persistence.getSnapshot().status !== "ready") {
+			const key = `restore:${ref.__typename}:${ref.id}:${[...getViewNames(view)].sort().join(",")}`;
+			let pending = this.pending.get(key);
+			if (!pending) {
+				pending = this.persistence.ready.then(() => {
+					if (this.persistence?.getSnapshot().status === "disposed") throw new Error("fate: Persistence was disposed.");
+					return this.readView(view, ref);
+				}).finally(() => this.pending.delete(key));
+				this.pending.set(key, pending);
+			}
+			return pending;
+		}
 		const id = ref.id;
 		const type = ref.__typename;
 		if (id == null) {
@@ -2112,7 +828,36 @@ var FateClient = class {
 			const pendingPromise = this.pending.get(key) || null;
 			if (pendingPromise) return pendingPromise;
 			const promise = this.trackPendingRequest(async () => {
-				await this.fetchByIdAndNormalize(type, [id], missing, plan);
+				if (this.persistence) {
+					const persistedRequest = {
+						items: [{
+							ids: [id],
+							kind: "node",
+							name: type,
+							plan,
+							refViewNames: /* @__PURE__ */ new Set(),
+							type,
+							viewSignature: ""
+						}],
+						key: `view:${key}`
+					};
+					await this.persistence.restoreRequest(persistedRequest);
+					const remaining = this.store.missingForSelection(entityId, selectedPaths);
+					if (remaining.size) {
+						await this.fetchByIdAndNormalize(type, [id], remaining, plan);
+						this.persistence.fetched({
+							...persistedRequest,
+							items: persistedRequest.items.map((item) => ({
+								...item,
+								plan: {
+									...item.plan,
+									paths: remaining
+								}
+							})),
+							key: `${persistedRequest.key}:${JSON.stringify([...remaining].sort())}`
+						});
+					}
+				} else await this.fetchByIdAndNormalize(type, [id], missing, plan);
 				try {
 					if (this.store.missingForSelection(entityId, selectedPaths).size > 0) {
 						this.stalledRequests.add(key);
@@ -2193,6 +938,7 @@ var FateClient = class {
 		if (!this.transport.subscribeConnection) throw new Error(`fate: transport does not support live list views. Please provide a 'subscribeConnection' implementation in your transport.`);
 	}
 	subscribeLiveView(view, ref) {
+		this.assertPersistenceActive();
 		this.assertLiveViewSupport();
 		const id = ref.id;
 		const type = ref.__typename;
@@ -2220,21 +966,26 @@ var FateClient = class {
 		try {
 			unsubscribe = this.transport.subscribeById(type, id, plan.paths, args, {
 				onData: (record, liveSelect) => {
-					if (!record || typeof record !== "object") return;
-					const pendingMask = this.getPendingOptimisticMask(entityId);
+					if (this.persistenceDisposal?.signal.aborted || !record || typeof record !== "object") return;
 					const select = new Set(liveSelect ?? plan.paths);
-					const selection = this.filterSelectionForPendingOptimistics(entityId, select);
-					this.write(type, record, selection, void 0, plan, null, pendingMask, "none");
+					this.write(type, record, select, plan, "none");
 				},
 				onDelete: (deletedId) => {
+					if (this.persistenceDisposal?.signal.aborted) return;
 					this.deleteRecord(type, deletedId ?? id);
 				},
-				onError: (error) => this.reportLiveError(error)
+				onError: (error) => {
+					if (!this.persistenceDisposal?.signal.aborted) this.reportLiveError(error);
+				}
 			});
 		} catch (error) {
 			this.reportLiveError(error);
 			return emptyDispose;
 		}
+		if (this.persistenceDisposal?.signal.aborted) {
+			unsubscribe();
+			return emptyDispose;
+		}
 		this.liveSubscriptions.set(key, {
 			count: 1,
 			unsubscribe
@@ -2244,6 +995,7 @@ var FateClient = class {
 		};
 	}
 	subscribeLiveListView(view, connection) {
+		this.assertPersistenceActive();
 		this.assertLiveConnectionSupport();
 		const plan = getSelectionPlan(view, null);
 		const connectionArgs = filterConnectionArgs(connection.args);
@@ -2260,8 +1012,11 @@ var FateClient = class {
 		let unsubscribe;
 		try {
 			unsubscribe = this.transport.subscribeConnection(connection.procedure, connection.type, connectionArgs, plan.paths, selectionArgs, {
-				onError: (error) => this.reportLiveError(error),
+				onError: (error) => {
+					if (!this.persistenceDisposal?.signal.aborted) this.reportLiveError(error);
+				},
 				onEvent: (event) => {
+					if (this.persistenceDisposal?.signal.aborted) return;
 					this.applyLiveConnectionEvent(view, connection, plan, event);
 				}
 			});
@@ -2269,6 +1024,10 @@ var FateClient = class {
 			this.reportLiveError(error);
 			return emptyDispose;
 		}
+		if (this.persistenceDisposal?.signal.aborted) {
+			unsubscribe();
+			return emptyDispose;
+		}
 		this.liveSubscriptions.set(key, {
 			count: 1,
 			unsubscribe
@@ -2278,24 +1037,26 @@ var FateClient = class {
 		};
 	}
 	applyLiveConnectionEvent(view, connection, plan, event) {
-		if (event.type === "invalidate") {
-			this.invalidateLiveConnection(view, connection);
-			return;
-		}
-		if (event.type === "deleteEdge") {
-			this.deleteConnectionEdge(connection, toEntityId(event.nodeType, event.id));
-			return;
-		}
-		const node = event.edge.node;
-		if (!node || typeof node !== "object") return;
-		const nodeRecord = node;
-		const nodeType = event.nodeType;
-		if (!nodeType) {
-			this.reportLiveError(/* @__PURE__ */ new Error(`fate: Live connection event for '${connection.procedure}' did not include a node type.`));
-			return;
-		}
-		const entityId = this.write(nodeType, nodeRecord, plan.paths, void 0, plan, null, null, "none");
-		this.insertConnectionEdge(connection.key, entityId, event.edge.cursor, event.type, event.targetCursor, view, connection);
+		return this.store.update(() => {
+			if (event.type === "invalidate") {
+				this.invalidateLiveConnection(view, connection);
+				return;
+			}
+			if (event.type === "deleteEdge") {
+				this.deleteConnectionEdge(connection, toEntityId(event.nodeType, event.id));
+				return;
+			}
+			const node = event.edge.node;
+			if (!node || typeof node !== "object") return;
+			const nodeRecord = node;
+			const nodeType = event.nodeType;
+			if (!nodeType) {
+				this.reportLiveError(/* @__PURE__ */ new Error(`fate: Live connection event for '${connection.procedure}' did not include a node type.`));
+				return;
+			}
+			const entityId = this.write(nodeType, nodeRecord, plan.paths, plan, "none");
+			this.insertConnectionEdge(connection.key, entityId, event.edge.cursor, event.type, event.targetCursor, view, connection);
+		});
 	}
 	invalidateLiveConnection(view, connection) {
 		const token = ++this.liveConnectionInvalidationToken;
@@ -2524,11 +1285,14 @@ var FateClient = class {
 		const cursors = hasIncomingCursor || Boolean(previous?.cursors) || options.hasCursorArg ? ids.map((id) => cursorMap.get(id)) : void 0;
 		const previousPagination = previous?.pagination;
 		const newPagination = incomingPagination;
+		const extendsExistingList = options.hasCursorArg && existingIds.length > 0;
+		const leadingPagination = extendsExistingList && !isBackward ? previousPagination ?? newPagination : newPagination;
+		const trailingPagination = extendsExistingList && isBackward ? previousPagination ?? newPagination : newPagination;
 		const pagination = previousPagination || newPagination ? {
-			hasNext: !!(newPagination?.hasNext ?? previousPagination?.hasNext),
-			hasPrevious: !!(newPagination?.hasPrevious ?? previousPagination?.hasPrevious),
-			nextCursor: newPagination?.nextCursor ?? previousPagination?.nextCursor,
-			previousCursor: newPagination?.previousCursor ?? previousPagination?.previousCursor
+			hasNext: !!(trailingPagination?.hasNext ?? previousPagination?.hasNext),
+			hasPrevious: !!(leadingPagination?.hasPrevious ?? previousPagination?.hasPrevious),
+			nextCursor: trailingPagination?.nextCursor ?? previousPagination?.nextCursor,
+			previousCursor: leadingPagination?.previousCursor ?? previousPagination?.previousCursor
 		} : void 0;
 		return {
 			backwardPageLimit: !options.hasCursorArg && isBackward && options.pageLimit != null ? Math.max(previous?.backwardPageLimit ?? 0, options.pageLimit) : previous?.backwardPageLimit,
@@ -2562,60 +1326,10 @@ var FateClient = class {
 		this.optimisticEntityResolutions.set(optimisticEntityId, resolvedEntityId);
 		this.store.replaceListEntityId(optimisticEntityId, resolvedEntityId);
 	}
-	registerOptimisticUpdate(entityId, select) {
-		if (!entityId || select.size === 0) return null;
-		const mask = fromPaths(select);
-		const token = ++this.optimisticTokenCounter;
-		this.optimisticMasks.set(token, {
-			entityId,
-			mask
-		});
-		let entries = this.optimisticByEntity.get(entityId);
-		if (!entries) {
-			entries = /* @__PURE__ */ new Set();
-			this.optimisticByEntity.set(entityId, entries);
-		}
-		entries.add(token);
-		return token;
-	}
-	clearOptimisticUpdate(token) {
-		if (token == null) return;
-		const entry = this.optimisticMasks.get(token);
-		if (!entry) return;
-		this.optimisticMasks.delete(token);
-		const entityTokens = this.optimisticByEntity.get(entry.entityId);
-		if (entityTokens) {
-			entityTokens.delete(token);
-			if (entityTokens.size === 0) this.optimisticByEntity.delete(entry.entityId);
-		}
-		this.runPendingGarbageCollection();
-	}
-	getPendingOptimisticMask(entityId, options = {}) {
-		if (!entityId) return null;
-		const tokens = this.optimisticByEntity.get(entityId);
-		if (!tokens || tokens.size === 0) return null;
-		let mask = null;
-		for (const token of tokens) {
-			if (options.excludeToken != null && token === options.excludeToken) continue;
-			const entry = this.optimisticMasks.get(token);
-			if (!entry) continue;
-			if (!mask) mask = cloneMask(entry.mask);
-			else union(mask, entry.mask);
-		}
-		return mask;
-	}
 	getPendingOptimisticMutations(entityId) {
 		const pending = this.pendingOptimisticMutations.get(entityId);
 		return pending && pending.size > 0 ? [...pending] : null;
 	}
-	filterSelectionForPendingOptimistics(entityId, select, options = {}) {
-		if (!entityId || select.size === 0) return select;
-		const pendingMask = this.getPendingOptimisticMask(entityId, options);
-		if (!pendingMask) return select;
-		const filtered = /* @__PURE__ */ new Set();
-		for (const path of select) if (!isCovered(pendingMask, path)) filtered.add(path);
-		return filtered;
-	}
 	async loadConnection(view, connection, args, options = {}) {
 		return await this.trackPendingRequest(() => this.loadConnectionInternal(view, connection, args, options));
 	}
@@ -2629,22 +1343,25 @@ var FateClient = class {
 			});
 			const { argsPayload, plan } = resolveSelectionPlan(view, requestArgs);
 			const { items, pagination } = await this.transport.fetchList(connection.field, plan.paths, argsPayload);
+			this.assertPersistenceActive();
 			if (!items) return this.store.getListState(connection.key);
-			const incomingIds = [];
-			const incomingCursors = [];
-			for (const entry of items) {
-				const id = this.write(connection.type, entry.node, plan.paths, void 0, plan, null, null, "none");
-				incomingIds.push(id);
-				incomingCursors.push(entry.cursor);
-			}
-			const previous = this.store.getListState(connection.key);
-			const nextListState = this.mergeListState(previous, incomingIds, incomingCursors, pagination, {
-				...getPaginationMergeInfo(requestArgs),
-				replace: true
+			this.store.update(() => {
+				const incomingIds = [];
+				const incomingCursors = [];
+				for (const entry of items) {
+					const id = this.write(connection.type, entry.node, plan.paths, plan, "none");
+					incomingIds.push(id);
+					incomingCursors.push(entry.cursor);
+				}
+				const previous = this.store.getListState(connection.key);
+				const nextListState = this.mergeListState(previous, incomingIds, incomingCursors, pagination, {
+					...getPaginationMergeInfo(requestArgs),
+					replace: true
+				});
+				if (!filterConnectionArgs(connection.args)) this.registerRootList(connection.type, connection.key);
+				this.store.setList(connection.key, nextListState);
 			});
-			if (!filterConnectionArgs(connection.args)) this.registerRootList(connection.type, connection.key);
-			this.store.setList(connection.key, nextListState);
-			return nextListState;
+			return this.store.getListState(connection.key);
 		}
 		const owner = parseEntityId(connection.owner);
 		const requestArgs = omitUndefinedValues({
@@ -2658,6 +1375,7 @@ var FateClient = class {
 		const parentSelection = /* @__PURE__ */ new Set();
 		for (const path of nodeSelection) parentSelection.add(`${connection.field}.${path}`);
 		const [parentRecord] = await this.transport.fetchById(owner.type, [owner.id], parentSelection, scopedArgsPayload);
+		this.assertPersistenceActive();
 		if (!parentRecord || typeof parentRecord !== "object") return this.store.getListState(connection.key);
 		const list = parentRecord[connection.field];
 		const connectionPayload = Array.isArray(list) ? {
@@ -2668,37 +1386,39 @@ var FateClient = class {
 			pagination: void 0
 		} : list;
 		if (!connectionPayload) return this.store.getListState(connection.key);
-		const incomingIds = [];
-		const incomingCursors = [];
-		const nodeType = this.getListNodeType(owner.type, connection.field);
-		for (const entry of connectionPayload.items) {
-			const { node } = entry;
-			const id = this.write(nodeType, node, nodeSelection, void 0, plan);
-			incomingIds.push(id);
-			incomingCursors.push(entry.cursor);
-		}
-		const previous = this.store.getListState(connection.key);
-		const previousIds = previous?.ids ?? [];
-		const previousSet = new Set(previousIds);
-		const newIds = incomingIds.filter((id) => !previousSet.has(id));
-		const nextListState = this.mergeListState(previous, incomingIds, incomingCursors, connectionPayload.pagination, {
-			...getPaginationMergeInfo(argsPayload),
-			direction,
-			hasCursorArg: true,
-			replace: true
+		this.store.update(() => {
+			const incomingIds = [];
+			const incomingCursors = [];
+			const nodeType = this.getListNodeType(owner.type, connection.field);
+			for (const entry of connectionPayload.items) {
+				const { node } = entry;
+				const id = this.write(nodeType, node, nodeSelection, plan);
+				incomingIds.push(id);
+				incomingCursors.push(entry.cursor);
+			}
+			const previous = this.store.getListState(connection.key);
+			const previousIds = previous?.ids ?? [];
+			const previousSet = new Set(previousIds);
+			const newIds = incomingIds.filter((id) => !previousSet.has(id));
+			const nextListState = this.mergeListState(previous, incomingIds, incomingCursors, connectionPayload.pagination, {
+				...getPaginationMergeInfo(argsPayload),
+				direction,
+				hasCursorArg: true,
+				replace: true
+			});
+			this.store.setList(connection.key, nextListState);
+			const current = this.store.read(connection.owner);
+			const existingField = Array.isArray(current?.[connection.field]) ? current?.[connection.field] || [] : [];
+			const nodeRefs = createNodeRefsForIds(newIds, void 0);
+			const nextField = direction === "forward" ? [...existingField, ...nodeRefs] : [...nodeRefs, ...existingField];
+			this.viewDataCache.invalidate(connection.owner);
+			this.store.merge(connection.owner, { [connection.field]: nextField }, [connection.field]);
 		});
-		this.store.setList(connection.key, nextListState);
-		const current = this.store.read(connection.owner);
-		const existingField = Array.isArray(current?.[connection.field]) ? current?.[connection.field] || [] : [];
-		const nodeRefs = createNodeRefsForIds(newIds, void 0);
-		const nextField = direction === "forward" ? [...existingField, ...nodeRefs] : [...nodeRefs, ...existingField];
-		this.viewDataCache.invalidate(connection.owner);
-		this.store.merge(connection.owner, { [connection.field]: nextField }, [connection.field]);
 		return this.store.getListState(connection.key);
 	}
 	request(request, options) {
 		const mode = options?.mode ?? "cache-first";
-		return this.requestWithDescriptor(this.createRequestDescriptor(request), mode, { revalidateExisting: true });
+		return this.requestWithDescriptor(this.createRequestDescriptor(request), mode, { revalidateExisting: true }, options);
 	}
 	requestForRender(request, options) {
 		return this.prepareRequestForRender(request, options).promise;
@@ -2707,16 +1427,23 @@ var FateClient = class {
 		const mode = options?.mode ?? "cache-first";
 		const descriptor = this.createRequestDescriptor(request);
 		return {
-			promise: this.requestWithDescriptor(descriptor, mode, { revalidateExisting: false }),
+			promise: this.requestWithDescriptor(descriptor, mode, { revalidateExisting: false }, options),
 			requestKey: descriptor.key
 		};
 	}
-	requestWithDescriptor(descriptor, mode, { revalidateExisting }) {
+	requestWithDescriptor(descriptor, mode, { revalidateExisting }, options) {
+		this.assertPersistenceActive();
+		if (this.persistence && options?.persist && (!Number.isSafeInteger(options.persist.maxAge) || options.persist.maxAge < 0 || options.persist.maxAge > Number.MAX_SAFE_INTEGER - Date.now())) throw new Error("fate: Persistence maxAge must be a non-negative finite duration.");
 		const requestKey = descriptor.key;
 		const existingRequest = this.requests.get(requestKey)?.get(mode);
 		if (existingRequest) {
+			if (this.persistence && options?.persist) {
+				const executionOptions = this.requestExecutionOptions.get(existingRequest.descriptor);
+				if (executionOptions) executionOptions.persist = { ...options.persist };
+			}
+			if (this.persistence && options?.persist && existingRequest.status === "fulfilled") this.persistence.used(existingRequest.descriptor, options.persist);
 			const isFulfilledCacheFirstWithMissingData = mode === "cache-first" && existingRequest.status === "fulfilled" && !this.hasRequestData(existingRequest.descriptor);
-			if (existingRequest.status !== "pending" && (isFulfilledCacheFirstWithMissingData || revalidateExisting && (mode === "network-only" || mode === "stale-while-revalidate" || mode === "cache-first" && existingRequest.status === "rejected"))) this.executeRequestHandle(existingRequest, mode);
+			if (existingRequest.status !== "pending" && (isFulfilledCacheFirstWithMissingData || revalidateExisting && (mode === "network-only" || mode === "stale-while-revalidate" || mode === "cache-first" && existingRequest.status === "rejected"))) this.executeRequestHandle(existingRequest, mode, options);
 			return existingRequest;
 		}
 		const handle = new FateRequestPromise(descriptor, () => this.getRequestResultFromDescriptor(descriptor));
@@ -2726,7 +1453,7 @@ var FateClient = class {
 			this.requests.set(requestKey, requests);
 		}
 		requests.set(mode, handle);
-		this.executeRequestHandle(handle, mode);
+		this.executeRequestHandle(handle, mode, options);
 		return handle;
 	}
 	releaseRequest(request, mode) {
@@ -2771,7 +1498,7 @@ var FateClient = class {
 	* memory-management flows.
 	*/
 	gc() {
-		if (this.hasActiveOptimisticUpdates()) {
+		if (this.persistence ? this.store.hasTransientOptimisticUpdates : this.hasActiveOptimisticUpdates()) {
 			this.gcPending = true;
 			return;
 		}
@@ -2792,6 +1519,10 @@ var FateClient = class {
 			for (const id of listState.ids) markRecord(id);
 			for (const id of listState.pendingAfterIds ?? []) markRecord(id);
 		};
+		const optimisticRoots = this.store.getOptimisticRoots();
+		optimisticRoots.baseRecords.forEach((record) => this.markRecordReferences(record, markRecord));
+		optimisticRoots.records.forEach(markRecord);
+		optimisticRoots.lists.forEach(markList);
 		for (const descriptor of this.operationLifetime.getDescriptors()) for (const item of descriptor.items) {
 			if (item.kind === "node" || item.kind === "nodes") {
 				for (const raw of item.ids) markRecord(toEntityId(item.type, raw));
@@ -2830,17 +1561,18 @@ var FateClient = class {
 			if (keys.size === 0) this.rootLists.delete(type);
 		}
 	}
-	executeRequestHandle(handle, mode) {
-		let execution;
-		switch (mode) {
-			case "stale-while-revalidate":
-				execution = this.handleStoreAndNetworkRequest(handle.descriptor);
-				break;
-			default:
-				execution = this.executeRequest(handle.descriptor, mode === "network-only" ? { fetchAll: true } : void 0).then(() => this.getRequestResultFromDescriptor(handle.descriptor));
-				break;
-		}
-		handle.start(execution);
+	executeRequestHandle(handle, mode, options) {
+		const executionOptions = {
+			fetchAll: mode !== "cache-first",
+			persist: options?.persist ? { ...options.persist } : void 0
+		};
+		if (this.persistence) this.requestExecutionOptions.set(handle.descriptor, executionOptions);
+		const execute = () => {
+			this.assertPersistenceActive();
+			if (mode === "stale-while-revalidate") return this.handleStoreAndNetworkRequest(handle.descriptor, executionOptions);
+			return this.executeRequest(handle.descriptor, executionOptions).then(() => this.getRequestResultFromDescriptor(handle.descriptor));
+		};
+		handle.start(this.persistence ? this.withPersistenceLifecycle(() => this.persistence.ready.then(() => mode === "network-only" ? void 0 : this.persistence.restoreRequest(handle.descriptor)).then(execute)) : execute());
 	}
 	markRecordReferences(record, markRecord) {
 		const seen = /* @__PURE__ */ new Set();
@@ -2861,29 +1593,52 @@ var FateClient = class {
 		walk(record);
 	}
 	hasActiveOptimisticUpdates() {
-		return this.optimisticMasks.size > 0 || this.optimisticByEntity.size > 0 || this.pendingOptimisticMutations.size > 0;
+		return this.store.hasOptimisticUpdates || this.pendingOptimisticMutations.size > 0;
 	}
 	hasPendingRequests() {
 		return this.pendingNetworkRequests > 0;
 	}
-	async trackPendingRequest(request) {
-		this.pendingNetworkRequests += 1;
+	/** @internal */
+	async withPersistenceLifecycle(request) {
+		this.assertPersistenceActive();
+		const signal = this.persistenceDisposal?.signal;
+		let onDispose;
 		try {
-			return await request();
+			const execution = request();
+			const result = signal ? await Promise.race([execution, new Promise((_, reject) => {
+				onDispose = () => reject(/* @__PURE__ */ new Error("fate: Persistence was disposed."));
+				signal.addEventListener("abort", onDispose, { once: true });
+				if (signal.aborted) onDispose();
+			})]) : await execution;
+			this.assertPersistenceActive();
+			return result;
 		} finally {
-			this.pendingNetworkRequests -= 1;
+			if (onDispose) signal?.removeEventListener("abort", onDispose);
 		}
 	}
+	async trackPendingRequest(request) {
+		return this.withPersistenceLifecycle(async () => {
+			if (this.persistence) await this.persistence.ready;
+			this.assertPersistenceActive();
+			this.pendingNetworkRequests += 1;
+			try {
+				return await this.withPersistenceLifecycle(request);
+			} finally {
+				this.pendingNetworkRequests -= 1;
+				this.persistence?.changed();
+			}
+		});
+	}
 	runPendingGarbageCollection() {
 		if (this.gcPending && !this.hasActiveOptimisticUpdates()) this.gc();
 	}
-	async handleStoreAndNetworkRequest(request) {
+	async handleStoreAndNetworkRequest(request, options) {
 		if (!this.hasRequestData(request)) {
-			await this.executeRequest(request, { fetchAll: true });
+			await this.executeRequest(request, options);
 			return this.getRequestResultFromDescriptor(request);
 		}
 		const result = this.getRequestResultFromDescriptor(request);
-		this.executeRequest(request, { fetchAll: true }).catch(() => {});
+		this.executeRequest(request, options).catch(() => {});
 		return result;
 	}
 	getRootType(name) {
@@ -2909,6 +1664,8 @@ var FateClient = class {
 		const fetchAll = options.fetchAll ?? false;
 		const groups = /* @__PURE__ */ new Map();
 		const promises = [];
+		const fetchedItems = [];
+		let fetchedAll = true;
 		for (const item of request.items) if (item.kind === "node" || item.kind === "nodes") {
 			const fields = item.plan.paths;
 			const fieldsSignature = [...fields].slice().sort().join(",");
@@ -2924,23 +1681,46 @@ var FateClient = class {
 				};
 				groups.set(groupKey, group);
 			}
+			const fetchedIds = [];
 			for (const raw of item.ids) {
 				const entityId = toEntityId(item.type, raw);
 				const missing = this.store.missingForSelection(entityId, fields);
-				if (fetchAll || missing.size > 0) group.ids.push(raw);
+				if (fetchAll || missing.size > 0) {
+					group.ids.push(raw);
+					fetchedIds.push(raw);
+				}
 			}
+			if (fetchedIds.length) fetchedItems.push({
+				...item,
+				ids: fetchedIds
+			});
+			fetchedAll &&= fetchedIds.length === item.ids.length;
 		} else {
 			if (item.kind === "query") {
 				const hasResult = this.rootRequests.has(item.queryKey);
 				const entityId = this.rootRequests.get(item.queryKey);
 				const missing = hasResult && entityId ? this.store.missingForSelection(entityId, item.plan.paths) : item.plan.paths;
-				if (fetchAll || !hasResult || entityId && missing.size > 0) promises.push(this.fetchQueryAndNormalize(item));
+				if (fetchAll || !hasResult || entityId && missing.size > 0) {
+					promises.push(this.fetchQueryAndNormalize(item));
+					fetchedItems.push(item);
+				} else fetchedAll = false;
 			}
 			if (item.kind !== "list") continue;
-			if (!fetchAll && !getPaginationArgsInfo(item.argsPayload).hasCursorArg && this.hasRootListData(item)) continue;
+			if (!fetchAll && !getPaginationArgsInfo(item.argsPayload).hasCursorArg && this.hasRootListData(item)) {
+				fetchedAll = false;
+				continue;
+			}
 			promises.push(this.fetchListAndNormalize(item));
+			fetchedItems.push(item);
 		}
 		await Promise.all([...promises, ...Array.from(groups.values()).map((group) => group.ids.length ? this.fetchByIdAndNormalize(group.type, group.ids, group.fields, group.plan) : Promise.resolve())]);
+		if (this.persistence) {
+			if (fetchedItems.length) this.persistence.fetched(fetchedAll ? request : {
+				items: fetchedItems,
+				key: `partial:${JSON.stringify([request.key, fetchedItems.map((item) => [item.name, "ids" in item ? item.ids : null])])}`
+			}, options.persist);
+			if (!fetchedItems.length || !fetchedAll) this.persistence.used(request, options.persist);
+		}
 	}
 	hasRequestData(request) {
 		for (const item of request.items) {
@@ -3028,18 +1808,20 @@ var FateClient = class {
 		const resolvedArgs = resolvedArgsFromPlan(plan);
 		await this.trackPendingRequest(async () => {
 			const records = await this.transport.fetchById(type, ids, select, resolvedArgs);
-			for (const record of records) this.writeEntity(type, record, select, void 0, plan, prefix);
+			this.assertPersistenceActive();
+			for (const record of records) this.writeEntity(type, record, select, plan, prefix);
 		});
 	}
 	async fetchQueryAndNormalize(item) {
 		if (!this.transport.fetchQuery) throw new Error(`fate: transport does not support queries. Please add support for 'fetchQuery' in your transport for '${item.name}'.`);
 		await this.trackPendingRequest(async () => {
 			const record = await this.transport.fetchQuery(item.name, item.plan.paths, item.argsPayload);
+			this.assertPersistenceActive();
 			if (!record || typeof record !== "object") {
 				this.rootRequests.set(item.queryKey, null);
 				return;
 			}
-			const entityId = this.writeEntity(item.type, record, item.plan.paths, void 0, item.plan);
+			const entityId = this.writeEntity(item.type, record, item.plan.paths, item.plan);
 			this.rootRequests.set(item.queryKey, entityId);
 		});
 	}
@@ -3047,133 +1829,132 @@ var FateClient = class {
 		if (!this.transport.fetchList) throw new Error(`fate: 'transport.fetchList' is not configured but request includes a list for key '${item.name}'.`);
 		await this.trackPendingRequest(async () => {
 			const { items, pagination } = await this.transport.fetchList(item.name, item.plan.paths, item.argsPayload);
-			const ids = [];
-			const cursors = [];
-			for (const entry of items) {
-				const id = this.writeEntity(item.type, entry.node, item.plan.paths, void 0, item.plan);
-				ids.push(id);
-				cursors.push(entry.cursor);
-			}
-			if (!filterConnectionArgs(item.argsPayload)) this.registerRootList(item.type, item.listKey);
-			const previous = this.store.getListState(item.listKey);
-			this.store.setList(item.listKey, this.mergeListState(previous, ids, cursors, pagination, {
-				...getPaginationMergeInfo(item.argsPayload),
-				replace: true
-			}));
+			this.assertPersistenceActive();
+			this.store.update(() => {
+				const ids = [];
+				const cursors = [];
+				for (const entry of items) {
+					const id = this.writeEntity(item.type, entry.node, item.plan.paths, item.plan);
+					ids.push(id);
+					cursors.push(entry.cursor);
+				}
+				if (!filterConnectionArgs(item.argsPayload)) this.registerRootList(item.type, item.listKey);
+				const previous = this.store.getListState(item.listKey);
+				this.store.setList(item.listKey, this.mergeListState(previous, ids, cursors, pagination, {
+					...getPaginationMergeInfo(item.argsPayload),
+					replace: true
+				}));
+			});
 		});
 	}
-	writeEntity(type, record, select, snapshots, plan, pathPrefix = null, blockedMask, insert, listSnapshots) {
-		const config = this.types.get(type);
-		if (!config) throw new Error(`fate: Found unknown entity type '${type}' in normalization.`);
-		const entityId = toEntityId(type, config.getId(record));
-		const result = {};
-		const selectionTree = groupSelectionByPrefix(select);
-		if (config.fields) for (const [key, relationDescriptor] of Object.entries(config.fields)) {
-			const value = record[key];
-			const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
-			const fieldArgs = plan?.args.get(fieldPath);
-			const isFieldBlocked = blockedMask ? isCovered(blockedMask, fieldPath) : false;
-			if (relationDescriptor === "scalar") {
-				if (isFieldBlocked || !Object.prototype.hasOwnProperty.call(record, key)) continue;
-				result[key] = value;
-			} else if (relationDescriptor && typeof relationDescriptor === "object" && "type" in relationDescriptor) {
-				if (isFieldBlocked) continue;
-				const childPaths = selectionTree.get(key) ?? emptySet;
-				if (value === null) {
-					result[key] = null;
-					continue;
-				}
-				if (value && typeof value === "object" && !isNodeRef(value)) {
-					const childType = relationDescriptor.type;
+	writeEntity(type, record, select, plan, pathPrefix = null, insert) {
+		return this.store.update(() => {
+			const config = this.types.get(type);
+			if (!config) throw new Error(`fate: Found unknown entity type '${type}' in normalization.`);
+			const id = config.getId(record);
+			const entityId = toEntityId(type, id);
+			const result = {};
+			const selectionTree = groupSelectionByPrefix(select);
+			if (config.fields) for (const [key, relationDescriptor] of Object.entries(config.fields)) {
+				const value = record[key];
+				const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+				const fieldArgs = plan?.args.get(fieldPath);
+				if (relationDescriptor === "scalar") {
+					if (!Object.hasOwn(record, key)) continue;
+					result[key] = value;
+				} else if (relationDescriptor && typeof relationDescriptor === "object" && "type" in relationDescriptor) {
+					const childPaths = selectionTree.get(key) ?? emptySet;
+					if (value === null) {
+						result[key] = null;
+						continue;
+					}
+					if (value && typeof value === "object" && !isNodeRef(value)) {
+						const childType = relationDescriptor.type;
+						const childConfig = this.types.get(childType);
+						if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${type}.${key}').`);
+						const childId = toEntityId(childType, childConfig.getId(value));
+						result[key] = createNodeRef(childId);
+						this.writeEntity(childType, value, childPaths, plan, fieldPath);
+					}
+				} else if (relationDescriptor && typeof relationDescriptor === "object" && "listOf" in relationDescriptor) {
+					const childPaths = selectionTree.get(key) ?? emptySet;
+					if (value === null) {
+						result[key] = null;
+						continue;
+					}
+					const childType = relationDescriptor.listOf;
 					const childConfig = this.types.get(childType);
 					if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${type}.${key}').`);
-					result[key] = createNodeRef(toEntityId(childType, childConfig.getId(value)));
-					this.writeEntity(childType, value, childPaths, snapshots, plan, fieldPath, blockedMask, void 0, listSnapshots);
-				}
-			} else if (relationDescriptor && typeof relationDescriptor === "object" && "listOf" in relationDescriptor) {
-				if (isFieldBlocked) continue;
-				const childPaths = selectionTree.get(key) ?? emptySet;
-				if (value === null) {
-					result[key] = null;
-					continue;
-				}
-				const childType = relationDescriptor.listOf;
-				const childConfig = this.types.get(childType);
-				if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${type}.${key}').`);
-				const connection = (() => {
-					if (Array.isArray(value)) return { items: value.map((item) => ({ node: item })) };
-					if (value && typeof value === "object") {
-						const record = value;
-						if (Array.isArray(record.items)) return {
-							items: record.items.map((node) => {
-								if (node && typeof node === "object" && "node" in node) {
-									const itemRecord = node;
-									return {
-										cursor: itemRecord.cursor,
-										node: itemRecord.node
-									};
-								}
-								return { node };
-							}),
-							pagination: record.pagination
-						};
-					}
-					return null;
-				})();
-				if (connection) {
-					const ids = [];
-					const cursors = [];
-					const nodeSelection = childPaths.size > 0 ? /* @__PURE__ */ new Set() : childPaths;
-					if (childPaths.size > 0) for (const path of childPaths) {
-						if (path.startsWith("items.node.")) {
-							nodeSelection.add(path.slice(11));
-							continue;
-						}
-						if (path.startsWith("node.")) {
-							nodeSelection.add(path.slice(5));
-							continue;
+					const connection = (() => {
+						if (Array.isArray(value)) return { items: value.map((item) => ({ node: item })) };
+						if (value && typeof value === "object") {
+							const record = value;
+							if (Array.isArray(record.items)) return {
+								items: record.items.map((node) => {
+									if (node && typeof node === "object" && "node" in node) {
+										const itemRecord = node;
+										return {
+											cursor: itemRecord.cursor,
+											node: itemRecord.node
+										};
+									}
+									return { node };
+								}),
+								pagination: record.pagination
+							};
 						}
-						if (path === "items.node" || path.startsWith("items.")) continue;
-						nodeSelection.add(path);
-					}
-					for (const entry of connection.items) {
-						const node = entry.node;
-						const cursor = "cursor" in entry ? entry.cursor : void 0;
-						cursors.push(cursor);
-						if (isNodeRef(node)) {
-							ids.push(getNodeRefId(node));
-							continue;
+						return null;
+					})();
+					if (connection) {
+						const ids = [];
+						const cursors = [];
+						const nodeSelection = childPaths.size > 0 ? /* @__PURE__ */ new Set() : childPaths;
+						if (childPaths.size > 0) for (const path of childPaths) {
+							if (path.startsWith("items.node.")) {
+								nodeSelection.add(path.slice(11));
+								continue;
+							}
+							if (path.startsWith("node.")) {
+								nodeSelection.add(path.slice(5));
+								continue;
+							}
+							if (path === "items.node" || path.startsWith("items.")) continue;
+							nodeSelection.add(path);
 						}
-						if (node && typeof node === "object") {
-							const childId = toEntityId(childType, childConfig.getId(node));
-							this.writeEntity(childType, node, nodeSelection, snapshots, plan, fieldPath, blockedMask, void 0, listSnapshots);
-							ids.push(childId);
-							continue;
+						for (const entry of connection.items) {
+							const node = entry.node;
+							const cursor = "cursor" in entry ? entry.cursor : void 0;
+							cursors.push(cursor);
+							if (isNodeRef(node)) {
+								ids.push(getNodeRefId(node));
+								continue;
+							}
+							if (node && typeof node === "object") {
+								const childId = toEntityId(childType, childConfig.getId(node));
+								this.writeEntity(childType, node, nodeSelection, plan, fieldPath);
+								ids.push(childId);
+								continue;
+							}
 						}
+						const listKey = getListKey(entityId, key, fieldArgs?.hash);
+						const previousList = this.store.getListState(listKey);
+						const argsValue = fieldArgs?.value;
+						const nextListState = this.mergeListState(previousList, ids, cursors, connection.pagination, getPaginationMergeInfo(argsValue));
+						const listChanged = !areListStatesEqual(previousList, nextListState);
+						result[key] = createNodeRefsForIds(nextListState.ids, this.store.read(entityId)?.[key], { reuseCurrentArray: !listChanged });
+						this.store.setList(listKey, nextListState);
 					}
-					const listKey = getListKey(entityId, key, fieldArgs?.hash);
-					const previousList = this.store.getListState(listKey);
-					const argsValue = fieldArgs?.value;
-					const nextListState = this.mergeListState(previousList, ids, cursors, connection.pagination, getPaginationMergeInfo(argsValue));
-					const listChanged = !areListStatesEqual(previousList, nextListState);
-					result[key] = createNodeRefsForIds(nextListState.ids, this.store.read(entityId)?.[key], { reuseCurrentArray: !listChanged });
-					this.store.setList(listKey, nextListState);
-				}
-			} else result[key] = value;
-		}
-		for (const [key, value] of Object.entries(record)) if (!(key in (config.fields ?? {}))) {
-			const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
-			if (blockedMask && isCovered(blockedMask, fieldPath)) continue;
-			result[key] = value;
-		}
-		if (snapshots && !snapshots.has(entityId)) snapshots.set(entityId, this.store.snapshot(entityId));
-		this.viewDataCache.invalidate(entityId);
-		this.store.merge(entityId, result, select);
-		this.linkParentLists(type, entityId, result, snapshots, listSnapshots, insert ?? "after");
-		if (!pathPrefix && insert) this.insertIntoRootLists(type, entityId, insert, listSnapshots);
-		return entityId;
+				} else result[key] = value;
+			}
+			for (const [key, value] of Object.entries(record)) if (!(key in (config.fields ?? {}))) result[key] = value;
+			this.viewDataCache.invalidate(entityId);
+			this.store.merge(entityId, result, select);
+			this.linkParentLists(type, entityId, result, insert ?? "after");
+			if (!pathPrefix && insert) this.insertIntoRootLists(type, entityId, insert);
+			return entityId;
+		});
 	}
-	linkParentLists(type, entityId, record, snapshots, listSnapshots, insert) {
+	linkParentLists(type, entityId, record, insert) {
 		if (insert === "none") return;
 		const parents = this.parentLists.get(type);
 		if (!parents) return;
@@ -3186,23 +1967,18 @@ var FateClient = class {
 			if (!existing) continue;
 			const current = Array.isArray(existing[parent.field]) ? existing[parent.field] : [];
 			if (current.some((item) => isNodeRef(item) && getNodeRefId(item) === entityId)) continue;
-			if (snapshots && !snapshots.has(parentId)) snapshots.set(parentId, this.store.snapshot(parentId));
 			this.viewDataCache.invalidate(parentId);
 			const defaultListKey = getListKey(parentId, parent.field);
 			const defaultListState = this.store.getListState(defaultListKey);
 			let nextField = current;
 			if (defaultListState) {
 				const { list: nextDefaultListState, pending } = this.applyListInsert(defaultListState, entityId, insert);
-				if (nextDefaultListState !== defaultListState) {
-					this.snapshotList(defaultListKey, listSnapshots);
-					this.store.setList(defaultListKey, nextDefaultListState);
-				}
+				if (nextDefaultListState !== defaultListState) this.store.setList(defaultListKey, nextDefaultListState);
 				const nextFieldIds = pending ? getListEntries(nextDefaultListState).map(({ id }) => id) : nextDefaultListState.ids;
 				nextField = createNodeRefsForIds(nextFieldIds, current);
 			} else {
 				const currentIds = current.map((item) => isNodeRef(item) ? getNodeRefId(item) : null).filter((id) => id != null);
 				const nextDefaultListState = { ids: insert === "before" ? [entityId, ...currentIds] : [...currentIds, entityId] };
-				this.snapshotList(defaultListKey, listSnapshots);
 				this.store.setList(defaultListKey, nextDefaultListState);
 				nextField = createNodeRefsForIds(nextDefaultListState.ids, current);
 			}
@@ -3210,7 +1986,6 @@ var FateClient = class {
 			for (const [listKey, listState] of registeredLists) {
 				const nextListState = this.applyListInsert(listState, entityId, insert).list;
 				if (nextListState === listState) continue;
-				this.snapshotList(listKey, listSnapshots);
 				this.store.setList(listKey, nextListState);
 			}
 			this.store.merge(parentId, { [parent.field]: nextField }, [parent.field]);
@@ -3258,92 +2033,93 @@ var FateClient = class {
 						target[key] = null;
 						continue;
 					}
-					if (Array.isArray(value)) if (nextSelection.items && typeof nextSelection.items === "object") {
-						const selection = nextSelection.items;
-						const fieldArgs = plan.args.get(fieldPath);
-						const listKey = getListKey(parentId, key, fieldArgs?.hash);
-						const listState = this.store.getListState(listKey);
-						const connection = { items: (listState ? getListEntries(listState) : value.map((item) => ({
-							cursor: void 0,
-							id: isNodeRef(item) ? getNodeRefId(item) : null
-						}))).map((entry, index) => {
-							const entityId = entry.id;
-							if (!entityId) return {
-								cursor: listState?.cursors?.[index],
-								node: null
-							};
+					if (Array.isArray(value)) {
+						if (nextSelection.items && typeof nextSelection.items === "object") {
+							const selection = nextSelection.items;
+							const fieldArgs = plan.args.get(fieldPath);
+							const listKey = getListKey(parentId, key, fieldArgs?.hash);
+							const listState = this.store.getListState(listKey);
+							const connection = { items: (listState ? getListEntries(listState) : value.map((item) => ({
+								cursor: void 0,
+								id: isNodeRef(item) ? getNodeRefId(item) : null
+							}))).map((entry, index) => {
+								const entityId = entry.id;
+								if (!entityId) return {
+									cursor: listState?.cursors?.[index],
+									node: null
+								};
+								ids.add(entityId);
+								const record = this.store.read(entityId);
+								const { id, type } = parseEntityId(entityId);
+								const node = {
+									__typename: type,
+									id
+								};
+								if (record) walk(selection.node, record, node, entityId, fieldPath);
+								const itemResult = { node: record ? node : null };
+								if (selection.cursor === true) itemResult.cursor = entry.cursor;
+								return itemResult;
+							}) };
+							if ("pagination" in nextSelection && nextSelection.pagination) {
+								const paginationSelection = nextSelection.pagination;
+								const storedPagination = listState?.pagination;
+								if (storedPagination) {
+									const pagination = {};
+									if (paginationSelection.nextCursor === true) {
+										if (storedPagination.nextCursor !== void 0) pagination.nextCursor = storedPagination.nextCursor;
+									}
+									if (paginationSelection.previousCursor === true) {
+										if (storedPagination.previousCursor !== void 0) pagination.previousCursor = storedPagination.previousCursor;
+									}
+									if (paginationSelection.hasNext === true) pagination.hasNext = storedPagination.hasNext;
+									if (paginationSelection.hasPrevious === true) pagination.hasPrevious = storedPagination.hasPrevious;
+									if (Object.keys(pagination).length > 0) connection.pagination = pagination;
+								} else connection.pagination = void 0;
+							}
+							const { id: ownerRawId, type: parentType } = parseEntityId(parentId);
+							if (parentType) {
+								const childType = this.getListNodeType(parentType, key);
+								const metadata = {
+									args: (() => {
+										if (!fieldArgs?.value && ownerRawId === void 0) return;
+										const value = fieldArgs?.value ? { ...fieldArgs.value } : {};
+										if (ownerRawId !== void 0) value.id = ownerRawId;
+										return value;
+									})(),
+									field: key,
+									hash: fieldArgs?.hash,
+									key: listKey,
+									live: plan.live.get(fieldPath),
+									owner: parentId,
+									procedure: `${parentType}.${key}`,
+									root: false,
+									type: childType
+								};
+								Object.defineProperty(connection, ConnectionTag, {
+									configurable: false,
+									enumerable: false,
+									value: metadata,
+									writable: false
+								});
+							}
+							target[key] = connection;
+						} else target[key] = value.map((item) => {
+							const entityId = isNodeRef(item) ? getNodeRefId(item) : null;
+							if (!entityId) return item;
 							ids.add(entityId);
 							const record = this.store.read(entityId);
 							const { id, type } = parseEntityId(entityId);
-							const node = {
-								__typename: type,
-								id
-							};
-							if (record) walk(selection.node, record, node, entityId, fieldPath);
-							const itemResult = { node: record ? node : null };
-							if (selection.cursor === true) itemResult.cursor = entry.cursor;
-							return itemResult;
-						}) };
-						if ("pagination" in nextSelection && nextSelection.pagination) {
-							const paginationSelection = nextSelection.pagination;
-							const storedPagination = listState?.pagination;
-							if (storedPagination) {
-								const pagination = {};
-								if (paginationSelection.nextCursor === true) {
-									if (storedPagination.nextCursor !== void 0) pagination.nextCursor = storedPagination.nextCursor;
-								}
-								if (paginationSelection.previousCursor === true) {
-									if (storedPagination.previousCursor !== void 0) pagination.previousCursor = storedPagination.previousCursor;
-								}
-								if (paginationSelection.hasNext === true) pagination.hasNext = storedPagination.hasNext;
-								if (paginationSelection.hasPrevious === true) pagination.hasPrevious = storedPagination.hasPrevious;
-								if (Object.keys(pagination).length > 0) connection.pagination = pagination;
-							} else connection.pagination = void 0;
-						}
-						const { id: ownerRawId, type: parentType } = parseEntityId(parentId);
-						if (parentType) {
-							const childType = this.getListNodeType(parentType, key);
-							const metadata = {
-								args: (() => {
-									if (!fieldArgs?.value && ownerRawId === void 0) return;
-									const value = fieldArgs?.value ? { ...fieldArgs.value } : {};
-									if (ownerRawId !== void 0) value.id = ownerRawId;
-									return value;
-								})(),
-								field: key,
-								hash: fieldArgs?.hash,
-								key: listKey,
-								live: plan.live.get(fieldPath),
-								owner: parentId,
-								procedure: `${parentType}.${key}`,
-								root: false,
-								type: childType
-							};
-							Object.defineProperty(connection, ConnectionTag, {
-								configurable: false,
-								enumerable: false,
-								value: metadata,
-								writable: false
-							});
-						}
-						target[key] = connection;
-					} else target[key] = value.map((item) => {
-						const entityId = isNodeRef(item) ? getNodeRefId(item) : null;
-						if (!entityId) return item;
-						ids.add(entityId);
-						const record = this.store.read(entityId);
-						const { id, type } = parseEntityId(entityId);
-						if (record) {
-							const node = {
-								__typename: type,
-								id
-							};
-							walk(nextSelection, record, node, entityId, fieldPath);
-							return node;
-						}
-						return null;
-					});
-					else if (isNodeRef(value)) {
+							if (record) {
+								const node = {
+									__typename: type,
+									id
+								};
+								walk(nextSelection, record, node, entityId, fieldPath);
+								return node;
+							}
+							return null;
+						});
+					} else if (isNodeRef(value)) {
 						const entityId = getNodeRefId(value);
 						ids.add(entityId);
 						const relatedRecord = this.store.read(entityId);
@@ -3440,7 +2216,7 @@ function createClient(options) {
 * Builds a `Transport` backed by a tRPC client using the configured resolvers
 * for by-id queries, lists, and mutations.
 */
-function createTRPCTransport({ byId, client, lists, mutations, queries }) {
+function createTRPCTransport({ byId, client, lists, mutateDurably, mutations, queries }) {
 	const transport = {
 		async fetchById(type, ids, select, args) {
 			const resolver = byId[type];
@@ -3468,7 +2244,8 @@ function createTRPCTransport({ byId, client, lists, mutations, queries }) {
 				args,
 				select: [...select]
 			});
-		}
+		},
+		mutateDurably
 	};
 	transport.mutate = async (procedure, input, select) => {
 		const resolver = mutations?.[procedure];
@@ -3546,7 +2323,7 @@ const responseError = async (response) => {
 	return new FateRequestError(errorCodeFromStatus(response.status), message, { status: response.status });
 };
 const assertProtocolResponse = (value) => {
-	if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.results) || value.results.some((entry) => !isRecord(entry) || typeof entry.id !== "string")) throw new Error("fate(http): Invalid protocol response.");
+	if (!isRecord(value) || value.version !== 1 && value.version !== 2 || !Array.isArray(value.results) || value.results.some((entry) => !isRecord(entry) || typeof entry.id !== "string")) throw new Error("fate(http): Invalid protocol response.");
 	return value;
 };
 const resultValue = (result) => {
@@ -3584,7 +2361,7 @@ function createHTTPTransport({ eventSource, fetch: fetchImpl = defaultFetch, hea
 			const response = await fetchImpl(endpoint, {
 				body: JSON.stringify({
 					operations: batch.map((entry) => entry.operation),
-					version: 1
+					version: batch.some((entry) => entry.operation.mutation) ? 2 : 1
 				}),
 				headers: await requestHeaders({ "content-type": "application/json" }, headers),
 				method: "POST"
@@ -3641,6 +2418,15 @@ function createHTTPTransport({ eventSource, fetch: fetchImpl = defaultFetch, hea
 				name,
 				select: [...select]
 			});
+		},
+		mutateDurably(name, input, select, identity) {
+			return enqueue({
+				input,
+				kind: "mutation",
+				mutation: identity,
+				name,
+				select: [...select]
+			});
 		}
 	};
 	if (liveEnabled) {