@nkzw/fate 1.3.3 → 1.5.0

package/lib/store-CeatPJeK.mjs

@@ -0,0 +1,1350 @@
+import { t as isRecord } from "./record-B07VwXd-.mjs";
+import { a as hashArgs, n as cloneArgs, o as paginationArgKeys } from "./args-CRLIRl_v.mjs";
+import { d as MutationKind, h as getViewTag, l as DeferTag, m as ViewsTag, o as getNodeRefId, p as ViewKind, s as isNodeRef, u as DeferredTag, y as isViewTag } from "./hydration-DPZRJgnu.mjs";
+import { t as FateRequestError } from "./protocol-DS5sf6sd.mjs";
+//#region src/defer.ts
+function defer(selection) {
+	return Object.freeze({ [DeferTag]: selection });
+}
+const isDeferredSelection = (value) => typeof value === "object" && value !== null && DeferTag in value;
+const getDeferredSelection = (selection) => selection[DeferTag];
+const createDeferred = (metadata) => Object.freeze({ [DeferredTag]: metadata });
+const isDeferred = (value) => typeof value === "object" && value !== null && DeferredTag in value;
+const getDeferredMetadata = (deferred) => deferred[DeferredTag];
+//#endregion
+//#region ../../node_modules/.pnpm/@trpc+server@11.18.0_typescript@7.0.2/node_modules/@trpc/server/dist/getErrorShape-BPSzUA7W.mjs
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+const JSONRPC2_TO_HTTP_CODE = {
+	PARSE_ERROR: 400,
+	BAD_REQUEST: 400,
+	UNAUTHORIZED: 401,
+	PAYMENT_REQUIRED: 402,
+	FORBIDDEN: 403,
+	NOT_FOUND: 404,
+	METHOD_NOT_SUPPORTED: 405,
+	TIMEOUT: 408,
+	CONFLICT: 409,
+	PRECONDITION_FAILED: 412,
+	PAYLOAD_TOO_LARGE: 413,
+	UNSUPPORTED_MEDIA_TYPE: 415,
+	UNPROCESSABLE_CONTENT: 422,
+	PRECONDITION_REQUIRED: 428,
+	TOO_MANY_REQUESTS: 429,
+	CLIENT_CLOSED_REQUEST: 499,
+	INTERNAL_SERVER_ERROR: 500,
+	NOT_IMPLEMENTED: 501,
+	BAD_GATEWAY: 502,
+	SERVICE_UNAVAILABLE: 503,
+	GATEWAY_TIMEOUT: 504
+};
+function getStatusCodeFromKey(code) {
+	var _JSONRPC2_TO_HTTP_COD;
+	return (_JSONRPC2_TO_HTTP_COD = JSONRPC2_TO_HTTP_CODE[code]) !== null && _JSONRPC2_TO_HTTP_COD !== void 0 ? _JSONRPC2_TO_HTTP_COD : 500;
+}
+function getHTTPStatusCodeFromError(error) {
+	return getStatusCodeFromKey(error.code);
+}
+var require_typeof = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
+	function _typeof$2(o) {
+		"@babel/helpers - typeof";
+		return module.exports = _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+			return typeof o$1;
+		} : function(o$1) {
+			return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+		}, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
+	}
+	module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPrimitive = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(exports, module) {
+	var _typeof$1 = require_typeof()["default"];
+	function toPrimitive$1(t, r) {
+		if ("object" != _typeof$1(t) || !t) return t;
+		var e = t[Symbol.toPrimitive];
+		if (void 0 !== e) {
+			var i = e.call(t, r || "default");
+			if ("object" != _typeof$1(i)) return i;
+			throw new TypeError("@@toPrimitive must return a primitive value.");
+		}
+		return ("string" === r ? String : Number)(t);
+	}
+	module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPropertyKey = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(exports, module) {
+	var _typeof = require_typeof()["default"];
+	var toPrimitive = require_toPrimitive();
+	function toPropertyKey$1(t) {
+		var i = toPrimitive(t, "string");
+		return "symbol" == _typeof(i) ? i : i + "";
+	}
+	module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_defineProperty = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
+	var toPropertyKey = require_toPropertyKey();
+	function _defineProperty(e, r, t) {
+		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+			value: t,
+			enumerable: !0,
+			configurable: !0,
+			writable: !0
+		}) : e[r] = t, e;
+	}
+	module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+__toESM(__commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
+	var defineProperty = require_defineProperty();
+	function ownKeys(e, r) {
+		var t = Object.keys(e);
+		if (Object.getOwnPropertySymbols) {
+			var o = Object.getOwnPropertySymbols(e);
+			r && (o = o.filter(function(r$1) {
+				return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+			})), t.push.apply(t, o);
+		}
+		return t;
+	}
+	function _objectSpread2(e) {
+		for (var r = 1; r < arguments.length; r++) {
+			var t = null != arguments[r] ? arguments[r] : {};
+			r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+				defineProperty(e, r$1, t[r$1]);
+			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+				Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+			});
+		}
+		return e;
+	}
+	module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} })(), 1);
+//#endregion
+//#region src/view.ts
+/**
+* Collects all view payloads that apply to the given ref.
+*/
+const getViewPayloads = (view, ref) => {
+	const result = [];
+	for (const [key, value] of Object.entries(view)) if (isViewTag(key) && (!ref || ref[ViewsTag]?.has(key))) result.push(value);
+	return result;
+};
+/**
+* Returns the set of view tags defined on a view composition.
+*/
+const getViewNames = (view) => {
+	const result = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(view)) if (isViewTag(key)) result.add(key);
+	return result;
+};
+/**
+* Extracts view tags from a nested selection object.
+*/
+const getSelectionViewNames = (selection) => {
+	return getViewNames(selection);
+};
+let id = 0;
+const importMetaEnvironment = import.meta.env;
+const isDevelopment = typeof importMetaEnvironment?.DEV === "boolean" ? importMetaEnvironment.DEV : typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : false;
+let viewModulePath = null;
+const getStableId = () => {
+	if (isDevelopment) try {
+		if (viewModulePath == null) viewModulePath = new URL(import.meta.url).pathname;
+		const stack = (/* @__PURE__ */ new Error()).stack?.split("\n");
+		if (stack) for (let i = 1; i < stack.length; i++) {
+			const match = stack[i].trim().match(/\(?([^()]+):(\d+):(\d+)\)?$/);
+			if (!match) continue;
+			const [, source, line, column] = match;
+			if (!source.includes(viewModulePath)) {
+				const file = source.startsWith("at ") ? source.slice(3) : source;
+				return `${/^[A-Za-z][\d+.A-Za-z-]*:/.test(file) ? new URL(file).pathname : file}:${line}:${column}`;
+			}
+		}
+	} catch {}
+	return String(id++);
+};
+/**
+* Creates a reusable view for an object using the declared selection.
+*
+* @example
+* const PostView = view<Post>()({
+*   id: true,
+*   title: true,
+* });
+*/
+function view() {
+	const viewId = getStableId();
+	return (select) => {
+		const payload = Object.freeze({
+			select,
+			[ViewKind]: true
+		});
+		const viewComposition = Object.defineProperty({}, getViewTag(viewId), {
+			configurable: false,
+			enumerable: true,
+			value: payload,
+			writable: false
+		});
+		return Object.freeze(viewComposition);
+	};
+}
+//#endregion
+//#region src/ref.ts
+/**
+* Builds the canonical cache ID for an entity.
+*/
+const toEntityId = (type, rawId) => `${type}:${String(rawId)}`;
+/**
+* Splits a cache entity ID back into its type and raw identifier.
+*/
+function parseEntityId(id) {
+	const idx = id.indexOf(":");
+	return idx < 0 ? {
+		id,
+		type: ""
+	} : {
+		id: id.slice(idx + 1),
+		type: id.slice(0, idx)
+	};
+}
+/**
+* Attaches view tags to a ref without leaking the symbol.
+*/
+function assignViewTag(target, value) {
+	Object.defineProperty(target, ViewsTag, {
+		configurable: false,
+		enumerable: false,
+		value,
+		writable: false
+	});
+}
+const getRootViewNames = (view) => {
+	const names = new Set(getViewNames(view));
+	const payloads = getViewPayloads(view, null);
+	for (const payload of payloads) for (const name of getSelectionViewNames(payload.select)) names.add(name);
+	return names;
+};
+function createRefWithViewNames(__typename, id, names) {
+	const ref = {
+		__typename,
+		id
+	};
+	assignViewTag(ref, names);
+	return Object.freeze(ref);
+}
+//#endregion
+//#region src/selection.ts
+const isConnectionSelection = (value) => isRecord(value.items) && "node" in value.items;
+/**
+* Flattens a view into a `SelectionPlan`, expanding composed views and
+* partitioning nested args so the client can fetch exactly what is declared.
+*/
+const getSelectionPlan = (viewComposition, ref) => {
+	const args = /* @__PURE__ */ new Map();
+	const live = /* @__PURE__ */ new Map();
+	const paths = /* @__PURE__ */ new Set();
+	const assignArgs = (path, value, ignoreKeys) => {
+		const hash = hashArgs(value, { ignoreKeys });
+		args.set(path, {
+			hash,
+			ignoreKeys,
+			value
+		});
+	};
+	const walk = (selection, prefix, context = "default") => {
+		if (prefix === null && context !== "connection" && isConnectionSelection(selection)) {
+			if (selection.live && isRecord(selection.live)) live.set("", {
+				append: selection.live.append === "visible" ? "visible" : "edge",
+				prepend: selection.live.prepend === "visible" ? "visible" : "edge"
+			});
+			if (selection.args && isRecord(selection.args)) {
+				const clonedArgs = cloneArgs(selection.args, "args");
+				const ignoreKeys = isRecord(selection.items) && isRecord(selection.items.node) ? paginationArgKeys : void 0;
+				assignArgs("", clonedArgs, ignoreKeys);
+			}
+			const { args: _args, live: _live, ...withoutArgs } = selection;
+			walk(withoutArgs, prefix, "connection");
+			return;
+		}
+		for (const [key, value] of Object.entries(selection)) {
+			const valueType = typeof value;
+			const path = prefix ? `${prefix}.${key}` : key;
+			if (context === "connection") {
+				if (key === "args" || key === "live" || key === "pagination") continue;
+				if (key === "items" && isRecord(value)) {
+					if (isRecord(value.node)) walk(value.node, prefix);
+					continue;
+				}
+			}
+			if (valueType === "boolean") {
+				if (value) paths.add(path);
+				continue;
+			}
+			if (isDeferredSelection(value)) continue;
+			if (isViewTag(key)) {
+				if (!ref || ref[ViewsTag] && ref[ViewsTag].has(key)) walk(value.select, prefix);
+				continue;
+			}
+			if (isRecord(value)) {
+				const selectionObject = value;
+				if (isConnectionSelection(selectionObject)) {
+					if (selectionObject.live && isRecord(selectionObject.live)) live.set(path, {
+						append: selectionObject.live.append === "visible" ? "visible" : "edge",
+						prepend: selectionObject.live.prepend === "visible" ? "visible" : "edge"
+					});
+					if (selectionObject.args && isRecord(selectionObject.args)) {
+						const clonedArgs = cloneArgs(selectionObject.args, path);
+						const ignoreKeys = isRecord(selectionObject.items) && isRecord(selectionObject.items.node) ? paginationArgKeys : void 0;
+						assignArgs(path, clonedArgs, ignoreKeys);
+					}
+					const { args: _ignored, live: _live, ...withoutArgs } = selectionObject;
+					walk(withoutArgs, path, "connection");
+					continue;
+				}
+				const hasArgs = selectionObject.args && isRecord(selectionObject.args);
+				let selectionWithoutArgs = selectionObject;
+				if (hasArgs) {
+					const clonedArgs = cloneArgs(selectionObject.args, path);
+					const ignoreKeys = isRecord(selectionObject.items) && isRecord(selectionObject.items?.node) ? paginationArgKeys : void 0;
+					assignArgs(path, clonedArgs, ignoreKeys);
+					const { args: _args, ...rest } = selectionObject;
+					selectionWithoutArgs = rest;
+				}
+				if (Object.keys(selectionWithoutArgs).length > 0) walk(selectionWithoutArgs, path);
+				else if (hasArgs) paths.add(path);
+			}
+		}
+	};
+	const payloads = getViewPayloads(viewComposition, ref);
+	if (payloads.length === 0 && isRecord(viewComposition)) walk(viewComposition, null);
+	else for (const payload of payloads) walk(payload.select, null);
+	return {
+		args,
+		live,
+		paths
+	};
+};
+const getDeferredSelectionPlan = (field, selection) => {
+	return getSelectionPlan({ [field]: selection }, null);
+};
+//#endregion
+//#region src/mutation.ts
+/**
+* Defines a mutation for a given entity type, preserving the input and output
+* types for transports.
+*/
+function mutation(entity) {
+	return Object.freeze({
+		entity,
+		[MutationKind]: true
+	});
+}
+const collectImplicitSelectedPaths = (value) => {
+	const paths = /* @__PURE__ */ new Set();
+	const walk = (current, prefix) => {
+		if (!current || typeof current !== "object") {
+			if (prefix) paths.add(prefix);
+			return;
+		}
+		if (Array.isArray(current)) {
+			if (prefix) paths.add(prefix);
+			for (const child of current) walk(child, prefix);
+			return;
+		}
+		for (const [key, child] of Object.entries(current)) {
+			const next = prefix ? `${prefix}.${key}` : key;
+			paths.add(next);
+			walk(child, next);
+		}
+	};
+	walk(value, null);
+	return paths;
+};
+const maybeGetId = (getId, input) => {
+	try {
+		return getId(input);
+	} catch {
+		return null;
+	}
+};
+const emptySet = /* @__PURE__ */ new Set();
+/** @internal Creates the same optimistic/confirmation machinery for live and restored calls. */
+function prepareMutation(client, command, config, durable = false) {
+	const { args, delete: deleteRecord, entity, input, insert, key, optimistic, plan } = command;
+	const id = maybeGetId(config.getId, input);
+	const optimisticRecord = optimistic ? id != null ? {
+		id,
+		...optimistic
+	} : optimistic : void 0;
+	const optimisticRecordId = optimisticRecord ? maybeGetId(config.getId, optimisticRecord) : null;
+	const optimisticEntityId = id != null ? toEntityId(entity, id) : optimisticRecordId != null ? toEntityId(entity, optimisticRecordId) : null;
+	const optimisticSelection = optimisticRecord ? collectImplicitSelectedPaths(optimisticRecord) : void 0;
+	const selection = /* @__PURE__ */ new Set([...plan?.paths ?? [], ...optimisticSelection ?? []]);
+	if (deleteRecord && id == null) throw new Error(`fate: Mutation '${key}' requires an 'id' to delete.`);
+	const settle = client.store.optimisticUpdate(() => {
+		if (optimisticRecord && optimisticEntityId) client.write(entity, optimisticRecord, optimisticSelection ?? emptySet, plan, insert);
+		if (deleteRecord && id != null) client.deleteRecord(entity, id);
+	}, durable);
+	return {
+		commit: (result) => settle(() => {
+			if (result && typeof result === "object" && (!deleteRecord || plan)) {
+				client.write(entity, result, collectImplicitSelectedPaths(result), plan, insert);
+				const resultId = maybeGetId(config.getId, result);
+				if (optimisticEntityId && resultId != null) client.resolveOptimisticEntity(optimisticEntityId, toEntityId(entity, resultId));
+				if (optimisticRecordId != null && resultId != null && optimisticRecordId !== resultId) client.deleteRecord(entity, optimisticRecordId);
+			}
+			if (deleteRecord && id != null) client.deleteRecord(entity, id);
+		}),
+		entityId: optimisticEntityId,
+		execute: (identity) => client.executeMutation(key, input, selection, {
+			args,
+			identity,
+			plan
+		}),
+		rollback: () => settle()
+	};
+}
+/** Binds a mutation's optimistic updates, cache writes, and error handling. */
+function wrapMutation(client, identifier) {
+	const config = client.getTypeConfig(identifier.entity);
+	return async ({ args, delete: deleteRecord, input, insert = "after", optimistic, persist, view }) => {
+		const command = {
+			args,
+			delete: deleteRecord,
+			entity: identifier.entity,
+			input,
+			insert,
+			key: identifier.key,
+			optimistic,
+			plan: view ? getSelectionPlan(view, null) : void 0
+		};
+		if (client.persistence && persist !== false) try {
+			return {
+				error: void 0,
+				result: await client.withPersistenceLifecycle(() => client.persistence.mutate(command))
+			};
+		} catch (error) {
+			return handleMutationError(identifier.key, error);
+		}
+		if (client.persistence) await client.withPersistenceLifecycle(() => client.persistence.ready);
+		client.assertPersistenceActive();
+		const operation = prepareMutation(client, command, config);
+		const performMutation = async () => {
+			try {
+				const result = await operation.execute();
+				client.assertPersistenceActive();
+				operation.commit(result);
+				return {
+					error: void 0,
+					result
+				};
+			} catch (error) {
+				operation.rollback();
+				return handleMutationError(identifier.key, error);
+			}
+		};
+		const mutationPromise = client.trackPendingRequest(performMutation);
+		if (operation.entityId) client.registerPendingOptimisticMutation(operation.entityId, mutationPromise);
+		return mutationPromise;
+	};
+}
+const handleMutationError = (key, error) => {
+	if (error instanceof Error) {
+		const statusCode = getErrorStatusCode(error);
+		if ((statusCode ? categorizeHTTPErrorStatus(statusCode) : "boundary") === "boundary") throw error;
+		return {
+			error,
+			result: void 0
+		};
+	}
+	throw new Error(`fate: Mutation '${key}' failed.`, { cause: error });
+};
+const getErrorStatusCode = (error) => {
+	if (error instanceof FateRequestError) return error.status;
+	const { data } = error;
+	if (!data || typeof data !== "object") return;
+	return getHTTPStatusCodeFromError(data);
+};
+const categorizeHTTPErrorStatus = (statusCode) => {
+	switch (statusCode) {
+		case 400:
+		case 402:
+		case 404:
+		case 408:
+		case 409:
+		case 412:
+		case 413:
+		case 415:
+		case 422:
+		case 429:
+		case 499: return "callSite";
+		default: return "boundary";
+	}
+};
+//#endregion
+//#region src/mask.ts
+function emptyMask() {
+	return {
+		all: false,
+		children: /* @__PURE__ */ new Map()
+	};
+}
+function cloneMask(m) {
+	const clone = {
+		all: m.all,
+		children: /* @__PURE__ */ new Map()
+	};
+	for (const [key, value] of m.children) clone.children.set(key, cloneMask(value));
+	return clone;
+}
+function addPath(mask, path) {
+	if (mask.all) return;
+	const parts = path.split(".");
+	let current = mask;
+	for (let i = 0; i < parts.length; i++) {
+		const seg = parts[i];
+		let child = current.children.get(seg);
+		if (!child) {
+			child = emptyMask();
+			current.children.set(seg, child);
+		}
+		current = child;
+	}
+	current.all = true;
+	current.children.clear();
+}
+function union(into, b) {
+	if (into.all || b.all) {
+		into.all = true;
+		into.children.clear();
+		return;
+	}
+	for (const [key, child] of b.children) {
+		const exist = into.children.get(key);
+		if (!exist) into.children.set(key, cloneMask(child));
+		else union(exist, child);
+	}
+}
+function fromPaths(paths) {
+	const mask = emptyMask();
+	for (const path of paths) addPath(mask, path);
+	return mask;
+}
+function toPaths(mask) {
+	const paths = [];
+	const visit = (current, prefix) => {
+		if (current.all) {
+			if (prefix) paths.push(prefix);
+			return;
+		}
+		for (const [key, child] of current.children) visit(child, prefix ? `${prefix}.${key}` : key);
+	};
+	visit(mask, null);
+	return paths;
+}
+function isCovered(mask, path) {
+	if (mask.all) return true;
+	const parts = path.split(".");
+	let current = mask;
+	for (let i = 0; i < parts.length; i++) {
+		if (!current) return false;
+		if (current.all) return true;
+		current = current.children.get(parts[i]);
+	}
+	return !!current && (current.all || current.children.size === 0);
+}
+function diffPaths(paths, mask) {
+	const missing = /* @__PURE__ */ new Set();
+	for (const path of paths) if (!isCovered(mask, path)) missing.add(path);
+	return missing;
+}
+function intersects(a, b) {
+	if (a.all || b.all) return true;
+	for (const [key, child] of a.children) {
+		const otherChild = b.children.get(key);
+		if (!otherChild) continue;
+		if (child.all || otherChild.all) return true;
+		if (intersects(child, otherChild)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/store.ts
+const listKeySeparator = " __fate__ ";
+const decodeListKeyPart = (part) => {
+	try {
+		return decodeURIComponent(part);
+	} catch {
+		return part;
+	}
+};
+const encodeListKeyPart = (part) => encodeURIComponent(part);
+const getListKey = (ownerId, field, hash = "default") => `${encodeListKeyPart(ownerId)}${listKeySeparator}${encodeListKeyPart(field)}${listKeySeparator}${encodeListKeyPart(hash)}`;
+const getOwnerFieldKey = (ownerId, field) => JSON.stringify([ownerId, field]);
+const parseListKey = (key) => {
+	const parts = key.split(listKeySeparator);
+	if (parts.length !== 3) return null;
+	const [ownerId, field] = parts;
+	return {
+		field: decodeListKeyPart(field),
+		ownerId: decodeListKeyPart(ownerId)
+	};
+};
+const isPlainRecord = (value) => {
+	if (value == null || typeof value !== "object" || Array.isArray(value) || isNodeRef(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+const isDate = (value) => value != null && typeof value === "object" && Object.prototype.toString.call(value) === "[object Date]" && typeof value.getTime === "function";
+const mergePreservingExisting = (incoming, existing) => {
+	if (!isPlainRecord(incoming) || !isPlainRecord(existing)) return existing;
+	const result = Object.create(null);
+	for (const [key, value] of Object.entries(incoming)) Object.defineProperty(result, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+	for (const [key, value] of Object.entries(existing)) Object.defineProperty(result, key, {
+		configurable: true,
+		enumerable: true,
+		value: Object.hasOwn(result, key) ? mergePreservingExisting(result[key], value) : value,
+		writable: true
+	});
+	return result;
+};
+const areHydrationValuesEqual = (left, right) => {
+	if (Object.is(left, right)) return true;
+	if (isNodeRef(left) || isNodeRef(right)) return isNodeRef(left) && isNodeRef(right) && getNodeRefId(left) === getNodeRefId(right);
+	if (isDate(left) || isDate(right)) return isDate(left) && isDate(right) && left.getTime() === right.getTime();
+	if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => areHydrationValuesEqual(value, right[index]));
+	if (!isPlainRecord(left) || !isPlainRecord(right)) return false;
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(right, key) && areHydrationValuesEqual(left[key], right[key]));
+};
+const areMasksEqual = (left, right) => {
+	if (left === right || left?.all && right?.all) return true;
+	if (!left || !right || left.all !== right.all || left.children.size !== right.children.size) return false;
+	for (const [key, child] of left.children) if (!areMasksEqual(child, right.children.get(key))) return false;
+	return true;
+};
+const emptyFunction = () => {};
+const hasReferences = (value) => isNodeRef(value) || Array.isArray(value) && value.some(isNodeRef);
+const areNormalizedValuesEqual = (left, right) => Object.is(left, right) || isNodeRef(left) && isNodeRef(right) && getNodeRefId(left) === getNodeRefId(right) || Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => areNormalizedValuesEqual(value, right[index]));
+var Store = class {
+	constructor(onRebase, onChange) {
+		this.onRebase = onRebase;
+		this.onChange = onChange;
+		this.coverage = /* @__PURE__ */ new Map();
+		this.listKeysByOwnerField = /* @__PURE__ */ new Map();
+		this.listKeysByReferencedEntity = /* @__PURE__ */ new Map();
+		this.lists = /* @__PURE__ */ new Map();
+		this.recordReferenceFields = /* @__PURE__ */ new Map();
+		this.recordReferencesByTarget = /* @__PURE__ */ new Map();
+		this.records = /* @__PURE__ */ new Map();
+		this.subscriptions = /* @__PURE__ */ new Map();
+		this.listSubscriptions = /* @__PURE__ */ new Map();
+		this.optimisticLayers = /* @__PURE__ */ new Set();
+		this.optimisticBase = {
+			lists: /* @__PURE__ */ new Map(),
+			records: /* @__PURE__ */ new Map()
+		};
+	}
+	get hasOptimisticUpdates() {
+		return this.optimisticLayers.size > 0;
+	}
+	get isRebasing() {
+		return this.rebase !== void 0;
+	}
+	/** Apply a synchronous cache update beneath the pending optimistic layers. */
+	update(apply) {
+		if (this.rebase || this.optimisticLayers.size === 0) return apply();
+		const rebase = {
+			lists: /* @__PURE__ */ new Map(),
+			records: /* @__PURE__ */ new Map()
+		};
+		this.rebase = rebase;
+		try {
+			for (const [id, snapshot] of this.optimisticBase.records) this.restore(id, snapshot);
+			for (const [key, list] of this.optimisticBase.lists) this.restoreList(key, list);
+			this.optimisticBase.records.clear();
+			this.optimisticBase.lists.clear();
+			return apply();
+		} finally {
+			try {
+				for (const layer of this.optimisticLayers) {
+					layer.writes.clear();
+					this.recordingLayer = layer;
+					layer.apply();
+				}
+			} finally {
+				this.recordingLayer = void 0;
+				const records = this.getRebaseChanges(rebase);
+				const lists = /* @__PURE__ */ new Set();
+				for (const [key, before] of rebase.lists) if (!areHydrationValuesEqual(before, this.lists.get(key))) {
+					lists.add(key);
+					const owner = parseListKey(key);
+					if (owner) {
+						if (!records.has(owner.ownerId)) records.set(owner.ownerId, /* @__PURE__ */ new Set([owner.field]));
+						else records.get(owner.ownerId)?.add(owner.field);
+					}
+				} else if (before) this.lists.set(key, before);
+				this.rebase = void 0;
+				this.onRebase?.(new Set(records.keys()));
+				for (const [id, paths] of records) this.notify(id, paths, false);
+				for (const key of lists) this.notifyListSubscribers(key, false);
+			}
+		}
+	}
+	getRebaseChanges(rebase) {
+		const changes = /* @__PURE__ */ new Map();
+		for (const [id, before] of rebase.records) {
+			const after = this.records.get(id);
+			const mask = this.coverage.get(id);
+			if (Boolean(before.record) !== Boolean(after) || before.mask?.all !== mask?.all) {
+				changes.set(id, void 0);
+				continue;
+			}
+			const paths = /* @__PURE__ */ new Set();
+			for (const key of /* @__PURE__ */ new Set([...Object.keys(before.record ?? {}), ...Object.keys(after ?? {})])) if (Object.hasOwn(before.record ?? {}, key) !== Object.hasOwn(after ?? {}, key) || !areNormalizedValuesEqual(before.record?.[key], after?.[key])) paths.add(key);
+			if (!areMasksEqual(before.mask, mask)) {
+				for (const path of before.mask ? toPaths(before.mask) : []) if (!mask || !isCovered(mask, path)) paths.add(path);
+				for (const path of mask ? toPaths(mask) : []) if (!before.mask || !isCovered(before.mask, path)) paths.add(path);
+			}
+			if (paths.size > 0) changes.set(id, paths);
+			else if (before.record) this.records.set(id, before.record);
+		}
+		return changes;
+	}
+	/** Returns an idempotent settlement function; omit its update to roll back. */
+	optimisticUpdate(apply, durable = false) {
+		const layer = {
+			apply,
+			durable,
+			writes: /* @__PURE__ */ new Map()
+		};
+		const settle = (commit) => {
+			if (!this.optimisticLayers.has(layer) || layer.settled) return;
+			this.update(() => {
+				const overlays = commit ? this.getPendingOverlap(layer, layer.writes) : /* @__PURE__ */ new Map();
+				if (overlays.size > 0) {
+					layer.settled = true;
+					layer.apply = () => {
+						for (const [id, { partial, paths }] of this.getPendingOverlap(layer, overlays)) this.merge(id, partial, paths);
+					};
+				} else this.optimisticLayers.delete(layer);
+				for (const pending of this.optimisticLayers) {
+					if (!pending.settled) break;
+					this.optimisticLayers.delete(pending);
+				}
+				commit?.();
+			});
+		};
+		this.optimisticLayers.add(layer);
+		try {
+			this.update(() => {});
+		} catch (error) {
+			settle();
+			throw error;
+		}
+		return settle;
+	}
+	getPendingOverlap(layer, writes) {
+		const earlier = [];
+		for (const pending of this.optimisticLayers) {
+			if (pending === layer) break;
+			if (!pending.settled) earlier.push(pending);
+		}
+		const overlaps = /* @__PURE__ */ new Map();
+		for (const [id, write] of writes) {
+			const partial = Object.fromEntries(Object.entries(write.partial).filter(([key, value]) => !hasReferences(value) && earlier.some(({ writes }) => {
+				const previous = writes.get(id)?.partial;
+				return previous && Object.hasOwn(previous, key) && !hasReferences(previous[key]);
+			})));
+			if (Object.keys(partial).length) overlaps.set(id, {
+				partial,
+				paths: new Set([...write.paths].filter((path) => Object.hasOwn(partial, path.split(".")[0])))
+			});
+		}
+		return overlaps;
+	}
+	captureRecord(id) {
+		if (!this.rebase) return;
+		for (const target of [this.rebase, this.recordingLayer && this.optimisticBase]) if (target && !target.records.has(id)) {
+			const mask = this.coverage.get(id);
+			target.records.set(id, {
+				mask: mask ? cloneMask(mask) : void 0,
+				record: this.records.get(id)
+			});
+		}
+	}
+	captureList(key) {
+		if (!this.rebase) return;
+		for (const target of [this.rebase, this.recordingLayer && this.optimisticBase]) if (target && !target.lists.has(key)) target.lists.set(key, this.lists.get(key));
+	}
+	get hasTransientOptimisticUpdates() {
+		return [...this.optimisticLayers].some((layer) => !layer.durable);
+	}
+	getOptimisticRoots() {
+		return {
+			baseRecords: [...this.optimisticBase.records.values()].flatMap(({ record }) => record ? [record] : []),
+			lists: [...this.optimisticBase.lists.keys()],
+			records: [...this.optimisticBase.records.keys(), ...[...this.optimisticBase.lists.values()].flatMap((list) => list ? [
+				...list.ids,
+				...list.pendingBeforeIds ?? [],
+				...list.pendingAfterIds ?? [],
+				...list.liveBeforeIds ?? [],
+				...list.liveAfterIds ?? []
+			] : [])]
+		};
+	}
+	/** @internal Indexed owners needed for mutation rollback. */
+	getPersistenceOwners(id) {
+		return {
+			lists: [...this.listKeysByReferencedEntity.get(id) ?? []],
+			records: [...this.recordReferencesByTarget.get(id)?.keys() ?? []]
+		};
+	}
+	/** @internal Read one confirmed record without copying the cache. */
+	readConfirmed(id) {
+		const snapshot = this.optimisticBase.records.get(id);
+		const record = snapshot ? snapshot.record : this.records.get(id);
+		const mask = snapshot ? snapshot.mask : this.coverage.get(id);
+		return record ? {
+			paths: mask ? toPaths(mask) : [],
+			record
+		} : void 0;
+	}
+	/** @internal */
+	readConfirmedList(key) {
+		return this.optimisticBase.lists.has(key) ? this.optimisticBase.lists.get(key) : this.lists.get(key);
+	}
+	dehydrateConfirmed() {
+		const records = new Map(this.records);
+		const coverage = new Map(this.coverage);
+		const lists = new Map(this.lists);
+		for (const [id, snapshot] of this.optimisticBase.records) {
+			if (snapshot.record === void 0) records.delete(id);
+			else records.set(id, snapshot.record);
+			if (snapshot.mask === void 0) coverage.delete(id);
+			else coverage.set(id, snapshot.mask);
+		}
+		for (const [key, list] of this.optimisticBase.lists) if (list === void 0) lists.delete(key);
+		else lists.set(key, list);
+		return {
+			coverage: [...coverage].map(([id, mask]) => [id, toPaths(mask)]),
+			lists: [...lists],
+			records: [...records]
+		};
+	}
+	dehydrate() {
+		return {
+			coverage: [...this.coverage].map(([id, mask]) => [id, toPaths(mask)]),
+			lists: [...this.lists],
+			records: [...this.records]
+		};
+	}
+	hydrate(state, mode, options = {}) {
+		const previousCoverage = this.coverage;
+		const previousLists = this.lists;
+		const previousRecords = this.records;
+		const coverage = mode === "replace" ? /* @__PURE__ */ new Map() : new Map([...previousCoverage].map(([id, mask]) => [id, cloneMask(mask)]));
+		const lists = mode === "replace" ? /* @__PURE__ */ new Map() : new Map(previousLists);
+		const records = mode === "replace" ? /* @__PURE__ */ new Map() : new Map(previousRecords);
+		for (const [id, incoming] of state.records) {
+			const previous = records.get(id);
+			const next = previous && mode === "preserve-existing" ? mergePreservingExisting(incoming, previous) : incoming;
+			records.set(id, previous && areHydrationValuesEqual(previous, next) ? previous : next);
+		}
+		for (const [id, paths] of state.coverage) {
+			const incoming = fromPaths(paths);
+			const previous = coverage.get(id);
+			if (previous && mode === "preserve-existing") union(previous, incoming);
+			else coverage.set(id, incoming);
+		}
+		for (const [key, list] of state.lists) {
+			const previous = lists.get(key);
+			if (mode === "replace" || !previous) lists.set(key, previous && areHydrationValuesEqual(previous, list) ? previous : list);
+		}
+		this.coverage = coverage;
+		this.lists = lists;
+		this.records = records;
+		this.rebuildIndexes();
+		const changedRecordIds = /* @__PURE__ */ new Set();
+		for (const id of /* @__PURE__ */ new Set([...previousRecords.keys(), ...records.keys()])) if (!areHydrationValuesEqual(previousRecords.get(id), records.get(id)) || !areMasksEqual(previousCoverage.get(id), coverage.get(id))) changedRecordIds.add(id);
+		const changedListKeys = /* @__PURE__ */ new Set();
+		for (const key of /* @__PURE__ */ new Set([...previousLists.keys(), ...lists.keys()])) if (!areHydrationValuesEqual(previousLists.get(key), lists.get(key))) changedListKeys.add(key);
+		const notify = () => {
+			for (const id of changedRecordIds) this.notify(id);
+			for (const key of changedListKeys) this.notifyListSubscribers(key);
+		};
+		if (!options.deferNotifications) notify();
+		return notify;
+	}
+	rebuildIndexes() {
+		this.listKeysByOwnerField.clear();
+		this.listKeysByReferencedEntity.clear();
+		this.recordReferenceFields.clear();
+		this.recordReferencesByTarget.clear();
+		for (const [id, record] of this.records) this.addRecordReferenceIndexes(id, record);
+		for (const [key, list] of this.lists) this.addListIndexes(key, list);
+	}
+	read(id) {
+		return this.records.get(id);
+	}
+	merge(id, partial, paths) {
+		return this.update(() => {
+			const changedPaths = this.mergeInternal(id, partial, paths);
+			if (changedPaths) this.notify(id, changedPaths);
+		});
+	}
+	mergeInternal(id, partial, paths) {
+		this.captureRecord(id);
+		const selectedPaths = this.recordingLayer ? new Set(paths) : paths;
+		if (this.recordingLayer) {
+			const write = this.recordingLayer.writes.get(id) ?? {
+				partial: {},
+				paths: /* @__PURE__ */ new Set()
+			};
+			Object.assign(write.partial, partial);
+			for (const path of selectedPaths) write.paths.add(path);
+			this.recordingLayer.writes.set(id, write);
+		}
+		const previous = this.records.get(id);
+		const changedPaths = /* @__PURE__ */ new Set();
+		let mask = this.coverage.get(id);
+		if (!mask) {
+			mask = emptyMask();
+			this.coverage.set(id, mask);
+		}
+		union(mask, fromPaths(selectedPaths));
+		if (previous) {
+			let hasChanges = false;
+			for (const [key, value] of Object.entries(partial)) if (previous[key] !== value) {
+				hasChanges = true;
+				changedPaths.add(key);
+			}
+			if (!hasChanges) return null;
+			const nextRecord = {
+				...previous,
+				...partial
+			};
+			this.records.set(id, nextRecord);
+			this.updateRecordReferenceIndexes(id, previous, nextRecord, changedPaths);
+		} else {
+			const nextRecord = { ...partial };
+			this.records.set(id, nextRecord);
+			this.updateRecordReferenceIndexes(id, void 0, nextRecord, Object.keys(nextRecord));
+		}
+		return changedPaths;
+	}
+	deleteRecord(id) {
+		return this.update(() => {
+			this.captureRecord(id);
+			const record = this.records.get(id);
+			if (record) this.removeRecordReferenceIndexes(id, record);
+			this.records.delete(id);
+			this.coverage.delete(id);
+			if (!this.recordingLayer) this.onChange?.("record", id);
+		});
+	}
+	missingForSelection(id, paths) {
+		const requested = new Set(paths);
+		if (!this.records.has(id)) return requested;
+		const mask = this.coverage.get(id);
+		if (!mask) return requested;
+		return diffPaths(requested, mask);
+	}
+	subscribe(id, selectionOrFn, callback) {
+		let mask = null;
+		let fn = emptyFunction;
+		if (typeof selectionOrFn === "function") fn = selectionOrFn;
+		else if (callback) {
+			mask = selectionOrFn ? fromPaths(selectionOrFn) : null;
+			fn = callback;
+		}
+		let subscribers = this.subscriptions.get(id);
+		if (!subscribers) {
+			subscribers = /* @__PURE__ */ new Set();
+			this.subscriptions.set(id, subscribers);
+		}
+		const subscription = {
+			fn,
+			mask
+		};
+		subscribers.add(subscription);
+		return () => {
+			const set = this.subscriptions.get(id);
+			if (!set) return;
+			set.delete(subscription);
+			if (set.size === 0) this.subscriptions.delete(id);
+		};
+	}
+	notify(id, paths, confirmed = true) {
+		if (confirmed && !this.recordingLayer) this.onChange?.("record", id, paths);
+		if (this.rebase) return;
+		const set = this.subscriptions.get(id);
+		if (!set) return;
+		const changedPaths = paths ? [...paths] : [];
+		const changedMask = changedPaths.length > 0 ? fromPaths(changedPaths) : null;
+		for (const { fn, mask } of set) {
+			if (mask && changedMask && !intersects(changedMask, mask)) continue;
+			try {
+				fn();
+			} catch {}
+		}
+	}
+	notifyListSubscribers(key, confirmed = true, previousList) {
+		if (confirmed && !this.recordingLayer) this.onChange?.("list", key, void 0, previousList);
+		if (this.rebase) return;
+		const set = this.listSubscriptions.get(key);
+		if (!set) return;
+		for (const fn of set) try {
+			fn();
+		} catch {}
+	}
+	getList(key) {
+		return this.lists.get(key)?.ids;
+	}
+	getListState(key) {
+		return this.lists.get(key);
+	}
+	getListsForField(ownerId, field) {
+		const entries = [];
+		const keys = this.listKeysByOwnerField.get(getOwnerFieldKey(ownerId, field));
+		if (!keys) return entries;
+		for (const key of keys) {
+			const list = this.lists.get(key);
+			if (list) entries.push([key, list]);
+		}
+		return entries;
+	}
+	setList(key, state) {
+		return this.update(() => {
+			this.captureList(key);
+			const previous = this.lists.get(key);
+			if (previous) this.removeListIndexes(key, previous);
+			this.lists.set(key, state);
+			this.addListIndexes(key, state);
+			this.notifyListSubscribers(key, true, previous);
+		});
+	}
+	replaceListEntityId(previousId, nextId) {
+		return this.update(() => {
+			const keys = [...this.listKeysByReferencedEntity.get(previousId) ?? []];
+			for (const key of keys) {
+				const list = this.lists.get(key);
+				if (!list) continue;
+				let changed = false;
+				let ids = list.ids;
+				let cursors = list.cursors;
+				if (list.ids.includes(previousId)) {
+					const nextIds = [];
+					const nextCursors = list.cursors ? [] : void 0;
+					const seenIds = /* @__PURE__ */ new Set();
+					list.ids.forEach((id, index) => {
+						const resolved = id === previousId ? nextId : id;
+						if (seenIds.has(resolved)) return;
+						seenIds.add(resolved);
+						nextIds.push(resolved);
+						if (nextCursors) nextCursors.push(list.cursors?.[index]);
+					});
+					changed = true;
+					ids = nextIds;
+					cursors = nextCursors;
+				}
+				const dedupe = (values) => {
+					if (!values || !values.includes(previousId)) return;
+					const seen = /* @__PURE__ */ new Set();
+					const next = [];
+					for (const value of values) {
+						const resolved = value === previousId ? nextId : value;
+						if (seen.has(resolved)) continue;
+						seen.add(resolved);
+						next.push(resolved);
+					}
+					changed = true;
+					return next;
+				};
+				const pendingBeforeIds = dedupe(list.pendingBeforeIds) ?? list.pendingBeforeIds;
+				const pendingAfterIds = dedupe(list.pendingAfterIds) ?? list.pendingAfterIds;
+				const liveBeforeIds = dedupe(list.liveBeforeIds) ?? list.liveBeforeIds;
+				const liveAfterIds = dedupe(list.liveAfterIds) ?? list.liveAfterIds;
+				if (!changed) continue;
+				const canonicalIds = new Set(ids);
+				this.setList(key, {
+					backwardPageLimit: list.backwardPageLimit,
+					cursors,
+					forwardPageLimit: list.forwardPageLimit,
+					ids,
+					liveAfterIds: liveAfterIds?.filter((id) => !canonicalIds.has(id)),
+					liveBeforeIds: liveBeforeIds?.filter((id) => !canonicalIds.has(id)),
+					pagination: list.pagination,
+					pendingAfterIds: pendingAfterIds?.filter((id) => !canonicalIds.has(id)),
+					pendingBeforeIds: pendingBeforeIds?.filter((id) => !canonicalIds.has(id))
+				});
+			}
+		});
+	}
+	restoreList(key, list) {
+		return this.update(() => {
+			if (list == null) this.deleteList(key);
+			else this.setList(key, list);
+		});
+	}
+	collectGarbage(markedRecords, markedLists, options = {}) {
+		const records = /* @__PURE__ */ new Set();
+		const lists = /* @__PURE__ */ new Set();
+		for (const id of this.records.keys()) {
+			if (markedRecords.has(id)) continue;
+			records.add(id);
+		}
+		for (const key of this.lists.keys()) {
+			if (markedLists.has(key)) continue;
+			lists.add(key);
+		}
+		for (const id of records) {
+			const record = this.records.get(id);
+			if (record) this.removeRecordReferenceIndexes(id, record);
+			this.records.delete(id);
+			this.coverage.delete(id);
+			options.onRecordDeleted?.(id);
+		}
+		for (const key of lists) this.deleteList(key, true);
+		return {
+			lists,
+			records
+		};
+	}
+	deleteList(key, collected = false) {
+		return this.update(() => {
+			this.captureList(key);
+			const previous = this.lists.get(key);
+			if (previous) this.removeListIndexes(key, previous);
+			this.lists.delete(key);
+			this.notifyListSubscribers(key, !collected, previous);
+		});
+	}
+	subscribeList(key, fn) {
+		let set = this.listSubscriptions.get(key);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listSubscriptions.set(key, set);
+		}
+		set.add(fn);
+		return () => {
+			const subscribers = this.listSubscriptions.get(key);
+			if (!subscribers) return;
+			subscribers.delete(fn);
+			if (subscribers.size === 0) this.listSubscriptions.delete(key);
+		};
+	}
+	removeReferencesTo(targetId, viewDataCache) {
+		return this.update(() => {
+			const listKeys = [...this.listKeysByReferencedEntity.get(targetId) ?? []];
+			for (const key of listKeys) {
+				const list = this.lists.get(key);
+				if (!list) continue;
+				const { ids } = list;
+				const hasLiveAfter = Boolean(list.liveAfterIds?.includes(targetId));
+				const hasLiveBefore = Boolean(list.liveBeforeIds?.includes(targetId));
+				const hasPendingAfter = Boolean(list.pendingAfterIds?.includes(targetId));
+				const hasPendingBefore = Boolean(list.pendingBeforeIds?.includes(targetId));
+				if (!ids.includes(targetId) && !hasLiveAfter && !hasLiveBefore && !hasPendingAfter && !hasPendingBefore) continue;
+				const entityIds = [];
+				const cursors = list.cursors ? [] : void 0;
+				for (let index = 0; index < ids.length; index++) {
+					const id = ids[index];
+					if (id === targetId) continue;
+					entityIds.push(id);
+					if (cursors) cursors.push(list.cursors?.[index]);
+				}
+				this.setList(key, {
+					backwardPageLimit: list.backwardPageLimit,
+					cursors,
+					forwardPageLimit: list.forwardPageLimit,
+					ids: entityIds,
+					liveAfterIds: list.liveAfterIds?.filter((id) => id !== targetId),
+					liveBeforeIds: list.liveBeforeIds?.filter((id) => id !== targetId),
+					pagination: list.pagination,
+					pendingAfterIds: list.pendingAfterIds?.filter((id) => id !== targetId),
+					pendingBeforeIds: list.pendingBeforeIds?.filter((id) => id !== targetId)
+				});
+			}
+			const ids = /* @__PURE__ */ new Map();
+			const recordEntries = [...this.recordReferencesByTarget.get(targetId)?.entries() ?? []];
+			for (const [id, fields] of recordEntries) {
+				const record = this.records.get(id);
+				if (!record) continue;
+				let updated = false;
+				const next = {};
+				const paths = /* @__PURE__ */ new Set();
+				for (const key of fields) {
+					const value = record[key];
+					if (Array.isArray(value)) {
+						const filtered = value.filter((item) => !(isNodeRef(item) && getNodeRefId(item) === targetId));
+						if (filtered.length !== value.length) {
+							updated = true;
+							paths.add(key);
+							next[key] = filtered;
+						}
+					} else if (isNodeRef(value) && getNodeRefId(value) === targetId) {
+						updated = true;
+						paths.add(key);
+						next[key] = null;
+					}
+				}
+				if (!updated) continue;
+				viewDataCache.invalidate(id);
+				this.mergeInternal(id, next, paths);
+				ids.set(id, paths);
+			}
+			for (const [id, paths] of ids) this.notify(id, paths);
+		});
+	}
+	restore(id, snapshot) {
+		return this.update(() => {
+			this.captureRecord(id);
+			const previous = this.records.get(id);
+			if (previous) this.removeRecordReferenceIndexes(id, previous);
+			if (snapshot.record === void 0) this.records.delete(id);
+			else {
+				this.records.set(id, snapshot.record);
+				this.addRecordReferenceIndexes(id, snapshot.record);
+			}
+			if (snapshot.mask === void 0) this.coverage.delete(id);
+			else this.coverage.set(id, snapshot.mask);
+			this.notify(id);
+		});
+	}
+	addListIndexes(key, list) {
+		const parsed = parseListKey(key);
+		if (parsed) {
+			const ownerFieldKey = getOwnerFieldKey(parsed.ownerId, parsed.field);
+			let keys = this.listKeysByOwnerField.get(ownerFieldKey);
+			if (!keys) {
+				keys = /* @__PURE__ */ new Set();
+				this.listKeysByOwnerField.set(ownerFieldKey, keys);
+			}
+			keys.add(key);
+		}
+		for (const id of this.getListReferencedEntityIds(list)) {
+			let keys = this.listKeysByReferencedEntity.get(id);
+			if (!keys) {
+				keys = /* @__PURE__ */ new Set();
+				this.listKeysByReferencedEntity.set(id, keys);
+			}
+			keys.add(key);
+		}
+	}
+	removeListIndexes(key, list) {
+		const parsed = parseListKey(key);
+		if (parsed) {
+			const ownerFieldKey = getOwnerFieldKey(parsed.ownerId, parsed.field);
+			const keys = this.listKeysByOwnerField.get(ownerFieldKey);
+			if (keys) {
+				keys.delete(key);
+				if (keys.size === 0) this.listKeysByOwnerField.delete(ownerFieldKey);
+			}
+		}
+		for (const id of this.getListReferencedEntityIds(list)) {
+			const keys = this.listKeysByReferencedEntity.get(id);
+			if (!keys) continue;
+			keys.delete(key);
+			if (keys.size === 0) this.listKeysByReferencedEntity.delete(id);
+		}
+	}
+	getListReferencedEntityIds(list) {
+		const ids = /* @__PURE__ */ new Set();
+		for (const id of list.ids) ids.add(id);
+		for (const id of list.liveAfterIds ?? []) ids.add(id);
+		for (const id of list.liveBeforeIds ?? []) ids.add(id);
+		for (const id of list.pendingAfterIds ?? []) ids.add(id);
+		for (const id of list.pendingBeforeIds ?? []) ids.add(id);
+		return ids;
+	}
+	getRecordFieldReferences(value) {
+		if (Array.isArray(value)) {
+			let ids = null;
+			for (const item of value) {
+				if (!isNodeRef(item)) continue;
+				if (!ids) ids = /* @__PURE__ */ new Set();
+				ids.add(getNodeRefId(item));
+			}
+			return ids;
+		}
+		if (isNodeRef(value)) return /* @__PURE__ */ new Set([getNodeRefId(value)]);
+		return null;
+	}
+	addRecordFieldReferenceIndex(id, field, value) {
+		const targets = this.getRecordFieldReferences(value);
+		if (!targets || targets.size === 0) return;
+		let fields = this.recordReferenceFields.get(id);
+		if (!fields) {
+			fields = /* @__PURE__ */ new Map();
+			this.recordReferenceFields.set(id, fields);
+		}
+		fields.set(field, targets);
+		for (const targetId of targets) {
+			let records = this.recordReferencesByTarget.get(targetId);
+			if (!records) {
+				records = /* @__PURE__ */ new Map();
+				this.recordReferencesByTarget.set(targetId, records);
+			}
+			let targetFields = records.get(id);
+			if (!targetFields) {
+				targetFields = /* @__PURE__ */ new Set();
+				records.set(id, targetFields);
+			}
+			targetFields.add(field);
+		}
+	}
+	removeRecordFieldReferenceIndex(id, field) {
+		const fields = this.recordReferenceFields.get(id);
+		const targets = fields?.get(field);
+		if (!fields || !targets) return;
+		for (const targetId of targets) {
+			const records = this.recordReferencesByTarget.get(targetId);
+			const targetFields = records?.get(id);
+			if (!records || !targetFields) continue;
+			targetFields.delete(field);
+			if (targetFields.size === 0) records.delete(id);
+			if (records.size === 0) this.recordReferencesByTarget.delete(targetId);
+		}
+		fields.delete(field);
+		if (fields.size === 0) this.recordReferenceFields.delete(id);
+	}
+	addRecordReferenceIndexes(id, record) {
+		for (const [field, value] of Object.entries(record)) this.addRecordFieldReferenceIndex(id, field, value);
+	}
+	removeRecordReferenceIndexes(id, record) {
+		for (const field of Object.keys(record)) this.removeRecordFieldReferenceIndex(id, field);
+	}
+	updateRecordReferenceIndexes(id, previous, next, fields) {
+		for (const field of fields) {
+			if (previous) this.removeRecordFieldReferenceIndex(id, field);
+			this.addRecordFieldReferenceIndex(id, field, next[field]);
+		}
+	}
+};
+//#endregion
+export { isDeferredSelection as C, isDeferred as S, view as _, mutation as a, getDeferredMetadata as b, getDeferredSelectionPlan as c, createRefWithViewNames as d, getRootViewNames as f, getViewPayloads as g, getViewNames as h, getErrorStatusCode as i, getSelectionPlan as l, toEntityId as m, getListKey as n, prepareMutation as o, parseEntityId as p, mergePreservingExisting as r, wrapMutation as s, Store as t, assignViewTag as u, createDeferred as v, getDeferredSelection as x, defer as y };