statewire 0.10.0 → 0.12.0

package/dist/client/session.js

@@ -5,6 +5,7 @@ import { bindCommandsHost } from "../host/host.js";
 import { encodeParams, encodeValue, reviveResponse, reviveValue } from "../wire/meta.js";
 import { SessionStorageContext, createMemorySessionStore } from "./sessionStore.js";
 import { backoff } from "./timing.js";
+import { TERMINAL } from "./connection.js";
 import { randomId } from "../util/randomId.js";
 import { useContext, useEffect, useState } from "@assistant-ui/tap/react-shim";
 //#region src/client/session.ts
@@ -47,14 +48,43 @@ const backlog = (s) => s.pending.filter((p) => p.seq > s.durableSeq).map((p) =>
 	seq: p.seq,
 	...p.command
 }));
-const syncBacklog = (s) => {
-	const commands = backlog(s);
-	if (commands.length === s.record.commands.length && commands.every((c, i) => c.seq === s.record.commands[i].seq)) return;
+const mergeBacklog = (s) => {
+	const own = backlog(s);
+	if (!s.shared) return own;
+	const known = new Set(s.pending.map((p) => p.seq));
+	return [...s.record.commands.filter((c) => !known.has(c.seq) && c.seq > s.durableSeq), ...own].sort((a, b) => a.seq - b.seq);
+};
+const syncBacklogInner = (s) => {
+	const parked = s.shared ? s.shared.parked.splice(0) : [];
+	const parkedSeqs = new Set(parked.map((v) => v.seq));
+	const commands = mergeBacklog(s).filter((c) => !parkedSeqs.has(c.seq));
+	const verdicts = parked.length > 0 ? [...s.record.verdicts ?? [], ...parked].slice(-64) : s.record.verdicts;
+	if (verdicts === s.record.verdicts && commands.length === s.record.commands.length && commands.every((c, i) => c.seq === s.record.commands[i].seq)) return;
 	setRecord(s, {
 		...s.record,
-		commands
+		commands,
+		...verdicts !== void 0 && { verdicts }
 	});
 };
+const syncBacklog = (s) => {
+	if (!s.shared) return syncBacklogInner(s);
+	transact(s, () => syncBacklogInner(s));
+};
+const transact = (s, fn) => {
+	if (!s.shared || s.deactivated) {
+		fn();
+		return Promise.resolve();
+	}
+	const shared = s.shared;
+	const run = 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) s.record = stored;
+		fn();
+	}));
+	shared.txq = run.then(() => {}, () => {});
+	return run;
+};
 const setIdle = (s, level) => {
 	if (level === s.idle) return;
 	s.idle = level;
@@ -84,11 +114,7 @@ const settleEntry = (s, entry, outcome) => {
 	}
 };
 const settleAll = (s, detach) => {
-	const cause = {
-		unmount: "unmount",
-		gone: "stream-gone",
-		superseded: "superseded"
-	}[detach];
+	const cause = detach === "unmount" ? "unmount" : "stream-gone";
 	const batch = s.pending;
 	const detachFailure = (entry) => {
 		if (!entry.attempted) {
@@ -129,9 +155,8 @@ const restateContext = (s) => {
 		posted: false
 	});
 };
-const resetRecord = (s, clientId) => {
-	const survivors = [];
-	for (const entry of [...s.pending]) if (entry.attempted || entry.applied) {
+const settleLost = (s, entries) => {
+	for (const entry of entries) {
 		s.lifecycle?.onCovered?.(entry.inv);
 		settleEntry(s, entry, {
 			ok: false,
@@ -140,23 +165,33 @@ const resetRecord = (s, clientId) => {
 				cause: "session-lost"
 			}
 		});
-	} else survivors.push(entry);
+	}
+};
+const rebaseRecord = (s, adopt) => {
+	const held = [...s.pending];
+	const survivors = held.filter((p) => !p.attempted && !p.applied);
+	settleLost(s, held.filter((p) => p.attempted || p.applied));
 	s.pending = [];
 	s.durableSeq = 0;
-	setRecord(s, {
-		clientId,
-		nextSeq: 1,
-		ctxNextSeq: 1,
-		commands: []
-	});
+	adopt();
 	for (const old of survivors) {
 		s.lifecycle?.onCovered?.(old.inv);
-		enqueue(s, old.command, old.inv.params, old.resolve, old.reject);
+		enqueueInner(s, old.command, old.inv.params, old.resolve, old.reject);
 	}
 	restateContext(s);
 	publish(s);
 	wake(s);
+	pump(s);
 };
+const resetRecord = (s, clientId) => rebaseRecord(s, () => setRecord(s, {
+	clientId,
+	nextSeq: 1,
+	ctxNextSeq: 1,
+	commands: []
+}));
+const adoptReset = (s, stored) => rebaseRecord(s, () => {
+	s.record = stored;
+});
 const ephemeralDetach = (s) => {
 	s.ephemeral = false;
 	s.sessionKnown = false;
@@ -171,6 +206,53 @@ const rejectedFailure = (cmd) => {
 		...cmd.payload !== void 0 && { payload: cmd.payload }
 	};
 };
+const outcomeOf = (cmd) => {
+	switch (cmd.type) {
+		case "result": return {
+			ok: true,
+			payload: reviveResponse(cmd).payload
+		};
+		case "rejected": return {
+			ok: false,
+			failure: rejectedFailure(reviveResponse(cmd))
+		};
+		case "failed": return {
+			ok: false,
+			failure: {
+				fate: "failed",
+				cause: "server",
+				...cmd.message !== void 0 && { message: cmd.message }
+			}
+		};
+		case "crashed": return {
+			ok: false,
+			failure: {
+				fate: "crashed",
+				cause: "server"
+			}
+		};
+		case "expired": return {
+			ok: false,
+			failure: {
+				fate: "expired",
+				cause: "server"
+			}
+		};
+		default: return protocolError(`unknown cmd type: ${String(cmd.type)}`);
+	}
+};
+const TERMINAL_CMD_TYPES = new Set(TERMINAL);
+const parkVerdict = (s, cmd) => {
+	if (!s.shared || !TERMINAL_CMD_TYPES.has(cmd.type)) return;
+	s.shared.parked.push({
+		seq: cmd.seq,
+		type: cmd.type,
+		...cmd.code !== void 0 && { code: cmd.code },
+		...cmd.message !== void 0 && { message: cmd.message },
+		...cmd.payload !== void 0 && { payload: cmd.payload },
+		...cmd.meta !== void 0 && { meta: cmd.meta }
+	});
+};
 const handleCmd = (s, cmd) => {
 	if (!Number.isSafeInteger(cmd.seq) || cmd.seq <= 0) protocolError("cmd.seq must be a positive safe integer");
 	if (cmd.dur === true) {
@@ -183,35 +265,29 @@ const handleCmd = (s, cmd) => {
 		if (entry) cover(s, entry);
 		return;
 	}
+	parkVerdict(s, cmd);
 	if (!entry) return;
 	cover(s, entry);
-	const outcome = cmd.type === "result" ? {
-		ok: true,
-		payload: reviveResponse(cmd).payload
-	} : cmd.type === "rejected" ? {
-		ok: false,
-		failure: rejectedFailure(reviveResponse(cmd))
-	} : cmd.type === "failed" ? {
-		ok: false,
-		failure: {
-			fate: "failed",
-			cause: "server",
-			...cmd.message !== void 0 && { message: cmd.message }
-		}
-	} : cmd.type === "crashed" ? {
-		ok: false,
-		failure: {
-			fate: "crashed",
-			cause: "server"
-		}
-	} : cmd.type === "expired" ? {
-		ok: false,
-		failure: {
-			fate: "expired",
-			cause: "server"
-		}
-	} : protocolError(`unknown cmd type: ${String(cmd.type)}`);
-	settleEntry(s, entry, outcome);
+	settleEntry(s, entry, outcomeOf(cmd));
+};
+const consumeVerdicts = (s) => {
+	const verdicts = s.record.verdicts ?? [];
+	const consumed = /* @__PURE__ */ new Set();
+	for (const verdict of verdicts) {
+		const entry = s.pending.find((p) => p.seq === verdict.seq);
+		if (!entry) continue;
+		consumed.add(verdict.seq);
+		cover(s, entry);
+		settleEntry(s, entry, outcomeOf(verdict));
+	}
+	if (consumed.size === 0) return;
+	setRecord(s, {
+		...s.record,
+		commands: s.record.commands.filter((c) => !consumed.has(c.seq)),
+		verdicts: verdicts.filter((v) => !consumed.has(v.seq))
+	});
+	publish(s);
+	wake(s);
 };
 const handleCmds = (s, cmds) => {
 	for (const cmd of cmds) handleCmd(s, cmd);
@@ -227,24 +303,7 @@ const publishIngested = (s) => {
 	publish(s);
 	wake(s);
 };
-const RECORDS = [
-	"fresh",
-	"resumed",
-	"ephemeral"
-];
-const snapClocks = (s, seqWm, ctxWm) => {
-	const tail = s.pending.filter((p) => p.seq > seqWm);
-	if (!(tail.every((p, i) => p.seq === seqWm + 1 + i) && s.record.nextSeq === seqWm + tail.length + 1)) {
-		s.pending = s.pending.filter((p) => p.seq <= seqWm);
-		setRecord(s, {
-			...s.record,
-			nextSeq: seqWm + 1
-		});
-		for (const old of tail) {
-			s.lifecycle?.onCovered?.(old.inv);
-			enqueue(s, old.command, old.inv.params, old.resolve, old.reject);
-		}
-	}
+const snapCtxClock = (s, ctxWm) => {
 	if (!(s.ctxPending.every((c, i) => c.seq === ctxWm + 1 + i) && s.record.ctxNextSeq === ctxWm + s.ctxPending.length + 1)) {
 		setRecord(s, {
 			...s.record,
@@ -253,29 +312,54 @@ const snapClocks = (s, seqWm, ctxWm) => {
 		restateContext(s);
 	}
 };
+const sessionLostInner = (s, seqWm, ctxWm) => {
+	const held = [...s.pending];
+	settleLost(s, held);
+	s.pending = [];
+	s.durableSeq = seqWm;
+	setRecord(s, {
+		clientId: s.record.clientId,
+		nextSeq: seqWm + 1,
+		ctxNextSeq: ctxWm + 1,
+		commands: []
+	});
+	restateContext(s);
+	if (held.length > 0 && s.onSessionLost?.(held.map((p) => p.inv)) === "requeue") for (const old of held) enqueueInner(s, old.command, old.inv.params, () => {}, () => {});
+	publish(s);
+	wake(s);
+};
 const handleHello = (s, { ops, syn }) => {
-	const record = syn.record ?? "fresh";
-	if (!RECORDS.includes(record)) protocolError(`unknown record: ${String(record)}`);
+	if (syn.record !== void 0 && syn.record !== "ephemeral") protocolError(`unknown record: ${String(syn.record)}`);
 	ingestOps(s, ops);
 	s.attach = "attached";
 	s.attachEpoch += 1;
 	s.frameFailures = 0;
 	s.resumeAt = 0;
-	s.ephemeral = record === "ephemeral";
+	s.ephemeral = syn.record === "ephemeral";
 	if (s.ephemeral) s.deactivated = true;
 	const [attachCmd, attachCtx] = s.attachLaneSeqs;
 	s.attachLaneSeqs = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
-	if (record === "resumed") {
+	const reconcile = () => {
+		if (s.shared) adoptStored(s);
+		s.durableSeq = syn.seq ?? 0;
 		for (const entry of s.pending) entry.posted = attachCmd.has(entry.seq);
 		const ctxWatermark = syn.ctxSeq ?? 0;
 		s.ctxPending = s.ctxPending.filter((c) => c.seq > ctxWatermark);
 		for (const c of s.ctxPending) c.posted = attachCtx.has(c.seq);
-		snapClocks(s, syn.seq ?? 0, ctxWatermark);
-		syncBacklog(s);
-	} else resetRecord(s, s.record.clientId);
-	s.sessionKnown = true;
-	publishIngested(s);
-	pump(s);
+		snapCtxClock(s, ctxWatermark);
+		syncBacklogInner(s);
+		s.sessionKnown = true;
+	};
+	if (!s.shared || s.deactivated) {
+		reconcile();
+		publishIngested(s);
+		pump(s);
+		return;
+	}
+	transact(s, reconcile).then(() => {
+		publishIngested(s);
+		pump(s);
+	});
 };
 const handleOps = (s, { ops, cmds }) => {
 	ingestOps(s, ops);
@@ -293,10 +377,26 @@ const handleRefusal = (s, syn) => {
 		s.ctxPending = s.ctxPending.filter((c) => c.seq > ctxSeq);
 		for (const c of s.ctxPending) c.posted = false;
 	}
-	if (typeof syn.retry === "number") s.resumeAt = Date.now() + syn.retry;
+	if (typeof syn.retry === "number") {
+		s.resumeAt = Date.now() + syn.retry;
+		wake(s);
+		pump(s);
+		return;
+	}
 	const firstCmd = s.pending.find((p) => !p.posted);
 	const firstCtx = s.ctxPending.find((c) => !c.posted);
-	if (typeof syn.seq === "number" && firstCmd !== void 0 && firstCmd.seq > Math.max(syn.seq, s.durableSeq) + 1 || typeof syn.ctxSeq === "number" && firstCtx !== void 0 && firstCtx.seq > syn.ctxSeq + 1) s.transport?.connection.reconnect();
+	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, () => {
+			if (cmdGap) sessionLostInner(s, seq, ctxSeq ?? 0);
+			else snapCtxClock(s, ctxSeq);
+		}).then(() => {
+			wake(s);
+			pump(s);
+		});
+		return;
+	}
 	wake(s);
 	pump(s);
 };
@@ -308,7 +408,7 @@ const handleDetach = (s) => {
 const handleFinish = (s, { reason }) => {
 	if (reason === "evicted" || reason === "error") return;
 	s.attach = "finished";
-	settleAll(s, reason === "superseded" ? "superseded" : "gone");
+	settleAll(s, "gone");
 	publish(s);
 	wake(s);
 };
@@ -376,7 +476,8 @@ const pump = async (s) => {
 			for (const entry of lanes.cmdEntries) entry.attempted = true;
 			let result;
 			try {
-				result = await transport.send(lanes.frame);
+				const send = () => transport.send(lanes.frame);
+				result = await (s.shared && !s.deactivated ? s.store.lock(send) : send());
 			} catch {
 				if (!s.running || isFinished(s)) return;
 				s.frameFailures += 1;
@@ -413,16 +514,33 @@ const pump = async (s) => {
 	}
 };
 const start = (s) => {
+	if (s.shared) {
+		s.shared.unsubscribe = s.store.subscribe(() => {
+			transact(s, () => consumeVerdicts(s));
+		});
+		s.running = true;
+		transact(s, () => {
+			if (s.store.load() === null) s.store.save(s.record);
+			s.recordPersisted = true;
+			adoptStored(s);
+			consumeVerdicts(s);
+		}).then(() => void pump(s));
+		return;
+	}
 	if (!s.recordPersisted) {
 		s.recordPersisted = true;
 		s.store.save(s.record);
 	}
-	resume(s);
+	adoptStored(s);
 	s.running = true;
 	pump(s);
 };
 const stop = (s) => {
 	s.running = false;
+	if (s.shared) {
+		s.shared.unsubscribe?.();
+		s.shared.unsubscribe = null;
+	}
 	wake(s);
 	settleAll(s, "unmount");
 };
@@ -431,7 +549,7 @@ const setTransport = (s, transport) => {
 	s.transport = transport;
 	wake(s);
 };
-const enqueue = (s, command, params, resolve, reject) => {
+const enqueueInner = (s, command, params, resolve, reject) => {
 	const seq = s.record.nextSeq;
 	const entry = {
 		seq,
@@ -453,13 +571,22 @@ const enqueue = (s, command, params, resolve, reject) => {
 	setRecord(s, {
 		...s.record,
 		nextSeq: seq + 1,
-		commands: backlog(s)
+		commands: mergeBacklog(s)
 	});
 	s.lifecycle?.onStart(entry.inv);
-	pump(s);
 };
-const resume = (s) => {
-	const stored = [...s.record.commands].sort((a, b) => a.seq - b.seq);
+const enqueue = (s, command, params, resolve, reject) => {
+	if (!s.shared) {
+		enqueueInner(s, command, params, resolve, reject);
+		pump(s);
+		return;
+	}
+	transact(s, () => enqueueInner(s, command, params, resolve, reject)).then(() => void pump(s));
+};
+const adoptStored = (s) => {
+	const known = new Set(s.pending.map((p) => p.seq));
+	const stored = s.record.commands.filter((c) => !known.has(c.seq));
+	if (stored.length === 0) return;
 	for (const { seq, ...command } of stored) {
 		const params = command.meta === void 0 ? command.params : reviveValue([...command.params], command.meta);
 		const entry = {
@@ -481,6 +608,7 @@ const resume = (s) => {
 		s.pending.push(entry);
 		s.lifecycle?.onStart(entry.inv);
 	}
+	s.pending.sort((a, b) => a.seq - b.seq);
 };
 const sendCommand = (s, method, params) => {
 	if (!s.running) return rejectedSend({
@@ -504,31 +632,44 @@ const sendCommand = (s, method, params) => {
 };
 const setContext = (s, value) => {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("statewire: context must be a plain object");
+	if (!s.running || isFinished(s)) return;
 	const { value: encoded, meta } = encodeValue(value);
-	s.ctxOps = [{
+	const ops = [{
 		op: "replace",
 		path: [],
 		value: encoded,
 		...meta !== void 0 && { meta }
 	}];
-	const seq = s.record.ctxNextSeq;
-	setRecord(s, {
-		...s.record,
-		ctxNextSeq: seq + 1
-	});
-	s.ctxPending.push({
-		seq,
-		ops: s.ctxOps,
-		posted: false
+	s.ctxOps = ops;
+	const mint = () => {
+		const seq = s.record.ctxNextSeq;
+		setRecord(s, {
+			...s.record,
+			ctxNextSeq: seq + 1
+		});
+		s.ctxPending.push({
+			seq,
+			ops,
+			posted: false
+		});
+	};
+	if (!s.shared) {
+		mint();
+		wake(s);
+		pump(s);
+		return;
+	}
+	transact(s, mint).then(() => {
+		wake(s);
+		pump(s);
 	});
-	wake(s);
-	pump(s);
 };
 const useStatewireSession = (options) => {
 	const [defaultStore] = useState(createMemorySessionStore);
 	const mounted = useContext(SessionStorageContext);
 	if (options.sessionStore !== void 0 && mounted !== void 0) throw new Error("statewire: session storage is set twice — drop the transport's sessionStore or the client's storage.session");
 	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(() => {
 		const stored = store.load();
 		if (stored !== null && !Array.isArray(stored.commands)) throw new Error("statewire: session storage loaded a record without a commands array");
@@ -554,12 +695,18 @@ const useStatewireSession = (options) => {
 			},
 			recordPersisted: stored !== null,
 			store,
+			shared: store.lock !== void 0 ? {
+				txq: Promise.resolve(),
+				parked: [],
+				unsubscribe: null
+			} : false,
 			ephemeral: false,
 			deactivated: false,
 			sessionKnown: false,
 			durableSeq: 0,
 			resumeAt: 0,
 			idle: false,
+			onSessionLost: void 0,
 			onDone: void 0,
 			ctxOps: void 0,
 			ctxPending: [],
@@ -596,7 +743,9 @@ const useStatewireSession = (options) => {
 		} });
 		return session;
 	});
+	if (store.lock !== void 0 !== (s.shared !== false)) throw new Error("statewire: session storage changed sharedness across renders — lock/subscribe must be present from the first render or never");
 	s.store = store;
+	s.onSessionLost = options.onSessionLost;
 	s.onDone = options.onDone;
 	useEffect(() => {
 		start(s);