statewire 0.23.0 → 0.24.1

package/dist/storage.js

@@ -1,8 +1,11 @@
 import { DEFAULT_PROTOCOL, negotiationHeaders, protocolToken } from "./wire/protocol.js";
+import { reviveDocumentValue } from "./document.js";
 import { wrapStorageError } from "./client/storageError.js";
 import { randomId } from "./util/randomId.js";
+import { IndexedDbSession, indexedDbBackend } from "./indexedDb.js";
 import { useEffect, useMemo, useRef } from "@assistant-ui/tap/react-shim";
 import { resource } from "@assistant-ui/tap";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 // src/storage.ts
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isOptionalString = (value) => value === void 0 || typeof value === "string";
@@ -11,7 +14,9 @@ const isStatement = (value) => isRecord(value) && isProtocol(value["protocol"])
 const isIdentified = (value) => typeof value["id"] === "string" && value["id"] !== "" && typeof value["ts"] === "number" && Number.isFinite(value["ts"]);
 const isLegacyCommand = (value) => isStatement(value) && isPositiveSafeInteger(value["seq"]);
 const isSessionCommand = (value) => isLegacyCommand(value) && isIdentified(value) && isOptionalString(value["owner"]);
-const isOutboxCommand = (value) => isStatement(value) && isIdentified(value) && (value["hold"] === void 0 || isRecord(value["hold"])) && (value["released"] === void 0 || value["released"] === true) && isOptionalString(value["by"]);
+const isOutboxCommand = (value) => isStatement(value) && isIdentified(value) && (value["held"] === void 0 || value["held"] === true) && (value["released"] === void 0 || value["released"] === true) && isOptionalString(value["by"]);
+const isLegacyOutboxCommand = (value) => isStatement(value) && isIdentified(value) && (value["hold"] === void 0 || isRecord(value["hold"])) && (value["released"] === void 0 || value["released"] === true) && isOptionalString(value["by"]);
+const isStoredSettled = (value) => isRecord(value) && isIdentified(value) && typeof value["method"] === "string" && Array.isArray(value["params"]) && (value["seq"] === void 0 || isPositiveSafeInteger(value["seq"])) && (value["failure"] === void 0 ? isRecord(value["result"]) && Array.isArray(value["result"]["value"]) : value["result"] === void 0 && isSendFailure(value["failure"]));
 const isSessionVerdict = (value) => isRecord(value) && isPositiveSafeInteger(value["seq"]) && isOptionalString(value["id"]) && (value["type"] === "result" || value["type"] === "rejected" || value["type"] === "failed" || value["type"] === "crashed" || value["type"] === "expired") && isOptionalString(value["code"]) && isOptionalString(value["message"]);
 const isSendFailure = (value) => {
 	if (!isRecord(value)) return false;
@@ -20,13 +25,15 @@ const isSendFailure = (value) => {
 		case "failed": return value["cause"] === "server" && isOptionalString(value["message"]);
 		case "crashed":
 		case "expired": return value["cause"] === "server";
-		case "aborted": return (value["cause"] === "unmount" || value["cause"] === "stream-gone" || value["cause"] === "session-lost" || value["cause"] === "removed") && (value["predecessorLost"] === void 0 || value["predecessorLost"] === true);
+		case "aborted": return (value["cause"] === "unmount" || value["cause"] === "stream-gone" || value["cause"] === "session-lost" || value["cause"] === "removed" || value["cause"] === "quota") && (value["predecessorLost"] === void 0 || value["predecessorLost"] === true);
 		case "lost": return value["cause"] === "unmount" || value["cause"] === "stream-gone" || value["cause"] === "session-lost";
 		default: return false;
 	}
 };
 const isFailedCommand = (value) => isRecord(value) && isProtocol(value["protocol"]) && isProducer(value["produced"]) && typeof value["command"] === "string" && Array.isArray(value["params"]) && isSendFailure(value["failure"]) && typeof value["ts"] === "number" && Number.isFinite(value["ts"]) && isPositiveSafeInteger(value["seq"]);
-const isLaneWith = (value, isCommand) => isRecord(value) && isPositiveSafeInteger(value["nextSeq"]) && Array.isArray(value["commands"]) && value["commands"].every(isCommand) && (value["outbox"] === void 0 || Array.isArray(value["outbox"]) && value["outbox"].every(isOutboxCommand)) && (value["removed"] === void 0 || Array.isArray(value["removed"]) && value["removed"].every((mark) => isRecord(mark) && typeof mark["id"] === "string" && typeof mark["by"] === "string")) && (value["verdicts"] === void 0 || Array.isArray(value["verdicts"]) && value["verdicts"].every(isSessionVerdict)) && (value["failed"] === void 0 || Array.isArray(value["failed"]) && value["failed"].every(isFailedCommand));
+const isArrayOf = (value, is) => value === void 0 || Array.isArray(value) && value.every(is);
+const isMark = (mark) => isRecord(mark) && typeof mark["id"] === "string" && typeof mark["by"] === "string" && (mark["failure"] === void 0 || isSendFailure(mark["failure"]));
+const isLaneWith = (value, isCommand, legacy = false) => isRecord(value) && isPositiveSafeInteger(value["nextSeq"]) && Array.isArray(value["commands"]) && value["commands"].every(isCommand) && isArrayOf(value["outbox"], legacy ? isLegacyOutboxCommand : isOutboxCommand) && isArrayOf(value["removed"], isMark) && isArrayOf(value["verdicts"], isSessionVerdict) && (legacy ? isArrayOf(value["failed"], isFailedCommand) : value["failed"] === void 0 && isArrayOf(value["inbox"], isStoredSettled));
 const isSessionLane = (value) => isLaneWith(value, isSessionCommand);
 const isClientId = (value) => typeof value === "string" && value.length > 0;
 const isRecordWith = (value, isLane) => isRecord(value) && isClientId(value["clientId"]) && isRecord(value["lanes"]) && Object.keys(value["lanes"]).every(isProtocol) && Object.values(value["lanes"]).every(isLane);
@@ -93,71 +100,162 @@ const liftLegacy = (value, protocol) => {
 		lanes
 	});
 };
+const upgrade = (record) => ({
+	clientId: record.clientId,
+	lanes: Object.fromEntries(Object.entries(record.lanes).map(([protocol, legacy]) => {
+		const { outbox, failed, ...lane } = legacy;
+		const inbox = [...failed ?? []].sort((a, b) => a.ts - b.ts).map((f) => ({
+			id: `failed:${protocol}:${f.seq}:${f.ts}`,
+			method: f.command,
+			params: f.params,
+			...f.meta !== void 0 && { meta: f.meta },
+			ts: f.ts,
+			failure: f.failure
+		}));
+		return [protocol, {
+			...lane,
+			...outbox?.length && { outbox: outbox.map(({ hold, ...command }) => ({
+				...command,
+				...hold !== void 0 && { held: true },
+				...hold?.meta !== void 0 && { localMeta: hold.meta }
+			})) },
+			...inbox.length > 0 && { inbox }
+		}];
+	}))
+});
+const isLegacyLane = (lane) => isLaneWith(lane, isSessionCommand, true);
 const normalize = (parsed, protocol) => {
 	if (!isRecord(parsed)) return invalid();
 	const { statewireStorageVersion: format, savedAt: _savedAt, ...value } = parsed;
-	if (format === 4) return isSessionRecord(value) ? value : invalid();
-	if (format === 3) return isRecordWith(value, (lane) => isLaneWith(lane, isLegacyCommand)) ? identify(value) : invalid();
+	if (format === 5) return isSessionRecord(value) ? value : invalid();
+	if (format === 4) return isRecordWith(value, isLegacyLane) ? upgrade(value) : invalid();
+	if (format === 3) return isRecordWith(value, (lane) => isLaneWith(lane, isLegacyCommand, true)) ? upgrade(identify(value)) : invalid();
 	if (format !== void 0 && format !== 1 && format !== 2) throw new Error("statewire: unsupported session storage version");
 	const { ctxNextSeq: _ctxNextSeq, context: _context, ...legacy } = value;
-	return liftLegacy(legacy, protocol);
+	return upgrade(liftLegacy(legacy, protocol));
 };
+const STORAGE_FORMAT = 5;
+const parse = async (raw, codec) => raw === null ? null : JSON.parse(codec === void 0 ? raw : await codec.decode(raw));
 const decode = (raw, protocol) => raw === null ? null : normalize(JSON.parse(raw), protocol);
-const isEmpty = (record) => Object.values(record.lanes).every((lane) => lane.commands.length === 0 && !lane.outbox?.length && !lane.failed?.length);
+const isUnsent = (lane) => lane.commands.length > 0 || (lane.outbox?.length ?? 0) > 0;
+const entryCount = (record) => record === null ? 0 : Object.values(record.lanes).reduce((sum, lane) => sum + lane.commands.length + (lane.outbox?.length ?? 0), 0);
+const noticesOf = (record) => Object.entries(record.lanes).flatMap(([protocol, lane]) => (lane.inbox ?? []).map((n) => ({
+	protocol,
+	id: n.id,
+	method: n.method,
+	params: n.params,
+	...n.seq !== void 0 && { seq: n.seq },
+	status: "settled",
+	...n.failure !== void 0 && { failure: n.failure },
+	...n.localMeta !== void 0 && { localMeta: n.localMeta }
+})));
 const active = /* @__PURE__ */ new WeakMap();
-const sweep = async (options, currentKey, quota = false) => {
-	const { backend, retention, namespace = "" } = options;
+/** Same-runtime saves, per backend, for `subscribeOutboxes`. */
+const savers = /* @__PURE__ */ new WeakMap();
+const announce = (backend, key) => {
+	for (const listener of savers.get(backend) ?? []) listener(key);
+};
+const sweeping = /* @__PURE__ */ new WeakMap();
+const sweep = (options, currentKey, quota = false) => {
+	const run = (sweeping.get(options.backend) ?? Promise.resolve()).catch(() => {}).then(() => sweepOnce(options, currentKey, quota));
+	sweeping.set(options.backend, run);
+	return run;
+};
+const sweepOnce = async (options, currentKey, quota = false) => {
+	const { backend, retention, namespace = "", codec, onEvict } = options;
 	if (!retention || !backend.getAllKeys) return;
-	const entries = [];
-	const candidate = (raw) => {
-		if (raw === null) return void 0;
+	const candidate = async (raw) => {
 		let value;
 		try {
-			value = JSON.parse(raw);
+			value = await parse(raw, codec);
 		} catch {
 			return;
 		}
+		if (value === null) return void 0;
+		let record;
 		try {
-			if (!isEmpty(normalize(value, "default"))) return void 0;
+			record = normalize(value, DEFAULT_PROTOCOL);
 		} catch {
 			return;
 		}
+		if (Object.values(record.lanes).some(isUnsent)) return void 0;
 		const savedAt = value["savedAt"] ?? value["updatedAt"];
-		return typeof savedAt === "number" && Number.isFinite(savedAt) ? savedAt : void 0;
+		return typeof savedAt === "number" && Number.isFinite(savedAt) ? {
+			savedAt,
+			record
+		} : void 0;
 	};
+	const empty = [];
+	const noticed = [];
 	for (const key of await backend.getAllKeys()) {
 		if (!key.startsWith(namespace) || key === currentKey || active.get(backend)?.has(key)) continue;
-		const savedAt = candidate(await backend.getItem(key));
-		if (savedAt !== void 0) entries.push({
+		const found = await candidate(await backend.getItem(key));
+		if (found === void 0) continue;
+		(noticesOf(found.record).length > 0 ? noticed : empty).push({
 			key,
-			savedAt
+			...found
 		});
 	}
-	entries.sort((a, b) => b.savedAt - a.savedAt);
+	const remove = async (entry, reason) => {
+		const run = async () => {
+			if (active.get(backend)?.has(entry.key)) return;
+			const again = await candidate(await backend.getItem(entry.key));
+			if (again?.savedAt !== entry.savedAt) return;
+			if (active.get(backend)?.has(entry.key)) return;
+			await backend.removeItem(entry.key);
+			announce(backend, entry.key);
+			onEvict?.({
+				key: entry.key,
+				reason,
+				dropped: noticesOf(again.record)
+			});
+		};
+		if (backend.withUnused) await backend.withUnused(entry.key, run);
+		else await run();
+	};
 	const now = Date.now();
+	const expired = (entry) => retention.maxAgeMs !== void 0 && now - entry.savedAt > retention.maxAgeMs;
+	empty.sort((a, b) => b.savedAt - a.savedAt);
 	let retained = 1;
-	const quotaStart = Math.floor(entries.length / 2);
-	for (const [index, entry] of entries.entries()) {
-		const expired = retention.maxAgeMs !== void 0 && now - entry.savedAt > retention.maxAgeMs;
+	const quotaStart = Math.floor(empty.length / 2);
+	for (const [index, entry] of empty.entries()) {
 		const overflow = retention.maxEntries !== void 0 && retained >= retention.maxEntries;
-		if (expired || overflow || quota && index >= quotaStart) {
-			const remove = async () => {
-				if (active.get(backend)?.has(entry.key)) return;
-				if (candidate(await backend.getItem(entry.key)) !== entry.savedAt) return;
-				if (active.get(backend)?.has(entry.key)) return;
-				await backend.removeItem(entry.key);
-			};
-			if (backend.withUnused) await backend.withUnused(entry.key, remove);
-			else await remove();
-		} else retained++;
+		if (expired(entry)) await remove(entry, "expired");
+		else if (overflow) await remove(entry, "overflow");
+		else if (quota && index >= quotaStart) await remove(entry, "quota");
+		else retained++;
 	}
+	for (const entry of noticed) if (expired(entry)) await remove(entry, "expired");
 };
 const isQuotaError = (error) => error instanceof Error && error.name === "QuotaExceededError";
+const quotaError = (limit) => {
+	const error = /* @__PURE__ */ new Error(`statewire: session ${limit} limit reached`);
+	error.name = "StatewireQuotaError";
+	return error;
+};
+const otherBytes = async (backend, namespace, key) => {
+	let total = 0;
+	for (const other of await backend.getAllKeys?.() ?? []) {
+		if (other === key || !other.startsWith(namespace)) continue;
+		total += (await backend.getItem(other))?.length ?? 0;
+	}
+	return total;
+};
+const validLimit = (value, name) => {
+	if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1)) throw new Error(`statewire: invalid session limit ${name}`);
+};
 const useKeyValueSessionStorage = (options) => {
-	const { backend, key, namespace = "", protocol = DEFAULT_PROTOCOL, migrate, retention: suppliedRetention, onError } = options;
-	const latestErrorHandler = useRef(onError);
-	latestErrorHandler.current = onError;
-	const reportError = useMemo(() => (error) => latestErrorHandler.current?.(error), []);
+	const { backend, key, namespace = "", protocol = DEFAULT_PROTOCOL, migrate, retention: suppliedRetention, limits: suppliedLimits, codec, onError, onEvict } = options;
+	const latest = useRef({
+		onError,
+		onEvict
+	});
+	latest.current = {
+		onError,
+		onEvict
+	};
+	const reportError = useMemo(() => (error) => latest.current.onError?.(error), []);
+	const reportEvict = useMemo(() => (event) => latest.current.onEvict?.(event), []);
 	const retain = suppliedRetention !== void 0;
 	const maxAgeMs = suppliedRetention?.maxAgeMs;
 	const maxEntries = suppliedRetention?.maxEntries;
@@ -169,16 +267,27 @@ const useKeyValueSessionStorage = (options) => {
 		maxAgeMs,
 		maxEntries
 	]);
+	const outboxEntries = suppliedLimits?.outboxEntries;
+	const recordBytes = suppliedLimits?.recordBytes;
+	const totalBytes = suppliedLimits?.totalBytes;
+	validLimit(outboxEntries, "outboxEntries");
+	validLimit(recordBytes, "recordBytes");
+	validLimit(totalBytes, "totalBytes");
+	if (totalBytes !== void 0 && !backend.getAllKeys) throw new Error("statewire: a totalBytes limit requires getAllKeys");
 	const configured = useMemo(() => ({
 		backend,
 		key,
 		namespace,
+		onEvict: reportEvict,
+		...codec === void 0 ? {} : { codec },
 		...retention === void 0 ? {} : { retention }
 	}), [
 		backend,
 		key,
 		namespace,
-		retention
+		retention,
+		codec,
+		reportEvict
 	]);
 	const storageKey = namespace + key;
 	if (retention !== void 0) {
@@ -198,17 +307,24 @@ const useKeyValueSessionStorage = (options) => {
 		}
 		const state = {
 			record: null,
+			bytes: 0,
+			others: void 0,
 			ready: void 0,
 			queue: Promise.resolve(),
 			pending: 0,
 			failure: void 0,
-			asynchronous: typeof raw !== "string" && raw !== null,
-			hydrated: typeof raw === "string" || raw === null
+			asynchronous: codec !== void 0 || typeof raw !== "string" && raw !== null,
+			hydrated: false
+		};
+		const hydrate = (record) => {
+			state.record = record;
+			state.hydrated = true;
 		};
 		if (state.asynchronous) {
-			state.ready = Promise.resolve(raw).then((value) => {
-				state.record = decode(value, protocol);
-				state.hydrated = true;
+			state.ready = Promise.resolve(raw).then(async (value) => {
+				state.bytes = value?.length ?? 0;
+				const parsed = await parse(value, codec);
+				hydrate(parsed === null ? null : normalize(parsed, protocol));
 			}).catch((cause_0) => {
 				const error_1 = wrapStorageError(cause_0);
 				if (state.failure !== error_1) reportError(error_1);
@@ -217,7 +333,8 @@ const useKeyValueSessionStorage = (options) => {
 			});
 			state.ready.catch(() => {});
 		} else try {
-			state.record = decode(raw, protocol);
+			state.bytes = raw?.length ?? 0;
+			hydrate(decode(raw, protocol));
 		} catch (cause_1) {
 			const error_2 = wrapStorageError(cause_1);
 			reportError(error_2);
@@ -228,6 +345,7 @@ const useKeyValueSessionStorage = (options) => {
 		backend,
 		storageKey,
 		protocol,
+		codec,
 		reportError
 	]);
 	useEffect(() => {
@@ -253,94 +371,151 @@ const useKeyValueSessionStorage = (options) => {
 		retention,
 		reportError
 	]);
-	return useMemo(() => ({
-		...state_0.ready === void 0 ? {} : { ready: state_0.ready },
-		load: () => {
-			if (state_0.failure !== void 0) throw state_0.failure;
-			if (!state_0.hydrated) throw new Error("statewire: await session storage readiness before loading");
-			if (state_0.asynchronous || state_0.pending > 0) return state_0.record;
-			let raw_0;
-			try {
-				raw_0 = backend.getItem(storageKey);
-			} catch (cause_3) {
-				const error_4 = wrapStorageError(cause_3);
-				reportError(error_4);
-				throw error_4;
-			}
-			if (typeof raw_0 !== "string" && raw_0 !== null) throw new Error("statewire: storage backend changed from synchronous to asynchronous");
+	useEffect(() => {
+		if (totalBytes === void 0) return;
+		otherBytes(backend, namespace, storageKey).then((bytes) => {
+			state_0.others = bytes;
+		}, () => {});
+	}, [
+		state_0,
+		backend,
+		namespace,
+		storageKey,
+		totalBytes
+	]);
+	return useMemo(() => {
+		const checkLimits = (record_0, bytes_0) => {
+			if (entryCount(record_0) <= entryCount(state_0.record)) return;
+			if (outboxEntries !== void 0 && entryCount(record_0) > outboxEntries) throw quotaError("outboxEntries");
+			if (recordBytes !== void 0 && bytes_0 > recordBytes) throw quotaError("recordBytes");
+			if (totalBytes !== void 0 && state_0.others !== void 0 && state_0.others + bytes_0 > totalBytes) throw quotaError("totalBytes");
+		};
+		const persist = async (encoded) => {
+			const stored = codec === void 0 ? encoded : await codec.encode(encoded);
 			try {
-				return decode(raw_0, protocol);
-			} catch (cause_4) {
-				const error_5 = wrapStorageError(cause_4);
-				reportError(error_5);
-				throw error_5;
+				await backend.setItem(storageKey, stored);
+			} catch (error_4) {
+				if (!isQuotaError(error_4)) throw error_4;
+				if (retention !== void 0) await sweep(configured, storageKey, true);
+				await backend.setItem(storageKey, stored);
 			}
-		},
-		save: (record) => {
-			if (state_0.failure !== void 0) throw state_0.failure;
-			if (!state_0.hydrated) throw new Error("statewire: await session storage readiness before saving");
-			if (!isSessionRecord(record)) throw new Error("statewire: invalid session record");
-			const encoded = JSON.stringify({
-				...record,
-				statewireStorageVersion: 4,
-				savedAt: Date.now()
-			});
-			state_0.record = record;
-			const recoverQuota = async (error_6) => {
-				if (!isQuotaError(error_6) || retention === void 0) throw error_6;
-				await sweep(configured, storageKey, true);
-				await backend.setItem(storageKey, encoded);
-			};
-			const write = async () => {
+			announce(backend, storageKey);
+		};
+		return {
+			durable: true,
+			...state_0.ready === void 0 ? {} : { ready: state_0.ready },
+			read: async () => {
+				if (state_0.failure !== void 0) throw state_0.failure;
+				await state_0.ready;
+				await state_0.queue.catch(() => {});
 				try {
-					await backend.setItem(storageKey, encoded);
-				} catch (error_7) {
-					await recoverQuota(error_7);
+					const raw_0 = await backend.getItem(storageKey);
+					const parsed_0 = await parse(raw_0, codec);
+					state_0.bytes = raw_0?.length ?? 0;
+					state_0.record = parsed_0 === null ? null : normalize(parsed_0, protocol);
+					return state_0.record;
+				} catch (cause_3) {
+					const error_5 = wrapStorageError(cause_3);
+					reportError(error_5);
+					throw error_5;
 				}
-			};
-			if (!state_0.asynchronous && state_0.pending === 0) {
-				let result;
+			},
+			load: () => {
+				if (state_0.failure !== void 0) throw state_0.failure;
+				if (!state_0.hydrated) throw new Error("statewire: await session storage readiness before loading");
+				if (state_0.asynchronous || state_0.pending > 0) return state_0.record;
+				let raw_1;
 				try {
-					result = backend.setItem(storageKey, encoded);
-				} catch (error_8) {
-					if (!isQuotaError(error_8) || retention === void 0) {
-						state_0.failure = wrapStorageError(error_8);
-						reportError(state_0.failure);
-						throw state_0.failure;
+					raw_1 = backend.getItem(storageKey);
+				} catch (cause_4) {
+					const error_6 = wrapStorageError(cause_4);
+					reportError(error_6);
+					throw error_6;
+				}
+				if (typeof raw_1 !== "string" && raw_1 !== null) throw new Error("statewire: storage backend changed from synchronous to asynchronous");
+				try {
+					state_0.record = decode(raw_1, protocol);
+					return state_0.record;
+				} catch (cause_5) {
+					const error_7 = wrapStorageError(cause_5);
+					reportError(error_7);
+					throw error_7;
+				}
+			},
+			save: (record_1) => {
+				if (state_0.failure !== void 0) throw state_0.failure;
+				if (!state_0.hydrated) throw new Error("statewire: await session storage readiness before saving");
+				if (!isSessionRecord(record_1)) throw new Error("statewire: invalid session record");
+				const encoded_0 = JSON.stringify({
+					...record_1,
+					statewireStorageVersion: 5,
+					savedAt: Date.now()
+				});
+				checkLimits(record_1, encoded_0.length);
+				if (!state_0.asynchronous && state_0.pending === 0) {
+					try {
+						backend.setItem(storageKey, encoded_0);
+					} catch (error_8) {
+						if (!isQuotaError(error_8)) {
+							state_0.failure = wrapStorageError(error_8);
+							reportError(state_0.failure);
+							throw state_0.failure;
+						}
+						if (entryCount(record_1) > entryCount(state_0.record)) {
+							if (retention !== void 0) sweep(configured, storageKey, true).catch(() => {});
+							throw quotaError("backend");
+						}
+						state_0.record = record_1;
+						state_0.bytes = encoded_0.length;
+						state_0.pending++;
+						state_0.queue = persist(encoded_0).finally(() => {
+							state_0.pending--;
+						});
+						state_0.queue.catch((cause_6) => {
+							const failure = wrapStorageError(cause_6);
+							if (state_0.failure !== failure) reportError(failure);
+							state_0.failure = failure;
+						});
+						return;
 					}
-					result = recoverQuota(error_8);
+					state_0.record = record_1;
+					state_0.bytes = encoded_0.length;
+					announce(backend, storageKey);
+					return;
 				}
-				if (result === void 0) return;
+				state_0.record = record_1;
+				state_0.bytes = encoded_0.length;
 				state_0.pending++;
-				state_0.queue = result;
-			} else {
-				state_0.pending++;
-				state_0.queue = state_0.queue.then(() => state_0.ready).then(write);
-			}
-			state_0.queue = state_0.queue.catch((cause_5) => {
-				const error_9 = wrapStorageError(cause_5);
-				if (state_0.failure !== error_9) reportError(error_9);
-				state_0.failure = error_9;
-				throw error_9;
-			}).finally(() => {
-				state_0.pending--;
-			});
-			state_0.queue.catch(() => {});
-		},
-		flush: () => {
-			if (state_0.failure !== void 0) throw state_0.failure;
-			if (!state_0.asynchronous && state_0.pending === 0) return;
-			return (async () => {
-				await state_0.ready;
-				for (;;) {
-					const queue = state_0.queue;
-					await queue;
-					if (queue === state_0.queue) return;
-				}
-			})();
-		},
-		...migrate === void 0 ? {} : { migrate }
-	}), [
+				state_0.queue = state_0.queue.then(() => state_0.ready).then(() => persist(encoded_0)).catch((cause_7) => {
+					const error_9 = wrapStorageError(cause_7);
+					if (state_0.failure !== error_9) reportError(error_9);
+					state_0.failure = error_9;
+					throw error_9;
+				}).finally(() => {
+					state_0.pending--;
+				});
+				state_0.queue.catch(() => {});
+			},
+			flush: () => {
+				if (state_0.failure !== void 0) throw state_0.failure;
+				if (!state_0.asynchronous && state_0.pending === 0) return;
+				return (async () => {
+					await state_0.ready;
+					for (;;) {
+						const queue = state_0.queue;
+						await queue;
+						if (queue === state_0.queue) return;
+					}
+				})();
+			},
+			onEvict: ({ reason, dropped }) => reportEvict({
+				key: storageKey,
+				reason,
+				dropped
+			}),
+			...migrate === void 0 ? {} : { migrate }
+		};
+	}, [
 		state_0,
 		backend,
 		storageKey,
@@ -348,11 +523,98 @@ const useKeyValueSessionStorage = (options) => {
 		migrate,
 		retention,
 		configured,
-		reportError
+		codec,
+		outboxEntries,
+		recordBytes,
+		totalBytes,
+		reportError,
+		reportEvict
 	]);
 };
 /** Persist sessions through a synchronous or asynchronous string storage backend. */
 const KeyValueSessionStorage = resource(useKeyValueSessionStorage);
-export { KeyValueSessionStorage };
+const pages = /* @__PURE__ */ new Map();
+const useMemorySessionStorage = (t0) => {
+	const $ = c(2);
+	const { scope } = t0;
+	let t1;
+	if ($[0] !== scope) {
+		t1 = {
+			durable: false,
+			load: () => pages.get(scope) ?? null,
+			save: (record) => {
+				pages.set(scope, record);
+			}
+		};
+		$[0] = scope;
+		$[1] = t1;
+	} else t1 = $[1];
+	return t1;
+};
+/** Session storage in page memory, keyed by scope: the record and client identity survive remounts, not reloads. */
+const MemorySessionStorage = resource(useMemorySessionStorage);
+const entriesOf = (record) => Object.entries(record.lanes).flatMap(([protocol, lane]) => {
+	const view = (c, state) => ({
+		id: c.id,
+		protocol,
+		command: {
+			method: c.method,
+			params: c.meta === void 0 ? c.params : reviveDocumentValue(structuredClone(c.params), c.meta)
+		},
+		ts: c.ts,
+		state,
+		localMeta: c.localMeta,
+		durable: true
+	});
+	return [...[...lane.commands].sort((a, b) => a.seq - b.seq).map((c) => view(c, "sending")), ...(lane.outbox ?? []).map((c) => view(c, c.held ? "held" : "queued"))];
+});
+/** Reads the outboxes of every session under `namespace`, mounted or not. */
+const readOutboxes = async (backend, options) => {
+	if (!backend.getAllKeys) throw new Error("statewire: readOutboxes requires getAllKeys");
+	const { namespace, codec, protocol = DEFAULT_PROTOCOL } = options;
+	if (!namespace) throw new Error("statewire: readOutboxes requires a namespace");
+	const result = [];
+	for (const key of await backend.getAllKeys()) {
+		if (!key.startsWith(namespace)) continue;
+		const parsed = await parse(await backend.getItem(key), codec);
+		if (parsed === null) continue;
+		const entries = entriesOf(normalize(parsed, protocol));
+		if (entries.length > 0) result.push({
+			key,
+			entries
+		});
+	}
+	return result;
+};
+/** Calls `listener` with `readOutboxes` now and after every save under `namespace`; returns unsubscribe. */
+const subscribeOutboxes = (backend, options, listener, onError) => {
+	let closed = false;
+	let reading = Promise.resolve();
+	const refresh = () => {
+		reading = reading.then(async () => {
+			if (closed) return;
+			try {
+				const outboxes = await readOutboxes(backend, options);
+				if (!closed) listener(outboxes);
+			} catch (error) {
+				onError(error);
+			}
+		});
+	};
+	const onKey = (key) => {
+		if (key.startsWith(options.namespace)) refresh();
+	};
+	const local = savers.get(backend) ?? /* @__PURE__ */ new Set();
+	savers.set(backend, local);
+	local.add(onKey);
+	const remote = backend.subscribe?.(onKey);
+	refresh();
+	return () => {
+		closed = true;
+		local.delete(onKey);
+		remote?.();
+	};
+};
+export { IndexedDbSession, KeyValueSessionStorage, MemorySessionStorage, STORAGE_FORMAT, indexedDbBackend, readOutboxes, subscribeOutboxes };
 
 //# sourceMappingURL=storage.js.map