@nkzw/fate 0.0.1

package/lib/index.mjs

@@ -0,0 +1,1842 @@
+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
+//#region src/cache.ts
+var ViewDataCache = class {
+	constructor() {
+		this.cache = /* @__PURE__ */ new Map();
+		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;
+	}
+	set(entityId, view$1, 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);
+		if (!viewMap) {
+			viewMap = /* @__PURE__ */ new WeakMap();
+			entityMap.set(view$1, viewMap);
+		}
+		viewMap.set(ref, thenable);
+		let roots = this.rootDependencies.get(entityId);
+		if (!roots) {
+			roots = /* @__PURE__ */ new Set();
+			this.rootDependencies.set(entityId, roots);
+		}
+		for (const dependency of dependencies) if (!roots.has(dependency)) {
+			roots.add(dependency);
+			let dependents = this.dependencyIndex.get(dependency);
+			if (!dependents) {
+				dependents = /* @__PURE__ */ new Set();
+				this.dependencyIndex.set(dependency, dependents);
+			}
+			dependents.add(entityId);
+		}
+	}
+	invalidate(entityId) {
+		this.invalidateDependents(entityId, /* @__PURE__ */ new Set());
+	}
+	invalidateDependents(entityId, visited) {
+		if (visited.has(entityId)) return;
+		visited.add(entityId);
+		const dependents = this.dependencyIndex.get(entityId);
+		if (dependents) for (const dependent of dependents) this.invalidateDependents(dependent, visited);
+		this.delete(entityId);
+	}
+	delete(entityId) {
+		const roots = this.rootDependencies.get(entityId);
+		if (roots) {
+			for (const dependency of roots) {
+				const dependents = this.dependencyIndex.get(dependency);
+				if (!dependents) continue;
+				dependents.delete(entityId);
+				if (dependents.size === 0) this.dependencyIndex.delete(dependency);
+			}
+			this.rootDependencies.delete(entityId);
+		}
+		this.cache.delete(entityId);
+	}
+};
+
+//#endregion
+//#region src/mask.ts
+function emptyMask() {
+	return {
+		all: false,
+		children: /* @__PURE__ */ new Map()
+	};
+}
+function cloneMask(m) {
+	const clone = {
+		all: m.all,
+		children: /* @__PURE__ */ new Map()
+	};
+	for (const [key, value] of m.children) clone.children.set(key, cloneMask(value));
+	return clone;
+}
+function addPath(mask, path) {
+	if (mask.all) return;
+	const parts = path.split(".");
+	let current = mask;
+	for (let i = 0; i < parts.length; i++) {
+		const seg = parts[i];
+		let child = current.children.get(seg);
+		if (!child) {
+			child = emptyMask();
+			current.children.set(seg, child);
+		}
+		current = child;
+	}
+	current.all = true;
+	current.children.clear();
+}
+function union(into, b) {
+	if (into.all || b.all) {
+		into.all = true;
+		into.children.clear();
+		return;
+	}
+	for (const [key, child] of b.children) {
+		const exist = into.children.get(key);
+		if (!exist) into.children.set(key, cloneMask(child));
+		else union(exist, child);
+	}
+}
+function fromPaths(paths) {
+	const mask = emptyMask();
+	for (const path of paths) addPath(mask, path);
+	return mask;
+}
+function isCovered(mask, path) {
+	if (mask.all) return true;
+	const parts = path.split(".");
+	let current = mask;
+	for (let i = 0; i < parts.length; i++) {
+		if (!current) return false;
+		if (current.all) return true;
+		current = current.children.get(parts[i]);
+	}
+	return !!current && (current.all || current.children.size === 0);
+}
+function diffPaths(paths, mask) {
+	const missing = /* @__PURE__ */ new Set();
+	for (const path of paths) if (!isCovered(mask, path)) missing.add(path);
+	return missing;
+}
+function intersects(a, b) {
+	if (a.all || b.all) return true;
+	for (const [key, child] of a.children) {
+		const otherChild = b.children.get(key);
+		if (!otherChild) continue;
+		if (child.all || otherChild.all) return true;
+		if (intersects(child, otherChild)) return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@trpc+server@11.7.2_typescript@5.9.3/node_modules/@trpc/server/dist/getErrorShape-BH60iMC2.mjs
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+const JSONRPC2_TO_HTTP_CODE = {
+	PARSE_ERROR: 400,
+	BAD_REQUEST: 400,
+	UNAUTHORIZED: 401,
+	PAYMENT_REQUIRED: 402,
+	FORBIDDEN: 403,
+	NOT_FOUND: 404,
+	METHOD_NOT_SUPPORTED: 405,
+	TIMEOUT: 408,
+	CONFLICT: 409,
+	PRECONDITION_FAILED: 412,
+	PAYLOAD_TOO_LARGE: 413,
+	UNSUPPORTED_MEDIA_TYPE: 415,
+	UNPROCESSABLE_CONTENT: 422,
+	PRECONDITION_REQUIRED: 428,
+	TOO_MANY_REQUESTS: 429,
+	CLIENT_CLOSED_REQUEST: 499,
+	INTERNAL_SERVER_ERROR: 500,
+	NOT_IMPLEMENTED: 501,
+	BAD_GATEWAY: 502,
+	SERVICE_UNAVAILABLE: 503,
+	GATEWAY_TIMEOUT: 504
+};
+function getStatusCodeFromKey(code) {
+	var _JSONRPC2_TO_HTTP_COD;
+	return (_JSONRPC2_TO_HTTP_COD = JSONRPC2_TO_HTTP_CODE[code]) !== null && _JSONRPC2_TO_HTTP_COD !== void 0 ? _JSONRPC2_TO_HTTP_COD : 500;
+}
+function getHTTPStatusCodeFromError(error) {
+	return getStatusCodeFromKey(error.code);
+}
+var require_typeof = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
+	function _typeof$2(o) {
+		"@babel/helpers - typeof";
+		return module.exports = _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+			return typeof o$1;
+		} : function(o$1) {
+			return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+		}, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
+	}
+	module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPrimitive = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(exports, module) {
+	var _typeof$1 = require_typeof()["default"];
+	function toPrimitive$1(t, r) {
+		if ("object" != _typeof$1(t) || !t) return t;
+		var e = t[Symbol.toPrimitive];
+		if (void 0 !== e) {
+			var i = e.call(t, r || "default");
+			if ("object" != _typeof$1(i)) return i;
+			throw new TypeError("@@toPrimitive must return a primitive value.");
+		}
+		return ("string" === r ? String : Number)(t);
+	}
+	module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPropertyKey = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(exports, module) {
+	var _typeof = require_typeof()["default"];
+	var toPrimitive = require_toPrimitive();
+	function toPropertyKey$1(t) {
+		var i = toPrimitive(t, "string");
+		return "symbol" == _typeof(i) ? i : i + "";
+	}
+	module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_defineProperty = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
+	var toPropertyKey = require_toPropertyKey();
+	function _defineProperty(e, r, t) {
+		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+			value: t,
+			enumerable: !0,
+			configurable: !0,
+			writable: !0
+		}) : e[r] = t, e;
+	}
+	module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_objectSpread2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
+	var defineProperty = require_defineProperty();
+	function ownKeys(e, r) {
+		var t = Object.keys(e);
+		if (Object.getOwnPropertySymbols) {
+			var o = Object.getOwnPropertySymbols(e);
+			r && (o = o.filter(function(r$1) {
+				return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+			})), t.push.apply(t, o);
+		}
+		return t;
+	}
+	function _objectSpread2(e) {
+		for (var r = 1; r < arguments.length; r++) {
+			var t = null != arguments[r] ? arguments[r] : {};
+			r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+				defineProperty(e, r$1, t[r$1]);
+			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+				Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+			});
+		}
+		return e;
+	}
+	module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_objectSpread2 = __toESM(require_objectSpread2(), 1);
+
+//#endregion
+//#region src/types.ts
+/** Internal marker added to objects that represent a view payload. */
+const ViewKind = Symbol("__fate__view");
+/** Symbol used to attach the set of view tags that were spread into a ref or masked record. */
+const ViewsTag = Symbol("__fate__views");
+/** Symbol used to brand a value as a node reference inside the cache. */
+const NodeRefTag = Symbol("__fate__node-ref");
+/** Symbol attached to connection results so pagination helpers can find their metadata. */
+const ConnectionTag = Symbol("__fate__connection");
+const viewTag = "__fate-view__";
+/** Generates a stable view tag for a view definition. */
+function getViewTag(id$1) {
+	return `${viewTag}${id$1}`;
+}
+/** Determines whether a property key is a fate view tag. */
+function isViewTag(key) {
+	return key.startsWith(viewTag);
+}
+/** Indicates whether a request item represents an explicit node ID. */
+function isNodeItem(item) {
+	return "id" in item;
+}
+/** Indicates whether a request item represents explicit node IDs. */
+function isNodesItem(item) {
+	return "ids" in item;
+}
+/** Brand used on mutation definitions to mark their identity in the d.ts output. */
+const MutationKind = "__fate__mutation";
+
+//#endregion
+//#region src/view.ts
+/**
+* Collects all view payloads that apply to the given ref.
+*/
+const getViewPayloads = (view$1, ref) => {
+	const result = [];
+	for (const [key, value] of Object.entries(view$1)) if (isViewTag(key) && (!ref || ref[ViewsTag]?.has(key))) result.push(value);
+	return result;
+};
+/**
+* Returns the set of view tags defined on a view composition.
+*/
+const getViewNames = (view$1) => {
+	const result = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(view$1)) if (isViewTag(key)) result.add(key);
+	return result;
+};
+/**
+* Extracts view tags from a nested selection object.
+*/
+const getSelectionViewNames = (selection) => {
+	return getViewNames(selection);
+};
+let id = 0;
+const isDevelopment = import.meta?.env?.DEV || import.meta?.env?.NODE_ENV !== "production";
+let viewModulePath = null;
+const getStableId = () => {
+	if (isDevelopment) try {
+		if (viewModulePath == null) viewModulePath = new URL(import.meta.url).pathname;
+		const stack = (/* @__PURE__ */ new Error()).stack?.split("\n");
+		if (stack) for (let i = 1; i < stack.length; i++) {
+			const match = stack[i].trim().match(/\(?([^()]+):(\d+):(\d+)\)?$/);
+			if (!match) continue;
+			const [, source, line, column] = match;
+			if (!source.includes(viewModulePath)) {
+				const file = source.startsWith("at ") ? source.slice(3) : source;
+				return `${/^[A-Za-z][\d+.A-Za-z-]*:/.test(file) ? new URL(file).pathname : file}:${line}:${column}`;
+			}
+		}
+	} catch {}
+	return String(id++);
+};
+/**
+* Creates a reusable view for an object using the declared selection.
+*
+* @example
+* const PostView = view<Post>()({
+*   id: true,
+*   title: true,
+* });
+*/
+function view() {
+	const viewId = getStableId();
+	return (select) => {
+		const payload = Object.freeze({
+			select,
+			[ViewKind]: true
+		});
+		const viewComposition = Object.defineProperty({}, getViewTag(viewId), {
+			configurable: false,
+			enumerable: true,
+			value: payload,
+			writable: false
+		});
+		return Object.freeze(viewComposition);
+	};
+}
+
+//#endregion
+//#region src/ref.ts
+/**
+* Builds the canonical cache ID for an entity.
+*/
+const toEntityId = (type, rawId) => `${type}:${String(rawId)}`;
+/**
+* Splits a cache entity ID back into its type and raw identifier.
+*/
+function parseEntityId(id$1) {
+	const idx = id$1.indexOf(":");
+	return idx < 0 ? {
+		id: id$1,
+		type: ""
+	} : {
+		id: id$1.slice(idx + 1),
+		type: id$1.slice(0, idx)
+	};
+}
+/**
+* Attaches view tags to a ref without leaking the symbol.
+*/
+function assignViewTag(target, value) {
+	Object.defineProperty(target, ViewsTag, {
+		configurable: false,
+		enumerable: false,
+		value,
+		writable: false
+	});
+}
+const getRootViewNames = (view$1) => {
+	const names = new Set(getViewNames(view$1));
+	const payloads = getViewPayloads(view$1, 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) {
+	const ref = {
+		__typename,
+		id: id$1
+	};
+	assignViewTag(ref, options?.root ? getRootViewNames(view$1) : getViewNames(view$1));
+	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
+* partitioning nested args so the client can fetch exactly what is declared.
+*/
+const getSelectionPlan = (viewComposition, ref) => {
+	const args = /* @__PURE__ */ new Map();
+	const paths = /* @__PURE__ */ new Set();
+	const assignArgs = (path, value, ignoreKeys) => {
+		const hash = hashArgs(value, { ignoreKeys });
+		args.set(path, {
+			hash,
+			ignoreKeys,
+			value
+		});
+	};
+	const walk = (selection, prefix, context = "default") => {
+		if (prefix === null && context !== "connection" && isConnectionSelection(selection)) {
+			if (selection.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;
+			walk(withoutArgs, prefix, "connection");
+			return;
+		}
+		for (const [key, value] of Object.entries(selection)) {
+			const valueType = typeof value;
+			const path = prefix ? `${prefix}.${key}` : key;
+			if (context === "connection") {
+				if (key === "args" || key === "pagination") continue;
+				if (key === "items" && isRecord(value)) {
+					if (isRecord(value.node)) walk(value.node, prefix);
+					continue;
+				}
+			}
+			if (valueType === "boolean") {
+				if (value) paths.add(path);
+				continue;
+			}
+			if (isViewTag(key)) {
+				if (!ref || ref[ViewsTag] && ref[ViewsTag].has(key)) walk(value.select, prefix);
+				continue;
+			}
+			if (isRecord(value)) {
+				const selectionObject = value;
+				if (isConnectionSelection(selectionObject)) {
+					if (selectionObject.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;
+					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;
+					selectionWithoutArgs = rest;
+				}
+				if (Object.keys(selectionWithoutArgs).length > 0) walk(selectionWithoutArgs, path);
+				else if (hasArgs) paths.add(path);
+			}
+		}
+	};
+	const payloads = getViewPayloads(viewComposition, ref);
+	if (payloads.length === 0 && isRecord(viewComposition)) walk(viewComposition, null);
+	else for (const payload of payloads) walk(payload.select, null);
+	return {
+		args,
+		paths
+	};
+};
+
+//#endregion
+//#region src/mutation.ts
+/**
+* Defines a mutation for a given entity type, preserving the input and output
+* types for transports.
+*/
+function mutation(entity) {
+	return Object.freeze({
+		entity,
+		[MutationKind]: true
+	});
+}
+const collectImplicitSelectedPaths = (value) => {
+	const paths = /* @__PURE__ */ new Set();
+	const walk = (current, prefix) => {
+		if (!current || typeof current !== "object") {
+			if (prefix) paths.add(prefix);
+			return;
+		}
+		if (Array.isArray(current)) {
+			if (prefix) paths.add(prefix);
+			for (const child of current) walk(child, prefix);
+			return;
+		}
+		for (const [key, child] of Object.entries(current)) {
+			const next = prefix ? `${prefix}.${key}` : key;
+			paths.add(next);
+			walk(child, next);
+		}
+	};
+	walk(value, null);
+	return paths;
+};
+const maybeGetId = (getId$1, input) => {
+	try {
+		return getId$1(input);
+	} catch {
+		return null;
+	}
+};
+const emptySet$1 = /* @__PURE__ */ new Set();
+/**
+* Binds a mutation definition to a `FateClient`, wiring up optimistic updates,
+* cache writes, and error handling.
+*/
+function wrapMutation(client, identifier) {
+	const config = client.getTypeConfig(identifier.entity);
+	return async ({ args, delete: deleteRecord, input, optimistic, view: view$1 }) => {
+		const id$1 = maybeGetId(config.getId, input);
+		const plan = view$1 ? getSelectionPlan(view$1, null) : void 0;
+		const viewSelection = plan?.paths;
+		const optimisticRecord = optimistic ? id$1 != null ? {
+			id: id$1,
+			...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 snapshots = /* @__PURE__ */ new Map();
+		const listSnapshots = deleteRecord ? /* @__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();
+		const optimisticToken = optimisticEntityId ? client.registerOptimisticUpdate(optimisticEntityId, optimisticSelection ?? emptySet$1) : null;
+		if (optimisticRecord && optimisticEntityId) client.write(identifier.entity, optimisticRecord, optimisticSelection ?? emptySet$1, snapshots, plan);
+		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);
+		}
+		try {
+			const result = await client.executeMutation(identifier.key, input, selection, {
+				args,
+				plan
+			});
+			if (result && typeof result === "object" && (!deleteRecord || Boolean(view$1))) {
+				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);
+				if (deleteRecord && id$1 != null) client.deleteRecord(identifier.entity, id$1);
+				const resultId = maybeGetId(config.getId, result);
+				if (optimisticRecordId != null && resultId != null && optimisticRecordId !== resultId) client.deleteRecord(identifier.entity, optimisticRecordId);
+			}
+			return {
+				error: void 0,
+				result
+			};
+		} catch (error) {
+			client.clearOptimisticUpdate(optimisticToken);
+			if (snapshots.size > 0) for (const [id$2, snapshot] of snapshots) client.restore(id$2, 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;
+				return {
+					error,
+					result: void 0
+				};
+			} else throw new Error(`fate: Mutation '${identifier.key}' failed.`);
+		} finally {
+			client.clearOptimisticUpdate(optimisticToken);
+		}
+	};
+}
+function categorizeTRPCError(statusCode) {
+	switch (statusCode) {
+		case 400:
+		case 402:
+		case 404:
+		case 408:
+		case 409:
+		case 412:
+		case 413:
+		case 415:
+		case 422:
+		case 429:
+		case 499: return "callSite";
+		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) {
+	const ref = {};
+	Object.defineProperty(ref, NodeRefTag, {
+		configurable: false,
+		enumerable: false,
+		value: id$1,
+		writable: false
+	});
+	return Object.freeze(ref);
+}
+function isNodeRef(value) {
+	return !value || typeof value !== "object" ? false : NodeRefTag in value;
+}
+function getNodeRefId(ref) {
+	return ref[NodeRefTag];
+}
+
+//#endregion
+//#region src/store.ts
+const getListKey = (ownerId, field, hash = "default") => `${ownerId} __fate__ ${field} __fate__ ${hash}`;
+const cloneValue = (value) => {
+	if (Array.isArray(value)) return value.map(cloneValue);
+	if (isNodeRef(value)) return value;
+	if (value != null && typeof value === "object") {
+		const result = {};
+		for (const [key, record] of Object.entries(value)) result[key] = cloneValue(record);
+		return result;
+	}
+	return value;
+};
+const emptyFunction = () => {};
+var Store = class {
+	constructor() {
+		this.coverage = /* @__PURE__ */ new Map();
+		this.lists = /* @__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);
+	}
+	merge(id$1, partial, paths) {
+		const changedPaths = this.mergeInternal(id$1, partial, paths);
+		if (changedPaths) this.notify(id$1, changedPaths);
+	}
+	mergeInternal(id$1, partial, paths) {
+		const previous = this.records.get(id$1);
+		const changedPaths = /* @__PURE__ */ new Set();
+		let mask = this.coverage.get(id$1);
+		if (!mask) {
+			mask = emptyMask();
+			this.coverage.set(id$1, mask);
+		}
+		union(mask, fromPaths(paths));
+		if (previous) {
+			let hasChanges = false;
+			for (const [key, value] of Object.entries(partial)) if (previous[key] !== value) {
+				hasChanges = true;
+				changedPaths.add(key);
+			}
+			if (!hasChanges) return null;
+			this.records.set(id$1, {
+				...previous,
+				...partial
+			});
+		} else this.records.set(id$1, { ...partial });
+		return changedPaths;
+	}
+	deleteRecord(id$1) {
+		this.records.delete(id$1);
+		this.coverage.delete(id$1);
+	}
+	missingForSelection(id$1, paths) {
+		const requested = new Set(paths);
+		if (!this.records.has(id$1)) return requested;
+		const mask = this.coverage.get(id$1);
+		if (!mask) return requested;
+		return diffPaths(requested, mask);
+	}
+	subscribe(id$1, selectionOrFn, callback) {
+		let mask = null;
+		let fn = emptyFunction;
+		if (typeof selectionOrFn === "function") fn = selectionOrFn;
+		else if (callback) {
+			mask = selectionOrFn ? fromPaths(selectionOrFn) : null;
+			fn = callback;
+		}
+		let subscribers = this.subscriptions.get(id$1);
+		if (!subscribers) {
+			subscribers = /* @__PURE__ */ new Set();
+			this.subscriptions.set(id$1, subscribers);
+		}
+		const subscription = {
+			fn,
+			mask
+		};
+		subscribers.add(subscription);
+		return () => {
+			const set = this.subscriptions.get(id$1);
+			if (!set) return;
+			set.delete(subscription);
+			if (set.size === 0) this.subscriptions.delete(id$1);
+		};
+	}
+	notify(id$1, paths) {
+		const set = this.subscriptions.get(id$1);
+		if (!set) return;
+		const changedPaths = paths ? [...paths] : [];
+		const changedMask = changedPaths.length > 0 ? fromPaths(changedPaths) : null;
+		for (const { fn, mask } of set) {
+			if (mask && changedMask && !intersects(changedMask, mask)) continue;
+			try {
+				fn();
+			} catch {}
+		}
+	}
+	notifyListSubscribers(key) {
+		const set = this.listSubscriptions.get(key);
+		if (!set) return;
+		for (const fn of set) try {
+			fn();
+		} catch {}
+	}
+	getList(key) {
+		return this.lists.get(key)?.ids;
+	}
+	getListState(key) {
+		return this.lists.get(key);
+	}
+	getListsForField(ownerId, field) {
+		const entries = [];
+		const prefix = getListKey(ownerId, field, "");
+		for (const entry of this.lists.entries()) if (entry[0].startsWith(prefix)) entries.push(entry);
+		return entries;
+	}
+	setList(key, state) {
+		this.lists.set(key, state);
+		this.notifyListSubscribers(key);
+	}
+	restoreList(key, list) {
+		if (list == null) this.lists.delete(key);
+		else this.setList(key, list);
+	}
+	subscribeList(key, fn) {
+		let set = this.listSubscriptions.get(key);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listSubscriptions.set(key, set);
+		}
+		set.add(fn);
+		return () => {
+			const subscribers = this.listSubscriptions.get(key);
+			if (!subscribers) return;
+			subscribers.delete(fn);
+			if (subscribers.size === 0) this.listSubscriptions.delete(key);
+		};
+	}
+	removeReferencesTo(targetId, viewDataCache, snapshots, listSnapshots) {
+		for (const [key, list] of this.lists.entries()) {
+			const { ids: ids$1 } = list;
+			if (!ids$1.includes(targetId)) 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);
+				if (cursors) cursors.push(list.cursors?.[index]);
+			}
+			this.setList(key, {
+				cursors,
+				ids: entityIds,
+				pagination: list.pagination
+			});
+		}
+		const ids = /* @__PURE__ */ new Map();
+		for (const [id$1, record] of this.records.entries()) {
+			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) {
+					updated = true;
+					paths.add(key);
+					next[key] = filtered;
+				}
+			} else if (isNodeRef(value) && getNodeRefId(value) === targetId) {
+				updated = true;
+				paths.add(key);
+				next[key] = null;
+			}
+			if (!updated) continue;
+			if (snapshots && !snapshots.has(id$1)) snapshots.set(id$1, this.snapshot(id$1));
+			viewDataCache.invalidate(id$1);
+			this.mergeInternal(id$1, next, paths);
+			ids.set(id$1, paths);
+		}
+		for (const [id$1, paths] of ids) this.notify(id$1, paths);
+	}
+	snapshot(id$1) {
+		const record = this.records.get(id$1);
+		const mask = this.coverage.get(id$1);
+		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);
+	}
+};
+
+//#endregion
+//#region src/client.ts
+const getId = (record) => {
+	if (!record || typeof record !== "object" || !("id" in record)) throw new Error(`fate: Missing 'id' on entity record.`);
+	const value = record.id;
+	const valueType = typeof value;
+	if (valueType !== "string" && valueType !== "number") throw new Error(`fate: Entity id must be a string or number, received '${valueType}'.`);
+	return value;
+};
+const emptySet = /* @__PURE__ */ new Set();
+const setNestedValue = (target, key, value) => {
+	const path = key.split(".");
+	let current = target;
+	for (let index = 0; index < path.length; index += 1) {
+		const segment = path[index];
+		const isLeaf = index === path.length - 1;
+		if (!segment) continue;
+		if (isLeaf) {
+			current[segment] = value;
+			return;
+		}
+		current[segment] = current[segment] ?? Object.create(null);
+		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;
+		const viewSignature = getViewSignature(item.root);
+		if (isNodeItem(item)) {
+			parts.push(`node:${name}:${item.type}:${viewSignature}:${item.id}`);
+			continue;
+		}
+		if (isNodesItem(item)) {
+			parts.push(`node:${name}:${item.type}:${viewSignature}:${item.ids.map(serializeId).join(",")}`);
+			continue;
+		}
+		parts.push(`list:${name}:${item.type}:${viewSignature}:${item.args ? hashArgs(item.args) : ""}`);
+	}
+	return parts.join("$");
+};
+const groupSelectionByPrefix = (select) => {
+	if (select.size === 0) return /* @__PURE__ */ new Map();
+	const result = /* @__PURE__ */ new Map();
+	for (const path of select) {
+		const separatorIndex = path.indexOf(".");
+		if (separatorIndex === -1) continue;
+		const prefix = path.slice(0, separatorIndex);
+		const remainder = path.slice(separatorIndex + 1);
+		let bucket = result.get(prefix);
+		if (!bucket) {
+			bucket = /* @__PURE__ */ new Set();
+			result.set(prefix, bucket);
+		}
+		bucket.add(remainder);
+	}
+	return result;
+};
+/**
+* Core client that normalizes records, manages the view cache, and coordinates
+* data fetching.
+*/
+var FateClient = class {
+	constructor(options) {
+		this.parentLists = /* @__PURE__ */ new Map();
+		this.pending = /* @__PURE__ */ new Map();
+		this.optimisticMasks = /* @__PURE__ */ new Map();
+		this.optimisticByEntity = /* @__PURE__ */ new Map();
+		this.optimisticTokenCounter = 0;
+		this.requests = /* @__PURE__ */ new Map();
+		this.stalledRequests = /* @__PURE__ */ new Set();
+		this.store = new Store();
+		this.viewDataCache = new ViewDataCache();
+		this.transport = options.transport;
+		this.types = new Map(options.types.map((entity) => [entity.type, {
+			getId,
+			...entity
+		}]));
+		this.mutationMap = Object.create(null);
+		this.mutations = Object.create(null);
+		this.actions = Object.create(null);
+		if (options.mutations) for (const [key, definition] of Object.entries(options.mutations)) {
+			const mutation$1 = wrapMutation(this, {
+				...definition,
+				key
+			});
+			this.mutationMap[key] = mutation$1;
+			setNestedValue(this.mutations, key, mutation$1);
+			setNestedValue(this.actions, key, async (_previousState, data) => data === "reset" ? null : await this.mutationMap[key](data));
+		}
+		this.initializeParentLists();
+	}
+	initializeParentLists() {
+		for (const config of this.types.values()) {
+			if (!config.fields) continue;
+			for (const [field, descriptor] of Object.entries(config.fields)) if (descriptor && typeof descriptor === "object" && "listOf" in descriptor) {
+				const childType = descriptor.listOf;
+				const childConfig = this.types.get(childType);
+				if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${config.type}.${field}').`);
+				if (!childConfig.fields) continue;
+				let via;
+				for (const [childField, childDescriptor] of Object.entries(childConfig.fields)) if (childDescriptor && typeof childDescriptor === "object" && "type" in childDescriptor && childDescriptor.type === config.type) {
+					via = childField;
+					break;
+				}
+				if (!via) continue;
+				let list = this.parentLists.get(childType);
+				if (!list) {
+					list = [];
+					this.parentLists.set(childType, list);
+				}
+				list.push({
+					field,
+					parentType: config.type,
+					via
+				});
+			}
+		}
+	}
+	getTypeConfig(type) {
+		const config = this.types.get(type);
+		if (!config) throw new Error(`fate: Unknown entity type '${type}'.`);
+		return config;
+	}
+	async executeMutation(key, input, select, options = {}) {
+		if (!this.transport.mutate) throw new Error(`fate: transport does not support mutations. Please provide a 'mutate' implementation in your transport.`);
+		const baseRecord = input && typeof input === "object" ? input : void 0;
+		const inputArgs = baseRecord && typeof baseRecord.args === "object" ? baseRecord.args : void 0;
+		const argsPayload = combineArgsPayload(options.plan ? resolvedArgsFromPlan(options.plan) : void 0, combineArgsPayload(inputArgs, options.args));
+		const requestInput = argsPayload && baseRecord ? {
+			...baseRecord,
+			args: argsPayload
+		} : argsPayload ? { args: argsPayload } : input;
+		return await this.transport.mutate(key, requestInput, select);
+	}
+	write(type, data, select, snapshots, plan, pathPrefix = null, blockedMask) {
+		return this.writeEntity(type, data, select, snapshots, plan, pathPrefix, blockedMask);
+	}
+	deleteRecord(type, id$1, snapshots, listSnapshots) {
+		const entityId = toEntityId(type, id$1);
+		if (snapshots && !snapshots.has(entityId)) snapshots.set(entityId, this.store.snapshot(entityId));
+		this.viewDataCache.invalidate(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);
+	}
+	restoreList(name, list) {
+		this.store.restoreList(name, list);
+	}
+	ref(type, id$1, view$1) {
+		return createRef(type, id$1, view$1);
+	}
+	rootListRef(entityId, rootView) {
+		const { id: id$1, type } = parseEntityId(entityId);
+		return createRef(type, id$1, rootView, { root: true });
+	}
+	readView(view$1, ref) {
+		const id$1 = ref.id;
+		const type = ref.__typename;
+		if (id$1 == 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 viewNames = getViewNames(view$1);
+		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);
+		if (cached) return cached;
+		const plan = getSelectionPlan(view$1, ref);
+		const selectedPaths = plan.paths;
+		const missing = this.store.missingForSelection(entityId, selectedPaths);
+		const resolveSnapshot = () => {
+			const resolvedView = this.readViewSelection(view$1, 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)));
+			return thenable;
+		};
+		if (missing.size === 0) {
+			this.clearStalledRequestsForEntity(entityId);
+			return resolveSnapshot();
+		}
+		if (missing.size > 0) {
+			const key = this.pendingKey(entityId, missing);
+			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(() => {
+				if (this.store.missingForSelection(entityId, selectedPaths).size > 0) {
+					this.stalledRequests.add(key);
+					return resolveSnapshot();
+				}
+				this.stalledRequests.delete(key);
+				return this.readView(view$1, ref);
+			});
+			this.pending.set(key, promise);
+			return promise;
+		}
+		return resolveSnapshot();
+	}
+	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) {
+				const incomingSet = new Set(incomingIds);
+				const remaining = existingIds.filter((id$1) => !incomingSet.has(id$1));
+				return isBackward ? [...remaining, ...incomingIds] : [...incomingIds, ...remaining];
+			}
+			const newIds = incomingIds.filter((id$1) => !existingSet.has(id$1));
+			return isBackward ? [...newIds, ...existingIds] : [...existingIds, ...newIds];
+		};
+		const ids = mergeIds();
+		const hasIncomingCursor = incomingCursors.some((cursor) => cursor !== void 0);
+		const cursorMap = /* @__PURE__ */ new Map();
+		if (previous?.cursors) previous.cursors.forEach((cursor, index) => {
+			cursorMap.set(existingIds[index], cursor);
+		});
+		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 previousPagination = previous?.pagination;
+		const newPagination = incomingPagination;
+		return {
+			cursors,
+			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
+		};
+	}
+	registerOptimisticUpdate(entityId, select) {
+		if (!entityId || select.size === 0) return null;
+		const mask = fromPaths(select);
+		const token = ++this.optimisticTokenCounter;
+		this.optimisticMasks.set(token, {
+			entityId,
+			mask
+		});
+		let entries = this.optimisticByEntity.get(entityId);
+		if (!entries) {
+			entries = /* @__PURE__ */ new Set();
+			this.optimisticByEntity.set(entityId, entries);
+		}
+		entries.add(token);
+		return token;
+	}
+	clearOptimisticUpdate(token) {
+		if (token == null) return;
+		const entry = this.optimisticMasks.get(token);
+		if (!entry) return;
+		this.optimisticMasks.delete(token);
+		const entityTokens = this.optimisticByEntity.get(entry.entityId);
+		if (entityTokens) {
+			entityTokens.delete(token);
+			if (entityTokens.size === 0) this.optimisticByEntity.delete(entry.entityId);
+		}
+	}
+	getPendingOptimisticMask(entityId, options = {}) {
+		if (!entityId) return null;
+		const tokens = this.optimisticByEntity.get(entityId);
+		if (!tokens || tokens.size === 0) return null;
+		let mask = null;
+		for (const token of tokens) {
+			if (options.excludeToken != null && token === options.excludeToken) continue;
+			const entry = this.optimisticMasks.get(token);
+			if (!entry) continue;
+			if (!mask) mask = cloneMask(entry.mask);
+			else union(mask, entry.mask);
+		}
+		return mask;
+	}
+	filterSelectionForPendingOptimistics(entityId, select, options = {}) {
+		if (!entityId || select.size === 0) return select;
+		const pendingMask = this.getPendingOptimisticMask(entityId, options);
+		if (!pendingMask) return select;
+		const filtered = /* @__PURE__ */ new Set();
+		for (const path of select) if (!isCovered(pendingMask, path)) filtered.add(path);
+		return filtered;
+	}
+	async loadConnection(view$1, 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 = {
+				...connection.args,
+				...args
+			};
+			const { argsPayload: argsPayload$1, plan: plan$1 } = this.resolveListSelection(view$1, requestArgs$1);
+			const { items, pagination } = await this.transport.fetchList(connection.field, plan$1.paths, argsPayload$1);
+			if (!items) return this.store.getListState(connection.key);
+			const incomingIds$1 = [];
+			const incomingCursors$1 = [];
+			for (const entry of items) {
+				const id$1 = this.write(connection.type, entry.node, plan$1.paths, void 0, plan$1);
+				incomingIds$1.push(id$1);
+				incomingCursors$1.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
+			});
+			this.store.setList(connection.key, nextListState$1);
+			return nextListState$1;
+		}
+		const owner = parseEntityId(connection.owner);
+		const requestArgs = {
+			...connection.args,
+			...args
+		};
+		if (requestArgs.id === void 0 && owner.id) requestArgs.id = owner.id;
+		const { argsPayload, plan } = this.resolveListSelection(view$1, requestArgs);
+		const nodeSelection = plan.paths;
+		const scopedArgsPayload = argsPayload ? scopeArgsPayload(argsPayload, connection.field) : void 0;
+		const parentSelection = /* @__PURE__ */ new Set();
+		for (const path of nodeSelection) parentSelection.add(`${connection.field}.${path}`);
+		const [parentRecord] = await this.transport.fetchById(owner.type, [owner.id], parentSelection, scopedArgsPayload);
+		if (!parentRecord || typeof parentRecord !== "object") return this.store.getListState(connection.key);
+		const list = parentRecord[connection.field];
+		const connectionPayload = Array.isArray(list) ? {
+			items: list.map((item) => ({
+				cursor: void 0,
+				node: item
+			})),
+			pagination: void 0
+		} : list;
+		if (!connectionPayload) return this.store.getListState(connection.key);
+		const incomingIds = [];
+		const incomingCursors = [];
+		const fieldConfig = this.getTypeConfig(owner.type).fields?.[connection.field];
+		const nodeType = fieldConfig && (fieldConfig === "scalar" ? null : "listOf" in fieldConfig ? fieldConfig.listOf : null) || null;
+		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);
+			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 nextListState = this.mergeListState(previous, incomingIds, incomingCursors, connectionPayload.pagination, {
+			direction,
+			hasCursorArg: 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 nextField = direction === "forward" ? [...existingField, ...nodeRefs] : [...nodeRefs, ...existingField];
+		this.viewDataCache.invalidate(connection.owner);
+		this.store.merge(connection.owner, { [connection.field]: nextField }, [connection.field]);
+		return this.store.getListState(connection.key);
+	}
+	request(request, options) {
+		const mode = options?.mode ?? "cache-first";
+		const requestKey = getRequestCacheKey(request);
+		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;
+		}
+		let requests = this.requests.get(requestKey);
+		if (!requests) {
+			requests = /* @__PURE__ */ new Map();
+			this.requests.set(requestKey, requests);
+		}
+		requests.set(mode, promise);
+		return promise;
+	}
+	releaseRequest(request, mode) {
+		const requestKey = getRequestCacheKey(request);
+		const requests = this.requests.get(requestKey);
+		if (!requests) return;
+		requests.delete(mode);
+		if (requests.size === 0) this.requests.delete(requestKey);
+	}
+	async handleStoreAndNetworkRequest(request) {
+		if (!this.hasRequestData(request)) {
+			await this.executeRequest(request, { fetchAll: true });
+			return this.getRequestResult(request);
+		}
+		const result = this.getRequestResult(request);
+		this.executeRequest(request, { fetchAll: true }).catch(() => {});
+		return result;
+	}
+	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 isNode = isNodeItem(item);
+			if (isNode || isNodesItem(item)) {
+				const plan = getSelectionPlan(item.root, null);
+				const fields = plan.paths;
+				const fieldsSignature = [...fields].slice().sort().join(",");
+				const argsSignature = [...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,
+						type: item.type
+					};
+					groups.set(groupKey, group);
+				}
+				for (const raw of isNode ? [item.id] : 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 promises.push(this.fetchListAndNormalize(name, 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);
+			if (isNode || isNodesItem(item)) {
+				const fields = getSelectionPlan(item.root, null).paths;
+				for (const raw of isNode ? [item.id] : item.ids) {
+					const entityId = toEntityId(item.type, raw);
+					if (this.store.missingForSelection(entityId, fields).size > 0) return false;
+				}
+				continue;
+			}
+			if (!this.store.getList(name)) return false;
+		}
+		return true;
+	}
+	getRequestResult(request) {
+		const result = {};
+		for (const [name, item] of Object.entries(request)) {
+			if (isNodeItem(item)) {
+				result[name] = this.ref(item.type, item.id, item.root);
+				continue;
+			}
+			if (isNodesItem(item)) {
+				result[name] = item.ids.map((id$1) => this.ref(item.type, id$1, item.root));
+				continue;
+			}
+			const listState = this.store.getListState(name);
+			const nodeView = item.root && typeof item.root === "object" && "items" in item.root && item.root.items ? item.root.items.node ?? item.root : item.root;
+			const nodes = (listState?.ids ?? []).map((id$1) => this.rootListRef(id$1, nodeView));
+			if (item.root && typeof item.root === "object" && "items" in item.root) {
+				const connection = {
+					items: nodes.map((node, index) => ({
+						cursor: listState?.cursors?.[index],
+						node
+					})),
+					pagination: listState?.pagination
+				};
+				const { argsPayload } = this.resolveListSelection(item.root, item.args);
+				const metadata = {
+					args: argsPayload,
+					field: name,
+					key: name,
+					owner: name,
+					procedure: `request.${name}`,
+					root: true,
+					type: item.type
+				};
+				Object.defineProperty(connection, ConnectionTag, {
+					configurable: false,
+					enumerable: false,
+					value: metadata,
+					writable: false
+				});
+				result[name] = connection;
+				continue;
+			}
+			result[name] = nodes;
+		}
+		return result;
+	}
+	async fetchByIdAndNormalize(type, ids, select, plan, prefix = null) {
+		const resolvedArgs = resolvedArgsFromPlan(plan);
+		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 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 { argsPayload, plan } = this.resolveListSelection(item.root, item.args);
+		const { items, pagination } = await this.transport.fetchList(name, plan.paths, argsPayload);
+		const ids = [];
+		const cursors = [];
+		for (const entry of items) {
+			const id$1 = this.writeEntity(item.type, entry.node, plan.paths, void 0, plan);
+			ids.push(id$1);
+			cursors.push(entry.cursor);
+		}
+		this.store.setList(name, {
+			cursors,
+			ids,
+			pagination
+		});
+	}
+	resolveListSelection(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) {
+		const config = this.types.get(type);
+		if (!config) throw new Error(`fate: Found unknown entity type '${type}' in normalization.`);
+		const entityId = toEntityId(type, config.getId(record));
+		const result = {};
+		const selectionTree = groupSelectionByPrefix(select);
+		if (config.fields) for (const [key, relationDescriptor] of Object.entries(config.fields)) {
+			const value = record[key];
+			const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+			const fieldArgs = plan?.args.get(fieldPath);
+			const isFieldBlocked = blockedMask ? isCovered(blockedMask, fieldPath) : false;
+			if (relationDescriptor === "scalar") {
+				if (isFieldBlocked) continue;
+				result[key] = value;
+			} else if (relationDescriptor && typeof relationDescriptor === "object" && "type" in relationDescriptor) {
+				if (isFieldBlocked) continue;
+				const childPaths = selectionTree.get(key) ?? emptySet;
+				if (value && typeof value === "object" && !isNodeRef(value)) {
+					const childType = relationDescriptor.type;
+					const childConfig = this.types.get(childType);
+					if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${type}.${key}').`);
+					result[key] = createNodeRef(toEntityId(childType, childConfig.getId(value)));
+					this.writeEntity(childType, value, childPaths, snapshots, plan, fieldPath, blockedMask);
+				}
+			} else if (relationDescriptor && typeof relationDescriptor === "object" && "listOf" in relationDescriptor) {
+				if (isFieldBlocked) continue;
+				const childPaths = selectionTree.get(key) ?? emptySet;
+				const childType = relationDescriptor.listOf;
+				const childConfig = this.types.get(childType);
+				if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${type}.${key}').`);
+				const connection = (() => {
+					if (Array.isArray(value)) return { items: value.map((item) => ({ node: item })) };
+					if (value && typeof value === "object") {
+						const record$1 = value;
+						if (Array.isArray(record$1.items)) return {
+							items: record$1.items.map((node) => {
+								if (node && typeof node === "object" && "node" in node) {
+									const itemRecord = node;
+									return {
+										cursor: itemRecord.cursor,
+										node: itemRecord.node
+									};
+								}
+								return { node };
+							}),
+							pagination: record$1.pagination
+						};
+					}
+					return null;
+				})();
+				if (connection) {
+					const ids = [];
+					const cursors = [];
+					const nodeSelection = childPaths.size > 0 ? /* @__PURE__ */ new Set() : childPaths;
+					if (childPaths.size > 0) for (const path of childPaths) {
+						if (path.startsWith("items.node.")) {
+							nodeSelection.add(path.slice(11));
+							continue;
+						}
+						if (path.startsWith("node.")) {
+							nodeSelection.add(path.slice(5));
+							continue;
+						}
+						if (path === "items.node" || path.startsWith("items.")) continue;
+						nodeSelection.add(path);
+					}
+					for (const entry of connection.items) {
+						const node = entry.node;
+						const cursor = "cursor" in entry ? entry.cursor : void 0;
+						cursors.push(cursor);
+						if (isNodeRef(node)) {
+							ids.push(getNodeRefId(node));
+							continue;
+						}
+						if (node && typeof node === "object") {
+							const childId = toEntityId(childType, childConfig.getId(node));
+							this.writeEntity(childType, node, nodeSelection, snapshots, plan, fieldPath, blockedMask);
+							ids.push(childId);
+							continue;
+						}
+					}
+					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));
+					this.store.setList(listKey, nextListState);
+				}
+			} else result[key] = value;
+		}
+		for (const [key, value] of Object.entries(record)) if (!(key in (config.fields ?? {}))) {
+			const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+			if (blockedMask && isCovered(blockedMask, fieldPath)) continue;
+			result[key] = value;
+		}
+		if (snapshots && !snapshots.has(entityId)) snapshots.set(entityId, this.store.snapshot(entityId));
+		this.viewDataCache.invalidate(entityId);
+		this.store.merge(entityId, result, select);
+		this.linkParentLists(type, entityId, result, snapshots);
+		return entityId;
+	}
+	linkParentLists(type, entityId, record, snapshots) {
+		const parents = this.parentLists.get(type);
+		if (!parents) return;
+		for (const parent of parents) {
+			if (!parent.via) continue;
+			const parentRef = record[parent.via];
+			const parentId = isNodeRef(parentRef) ? getNodeRefId(parentRef) : null;
+			if (!parentId) continue;
+			const existing = this.store.read(parentId);
+			if (!existing) continue;
+			const current = Array.isArray(existing[parent.field]) ? existing[parent.field] : [];
+			if (current.some((item) => isNodeRef(item) && getNodeRefId(item) === entityId)) continue;
+			if (snapshots && !snapshots.has(parentId)) snapshots.set(parentId, this.store.snapshot(parentId));
+			this.viewDataCache.invalidate(parentId);
+			const nextList = [...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 && ids.length > defaultListState.cursors.length ? [...defaultListState.cursors, ...new Array(ids.length - defaultListState.cursors.length).fill(void 0)] : defaultListState?.cursors;
+			this.store.setList(defaultListKey, {
+				cursors: nextDefaultCursors,
+				ids,
+				pagination: defaultListState?.pagination
+			});
+			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 = [...listState.ids, entityId];
+				const listCursors = listState.cursors ? [...listState.cursors, void 0] : void 0;
+				this.store.setList(listKey, {
+					cursors: listCursors,
+					ids: listIds,
+					pagination: listState.pagination
+				});
+			}
+			this.store.merge(parentId, { [parent.field]: nextList }, [parent.field]);
+		}
+	}
+	readViewSelection(viewComposition, ref, entityId, plan, pathPrefix = null) {
+		const record = this.store.read(entityId) || { id: entityId };
+		const ids = /* @__PURE__ */ new Set();
+		ids.add(entityId);
+		const coverageById = /* @__PURE__ */ new Map();
+		const walk = (viewPayload, record$1, target, parentId, prefix) => {
+			for (const [key, selectionKind] of Object.entries(viewPayload)) {
+				if (isViewTag(key)) {
+					if (!target[ViewsTag]) assignViewTag(target, /* @__PURE__ */ new Set());
+					target[ViewsTag].add(key);
+					continue;
+				}
+				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];
+				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];
+						continue;
+					}
+					if (!(key in target)) target[key] = {};
+					const nextSelection = Object.keys(selectionWithoutArgs).length ? selectionWithoutArgs : selectionValue;
+					const value = record$1[key];
+					if (Array.isArray(value)) if (nextSelection.items && typeof nextSelection.items === "object") {
+						const selection = nextSelection.items;
+						const fieldArgs = plan.args.get(fieldPath);
+						const listKey = getListKey(parentId, key, fieldArgs?.hash);
+						const listState = this.store.getListState(listKey);
+						const connection = { items: value.map((item, index) => {
+							const entityId$1 = isNodeRef(item) ? getNodeRefId(item) : null;
+							if (!entityId$1) 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);
+							const node = {
+								__typename: type,
+								id: id$1
+							};
+							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 ("pagination" in nextSelection && nextSelection.pagination) {
+							const paginationSelection = nextSelection.pagination;
+							const storedPagination = listState?.pagination;
+							if (storedPagination) {
+								const pagination = {};
+								if (paginationSelection.nextCursor === true) {
+									if (storedPagination.nextCursor !== void 0) pagination.nextCursor = storedPagination.nextCursor;
+								}
+								if (paginationSelection.previousCursor === true) {
+									if (storedPagination.previousCursor !== void 0) pagination.previousCursor = storedPagination.previousCursor;
+								}
+								if (paginationSelection.hasNext === true) pagination.hasNext = storedPagination.hasNext;
+								if (paginationSelection.hasPrevious === true) pagination.hasPrevious = storedPagination.hasPrevious;
+								if (Object.keys(pagination).length > 0) connection.pagination = pagination;
+							} else connection.pagination = void 0;
+						}
+						const { id: ownerRawId, type: parentType } = parseEntityId(parentId);
+						const childType = (() => {
+							for (const item of value) if (isNodeRef(item)) return parseEntityId(getNodeRefId(item)).type;
+							return "";
+						})();
+						if (parentType) {
+							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;
+								})(),
+								field: key,
+								hash: fieldArgs?.hash,
+								key: listKey,
+								owner: parentId,
+								procedure: `${parentType}.${key}`,
+								root: false,
+								type: childType
+							};
+							Object.defineProperty(connection, ConnectionTag, {
+								configurable: false,
+								enumerable: false,
+								value: metadata,
+								writable: false
+							});
+						}
+						target[key] = connection;
+					} else target[key] = value.map((item) => {
+						const entityId$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 node = {
+								__typename: type,
+								id: id$1
+							};
+							walk(nextSelection, record$2, node, entityId$1, 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 targetRecord = target[key];
+						targetRecord.id = id$1;
+						targetRecord.__typename = type;
+						if (relatedRecord) walk(nextSelection, relatedRecord, targetRecord, entityId$1, fieldPath);
+					} else walk(nextSelection, record$1, target[key], entityId, fieldPath);
+				}
+			}
+		};
+		const data = { __typename: parseEntityId(entityId).type };
+		for (const viewPayload of getViewPayloads(viewComposition, ref)) walk(viewPayload.select, record, data, entityId, pathPrefix);
+		return {
+			coverage: [...coverageById.entries()],
+			data
+		};
+	}
+	clearStalledRequestsForEntity(entityId) {
+		const prefix = this.pendingPrefix(entityId);
+		for (const key of this.stalledRequests) if (key.startsWith(prefix)) this.stalledRequests.delete(key);
+	}
+	pendingPrefix(entityId) {
+		return `__fate__|${entityId}|`;
+	}
+	pendingKey(entityId, missingFields) {
+		return `${this.pendingPrefix(entityId)}${[...missingFields].sort().join("|")}`;
+	}
+};
+function createClient(options) {
+	return new FateClient(options);
+}
+
+//#endregion
+//#region src/transport.ts
+/**
+* Builds a `Transport` backed by a tRPC client using the configured resolvers
+* for by-id queries, lists, and mutations.
+*/
+function createTRPCTransport({ byId, client, lists, mutations }) {
+	const transport = {
+		async fetchById(type, ids, select, args) {
+			const resolver = byId[type];
+			if (!resolver) throw new Error(`fate(trpc): No 'byId' resolver configured for entity type '${type}'.`);
+			return await resolver(client)({
+				args,
+				ids,
+				select: [...select]
+			});
+		},
+		async fetchList(procedure, select, args) {
+			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)({
+				args,
+				select: [...select]
+			});
+		}
+	};
+	transport.mutate = async (procedure, input, select) => {
+		const resolver = mutations?.[procedure];
+		if (!resolver) throw new Error(`fate(trpc): Missing mutation resolver for procedure '${procedure}'.`);
+		return await resolver(client)({
+			...input,
+			select: [...select]
+		});
+	};
+	return transport;
+}
+
+//#endregion
+export { ConnectionTag, FateClient, createClient, createTRPCTransport, getSelectionPlan, isViewTag, mutation, toEntityId, view };