@nkzw/fate 1.3.3 → 1.5.0

package/lib/persistence.mjs

@@ -0,0 +1,1529 @@
+import { i as filterConnectionArgs } from "./args-CRLIRl_v.mjs";
+import { a as createNodeRef, n as decodeHydrationValue, o as getNodeRefId, r as encodeHydrationValue, s as isNodeRef, t as decodeClientHydrationState } from "./hydration-DPZRJgnu.mjs";
+import { i as getErrorStatusCode, m as toEntityId, n as getListKey, o as prepareMutation } from "./store-CeatPJeK.mjs";
+import { t as FateRequestError } from "./protocol-DS5sf6sd.mjs";
+//#region src/persistence-codec.ts
+const serializePlan = (plan) => ({
+	args: [...plan.args].map(([key, value]) => [key, {
+		...value,
+		ignoreKeys: value.ignoreKeys ? [...value.ignoreKeys] : void 0
+	}]),
+	live: [...plan.live],
+	paths: [...plan.paths]
+});
+const deserializePlan = (value) => ({
+	args: new Map(value.args.map(([key, entry]) => [key, {
+		...entry,
+		ignoreKeys: entry.ignoreKeys ? new Set(entry.ignoreKeys) : void 0
+	}])),
+	live: new Map(value.live),
+	paths: new Set(value.paths)
+});
+const encodeRequests = (requests) => encodeHydrationValue(requests.map((request) => ({
+	...request,
+	items: request.items.map((item) => ({
+		...item,
+		plan: serializePlan(item.plan),
+		..."refViewNames" in item ? { refViewNames: [...item.refViewNames] } : { nodeRefViewNames: [...item.nodeRefViewNames] }
+	}))
+})));
+const decodeRequests = (value) => decodeHydrationValue(value).map((request) => ({
+	...request,
+	items: request.items.map((item) => ({
+		...item,
+		plan: deserializePlan(item.plan),
+		..."refViewNames" in item ? { refViewNames: new Set(item.refViewNames) } : { nodeRefViewNames: new Set(item.nodeRefViewNames) }
+	}))
+}));
+//#endregion
+//#region src/persistence-cache.ts
+const mergeCacheUpdate = (key, before, after) => ({
+	fields: after.fields && (!before || before.fields) ? [.../* @__PURE__ */ new Set([...before?.fields ?? [], ...after.fields])] : void 0,
+	previousList: before ? before.previousList : after.previousList,
+	value: key.startsWith("r:") && before?.value && after.value ? applyRecordUpdate(before.value, after.value, after.fields ? new Set(after.fields) : void 0) : after.value
+});
+const encoder = new TextEncoder();
+const sized = (key, value) => {
+	const item = {
+		bytes: 0,
+		value
+	};
+	for (;;) {
+		const bytes = encoder.encode(JSON.stringify([key, item])).byteLength;
+		if (bytes === item.bytes) return item;
+		item.bytes = bytes;
+	}
+};
+const yieldTask$1 = () => new Promise((resolve) => setTimeout(resolve, 0));
+const stamp = (time) => String(time).padStart(16, "0");
+const recordKey = (id) => `r:${id}`;
+const listKey = (id) => `l:${id}`;
+const queryKey = (id) => `q:${id}`;
+const matches = (path, selected) => path === selected || path.startsWith(`${selected}.`) || selected.startsWith(`${path}.`);
+const project = (value, paths) => {
+	const fields = /* @__PURE__ */ new Set([
+		"id",
+		"__typename",
+		...paths.map((path) => path.split(".")[0])
+	]);
+	return {
+		paths: value.paths.filter((path) => paths.some((selected) => matches(path, selected))),
+		record: Object.fromEntries(Object.entries(value.record).filter(([field]) => fields.has(field)))
+	};
+};
+const applyRecordUpdate = (before, after, fields) => ({
+	paths: [.../* @__PURE__ */ new Set([...before.paths, ...after.paths.filter((path) => !fields || fields.has(path.split(".")[0]))])],
+	record: {
+		...before.record,
+		...Object.fromEntries(Object.entries(after.record).filter(([key]) => !fields || fields.has(key)))
+	}
+});
+const mergeIds = (before, after, latest) => {
+	const old = new Set(before);
+	const next = new Set(after);
+	let retained = latest.filter((id) => !old.has(id) || next.has(id));
+	const present = new Set(retained);
+	const oldOrder = before.filter((id) => next.has(id));
+	const nextOrder = after.filter((id) => old.has(id));
+	if (oldOrder.some((id, index) => id !== nextOrder[index])) {
+		let index = 0;
+		const reordered = nextOrder.filter((id) => present.has(id));
+		retained = retained.map((id) => old.has(id) ? reordered[index++] : id);
+	}
+	const insertions = /* @__PURE__ */ new Map();
+	let anchor;
+	for (let index = after.length - 1; index >= 0; index--) {
+		const id = after[index];
+		if (present.has(id)) anchor = id;
+		else if (!old.has(id)) {
+			const group = insertions.get(anchor) ?? [];
+			group.push(id);
+			insertions.set(anchor, group);
+			present.add(id);
+		}
+	}
+	return [...retained.flatMap((id) => [...insertions.get(id)?.reverse() ?? [], id]), ...insertions.get(void 0)?.reverse() ?? []];
+};
+const membershipFields = [
+	"ids",
+	"liveAfterIds",
+	"liveBeforeIds",
+	"pendingAfterIds",
+	"pendingBeforeIds"
+];
+const applyListUpdate = (latest, before, after) => {
+	const previousMembers = new Set(membershipFields.flatMap((field) => before[field] ?? []));
+	const latestMembers = new Set(membershipFields.flatMap((field) => latest[field] ?? []));
+	const surviving = (ids) => ids.filter((id) => !previousMembers.has(id) || latestMembers.has(id));
+	const ids = mergeIds(before.ids, surviving(after.ids), latest.ids);
+	const oldCursors = new Map(before.ids.map((id, index) => [id, before.cursors?.[index]]));
+	const nextCursors = new Map(after.ids.map((id, index) => [id, after.cursors?.[index]]));
+	const cursors = new Map(latest.ids.map((id, index) => [id, latest.cursors?.[index]]));
+	for (const [id, cursor] of nextCursors) if (!oldCursors.has(id) || oldCursors.get(id) !== cursor) cursors.set(id, cursor);
+	const result = {
+		...latest,
+		ids
+	};
+	if (latest.cursors || after.cursors) result.cursors = ids.map((id) => cursors.get(id));
+	for (const field of [
+		"liveAfterIds",
+		"liveBeforeIds",
+		"pendingAfterIds",
+		"pendingBeforeIds"
+	]) if (before[field] || after[field] || latest[field]) result[field] = mergeIds(before[field] ?? [], surviving(after[field] ?? []), latest[field] ?? []);
+	for (const field of ["backwardPageLimit", "forwardPageLimit"]) if (before[field] !== after[field]) result[field] = after[field];
+	if (after.pagination) result.pagination = {
+		...latest.pagination ?? after.pagination,
+		...Object.fromEntries(Object.entries(after.pagination).filter(([key, value]) => value !== before.pagination?.[key]))
+	};
+	return result;
+};
+const references = (value) => {
+	if (isNodeRef(value)) return JSON.stringify(["ref", getNodeRefId(value)]);
+	if (Array.isArray(value)) return JSON.stringify(value.map(references));
+	if (value && typeof value === "object") return JSON.stringify(Object.entries(value).map(([key, entry]) => [key, references(entry)]));
+	return "";
+};
+/** Independently addressable normalized disk data. No in-memory retention roots. */
+var PersistenceCache = class {
+	constructor(client, storage, key, maxAge, maxBytes) {
+		this.client = client;
+		this.storage = storage;
+		this.key = key;
+		this.maxAge = maxAge;
+		this.maxBytes = maxBytes;
+		this.changed = /* @__PURE__ */ new Map();
+		this.updates = /* @__PURE__ */ new Map();
+		this.listBases = /* @__PURE__ */ new Map();
+		this.updateListBases = /* @__PURE__ */ new Map();
+		this.fields = /* @__PURE__ */ new Map();
+		this.updateFields = /* @__PURE__ */ new Map();
+		this.recoveryChanges = /* @__PURE__ */ new Map();
+		this.pending = /* @__PURE__ */ new Map();
+		this.suppressed = false;
+		this.disposed = false;
+		this.work = 0;
+		this.journalBytes = 0;
+		this.policies = /* @__PURE__ */ new WeakMap();
+		this.prefix = `${JSON.stringify([key, "cache-v2"])}:`;
+	}
+	async initialize() {
+		await this.storage.exclusive(`${this.key}:write`, async () => {
+			this.assertActive();
+			if (await this.read(`${this.prefix}scope`) !== this.client.getPersistenceScope()) {
+				await this.clear();
+				if (sized(`${this.prefix}scope`, this.client.getPersistenceScope()).bytes + this.overhead <= this.maxBytes) await this.put([[`${this.prefix}scope`, this.client.getPersistenceScope()]]);
+			}
+		});
+	}
+	assertActive() {
+		if (this.disposed) throw new Error("fate: Persistence was disposed.");
+	}
+	async active() {
+		this.assertActive();
+		const scope = await this.read(`${this.prefix}scope`);
+		this.assertActive();
+		return scope === this.client.getPersistenceScope();
+	}
+	restoreBase(state) {
+		this.assertActive();
+		this.suppressed = true;
+		try {
+			this.client.restorePersistenceData(state);
+		} finally {
+			this.suppressed = false;
+		}
+	}
+	/** Save only recovery dependencies, never an unrelated read-cache snapshot. */
+	async mutationBase(command, base) {
+		const previous = base ? decodeClientHydrationState(base.data).store : void 0;
+		const previousRecords = new Map(previous?.records);
+		const previousCoverage = new Map(previous?.coverage);
+		const previousLists = new Map(previous?.lists);
+		const ids = new Set(previousRecords.keys());
+		const config = this.client.getTypeConfig(command.entity);
+		for (const input of [command.input, command.optimistic]) if (input) try {
+			const id = config.getId(input);
+			if (id != null) ids.add(toEntityId(command.entity, id));
+		} catch {}
+		const lists = /* @__PURE__ */ new Set([...previousLists.keys(), ...command.insert !== "none" ? this.client.getPersistenceRootLists(command.entity) : []]);
+		for (const id of ids) {
+			const owners = this.client.store.getPersistenceOwners(id);
+			for (const owner of owners.records) ids.add(owner);
+			for (const key of owners.lists) lists.add(key);
+		}
+		const records = [];
+		const coverage = [];
+		const visit = (value) => {
+			if (isNodeRef(value)) ids.add(getNodeRefId(value));
+			else if (Array.isArray(value)) for (const item of value) visit(item);
+			else if (value && typeof value === "object") for (const item of Object.values(value)) visit(item);
+		};
+		for (const id of ids) {
+			const key = recordKey(id);
+			const saved = previousRecords.get(id);
+			const before = saved ? {
+				paths: [...previousCoverage.get(id) ?? []],
+				record: saved
+			} : void 0;
+			const memory = this.client.store.readConfirmed(id);
+			const disk = memory || before ? void 0 : await this.node(key);
+			const recovery = this.recoveryChanges.get(key);
+			const update = this.changed.has(key) ? mergeCacheUpdate(key, recovery, {
+				fields: this.fields.get(key) ? [...this.fields.get(key)] : void 0,
+				value: this.changed.get(key)
+			}) : recovery;
+			const incoming = update?.value;
+			const value = update ? incoming && (before ? applyRecordUpdate(before, incoming, update.fields ? new Set(update.fields) : void 0) : incoming) : before ?? memory ?? (disk ? decodeHydrationValue(disk.value) : void 0);
+			if (value) {
+				records.push([id, value.record]);
+				coverage.push([id, value.paths]);
+				visit(value.record);
+				for (const [field, entry] of Object.entries(value.record)) if (Array.isArray(entry)) for (const [key] of this.client.store.getListsForField(id, field)) lists.add(key);
+			}
+			await this.step();
+		}
+		const listValues = [];
+		for (const key of lists) {
+			const value = this.changed.has(listKey(key)) ? this.changed.get(listKey(key)) : this.recoveryChanges.has(listKey(key)) ? this.recoveryChanges.get(listKey(key)).value : previousLists.get(key) ?? this.client.store.readConfirmedList(key);
+			if (value) listValues.push([key, value]);
+			await this.step();
+		}
+		return {
+			data: encodeHydrationValue({
+				rootLists: [[command.entity, [...this.client.getPersistenceRootLists(command.entity)]]],
+				rootRequests: [],
+				store: {
+					coverage,
+					lists: listValues,
+					records
+				}
+			}),
+			scope: this.client.getPersistenceScope(),
+			version: 1
+		};
+	}
+	get overhead() {
+		return encoder.encode(JSON.stringify([`${this.prefix}bytes`, this.maxBytes])).byteLength;
+	}
+	async step() {
+		this.assertActive();
+		if (++this.work % 64 === 0) {
+			await yieldTask$1();
+			this.assertActive();
+		}
+	}
+	nodeKey(key) {
+		return `${this.prefix}node:${key}`;
+	}
+	rootKey(key) {
+		return `${this.prefix}root:${key}`;
+	}
+	async read(key) {
+		return (await this.storage.read(key))?.value;
+	}
+	async put(entries) {
+		let bytes = await this.storage.read(`${this.prefix}bytes`) ?? 0;
+		const writes = [];
+		for (const [key, value] of new Map(entries)) {
+			const previous = await this.storage.read(key);
+			bytes -= previous?.bytes ?? 0;
+			if (value === void 0) writes.push([key, void 0]);
+			else {
+				const item = sized(key, value);
+				bytes += item.bytes;
+				writes.push([key, item]);
+			}
+			await this.step();
+		}
+		writes.push([`${this.prefix}bytes`, Math.max(0, bytes)]);
+		this.assertActive();
+		await this.storage.writeBatch(writes);
+	}
+	get hasChanges() {
+		return this.changed.size > 0 || this.recoveryChanges.size > 0;
+	}
+	changedNode(kind, key, paths, previousList) {
+		if (!this.suppressed && key) {
+			const selected = paths ? new Set([...paths].map((path) => path.split(".")[0])) : void 0;
+			if (kind === "record") {
+				const id = recordKey(key);
+				const previous = this.fields.get(id);
+				this.fields.set(id, selected?.size && (!this.fields.has(id) || previous) ? /* @__PURE__ */ new Set([...previous ?? [], ...selected]) : void 0);
+			}
+			const id = kind === "record" ? recordKey(key) : listKey(key);
+			const value = kind === "record" ? this.client.store.readConfirmed(key) : this.client.store.readConfirmedList(key);
+			if (kind === "list" && !this.changed.has(id)) this.listBases.set(id, previousList);
+			this.changed.set(id, value);
+			if (this.capturing) {
+				const previous = this.capturing.get(id);
+				this.capturing.set(id, {
+					fields: selected?.size && (!previous || previous.fields) ? [.../* @__PURE__ */ new Set([...previous?.fields ?? [], ...selected])] : void 0,
+					previousList: previous ? previous.previousList : previousList,
+					value
+				});
+			}
+			return true;
+		}
+		return false;
+	}
+	/** A recovered receipt has already been checkpointed by another tab. */
+	withoutChanges(commit) {
+		this.suppressed = true;
+		try {
+			commit();
+		} finally {
+			this.suppressed = false;
+		}
+	}
+	/** Capture only the confirmed writes made by this mutation for crash recovery. */
+	captureChanges(commit) {
+		const changes = /* @__PURE__ */ new Map();
+		this.capturing = changes;
+		try {
+			commit();
+		} finally {
+			this.capturing = void 0;
+		}
+		for (const [key, update] of changes) {
+			changes.set(key, {
+				fields: this.fields.get(key) ? [...this.fields.get(key)] : void 0,
+				previousList: this.listBases.has(key) ? this.listBases.get(key) : update.previousList,
+				value: this.changed.get(key)
+			});
+			this.changed.delete(key);
+			this.fields.delete(key);
+			this.listBases.delete(key);
+		}
+		return encodeHydrationValue([...changes]);
+	}
+	replayChanges(updates) {
+		this.recoveryChanges.clear();
+		for (const encoded of updates) for (const [key, update] of decodeHydrationValue(encoded)) this.recoveryChanges.set(key, mergeCacheUpdate(key, this.recoveryChanges.get(key), update));
+	}
+	fetched(request, maxAge = this.maxAge, fromNetwork = true) {
+		if (!Number.isSafeInteger(maxAge) || maxAge < 0 || maxAge > Number.MAX_SAFE_INTEGER - Date.now()) throw new Error("fate: Persistence maxAge must be a non-negative finite duration.");
+		if (!fromNetwork && this.policies.get(request) === maxAge) return;
+		this.policies.set(request, maxAge);
+		const previous = this.pending.get(request.key);
+		const retain = this.client.retainPersistenceRequest(request);
+		previous?.release();
+		this.pending.set(request.key, {
+			fetchedAt: fromNetwork ? Date.now() : previous?.fetchedAt,
+			maxAge,
+			release: retain.dispose,
+			request
+		});
+	}
+	async node(key) {
+		const node = await this.read(this.nodeKey(key));
+		if (!node) return;
+		node.claims = Object.fromEntries(Object.entries(node.claims).filter(([, claim]) => claim.expiresAt > Date.now()));
+		if (!Object.keys(node.claims).length) return;
+		if (key.startsWith("r:")) {
+			const paths = Object.values(node.claims).flatMap((claim) => claim.paths);
+			node.value = encodeHydrationValue(project(decodeHydrationValue(node.value), paths));
+		}
+		return node;
+	}
+	/** Walk only the requested selection, yielding between small pieces of work. */
+	async collect(request, memory, fromNetwork = false) {
+		const nodes = /* @__PURE__ */ new Map();
+		const visited = /* @__PURE__ */ new Map();
+		let complete = true;
+		let fetchedAt = Infinity;
+		const queue = [];
+		const read = async (key) => {
+			await this.step();
+			if (memory) {
+				if (this.updates.has(key)) {
+					const incoming = this.updates.get(key);
+					const base = this.updateListBases.get(key);
+					if (!fromNetwork && incoming && base && key.startsWith("l:")) {
+						const stored = await this.node(key);
+						if (stored) return applyListUpdate(decodeHydrationValue(stored.value), base, incoming);
+					}
+					if (incoming && key.startsWith("r:") && this.updateFields.get(key)) {
+						const stored = await this.node(key);
+						if (stored) return applyRecordUpdate(decodeHydrationValue(stored.value), incoming, this.updateFields.get(key));
+					}
+					return incoming;
+				}
+				if (fromNetwork) {
+					const id = key.slice(2);
+					const value = key.startsWith("r:") ? this.client.store.readConfirmed(id) : key.startsWith("l:") ? this.client.store.readConfirmedList(id) : this.client.getPersistenceQuery(id);
+					if (value !== void 0) return value;
+					if (this.changed.has(key)) return;
+				}
+			}
+			const stored = await this.node(key);
+			if (stored) for (const claim of Object.values(stored.claims)) fetchedAt = Math.min(fetchedAt, claim.fetchedAt);
+			if (!stored) return memory && key.startsWith("r:") ? this.client.store.readConfirmed(key.slice(2)) : void 0;
+			const value = decodeHydrationValue(stored.value);
+			if (!memory) return value;
+			const deleted = (id) => this.updates.has(recordKey(id)) && this.updates.get(recordKey(id)) === void 0;
+			if (key.startsWith("l:")) {
+				const list = value;
+				return {
+					...list,
+					cursors: list.cursors?.filter((_, index) => !deleted(list.ids[index])),
+					ids: list.ids.filter((id) => !deleted(id)),
+					liveAfterIds: list.liveAfterIds?.filter((id) => !deleted(id)),
+					liveBeforeIds: list.liveBeforeIds?.filter((id) => !deleted(id)),
+					pendingAfterIds: list.pendingAfterIds?.filter((id) => !deleted(id)),
+					pendingBeforeIds: list.pendingBeforeIds?.filter((id) => !deleted(id))
+				};
+			}
+			if (key.startsWith("r:")) {
+				const record = value;
+				return {
+					...record,
+					record: Object.fromEntries(Object.entries(record.record).map(([field, value]) => [field, isNodeRef(value) && deleted(getNodeRefId(value)) ? null : Array.isArray(value) ? value.filter((item) => !isNodeRef(item) || !deleted(getNodeRefId(item))) : value]))
+				};
+			}
+			return typeof value === "string" && deleted(value) ? null : value;
+		};
+		const addList = async (key, paths, plan, prefix) => {
+			const list = await read(listKey(key));
+			if (!list) {
+				complete = false;
+				return;
+			}
+			nodes.set(listKey(key), {
+				paths: /* @__PURE__ */ new Set(),
+				value: list
+			});
+			for (const id of [
+				...list.ids,
+				...list.pendingBeforeIds ?? [],
+				...list.pendingAfterIds ?? [],
+				...list.liveBeforeIds ?? [],
+				...list.liveAfterIds ?? []
+			]) queue.push({
+				id,
+				paths,
+				plan,
+				prefix
+			});
+		};
+		for (const item of request.items) {
+			const paths = [...item.plan.paths];
+			if (item.kind === "node" || item.kind === "nodes") for (const id of item.ids) queue.push({
+				id: toEntityId(item.type, id),
+				paths,
+				plan: item.plan,
+				prefix: ""
+			});
+			else if (item.kind === "query") {
+				const id = await read(queryKey(item.queryKey));
+				if (id === void 0) {
+					complete = false;
+					continue;
+				}
+				nodes.set(queryKey(item.queryKey), {
+					paths: /* @__PURE__ */ new Set(),
+					value: id
+				});
+				if (typeof id === "string") queue.push({
+					id,
+					paths,
+					plan: item.plan,
+					prefix: ""
+				});
+			} else if (item.kind === "list") await addList(item.listKey, paths, item.plan, "");
+		}
+		for (let index = 0; index < queue.length; index++) {
+			const { id, paths, plan, prefix } = queue[index];
+			const key = recordKey(id);
+			const seen = nodes.get(key);
+			const contexts = visited.get(plan) ?? /* @__PURE__ */ new Map();
+			visited.set(plan, contexts);
+			const context = JSON.stringify([id, prefix]);
+			const traversed = contexts.get(context);
+			const needed = paths.filter((path) => !traversed?.has(path));
+			if (traversed && !needed.length) continue;
+			contexts.set(context, /* @__PURE__ */ new Set([...traversed ?? [], ...paths]));
+			const source = await read(key);
+			if (!source) {
+				complete = false;
+				continue;
+			}
+			if (paths.some((path) => !source.paths.some((covered) => path === covered || path.startsWith(`${covered}.`)))) complete = false;
+			const all = /* @__PURE__ */ new Set([...seen?.paths ?? [], ...paths]);
+			nodes.set(key, {
+				paths: all,
+				value: project(source, [...all])
+			});
+			const groups = /* @__PURE__ */ new Map();
+			for (const path of needed) {
+				const [field, ...rest] = path.split(".");
+				const children = groups.get(field) ?? [];
+				if (rest.length) children.push(rest.join("."));
+				groups.set(field, children);
+			}
+			const walk = (value, children, childPrefix) => {
+				if (isNodeRef(value)) queue.push({
+					id: getNodeRefId(value),
+					paths: children,
+					plan,
+					prefix: childPrefix
+				});
+				else if (Array.isArray(value)) for (const item of value) walk(item, children, childPrefix);
+				else if (value && typeof value === "object" && children.length) for (const child of children) {
+					const [field, ...rest] = child.split(".");
+					walk(value[field], rest.length ? [rest.join(".")] : [], `${childPrefix}.${field}`);
+				}
+			};
+			for (const [field, children] of groups) {
+				const childPrefix = prefix ? `${prefix}.${field}` : field;
+				const value = source.record[field];
+				if (Array.isArray(value)) {
+					const nestedKey = getListKey(id, field, plan.args.get(childPrefix)?.hash);
+					const list = await read(listKey(nestedKey));
+					if (list) {
+						const projected = nodes.get(key).value;
+						projected.record[field] = list.ids.map(createNodeRef);
+						await addList(nestedKey, children, plan, childPrefix);
+					} else walk(value, children, childPrefix);
+				} else walk(value, children, childPrefix);
+			}
+		}
+		return {
+			complete,
+			fetchedAt,
+			nodes
+		};
+	}
+	async restore(request) {
+		await this.storage.exclusive(`${this.key}:write`, async () => {
+			if (!await this.active()) return;
+			const { complete, nodes } = await this.collect(request, false);
+			if (!complete) return;
+			for (const [key, node] of nodes) {
+				this.assertActive();
+				const id = key.slice(2);
+				const state = {
+					rootLists: [],
+					rootRequests: [],
+					store: {
+						coverage: [],
+						lists: [],
+						records: []
+					}
+				};
+				if (key.startsWith("r:")) {
+					const value = node.value;
+					state.store.records.push([id, value.record]);
+					state.store.coverage.push([id, value.paths]);
+				} else if (key.startsWith("l:")) {
+					state.store.lists.push([id, node.value]);
+					for (const item of request.items) if (item.kind === "list" && item.listKey === id && !filterConnectionArgs(item.argsPayload)) state.rootLists.push([item.type, [id]]);
+				} else state.rootRequests.push([id, node.value]);
+				this.suppressed = true;
+				try {
+					this.client.restorePersistenceData(state);
+				} finally {
+					this.suppressed = false;
+				}
+				await this.step();
+			}
+			const root = await this.read(this.rootKey(request.key));
+			if (root && root.fetchedAt + root.maxAge > Date.now()) {
+				const old = `${this.prefix}lru:${stamp(root.usedAt)}:${request.key}`;
+				root.usedAt = Date.now();
+				await this.put([
+					[old, void 0],
+					[this.rootKey(request.key), root],
+					[`${this.prefix}lru:${stamp(root.usedAt)}:${request.key}`, request.key]
+				]);
+			}
+		});
+	}
+	async remove(rootId) {
+		const root = await this.read(this.rootKey(rootId));
+		if (!root) return;
+		for (const key of root.nodes) {
+			const node = await this.read(this.nodeKey(key));
+			if (node) {
+				delete node.claims[rootId];
+				const live = Object.values(node.claims).filter((claim) => claim.expiresAt > Date.now());
+				if (key.startsWith("r:") && live.length) node.value = encodeHydrationValue(project(decodeHydrationValue(node.value), live.flatMap((claim) => claim.paths)));
+				await this.put([[this.nodeKey(key), live.length ? node : void 0]]);
+			}
+			await this.step();
+		}
+		await this.put([
+			[this.rootKey(rootId), void 0],
+			[`${this.prefix}lru:${stamp(root.usedAt)}:${rootId}`, void 0],
+			[`${this.prefix}expiry:${stamp(root.fetchedAt + root.maxAge)}:${rootId}`, void 0]
+		]);
+	}
+	async save(request, fetchedAt, maxAge, usedAt = Date.now(), fromNetwork = false) {
+		if (!maxAge || fetchedAt + maxAge <= Date.now()) {
+			await this.remove(request.key);
+			return;
+		}
+		const { nodes } = await this.collect(request, true, fromNetwork);
+		const root = {
+			fetchedAt,
+			maxAge,
+			nodes: [...nodes.keys()],
+			request: encodeRequests([request]),
+			usedAt
+		};
+		let minimum = sized(this.rootKey(request.key), root).bytes + sized(`${this.prefix}lru:${stamp(usedAt)}:${request.key}`, request.key).bytes + sized(`${this.prefix}expiry:${stamp(fetchedAt + maxAge)}:${request.key}`, request.key).bytes + sized(`${this.prefix}scope`, this.client.getPersistenceScope()).bytes;
+		for (const [key, node] of nodes) {
+			minimum += sized(this.nodeKey(key), {
+				claims: { [request.key]: {
+					expiresAt: fetchedAt + maxAge,
+					fetchedAt,
+					paths: [...node.paths]
+				} },
+				value: encodeHydrationValue(node.value)
+			}).bytes;
+			await this.step();
+		}
+		if (minimum + this.journalBytes + this.overhead > this.maxBytes) {
+			await this.remove(request.key);
+			return;
+		}
+		const prepare = async () => {
+			const old = await this.read(this.rootKey(request.key));
+			const writes = /* @__PURE__ */ new Map();
+			if (old) {
+				writes.set(`${this.prefix}lru:${stamp(old.usedAt)}:${request.key}`, void 0);
+				writes.set(`${this.prefix}expiry:${stamp(old.fetchedAt + old.maxAge)}:${request.key}`, void 0);
+			}
+			writes.set(this.rootKey(request.key), {
+				...root,
+				nodes: [.../* @__PURE__ */ new Set([...root.nodes, ...old?.nodes ?? []])]
+			});
+			writes.set(`${this.prefix}lru:${stamp(root.usedAt)}:${request.key}`, request.key);
+			writes.set(`${this.prefix}expiry:${stamp(fetchedAt + maxAge)}:${request.key}`, request.key);
+			for (const key of /* @__PURE__ */ new Set([...nodes.keys(), ...old?.nodes ?? []])) {
+				const previous = await this.node(key);
+				const next = nodes.get(key);
+				const claims = previous?.claims ?? {};
+				if (!next) delete claims[request.key];
+				else claims[request.key] = {
+					expiresAt: fetchedAt + maxAge,
+					fetchedAt,
+					paths: [...next.paths]
+				};
+				let value = next?.value;
+				if (previous && key.startsWith("r:")) {
+					const before = decodeHydrationValue(previous.value);
+					const after = next?.value;
+					value = project({
+						paths: [.../* @__PURE__ */ new Set([...before.paths, ...after?.paths ?? []])],
+						record: {
+							...before.record,
+							...after?.record
+						}
+					}, Object.values(claims).flatMap((claim) => claim.paths));
+				}
+				writes.set(this.nodeKey(key), Object.keys(claims).length ? {
+					claims,
+					value: value !== void 0 ? encodeHydrationValue(value) : previous.value
+				} : void 0);
+				await this.step();
+			}
+			return writes;
+		};
+		let writes = await prepare();
+		for (;;) {
+			let added = 0;
+			for (const [key, value] of writes) {
+				const before = await this.storage.read(key);
+				added += Math.max(0, (value === void 0 ? 0 : sized(key, value).bytes) - (before?.bytes ?? 0));
+				await this.step();
+			}
+			if ((await this.storage.read(`${this.prefix}bytes`) ?? 0) + added + this.journalBytes + this.overhead <= this.maxBytes) break;
+			const candidate = (await this.storage.scan(`${this.prefix}lru:`, void 0, 2)).find((entry) => entry.value.value !== request.key);
+			if (!candidate) {
+				await this.remove(request.key);
+				return;
+			}
+			const id = candidate.value.value;
+			if (await this.read(this.rootKey(id))) await this.remove(id);
+			else await this.put([[candidate.key, void 0]]);
+			writes = await prepare();
+		}
+		const entries = [...writes];
+		for (let index = 0; index < entries.length; index += 64) {
+			await this.put(entries.slice(index, index + 64));
+			await yieldTask$1();
+		}
+		await this.put([[this.rootKey(request.key), root]]);
+	}
+	/** Called under the shared write lock. Expiry/LRU indexes avoid whole-cache scans. */
+	async prune(journalBytes) {
+		this.journalBytes = journalBytes;
+		while (true) {
+			const [entry] = await this.storage.scan(`${this.prefix}expiry:`, void 0, 1);
+			if (!entry) break;
+			const id = entry.value.value;
+			const root = await this.read(this.rootKey(id));
+			if (root && root.fetchedAt + root.maxAge > Date.now()) break;
+			if (root) await this.remove(id);
+			else await this.put([[entry.key, void 0]]);
+			await this.step();
+		}
+		while ((await this.storage.read(`${this.prefix}bytes`) ?? 0) + journalBytes + this.overhead > this.maxBytes) {
+			const [entry] = await this.storage.scan(`${this.prefix}lru:`, void 0, 1);
+			if (!entry) break;
+			const id = entry.value.value;
+			if (await this.read(this.rootKey(id))) await this.remove(id);
+			else await this.put([[entry.key, void 0]]);
+			await this.step();
+		}
+	}
+	async fits(journalBytes) {
+		return (await this.storage.read(`${this.prefix}bytes`) ?? 0) + journalBytes + this.overhead <= this.maxBytes;
+	}
+	async flush(journalBytes) {
+		if (!await this.active()) {
+			this.reset();
+			return;
+		}
+		await this.prune(journalBytes);
+		const pending = this.pending;
+		this.pending = /* @__PURE__ */ new Map();
+		const changes = this.changed;
+		const fields = this.fields;
+		const listBases = this.listBases;
+		this.listBases = /* @__PURE__ */ new Map();
+		const recovery = this.recoveryChanges;
+		this.recoveryChanges = /* @__PURE__ */ new Map();
+		const updates = new Map(recovery);
+		for (const [key, value] of changes) updates.set(key, mergeCacheUpdate(key, updates.get(key), {
+			fields: fields.get(key) ? [...fields.get(key)] : void 0,
+			previousList: listBases.get(key),
+			value
+		}));
+		this.updates = new Map([...updates].map(([key, update]) => [key, update.value]));
+		this.changed = /* @__PURE__ */ new Map();
+		this.updateListBases = new Map([...updates].map(([key, update]) => [key, update.previousList]));
+		this.updateFields = new Map([...updates].map(([key, update]) => [key, update.fields ? new Set(update.fields) : void 0]));
+		this.fields = /* @__PURE__ */ new Map();
+		try {
+			const affected = /* @__PURE__ */ new Map();
+			for (const key of this.updates.keys()) {
+				const node = await this.node(key);
+				const incoming = this.updates.get(key);
+				if (node && incoming && key.startsWith("r:")) {
+					const before = decodeHydrationValue(node.value);
+					const after = applyRecordUpdate(before, incoming, this.updateFields.get(key));
+					if (!Object.keys({
+						...before.record,
+						...after.record
+					}).some((field) => references(before.record[field]) !== references(after.record[field]))) {
+						const value = encodeHydrationValue(project({
+							paths: [.../* @__PURE__ */ new Set([...before.paths, ...after.paths])],
+							record: {
+								...before.record,
+								...after.record
+							}
+						}, Object.values(node.claims).flatMap((claim) => claim.paths)));
+						const next = {
+							...node,
+							value
+						};
+						const beforeSize = (await this.storage.read(this.nodeKey(key))).bytes;
+						const growth = Math.max(0, sized(this.nodeKey(key), next).bytes - beforeSize);
+						await this.prune(journalBytes + growth);
+						const retained = await this.node(key);
+						if (retained) {
+							next.claims = retained.claims;
+							next.value = encodeHydrationValue(project(decodeHydrationValue(value), Object.values(retained.claims).flatMap((claim) => claim.paths)));
+							await this.put([[this.nodeKey(key), next]]);
+						}
+						this.journalBytes = journalBytes;
+						continue;
+					}
+				}
+				for (const rootId of Object.keys(node?.claims ?? {})) {
+					if (pending.has(rootId) || affected.has(rootId)) continue;
+					const root = await this.read(this.rootKey(rootId));
+					if (root) affected.set(rootId, root);
+				}
+				await this.step();
+			}
+			for (const root of affected.values()) await this.save(decodeRequests(root.request)[0], root.fetchedAt, root.maxAge, root.usedAt);
+			for (const { fetchedAt, maxAge, request } of pending.values()) if (fetchedAt !== void 0) await this.save(request, fetchedAt, maxAge, Date.now(), true);
+			for (const { fetchedAt, maxAge, request } of pending.values()) {
+				if (fetchedAt !== void 0) continue;
+				if (!maxAge) {
+					await this.remove(request.key);
+					continue;
+				}
+				const cached = await this.collect(request, false);
+				if (cached.complete && Number.isFinite(cached.fetchedAt)) {
+					const root = await this.read(this.rootKey(request.key));
+					await this.save(request, root?.fetchedAt ?? cached.fetchedAt, maxAge);
+				}
+			}
+			this.updates.clear();
+			await this.prune(journalBytes);
+		} catch (error) {
+			if (!this.disposed) {
+				for (const [key, update] of recovery) this.recoveryChanges.set(key, this.recoveryChanges.has(key) ? mergeCacheUpdate(key, update, this.recoveryChanges.get(key)) : update);
+				for (const [key, value] of changes) {
+					if (key.startsWith("l:")) this.listBases.set(key, listBases.get(key));
+					if (!this.changed.has(key)) {
+						this.changed.set(key, value);
+						this.fields.set(key, fields.get(key));
+					} else if (key.startsWith("r:")) {
+						const before = fields.get(key);
+						const after = this.fields.get(key);
+						this.fields.set(key, before && after ? /* @__PURE__ */ new Set([...before, ...after]) : void 0);
+					}
+				}
+				for (const [key, entry] of pending) if (!this.pending.has(key)) {
+					this.pending.set(key, entry);
+					pending.delete(key);
+				}
+			}
+			throw error;
+		} finally {
+			this.updates.clear();
+			this.updateFields.clear();
+			this.updateListBases.clear();
+			for (const entry of pending.values()) entry.release();
+		}
+	}
+	async clear() {
+		this.reset();
+		while (true) {
+			const entries = await this.storage.scan(this.prefix, void 0, 64);
+			if (!entries.length) return;
+			await this.storage.writeBatch(entries.map(({ key }) => [key, void 0]));
+			await yieldTask$1();
+		}
+	}
+	dispose() {
+		this.disposed = true;
+		this.reset();
+	}
+	reset() {
+		this.recoveryChanges.clear();
+		this.policies = /* @__PURE__ */ new WeakMap();
+		for (const entry of this.pending.values()) entry.release();
+		this.pending.clear();
+		this.changed.clear();
+		this.updates.clear();
+		this.fields.clear();
+		this.updateFields.clear();
+		this.listBases.clear();
+		this.updateListBases.clear();
+	}
+};
+//#endregion
+//#region src/persistence-journal.ts
+const invalid = () => /* @__PURE__ */ new Error("fate: Unsupported or corrupt persistence data. It has not been overwritten.");
+const valid = (entry) => entry && typeof entry.id === "string" && typeof entry.scope === "string" && [
+	"queued",
+	"sending",
+	"failed",
+	"confirmed"
+].includes(entry.status) && Number.isInteger(entry.attempts) && entry.attempts >= 0;
+const same = (left, right) => {
+	return [.../* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])].every((key) => left[key] === right[key]);
+};
+const size = (key, value) => new TextEncoder().encode(JSON.stringify([key, value])).byteLength;
+const yieldTask = () => new Promise((resolve) => setTimeout(resolve, 0));
+/** All methods run under the account's write lock, including reads across scan pages. */
+var PersistenceJournal = class {
+	constructor(storage, key, validate) {
+		this.storage = storage;
+		this.key = key;
+		this.validate = validate;
+		this.disposed = false;
+		this.entries = /* @__PURE__ */ new Map();
+		this.prefix = `${JSON.stringify([key, "journal"])}:`;
+	}
+	dispose() {
+		this.disposed = true;
+		this.entries.clear();
+		this.prepared = void 0;
+	}
+	assertActive() {
+		if (this.disposed) throw new Error("fate: Persistence was disposed.");
+	}
+	async load() {
+		this.assertActive();
+		const value = await this.storage.read(this.key);
+		this.assertActive();
+		if (value == null) {
+			this.header = void 0;
+			this.entries.clear();
+		} else if (value.version === 1) {
+			if (!Array.isArray(value.mutations) || value.mutations.some((entry) => !valid(entry)) || new Set(value.mutations.map(({ id }) => id)).size !== value.mutations.length) throw invalid();
+			let checked = 0;
+			for (const entry of value.mutations) {
+				this.validate?.(entry);
+				if (++checked % 64 === 0) {
+					await yieldTask();
+					this.assertActive();
+				}
+			}
+			this.header = void 0;
+			this.entries.clear();
+			await this.save({ mutations: value.mutations });
+		} else if (value.version !== 2 || typeof value.revision !== "string" || !Number.isSafeInteger(value.nextSequence) || value.nextSequence < 0) throw invalid();
+		else if (this.header?.revision !== value.revision) {
+			const entries = /* @__PURE__ */ new Map();
+			let after;
+			while (true) {
+				const page = await this.storage.scan(this.prefix, after, 64);
+				this.assertActive();
+				for (const { key, value } of page) {
+					const stored = value;
+					if (!stored || !valid(stored.entry) || !Number.isSafeInteger(stored.bytes) || stored.bytes <= 0 || entries.has(stored.entry.id)) throw invalid();
+					entries.set(stored.entry.id, {
+						...stored,
+						key
+					});
+				}
+				if (page.length < 64) break;
+				after = page.at(-1).key;
+				await yieldTask();
+			}
+			this.assertActive();
+			this.header = value;
+			this.entries = entries;
+		}
+		this.prepared = void 0;
+		return { mutations: [...this.entries.values()].map(({ entry }) => ({ ...entry })) };
+	}
+	async measure(data) {
+		this.assertActive();
+		const header = {
+			nextSequence: this.header?.nextSequence ?? 0,
+			revision: crypto.randomUUID(),
+			version: 2
+		};
+		const entries = /* @__PURE__ */ new Map();
+		const writes = [];
+		let bytes = 0;
+		let count = 0;
+		for (const entry of data.mutations) {
+			const previous = this.entries.get(entry.id);
+			let stored = previous;
+			if (!previous || !same(previous.entry, entry)) {
+				const key = previous?.key ?? `${this.prefix}${String(header.nextSequence++).padStart(16, "0")}:${entry.id}`;
+				const value = {
+					bytes: 0,
+					entry
+				};
+				let measured = size(key, value);
+				while (measured !== value.bytes) {
+					value.bytes = measured;
+					measured = size(key, value);
+				}
+				stored = {
+					...value,
+					entry: { ...entry },
+					key
+				};
+				writes.push([key, value]);
+			}
+			entries.set(entry.id, stored);
+			bytes += stored.bytes;
+			if (++count % 64 === 0) {
+				await yieldTask();
+				this.assertActive();
+			}
+		}
+		for (const [id, { key }] of this.entries) if (!entries.has(id)) writes.push([key, void 0]);
+		bytes += size(this.key, header);
+		this.prepared = {
+			bytes,
+			data,
+			entries,
+			header,
+			writes
+		};
+		return bytes;
+	}
+	async save(data) {
+		this.assertActive();
+		if (this.prepared?.data !== data) await this.measure(data);
+		this.assertActive();
+		const prepared = this.prepared;
+		if (prepared.writes.length || !this.header) {
+			await this.storage.writeBatch([...prepared.writes, [this.key, prepared.header]]);
+			this.assertActive();
+			this.header = prepared.header;
+			this.entries = prepared.entries;
+		}
+		this.prepared = void 0;
+	}
+};
+//#endregion
+//#region src/persistence.ts
+const encodeCommand = (command) => encodeHydrationValue({
+	...command,
+	plan: command.plan ? serializePlan(command.plan) : void 0
+});
+const decodeCommand = (value) => {
+	const command = decodeHydrationValue(value);
+	if (!command || typeof command.key !== "string" || typeof command.entity !== "string" || ![
+		"after",
+		"before",
+		"none"
+	].includes(command.insert)) throw new Error("fate: Invalid persisted mutation.");
+	return {
+		...command,
+		plan: command.plan ? deserializePlan(command.plan) : void 0
+	};
+};
+/**
+* Enables cache persistence and durable delivery through the existing mutation API.
+* Import this entry point only in applications using persistence. Storage keys must
+* isolate authenticated accounts/workspaces and match the server's identity scope.
+*/
+function createPersistence({ key, maxAge = 864e5, maxBytes = 26214400, online = () => typeof navigator === "undefined" || navigator.onLine, retryDelay = 1e3, storage }) {
+	if (!key || key.length > 1024) throw new Error("fate: Persistence requires an account-scoped key of 1–1024 characters.");
+	if (!Number.isFinite(retryDelay) || retryDelay <= 0) throw new Error("fate: retryDelay must be a positive finite number.");
+	if (!Number.isSafeInteger(maxAge) || maxAge < 0 || maxAge > Number.MAX_SAFE_INTEGER - Date.now()) throw new Error("fate: Persistence maxAge must be a non-negative finite duration.");
+	if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) throw new Error("fate: Persistence maxBytes must be a positive safe integer.");
+	return { attach: (client) => new Session(client, storage, key, online, retryDelay, maxAge, maxBytes) };
+}
+var Session = class {
+	constructor(client, storage, key, online, retryDelay, maxAge, maxBytes) {
+		this.client = client;
+		this.storage = storage;
+		this.key = key;
+		this.online = online;
+		this.retryDelay = retryDelay;
+		this.maxBytes = maxBytes;
+		this.snapshot = {
+			mutations: [],
+			status: "restoring"
+		};
+		this.listeners = /* @__PURE__ */ new Set();
+		this.commands = /* @__PURE__ */ new Map();
+		this.operations = /* @__PURE__ */ new Map();
+		this.mutationAdmission = Promise.resolve();
+		this.needsCacheRecovery = false;
+		this.needsCheckpoint = false;
+		this.waiters = /* @__PURE__ */ new Map();
+		this.disposed = false;
+		this.draining = false;
+		this.onOnline = () => this.retry();
+		this.getSnapshot = () => this.snapshot;
+		this.subscribe = (listener) => {
+			this.listeners.add(listener);
+			return () => {
+				this.listeners.delete(listener);
+			};
+		};
+		this.load = () => this.storage.exclusive(`${this.key}:write`, () => this.journal.load());
+		this.update = (apply, admit = false) => this.storage.exclusive(`${this.key}:write`, async () => {
+			if (this.disposed) throw new Error("fate: Persistence was disposed.");
+			const data = await this.journal.load();
+			const result = await apply(data);
+			const bytes = await this.journal.measure(data);
+			if (admit && bytes > this.maxBytes) throw new Error("fate: Persistence size limit exceeded; unconfirmed mutations have been preserved.");
+			try {
+				await this.cache.prune(bytes);
+			} catch (error) {
+				if (admit) throw error;
+				this.report(error);
+			}
+			if (admit && !await this.cache.fits(bytes)) throw new Error("fate: Persistence size limit exceeded; unconfirmed mutations have been preserved.");
+			if (this.disposed) throw new Error("fate: Persistence was disposed.");
+			await this.journal.save(data);
+			return result;
+		});
+		this.journal = new PersistenceJournal(storage, key, (entry) => {
+			decodeCommand(entry.command);
+		});
+		this.cache = new PersistenceCache(client, storage, key, maxAge, maxBytes);
+		try {
+			client.validatePersistence();
+		} catch (error) {
+			this.mutationError = error instanceof Error ? error : new Error(String(error));
+			this.snapshot = {
+				...this.snapshot,
+				error: this.mutationError
+			};
+		}
+		this.ready = this.restore().catch((error) => {
+			if (!this.disposed) this.snapshot = {
+				...this.snapshot,
+				status: "error"
+			};
+			throw error;
+		});
+		this.ready.catch((error) => this.report(error));
+	}
+	command(entry) {
+		let cached = this.commands.get(entry.id);
+		if (cached?.value !== entry.command) {
+			cached = {
+				command: decodeCommand(entry.command),
+				input: decodeHydrationValue(entry.command).input,
+				value: entry.command
+			};
+			this.commands.set(entry.id, cached);
+		}
+		return cached.command;
+	}
+	publish(data) {
+		if (data) this.snapshot = {
+			...this.snapshot,
+			mutations: data.mutations.filter((entry) => entry.status !== "confirmed").map((entry) => ({
+				error: entry.error?.message,
+				id: entry.id,
+				input: this.commands.get(entry.id).input,
+				name: this.command(entry).key,
+				status: entry.status
+			}))
+		};
+		for (const listener of this.listeners) try {
+			listener();
+		} catch {}
+	}
+	report(error) {
+		if (this.disposed) return;
+		this.snapshot = {
+			...this.snapshot,
+			error: error instanceof Error ? error : new Error(String(error)),
+			status: this.snapshot.status === "restoring" ? "error" : this.snapshot.status
+		};
+		this.publish();
+	}
+	async restore() {
+		const data = await this.load();
+		await this.cache.initialize();
+		if (this.disposed) return;
+		for (const entry of data.mutations) if (entry.status === "queued" || entry.status === "sending") {
+			if (entry.base && entry.base.scope === this.client.getPersistenceScope()) this.cache.restoreBase(decodeClientHydrationState(entry.base.data));
+		}
+		this.snapshot = {
+			error: this.mutationError,
+			mutations: [],
+			status: "ready"
+		};
+		await this.reconcile(data);
+		if (this.needsCacheRecovery) try {
+			await this.flushCache();
+		} catch (error) {
+			this.report(error);
+		}
+		if (this.disposed) return;
+		this.unsubscribe = this.storage.subscribe?.(this.key, () => {
+			this.refresh().catch((error) => this.report(error));
+		});
+		if (typeof globalThis.addEventListener === "function") globalThis.addEventListener("online", this.onOnline);
+		this.retry();
+	}
+	async reconcile(data) {
+		if (this.disposed) return;
+		let processed = 0;
+		for (const entry of data.mutations) {
+			if (++processed % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+			if (this.disposed) return;
+			this.command(entry);
+			if (entry.status === "confirmed" || entry.status === "failed") {
+				const operation = this.operations.get(entry.id);
+				if (entry.status === "confirmed") {
+					this.needsCheckpoint = true;
+					const result = operation || this.waiters.has(entry.id) ? decodeHydrationValue(entry.result) : void 0;
+					operation?.commit(result);
+					if (entry.cacheUpdates && entry.scope === this.client.getPersistenceScope()) this.needsCacheRecovery = true;
+					this.waiters.get(entry.id)?.resolve(result);
+				} else {
+					operation?.rollback();
+					this.waiters.get(entry.id)?.reject(new FateRequestError("BAD_REQUEST", entry.error?.message ?? "Mutation failed.", { status: entry.error?.status ?? 400 }));
+				}
+				this.operations.delete(entry.id);
+				this.waiters.delete(entry.id);
+			} else if (!this.operations.has(entry.id) && entry.scope === this.client.getPersistenceScope()) {
+				if (entry.base) this.cache.restoreBase(decodeClientHydrationState(entry.base.data));
+				const command = this.command(entry);
+				if (this.client.hasMutation(command.key, command.entity)) this.operations.set(entry.id, this.prepareOperation(command));
+			}
+		}
+		const retained = new Set(data.mutations.map(({ id }) => id));
+		for (const id of this.commands.keys()) if (!retained.has(id)) this.commands.delete(id);
+		this.publish(data);
+	}
+	prepareOperation(command) {
+		const operation = prepareMutation(this.client, command, this.client.getTypeConfig(command.entity), true);
+		const { promise, resolve } = Promise.withResolvers();
+		let cacheUpdates;
+		if (operation.entityId) this.client.registerPendingOptimisticMutation(operation.entityId, promise);
+		return {
+			...operation,
+			commit: (result, persist = true) => {
+				if (persist) cacheUpdates ??= this.cache.captureChanges(() => operation.commit(result));
+				else this.cache.withoutChanges(() => operation.commit(result));
+				resolve();
+			},
+			getCacheUpdates: () => cacheUpdates,
+			rollback: (persist = true) => {
+				try {
+					if (persist) operation.rollback();
+					else this.cache.withoutChanges(() => operation.rollback());
+				} finally {
+					resolve();
+				}
+			}
+		};
+	}
+	refresh() {
+		return this.refreshing ??= this.load().then(async (data) => {
+			await this.reconcile(data);
+			this.retry();
+		}).finally(() => {
+			this.refreshing = void 0;
+		});
+	}
+	async mutate(command) {
+		if (this.mutationError) throw this.mutationError;
+		const encoded = encodeCommand(command);
+		await this.ready;
+		if (this.disposed) throw new Error("fate: Persistence was disposed.");
+		const id = crypto.randomUUID();
+		const admission = this.mutationAdmission.then(async () => {
+			if (this.needsCheckpoint) await this.flushCache().catch((error) => this.report(error));
+			return this.update(async (data) => {
+				await this.reconcile(data);
+				const base = await this.cache.mutationBase(decodeCommand(encoded));
+				data.mutations.push({
+					attempts: 0,
+					base,
+					command: encoded,
+					id,
+					scope: base.scope,
+					status: "queued"
+				});
+				return base;
+			}, true);
+		});
+		this.mutationAdmission = admission.catch(() => {});
+		const base = await admission;
+		if (this.disposed) throw new Error("fate: Persistence was disposed.");
+		this.cache.restoreBase(decodeClientHydrationState(base.data));
+		const result = new Promise((resolve, reject) => this.waiters.set(id, {
+			reject,
+			resolve
+		}));
+		try {
+			if (!this.operations.has(id)) this.operations.set(id, this.prepareOperation(decodeCommand(encoded)));
+		} catch (error) {
+			await this.fail(id, error);
+		}
+		this.refresh().catch((error) => this.report(error));
+		this.retry();
+		return result;
+	}
+	async restoreRequest(request) {
+		await this.ready;
+		if (this.disposed) throw new Error("fate: Persistence was disposed.");
+		try {
+			if (this.needsCacheRecovery) await this.flush();
+			await this.cache.restore(request);
+		} catch (error) {
+			if (this.disposed) throw error;
+			this.report(error);
+		}
+	}
+	fetched(request, options) {
+		if (this.disposed) return;
+		this.cache.fetched(request, options?.maxAge);
+		this.changed();
+	}
+	used(request, options) {
+		if (this.disposed) return;
+		this.cache.fetched(request, options?.maxAge, false);
+		this.changed();
+	}
+	changed(kind, key, paths, previousList) {
+		if (this.disposed) return;
+		if (this.cache.changedNode(kind, key, paths, previousList)) this.needsCacheRecovery = true;
+		if (this.disposed || this.snapshot.status !== "ready") return;
+		if (!this.saveTimer) this.saveTimer = setTimeout(() => {
+			this.saveTimer = void 0;
+			this.flush().catch((error) => this.report(error));
+		}, 25);
+	}
+	async flush() {
+		await this.ready;
+		await this.flushCache();
+	}
+	async flushCache() {
+		if (this.disposed) throw new Error("fate: Persistence was disposed.");
+		await this.storage.exclusive(`${this.key}:write`, async () => {
+			if (this.disposed) throw new Error("fate: Persistence was disposed.");
+			const data = await this.journal.load();
+			await this.reconcile(data);
+			this.cache.replayChanges(data.mutations.flatMap((entry) => entry.cacheUpdates && entry.scope === this.client.getPersistenceScope() ? [entry.cacheUpdates] : []));
+			if (data.mutations.some((entry) => entry.status === "queued" || entry.status === "sending")) {
+				for (const entry of data.mutations) if ((entry.status === "queued" || entry.status === "sending") && entry.scope === this.client.getPersistenceScope()) entry.base = await this.cache.mutationBase(this.command(entry), entry.base);
+				await this.cache.prune(await this.journal.measure(data));
+				if (this.disposed) throw new Error("fate: Persistence was disposed.");
+				await this.journal.save(data);
+			}
+			await this.cache.flush(await this.journal.measure(data));
+			if (this.disposed) throw new Error("fate: Persistence was disposed.");
+			const confirmed = data.mutations.filter((entry) => entry.status === "confirmed");
+			if (confirmed.length) {
+				const ids = new Set(confirmed.map(({ id }) => id));
+				data.mutations = data.mutations.filter(({ id }) => !ids.has(id));
+				await this.journal.measure(data);
+				await this.journal.save(data);
+			}
+			this.needsCacheRecovery = this.cache.hasChanges;
+			this.needsCheckpoint = false;
+		});
+	}
+	retry() {
+		if (this.mutationError || this.disposed || this.snapshot.status !== "ready" || this.draining) return;
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = setTimeout(() => {
+			this.timer = void 0;
+			this.drain().catch((error) => {
+				this.report(error);
+				this.scheduleRetry();
+			});
+		}, 0);
+	}
+	scheduleRetry(delay = this.retryDelay) {
+		if (!this.disposed && !this.timer) this.timer = setTimeout(() => {
+			this.timer = void 0;
+			this.retry();
+		}, delay);
+	}
+	async fail(id, error) {
+		const failure = error instanceof Error ? error : new Error(String(error));
+		await this.update((data) => {
+			const entry = data.mutations.find((item) => item.id === id);
+			if (entry) {
+				entry.status = "failed";
+				delete entry.base;
+				entry.error = {
+					message: failure.message,
+					status: getErrorStatusCode(failure)
+				};
+			}
+		});
+		await this.reconcile(await this.load());
+	}
+	async drain() {
+		if (this.draining || this.disposed || !this.online()) return;
+		this.draining = true;
+		try {
+			await this.storage.exclusive(`${this.key}:delivery`, async () => {
+				while (!this.disposed && this.online()) {
+					const data = await this.load();
+					await this.reconcile(data);
+					const retained = new Set(data.mutations.map(({ id }) => id));
+					for (const [id, operation] of this.operations) {
+						if (retained.has(id)) continue;
+						try {
+							const result = await operation.execute({
+								id,
+								replayOnly: true,
+								scope: this.key
+							});
+							if (this.disposed) return;
+							operation.commit(result, false);
+							this.waiters.get(id)?.resolve(result);
+						} catch (error) {
+							if (this.disposed) return;
+							if (!(error instanceof Error) || getErrorStatusCode(error) !== 404) {
+								this.report(error);
+								this.scheduleRetry();
+								return;
+							}
+							operation.rollback(false);
+							this.waiters.get(id)?.reject(/* @__PURE__ */ new Error("fate: Mutation was discarded."));
+						}
+						this.operations.delete(id);
+						this.waiters.delete(id);
+					}
+					const entry = data.mutations.find((item) => item.status !== "confirmed" && item.status !== "failed");
+					if (!entry) return;
+					if (entry.nextAttemptAt && entry.nextAttemptAt > Date.now()) {
+						this.scheduleRetry(entry.nextAttemptAt - Date.now());
+						return;
+					}
+					const command = this.command(entry);
+					if (entry.scope !== this.client.getPersistenceScope() || !this.client.hasMutation(command.key, command.entity)) {
+						await this.fail(entry.id, new FateRequestError("BAD_REQUEST", "Persisted mutation is incompatible with this client. Its input has been preserved."));
+						continue;
+					}
+					const operation = this.operations.get(entry.id);
+					const claimed = await this.update((latest) => {
+						const item = latest.mutations.find((item) => item.id === entry.id);
+						if (!item) return false;
+						item.status = "sending";
+						item.attempts += 1;
+						return true;
+					});
+					if (this.disposed) return;
+					if (!claimed) continue;
+					try {
+						const result = await operation.execute({
+							id: entry.id,
+							scope: this.key
+						});
+						if (this.disposed) return;
+						const encoded = encodeHydrationValue(result);
+						operation.commit(result);
+						await this.update(async (latest) => {
+							this.cache.replayChanges([operation.getCacheUpdates()]);
+							const item = latest.mutations.find((item) => item.id === entry.id);
+							if (item) {
+								item.status = "confirmed";
+								delete item.base;
+								item.result = encoded;
+								item.cacheUpdates = operation.getCacheUpdates();
+								item.error = void 0;
+							}
+							for (const pending of latest.mutations) if ((pending.status === "queued" || pending.status === "sending") && pending.scope === this.client.getPersistenceScope()) pending.base = await this.cache.mutationBase(decodeCommand(pending.command), pending.base);
+						});
+						await this.reconcile(await this.load());
+						await this.flush().catch((error) => this.report(error));
+					} catch (error) {
+						if (this.disposed) return;
+						const status = error instanceof Error ? getErrorStatusCode(error) : void 0;
+						if (status && status >= 400 && status < 500 && ![
+							401,
+							403,
+							408,
+							429
+						].includes(status)) {
+							await this.fail(entry.id, error);
+							continue;
+						}
+						await this.update((latest) => {
+							const item = latest.mutations.find((item) => item.id === entry.id);
+							if (item && item.status !== "confirmed") {
+								item.status = "queued";
+								item.nextAttemptAt = Date.now() + Math.min(3e4, this.retryDelay * 2 ** Math.min(item.attempts - 1, 10));
+								item.error = {
+									message: error instanceof Error ? error.message : String(error),
+									status
+								};
+							}
+						});
+						await this.reconcile(await this.load());
+						this.scheduleRetry();
+						return;
+					}
+				}
+			});
+		} finally {
+			this.draining = false;
+		}
+	}
+	async discard(id) {
+		await this.ready;
+		if (await this.update((data) => {
+			const entry = data.mutations.find((entry) => entry.id === id);
+			if (entry && entry.attempts > 0 && entry.status !== "failed" && entry.status !== "confirmed") throw new Error("fate: An attempted mutation may have committed remotely and cannot be discarded until its outcome is known.");
+			if (entry?.status === "confirmed") return;
+			data.mutations = data.mutations.filter((entry) => entry.id !== id);
+			return true;
+		})) {
+			this.operations.get(id)?.rollback();
+			this.operations.delete(id);
+			this.waiters.get(id)?.reject(/* @__PURE__ */ new Error("fate: Mutation was discarded."));
+			this.waiters.delete(id);
+		}
+		await this.refresh();
+	}
+	async clearCache() {
+		await this.ready;
+		await this.storage.exclusive(`${this.key}:write`, () => this.cache.clear());
+		await this.cache.initialize();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.client.disposePersistence();
+		this.cache.dispose();
+		this.journal.dispose();
+		clearTimeout(this.timer);
+		clearTimeout(this.saveTimer);
+		this.unsubscribe?.();
+		if (typeof globalThis.removeEventListener === "function") globalThis.removeEventListener("online", this.onOnline);
+		for (const operation of this.operations.values()) operation.rollback();
+		this.operations.clear();
+		this.commands.clear();
+		for (const waiter of this.waiters.values()) waiter.reject(/* @__PURE__ */ new Error("fate: Persistence was disposed; pending mutations remain stored."));
+		this.waiters.clear();
+		this.snapshot = {
+			...this.snapshot,
+			status: "disposed"
+		};
+		this.publish();
+	}
+};
+//#endregion
+export { createPersistence };