@nkzw/fate 1.4.0 → 1.5.0

package/lib/index.mjs

@@ -1,7 +1,11 @@
 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(isEnabled = () => true) {
@@ -73,747 +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 ../../node_modules/.pnpm/@trpc+server@11.18.0_typescript@7.0.2/node_modules/@trpc/server/dist/getErrorShape-BPSzUA7W.mjs
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-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 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 applyOptimistic = () => {
-			if (optimisticRecord && optimisticEntityId) client.write(identifier.entity, optimisticRecord, optimisticSelection ?? emptySet$1, plan, insert);
-			if (deleteRecord && id != null) client.deleteRecord(identifier.entity, id);
-		};
-		const settle = client.store.optimisticUpdate(applyOptimistic);
-		const performMutation = async () => {
-			try {
-				const result = await client.executeMutation(identifier.key, input, selection, {
-					args,
-					plan
-				});
-				const shouldWriteResult = result && typeof result === "object" && (!deleteRecord || Boolean(view));
-				settle(() => {
-					if (shouldWriteResult) {
-						const select = collectImplicitSelectedPaths(result);
-						client.write(identifier.entity, result, select, plan, insert);
-						const resultId = maybeGetId(config.getId, result);
-						if (optimisticEntityId && resultId != null) client.resolveOptimisticEntity(optimisticEntityId, toEntityId(identifier.entity, resultId));
-						if (optimisticRecordId != null && resultId != null && optimisticRecordId !== resultId) client.deleteRecord(identifier.entity, optimisticRecordId);
-					}
-					if (deleteRecord && id != null) client.deleteRecord(identifier.entity, id);
-				});
-				return {
-					error: void 0,
-					result
-				};
-			} catch (error) {
-				settle();
-				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.`, { cause: error });
-			}
-		};
-		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) {
@@ -842,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;
@@ -870,793 +142,6 @@ var OperationLifetime = class {
 	}
 };
 //#endregion
-//#region src/mask.ts
-function emptyMask() {
-	return {
-		all: false,
-		children: /* @__PURE__ */ new Map()
-	};
-}
-function cloneMask(m) {
-	const clone = {
-		all: m.all,
-		children: /* @__PURE__ */ new Map()
-	};
-	for (const [key, value] of m.children) clone.children.set(key, cloneMask(value));
-	return clone;
-}
-function addPath(mask, path) {
-	if (mask.all) return;
-	const parts = path.split(".");
-	let current = mask;
-	for (let i = 0; i < parts.length; i++) {
-		const seg = parts[i];
-		let child = current.children.get(seg);
-		if (!child) {
-			child = emptyMask();
-			current.children.set(seg, child);
-		}
-		current = child;
-	}
-	current.all = true;
-	current.children.clear();
-}
-function union(into, b) {
-	if (into.all || b.all) {
-		into.all = true;
-		into.children.clear();
-		return;
-	}
-	for (const [key, child] of b.children) {
-		const exist = into.children.get(key);
-		if (!exist) into.children.set(key, cloneMask(child));
-		else union(exist, child);
-	}
-}
-function fromPaths(paths) {
-	const mask = emptyMask();
-	for (const path of paths) addPath(mask, path);
-	return mask;
-}
-function toPaths(mask) {
-	const paths = [];
-	const visit = (current, prefix) => {
-		if (current.all) {
-			if (prefix) paths.push(prefix);
-			return;
-		}
-		for (const [key, child] of current.children) visit(child, prefix ? `${prefix}.${key}` : key);
-	};
-	visit(mask, null);
-	return paths;
-}
-function isCovered(mask, path) {
-	if (mask.all) return true;
-	const parts = path.split(".");
-	let current = mask;
-	for (let i = 0; i < parts.length; i++) {
-		if (!current) return false;
-		if (current.all) return true;
-		current = current.children.get(parts[i]);
-	}
-	return !!current && (current.all || current.children.size === 0);
-}
-function diffPaths(paths, mask) {
-	const missing = /* @__PURE__ */ new Set();
-	for (const path of paths) if (!isCovered(mask, path)) missing.add(path);
-	return missing;
-}
-function intersects(a, b) {
-	if (a.all || b.all) return true;
-	for (const [key, child] of a.children) {
-		const otherChild = b.children.get(key);
-		if (!otherChild) continue;
-		if (child.all || otherChild.all) return true;
-		if (intersects(child, otherChild)) return true;
-	}
-	return false;
-}
-//#endregion
-//#region src/store.ts
-const listKeySeparator = " __fate__ ";
-const decodeListKeyPart = (part) => {
-	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 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 || left?.all && right?.all) return true;
-	if (!left || !right || left.all !== right.all || left.children.size !== right.children.size) return false;
-	for (const [key, child] of left.children) if (!areMasksEqual(child, right.children.get(key))) return false;
-	return true;
-};
-const emptyFunction = () => {};
-const hasReferences = (value) => isNodeRef(value) || Array.isArray(value) && value.some(isNodeRef);
-const areNormalizedValuesEqual = (left, right) => Object.is(left, right) || isNodeRef(left) && isNodeRef(right) && getNodeRefId(left) === getNodeRefId(right) || Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => areNormalizedValuesEqual(value, right[index]));
-var Store = class {
-	constructor(onRebase) {
-		this.onRebase = onRebase;
-		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();
-		this.optimisticLayers = /* @__PURE__ */ new Set();
-		this.optimisticBase = {
-			lists: /* @__PURE__ */ new Map(),
-			records: /* @__PURE__ */ new Map()
-		};
-	}
-	get hasOptimisticUpdates() {
-		return this.optimisticLayers.size > 0;
-	}
-	get isRebasing() {
-		return this.rebase !== void 0;
-	}
-	/** Apply a synchronous cache update beneath the pending optimistic layers. */
-	update(apply) {
-		if (this.rebase || this.optimisticLayers.size === 0) return apply();
-		const rebase = {
-			lists: /* @__PURE__ */ new Map(),
-			records: /* @__PURE__ */ new Map()
-		};
-		this.rebase = rebase;
-		try {
-			for (const [id, snapshot] of this.optimisticBase.records) this.restore(id, snapshot);
-			for (const [key, list] of this.optimisticBase.lists) this.restoreList(key, list);
-			this.optimisticBase.records.clear();
-			this.optimisticBase.lists.clear();
-			return apply();
-		} finally {
-			try {
-				for (const layer of this.optimisticLayers) {
-					layer.writes.clear();
-					this.recordingLayer = layer;
-					layer.apply();
-				}
-			} finally {
-				this.recordingLayer = void 0;
-				const records = this.getRebaseChanges(rebase);
-				const lists = /* @__PURE__ */ new Set();
-				for (const [key, before] of rebase.lists) if (!areHydrationValuesEqual(before, this.lists.get(key))) {
-					lists.add(key);
-					const owner = parseListKey(key);
-					if (owner) {
-						if (!records.has(owner.ownerId)) records.set(owner.ownerId, /* @__PURE__ */ new Set([owner.field]));
-						else records.get(owner.ownerId)?.add(owner.field);
-					}
-				} else if (before) this.lists.set(key, before);
-				this.rebase = void 0;
-				this.onRebase?.(new Set(records.keys()));
-				for (const [id, paths] of records) this.notify(id, paths);
-				for (const key of lists) this.notifyListSubscribers(key);
-			}
-		}
-	}
-	getRebaseChanges(rebase) {
-		const changes = /* @__PURE__ */ new Map();
-		for (const [id, before] of rebase.records) {
-			const after = this.records.get(id);
-			const mask = this.coverage.get(id);
-			if (Boolean(before.record) !== Boolean(after) || before.mask?.all !== mask?.all) {
-				changes.set(id, void 0);
-				continue;
-			}
-			const paths = /* @__PURE__ */ new Set();
-			for (const key of /* @__PURE__ */ new Set([...Object.keys(before.record ?? {}), ...Object.keys(after ?? {})])) if (Object.hasOwn(before.record ?? {}, key) !== Object.hasOwn(after ?? {}, key) || !areNormalizedValuesEqual(before.record?.[key], after?.[key])) paths.add(key);
-			if (!areMasksEqual(before.mask, mask)) {
-				for (const path of before.mask ? toPaths(before.mask) : []) if (!mask || !isCovered(mask, path)) paths.add(path);
-				for (const path of mask ? toPaths(mask) : []) if (!before.mask || !isCovered(before.mask, path)) paths.add(path);
-			}
-			if (paths.size > 0) changes.set(id, paths);
-			else if (before.record) this.records.set(id, before.record);
-		}
-		return changes;
-	}
-	/** Returns an idempotent settlement function; omit its update to roll back. */
-	optimisticUpdate(apply) {
-		const layer = {
-			apply,
-			writes: /* @__PURE__ */ new Map()
-		};
-		const settle = (commit) => {
-			if (!this.optimisticLayers.has(layer) || layer.settled) return;
-			this.update(() => {
-				const overlays = commit ? this.getPendingOverlap(layer, layer.writes) : /* @__PURE__ */ new Map();
-				if (overlays.size > 0) {
-					layer.settled = true;
-					layer.apply = () => {
-						for (const [id, { partial, paths }] of this.getPendingOverlap(layer, overlays)) this.merge(id, partial, paths);
-					};
-				} else this.optimisticLayers.delete(layer);
-				for (const pending of this.optimisticLayers) {
-					if (!pending.settled) break;
-					this.optimisticLayers.delete(pending);
-				}
-				commit?.();
-			});
-		};
-		this.optimisticLayers.add(layer);
-		try {
-			this.update(() => {});
-		} catch (error) {
-			settle();
-			throw error;
-		}
-		return settle;
-	}
-	getPendingOverlap(layer, writes) {
-		const earlier = [];
-		for (const pending of this.optimisticLayers) {
-			if (pending === layer) break;
-			if (!pending.settled) earlier.push(pending);
-		}
-		const overlaps = /* @__PURE__ */ new Map();
-		for (const [id, write] of writes) {
-			const partial = Object.fromEntries(Object.entries(write.partial).filter(([key, value]) => !hasReferences(value) && earlier.some(({ writes }) => {
-				const previous = writes.get(id)?.partial;
-				return previous && Object.hasOwn(previous, key) && !hasReferences(previous[key]);
-			})));
-			if (Object.keys(partial).length) overlaps.set(id, {
-				partial,
-				paths: new Set([...write.paths].filter((path) => Object.hasOwn(partial, path.split(".")[0])))
-			});
-		}
-		return overlaps;
-	}
-	captureRecord(id) {
-		if (!this.rebase) return;
-		for (const target of [this.rebase, this.recordingLayer && this.optimisticBase]) if (target && !target.records.has(id)) {
-			const mask = this.coverage.get(id);
-			target.records.set(id, {
-				mask: mask ? cloneMask(mask) : void 0,
-				record: this.records.get(id)
-			});
-		}
-	}
-	captureList(key) {
-		if (!this.rebase) return;
-		for (const target of [this.rebase, this.recordingLayer && this.optimisticBase]) if (target && !target.lists.has(key)) target.lists.set(key, this.lists.get(key));
-	}
-	dehydrate() {
-		return {
-			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) {
-		return this.update(() => {
-			const changedPaths = this.mergeInternal(id, partial, paths);
-			if (changedPaths) this.notify(id, changedPaths);
-		});
-	}
-	mergeInternal(id, partial, paths) {
-		this.captureRecord(id);
-		const selectedPaths = this.recordingLayer ? new Set(paths) : paths;
-		if (this.recordingLayer) {
-			const write = this.recordingLayer.writes.get(id) ?? {
-				partial: {},
-				paths: /* @__PURE__ */ new Set()
-			};
-			Object.assign(write.partial, partial);
-			for (const path of selectedPaths) write.paths.add(path);
-			this.recordingLayer.writes.set(id, write);
-		}
-		const previous = this.records.get(id);
-		const changedPaths = /* @__PURE__ */ new Set();
-		let mask = this.coverage.get(id);
-		if (!mask) {
-			mask = emptyMask();
-			this.coverage.set(id, mask);
-		}
-		union(mask, fromPaths(selectedPaths));
-		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) {
-		return this.update(() => {
-			this.captureRecord(id);
-			const record = this.records.get(id);
-			if (record) this.removeRecordReferenceIndexes(id, record);
-			this.records.delete(id);
-			this.coverage.delete(id);
-		});
-	}
-	missingForSelection(id, paths) {
-		const requested = new Set(paths);
-		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) {
-		if (this.rebase) return;
-		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) {
-		if (this.rebase) return;
-		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) {
-		return this.update(() => {
-			this.captureList(key);
-			const previous = this.lists.get(key);
-			if (previous) this.removeListIndexes(key, previous);
-			this.lists.set(key, state);
-			this.addListIndexes(key, state);
-			this.notifyListSubscribers(key);
-		});
-	}
-	replaceListEntityId(previousId, nextId) {
-		return this.update(() => {
-			const keys = [...this.listKeysByReferencedEntity.get(previousId) ?? []];
-			for (const key of keys) {
-				const list = this.lists.get(key);
-				if (!list) continue;
-				let changed = false;
-				let ids = list.ids;
-				let cursors = list.cursors;
-				if (list.ids.includes(previousId)) {
-					const nextIds = [];
-					const nextCursors = list.cursors ? [] : void 0;
-					const seenIds = /* @__PURE__ */ new Set();
-					list.ids.forEach((id, index) => {
-						const resolved = id === previousId ? nextId : id;
-						if (seenIds.has(resolved)) return;
-						seenIds.add(resolved);
-						nextIds.push(resolved);
-						if (nextCursors) nextCursors.push(list.cursors?.[index]);
-					});
-					changed = true;
-					ids = nextIds;
-					cursors = nextCursors;
-				}
-				const dedupe = (values) => {
-					if (!values || !values.includes(previousId)) return;
-					const seen = /* @__PURE__ */ new Set();
-					const next = [];
-					for (const value of values) {
-						const resolved = value === previousId ? nextId : value;
-						if (seen.has(resolved)) continue;
-						seen.add(resolved);
-						next.push(resolved);
-					}
-					changed = true;
-					return next;
-				};
-				const pendingBeforeIds = dedupe(list.pendingBeforeIds) ?? list.pendingBeforeIds;
-				const pendingAfterIds = dedupe(list.pendingAfterIds) ?? list.pendingAfterIds;
-				const liveBeforeIds = dedupe(list.liveBeforeIds) ?? list.liveBeforeIds;
-				const liveAfterIds = dedupe(list.liveAfterIds) ?? list.liveAfterIds;
-				if (!changed) continue;
-				const canonicalIds = new Set(ids);
-				this.setList(key, {
-					backwardPageLimit: list.backwardPageLimit,
-					cursors,
-					forwardPageLimit: list.forwardPageLimit,
-					ids,
-					liveAfterIds: liveAfterIds?.filter((id) => !canonicalIds.has(id)),
-					liveBeforeIds: liveBeforeIds?.filter((id) => !canonicalIds.has(id)),
-					pagination: list.pagination,
-					pendingAfterIds: pendingAfterIds?.filter((id) => !canonicalIds.has(id)),
-					pendingBeforeIds: pendingBeforeIds?.filter((id) => !canonicalIds.has(id))
-				});
-			}
-		});
-	}
-	restoreList(key, list) {
-		return this.update(() => {
-			if (list == null) this.deleteList(key);
-			else this.setList(key, list);
-		});
-	}
-	collectGarbage(markedRecords, markedLists, options = {}) {
-		const records = /* @__PURE__ */ new Set();
-		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) {
-		return this.update(() => {
-			this.captureList(key);
-			const previous = this.lists.get(key);
-			if (previous) this.removeListIndexes(key, previous);
-			this.lists.delete(key);
-			this.notifyListSubscribers(key);
-		});
-	}
-	subscribeList(key, fn) {
-		let set = this.listSubscriptions.get(key);
-		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) {
-		return this.update(() => {
-			const listKeys = [...this.listKeysByReferencedEntity.get(targetId) ?? []];
-			for (const key of listKeys) {
-				const list = this.lists.get(key);
-				if (!list) continue;
-				const { ids } = list;
-				const hasLiveAfter = Boolean(list.liveAfterIds?.includes(targetId));
-				const hasLiveBefore = Boolean(list.liveBeforeIds?.includes(targetId));
-				const hasPendingAfter = Boolean(list.pendingAfterIds?.includes(targetId));
-				const hasPendingBefore = Boolean(list.pendingBeforeIds?.includes(targetId));
-				if (!ids.includes(targetId) && !hasLiveAfter && !hasLiveBefore && !hasPendingAfter && !hasPendingBefore) continue;
-				const entityIds = [];
-				const cursors = list.cursors ? [] : void 0;
-				for (let index = 0; index < ids.length; index++) {
-					const id = ids[index];
-					if (id === targetId) continue;
-					entityIds.push(id);
-					if (cursors) cursors.push(list.cursors?.[index]);
-				}
-				this.setList(key, {
-					backwardPageLimit: list.backwardPageLimit,
-					cursors,
-					forwardPageLimit: list.forwardPageLimit,
-					ids: entityIds,
-					liveAfterIds: list.liveAfterIds?.filter((id) => id !== targetId),
-					liveBeforeIds: list.liveBeforeIds?.filter((id) => id !== targetId),
-					pagination: list.pagination,
-					pendingAfterIds: list.pendingAfterIds?.filter((id) => id !== targetId),
-					pendingBeforeIds: list.pendingBeforeIds?.filter((id) => id !== targetId)
-				});
-			}
-			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;
-				viewDataCache.invalidate(id);
-				this.mergeInternal(id, next, paths);
-				ids.set(id, paths);
-			}
-			for (const [id, paths] of ids) this.notify(id, paths);
-		});
-	}
-	restore(id, snapshot) {
-		return this.update(() => {
-			this.captureRecord(id);
-			const previous = this.records.get(id);
-			if (previous) this.removeRecordReferenceIndexes(id, previous);
-			if (snapshot.record === void 0) this.records.delete(id);
-			else {
-				this.records.set(id, snapshot.record);
-				this.addRecordReferenceIndexes(id, snapshot.record);
-			}
-			if (snapshot.mask === void 0) this.coverage.delete(id);
-			else this.coverage.set(id, snapshot.mask);
-			this.notify(id);
-		});
-	}
-	addListIndexes(key, list) {
-		const parsed = parseListKey(key);
-		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) => {
@@ -1984,6 +469,7 @@ var FateClient = class {
 		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;
@@ -1992,11 +478,13 @@ var FateClient = class {
 		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);
@@ -2020,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()) {
@@ -2098,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) {
@@ -2156,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));
@@ -2165,7 +728,7 @@ var FateClient = class {
 			...baseRecord,
 			args: argsPayload
 		} : argsPayload ? { args: argsPayload } : input;
-		return await this.trackPendingRequest(() => this.transport.mutate(key, requestInput, select));
+		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);
@@ -2201,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) {
@@ -2253,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);
@@ -2334,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;
@@ -2361,19 +966,26 @@ var FateClient = class {
 		try {
 			unsubscribe = this.transport.subscribeById(type, id, plan.paths, args, {
 				onData: (record, liveSelect) => {
-					if (!record || typeof record !== "object") return;
+					if (this.persistenceDisposal?.signal.aborted || !record || typeof record !== "object") return;
 					const select = new Set(liveSelect ?? plan.paths);
 					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
@@ -2383,6 +995,7 @@ var FateClient = class {
 		};
 	}
 	subscribeLiveListView(view, connection) {
+		this.assertPersistenceActive();
 		this.assertLiveConnectionSupport();
 		const plan = getSelectionPlan(view, null);
 		const connectionArgs = filterConnectionArgs(connection.args);
@@ -2399,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);
 				}
 			});
@@ -2408,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
@@ -2723,6 +1343,7 @@ 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);
 			this.store.update(() => {
 				const incomingIds = [];
@@ -2754,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) ? {
@@ -2796,7 +1418,7 @@ var FateClient = class {
 	}
 	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;
@@ -2805,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));
@@ -2824,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) {
@@ -2869,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;
 		}
@@ -2890,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));
@@ -2928,15 +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));
-		}
-		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();
@@ -2962,24 +1598,47 @@ var FateClient = class {
 	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) {
@@ -3005,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(",");
@@ -3020,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) {
@@ -3124,6 +1808,7 @@ var FateClient = class {
 		const resolvedArgs = resolvedArgsFromPlan(plan);
 		await this.trackPendingRequest(async () => {
 			const records = await this.transport.fetchById(type, ids, select, resolvedArgs);
+			this.assertPersistenceActive();
 			for (const record of records) this.writeEntity(type, record, select, plan, prefix);
 		});
 	}
@@ -3131,6 +1816,7 @@ var FateClient = class {
 		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;
@@ -3143,6 +1829,7 @@ 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);
+			this.assertPersistenceActive();
 			this.store.update(() => {
 				const ids = [];
 				const cursors = [];
@@ -3185,7 +1872,8 @@ var FateClient = class {
 						const childType = relationDescriptor.type;
 						const childConfig = this.types.get(childType);
 						if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${type}.${key}').`);
-						result[key] = createNodeRef(toEntityId(childType, childConfig.getId(value)));
+						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) {
@@ -3528,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];
@@ -3556,7 +2244,8 @@ function createTRPCTransport({ byId, client, lists, mutations, queries }) {
 				args,
 				select: [...select]
 			});
-		}
+		},
+		mutateDurably
 	};
 	transport.mutate = async (procedure, input, select) => {
 		const resolver = mutations?.[procedure];
@@ -3634,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) => {
@@ -3672,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"
@@ -3729,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) {