@nkzw/fate 0.1.3 → 1.0.0-rc.0

package/lib/index.mjs

@@ -1,130 +1,6 @@
-import { t as isRecord } from "./record-DnhZuvUe.mjs";
-
-//#region src/args.ts
-const ensureSerializable = (value, path) => {
-	const type = typeof value;
-	if (type === "function" || type === "symbol") throw new Error(`fate: Argument '${path}' must be serializable. Received '${type}'.`);
-};
-const cloneArgs = (value, path) => {
-	const cloneValue$1 = (entry, currentPath) => {
-		if (Array.isArray(entry)) return entry.map((item, index) => cloneValue$1(item, `${currentPath}[${index}]`));
-		if (isRecord(entry)) {
-			const result = {};
-			for (const [key, child] of Object.entries(entry)) result[key] = cloneValue$1(child, `${currentPath}.${key}`);
-			return result;
-		}
-		ensureSerializable(entry, currentPath);
-		return entry;
-	};
-	return cloneValue$1(value, path);
-};
-const stableSerialize = (value) => {
-	if (value === null) return "null";
-	const type = typeof value;
-	if (type === "number" || type === "boolean" || type === "bigint") return `${type}:${String(value)}`;
-	if (type === "string") return `string:${JSON.stringify(value)}`;
-	if (type === "undefined") return "undefined";
-	if (Array.isArray(value)) return `array:[${value.map(stableSerialize).join(",")}]`;
-	if (typeof value === "object") return `object:{${Object.entries(value).map(([key, entry]) => [key, entry]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([_key, entry]) => `${JSON.stringify(_key)}:${stableSerialize(entry)}`).join(",")}}`;
-	throw new Error(`fate: Unable to serialize argument value of type '${type}'.`);
-};
-const hashArgs = (argsValue, options = {}) => {
-	const keys = {};
-	for (const [key, value] of Object.entries(argsValue)) {
-		if (options.ignoreKeys && options.ignoreKeys.has(key)) continue;
-		keys[key] = value;
-	}
-	return stableSerialize(keys);
-};
-const mergeArgs = (target, source) => {
-	for (const [key, value] of Object.entries(source)) {
-		if (isRecord(value)) {
-			const existing = target[key];
-			if (isRecord(existing)) mergeArgs(existing, value);
-			else target[key] = { ...value };
-			continue;
-		}
-		target[key] = value;
-	}
-};
-const resolvedArgsFromPlan = (plan) => {
-	if (!plan || plan.args.size === 0) return;
-	const result = {};
-	for (const [path, entry] of plan.args.entries()) {
-		if (path === "") {
-			mergeArgs(result, entry.value);
-			continue;
-		}
-		const segments = path.split(".");
-		let current = result;
-		segments.forEach((segment, index) => {
-			if (index === segments.length - 1) {
-				const existing$1 = current[segment];
-				if (isRecord(existing$1)) mergeArgs(existing$1, entry.value);
-				else current[segment] = { ...entry.value };
-				return;
-			}
-			const existing = current[segment];
-			if (isRecord(existing)) {
-				current = existing;
-				return;
-			}
-			const next = {};
-			current[segment] = next;
-			current = next;
-		});
-	}
-	return result;
-};
-const hasEntries = (value) => Boolean(value && Object.keys(value).length > 0);
-const combineArgsPayload = (base, scoped) => {
-	if (!hasEntries(base) && !hasEntries(scoped)) return;
-	const result = hasEntries(base) ? { ...base } : {};
-	if (hasEntries(scoped)) mergeArgs(result, scoped);
-	return result;
-};
-const getArgsAtPath = (payload, path) => {
-	if (!payload) return;
-	if (path === "") return payload;
-	const segments = path.split(".");
-	let current = payload;
-	for (const segment of segments) {
-		if (!isRecord(current)) return;
-		current = current[segment];
-		if (current === void 0) return;
-	}
-	return isRecord(current) ? current : void 0;
-};
-const applyArgsPayloadToPlan = (plan, payload) => {
-	for (const [path, entry] of plan.args.entries()) {
-		const actual = path === "" ? payload : getArgsAtPath(payload, path);
-		if (!actual) continue;
-		const cloned = cloneArgs(actual, path);
-		const hash = hashArgs(cloned, { ignoreKeys: entry.ignoreKeys });
-		plan.args.set(path, {
-			hash,
-			ignoreKeys: entry.ignoreKeys,
-			value: cloned
-		});
-	}
-};
-const scopeArgsPayload = (args, scope) => {
-	const segments = scope.split(".");
-	const result = {};
-	let current = result;
-	segments.forEach((segment, index) => {
-		if (index === segments.length - 1) {
-			current[segment] = args;
-			return;
-		}
-		const next = {};
-		current[segment] = next;
-		current = next;
-	});
-	return result;
-};
-
-//#endregion
+import { t as isRecord } from "./record-AeZJC9fd.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-DzNtJaBD.mjs";
+import { t as getListEntries } from "./list-C_mi6GnE.mjs";
 //#region src/cache.ts
 var ViewDataCache = class {
 	constructor() {
@@ -132,19 +8,19 @@ var ViewDataCache = class {
 		this.rootDependencies = /* @__PURE__ */ new Map();
 		this.dependencyIndex = /* @__PURE__ */ new Map();
 	}
-	get(entityId, view$1, ref) {
-		return this.cache.get(entityId)?.get(view$1)?.get(ref) ?? null;
+	get(entityId, view, ref) {
+		return this.cache.get(entityId)?.get(view)?.get(ref) ?? null;
 	}
-	set(entityId, view$1, ref, thenable, dependencies) {
+	set(entityId, view, ref, thenable, dependencies) {
 		let entityMap = this.cache.get(entityId);
 		if (!entityMap) {
 			entityMap = /* @__PURE__ */ new WeakMap();
 			this.cache.set(entityId, entityMap);
 		}
-		let viewMap = entityMap.get(view$1);
+		let viewMap = entityMap.get(view);
 		if (!viewMap) {
 			viewMap = /* @__PURE__ */ new WeakMap();
-			entityMap.set(view$1, viewMap);
+			entityMap.set(view, viewMap);
 		}
 		viewMap.set(ref, thenable);
 		let roots = this.rootDependencies.get(entityId);
@@ -186,7 +62,6 @@ var ViewDataCache = class {
 		this.cache.delete(entityId);
 	}
 };
-
 //#endregion
 //#region src/mask.ts
 function emptyMask() {
@@ -262,9 +137,8 @@ function intersects(a, b) {
 	}
 	return false;
 }
-
 //#endregion
-//#region ../../node_modules/.pnpm/@trpc+server@11.8.1_typescript@5.9.3/node_modules/@trpc/server/dist/getErrorShape-vC8mUXJD.mjs
+//#region ../../node_modules/.pnpm/@trpc+server@11.17.0_typescript@5.9.3/node_modules/@trpc/server/dist/getErrorShape-BPSzUA7W.mjs
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -364,7 +238,7 @@ var require_defineProperty = __commonJS({ "../../node_modules/.pnpm/@oxc-project
 	}
 	module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
 } });
-var require_objectSpread2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
+__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);
@@ -388,9 +262,7 @@ var require_objectSpread2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+
 		return e;
 	}
 	module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} });
-var import_objectSpread2 = __toESM(require_objectSpread2(), 1);
-
+} })(), 1);
 //#endregion
 //#region src/types.ts
 /** Internal marker added to objects that represent a view payload. */
@@ -403,8 +275,8 @@ const NodeRefTag = Symbol("__fate__node-ref");
 const ConnectionTag = Symbol("__fate__connection");
 const viewTag = "__fate-view__";
 /** Generates a stable view tag for a view definition. */
-function getViewTag(id$1) {
-	return `${viewTag}${id$1}`;
+function getViewTag(id) {
+	return `${viewTag}${id}`;
 }
 /** Determines whether a property key is a fate view tag. */
 function isViewTag(key) {
@@ -426,7 +298,6 @@ function isQueryItem(item) {
 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/view.ts
 /**
@@ -452,7 +323,8 @@ const getSelectionViewNames = (selection) => {
 	return getViewNames(selection);
 };
 let id = 0;
-const isDevelopment = import.meta?.env?.DEV || import.meta?.env?.NODE_ENV !== "production";
+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 {
@@ -495,7 +367,6 @@ function view() {
 		return Object.freeze(viewComposition);
 	};
 }
-
 //#endregion
 //#region src/ref.ts
 /**
@@ -505,14 +376,14 @@ const toEntityId = (type, rawId) => `${type}:${String(rawId)}`;
 /**
 * Splits a cache entity ID back into its type and raw identifier.
 */
-function parseEntityId(id$1) {
-	const idx = id$1.indexOf(":");
+function parseEntityId(id) {
+	const idx = id.indexOf(":");
 	return idx < 0 ? {
-		id: id$1,
+		id,
 		type: ""
 	} : {
-		id: id$1.slice(idx + 1),
-		type: id$1.slice(0, idx)
+		id: id.slice(idx + 1),
+		type: id.slice(0, idx)
 	};
 }
 /**
@@ -526,32 +397,22 @@ function assignViewTag(target, value) {
 		writable: false
 	});
 }
-const getRootViewNames = (view$1) => {
-	const names = new Set(getViewNames(view$1));
-	const payloads = getViewPayloads(view$1, null);
+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;
 };
-/**
-* Creates an immutable `ViewRef` for an entity, tagging it with all views from
-* the provided composition so `useView` can resolve the ref against a view.
-*/
-function createRef(__typename, id$1, view$1, options) {
+function createRefWithViewNames(__typename, id, names) {
 	const ref = {
 		__typename,
-		id: id$1
+		id
 	};
-	assignViewTag(ref, options?.root ? getRootViewNames(view$1) : getViewNames(view$1));
+	assignViewTag(ref, names);
 	return Object.freeze(ref);
 }
-
 //#endregion
 //#region src/selection.ts
-const paginationKeys = new Set([
-	"after",
-	"before",
-	"cursor"
-]);
 const isConnectionSelection = (value) => isRecord(value.items) && "node" in value.items;
 /**
 * Flattens a view into a `SelectionPlan`, expanding composed views and
@@ -559,6 +420,7 @@ const isConnectionSelection = (value) => isRecord(value.items) && "node" in valu
 */
 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 });
@@ -570,8 +432,12 @@ const getSelectionPlan = (viewComposition, ref) => {
 	};
 	const walk = (selection, prefix, context = "default") => {
 		if (prefix === null && context !== "connection" && isConnectionSelection(selection)) {
-			if (selection.args && isRecord(selection.args)) assignArgs("", cloneArgs(selection.args, "args"), isRecord(selection.items) && isRecord(selection.items.node) ? paginationKeys : void 0);
-			const { args: args$1, ...withoutArgs } = 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)) assignArgs("", cloneArgs(selection.args, "args"), isRecord(selection.items) && isRecord(selection.items.node) ? paginationArgKeys : void 0);
+			const { args: _args, live: _live, ...withoutArgs } = selection;
 			walk(withoutArgs, prefix, "connection");
 			return;
 		}
@@ -579,7 +445,7 @@ const getSelectionPlan = (viewComposition, ref) => {
 			const valueType = typeof value;
 			const path = prefix ? `${prefix}.${key}` : key;
 			if (context === "connection") {
-				if (key === "args" || key === "pagination") continue;
+				if (key === "args" || key === "live" || key === "pagination") continue;
 				if (key === "items" && isRecord(value)) {
 					if (isRecord(value.node)) walk(value.node, prefix);
 					continue;
@@ -596,16 +462,20 @@ const getSelectionPlan = (viewComposition, ref) => {
 			if (isRecord(value)) {
 				const selectionObject = value;
 				if (isConnectionSelection(selectionObject)) {
-					if (selectionObject.args && isRecord(selectionObject.args)) assignArgs(path, cloneArgs(selectionObject.args, path), isRecord(selectionObject.items) && isRecord(selectionObject.items.node) ? paginationKeys : void 0);
-					const { args: _ignored, ...withoutArgs } = 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)) assignArgs(path, cloneArgs(selectionObject.args, path), isRecord(selectionObject.items) && isRecord(selectionObject.items.node) ? paginationArgKeys : void 0);
+					const { args: _ignored, live: _live, ...withoutArgs } = selectionObject;
 					walk(withoutArgs, path, "connection");
 					continue;
 				}
 				const hasArgs = selectionObject.args && isRecord(selectionObject.args);
 				let selectionWithoutArgs = selectionObject;
 				if (hasArgs) {
-					assignArgs(path, cloneArgs(selectionObject.args, path), isRecord(selectionObject.items) && isRecord(selectionObject.items?.node) ? paginationKeys : void 0);
-					const { args: args$1, ...rest } = selectionObject;
+					assignArgs(path, cloneArgs(selectionObject.args, path), isRecord(selectionObject.items) && isRecord(selectionObject.items?.node) ? paginationArgKeys : void 0);
+					const { args: _args, ...rest } = selectionObject;
 					selectionWithoutArgs = rest;
 				}
 				if (Object.keys(selectionWithoutArgs).length > 0) walk(selectionWithoutArgs, path);
@@ -618,10 +488,10 @@ const getSelectionPlan = (viewComposition, ref) => {
 	else for (const payload of payloads) walk(payload.select, null);
 	return {
 		args,
+		live,
 		paths
 	};
 };
-
 //#endregion
 //#region src/mutation.ts
 /**
@@ -655,9 +525,9 @@ const collectImplicitSelectedPaths = (value) => {
 	walk(value, null);
 	return paths;
 };
-const maybeGetId = (getId$1, input) => {
+const maybeGetId = (getId, input) => {
 	try {
-		return getId$1(input);
+		return getId(input);
 	} catch {
 		return null;
 	}
@@ -669,38 +539,36 @@ const emptySet$1 = /* @__PURE__ */ new Set();
 */
 function wrapMutation(client, identifier) {
 	const config = client.getTypeConfig(identifier.entity);
-	return async ({ args, delete: deleteRecord, input, insert = "after", optimistic, view: view$1 }) => {
-		const id$1 = maybeGetId(config.getId, input);
-		const plan = view$1 ? getSelectionPlan(view$1, null) : void 0;
+	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$1 != null ? {
-			id: id$1,
+		const optimisticRecord = optimistic ? id != null ? {
+			id,
 			...optimistic
 		} : optimistic : void 0;
 		const optimisticRecordId = optimisticRecord !== void 0 ? maybeGetId(config.getId, optimisticRecord) : null;
-		const optimisticEntityId = id$1 != null ? toEntityId(identifier.entity, id$1) : optimisticRecordId != null ? toEntityId(identifier.entity, optimisticRecordId) : null;
+		const optimisticEntityId = id != null ? toEntityId(identifier.entity, id) : optimisticRecordId != null ? toEntityId(identifier.entity, optimisticRecordId) : null;
 		const snapshots = /* @__PURE__ */ new Map();
-		const listSnapshots = deleteRecord ? /* @__PURE__ */ new Map() : void 0;
+		const listSnapshots = deleteRecord || optimisticRecord ? /* @__PURE__ */ new Map() : void 0;
 		const optimisticSelection = optimisticRecord ? collectImplicitSelectedPaths(optimisticRecord) : void 0;
 		const selection = viewSelection || optimisticSelection ? 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);
-		if (deleteRecord) {
-			if (id$1 == null) throw new Error(`fate: Mutation '${identifier.key}' requires an 'id' to delete.`);
-			client.deleteRecord(identifier.entity, id$1, snapshots, listSnapshots);
-		}
+		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$1))) {
+				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$1 != null) client.deleteRecord(identifier.entity, id$1);
+					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);
@@ -711,11 +579,11 @@ function wrapMutation(client, identifier) {
 				};
 			} catch (error) {
 				client.clearOptimisticUpdate(optimisticToken);
-				if (snapshots.size > 0) for (const [id$2, snapshot] of snapshots) client.restore(id$2, snapshot);
+				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 { data } = error;
-					if ((data ? categorizeTRPCError(getHTTPStatusCodeFromError(data)) : "boundary") === "boundary") throw error;
+					const statusCode = getErrorStatusCode(error);
+					if ((statusCode ? categorizeHTTPErrorStatus(statusCode) : "boundary") === "boundary") throw error;
 					return {
 						error,
 						result: void 0
@@ -730,7 +598,13 @@ function wrapMutation(client, identifier) {
 		return mutationPromise;
 	};
 }
-function categorizeTRPCError(statusCode) {
+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:
@@ -743,27 +617,17 @@ function categorizeTRPCError(statusCode) {
 		case 422:
 		case 429:
 		case 499: return "callSite";
-		case 401:
-		case 403:
-		case 405:
-		case 428:
-		case 500:
-		case 501:
-		case 502:
-		case 503:
-		case 504:
 		default: return "boundary";
 	}
-}
-
+};
 //#endregion
 //#region src/node-ref.ts
-function createNodeRef(id$1) {
+function createNodeRef(id) {
 	const ref = {};
 	Object.defineProperty(ref, NodeRefTag, {
 		configurable: false,
 		enumerable: false,
-		value: id$1,
+		value: id,
 		writable: false
 	});
 	return Object.freeze(ref);
@@ -774,10 +638,84 @@ function isNodeRef(value) {
 function getNodeRefId(ref) {
 	return ref[NodeRefTag];
 }
-
+//#endregion
+//#region src/operation-lifetime.ts
+var OperationLifetime = class {
+	constructor(releaseBufferSize) {
+		this.releaseBufferSize = releaseBufferSize;
+		this.operations = /* @__PURE__ */ new Map();
+		this.releaseBuffer = [];
+	}
+	retain(descriptor, onDispose) {
+		let operation = this.operations.get(descriptor.key);
+		if (!operation) {
+			operation = {
+				descriptor,
+				refCount: 0
+			};
+			this.operations.set(descriptor.key, operation);
+		}
+		operation.refCount += 1;
+		this.removeFromReleaseBuffer(descriptor.key);
+		let disposed = false;
+		return { dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			if (this.release(descriptor.key)) onDispose?.();
+		} };
+	}
+	getDescriptors() {
+		return [...this.operations.values()].map((operation) => operation.descriptor);
+	}
+	release(key) {
+		const operation = this.operations.get(key);
+		if (!operation) return false;
+		operation.refCount -= 1;
+		if (operation.refCount > 0) return false;
+		if (this.releaseBufferSize <= 0) {
+			this.operations.delete(key);
+			return true;
+		}
+		this.releaseBuffer.push(key);
+		let released = false;
+		while (this.releaseBuffer.length > this.releaseBufferSize) {
+			const releasedKey = this.releaseBuffer.shift();
+			if (!releasedKey) continue;
+			const releasedOperation = this.operations.get(releasedKey);
+			if (releasedOperation && releasedOperation.refCount <= 0) {
+				this.operations.delete(releasedKey);
+				released = true;
+			}
+		}
+		return released;
+	}
+	removeFromReleaseBuffer(key) {
+		const index = this.releaseBuffer.indexOf(key);
+		if (index !== -1) this.releaseBuffer.splice(index, 1);
+	}
+};
 //#endregion
 //#region src/store.ts
-const getListKey = (ownerId, field, hash = "default") => `${ownerId} __fate__ ${field} __fate__ ${hash}`;
+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;
@@ -792,25 +730,29 @@ 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();
 	}
-	read(id$1) {
-		return this.records.get(id$1);
+	read(id) {
+		return this.records.get(id);
 	}
-	merge(id$1, partial, paths) {
-		const changedPaths = this.mergeInternal(id$1, partial, paths);
-		if (changedPaths) this.notify(id$1, changedPaths);
+	merge(id, partial, paths) {
+		const changedPaths = this.mergeInternal(id, partial, paths);
+		if (changedPaths) this.notify(id, changedPaths);
 	}
-	mergeInternal(id$1, partial, paths) {
-		const previous = this.records.get(id$1);
+	mergeInternal(id, partial, paths) {
+		const previous = this.records.get(id);
 		const changedPaths = /* @__PURE__ */ new Set();
-		let mask = this.coverage.get(id$1);
+		let mask = this.coverage.get(id);
 		if (!mask) {
 			mask = emptyMask();
-			this.coverage.set(id$1, mask);
+			this.coverage.set(id, mask);
 		}
 		union(mask, fromPaths(paths));
 		if (previous) {
@@ -820,25 +762,33 @@ var Store = class {
 				changedPaths.add(key);
 			}
 			if (!hasChanges) return null;
-			this.records.set(id$1, {
+			const nextRecord = {
 				...previous,
 				...partial
-			});
-		} else this.records.set(id$1, { ...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$1) {
-		this.records.delete(id$1);
-		this.coverage.delete(id$1);
+	deleteRecord(id) {
+		const record = this.records.get(id);
+		if (record) this.removeRecordReferenceIndexes(id, record);
+		this.records.delete(id);
+		this.coverage.delete(id);
 	}
-	missingForSelection(id$1, paths) {
+	missingForSelection(id, paths) {
 		const requested = new Set(paths);
-		if (!this.records.has(id$1)) return requested;
-		const mask = this.coverage.get(id$1);
+		if (!this.records.has(id)) return requested;
+		const mask = this.coverage.get(id);
 		if (!mask) return requested;
 		return diffPaths(requested, mask);
 	}
-	subscribe(id$1, selectionOrFn, callback) {
+	subscribe(id, selectionOrFn, callback) {
 		let mask = null;
 		let fn = emptyFunction;
 		if (typeof selectionOrFn === "function") fn = selectionOrFn;
@@ -846,10 +796,10 @@ var Store = class {
 			mask = selectionOrFn ? fromPaths(selectionOrFn) : null;
 			fn = callback;
 		}
-		let subscribers = this.subscriptions.get(id$1);
+		let subscribers = this.subscriptions.get(id);
 		if (!subscribers) {
 			subscribers = /* @__PURE__ */ new Set();
-			this.subscriptions.set(id$1, subscribers);
+			this.subscriptions.set(id, subscribers);
 		}
 		const subscription = {
 			fn,
@@ -857,14 +807,14 @@ var Store = class {
 		};
 		subscribers.add(subscription);
 		return () => {
-			const set = this.subscriptions.get(id$1);
+			const set = this.subscriptions.get(id);
 			if (!set) return;
 			set.delete(subscription);
-			if (set.size === 0) this.subscriptions.delete(id$1);
+			if (set.size === 0) this.subscriptions.delete(id);
 		};
 	}
-	notify(id$1, paths) {
-		const set = this.subscriptions.get(id$1);
+	notify(id, paths) {
+		const set = this.subscriptions.get(id);
 		if (!set) return;
 		const changedPaths = paths ? [...paths] : [];
 		const changedMask = changedPaths.length > 0 ? fromPaths(changedPaths) : null;
@@ -890,18 +840,110 @@ var Store = class {
 	}
 	getListsForField(ownerId, field) {
 		const entries = [];
-		const prefix = getListKey(ownerId, field, "");
-		for (const entry of this.lists.entries()) if (entry[0].startsWith(prefix)) entries.push(entry);
+		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.lists.delete(key);
+		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) {
@@ -917,66 +959,373 @@ var Store = class {
 		};
 	}
 	removeReferencesTo(targetId, viewDataCache, snapshots, listSnapshots) {
-		for (const [key, list] of this.lists.entries()) {
-			const { ids: ids$1 } = list;
-			if (!ids$1.includes(targetId)) continue;
+		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$1.length; index++) {
-				const id$1 = ids$1[index];
-				if (id$1 === targetId) continue;
-				entityIds.push(id$1);
+			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,
-				pagination: list.pagination
+				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();
-		for (const [id$1, record] of this.records.entries()) {
+		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, value] of Object.entries(record)) if (Array.isArray(value)) {
-				const filtered = value.filter((item) => !(isNodeRef(item) && getNodeRefId(item) === targetId));
-				if (filtered.length !== value.length) {
+			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] = filtered;
+					next[key] = null;
 				}
-			} else if (isNodeRef(value) && getNodeRefId(value) === targetId) {
-				updated = true;
-				paths.add(key);
-				next[key] = null;
 			}
 			if (!updated) continue;
-			if (snapshots && !snapshots.has(id$1)) snapshots.set(id$1, this.snapshot(id$1));
-			viewDataCache.invalidate(id$1);
-			this.mergeInternal(id$1, next, paths);
-			ids.set(id$1, paths);
+			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$1, paths] of ids) this.notify(id$1, paths);
+		for (const [id, paths] of ids) this.notify(id, paths);
 	}
-	snapshot(id$1) {
-		const record = this.records.get(id$1);
-		const mask = this.coverage.get(id$1);
+	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$1, snapshot) {
-		if (snapshot.record === void 0) this.records.delete(id$1);
-		else this.records.set(id$1, snapshot.record);
-		if (snapshot.mask === void 0) this.coverage.delete(id$1);
-		else this.coverage.set(id$1, snapshot.mask);
-		this.notify(id$1);
+	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 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) => {
+	const viewNames = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const collect = (value) => {
+		if (!value || typeof value !== "object" || seen.has(value)) return;
+		seen.add(value);
+		for (const [key, entry] of Object.entries(value)) {
+			if (isViewTag(key)) viewNames.add(key);
+			collect(entry);
+		}
+	};
+	collect(view);
+	return viewNames.size ? [...viewNames].sort().join(",") : "";
+};
+const getRootDescriptorKey = (name, argsPayload, plan) => {
+	if (!argsPayload) return name;
+	return getListKey("__root__", name, plan.args.get("")?.hash ?? hashArgs(argsPayload));
+};
+const getRootListDescriptorKey = (name, argsPayload, plan) => {
+	if (!argsPayload) return name;
+	return getListKey("__root__", name, plan.args.get("")?.hash ?? hashArgs(filterConnectionArgs(argsPayload) ?? {}));
+};
+const hasCursorArgs = (argsPayload) => Boolean(argsPayload && ("after" in argsPayload || "before" in argsPayload || "cursor" in argsPayload));
+const getPaginationArgsInfo = (argsPayload) => ({
+	direction: argsPayload?.before !== void 0 || argsPayload?.last !== void 0 ? "backward" : "forward",
+	hasCursorArg: hasCursorArgs(argsPayload)
+});
+const getRequestDescriptorKey = (items) => {
+	const parts = [];
+	const sorted = [...items].sort((a, b) => a.name.localeCompare(b.name));
+	for (const item of sorted) {
+		if (item.kind === "node") {
+			parts.push(`node:${item.name}:${item.viewSignature}:${item.ids[0]}`);
+			continue;
+		}
+		if (item.kind === "nodes") {
+			parts.push(`node:${item.name}:${item.viewSignature}:${item.ids.map(serializeId).join(",")}`);
+			continue;
+		}
+		if (item.kind === "query") {
+			parts.push(`query:${item.name}:${item.viewSignature}:${item.argsPayload ? hashArgs(item.argsPayload) : ""}`);
+			continue;
+		}
+		if (item.kind === "list") parts.push(`list:${item.name}:${item.viewSignature}:${item.argsPayload ? hashArgs(item.argsPayload) : ""}`);
+	}
+	return parts.join("$");
+};
+const createRequestDescriptor = (request, getRootType) => {
+	const items = [];
+	for (const [name, item] of Object.entries(request)) {
+		const type = getRootType(name);
+		if (isNodeItem(item)) {
+			items.push({
+				ids: [item.id],
+				kind: "node",
+				name,
+				plan: getSelectionPlan(item.view, null),
+				refViewNames: new Set(getViewNames(item.view)),
+				type,
+				viewSignature: getViewSignature(item.view)
+			});
+			continue;
+		}
+		if (isNodesItem(item)) {
+			items.push({
+				ids: item.ids,
+				kind: "nodes",
+				name,
+				plan: getSelectionPlan(item.view, null),
+				refViewNames: new Set(getViewNames(item.view)),
+				type,
+				viewSignature: getViewSignature(item.view)
+			});
+			continue;
+		}
+		if (isQueryItem(item)) {
+			const { argsPayload, plan } = resolveSelectionPlan(item.view, item.args);
+			items.push({
+				argsPayload,
+				kind: "query",
+				name,
+				plan,
+				queryKey: getRootDescriptorKey(name, argsPayload, plan),
+				refViewNames: getRootViewNames(item.view),
+				type,
+				viewSignature: getViewSignature(item.view)
+			});
+			continue;
+		}
+		const { argsPayload, plan } = resolveSelectionPlan(item.list, item.args);
+		const hasItems = item.list && typeof item.list === "object" && "items" in item.list;
+		const nodeView = hasItems && item.list.items ? item.list.items.node ?? item.list : item.list;
+		items.push({
+			argsPayload,
+			hasItems,
+			kind: "list",
+			listKey: getRootListDescriptorKey(name, argsPayload, plan),
+			name,
+			nodeRefViewNames: getRootViewNames(nodeView),
+			plan,
+			type,
+			viewSignature: getViewSignature(item.list)
+		});
+	}
+	return {
+		items,
+		key: getRequestDescriptorKey(items)
+	};
+};
+const resolveSelectionPlan = (view, args) => {
+	const plan = getSelectionPlan(view, null);
+	const argsPayload = combineArgsPayload(args, resolvedArgsFromPlan(plan));
+	if (argsPayload) applyArgsPayloadToPlan(plan, argsPayload);
+	return {
+		argsPayload,
+		plan
+	};
+};
+//#endregion
+//#region src/request-promise.ts
+let _Symbol$toStringTag;
+var FateRequestPromise = class {
+	static {
+		_Symbol$toStringTag = Symbol.toStringTag;
+	}
+	constructor(descriptor, readValue) {
+		this.descriptor = descriptor;
+		this.readValue = readValue;
+		this[_Symbol$toStringTag] = "Promise";
+		this.status = "pending";
+		this.execution = null;
+	}
+	get value() {
+		return this.readValue();
+	}
+	start(execution) {
+		this.execution = execution;
+		this.reason = void 0;
+		this.status = "pending";
+		execution.then(() => {
+			if (this.execution !== execution) return;
+			this.execution = null;
+			this.status = "fulfilled";
+		}, (error) => {
+			if (this.execution !== execution) return;
+			this.execution = null;
+			this.reason = error;
+			this.status = "rejected";
+		});
+	}
+	then(onfulfilled, onrejected) {
+		switch (this.status) {
+			case "fulfilled": return Promise.resolve().then(() => this.readValue()).then(onfulfilled ?? void 0, onrejected ?? void 0);
+			case "rejected": return Promise.reject(this.reason).then(onfulfilled ?? void 0, onrejected ?? void 0);
+			default:
+				if (!this.execution) throw new Error(`fate: Pending request is missing its execution.`);
+				return this.execution.then(onfulfilled ?? void 0, onrejected ?? void 0);
+		}
+	}
+	catch(onrejected) {
+		return this.then(void 0, onrejected ?? void 0);
+	}
+	finally(onfinally) {
+		return this.then(async (value) => {
+			await onfinally?.();
+			return value;
+		}, async (error) => {
+			await onfinally?.();
+			throw error;
+		});
 	}
 };
-
 //#endregion
 //#region src/client.ts
 const getId = (record) => {
@@ -987,6 +1336,88 @@ const getId = (record) => {
 	return value;
 };
 const emptySet = /* @__PURE__ */ new Set();
+const emptyDispose = () => void 0;
+const dropCanonicalListIds = (listIds, ids) => {
+	if (!listIds || listIds.length === 0) return;
+	const canonicalIds = new Set(ids);
+	const next = listIds.filter((id) => !canonicalIds.has(id));
+	return next.length > 0 ? next : void 0;
+};
+const removeListId = (listIds, entityId) => listIds?.includes(entityId) ? listIds.filter((id) => id !== entityId) : listIds;
+const areArraysEqual = (left, right) => {
+	if (left === right) return true;
+	if (!left || !right || left.length !== right.length) return false;
+	return left.every((value, index) => value === right[index]);
+};
+const arePaginationStatesEqual = (left, right) => left === right || (!left || !right ? false : left.hasNext === right.hasNext && left.hasPrevious === right.hasPrevious && left.nextCursor === right.nextCursor && left.previousCursor === right.previousCursor);
+const areListStatesEqual = (left, right) => Boolean(left) && areArraysEqual(left?.ids, right.ids) && areArraysEqual(left?.cursors, right.cursors) && areArraysEqual(left?.liveAfterIds, right.liveAfterIds) && areArraysEqual(left?.liveBeforeIds, right.liveBeforeIds) && areArraysEqual(left?.pendingAfterIds, right.pendingAfterIds) && areArraysEqual(left?.pendingBeforeIds, right.pendingBeforeIds) && left?.backwardPageLimit === right.backwardPageLimit && left?.forwardPageLimit === right.forwardPageLimit && arePaginationStatesEqual(left?.pagination, right.pagination);
+const createNodeRefsForIds = (ids, current, options = {}) => {
+	if (options.reuseCurrentArray !== false && Array.isArray(current) && current.length === ids.length) {
+		let matches = true;
+		for (let index = 0; index < ids.length; index += 1) {
+			const value = current[index];
+			if (!isNodeRef(value) || getNodeRefId(value) !== ids[index]) {
+				matches = false;
+				break;
+			}
+		}
+		if (matches) return current;
+	}
+	const existingRefsById = /* @__PURE__ */ new Map();
+	if (Array.isArray(current)) {
+		for (const value of current) if (isNodeRef(value)) existingRefsById.set(getNodeRefId(value), value);
+	}
+	return ids.map((id) => existingRefsById.get(id) ?? createNodeRef(id));
+};
+const getConnectionPageLimit = (args, direction) => {
+	const value = direction === "forward" ? args?.first ?? args?.last : args?.last ?? args?.first;
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+};
+const isConnectionWindowFull = (listState, connection, direction) => {
+	const limit = getConnectionPageLimit(connection.args, direction);
+	return limit != null && listState.ids.length >= limit;
+};
+const hasConnectionPageCoverage = (listState, args, direction) => {
+	const limit = getConnectionPageLimit(args, direction);
+	const pagination = listState.pagination;
+	if (direction === "forward") {
+		if (pagination?.hasPrevious) return false;
+		return limit == null || listState.ids.length >= limit || listState.forwardPageLimit != null && listState.forwardPageLimit >= limit || pagination?.hasNext === false;
+	}
+	if (pagination?.hasNext) return false;
+	return limit == null || listState.ids.length >= limit || listState.backwardPageLimit != null && listState.backwardPageLimit >= limit || pagination?.hasPrevious === false;
+};
+const getPaginationMergeInfo = (args) => {
+	const paginationArgs = getPaginationArgsInfo(args);
+	return {
+		...paginationArgs,
+		pageLimit: getConnectionPageLimit(args, paginationArgs.direction)
+	};
+};
+const getConnectionBoundaryCursor = (listState, direction) => {
+	if (!listState.cursors || listState.cursors.length === 0) return;
+	return direction === "forward" ? listState.cursors.at(-1) : listState.cursors[0];
+};
+const markConnectionPageAvailable = (listState, direction) => {
+	const pagination = {
+		hasNext: Boolean(listState.pagination?.hasNext),
+		hasPrevious: Boolean(listState.pagination?.hasPrevious),
+		nextCursor: listState.pagination?.nextCursor,
+		previousCursor: listState.pagination?.previousCursor
+	};
+	const cursor = getConnectionBoundaryCursor(listState, direction);
+	if (direction === "forward") {
+		pagination.hasNext = true;
+		pagination.nextCursor = cursor ?? pagination.nextCursor;
+	} else {
+		pagination.hasPrevious = true;
+		pagination.previousCursor = cursor ?? pagination.previousCursor;
+	}
+	return {
+		...listState,
+		pagination
+	};
+};
 const setNestedValue = (target, key, value) => {
 	const path = key.split(".");
 	let current = target;
@@ -1002,32 +1433,10 @@ const setNestedValue = (target, key, value) => {
 		current = current[segment];
 	}
 };
-const serializeId = (value) => `${typeof value}:${String(value)}`;
-const getViewSignature = (view$1) => {
-	const viewNames = getViewNames(view$1);
-	return viewNames.size ? [...viewNames].sort().join(",") : "";
-};
-const getRequestCacheKey = (request) => {
-	const parts = [];
-	const names = Object.keys(request).sort();
-	for (const name of names) {
-		const item = request[name];
-		if (!item) continue;
-		if (isNodeItem(item)) {
-			parts.push(`node:${name}:${getViewSignature(item.view)}:${item.id}`);
-			continue;
-		}
-		if (isNodesItem(item)) {
-			parts.push(`node:${name}:${getViewSignature(item.view)}:${item.ids.map(serializeId).join(",")}`);
-			continue;
-		}
-		if (isQueryItem(item)) {
-			parts.push(`query:${name}:${getViewSignature(item.view)}:${item.args ? hashArgs(item.args) : ""}`);
-			continue;
-		}
-		parts.push(`list:${name}:${getViewSignature(item.list)}:${item.args ? hashArgs(item.args) : ""}`);
-	}
-	return parts.join("$");
+const omitUndefinedValues = (record) => {
+	const result = {};
+	for (const [key, value] of Object.entries(record)) if (value !== void 0) result[key] = value;
+	return result;
 };
 const groupSelectionByPrefix = (select) => {
 	if (select.size === 0) return /* @__PURE__ */ new Map();
@@ -1060,14 +1469,22 @@ var FateClient = class {
 		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.rootRequests = /* @__PURE__ */ new Map();
 		this.stalledRequests = /* @__PURE__ */ new Set();
+		this.gcPending = false;
+		this.gcScheduled = false;
 		this.store = new Store();
 		this.viewDataCache = new ViewDataCache();
+		this.liveConnectionInvalidationToken = 0;
 		this.actions = Object.create(null);
 		this.mutationMap = Object.create(null);
 		this.mutations = Object.create(null);
+		this.onLiveError = options.onLiveError;
+		this.operationLifetime = new OperationLifetime(options.gcReleaseBufferSize ?? 10);
 		this.roots = options.roots;
 		this.transport = options.transport;
 		this.types = new Map(options.types.map((entity) => [entity.type, {
@@ -1075,12 +1492,12 @@ var FateClient = class {
 			...entity
 		}]));
 		if (options.mutations) for (const [key, definition] of Object.entries(options.mutations)) {
-			const mutation$1 = wrapMutation(this, {
+			const mutation = wrapMutation(this, {
 				...definition,
 				key
 			});
-			this.mutationMap[key] = mutation$1;
-			setNestedValue(this.mutations, key, mutation$1);
+			this.mutationMap[key] = mutation;
+			setNestedValue(this.mutations, key, mutation);
 			setNestedValue(this.actions, key, async (_previousState, data) => data === "reset" ? null : await this.mutationMap[key](data));
 		}
 		this.initializeParentLists();
@@ -1120,20 +1537,50 @@ var FateClient = class {
 		}
 		lists.add(key);
 	}
-	insertIntoRootLists(type, entityId, insert) {
+	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 ?? [];
+		if (listState.ids.includes(entityId) || pendingBeforeIds.includes(entityId) || pendingAfterIds.includes(entityId)) return {
+			list: listState,
+			pending: false
+		};
+		if (insert === "before" ? Boolean(listState.pagination?.hasPrevious) : Boolean(listState.pagination?.hasNext)) return {
+			list: insert === "before" ? {
+				...listState,
+				pendingBeforeIds: [entityId, ...pendingBeforeIds]
+			} : {
+				...listState,
+				pendingAfterIds: [...pendingAfterIds, entityId]
+			},
+			pending: true
+		};
+		const ids = insert === "before" ? [entityId, ...listState.ids] : [...listState.ids, entityId];
+		const cursors = listState.cursors ? insert === "before" ? [void 0, ...listState.cursors] : [...listState.cursors, void 0] : listState.cursors;
+		return {
+			list: {
+				...listState,
+				cursors,
+				ids
+			},
+			pending: false
+		};
+	}
+	insertIntoRootLists(type, entityId, insert, listSnapshots) {
 		if (insert === "none") return;
 		const listNames = this.rootLists.get(type);
 		if (!listNames) return;
 		for (const key of listNames) {
 			const listState = this.store.getListState(key);
-			if (!listState || listState.ids.includes(entityId)) continue;
-			const ids = insert === "before" ? [entityId, ...listState.ids] : [...listState.ids, entityId];
-			const cursors = listState.cursors ? insert === "before" ? [void 0, ...listState.cursors] : [...listState.cursors, void 0] : listState.cursors;
-			this.store.setList(key, {
-				cursors,
-				ids,
-				pagination: listState.pagination
-			});
+			if (!listState) continue;
+			const next = this.applyListInsert(listState, entityId, insert).list;
+			if (next === listState) continue;
+			this.snapshotList(key, listSnapshots);
+			this.store.setList(key, next);
 		}
 	}
 	getTypeConfig(type) {
@@ -1152,63 +1599,78 @@ var FateClient = class {
 		} : argsPayload ? { args: argsPayload } : input;
 		return await this.transport.mutate(key, requestInput, select);
 	}
-	write(type, data, select, snapshots, plan, pathPrefix = null, blockedMask, insert) {
-		return this.writeEntity(type, data, select, snapshots, plan, pathPrefix, blockedMask, insert);
+	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$1, snapshots, listSnapshots) {
-		const entityId = toEntityId(type, id$1);
+	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$1, snapshot) {
-		this.viewDataCache.invalidate(id$1);
-		this.store.restore(id$1, snapshot);
+	restore(id, snapshot) {
+		this.viewDataCache.invalidate(id);
+		this.store.restore(id, snapshot);
 	}
 	restoreList(name, list) {
 		this.store.restoreList(name, list);
 	}
-	ref(type, id$1, view$1) {
-		return createRef(type, id$1, view$1);
+	stableRefWithViewNames(type, id, viewNames) {
+		const entityId = toEntityId(type, id);
+		const key = `${typeof id}:${String(id)}:${[...viewNames].sort().join(",")}`;
+		let refs = this.stableRefs.get(entityId);
+		if (!refs) {
+			refs = /* @__PURE__ */ new Map();
+			this.stableRefs.set(entityId, refs);
+		}
+		const existing = refs.get(key);
+		if (existing) return existing;
+		const ref = createRefWithViewNames(type, id, viewNames);
+		refs.set(key, ref);
+		return ref;
+	}
+	ref(type, id, view) {
+		return this.stableRefWithViewNames(type, id, getViewNames(view));
 	}
 	rootListRef(entityId, rootView) {
-		const { id: id$1, type } = parseEntityId(entityId);
-		return createRef(type, id$1, rootView, { root: true });
+		const { id, type } = parseEntityId(entityId);
+		return this.stableRefWithViewNames(type, id, getRootViewNames(rootView));
 	}
-	readView(view$1, ref) {
-		const id$1 = ref.id;
+	readView(view, ref) {
+		const id = ref.id;
 		const type = ref.__typename;
-		if (id$1 == null) {
+		if (id == null) {
 			const received = Object.keys(ref).length > 0 ? `'${JSON.stringify(ref)}'` : "an empty object";
 			throw new Error(`fate: Invalid view reference. Expected 'id' to be provided as part of the reference, received ${received}. Did you forget to spread the correct view into its parent or pass the wrong ref to 'useView'?`);
 		}
 		if (type == null) throw new Error(`fate: Invalid view reference. Expected '__typename' to be provided as part of the reference, received '${JSON.stringify(ref)}'.`);
-		const entityId = toEntityId(type, id$1);
+		const entityId = toEntityId(type, id);
 		const resolvedEntityId = this.optimisticEntityResolutions.get(entityId) ?? null;
 		if (resolvedEntityId && resolvedEntityId !== entityId) {
 			const { id: resolvedId, type: resolvedType } = parseEntityId(resolvedEntityId);
-			return this.readView(view$1, createRef(resolvedType, resolvedId, view$1));
+			return this.readView(view, this.stableRefWithViewNames(resolvedType, resolvedId, getViewNames(view)));
 		}
-		const viewNames = getViewNames(view$1);
+		const viewNames = getViewNames(view);
 		const refViews = ref[ViewsTag];
 		if (!refViews || ![...viewNames].every((name) => refViews.has(name))) {
 			const received = refViews ? [...refViews].join(", ") : JSON.stringify(ref);
 			throw new Error(`fate: Invalid view reference. Expected the provided ref to include the view(s) '${[...viewNames].join("', '")}', received '${received}'. You can fix this issue by spreading the correct view into its parent so fate can create the correct view refs for you.`);
 		}
-		const cached = this.viewDataCache.get(entityId, view$1, ref);
+		const cached = this.viewDataCache.get(entityId, view, ref);
 		if (cached) return cached;
-		const plan = getSelectionPlan(view$1, ref);
+		const plan = getSelectionPlan(view, ref);
 		const selectedPaths = plan.paths;
 		const missing = this.store.missingForSelection(entityId, selectedPaths);
 		const resolveSnapshot = () => {
-			const resolvedView = this.readViewSelection(view$1, ref, entityId, plan);
+			const resolvedView = this.readViewSelection(view, ref, entityId, plan);
 			const thenable = {
 				status: "fulfilled",
 				then: (onfulfilled, onrejected) => Promise.resolve(resolvedView).then(onfulfilled, onrejected),
 				value: resolvedView
 			};
-			this.viewDataCache.set(entityId, view$1, ref, thenable, new Set(resolvedView.coverage.map(([id$2]) => id$2)));
+			this.viewDataCache.set(entityId, view, ref, thenable, new Set(resolvedView.coverage.map(([id]) => id)));
 			return thenable;
 		};
 		if (missing.size === 0) {
@@ -1221,38 +1683,350 @@ var FateClient = class {
 			if (pendingOptimistic) {
 				const pending = this.pending.get(key);
 				if (pending) return pending;
-				const promise$1 = Promise.all(pendingOptimistic).then(() => this.readView(view$1, ref)).finally(() => this.pending.delete(key));
-				this.pending.set(key, promise$1);
-				return promise$1;
+				const promise = Promise.all(pendingOptimistic).then(() => this.readView(view, ref)).finally(() => this.pending.delete(key));
+				this.pending.set(key, promise);
+				return promise;
 			}
 			if (this.stalledRequests.has(key)) return resolveSnapshot();
 			const pendingPromise = this.pending.get(key) || null;
 			if (pendingPromise) return pendingPromise;
-			const promise = this.fetchByIdAndNormalize(type, [id$1], missing, plan).finally(() => this.pending.delete(key)).then(() => {
+			const promise = this.fetchByIdAndNormalize(type, [id], missing, plan).finally(() => this.pending.delete(key)).then(() => {
 				if (this.store.missingForSelection(entityId, selectedPaths).size > 0) {
 					this.stalledRequests.add(key);
 					return resolveSnapshot();
 				}
 				this.stalledRequests.delete(key);
-				return this.readView(view$1, ref);
+				return this.readView(view, ref);
 			});
 			this.pending.set(key, promise);
 			return promise;
 		}
 		return resolveSnapshot();
 	}
+	assertLiveViewSupport() {
+		if (!this.transport.subscribeById) throw new Error(`fate: transport does not support live views. Please provide a 'subscribeById' implementation in your transport.`);
+	}
+	assertLiveConnectionSupport() {
+		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.assertLiveViewSupport();
+		const id = ref.id;
+		const type = ref.__typename;
+		if (id == null) throw new Error(`fate: Invalid live view reference. Expected 'id' to be provided as part of the reference.`);
+		if (type == null) throw new Error(`fate: Invalid live view reference. Expected '__typename' to be provided as part of the reference.`);
+		const viewNames = getViewNames(view);
+		const refViews = ref[ViewsTag];
+		if (!refViews || ![...viewNames].every((name) => refViews.has(name))) {
+			const received = refViews ? [...refViews].join(", ") : JSON.stringify(ref);
+			throw new Error(`fate: Invalid live view reference. Expected the provided ref to include the view(s) '${[...viewNames].join("', '")}', received '${received}'.`);
+		}
+		const entityId = toEntityId(type, id);
+		const plan = getSelectionPlan(view, ref);
+		const key = this.liveSubscriptionKey(entityId, plan);
+		const existing = this.liveSubscriptions.get(key);
+		if (existing) {
+			existing.count += 1;
+			existing.releaseScheduled = false;
+			return () => {
+				this.releaseLiveSubscription(key);
+			};
+		}
+		const args = resolvedArgsFromPlan(plan);
+		let unsubscribe;
+		try {
+			unsubscribe = this.transport.subscribeById(type, id, plan.paths, args, {
+				onData: (record, liveSelect) => {
+					if (!record || typeof record !== "object") return;
+					const pendingMask = this.getPendingOptimisticMask(entityId);
+					const select = new Set(liveSelect ?? plan.paths);
+					const selection = this.filterSelectionForPendingOptimistics(entityId, select);
+					this.write(type, record, selection, void 0, plan, null, pendingMask, "none");
+				},
+				onDelete: (deletedId) => {
+					this.deleteRecord(type, deletedId ?? id);
+				},
+				onError: (error) => this.reportLiveError(error)
+			});
+		} catch (error) {
+			this.reportLiveError(error);
+			return emptyDispose;
+		}
+		this.liveSubscriptions.set(key, {
+			count: 1,
+			unsubscribe
+		});
+		return () => {
+			this.releaseLiveSubscription(key);
+		};
+	}
+	subscribeLiveListView(view, connection) {
+		this.assertLiveConnectionSupport();
+		const plan = getSelectionPlan(view, null);
+		const connectionArgs = filterConnectionArgs(connection.args);
+		const selectionArgs = resolvedArgsFromPlan(plan);
+		const key = this.liveConnectionSubscriptionKey(connection, plan, connectionArgs);
+		const existing = this.liveSubscriptions.get(key);
+		if (existing) {
+			existing.count += 1;
+			existing.releaseScheduled = false;
+			return () => {
+				this.releaseLiveSubscription(key);
+			};
+		}
+		let unsubscribe;
+		try {
+			unsubscribe = this.transport.subscribeConnection(connection.procedure, connection.type, connectionArgs, plan.paths, selectionArgs, {
+				onError: (error) => this.reportLiveError(error),
+				onEvent: (event) => {
+					this.applyLiveConnectionEvent(view, connection, plan, event);
+				}
+			});
+		} catch (error) {
+			this.reportLiveError(error);
+			return emptyDispose;
+		}
+		this.liveSubscriptions.set(key, {
+			count: 1,
+			unsubscribe
+		});
+		return () => {
+			this.releaseLiveSubscription(key);
+		};
+	}
+	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);
+	}
+	invalidateLiveConnection(view, connection) {
+		const token = ++this.liveConnectionInvalidationToken;
+		this.liveConnectionInvalidations.set(connection.key, token);
+		const previous = this.store.getListState(connection.key);
+		this.store.restoreList(connection.key, void 0);
+		this.loadConnection(view, connection, connection.args ?? {}).then(() => {
+			if (this.liveConnectionInvalidations.get(connection.key) === token) this.liveConnectionInvalidations.delete(connection.key);
+		}).catch((error) => {
+			if (this.liveConnectionInvalidations.get(connection.key) === token) {
+				this.store.restoreList(connection.key, previous);
+				this.liveConnectionInvalidations.delete(connection.key);
+			}
+			this.reportLiveError(error);
+		});
+	}
+	deleteConnectionEdge(connection, entityId) {
+		const listState = this.store.getListState(connection.key);
+		if (!listState) {
+			this.syncNestedConnectionOwnerField(connection, entityId, void 0, "delete");
+			return;
+		}
+		const ids = [];
+		const cursors = listState.cursors ? [] : void 0;
+		let changed = false;
+		listState.ids.forEach((id, index) => {
+			if (id === entityId) {
+				changed = true;
+				return;
+			}
+			ids.push(id);
+			if (cursors) cursors.push(listState.cursors?.[index]);
+		});
+		const liveAfterIds = removeListId(listState.liveAfterIds, entityId);
+		const liveBeforeIds = removeListId(listState.liveBeforeIds, entityId);
+		const pendingAfterIds = removeListId(listState.pendingAfterIds, entityId);
+		const pendingBeforeIds = removeListId(listState.pendingBeforeIds, entityId);
+		changed = changed || liveAfterIds?.length !== listState.liveAfterIds?.length || liveBeforeIds?.length !== listState.liveBeforeIds?.length || pendingAfterIds?.length !== listState.pendingAfterIds?.length || pendingBeforeIds?.length !== listState.pendingBeforeIds?.length;
+		if (changed) {
+			const nextListState = {
+				...listState,
+				cursors,
+				ids,
+				liveAfterIds,
+				liveBeforeIds,
+				pendingAfterIds,
+				pendingBeforeIds
+			};
+			this.store.setList(connection.key, nextListState);
+			this.syncNestedConnectionOwnerField(connection, entityId, nextListState, "delete");
+			return;
+		}
+		this.syncNestedConnectionOwnerField(connection, entityId, listState, "delete");
+	}
+	insertConnectionEdge(key, entityId, cursor, type, targetCursor, view, connection) {
+		const listState = this.store.getListState(key) ?? { ids: [] };
+		const isAppendEvent = type === "appendEdge" || type === "appendNode";
+		const isPrependEvent = type === "prependEdge" || type === "prependNode";
+		const appendMode = connection.live?.append ?? "edge";
+		const prependMode = connection.live?.prepend ?? "edge";
+		if (isAppendEvent && listState.pendingAfterIds?.includes(entityId) || isPrependEvent && listState.pendingBeforeIds?.includes(entityId)) {
+			this.syncNestedConnectionOwnerField(connection, entityId, listState, "insert");
+			return;
+		}
+		const visibleIndex = listState.ids.indexOf(entityId);
+		if (visibleIndex >= 0 && (isAppendEvent && appendMode === "visible" || isPrependEvent && prependMode === "visible")) {
+			const nextListState = cursor === void 0 ? listState : {
+				...listState,
+				cursors: listState.ids.map((_, index) => index === visibleIndex ? cursor : listState.cursors?.[index])
+			};
+			if (nextListState !== listState) this.store.setList(key, nextListState);
+			this.syncNestedConnectionOwnerField(connection, entityId, nextListState, "insert");
+			return;
+		}
+		const withoutExisting = this.removeEntityFromListState(listState, entityId);
+		const keepLiveBeforeHidden = isPrependEvent && prependMode !== "visible" && (Boolean(withoutExisting.pagination?.hasPrevious) || isConnectionWindowFull(withoutExisting, connection, "backward"));
+		const keepLiveAfterHidden = isAppendEvent && appendMode !== "visible" && (Boolean(withoutExisting.pagination?.hasNext) || isConnectionWindowFull(withoutExisting, connection, "forward"));
+		const keepVisibleBeforePending = isPrependEvent && prependMode === "visible" && (withoutExisting.pagination?.hasPrevious === true || withoutExisting.pagination?.hasPrevious === void 0 && isConnectionWindowFull(withoutExisting, connection, "backward"));
+		const keepVisibleAfterPending = isAppendEvent && appendMode === "visible" && (withoutExisting.pagination?.hasNext === true || withoutExisting.pagination?.hasNext === void 0 && isConnectionWindowFull(withoutExisting, connection, "forward"));
+		if (keepLiveBeforeHidden) {
+			const nextList = markConnectionPageAvailable(withoutExisting, "backward");
+			const nextListState = {
+				...nextList,
+				liveBeforeIds: [entityId, ...nextList.liveBeforeIds ?? []]
+			};
+			this.store.setList(key, nextListState);
+			this.syncNestedConnectionOwnerField(connection, entityId, nextListState, "insert");
+			return;
+		}
+		if (keepLiveAfterHidden) {
+			const nextList = markConnectionPageAvailable(withoutExisting, "forward");
+			const nextListState = {
+				...nextList,
+				liveAfterIds: [...nextList.liveAfterIds ?? [], entityId]
+			};
+			this.store.setList(key, nextListState);
+			this.syncNestedConnectionOwnerField(connection, entityId, nextListState, "insert");
+			return;
+		}
+		if (keepVisibleBeforePending) {
+			const nextList = markConnectionPageAvailable(withoutExisting, "backward");
+			const nextListState = {
+				...nextList,
+				pendingBeforeIds: [entityId, ...nextList.pendingBeforeIds ?? []]
+			};
+			this.store.setList(key, nextListState);
+			this.syncNestedConnectionOwnerField(connection, entityId, nextListState, "insert");
+			return;
+		}
+		if (keepVisibleAfterPending) {
+			const nextList = markConnectionPageAvailable(withoutExisting, "forward");
+			const nextListState = {
+				...nextList,
+				pendingAfterIds: [...nextList.pendingAfterIds ?? [], entityId]
+			};
+			this.store.setList(key, nextListState);
+			this.syncNestedConnectionOwnerField(connection, entityId, nextListState, "insert");
+			return;
+		}
+		const index = this.getConnectionInsertIndex(withoutExisting, type, targetCursor);
+		if (index == null) {
+			this.invalidateLiveConnection(view, connection);
+			return;
+		}
+		const ids = [...withoutExisting.ids];
+		ids.splice(index, 0, entityId);
+		const cursors = Boolean(withoutExisting.cursors) || cursor !== void 0 ? [...withoutExisting.cursors ?? []] : void 0;
+		if (cursors) {
+			while (cursors.length < withoutExisting.ids.length) cursors.push(void 0);
+			cursors.splice(index, 0, cursor);
+		}
+		const nextListState = {
+			...withoutExisting,
+			cursors,
+			ids,
+			liveAfterIds: removeListId(withoutExisting.liveAfterIds, entityId),
+			liveBeforeIds: removeListId(withoutExisting.liveBeforeIds, entityId)
+		};
+		this.store.setList(key, nextListState);
+		this.syncNestedConnectionOwnerField(connection, entityId, nextListState, "insert");
+	}
+	syncNestedConnectionOwnerField(connection, entityId, listState, action) {
+		if (connection.root) return;
+		const owner = this.store.read(connection.owner);
+		const current = Array.isArray(owner?.[connection.field]) ? owner?.[connection.field] : [];
+		const currentIds = current.map((item) => isNodeRef(item) ? getNodeRefId(item) : null).filter((id) => id != null);
+		const nextIds = currentIds.filter((id) => id !== entityId);
+		if (action === "insert" && listState) {
+			const visibleIds = getListEntries(listState).map(({ id }) => id);
+			const visibleIndex = visibleIds.indexOf(entityId);
+			if (visibleIndex >= 0) {
+				const nextIndexById = new Map(nextIds.map((id, index) => [id, index]));
+				let insertIndex = null;
+				for (let index = visibleIndex - 1; index >= 0; index -= 1) {
+					const currentIndex = nextIndexById.get(visibleIds[index]);
+					if (currentIndex != null) {
+						insertIndex = currentIndex + 1;
+						break;
+					}
+				}
+				if (insertIndex == null) for (let index = visibleIndex + 1; index < visibleIds.length; index += 1) {
+					const currentIndex = nextIndexById.get(visibleIds[index]);
+					if (currentIndex != null) {
+						insertIndex = currentIndex;
+						break;
+					}
+				}
+				nextIds.splice(insertIndex ?? (visibleIndex === 0 ? 0 : nextIds.length), 0, entityId);
+			}
+		}
+		if (currentIds.length === nextIds.length && currentIds.every((id, index) => id === nextIds[index])) return;
+		this.viewDataCache.invalidate(connection.owner);
+		this.store.merge(connection.owner, { [connection.field]: createNodeRefsForIds(nextIds, current) }, [connection.field]);
+	}
+	getConnectionInsertIndex(listState, type, targetCursor) {
+		if (type === "prependEdge" || type === "prependNode") return 0;
+		if (type === "appendEdge" || type === "appendNode") return listState.ids.length;
+		if (targetCursor && listState.cursors) {
+			const index = listState.cursors.indexOf(targetCursor);
+			if (index >= 0) return type === "insertEdgeBefore" ? index : index + 1;
+		}
+		return null;
+	}
+	removeEntityFromListState(listState, entityId) {
+		const ids = [];
+		const cursors = listState.cursors ? [] : void 0;
+		listState.ids.forEach((id, index) => {
+			if (id === entityId) return;
+			ids.push(id);
+			if (cursors) cursors.push(listState.cursors?.[index]);
+		});
+		return {
+			...listState,
+			cursors,
+			ids,
+			liveAfterIds: removeListId(listState.liveAfterIds, entityId),
+			liveBeforeIds: removeListId(listState.liveBeforeIds, entityId),
+			pendingAfterIds: removeListId(listState.pendingAfterIds, entityId),
+			pendingBeforeIds: removeListId(listState.pendingBeforeIds, entityId)
+		};
+	}
 	mergeListState(previous, incomingIds, incomingCursors, incomingPagination, options) {
 		const existingIds = previous?.ids ?? [];
 		const existingSet = new Set(existingIds);
 		const isBackward = options.direction === "backward";
 		const mergeIds = () => {
 			if (!previous) return [...incomingIds];
+			if (!options.hasCursorArg && options.replace) return [...incomingIds];
 			if (!options.hasCursorArg) {
 				const incomingSet = new Set(incomingIds);
-				const remaining = existingIds.filter((id$1) => !incomingSet.has(id$1));
+				const remaining = existingIds.filter((id) => !incomingSet.has(id));
 				return isBackward ? [...remaining, ...incomingIds] : [...incomingIds, ...remaining];
 			}
-			const newIds = incomingIds.filter((id$1) => !existingSet.has(id$1));
+			const newIds = incomingIds.filter((id) => !existingSet.has(id));
 			return isBackward ? [...newIds, ...existingIds] : [...existingIds, ...newIds];
 		};
 		const ids = mergeIds();
@@ -1264,18 +2038,25 @@ var FateClient = class {
 		incomingCursors.forEach((cursor, index) => {
 			if (cursor !== void 0) cursorMap.set(incomingIds[index], cursor);
 		});
-		const cursors = hasIncomingCursor || Boolean(previous?.cursors) || options.hasCursorArg ? ids.map((id$1) => cursorMap.get(id$1)) : void 0;
+		const cursors = hasIncomingCursor || Boolean(previous?.cursors) || options.hasCursorArg ? ids.map((id) => cursorMap.get(id)) : void 0;
 		const previousPagination = previous?.pagination;
 		const newPagination = incomingPagination;
+		const pagination = previousPagination || newPagination ? {
+			hasNext: !!(newPagination?.hasNext ?? previousPagination?.hasNext),
+			hasPrevious: !!(newPagination?.hasPrevious ?? previousPagination?.hasPrevious),
+			nextCursor: newPagination?.nextCursor ?? previousPagination?.nextCursor,
+			previousCursor: newPagination?.previousCursor ?? previousPagination?.previousCursor
+		} : void 0;
 		return {
+			backwardPageLimit: !options.hasCursorArg && isBackward && options.pageLimit != null ? Math.max(previous?.backwardPageLimit ?? 0, options.pageLimit) : previous?.backwardPageLimit,
 			cursors,
+			forwardPageLimit: !options.hasCursorArg && !isBackward && options.pageLimit != null ? Math.max(previous?.forwardPageLimit ?? 0, options.pageLimit) : previous?.forwardPageLimit,
 			ids,
-			pagination: previousPagination || newPagination ? {
-				hasNext: !!(newPagination?.hasNext ?? previousPagination?.hasNext),
-				hasPrevious: !!(newPagination?.hasPrevious ?? previousPagination?.hasPrevious),
-				nextCursor: newPagination?.nextCursor ?? previousPagination?.nextCursor,
-				previousCursor: newPagination?.previousCursor ?? previousPagination?.previousCursor
-			} : void 0
+			liveAfterIds: dropCanonicalListIds(previous?.liveAfterIds, ids),
+			liveBeforeIds: dropCanonicalListIds(previous?.liveBeforeIds, ids),
+			pagination,
+			pendingAfterIds: dropCanonicalListIds(previous?.pendingAfterIds, ids),
+			pendingBeforeIds: dropCanonicalListIds(previous?.pendingBeforeIds, ids)
 		};
 	}
 	registerPendingOptimisticMutation(entityId, promise) {
@@ -1291,10 +2072,12 @@ var FateClient = class {
 			if (!current) return;
 			current.delete(trackedPromise);
 			if (current.size === 0) this.pendingOptimisticMutations.delete(entityId);
+			this.runPendingGarbageCollection();
 		});
 	}
 	resolveOptimisticEntity(optimisticEntityId, resolvedEntityId) {
 		this.optimisticEntityResolutions.set(optimisticEntityId, resolvedEntityId);
+		this.store.replaceListEntityId(optimisticEntityId, resolvedEntityId);
 	}
 	registerOptimisticUpdate(entityId, select) {
 		if (!entityId || select.size === 0) return null;
@@ -1322,6 +2105,7 @@ var FateClient = class {
 			entityTokens.delete(token);
 			if (entityTokens.size === 0) this.optimisticByEntity.delete(entry.entityId);
 		}
+		this.runPendingGarbageCollection();
 	}
 	getPendingOptimisticMask(entityId, options = {}) {
 		if (!entityId) return null;
@@ -1349,43 +2133,40 @@ var FateClient = class {
 		for (const path of select) if (!isCovered(pendingMask, path)) filtered.add(path);
 		return filtered;
 	}
-	async loadConnection(view$1, connection, args, options = {}) {
+	async loadConnection(view, connection, args, options = {}) {
 		const direction = options.direction ?? "forward";
 		if (connection.root) {
 			if (!this.transport.fetchList) throw new Error(`fate: transport does not support list fetching. Please add support for 'fetchList' in your transport.`);
-			const requestArgs$1 = {
+			const requestArgs = omitUndefinedValues({
 				...connection.args,
 				...args
-			};
-			const { argsPayload: argsPayload$1, plan: plan$1 } = this.resolveSelection(view$1, requestArgs$1);
-			const { items, pagination } = await this.transport.fetchList(connection.field, plan$1.paths, argsPayload$1);
+			});
+			const { argsPayload, plan } = resolveSelectionPlan(view, requestArgs);
+			const { items, pagination } = await this.transport.fetchList(connection.field, plan.paths, argsPayload);
 			if (!items) return this.store.getListState(connection.key);
-			const incomingIds$1 = [];
-			const incomingCursors$1 = [];
+			const incomingIds = [];
+			const incomingCursors = [];
 			for (const entry of items) {
-				const id$1 = this.write(connection.type, entry.node, plan$1.paths, void 0, plan$1, null, null, "after");
-				incomingIds$1.push(id$1);
-				incomingCursors$1.push(entry.cursor);
+				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$1 = this.store.getListState(connection.key);
-			const argsValue = args;
-			const hasCursorArg = Boolean(argsValue && ("after" in argsValue || "before" in argsValue || "cursor" in argsValue));
-			const isBackward = Boolean(argsValue && (argsValue.before !== void 0 || argsValue.last !== void 0));
-			const nextListState$1 = this.mergeListState(previous$1, incomingIds$1, incomingCursors$1, pagination, {
-				direction: isBackward ? "backward" : "forward",
-				hasCursorArg
+			const previous = this.store.getListState(connection.key);
+			const nextListState = this.mergeListState(previous, incomingIds, incomingCursors, pagination, {
+				...getPaginationMergeInfo(requestArgs),
+				replace: true
 			});
-			this.registerRootList(connection.type, connection.key);
-			this.store.setList(connection.key, nextListState$1);
-			return nextListState$1;
+			if (!connection.args) this.registerRootList(connection.type, connection.key);
+			this.store.setList(connection.key, nextListState);
+			return nextListState;
 		}
 		const owner = parseEntityId(connection.owner);
-		const requestArgs = {
+		const requestArgs = omitUndefinedValues({
 			...connection.args,
 			...args
-		};
+		});
 		if (requestArgs.id === void 0 && owner.id) requestArgs.id = owner.id;
-		const { argsPayload, plan } = this.resolveSelection(view$1, requestArgs);
+		const { argsPayload, plan } = resolveSelectionPlan(view, requestArgs);
 		const nodeSelection = plan.paths;
 		const scopedArgsPayload = argsPayload ? scopeArgsPayload(argsPayload, connection.field) : void 0;
 		const parentSelection = /* @__PURE__ */ new Set();
@@ -1408,22 +2189,24 @@ var FateClient = class {
 		if (!nodeType) throw new Error(`fate: Could not find node type for '${owner.type}.${connection.field}'.`);
 		for (const entry of connectionPayload.items) {
 			const { node } = entry;
-			const id$1 = this.write(nodeType, node, nodeSelection, void 0, plan);
-			incomingIds.push(id$1);
+			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$1) => !previousSet.has(id$1));
+		const newIds = incomingIds.filter((id) => !previousSet.has(id));
 		const nextListState = this.mergeListState(previous, incomingIds, incomingCursors, connectionPayload.pagination, {
+			...getPaginationMergeInfo(argsPayload),
 			direction,
-			hasCursorArg: true
+			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 = newIds.map((id$1) => createNodeRef(id$1));
+		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]);
@@ -1431,41 +2214,179 @@ var FateClient = class {
 	}
 	request(request, options) {
 		const mode = options?.mode ?? "cache-first";
-		const requestKey = getRequestCacheKey(request);
+		return this.requestWithDescriptor(this.createRequestDescriptor(request), mode, { revalidateExisting: true });
+	}
+	requestForRender(request, options) {
+		return this.prepareRequestForRender(request, options).promise;
+	}
+	prepareRequestForRender(request, options) {
+		const mode = options?.mode ?? "cache-first";
+		const descriptor = this.createRequestDescriptor(request);
+		return {
+			promise: this.requestWithDescriptor(descriptor, mode, { revalidateExisting: false }),
+			requestKey: descriptor.key
+		};
+	}
+	requestWithDescriptor(descriptor, mode, { revalidateExisting }) {
+		const requestKey = descriptor.key;
 		const existingRequest = this.requests.get(requestKey)?.get(mode);
-		if (existingRequest) return existingRequest;
-		let promise;
-		switch (mode) {
-			case "stale-while-revalidate":
-				promise = this.handleStoreAndNetworkRequest(request);
-				break;
-			case "cache-first":
-			case "network-only":
-			default:
-				promise = this.executeRequest(request, mode === "network-only" ? { fetchAll: true } : void 0).then(() => this.getRequestResult(request));
-				break;
+		if (existingRequest) {
+			if (revalidateExisting && existingRequest.status !== "pending" && (mode === "network-only" || mode === "stale-while-revalidate" || mode === "cache-first" && (existingRequest.status === "rejected" || existingRequest.status === "fulfilled" && !this.hasRequestData(existingRequest.descriptor)))) this.executeRequestHandle(existingRequest, mode);
+			return existingRequest;
 		}
+		const handle = new FateRequestPromise(descriptor, () => this.getRequestResultFromDescriptor(descriptor));
 		let requests = this.requests.get(requestKey);
 		if (!requests) {
 			requests = /* @__PURE__ */ new Map();
 			this.requests.set(requestKey, requests);
 		}
-		requests.set(mode, promise);
-		return promise;
+		requests.set(mode, handle);
+		this.executeRequestHandle(handle, mode);
+		return handle;
 	}
 	releaseRequest(request, mode) {
-		const requestKey = getRequestCacheKey(request);
+		this.releaseRequestKey(this.createRequestDescriptor(request).key, mode);
+	}
+	releaseRequestKey(requestKey, mode) {
 		const requests = this.requests.get(requestKey);
 		if (!requests) return;
 		requests.delete(mode);
 		if (requests.size === 0) this.requests.delete(requestKey);
 	}
+	retainRequestKey(requestKey, mode) {
+		const requests = this.requests.get(requestKey);
+		const descriptor = (mode ? requests?.get(mode)?.descriptor : void 0) ?? requests?.values().next().value?.descriptor;
+		return descriptor ? this.operationLifetime.retain(descriptor, () => this.scheduleGarbageCollection()) : { dispose: emptyDispose };
+	}
+	/**
+	* Keeps the records and lists reachable from a request alive until the
+	* returned handle is disposed.
+	*
+	* `useRequest` calls this automatically while the component is mounted.
+	* Use it directly for non-React request lifetimes, tests, or preloaded data
+	* that must survive manual garbage collection.
+	*/
+	retain(request) {
+		return this.operationLifetime.retain(this.createRequestDescriptor(request), () => this.scheduleGarbageCollection());
+	}
+	scheduleGarbageCollection() {
+		if (this.gcScheduled) return;
+		this.gcScheduled = true;
+		queueMicrotask(() => {
+			this.gcScheduled = false;
+			this.gc();
+		});
+	}
+	/**
+	* Removes records and lists that are not reachable from retained requests or
+	* the release buffer.
+	*
+	* Garbage collection is scheduled automatically when retained requests are
+	* released. Calling this method manually is mainly useful in tests and custom
+	* memory-management flows.
+	*/
+	gc() {
+		if (this.hasActiveOptimisticUpdates()) {
+			this.gcPending = true;
+			return;
+		}
+		this.gcPending = false;
+		const markedLists = /* @__PURE__ */ new Set();
+		const markedRecords = /* @__PURE__ */ new Set();
+		const queue = [];
+		const markRecord = (entityId) => {
+			if (!entityId || markedRecords.has(entityId)) return;
+			markedRecords.add(entityId);
+			queue.push(entityId);
+		};
+		const markList = (key) => {
+			markedLists.add(key);
+			const listState = this.store.getListState(key);
+			if (!listState) return;
+			for (const id of listState.pendingBeforeIds ?? []) markRecord(id);
+			for (const id of listState.ids) markRecord(id);
+			for (const id of listState.pendingAfterIds ?? []) markRecord(id);
+		};
+		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));
+				continue;
+			}
+			if (item.kind === "query") {
+				markRecord(this.rootRequests.get(item.queryKey));
+				continue;
+			}
+			if (item.kind === "list") markList(item.listKey);
+		}
+		for (let queueIndex = 0; queueIndex < queue.length; queueIndex += 1) {
+			const entityId = queue[queueIndex];
+			if (!entityId) continue;
+			const record = this.store.read(entityId);
+			if (!record) continue;
+			this.markRecordReferences(record, markRecord);
+			const { type } = parseEntityId(entityId);
+			const config = this.types.get(type);
+			if (!config?.fields) continue;
+			for (const [field, descriptor] of Object.entries(config.fields)) {
+				if (!descriptor || descriptor === "scalar" || !("listOf" in descriptor)) continue;
+				for (const [listKey] of this.store.getListsForField(entityId, field)) markList(listKey);
+			}
+		}
+		const swept = this.store.collectGarbage(markedRecords, markedLists, { onRecordDeleted: (id) => {
+			this.viewDataCache.invalidate(id);
+			this.stableRefs.delete(id);
+			this.clearStalledRequestsForEntity(id);
+		} });
+		if (swept.records.size > 0) {
+			for (const [key, entityId] of this.rootRequests.entries()) if (entityId && swept.records.has(entityId)) this.rootRequests.delete(key);
+		}
+		if (swept.lists.size > 0) for (const [type, keys] of this.rootLists.entries()) {
+			for (const key of swept.lists) keys.delete(key);
+			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);
+	}
+	markRecordReferences(record, markRecord) {
+		const seen = /* @__PURE__ */ new Set();
+		const walk = (value) => {
+			if (isNodeRef(value)) {
+				markRecord(getNodeRefId(value));
+				return;
+			}
+			if (!value || typeof value !== "object") return;
+			if (seen.has(value)) return;
+			seen.add(value);
+			if (Array.isArray(value)) {
+				for (const item of value) walk(item);
+				return;
+			}
+			for (const child of Object.values(value)) walk(child);
+		};
+		walk(record);
+	}
+	hasActiveOptimisticUpdates() {
+		return this.optimisticMasks.size > 0 || this.optimisticByEntity.size > 0 || this.pendingOptimisticMutations.size > 0;
+	}
+	runPendingGarbageCollection() {
+		if (this.gcPending && !this.hasActiveOptimisticUpdates()) this.gc();
+	}
 	async handleStoreAndNetworkRequest(request) {
 		if (!this.hasRequestData(request)) {
 			await this.executeRequest(request, { fetchAll: true });
-			return this.getRequestResult(request);
+			return this.getRequestResultFromDescriptor(request);
 		}
-		const result = this.getRequestResult(request);
+		const result = this.getRequestResultFromDescriptor(request);
 		this.executeRequest(request, { fetchAll: true }).catch(() => {});
 		return result;
 	}
@@ -1474,104 +2395,125 @@ var FateClient = class {
 		if (!root) throw new Error(`fate: Unknown root request '${name}'.`);
 		return root.type;
 	}
+	createRequestDescriptor(request) {
+		return createRequestDescriptor(request, (name) => this.getRootType(name));
+	}
+	getRequestKey(request) {
+		return this.createRequestDescriptor(request).key;
+	}
+	hasRootListData(item) {
+		const listState = this.store.getListState(item.listKey);
+		if (!listState) return false;
+		const paginationArgs = getPaginationArgsInfo(item.argsPayload);
+		if (!paginationArgs.hasCursorArg && !hasConnectionPageCoverage(listState, item.argsPayload, paginationArgs.direction)) return false;
+		for (const id of listState.ids) if (this.store.missingForSelection(id, item.plan.paths).size > 0) return false;
+		return true;
+	}
 	async executeRequest(request, options = {}) {
 		const fetchAll = options.fetchAll ?? false;
 		const groups = /* @__PURE__ */ new Map();
 		const promises = [];
-		for (const [name, item] of Object.entries(request)) {
-			const type = this.getRootType(name);
-			const isNode = isNodeItem(item);
-			if (isNode || isNodesItem(item)) {
-				const plan = getSelectionPlan(item.view, null);
-				const fields = plan.paths;
-				const groupKey = `${type}#${[...fields].slice().sort().join(",")}|${[...plan.args.entries()].map(([path, entry]) => `${path}:${entry.hash}`).sort().join(",")}`;
-				let group = groups.get(groupKey);
-				if (!group) {
-					group = {
-						fields,
-						ids: [],
-						plan,
-						type
-					};
-					groups.set(groupKey, group);
-				}
-				for (const raw of isNode ? [item.id] : item.ids) {
-					const entityId = toEntityId(type, raw);
-					const missing = this.store.missingForSelection(entityId, fields);
-					if (fetchAll || missing.size > 0) group.ids.push(raw);
-				}
-			} else if (isQueryItem(item)) {
-				const { argsPayload, plan } = this.resolveSelection(item.view, item.args);
-				const entityId = this.rootRequests.get(name);
-				const missing = entityId ? this.store.missingForSelection(entityId, plan.paths) : plan.paths;
-				if (fetchAll || missing.size > 0) promises.push(this.fetchQueryAndNormalize(name, item, plan, argsPayload));
-			} else promises.push(this.fetchListAndNormalize(name, item));
+		for (const item of request.items) if (item.kind === "node" || item.kind === "nodes") {
+			const fields = item.plan.paths;
+			const fieldsSignature = [...fields].slice().sort().join(",");
+			const argsSignature = [...item.plan.args.entries()].map(([path, entry]) => `${path}:${entry.hash}`).sort().join(",");
+			const groupKey = `${item.type}#${fieldsSignature}|${argsSignature}`;
+			let group = groups.get(groupKey);
+			if (!group) {
+				group = {
+					fields,
+					ids: [],
+					plan: item.plan,
+					type: item.type
+				};
+				groups.set(groupKey, group);
+			}
+			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);
+			}
+		} 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 (item.kind !== "list") continue;
+			if (!fetchAll && !getPaginationArgsInfo(item.argsPayload).hasCursorArg && this.hasRootListData(item)) continue;
+			promises.push(this.fetchListAndNormalize(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())]);
 	}
 	hasRequestData(request) {
-		for (const [name, item] of Object.entries(request)) {
-			const isNode = isNodeItem(item);
-			const type = this.getRootType(name);
-			if (isNode || isNodesItem(item)) {
-				const fields = getSelectionPlan(item.view, null).paths;
-				for (const raw of isNode ? [item.id] : item.ids) {
-					const entityId = toEntityId(type, raw);
+		for (const item of request.items) {
+			if (item.kind === "node" || item.kind === "nodes") {
+				const fields = item.plan.paths;
+				for (const raw of item.ids) {
+					const entityId = toEntityId(item.type, raw);
 					if (this.store.missingForSelection(entityId, fields).size > 0) return false;
 				}
 				continue;
 			}
-			if (isQueryItem(item)) {
-				const { plan } = this.resolveSelection(item.view, item.args);
-				const entityId = this.rootRequests.get(name);
-				if ((entityId ? this.store.missingForSelection(entityId, plan.paths) : plan.paths).size > 0) return false;
+			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 (!hasResult || entityId && missing.size > 0) return false;
 				continue;
 			}
-			if (!this.store.getList(name)) return false;
+			if (item.kind !== "list") continue;
+			if (!this.hasRootListData(item)) return false;
 		}
 		return true;
 	}
 	getRequestResult(request) {
+		return this.getRequestResultFromDescriptor(this.createRequestDescriptor(request));
+	}
+	getRequestResultFromDescriptor(request) {
 		const result = {};
-		for (const [name, item] of Object.entries(request)) {
-			const type = this.getRootType(name);
-			if (isNodeItem(item)) {
-				result[name] = this.ref(type, item.id, item.view);
+		for (const item of request.items) {
+			if (item.kind === "node") {
+				result[item.name] = this.stableRefWithViewNames(item.type, item.ids[0], item.refViewNames);
 				continue;
 			}
-			if (isNodesItem(item)) {
-				result[name] = item.ids.map((id$1) => this.ref(type, id$1, item.view));
+			if (item.kind === "nodes") {
+				result[item.name] = item.ids.map((id) => this.stableRefWithViewNames(item.type, id, item.refViewNames));
 				continue;
 			}
-			if (isQueryItem(item)) {
-				const entityId = this.rootRequests.get(name);
+			if (item.kind === "query") {
+				const entityId = this.rootRequests.get(item.queryKey);
 				if (entityId) {
-					const { id: id$1 } = parseEntityId(entityId);
-					result[name] = createRef(type, id$1, item.view, { root: true });
-				} else result[name] = null;
+					const { id } = parseEntityId(entityId);
+					result[item.name] = this.stableRefWithViewNames(item.type, id, item.refViewNames);
+				} else result[item.name] = null;
 				continue;
 			}
-			const listState = this.store.getListState(name);
-			const hasItems = item.list && typeof item.list === "object" && "items" in item.list;
-			const nodeView = hasItems && item.list.items ? item.list.items.node ?? item.list : item.list;
-			const nodes = (listState?.ids ?? []).map((id$1) => this.rootListRef(id$1, nodeView));
-			if (hasItems) {
+			if (item.kind !== "list") continue;
+			const listState = this.store.getListState(item.listKey);
+			const entries = getListEntries(listState);
+			const nodes = entries.map(({ id }) => {
+				const { id: rawId, type } = parseEntityId(id);
+				return this.stableRefWithViewNames(type, rawId, item.nodeRefViewNames);
+			});
+			if (item.hasItems) {
 				const connection = {
 					items: nodes.map((node, index) => ({
-						cursor: listState?.cursors?.[index],
+						cursor: entries[index]?.cursor,
 						node
 					})),
 					pagination: listState?.pagination
 				};
-				const { argsPayload } = this.resolveSelection(item.list, item.args);
 				const metadata = {
-					args: argsPayload,
-					field: name,
-					key: name,
-					owner: name,
-					procedure: `request.${name}`,
+					args: item.argsPayload,
+					field: item.name,
+					key: item.listKey,
+					live: item.plan.live.get(""),
+					owner: item.name,
+					procedure: item.name,
 					root: true,
-					type
+					type: item.type
 				};
 				Object.defineProperty(connection, ConnectionTag, {
 					configurable: false,
@@ -1579,10 +2521,10 @@ var FateClient = class {
 					value: metadata,
 					writable: false
 				});
-				result[name] = connection;
+				result[item.name] = connection;
 				continue;
 			}
-			result[name] = nodes;
+			result[item.name] = nodes;
 		}
 		return result;
 	}
@@ -1591,42 +2533,34 @@ var FateClient = class {
 		const records = await this.transport.fetchById(type, ids, select, resolvedArgs);
 		for (const record of records) this.writeEntity(type, record, select, void 0, plan, prefix);
 	}
-	async fetchQueryAndNormalize(name, item, plan, argsPayload) {
-		if (!this.transport.fetchQuery) throw new Error(`fate: transport does not support queries. Please add support for 'fetchQuery' in your transport for '${name}'.`);
-		const record = await this.transport.fetchQuery(name, plan.paths, argsPayload);
-		if (!record || typeof record !== "object") return;
-		const entityId = this.writeEntity(this.getRootType(name), record, plan.paths, void 0, plan);
-		this.rootRequests.set(name, entityId);
-	}
-	async fetchListAndNormalize(name, item) {
-		if (!this.transport.fetchList) throw new Error(`fate: 'transport.fetchList' is not configured but request includes a list for key '${name}'.`);
-		const type = this.getRootType(name);
-		const { argsPayload, plan } = this.resolveSelection(item.list, item.args);
-		const { items, pagination } = await this.transport.fetchList(name, plan.paths, argsPayload);
+	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}'.`);
+		const record = await this.transport.fetchQuery(item.name, item.plan.paths, item.argsPayload);
+		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);
+		this.rootRequests.set(item.queryKey, entityId);
+	}
+	async fetchListAndNormalize(item) {
+		if (!this.transport.fetchList) throw new Error(`fate: 'transport.fetchList' is not configured but request includes a list for key '${item.name}'.`);
+		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$1 = this.writeEntity(type, entry.node, plan.paths, void 0, plan);
-			ids.push(id$1);
+			const id = this.writeEntity(item.type, entry.node, item.plan.paths, void 0, item.plan);
+			ids.push(id);
 			cursors.push(entry.cursor);
 		}
-		this.registerRootList(type, name);
-		this.store.setList(name, {
-			cursors,
-			ids,
-			pagination
-		});
-	}
-	resolveSelection(view$1, args) {
-		const plan = getSelectionPlan(view$1, null);
-		const argsPayload = combineArgsPayload(args, resolvedArgsFromPlan(plan));
-		if (argsPayload) applyArgsPayloadToPlan(plan, argsPayload);
-		return {
-			argsPayload,
-			plan
-		};
-	}
-	writeEntity(type, record, select, snapshots, plan, pathPrefix = null, blockedMask, insert) {
+		if (!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));
@@ -1638,7 +2572,7 @@ var FateClient = class {
 			const fieldArgs = plan?.args.get(fieldPath);
 			const isFieldBlocked = blockedMask ? isCovered(blockedMask, fieldPath) : false;
 			if (relationDescriptor === "scalar") {
-				if (isFieldBlocked) continue;
+				if (isFieldBlocked || !Object.prototype.hasOwnProperty.call(record, key)) continue;
 				result[key] = value;
 			} else if (relationDescriptor && typeof relationDescriptor === "object" && "type" in relationDescriptor) {
 				if (isFieldBlocked) continue;
@@ -1652,7 +2586,7 @@ var FateClient = class {
 					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);
+					this.writeEntity(childType, value, childPaths, snapshots, plan, fieldPath, blockedMask, void 0, listSnapshots);
 				}
 			} else if (relationDescriptor && typeof relationDescriptor === "object" && "listOf" in relationDescriptor) {
 				if (isFieldBlocked) continue;
@@ -1667,9 +2601,9 @@ var FateClient = class {
 				const connection = (() => {
 					if (Array.isArray(value)) return { items: value.map((item) => ({ node: item })) };
 					if (value && typeof value === "object") {
-						const record$1 = value;
-						if (Array.isArray(record$1.items)) return {
-							items: record$1.items.map((node) => {
+						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 {
@@ -1679,7 +2613,7 @@ var FateClient = class {
 								}
 								return { node };
 							}),
-							pagination: record$1.pagination
+							pagination: record.pagination
 						};
 					}
 					return null;
@@ -1710,7 +2644,7 @@ var FateClient = class {
 						}
 						if (node && typeof node === "object") {
 							const childId = toEntityId(childType, childConfig.getId(node));
-							this.writeEntity(childType, node, nodeSelection, snapshots, plan, fieldPath, blockedMask);
+							this.writeEntity(childType, node, nodeSelection, snapshots, plan, fieldPath, blockedMask, void 0, listSnapshots);
 							ids.push(childId);
 							continue;
 						}
@@ -1718,13 +2652,9 @@ var FateClient = class {
 					const listKey = getListKey(entityId, key, fieldArgs?.hash);
 					const previousList = this.store.getListState(listKey);
 					const argsValue = fieldArgs?.value;
-					const hasCursorArg = Boolean(argsValue && ("after" in argsValue || "before" in argsValue || "cursor" in argsValue));
-					const isBackward = Boolean(argsValue && (argsValue.before !== void 0 || argsValue.last !== void 0));
-					const nextListState = this.mergeListState(previousList, ids, cursors, connection.pagination, {
-						direction: isBackward ? "backward" : "forward",
-						hasCursorArg
-					});
-					result[key] = nextListState.ids.map((id$1) => createNodeRef(id$1));
+					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;
@@ -1737,11 +2667,11 @@ var FateClient = class {
 		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, insert ?? "after");
-		if (!pathPrefix && insert) this.insertIntoRootLists(type, entityId, insert);
+		this.linkParentLists(type, entityId, result, snapshots, listSnapshots, insert ?? "after");
+		if (!pathPrefix && insert) this.insertIntoRootLists(type, entityId, insert, listSnapshots);
 		return entityId;
 	}
-	linkParentLists(type, entityId, record, snapshots, insert) {
+	linkParentLists(type, entityId, record, snapshots, listSnapshots, insert) {
 		if (insert === "none") return;
 		const parents = this.parentLists.get(type);
 		if (!parents) return;
@@ -1756,28 +2686,31 @@ var FateClient = class {
 			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 nextList = insert === "before" ? [createNodeRef(entityId), ...current] : [...current, createNodeRef(entityId)];
-			const ids = nextList.map((item) => isNodeRef(item) ? getNodeRefId(item) : null).filter((id$1) => id$1 != null);
 			const defaultListKey = getListKey(parentId, parent.field);
 			const defaultListState = this.store.getListState(defaultListKey);
-			const nextDefaultCursors = defaultListState?.cursors ? insert === "before" ? [void 0, ...defaultListState.cursors] : [...defaultListState.cursors, void 0] : defaultListState?.cursors;
-			this.store.setList(defaultListKey, {
-				cursors: nextDefaultCursors,
-				ids,
-				pagination: defaultListState?.pagination
-			});
+			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);
+				}
+				nextField = createNodeRefsForIds(pending ? getListEntries(nextDefaultListState).map(({ id }) => id) : nextDefaultListState.ids, 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);
+			}
 			const registeredLists = this.store.getListsForField(parentId, parent.field).filter(([key]) => key !== defaultListKey);
 			for (const [listKey, listState] of registeredLists) {
-				if (listState.ids.includes(entityId)) continue;
-				const listIds = insert === "before" ? [entityId, ...listState.ids] : [...listState.ids, entityId];
-				const listCursors = listState.cursors ? insert === "before" ? [void 0, ...listState.cursors] : [...listState.cursors, void 0] : void 0;
-				this.store.setList(listKey, {
-					cursors: listCursors,
-					ids: listIds,
-					pagination: listState.pagination
-				});
+				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]: nextList }, [parent.field]);
+			this.store.merge(parentId, { [parent.field]: nextField }, [parent.field]);
 		}
 	}
 	readViewSelection(viewComposition, ref, entityId, plan, pathPrefix = null) {
@@ -1785,7 +2718,7 @@ var FateClient = class {
 		const ids = /* @__PURE__ */ new Set();
 		ids.add(entityId);
 		const coverageById = /* @__PURE__ */ new Map();
-		const walk = (viewPayload, record$1, target, parentId, prefix) => {
+		const walk = (viewPayload, record, target, parentId, prefix) => {
 			for (const [key, selectionKind] of Object.entries(viewPayload)) {
 				if (isViewTag(key)) {
 					if (!target[ViewsTag]) assignViewTag(target, /* @__PURE__ */ new Set());
@@ -1795,17 +2728,17 @@ var FateClient = class {
 				coverageById.set(parentId, (coverageById.get(parentId) ?? /* @__PURE__ */ new Set()).add(key));
 				const fieldPath = prefix ? `${prefix}.${key}` : key;
 				const selectionType = typeof selectionKind;
-				if (selectionType === "boolean" && selectionKind) target[key] = record$1[key];
+				if (selectionType === "boolean" && selectionKind) target[key] = record[key];
 				else if (selectionKind && selectionType === "object") {
 					const selectionValue = selectionKind;
 					const { args: selectionArgs, ...selectionWithoutArgs } = selectionValue;
 					if (Boolean(selectionArgs) && typeof selectionArgs === "object" && Object.keys(selectionWithoutArgs).length === 0) {
-						target[key] = record$1[key];
+						target[key] = record[key];
 						continue;
 					}
 					if (!(key in target)) target[key] = {};
 					const nextSelection = Object.keys(selectionWithoutArgs).length ? selectionWithoutArgs : selectionValue;
-					const value = record$1[key];
+					const value = record[key];
 					if (value == null) {
 						target[key] = null;
 						continue;
@@ -1815,23 +2748,26 @@ var FateClient = class {
 						const fieldArgs = plan.args.get(fieldPath);
 						const listKey = getListKey(parentId, key, fieldArgs?.hash);
 						const listState = this.store.getListState(listKey);
-						const connection = { items: value.map((item, index) => {
-							const entityId$1 = isNodeRef(item) ? getNodeRefId(item) : null;
-							if (!entityId$1) return {
+						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$1);
-							const record$2 = this.store.read(entityId$1);
-							const { id: id$1, type } = parseEntityId(entityId$1);
+							ids.add(entityId);
+							const record = this.store.read(entityId);
+							const { id, type } = parseEntityId(entityId);
 							const node = {
 								__typename: type,
-								id: id$1
+								id
 							};
-							if (record$2) walk(selection.node, record$2, node, entityId$1, fieldPath);
-							const entry = { node: record$2 ? node : null };
-							if (selection.cursor === true) entry.cursor = listState?.cursors?.[index];
-							return entry;
+							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;
@@ -1858,13 +2794,14 @@ var FateClient = class {
 							const metadata = {
 								args: (() => {
 									if (!fieldArgs?.value && ownerRawId === void 0) return;
-									const value$1 = fieldArgs?.value ? { ...fieldArgs.value } : {};
-									if (ownerRawId !== void 0) value$1.id = ownerRawId;
-									return value$1;
+									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,
@@ -1879,31 +2816,31 @@ var FateClient = class {
 						}
 						target[key] = connection;
 					} else target[key] = value.map((item) => {
-						const entityId$1 = isNodeRef(item) ? getNodeRefId(item) : null;
-						if (!entityId$1) return item;
-						ids.add(entityId$1);
-						const record$2 = this.store.read(entityId$1);
-						const { id: id$1, type } = parseEntityId(entityId$1);
-						if (record$2) {
+						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: id$1
+								id
 							};
-							walk(nextSelection, record$2, node, entityId$1, fieldPath);
+							walk(nextSelection, record, node, entityId, fieldPath);
 							return node;
 						}
 						return null;
 					});
 					else if (isNodeRef(value)) {
-						const entityId$1 = getNodeRefId(value);
-						ids.add(entityId$1);
-						const relatedRecord = this.store.read(entityId$1);
-						const { id: id$1, type } = parseEntityId(entityId$1);
+						const entityId = getNodeRefId(value);
+						ids.add(entityId);
+						const relatedRecord = this.store.read(entityId);
+						const { id, type } = parseEntityId(entityId);
 						const targetRecord = target[key];
-						targetRecord.id = id$1;
+						targetRecord.id = id;
 						targetRecord.__typename = type;
-						if (relatedRecord) walk(nextSelection, relatedRecord, targetRecord, entityId$1, fieldPath);
-					} else walk(nextSelection, record$1, target[key], entityId, fieldPath);
+						if (relatedRecord) walk(nextSelection, relatedRecord, targetRecord, entityId, fieldPath);
+					} else walk(nextSelection, value, target[key], entityId, fieldPath);
 				}
 			}
 		};
@@ -1924,11 +2861,39 @@ var FateClient = class {
 	pendingKey(entityId, missingFields) {
 		return `${this.pendingPrefix(entityId)}${[...missingFields].sort().join("|")}`;
 	}
+	liveSubscriptionKey(entityId, plan) {
+		return `${entityId}|${[...plan.paths].sort().join("|")}|${[...plan.args.entries()].map(([path, entry]) => `${path}:${entry.hash}`).sort().join("|")}`;
+	}
+	liveConnectionSubscriptionKey(connection, plan, args) {
+		const paths = [...plan.paths].sort().join("|");
+		const selectionArgs = [...plan.args.entries()].map(([path, entry]) => `${path}:${entry.hash}`).sort().join("|");
+		return `connection|${connection.procedure}|${connection.type}|${hashArgs(args ?? {})}|${paths}|${selectionArgs}`;
+	}
+	releaseLiveSubscription(key) {
+		const subscription = this.liveSubscriptions.get(key);
+		if (!subscription) return;
+		if (subscription.count <= 0) return;
+		subscription.count -= 1;
+		if (subscription.count > 0) return;
+		subscription.releaseScheduled = true;
+		queueMicrotask(() => {
+			const current = this.liveSubscriptions.get(key);
+			if (!current || !current.releaseScheduled || current.count > 0) return;
+			current.unsubscribe();
+			this.liveSubscriptions.delete(key);
+		});
+	}
+	reportLiveError(error) {
+		const onLiveError = this.onLiveError;
+		if (!onLiveError) return;
+		queueMicrotask(() => {
+			onLiveError(error);
+		});
+	}
 };
 function createClient(options) {
 	return new FateClient(options);
 }
-
 //#endregion
 //#region src/transport.ts
 /**
@@ -1950,7 +2915,7 @@ function createTRPCTransport({ byId, client, lists, mutations, queries }) {
 			if (!lists) throw new Error(`fate(trpc): No list resolvers configured; cannot call "${procedure}".`);
 			const resolver = lists[procedure];
 			if (!resolver) throw new Error(`fate(trpc): Missing list resolver for procedure "${procedure}"`);
-			return resolver(client)({
+			return await resolver(client)({
 				args,
 				select: [...select]
 			});
@@ -1975,7 +2940,449 @@ function createTRPCTransport({ byId, client, lists, mutations, queries }) {
 	};
 	return transport;
 }
-
+//#endregion
+//#region src/httpTransport.ts
+const reportSubscriptionError = (subscription, error) => {
+	subscription.handlers.onError?.(error);
+};
+const notifyLiveData = (handlers, record, select) => {
+	if (select) {
+		handlers.onData(record, select);
+		return;
+	}
+	handlers.onData(record);
+};
+const protocolError = (message) => new FateRequestError(message.error.code, message.error.message, { issues: message.error.issues });
+const pathsIntersect = (left, right) => left === right || left.startsWith(`${right}.`) || right.startsWith(`${left}.`);
+const filterLiveSelection = (select, changed) => {
+	if (!changed) return null;
+	const changedPaths = changed.filter((path) => path.length > 0);
+	if (changedPaths.length === 0) return [];
+	const selected = select.filter((path) => changedPaths.some((changedPath) => pathsIntersect(path, changedPath)));
+	if (selected.length === 0) return [];
+	const result = new Set(selected);
+	result.add("id");
+	for (const path of select) {
+		if (!path.endsWith(".id")) continue;
+		const parentPath = path.slice(0, -3);
+		if (selected.some((selectedPath) => pathsIntersect(selectedPath, parentPath))) result.add(path);
+	}
+	return [...result];
+};
+const hasSelectedDataPath = (value, segments) => {
+	if (segments.length === 0) return true;
+	if (Array.isArray(value)) return value.every((entry) => hasSelectedDataPath(entry, segments));
+	if (!isRecord(value)) return false;
+	const [field, ...rest] = segments;
+	return field in value && hasSelectedDataPath(value[field], rest);
+};
+const canUseLivePayloadData = (data, select) => {
+	if (!isRecord(data)) return false;
+	for (const path of select) if (!hasSelectedDataPath(data, path.split("."))) return false;
+	return true;
+};
+const defaultFetch = (input, init) => globalThis.fetch(input, init);
+const resolveHeaders = async (headers) => typeof headers === "function" ? await headers() : headers ?? {};
+const requestHeaders = async (defaults, headers) => {
+	const result = new Headers(defaults);
+	new Headers(await resolveHeaders(headers)).forEach((value, key) => {
+		result.set(key, value);
+	});
+	return result;
+};
+const normalizeEndpoint = (url) => String(url).replace(/\/$/, "");
+const liveEndpoint = (url) => `${normalizeEndpoint(url)}/live`;
+const responseError = async (response) => {
+	let message = response.statusText || `HTTP ${response.status}`;
+	try {
+		const payload = await response.clone().json();
+		if (isRecord(payload) && Array.isArray(payload.results) && isRecord(payload.results[0]) && isRecord(payload.results[0].error) && typeof payload.results[0].error.message === "string") message = payload.results[0].error.message;
+	} catch {
+		try {
+			const text = await response.text();
+			if (text) message = text;
+		} catch {}
+	}
+	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.");
+	return value;
+};
+const resultValue = (result) => {
+	if (result.ok) return result.data;
+	throw new FateRequestError(result.error.code, result.error.message, { issues: result.error.issues });
+};
+function createHTTPTransport({ eventSource, fetch: fetchImpl = defaultFetch, headers, live = true, liveRetryMs = 1e3, liveUrl, url }) {
+	const endpoint = normalizeEndpoint(url);
+	const liveEndpointUrl = liveUrl ? String(liveUrl) : liveEndpoint(endpoint);
+	const liveConnector = typeof live === "function" ? live : void 0;
+	const liveEnabled = live !== false;
+	let nextId = 0;
+	let pending = [];
+	let scheduled = false;
+	const enqueue = (operation) => new Promise((resolve, reject) => {
+		pending.push({
+			operation: {
+				...operation,
+				id: String(++nextId)
+			},
+			reject,
+			resolve
+		});
+		if (!scheduled) {
+			scheduled = true;
+			queueMicrotask(flush);
+		}
+	});
+	const flush = async () => {
+		scheduled = false;
+		const batch = pending;
+		pending = [];
+		if (!batch.length) return;
+		try {
+			const response = await fetchImpl(endpoint, {
+				body: JSON.stringify({
+					operations: batch.map((entry) => entry.operation),
+					version: 1
+				}),
+				headers: await requestHeaders({ "content-type": "application/json" }, headers),
+				method: "POST"
+			});
+			if (!response.ok) throw await responseError(response);
+			const payload = assertProtocolResponse(await response.json());
+			const results = new Map(payload.results.map((result) => [result.id, result]));
+			for (const entry of batch) {
+				const result = results.get(entry.operation.id);
+				if (!result) {
+					entry.reject(/* @__PURE__ */ new Error(`fate(http): Missing result for operation '${entry.operation.id}'.`));
+					continue;
+				}
+				try {
+					entry.resolve(resultValue(result));
+				} catch (error) {
+					entry.reject(error);
+				}
+			}
+		} catch (error) {
+			for (const entry of batch) entry.reject(error);
+		}
+	};
+	const transport = {
+		fetchById(type, ids, select, args) {
+			return enqueue({
+				args,
+				ids,
+				kind: "byId",
+				select: [...select],
+				type
+			});
+		},
+		fetchList(name, select, args) {
+			return enqueue({
+				args,
+				kind: "list",
+				name,
+				select: [...select]
+			});
+		},
+		fetchQuery(name, select, args) {
+			return enqueue({
+				args,
+				kind: "query",
+				name,
+				select: [...select]
+			});
+		},
+		mutate(name, input, select) {
+			return enqueue({
+				input,
+				kind: "mutation",
+				name,
+				select: [...select]
+			});
+		}
+	};
+	if (liveEnabled) {
+		const liveSubscriptions = /* @__PURE__ */ new Map();
+		let liveClient;
+		let nativeLiveClient;
+		let liveNextId = 0;
+		const getLiveClient = () => {
+			if (!liveConnector) throw new Error("fate(http): A live connector is required for topic subscriptions.");
+			return liveClient ??= liveConnector(liveEndpointUrl, {
+				eventSource,
+				fetch: fetchImpl,
+				headers,
+				onError(error) {
+					for (const subscription of new Set(liveSubscriptions.values())) subscription.handlers.onError?.(error);
+				},
+				retryDelay: liveRetryMs,
+				withCredentials: true
+			});
+		};
+		const getNativeLiveClient = () => {
+			if (nativeLiveClient) return nativeLiveClient;
+			const EventSourceCtor = eventSource ?? globalThis.EventSource;
+			if (!EventSourceCtor) throw new Error("fate(http): EventSource is required for live views.");
+			const connectionId = globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+			const operations = /* @__PURE__ */ new Map();
+			const lastEventIds = /* @__PURE__ */ new Map();
+			let opened = false;
+			let resolveOpen;
+			let rejectOpen;
+			const open = new Promise((resolve, reject) => {
+				resolveOpen = resolve;
+				rejectOpen = reject;
+			});
+			const sourceUrl = new URL(liveEndpointUrl, typeof globalThis.location === "object" ? globalThis.location.href : "http://local");
+			sourceUrl.searchParams.set("connectionId", connectionId);
+			const source = new EventSourceCtor(sourceUrl.href, { withCredentials: true });
+			const control = async (controlOperations) => {
+				const response = await fetchImpl(liveEndpointUrl, {
+					body: JSON.stringify({
+						connectionId,
+						operations: controlOperations,
+						version: 1
+					}),
+					headers: await requestHeaders({ "content-type": "application/json" }, headers),
+					method: "POST"
+				});
+				if (!response.ok) throw await responseError(response);
+				const payload = assertProtocolResponse(await response.json());
+				for (const result of payload.results) resultValue(result);
+			};
+			const withLastEventId = (operation) => {
+				const lastEventId = lastEventIds.get(operation.id);
+				return lastEventId ? {
+					...operation,
+					lastEventId
+				} : operation;
+			};
+			const reportError = (error) => {
+				for (const subscription of new Set(liveSubscriptions.values())) reportSubscriptionError(subscription, error);
+			};
+			source.addEventListener("open", () => {
+				if (!opened) {
+					opened = true;
+					resolveOpen?.();
+					return;
+				}
+				const resubscribe = [...operations.values()].map(withLastEventId);
+				if (resubscribe.length > 0) control(resubscribe).catch(reportError);
+			});
+			const handleLiveMessage = (event) => {
+				const message = JSON.parse(event.data);
+				const subscription = liveSubscriptions.get(message.id);
+				if (!subscription) return;
+				const lastEventId = event.lastEventId;
+				if (lastEventId) lastEventIds.set(message.id, lastEventId);
+				if (message.kind === "error") {
+					reportSubscriptionError(subscription, protocolError(message));
+					return;
+				}
+				if (message.kind === "connection") {
+					if ("onEvent" in subscription.handlers) subscription.handlers.onEvent(message.event);
+					return;
+				}
+				if ("delete" in message.event && message.event.delete) {
+					if ("onDelete" in subscription.handlers) subscription.handlers.onDelete?.(message.event.id ?? subscription.targetId);
+					return;
+				}
+				if ("onData" in subscription.handlers) notifyLiveData(subscription.handlers, message.event.data, message.event.select);
+			};
+			source.addEventListener("error", (event) => {
+				if ("data" in event) {
+					handleLiveMessage(event);
+					return;
+				}
+				if (!opened) rejectOpen?.(event);
+				reportError(event);
+			});
+			source.addEventListener("message", handleLiveMessage);
+			source.addEventListener("next", handleLiveMessage);
+			source.addEventListener("connection", handleLiveMessage);
+			nativeLiveClient = {
+				add(operation) {
+					operations.set(operation.id, operation);
+					open.then(() => control([withLastEventId(operation)])).catch((error) => {
+						operations.delete(operation.id);
+						liveSubscriptions.delete(operation.id);
+						reportError(error);
+					});
+				},
+				remove(id) {
+					operations.delete(id);
+					lastEventIds.delete(id);
+					open.then(() => control([{
+						id,
+						kind: "unsubscribe"
+					}])).catch(reportError);
+					if (operations.size === 0) {
+						source.close();
+						nativeLiveClient = void 0;
+					}
+				}
+			};
+			return nativeLiveClient;
+		};
+		const fetchLiveRecord = async (subscription, select = subscription.select) => {
+			const [record] = await transport.fetchById(subscription.type, [subscription.targetId], select, subscription.args);
+			return record;
+		};
+		const resolveConnectionNode = async (subscription, id) => {
+			const [record] = await transport.fetchById(subscription.type, [id], subscription.select, subscription.selectionArgs);
+			return record;
+		};
+		transport.subscribeById = (type, id, select, args, handlers) => {
+			const liveId = String(++liveNextId);
+			const subscription = {
+				args,
+				handlers,
+				select: [...select],
+				targetId: id,
+				type
+			};
+			liveSubscriptions.set(liveId, subscription);
+			if (!liveConnector) {
+				getNativeLiveClient().add({
+					args,
+					entityId: id,
+					id: liveId,
+					kind: "subscribe",
+					select: [...select],
+					type
+				});
+				return () => {
+					if (!liveSubscriptions.delete(liveId)) return;
+					getNativeLiveClient().remove(liveId);
+				};
+			}
+			const unsubscribePromise = getLiveClient().subscribe({
+				id: liveId,
+				onEvent(event) {
+					if (event.type === "delete") {
+						handlers.onDelete?.(event.data.id ?? id);
+						return;
+					}
+					const liveSelect = (Array.isArray(event.data.select) ? event.data.select : null) ?? filterLiveSelection(subscription.select, event.data.changed);
+					if (liveSelect?.length === 0) return;
+					if ("data" in event.data && event.data.data !== void 0) {
+						if (!liveSelect || canUseLivePayloadData(event.data.data, liveSelect)) {
+							notifyLiveData(handlers, event.data.data, liveSelect ?? void 0);
+							return;
+						}
+					}
+					fetchLiveRecord(subscription, liveSelect ?? subscription.select).then((record) => {
+						if (record == null) handlers.onDelete?.(id);
+						else notifyLiveData(handlers, record, liveSelect ?? void 0);
+					}).catch((error) => reportSubscriptionError(subscription, error));
+				},
+				topic: liveEntityTopic(type, id)
+			}).catch((error) => {
+				liveSubscriptions.delete(liveId);
+				reportSubscriptionError(subscription, error);
+				return null;
+			});
+			return () => {
+				if (!liveSubscriptions.delete(liveId)) return;
+				unsubscribePromise.then((unsubscribe) => unsubscribe?.());
+			};
+		};
+		transport.subscribeConnection = (procedure, type, args, select, selectionArgs, handlers) => {
+			const liveId = String(++liveNextId);
+			const globalLiveId = `${liveId}:global`;
+			const subscription = {
+				args,
+				handlers,
+				procedure,
+				select: [...select],
+				selectionArgs,
+				type
+			};
+			const handleEvent = (event) => {
+				const data = isRecord(event.data) ? event.data : {};
+				if (event.type === "invalidate") {
+					handlers.onEvent({ type: "invalidate" });
+					return;
+				}
+				const nodeType = typeof data.nodeType === "string" ? data.nodeType : type;
+				const id = data.id;
+				if (event.type === "deleteEdge") {
+					if (typeof id === "string" || typeof id === "number") handlers.onEvent({
+						id,
+						nodeType,
+						type: "deleteEdge"
+					});
+					else reportSubscriptionError(subscription, /* @__PURE__ */ new Error(`fate(http): Live connection delete event for '${procedure}' missed an id.`));
+					return;
+				}
+				if (event.type !== "appendEdge" && event.type !== "appendNode" && event.type !== "insertEdgeAfter" && event.type !== "insertEdgeBefore" && event.type !== "prependEdge" && event.type !== "prependNode") return;
+				const eventType = event.type;
+				const sendNode = (node) => {
+					handlers.onEvent({
+						edge: {
+							cursor: typeof data.cursor === "string" ? data.cursor : void 0,
+							node
+						},
+						nodeType,
+						targetCursor: typeof data.targetCursor === "string" ? data.targetCursor : void 0,
+						type: eventType
+					});
+				};
+				if ("node" in data && data.node !== void 0) {
+					sendNode(data.node);
+					return;
+				}
+				if (typeof id !== "string" && typeof id !== "number") {
+					reportSubscriptionError(subscription, /* @__PURE__ */ new Error(`fate(http): Live connection event for '${procedure}' missed a node id.`));
+					return;
+				}
+				resolveConnectionNode(subscription, id).then(sendNode).catch((error) => reportSubscriptionError(subscription, error));
+			};
+			liveSubscriptions.set(liveId, subscription);
+			if (!liveConnector) {
+				getNativeLiveClient().add({
+					args,
+					id: liveId,
+					kind: "subscribeConnection",
+					procedure,
+					select: [...select],
+					selectionArgs,
+					type
+				});
+				return () => {
+					if (!liveSubscriptions.delete(liveId)) return;
+					getNativeLiveClient().remove(liveId);
+				};
+			}
+			liveSubscriptions.set(globalLiveId, subscription);
+			const client = getLiveClient();
+			const unsubscribeSpecific = client.subscribe({
+				id: liveId,
+				onEvent: handleEvent,
+				topic: liveConnectionTopic(procedure, args)
+			});
+			const unsubscribeGlobal = client.subscribe({
+				id: globalLiveId,
+				onEvent: handleEvent,
+				topic: liveGlobalConnectionTopic(procedure)
+			});
+			const unsubscribePromise = Promise.all([unsubscribeSpecific, unsubscribeGlobal]).catch((error) => {
+				liveSubscriptions.delete(liveId);
+				liveSubscriptions.delete(globalLiveId);
+				reportSubscriptionError(subscription, error);
+				return [];
+			});
+			return () => {
+				if (!(liveSubscriptions.delete(liveId) || liveSubscriptions.delete(globalLiveId))) return;
+				liveSubscriptions.delete(globalLiveId);
+				unsubscribePromise.then((unsubscribers) => Promise.all(unsubscribers.map((unsubscribe) => unsubscribe())));
+			};
+		};
+	}
+	return transport;
+}
 //#endregion
 //#region src/root.ts
 /**
@@ -1987,6 +3394,5 @@ function clientRoot(type) {
 		type
 	});
 }
-
 //#endregion
-export { ConnectionTag, FateClient, clientRoot, createClient, createTRPCTransport, getSelectionPlan, isViewTag, mutation, toEntityId, view };
+export { ConnectionTag, FateClient, clientRoot, createClient, createHTTPTransport, createTRPCTransport, getListEntries, getSelectionPlan, isRecord, isViewTag, liveConnectionTopic, liveEntityTopic, liveGlobalConnectionTopic, mutation, toEntityId, view };