statewire 0.10.0 → 0.11.0

package/dist/client/session.d.ts

@@ -32,11 +32,17 @@ type StatewireSessionOptions = {
   sessionStore?: StatewireClient.SessionStorage | undefined;
   onDone?: (() => void) | undefined;
 };
+type Shared = {
+  txq: Promise<void>;
+  parked: StatewireClient.SessionVerdict[];
+  unsubscribe: (() => void) | null;
+};
 type Session = {
   record: StatewireClient.SessionRecord;
   ctx: StatewireRemoteProps;
   recordPersisted: boolean;
   store: StatewireClient.SessionStorage;
+  shared: Shared | false;
   ephemeral: boolean;
   /** An ephemeral record died with its attach: the storage is off for good. */
   deactivated: boolean;

package/dist/client/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","names":[],"sources":["../../src/client/session.ts"],"mappings":";;;;;;KA4BK;EACH;EACA;EACA;;KAGG;WACM;WACA,SAAS;WACT,KAAK;;EAEd;;EAEA;;EAEA;EACA,UAAU;EACV,SAAS,OAAO;;KAGb;WACM;WACA;EACT;;KAiBG;KAEO;EACV,eAAe,gBAAgB;EAC/B;;KAGG;EACH,QAAQ,gBAAgB;EACxB,KAAK;EACL;EACA,OAAO,gBAAgB;EACvB;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,YAAY;EACZ;EACA,0BAA0B,qBAAqB;EAC/C;EACA,SAAS;EACT;EACA;EACA,SAAS;EACT,QAAQ,UAAU;EAClB,QAAQ;EACR;EACA;EACA;EACA,WAAW;EACX;EACA,WAAW;EACX;EACA,UAAU,mBAAmB,sBAAsB;;cA2e/C,eAAgB,GAAG,SAAS,WAAW;cA2FvC,aAAc,GAAG,SAAS,OAAO;cAoB1B,sBACX,SAAS,4BACR"}
+{"version":3,"file":"session.d.ts","names":[],"sources":["../../src/client/session.ts"],"mappings":";;;;;;KA4BK;EACH;EACA;EACA;;KAGG;WACM;WACA,SAAS;WACT,KAAK;;EAEd;;EAEA;;EAEA;EACA,UAAU;EACV,SAAS,OAAO;;KAGb;WACM;WACA;EACT;;KAiBG;KAEO;EACV,eAAe,gBAAgB;EAC/B;;KAGG;EACH,KAAK;EACL,QAAQ,gBAAgB;EACxB;;KAGG;EACH,QAAQ,gBAAgB;EACxB,KAAK;EACL;EACA,OAAO,gBAAgB;EACvB,QAAQ;EACR;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,YAAY;EACZ;EACA,0BAA0B,qBAAqB;EAC/C;EACA,SAAS;EACT;EACA;EACA,SAAS;EACT,QAAQ,UAAU;EAClB,QAAQ;EACR;EACA;EACA;EACA,WAAW;EACX;EACA,WAAW;EACX;EACA,UAAU,mBAAmB,sBAAsB;;cAgpB/C,eAAgB,GAAG,SAAS,WAAW;cA8GvC,aAAc,GAAG,SAAS,OAAO;cAgC1B,sBACX,SAAS,4BACR"}

package/dist/client/session.js

@@ -47,14 +47,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;
@@ -151,11 +180,36 @@ const resetRecord = (s, clientId) => {
 	});
 	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;
@@ -171,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) {
@@ -183,35 +281,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);
@@ -242,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)) {
@@ -265,17 +357,28 @@ const handleHello = (s, { ops, syn }) => {
 	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);
-		syncBacklog(s);
-	} 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);
@@ -308,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);
 };
@@ -376,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;
@@ -413,16 +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);
 	}
-	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 +552,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 +574,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 +611,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 +635,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,6 +698,11 @@ 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,