@nkzw/fate 1.4.0 → 1.5.1

package/lib/persistence.mjs

@@ -0,0 +1,1730 @@
+import { t as isRecord } from "./record-B07VwXd-.mjs";
+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-CakBBzWG.mjs";
+import { t as FateRequestError } from "./protocol-DS5sf6sd.mjs";
+//#region src/persistence-codec.ts
+const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+const isLivePolicy = (value) => isRecord(value) && (value.append === void 0 || value.append === "edge" || value.append === "visible") && (value.prepend === void 0 || value.prepend === "edge" || value.prepend === "visible");
+const isSerializedPlan = (value) => isRecord(value) && Array.isArray(value.args) && value.args.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && isRecord(entry[1]) && typeof entry[1].hash === "string" && isRecord(entry[1].value) && (entry[1].ignoreKeys === void 0 || isStringArray(entry[1].ignoreKeys))) && Array.isArray(value.live) && value.live.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && isLivePolicy(entry[1])) && isStringArray(value.paths);
+const isSerializedRequest = (value) => isRecord(value) && typeof value.key === "string" && Array.isArray(value.items) && value.items.every((item) => isRecord(item) && isSerializedPlan(item.plan) && (item.kind === "list" ? isStringArray(item.nodeRefViewNames) : (item.kind === "node" || item.kind === "nodes" || item.kind === "query") && isStringArray(item.refViewNames)));
+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 decodeItem = (item) => item.kind === "list" ? {
+	...item,
+	nodeRefViewNames: new Set(item.nodeRefViewNames),
+	plan: deserializePlan(item.plan)
+} : {
+	...item,
+	plan: deserializePlan(item.plan),
+	refViewNames: new Set(item.refViewNames)
+};
+const decodeRequests = (value) => {
+	const requests = decodeHydrationValue(value);
+	if (!Array.isArray(requests) || !requests.every(isSerializedRequest)) throw new Error("fate: Invalid persisted request descriptors.");
+	return requests.map((request) => ({
+		...request,
+		items: request.items.map(decodeItem)
+	}));
+};
+//#endregion
+//#region src/persistence-utils.ts
+const encoder = new TextEncoder();
+const persistenceEntrySize = (key, value) => encoder.encode(JSON.stringify([key, value])).byteLength;
+const yieldPersistenceTask = () => new Promise((resolve) => setTimeout(resolve, 0));
+//#endregion
+//#region src/persistence-cache.ts
+const createNodeChanges = () => ({
+	listBases: /* @__PURE__ */ new Map(),
+	recordFields: /* @__PURE__ */ new Map(),
+	referenceChanges: /* @__PURE__ */ new Set(),
+	values: /* @__PURE__ */ new Map()
+});
+const decodeStoredValue = (value) => {
+	if (value === void 0) return;
+	if (!isRecord(value) || !Number.isSafeInteger(value.bytes) || value.bytes <= 0 || !Object.hasOwn(value, "value")) throw new Error("fate: Unsupported or corrupt persisted cache data.");
+	return value;
+};
+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,
+	referencesChanged: before?.referencesChanged || after.referencesChanged,
+	value: key.startsWith("r:") && before?.value && after.value ? applyRecordUpdate(before.value, after.value, after.fields ? new Set(after.fields) : void 0) : after.value
+});
+const withStoredSize = (key, value) => {
+	const item = {
+		bytes: 0,
+		value
+	};
+	for (;;) {
+		const bytes = persistenceEntrySize(key, item);
+		if (bytes === item.bytes) return item;
+		item.bytes = bytes;
+	}
+};
+const stamp = (time) => String(time).padStart(16, "0");
+const recordKey = (id) => `r:${id}`;
+const listKey = (id) => `l:${id}`;
+const queryKey = (id) => `q:${id}`;
+const pathsOverlap = (path, selected) => path === selected || path.startsWith(`${selected}.`) || selected.startsWith(`${path}.`);
+const projectRecord = (value, paths) => {
+	const fields = /* @__PURE__ */ new Set([
+		"id",
+		"__typename",
+		...paths.map((path) => path.split(".")[0])
+	]);
+	return {
+		paths: value.paths.filter((path) => paths.some((selected) => pathsOverlap(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;
+};
+/** 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.pendingNodes = createNodeChanges();
+		this.flushingNodes = createNodeChanges();
+		this.recoveryUpdates = /* @__PURE__ */ new Map();
+		this.pendingRequests = /* @__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 (withStoredSize(`${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.recoveryUpdates.get(key);
+			const update = this.pendingNodes.values.has(key) ? mergeCacheUpdate(key, recovery, {
+				fields: this.pendingNodes.recordFields.get(key) ? [...this.pendingNodes.recordFields.get(key)] : void 0,
+				value: this.pendingNodes.values.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.pendingNodes.values.has(listKey(key)) ? this.pendingNodes.values.get(listKey(key)) : this.recoveryUpdates.has(listKey(key)) ? this.recoveryUpdates.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 persistenceEntrySize(`${this.prefix}bytes`, this.maxBytes);
+	}
+	async step() {
+		this.assertActive();
+		if (++this.work % 64 === 0) {
+			await yieldPersistenceTask();
+			this.assertActive();
+		}
+	}
+	nodeKey(key) {
+		return `${this.prefix}node:${key}`;
+	}
+	rootKey(key) {
+		return `${this.prefix}root:${key}`;
+	}
+	async read(key) {
+		return (await this.readStored(key))?.value;
+	}
+	async readStored(key) {
+		return decodeStoredValue(await this.storage.read(key));
+	}
+	async put(entries) {
+		let bytes = await this.storage.read(`${this.prefix}bytes`) ?? 0;
+		const writes = [];
+		const unique = /* @__PURE__ */ new Map();
+		for (const [key, value, previousBytes] of entries) unique.set(key, [value, previousBytes]);
+		for (const [key, [value, knownPreviousBytes]] of unique) {
+			const previousBytes = knownPreviousBytes ?? (await this.readStored(key))?.bytes ?? 0;
+			bytes -= previousBytes;
+			if (value === void 0) writes.push([key, void 0]);
+			else {
+				const item = withStoredSize(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.pendingNodes.values.size > 0 || this.recoveryUpdates.size > 0;
+	}
+	changedNode(change) {
+		if (!this.suppressed && change) {
+			const selected = change.kind === "record" && change.paths ? new Set([...change.paths].map((path) => path.split(".")[0])) : void 0;
+			if (change.kind === "record") {
+				const id = recordKey(change.key);
+				const previous = this.pendingNodes.recordFields.get(id);
+				this.pendingNodes.recordFields.set(id, selected?.size && (!this.pendingNodes.recordFields.has(id) || previous) ? /* @__PURE__ */ new Set([...previous ?? [], ...selected]) : void 0);
+				if (change.referencesChanged) this.pendingNodes.referenceChanges.add(id);
+			}
+			const id = change.kind === "record" ? recordKey(change.key) : listKey(change.key);
+			const value = change.kind === "record" ? this.client.store.readConfirmed(change.key) : this.client.store.readConfirmedList(change.key);
+			if (change.kind === "list" && !this.pendingNodes.values.has(id)) this.pendingNodes.listBases.set(id, change.previousList);
+			this.pendingNodes.values.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 : change.kind === "list" ? change.previousList : void 0,
+					referencesChanged: previous?.referencesChanged || change.kind === "record" && change.referencesChanged,
+					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.pendingNodes.recordFields.get(key) ? [...this.pendingNodes.recordFields.get(key)] : void 0,
+				previousList: this.pendingNodes.listBases.has(key) ? this.pendingNodes.listBases.get(key) : update.previousList,
+				referencesChanged: this.pendingNodes.referenceChanges.has(key),
+				value: this.pendingNodes.values.get(key)
+			});
+			this.pendingNodes.values.delete(key);
+			this.pendingNodes.recordFields.delete(key);
+			this.pendingNodes.referenceChanges.delete(key);
+			this.pendingNodes.listBases.delete(key);
+		}
+		return encodeHydrationValue([...changes]);
+	}
+	replayChanges(updates) {
+		this.recoveryUpdates.clear();
+		for (const encoded of updates) for (const [key, update] of decodeHydrationValue(encoded)) {
+			const compatible = key.startsWith("r:") && update.referencesChanged === void 0 ? {
+				...update,
+				referencesChanged: true
+			} : update;
+			this.recoveryUpdates.set(key, mergeCacheUpdate(key, this.recoveryUpdates.get(key), compatible));
+		}
+	}
+	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.pendingRequests.get(request.key);
+		const retain = this.client.retainPersistenceRequest(request);
+		previous?.release();
+		this.pendingRequests.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(projectRecord(decodeHydrationValue(node.value), paths));
+		}
+		return node;
+	}
+	/** Walk only the requested selection, yielding between small pieces of work. */
+	async collect(request, source) {
+		const readsMemory = source !== "disk";
+		const prefersNetworkResult = source === "network";
+		const nodes = /* @__PURE__ */ new Map();
+		const visited = /* @__PURE__ */ new Map();
+		let complete = true;
+		let fetchedAt = Infinity;
+		const queue = [];
+		const readNode = async (key) => {
+			await this.step();
+			if (readsMemory) {
+				if (this.flushingNodes.values.has(key)) {
+					const incoming = this.flushingNodes.values.get(key);
+					const base = this.flushingNodes.listBases.get(key);
+					if (!prefersNetworkResult && 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.flushingNodes.recordFields.get(key)) {
+						const stored = await this.node(key);
+						if (stored) return applyRecordUpdate(decodeHydrationValue(stored.value), incoming, this.flushingNodes.recordFields.get(key));
+					}
+					return incoming;
+				}
+				if (prefersNetworkResult) {
+					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.pendingNodes.values.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 readsMemory && key.startsWith("r:") ? this.client.store.readConfirmed(key.slice(2)) : void 0;
+			const value = decodeHydrationValue(stored.value);
+			if (!readsMemory) return value;
+			const deleted = (id) => this.flushingNodes.values.has(recordKey(id)) && this.flushingNodes.values.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 readNode(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 readNode(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 record = await readNode(key);
+			if (!record) {
+				complete = false;
+				continue;
+			}
+			if (paths.some((path) => !record.paths.some((covered) => path === covered || path.startsWith(`${covered}.`)))) complete = false;
+			const all = /* @__PURE__ */ new Set([...seen?.paths ?? [], ...paths]);
+			nodes.set(key, {
+				paths: all,
+				value: projectRecord(record, [...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 = record.record[field];
+				if (Array.isArray(value)) {
+					const nestedKey = getListKey(id, field, plan.args.get(childPrefix)?.hash);
+					const list = await readNode(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, "disk");
+			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;
+		let writes = [];
+		for (const key of root.nodes) {
+			const storageKey = this.nodeKey(key);
+			const stored = await this.readStored(storageKey);
+			const node = stored?.value;
+			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(projectRecord(decodeHydrationValue(node.value), live.flatMap((claim) => claim.paths)));
+				writes.push([
+					storageKey,
+					live.length ? node : void 0,
+					stored.bytes
+				]);
+				if (writes.length === 64) {
+					await this.put(writes);
+					writes = [];
+				}
+			}
+			await this.step();
+		}
+		if (writes.length) await this.put(writes);
+		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, fromNetwork ? "network" : "memory");
+		const root = {
+			fetchedAt,
+			maxAge,
+			nodes: [...nodes.keys()],
+			request: encodeRequests([request]),
+			usedAt
+		};
+		let minimum = withStoredSize(this.rootKey(request.key), root).bytes + withStoredSize(`${this.prefix}lru:${stamp(usedAt)}:${request.key}`, request.key).bytes + withStoredSize(`${this.prefix}expiry:${stamp(fetchedAt + maxAge)}:${request.key}`, request.key).bytes + withStoredSize(`${this.prefix}scope`, this.client.getPersistenceScope()).bytes;
+		for (const [key, node] of nodes) {
+			minimum += withStoredSize(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 = projectRecord({
+						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.readStored(key);
+				added += Math.max(0, (value === void 0 ? 0 : withStoredSize(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) => decodeStoredValue(entry.value)?.value !== request.key);
+			if (!candidate) {
+				await this.remove(request.key);
+				return;
+			}
+			const id = decodeStoredValue(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 yieldPersistenceTask();
+		}
+		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 = decodeStoredValue(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 = decodeStoredValue(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;
+	}
+	/** Check fixed cache metadata before evicting any saved requests for a new journal entry. */
+	async fitsWithoutEviction(journalBytes) {
+		this.assertActive();
+		const scope = await this.storage.read(`${this.prefix}scope`);
+		this.assertActive();
+		return (scope?.bytes ?? 0) + journalBytes + this.overhead <= this.maxBytes;
+	}
+	async flush(journalBytes) {
+		if (!await this.active()) {
+			this.reset();
+			return;
+		}
+		await this.prune(journalBytes);
+		const pending = this.pendingRequests;
+		this.pendingRequests = /* @__PURE__ */ new Map();
+		const pendingNodes = this.pendingNodes;
+		this.pendingNodes = createNodeChanges();
+		const { listBases, recordFields, referenceChanges, values } = pendingNodes;
+		const recovery = this.recoveryUpdates;
+		this.recoveryUpdates = /* @__PURE__ */ new Map();
+		const updates = new Map(recovery);
+		for (const [key, value] of values) updates.set(key, mergeCacheUpdate(key, updates.get(key), {
+			fields: recordFields.get(key) ? [...recordFields.get(key)] : void 0,
+			previousList: listBases.get(key),
+			referencesChanged: referenceChanges.has(key),
+			value
+		}));
+		this.flushingNodes = {
+			listBases: new Map([...updates].map(([key, update]) => [key, update.previousList])),
+			recordFields: new Map([...updates].map(([key, update]) => [key, update.fields ? new Set(update.fields) : void 0])),
+			referenceChanges: new Set([...updates].filter(([, update]) => update.referencesChanged).map(([key]) => key)),
+			values: new Map([...updates].map(([key, update]) => [key, update.value]))
+		};
+		try {
+			const affected = /* @__PURE__ */ new Map();
+			for (const key of this.flushingNodes.values.keys()) {
+				const node = await this.node(key);
+				const incoming = this.flushingNodes.values.get(key);
+				if (node && incoming && key.startsWith("r:") && !this.flushingNodes.referenceChanges.has(key)) {
+					const before = decodeHydrationValue(node.value);
+					const after = applyRecordUpdate(before, incoming, this.flushingNodes.recordFields.get(key));
+					const value = encodeHydrationValue(projectRecord({
+						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.readStored(this.nodeKey(key))).bytes;
+					const growth = Math.max(0, withStoredSize(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(projectRecord(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, "disk");
+				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.flushingNodes.values.clear();
+			await this.prune(journalBytes);
+		} catch (error) {
+			if (!this.disposed) {
+				for (const [key, update] of recovery) this.recoveryUpdates.set(key, this.recoveryUpdates.has(key) ? mergeCacheUpdate(key, update, this.recoveryUpdates.get(key)) : update);
+				for (const [key, value] of values) {
+					if (referenceChanges.has(key)) this.pendingNodes.referenceChanges.add(key);
+					if (key.startsWith("l:")) this.pendingNodes.listBases.set(key, listBases.get(key));
+					if (!this.pendingNodes.values.has(key)) {
+						this.pendingNodes.values.set(key, value);
+						this.pendingNodes.recordFields.set(key, recordFields.get(key));
+					} else if (key.startsWith("r:")) {
+						const before = recordFields.get(key);
+						const after = this.pendingNodes.recordFields.get(key);
+						this.pendingNodes.recordFields.set(key, before && after ? /* @__PURE__ */ new Set([...before, ...after]) : void 0);
+					}
+				}
+				for (const [key, entry] of pending) if (!this.pendingRequests.has(key)) {
+					this.pendingRequests.set(key, entry);
+					pending.delete(key);
+				}
+			}
+			throw error;
+		} finally {
+			this.flushingNodes = createNodeChanges();
+			for (const entry of pending.values()) entry.release();
+		}
+	}
+	async clear() {
+		this.assertActive();
+		this.reset();
+		while (true) {
+			const entries = await this.storage.scan(this.prefix, void 0, 64);
+			this.assertActive();
+			if (!entries.length) return;
+			await this.storage.writeBatch(entries.map(({ key }) => [key, void 0]));
+			await yieldPersistenceTask();
+			this.assertActive();
+		}
+	}
+	dispose() {
+		this.disposed = true;
+		this.reset();
+	}
+	reset() {
+		this.recoveryUpdates.clear();
+		this.policies = /* @__PURE__ */ new WeakMap();
+		for (const entry of this.pendingRequests.values()) entry.release();
+		this.pendingRequests.clear();
+		this.pendingNodes = createNodeChanges();
+		this.flushingNodes = createNodeChanges();
+	}
+};
+//#endregion
+//#region src/persistence-journal.ts
+const invalid = () => /* @__PURE__ */ new Error("fate: Unsupported or corrupt persistence data. It has not been overwritten.");
+const valid = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const entry = value;
+	if (typeof entry.id !== "string" || typeof entry.scope !== "string" || !Number.isInteger(entry.attempts) || entry.attempts < 0) return false;
+	if (entry.status === "failed") return !!entry.error && typeof entry.error === "object" && typeof entry.error.message === "string";
+	if (entry.status === "confirmed") return "cacheUpdates" in entry && "result" in entry;
+	return entry.status === "queued" || entry.status === "sending";
+};
+const hasSameFields = (left, right) => {
+	return [.../* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])].every((key) => left[key] === right[key]);
+};
+/** 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();
+	}
+	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 yieldPersistenceTask();
+					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();
+					this.validate?.(stored.entry);
+					entries.set(stored.entry.id, {
+						...stored,
+						key
+					});
+				}
+				if (page.length < 64) break;
+				after = page.at(-1).key;
+				await yieldPersistenceTask();
+			}
+			this.assertActive();
+			this.header = value;
+			this.entries = entries;
+		}
+		return { mutations: [...this.entries.values()].map(({ entry }) => ({ ...entry })) };
+	}
+	async prepare(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 || !hasSameFields(previous.entry, entry)) {
+				const key = previous?.key ?? `${this.prefix}${String(header.nextSequence++).padStart(16, "0")}:${entry.id}`;
+				const value = {
+					bytes: 0,
+					entry
+				};
+				let measured = persistenceEntrySize(key, value);
+				while (measured !== value.bytes) {
+					value.bytes = measured;
+					measured = persistenceEntrySize(key, value);
+				}
+				stored = {
+					...value,
+					entry: { ...entry },
+					key
+				};
+				writes.push([key, value]);
+			}
+			entries.set(entry.id, stored);
+			bytes += stored.bytes;
+			if (++count % 64 === 0) {
+				await yieldPersistenceTask();
+				this.assertActive();
+			}
+		}
+		for (const [id, { key }] of this.entries) if (!entries.has(id)) writes.push([key, void 0]);
+		bytes += persistenceEntrySize(this.key, header);
+		return {
+			bytes,
+			entries,
+			header,
+			writes
+		};
+	}
+	async commit(plan) {
+		this.assertActive();
+		if (plan.writes.length || !this.header) {
+			await this.storage.writeBatch([...plan.writes, [this.key, plan.header]]);
+			this.assertActive();
+			this.header = plan.header;
+			this.entries = plan.entries;
+		}
+	}
+	async save(data) {
+		await this.commit(await this.prepare(data));
+	}
+};
+//#endregion
+//#region src/persistence.ts
+const isPendingMutation = (entry) => entry.status === "queued" || entry.status === "sending";
+const replaceMutation = (data, id, replace) => {
+	const index = data.mutations.findIndex((entry) => entry.id === id);
+	if (index >= 0) data.mutations[index] = replace(data.mutations[index]);
+};
+const isTerminalDeliveryError = (status) => status !== void 0 && status >= 400 && status < 500 && ![
+	401,
+	403,
+	408,
+	429
+].includes(status);
+const mutationDiscardedError = () => /* @__PURE__ */ new Error("fate: Mutation was discarded.");
+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.snapshot = {
+			mutations: [],
+			status: "restoring"
+		};
+		this.listeners = /* @__PURE__ */ new Set();
+		this.commands = /* @__PURE__ */ new Map();
+		this.operations = /* @__PURE__ */ new Map();
+		this.mutationAdmission = Promise.resolve();
+		this.cacheChangeRevision = 0;
+		this.baseCheckpointRevision = 0;
+		this.checkpointedCacheUpdates = /* @__PURE__ */ new Set();
+		this.needsCacheRecovery = false;
+		this.needsCheckpoint = false;
+		this.waiters = /* @__PURE__ */ new Map();
+		this.disposed = false;
+		this.draining = false;
+		this.flushRequested = false;
+		this.refreshRequested = false;
+		this.onOnline = () => this.retry();
+		this.getSnapshot = () => this.snapshot;
+		this.subscribe = (listener) => {
+			this.listeners.add(listener);
+			return () => {
+				this.listeners.delete(listener);
+			};
+		};
+		this.loadJournal = () => this.storage.exclusive(`${this.key}:write`, () => this.journal.load());
+		this.updateJournal = (apply, admit = false) => this.storage.exclusive(`${this.key}:write`, async () => {
+			this.assertActive();
+			const data = await this.journal.load();
+			const result = await apply(data);
+			const plan = await this.journal.prepare(data);
+			const { bytes } = plan;
+			if (admit && !await this.cache.fitsWithoutEviction(bytes)) 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.");
+			this.assertActive();
+			await this.journal.commit(plan);
+			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();
+	}
+	clearError() {
+		if (!this.mutationError && this.snapshot.error) {
+			this.snapshot = {
+				...this.snapshot,
+				error: void 0
+			};
+			this.publish();
+		}
+	}
+	assertActive() {
+		if (this.disposed) throw new Error("fate: Persistence was disposed.");
+	}
+	async restore() {
+		const data = await this.loadJournal();
+		await this.cache.initialize();
+		if (this.disposed) return;
+		for (const entry of data.mutations) if (isPendingMutation(entry)) {
+			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 yieldPersistenceTask();
+			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;
+		let commitError;
+		let commitFailed = false;
+		if (operation.entityId) this.client.registerPendingOptimisticMutation(operation.entityId, promise);
+		return {
+			...operation,
+			commit: (result, persist = true) => {
+				if (commitFailed) throw commitError;
+				try {
+					if (persist) cacheUpdates ??= this.cache.captureChanges(() => operation.commit(result));
+					else this.cache.withoutChanges(() => operation.commit(result));
+				} catch (error) {
+					commitFailed = true;
+					commitError = error;
+					throw error;
+				}
+				resolve();
+			},
+			getCacheUpdates: () => cacheUpdates,
+			rollback: (persist = true) => {
+				try {
+					if (persist) operation.rollback();
+					else this.cache.withoutChanges(() => operation.rollback());
+				} finally {
+					resolve();
+				}
+			}
+		};
+	}
+	refresh() {
+		this.refreshRequested = true;
+		return this.refreshing ??= this.drainRefreshes();
+	}
+	async drainRefreshes() {
+		try {
+			while (this.refreshRequested && !this.disposed) {
+				this.refreshRequested = false;
+				await this.reconcile(await this.loadJournal());
+			}
+			this.retry();
+		} finally {
+			this.refreshing = void 0;
+			if (this.refreshRequested && !this.disposed) this.refresh().catch((error) => this.report(error));
+		}
+	}
+	async mutate(command) {
+		if (this.mutationError) throw this.mutationError;
+		const encoded = encodeCommand(command);
+		await this.ready;
+		this.assertActive();
+		const id = crypto.randomUUID();
+		const admission = this.mutationAdmission.then(async () => {
+			if (this.needsCheckpoint) await this.flushCache().catch((error) => this.report(error));
+			return this.updateJournal(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;
+		this.assertActive();
+		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;
+		this.assertActive();
+		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(change) {
+		if (this.disposed) return;
+		if (this.cache.changedNode(change)) {
+			this.needsCacheRecovery = true;
+			this.cacheChangeRevision++;
+		}
+		if (this.disposed || this.snapshot.status !== "ready") return;
+		if (this.flushing || this.draining) this.flushRequested = true;
+		else this.scheduleSave();
+	}
+	async flush() {
+		clearTimeout(this.saveTimer);
+		this.saveTimer = void 0;
+		await this.ready;
+		await this.flushCache();
+		this.clearError();
+	}
+	scheduleSave() {
+		if (!this.saveTimer && !this.disposed) this.saveTimer = setTimeout(() => {
+			this.saveTimer = void 0;
+			this.flush().catch((error) => this.report(error));
+		}, 25);
+	}
+	confirmedCacheEntries(data) {
+		const scope = this.client.getPersistenceScope();
+		return data.mutations.flatMap((entry) => entry.status === "confirmed" && entry.scope === scope ? [[entry.id, entry.cacheUpdates]] : []);
+	}
+	confirmedCacheUpdates(data) {
+		return this.confirmedCacheEntries(data).map(([, updates]) => updates);
+	}
+	async checkpointPendingBases(data) {
+		const revision = this.cacheChangeRevision;
+		const cacheUpdateIds = this.confirmedCacheEntries(data).map(([id]) => id);
+		if (revision === this.baseCheckpointRevision && cacheUpdateIds.every((id) => this.checkpointedCacheUpdates.has(id))) return;
+		const scope = this.client.getPersistenceScope();
+		if (!data.mutations.some((entry) => isPendingMutation(entry) && entry.scope === scope)) {
+			this.baseCheckpointRevision = revision;
+			for (const id of cacheUpdateIds) this.checkpointedCacheUpdates.add(id);
+			return;
+		}
+		for (const entry of data.mutations) if (isPendingMutation(entry) && entry.scope === scope) entry.base = await this.cache.mutationBase(this.command(entry), entry.base);
+		const plan = await this.journal.prepare(data);
+		await this.cache.prune(plan.bytes);
+		this.assertActive();
+		await this.journal.commit(plan);
+		this.baseCheckpointRevision = revision;
+		for (const id of cacheUpdateIds) this.checkpointedCacheUpdates.add(id);
+	}
+	async removeConfirmedEntries(data) {
+		const confirmedIds = new Set(data.mutations.filter((entry) => entry.status === "confirmed").map(({ id }) => id));
+		if (!confirmedIds.size) return;
+		data.mutations = data.mutations.filter(({ id }) => !confirmedIds.has(id));
+		await this.journal.commit(await this.journal.prepare(data));
+		for (const id of confirmedIds) this.checkpointedCacheUpdates.delete(id);
+	}
+	flushCache() {
+		this.assertActive();
+		this.flushRequested = true;
+		if (!this.flushing) {
+			const flushing = this.drainCacheFlushes();
+			this.flushing = flushing;
+			flushing.then(() => this.finishCacheFlush(flushing), () => this.finishCacheFlush(flushing));
+		}
+		return this.flushing;
+	}
+	finishCacheFlush(flushing) {
+		if (this.flushing !== flushing) return;
+		this.flushing = void 0;
+		if (this.flushRequested && !this.disposed) this.scheduleSave();
+	}
+	async drainCacheFlushes() {
+		while (this.flushRequested && !this.disposed) {
+			this.flushRequested = false;
+			await this.flushCacheOnce();
+		}
+	}
+	async flushCacheOnce() {
+		await this.storage.exclusive(`${this.key}:write`, async () => {
+			this.assertActive();
+			const data = await this.journal.load();
+			await this.reconcile(data);
+			this.cache.replayChanges(this.confirmedCacheUpdates(data));
+			await this.checkpointPendingBases(data);
+			await this.cache.flush((await this.journal.prepare(data)).bytes);
+			this.assertActive();
+			await this.removeConfirmedEntries(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, status) {
+		const failure = error instanceof Error ? error : new Error(String(error));
+		status ??= getErrorStatusCode(failure);
+		await this.updateJournal((data) => {
+			replaceMutation(data, id, (entry) => ({
+				attempts: entry.attempts,
+				command: entry.command,
+				error: {
+					message: failure.message,
+					status
+				},
+				id: entry.id,
+				scope: entry.scope,
+				status: "failed"
+			}));
+		});
+		await this.reconcile(await this.loadJournal());
+	}
+	forgetOperation(id) {
+		this.operations.delete(id);
+		this.waiters.delete(id);
+	}
+	/** Resolve an operation whose journal entry another client already removed. */
+	async recoverOperation(id, operation) {
+		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) throw error;
+			operation.rollback(false);
+			this.waiters.get(id)?.reject(mutationDiscardedError());
+		}
+		this.forgetOperation(id);
+	}
+	async recoverRemovedOperations(data) {
+		const retained = new Set(data.mutations.map(({ id }) => id));
+		for (const [id, operation] of this.operations) {
+			if (retained.has(id)) continue;
+			try {
+				await this.recoverOperation(id, operation);
+			} catch (error) {
+				this.report(error);
+				this.scheduleRetry();
+				return false;
+			}
+			if (this.disposed) return false;
+		}
+		return true;
+	}
+	async claim(entry) {
+		const data = await this.updateJournal((data) => {
+			const current = data.mutations.find((item) => item.id === entry.id);
+			if (!current || !isPendingMutation(current)) return;
+			replaceMutation(data, entry.id, () => ({
+				...current,
+				attempts: current.attempts + 1,
+				status: "sending"
+			}));
+			return data;
+		});
+		if (!data) return false;
+		await this.reconcile(data);
+		return true;
+	}
+	async confirm(entry, operation, encodedResult) {
+		const cacheUpdates = operation.getCacheUpdates();
+		if (!cacheUpdates) throw new Error("fate: Mutation confirmation did not capture its cache updates.");
+		await this.updateJournal((data) => {
+			replaceMutation(data, entry.id, (current) => ({
+				attempts: current.attempts,
+				cacheUpdates,
+				command: current.command,
+				id: current.id,
+				result: encodedResult,
+				scope: current.scope,
+				status: "confirmed"
+			}));
+		});
+		await this.reconcile(await this.loadJournal());
+	}
+	/** Deliver one claimed entry. False means the queue must pause for a retry. */
+	async deliver(entry, operation) {
+		let result;
+		try {
+			result = await operation.execute({
+				id: entry.id,
+				scope: this.key
+			});
+		} catch (error) {
+			if (this.disposed) return false;
+			const status = error instanceof Error ? getErrorStatusCode(error) : void 0;
+			if (isTerminalDeliveryError(status)) {
+				await this.fail(entry.id, error);
+				return true;
+			}
+			await this.queueRetry(entry.id, error, status);
+			return false;
+		}
+		if (this.disposed) return false;
+		let encodedResult;
+		try {
+			encodedResult = encodeHydrationValue(result);
+			operation.commit(result);
+		} catch (error) {
+			await this.fail(entry.id, error, 500);
+			return true;
+		}
+		try {
+			await this.confirm(entry, operation, encodedResult);
+			return true;
+		} catch (error) {
+			if (this.disposed) return false;
+			const status = error instanceof Error ? getErrorStatusCode(error) : void 0;
+			await this.queueRetry(entry.id, error, status);
+			return false;
+		}
+	}
+	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.loadJournal();
+					await this.reconcile(data);
+					if (!await this.recoverRemovedOperations(data)) return;
+					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);
+					if (!operation) throw new Error(`fate: Missing restored mutation operation '${entry.id}'.`);
+					const claimed = await this.claim(entry);
+					if (this.disposed) return;
+					if (!claimed) continue;
+					if (!await this.deliver(entry, operation)) return;
+				}
+			});
+			if ((this.needsCheckpoint || this.flushRequested) && !this.disposed) await this.flush().catch((error) => this.report(error));
+		} finally {
+			this.draining = false;
+		}
+	}
+	async queueRetry(id, error, status) {
+		await this.updateJournal((latest) => {
+			const item = latest.mutations.find((item) => item.id === id);
+			if (item && isPendingMutation(item)) replaceMutation(latest, id, () => ({
+				...item,
+				error: {
+					message: error instanceof Error ? error.message : String(error),
+					status
+				},
+				nextAttemptAt: Date.now() + Math.min(3e4, this.retryDelay * 2 ** Math.min(item.attempts - 1, 10)),
+				status: "queued"
+			}));
+		});
+		await this.reconcile(await this.loadJournal());
+		this.scheduleRetry();
+	}
+	async discard(id) {
+		await this.ready;
+		const outcome = await this.updateJournal((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 "confirmed";
+			if (!entry) return "missing";
+			data.mutations = data.mutations.filter((entry) => entry.id !== id);
+			return "discarded";
+		});
+		if (outcome === "missing") {
+			const operation = this.operations.get(id);
+			if (operation) await this.recoverOperation(id, operation);
+		} else if (outcome === "discarded") {
+			this.operations.get(id)?.rollback();
+			this.waiters.get(id)?.reject(mutationDiscardedError());
+			this.forgetOperation(id);
+		}
+		await this.refresh();
+	}
+	async clearCache() {
+		await this.ready;
+		this.assertActive();
+		await this.storage.exclusive(`${this.key}:write`, async () => {
+			this.assertActive();
+			await this.cache.clear();
+		});
+		this.assertActive();
+		await this.cache.initialize();
+		this.clearError();
+	}
+	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 };