statewire 0.17.2 → 0.18.0

package/dist/client/session.js

@@ -8,6 +8,7 @@ import { bindCommandsHost } from "../host/host.js";
 import "../wire/limits.js";
 import { DocumentStorageContext, SessionStorageContext, createMemorySessionStore } from "./sessionStore.js";
 import { backoff } from "./timing.js";
+import { wrapStorageError } from "./storageError.js";
 import { TERMINAL } from "./connection.js";
 import { randomId } from "../util/randomId.js";
 import { useContext, useEffect, useState } from "@assistant-ui/tap/react-shim";
@@ -42,9 +43,20 @@ const sleepUntilWake = (s, delayMs) => new Promise((resolve) => {
 	}, delayMs);
 	s.waiters.push(waiter);
 });
+const storageFailed = (s, cause) => {
+	const error = wrapStorageError(cause);
+	s.storageError = error;
+	for (const entry of s.pending) entry.reject(error);
+	s.transport?.storageFailed(error);
+};
 const setRecord = (s, record) => {
 	s.record = record;
-	if (!s.deactivated) s.store.save(record);
+	if (!s.deactivated) try {
+		s.store.save(record);
+	} catch (cause) {
+		storageFailed(s, cause);
+		throw s.storageError;
+	}
 };
 const backlog = (s) => s.pending.filter((p) => p.seq > s.durableSeq).map((p) => ({
 	seq: p.seq,
@@ -70,7 +82,7 @@ const syncBacklogInner = (s) => {
 };
 const syncBacklog = (s) => {
 	if (!s.shared) return syncBacklogInner(s);
-	transact(s, () => syncBacklogInner(s));
+	transactBackground(s, () => syncBacklogInner(s));
 };
 const transact = (s, fn) => {
 	if (!s.shared || s.deactivated) {
@@ -78,7 +90,7 @@ const transact = (s, fn) => {
 		return Promise.resolve();
 	}
 	const shared = s.shared;
-	const run = shared.txq.then(() => s.store.lock(async () => {
+	const result = shared.txq.then(() => s.store.lock(async () => {
 		const stored = s.store.load();
 		if (stored !== null && stored.clientId !== s.record.clientId) adoptReset(s, stored);
 		else if (stored !== null) {
@@ -97,9 +109,17 @@ const transact = (s, fn) => {
 			}
 		}
 		fn();
-	}));
-	shared.txq = run.then(() => {}, () => {});
-	return run;
+		const persistence = s.store.flush?.();
+		if (persistence) await persistence;
+	})).catch((cause) => {
+		storageFailed(s, cause);
+		throw s.storageError;
+	});
+	shared.txq = result.then(() => {}, () => {});
+	return result;
+};
+const transactBackground = (s, fn, done) => {
+	transact(s, fn).then(done, () => {});
 };
 const setIdle = (s, level) => {
 	if (level === s.idle) return;
@@ -136,7 +156,7 @@ const retainFailed = (s, entry, failure) => {
 		retainFailedInner(s, entry, failure);
 		return;
 	}
-	transact(s, () => retainFailedInner(s, entry, failure));
+	transactBackground(s, () => retainFailedInner(s, entry, failure));
 };
 const settleEntry = (s, entry, outcome) => {
 	s.pending = s.pending.filter((p) => p !== entry);
@@ -463,7 +483,7 @@ const handleHello = (s, { ops, syn }) => {
 		pump(s);
 		return;
 	}
-	transact(s, reconcile).then(() => {
+	transactBackground(s, reconcile, () => {
 		publishIngested(s);
 		pump(s);
 	});
@@ -496,10 +516,10 @@ const handleRefusal = (s, syn) => {
 	const cmdGap = typeof seq === "number" && firstCmd !== void 0 && firstCmd.seq > Math.max(seq, s.durableSeq) + 1;
 	const ctxGap = typeof ctxSeq === "number" && firstCtx !== void 0 && firstCtx.seq > ctxSeq + 1;
 	if (cmdGap || ctxGap) {
-		transact(s, () => {
+		transactBackground(s, () => {
 			if (cmdGap) sessionLostInner(s, seq, ctxSeq ?? 0);
 			else snapCtxClock(s, ctxSeq);
-		}).then(() => {
+		}, () => {
 			wake(s);
 			pump(s);
 		});
@@ -521,10 +541,11 @@ const handleFinish = (s, { reason }) => {
 	wake(s);
 };
 const isFinished = (s) => s.attach === "finished";
-const buildLanes = (s) => {
+const buildLanes = (s, persisted = false) => {
 	const ctxEntries = [];
 	for (const entry of s.ctxPending) {
 		if (entry.posted) continue;
+		if (persisted && (s.persistedRecord?.clientId !== s.record.clientId || entry.seq >= s.persistedRecord.ctxNextSeq)) break;
 		if (ctxEntries.length >= 256) break;
 		if (ctxEntries.length > 0 && entry.seq !== ctxEntries.at(-1).seq + 1) break;
 		ctxEntries.push(entry);
@@ -532,6 +553,7 @@ const buildLanes = (s) => {
 	const cmdEntries = [];
 	for (const entry of s.pending) {
 		if (entry.posted) continue;
+		if (persisted && (s.persistedRecord?.clientId !== s.record.clientId || entry.seq >= s.persistedRecord.nextSeq)) break;
 		if (cmdEntries.length >= 256) break;
 		if (cmdEntries.length > 0 && entry.seq !== cmdEntries.at(-1).seq + 1) break;
 		cmdEntries.push(entry);
@@ -560,21 +582,38 @@ const takeAttachLanes = (s) => {
 	const wanted = s.lanesOnAttach;
 	s.lanesOnAttach = false;
 	if (!wanted || !s.sessionKnown || s.record.context?.recover !== void 0) return null;
-	const lanes = buildLanes(s);
+	const lanes = buildLanes(s, true);
 	if (!lanes) return null;
 	s.attachLaneSeqs = [new Set(lanes.cmdEntries.map((p) => p.seq)), new Set(lanes.ctxEntries.map((c) => c.seq))];
 	for (const entry of lanes.cmdEntries) entry.attempted = true;
 	return lanes.frame;
 };
+const persistBeforeSend = (s) => {
+	if (s.storageError !== void 0) throw s.storageError;
+	if (!s.hydrated) return s.ready.then(() => persistBeforeSend(s));
+	const record = s.record;
+	try {
+		const pending = s.store.flush?.();
+		if (pending) return pending.then(() => {
+			s.persistedRecord = record;
+		}, (cause) => {
+			throw wrapStorageError(cause);
+		});
+		s.persistedRecord = record;
+	} catch (cause) {
+		throw wrapStorageError(cause);
+	}
+};
 const pump = async (s) => {
 	if (s.pumping) return;
 	s.pumping = true;
 	try {
 		while (s.running && !isFinished(s)) {
+			if (!s.hydrated) await s.ready;
 			const transport = s.transport;
 			if (buildLanes(s) === null) return;
 			if (s.attach !== "attached" || !transport) {
-				if (transport?.connection.status === "disconnected" && transport.connection.reason === "idle" || transport?.parked && s.pending.length > 0) transport.connection.reconnect();
+				if (transport?.connection.status === "standby" && transport.connection.reason === "idle" || transport?.parked && s.pending.length > 0) transport.connection.reconnect();
 				await waitForWake(s);
 				continue;
 			}
@@ -586,6 +625,10 @@ const pump = async (s) => {
 			const lanes = buildLanes(s);
 			if (!lanes) continue;
 			const epoch = s.attachEpoch;
+			const persistence = persistBeforeSend(s);
+			if (persistence) await persistence;
+			if (!s.running || isFinished(s)) return;
+			if (epoch !== s.attachEpoch || s.attach !== "attached") continue;
 			for (const entry of lanes.cmdEntries) entry.attempted = true;
 			let result;
 			try {
@@ -622,22 +665,31 @@ const pump = async (s) => {
 				}
 			}
 		}
+	} catch (error) {
+		storageFailed(s, error);
 	} finally {
 		s.pumping = false;
 	}
 };
 const start = (s) => {
+	s.running = true;
+	if (!s.hydrated) {
+		s.ready.then(() => {
+			if (s.running) start(s);
+		}, () => {});
+		return;
+	}
 	if (s.shared) {
 		s.shared.unsubscribe = s.store.subscribe(() => {
-			transact(s, () => consumeVerdicts(s));
+			transactBackground(s, () => consumeVerdicts(s));
 		});
 		s.running = true;
-		transact(s, () => {
+		transactBackground(s, () => {
 			if (s.store.load() === null) s.store.save(s.record);
 			s.recordPersisted = true;
 			adoptStored(s);
 			consumeVerdicts(s);
-		}).then(() => void pump(s));
+		}, () => void pump(s));
 		return;
 	}
 	if (!s.recordPersisted) {
@@ -715,7 +767,7 @@ const enqueue = (s, command, params, resolve, reject) => {
 	}).then(() => {
 		wake(s);
 		pump(s);
-	});
+	}, reject);
 };
 const adoptStored = (s) => {
 	const known = new Set(s.pending.map((p) => p.seq));
@@ -748,6 +800,16 @@ const adoptStored = (s) => {
 	s.pending.sort((a, b) => a.seq - b.seq);
 };
 const sendCommand = (s, method, params, protocol = s.options.protocol ?? "default") => {
+	if (!s.hydrated) {
+		const result = s.ready.then(() => sendCommand(s, method, params, protocol));
+		result.catch(() => {});
+		return result;
+	}
+	if (s.storageError !== void 0) {
+		const result = Promise.reject(s.storageError);
+		result.catch(() => {});
+		return result;
+	}
 	if (!s.running) return rejectedSend({
 		fate: "aborted",
 		cause: "unmount"
@@ -791,7 +853,7 @@ const discardFailed = (s, entry) => {
 		return;
 	}
 	if (findFailed(s, entry) === void 0) throw unknownFailed(entry);
-	transact(s, () => {
+	transactBackground(s, () => {
 		if (findFailed(s, entry) !== void 0) takeFailed(s, entry);
 	});
 };
@@ -879,6 +941,14 @@ const persistContext = (s) => {
 	});
 };
 const changeContext = (s, build) => {
+	if (!s.hydrated) {
+		s.ready.then(() => changeContext(s, build)).catch((cause) => {
+			const error = wrapStorageError(cause);
+			s.storageError = error;
+			s.transport?.storageFailed(error);
+		});
+		return;
+	}
 	if (!s.running || isFinished(s)) return;
 	const submit = () => {
 		if (!s.running || isFinished(s)) return;
@@ -912,7 +982,7 @@ const changeContext = (s, build) => {
 		submit();
 		wake(s);
 		pump(s);
-	} else transact(s, submit).then(() => {
+	} else transactBackground(s, submit, () => {
 		wake(s);
 		pump(s);
 	});
@@ -974,6 +1044,32 @@ const storedCommandCompatible = (command, current) => {
 	const offer = current.protocols.find((p) => p.name === command.protocol);
 	return produced !== void 0 && offer !== void 0 && inRange(produced.version, offer);
 };
+const loadSessionRecord = (store, options) => {
+	let stored = store.load();
+	if (stored !== null && !Array.isArray(stored.commands)) throw new Error("statewire: session storage loaded a record without a commands array");
+	const current = {
+		wire: options.wireVersion ?? { version: "2026-09-07" },
+		protocols: protocolOffers(options)
+	};
+	if (stored !== null && !stored.commands.every((command) => storedCommandCompatible(command, current))) {
+		if (!store.migrate) throw new Error("statewire: stored commands require a storage migration");
+		stored = store.migrate(stored, current);
+		if (stored !== null && !stored.commands.every((command) => storedCommandCompatible(command, current))) throw new Error("statewire: migrated commands are incompatible");
+		if (stored !== null) store.save(stored);
+	}
+	if (stored !== null && !Array.isArray(stored.commands)) throw new Error("statewire: session storage loaded a record without a commands array");
+	const record = stored ?? {
+		clientId: randomId(),
+		nextSeq: 1,
+		ctxNextSeq: 1,
+		commands: []
+	};
+	if (stored === null) store.save(record);
+	return {
+		record,
+		stored
+	};
+};
 const useStatewireSession = (options) => {
 	const [defaultStore] = useState(createMemorySessionStore);
 	const mounted = useContext(SessionStorageContext);
@@ -982,26 +1078,15 @@ const useStatewireSession = (options) => {
 	const store = options.sessionStore ?? mounted ?? defaultStore;
 	if (store.lock === void 0 !== (store.subscribe === void 0)) throw new Error("statewire: session storage must provide lock and subscribe together");
 	const [s] = useState(() => {
-		let stored = store.load();
-		if (stored !== null && !Array.isArray(stored.commands)) throw new Error("statewire: session storage loaded a record without a commands array");
-		const current = {
-			wire: options.wireVersion ?? { version: "2026-09-07" },
-			protocols: protocolOffers(options)
-		};
-		if (stored !== null && !stored.commands.every((command_0) => storedCommandCompatible(command_0, current))) {
-			if (!store.migrate) throw new Error("statewire: stored commands require a storage migration");
-			stored = store.migrate(stored, current);
-			if (stored !== null && !stored.commands.every((command) => storedCommandCompatible(command, current))) throw new Error("statewire: migrated commands are incompatible");
-			if (stored !== null) store.save(stored);
-		}
-		if (stored !== null && !Array.isArray(stored.commands)) throw new Error("statewire: session storage loaded a record without a commands array");
-		const record = stored ?? {
-			clientId: randomId(),
-			nextSeq: 1,
-			ctxNextSeq: 1,
-			commands: []
+		const { record, stored } = store.ready === void 0 ? loadSessionRecord(store, options) : {
+			record: {
+				clientId: randomId(),
+				nextSeq: 1,
+				ctxNextSeq: 1,
+				commands: []
+			},
+			stored: null
 		};
-		if (stored === null) store.save(record);
 		const session = {
 			options,
 			selection: void 0,
@@ -1014,6 +1099,7 @@ const useStatewireSession = (options) => {
 			}, stored.context.ops),
 			record,
 			ctx: {
+				beforeAttach: () => persistBeforeSend(session),
 				get clientId() {
 					return session.record.clientId;
 				},
@@ -1026,7 +1112,11 @@ const useStatewireSession = (options) => {
 				onDetach: () => handleDetach(session),
 				onFinish: (args_1) => handleFinish(session, args_1)
 			},
-			recordPersisted: stored !== null,
+			recordPersisted: store.ready === void 0,
+			hydrated: store.ready === void 0,
+			ready: void 0,
+			storageError: void 0,
+			persistedRecord: store.ready === void 0 ? record : null,
 			store,
 			documentStore,
 			shared: store.lock !== void 0 ? {
@@ -1080,6 +1170,34 @@ const useStatewireSession = (options) => {
 			notify: () => {},
 			commands: createMethodProxy((method, params) => sendCommand(session, method, params))
 		};
+		if (store.ready !== void 0) {
+			session.ready = store.ready.then(() => {
+				const { record: record_0 } = loadSessionRecord(store, session.options);
+				session.record = record_0;
+				session.contextDocuments = record_0.context === void 0 ? {
+					mode: "mounted",
+					documents: /* @__PURE__ */ new Map()
+				} : applyDocumentOps({
+					mode: "mounted",
+					documents: /* @__PURE__ */ new Map()
+				}, record_0.context.ops);
+				session.ctxOps = record_0.context?.ops;
+				session.ctxPending = record_0.context?.pending.map((entry) => ({
+					...entry,
+					posted: false
+				})) ?? [];
+				session.recordPersisted = true;
+				session.hydrated = true;
+				if (session.running) session.notify();
+			});
+			session.ready = session.ready.catch((cause) => {
+				const error = wrapStorageError(cause);
+				session.storageError = error;
+				session.transport?.storageFailed(error);
+				throw error;
+			});
+			session.ready.catch(() => {});
+		}
 		bindCommandsHost(session.commands, { setListener: (listener_0) => {
 			session.lifecycle = listener_0;
 		} });