statewire 0.9.2 → 0.11.0

package/dist/client/session.js

@@ -2,11 +2,11 @@ import { applyOps } from "../wire/ops.js";
 import { createMethodProxy } from "../util/methodProxy.js";
 import { StatewireSendError } from "../types.js";
 import { bindCommandsHost } from "../host/host.js";
-import { encodeParams, encodeValue, reviveResponse } from "../wire/meta.js";
+import { encodeParams, encodeValue, reviveResponse, reviveValue } from "../wire/meta.js";
+import { SessionStorageContext, createMemorySessionStore } from "./sessionStore.js";
 import { backoff } from "./timing.js";
-import { createMemorySessionStore } from "./sessionStore.js";
 import { randomId } from "../util/randomId.js";
-import { useEffect, useState } from "@assistant-ui/tap/react-shim";
+import { useContext, useEffect, useState } from "@assistant-ui/tap/react-shim";
 //#region src/client/session.ts
 const protocolError = (message) => {
 	throw new Error(`statewire: protocol error: ${message}`);
@@ -41,7 +41,48 @@ const sleepUntilWake = (s, delayMs) => new Promise((resolve) => {
 });
 const setRecord = (s, record) => {
 	s.record = record;
-	if (!s.ephemeral) s.store.save(record);
+	if (!s.deactivated) s.store.save(record);
+};
+const backlog = (s) => s.pending.filter((p) => p.seq > s.durableSeq).map((p) => ({
+	seq: p.seq,
+	...p.command
+}));
+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,
+		...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;
@@ -134,15 +175,41 @@ const resetRecord = (s, clientId) => {
 	setRecord(s, {
 		clientId,
 		nextSeq: 1,
-		ctxNextSeq: 1
+		ctxNextSeq: 1,
+		commands: []
 	});
 	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 adoptReset = (s, stored) => {
+	const survivors = [];
+	for (const entry of [...s.pending]) if (entry.attempted || entry.applied) {
+		s.lifecycle?.onCovered?.(entry.inv);
+		settleEntry(s, entry, {
+			ok: false,
+			failure: {
+				fate: "lost",
+				cause: "session-lost"
+			}
+		});
+	} else survivors.push(entry);
+	s.pending = [];
+	s.durableSeq = 0;
+	s.record = stored;
+	for (const old of survivors) {
+		s.lifecycle?.onCovered?.(old.inv);
+		enqueueInner(s, old.command, old.inv.params, old.resolve, old.reject);
+	}
+	restateContext(s);
+	publish(s);
+	wake(s);
+	pump(s);
 };
 const ephemeralDetach = (s) => {
 	s.ephemeral = false;
@@ -158,6 +225,50 @@ const rejectedFailure = (cmd) => {
 		...cmd.payload !== void 0 && { payload: cmd.payload }
 	};
 };
+const outcomeOf = (cmd) => 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)}`);
+const TERMINAL_CMD_TYPES = /* @__PURE__ */ new Set([
+	"result",
+	"rejected",
+	"failed",
+	"crashed",
+	"expired"
+]);
+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) {
@@ -170,38 +281,33 @@ 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);
+	syncBacklog(s);
 	wake(s);
 };
 const ingestOps = (s, ops) => {
@@ -228,7 +334,7 @@ const snapClocks = (s, seqWm, ctxWm) => {
 		});
 		for (const old of tail) {
 			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);
 		}
 	}
 	if (!(s.ctxPending.every((c, i) => c.seq === ctxWm + 1 + i) && s.record.ctxNextSeq === ctxWm + s.ctxPending.length + 1)) {
@@ -248,22 +354,36 @@ const handleHello = (s, { ops, syn }) => {
 	s.frameFailures = 0;
 	s.resumeAt = 0;
 	s.ephemeral = record === "ephemeral";
+	if (s.ephemeral) s.deactivated = true;
 	const [attachCmd, attachCtx] = s.attachLaneSeqs;
 	s.attachLaneSeqs = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
-	if (record === "resumed") {
-		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);
-	} else resetRecord(s, s.record.clientId);
-	s.sessionKnown = true;
-	publishIngested(s);
-	pump(s);
+	const reconcile = () => {
+		if (record === "resumed") {
+			if (s.shared) adoptStored(s);
+			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);
+			syncBacklogInner(s);
+		} else resetRecord(s, s.record.clientId);
+		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);
 	for (const cmd of cmds) handleCmd(s, cmd);
+	syncBacklog(s);
 	publishIngested(s);
 };
 const handleRefusal = (s, syn) => {
@@ -291,7 +411,7 @@ const handleDetach = (s) => {
 const handleFinish = (s, { reason }) => {
 	if (reason === "evicted" || reason === "error") return;
 	s.attach = "finished";
-	settleAll(s, reason === "superseded" ? "superseded" : "gone");
+	if (!(s.shared && reason === "superseded")) settleAll(s, reason === "superseded" ? "superseded" : "gone");
 	publish(s);
 	wake(s);
 };
@@ -359,7 +479,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;
@@ -396,15 +517,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);
 	}
+	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");
 };
@@ -413,12 +552,8 @@ 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;
-	setRecord(s, {
-		...s.record,
-		nextSeq: seq + 1
-	});
 	const entry = {
 		seq,
 		command,
@@ -436,8 +571,47 @@ const enqueue = (s, command, params, resolve, reject) => {
 		reject
 	};
 	s.pending.push(entry);
+	setRecord(s, {
+		...s.record,
+		nextSeq: seq + 1,
+		commands: mergeBacklog(s)
+	});
 	s.lifecycle?.onStart(entry.inv);
-	pump(s);
+};
+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 = {
+			seq,
+			command,
+			inv: {
+				method: command.method,
+				params,
+				ts: Date.now(),
+				seq,
+				clientId: s.record.clientId
+			},
+			attempted: true,
+			posted: false,
+			applied: false,
+			resolve: () => {},
+			reject: () => {}
+		};
+		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({
@@ -461,36 +635,53 @@ 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 store = options.sessionStore ?? defaultStore;
+	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");
 		const session = {
 			record: stored ?? {
 				clientId: newClientId(),
 				nextSeq: 1,
-				ctxNextSeq: 1
+				ctxNextSeq: 1,
+				commands: []
 			},
 			ctx: {
 				get clientId() {
@@ -507,7 +698,13 @@ 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,