statewire 0.0.0-0 → 0.0.2

package/dist/client/session.js

@@ -0,0 +1,529 @@
+import { applyOps } from "../wire/ops.js";
+import { createMethodProxy } from "../util/methodProxy.js";
+import { StatewireSendError } from "../types.js";
+import { bindCommandsHost } from "../host/host.js";
+import { randomId } from "../util/randomId.js";
+import { retryDelay } from "./timing.js";
+import { createMemorySessionStore } from "./sessionStore.js";
+import { useEffect, useState } from "@assistant-ui/tap/react-shim";
+//#region src/client/session.ts
+const isResolved = (state) => state.at === "settled-live" || state.at === "done";
+const isStateSettled = (state) => state.at === "awaiting-result" || state.at === "done";
+const inFlight = (state) => {
+	if (state.at === "queued" || state.at === "done") throw new Error(`statewire: ${state.at} entry observed after a send`);
+	return state;
+};
+const legalTransitions = {
+	queued: [
+		"queued",
+		"trying",
+		"awaiting-result",
+		"settled-live",
+		"done"
+	],
+	trying: [
+		"queued",
+		"trying",
+		"posted",
+		"awaiting-result",
+		"settled-live",
+		"done"
+	],
+	posted: [
+		"posted",
+		"trying",
+		"awaiting-result",
+		"settled-live",
+		"done"
+	],
+	"awaiting-result": ["awaiting-result", "done"],
+	"settled-live": ["settled-live", "done"],
+	done: []
+};
+const transition = (s, entry, next, outcome) => {
+	const prev = entry.state;
+	if (!legalTransitions[prev.at].includes(next.at)) throw new Error(`statewire: illegal pending transition ${prev.at} -> ${next.at}`);
+	const settles = !isResolved(prev) && isResolved(next);
+	if (settles && outcome === void 0) throw new Error(`statewire: settling transition ${prev.at} -> ${next.at} without an outcome`);
+	const covers = !isStateSettled(prev) && isStateSettled(next);
+	entry.state = next;
+	if (covers) s.lifecycle?.onCovered?.(entry.inv);
+	if (settles && outcome !== void 0) if (outcome.ok) {
+		entry.resolve(outcome.payload);
+		s.lifecycle?.onSettle(entry.inv, {
+			type: "accepted",
+			payload: outcome.payload
+		});
+	} else {
+		entry.reject(new StatewireSendError(outcome.failure));
+		s.lifecycle?.onSettle(entry.inv, {
+			type: "rejected",
+			error: new StatewireSendError(outcome.failure)
+		});
+	}
+	if (next.at === "done") s.pending = s.pending.filter((p) => p !== entry);
+};
+const carried = (state) => state.at === "queued" ? {
+	posted: false,
+	failedAttempts: 0
+} : state.at === "trying" || state.at === "posted" ? {
+	posted: state.at === "posted",
+	failedAttempts: state.failedAttempts
+} : {
+	posted: state.posted,
+	failedAttempts: state.failedAttempts
+};
+const newClientId = () => `c-${randomId()}`;
+const rejectedSend = (failure) => {
+	const result = Promise.reject(new StatewireSendError(failure));
+	result.catch(() => {});
+	return result;
+};
+const createSession = (options) => {
+	const store = options.sessionStore ?? createMemorySessionStore();
+	const stored = store.load();
+	const s = {
+		record: stored ?? {
+			clientId: newClientId(),
+			nextSeq: 1
+		},
+		ctx: {
+			get clientId() {
+				return s.record.clientId;
+			},
+			onSnapshot: (args) => handleSnapshot(s, args),
+			onOps: (args) => handleOps(s, args),
+			onFinish: (args) => handleFinish(s, args)
+		},
+		recordPersisted: stored !== null,
+		store,
+		lastAck: -1,
+		pending: [],
+		canonical: void 0,
+		lastPublished: void 0,
+		changed: [],
+		source: {
+			snapshot: () => s.canonical,
+			takeChanged: () => {
+				const changed = s.changed;
+				s.changed = [];
+				return changed;
+			},
+			setOnChange: (listener) => {
+				s.notify = listener ?? (() => {});
+			}
+		},
+		attach: "detached",
+		attachEpoch: 0,
+		running: false,
+		pumping: false,
+		transport: null,
+		waiters: [],
+		lifecycle: null,
+		notify: () => {},
+		emitEvent: () => {},
+		send: (command) => sendCommand(s, command),
+		commands: createMethodProxy((method, params) => s.send({
+			method,
+			params
+		}))
+	};
+	bindCommandsHost(s.commands, { setListener: (listener) => {
+		s.lifecycle = listener;
+	} });
+	return s;
+};
+const publish = (s) => {
+	if (s.canonical === s.lastPublished) return;
+	s.lastPublished = s.canonical;
+	s.notify();
+};
+const wake = (s) => {
+	const waiters = s.waiters;
+	s.waiters = [];
+	for (const waiter of waiters) waiter();
+};
+const waitForWake = (s) => new Promise((r) => s.waiters.push(r));
+const sleepUntilWake = (s, delayMs) => new Promise((resolve) => {
+	const waiter = () => {
+		clearTimeout(timer);
+		resolve();
+	};
+	const timer = setTimeout(() => {
+		s.waiters = s.waiters.filter((w) => w !== waiter);
+		resolve();
+	}, delayMs);
+	s.waiters.push(waiter);
+});
+const settleAll = (s, detach, verdict) => {
+	const cause = {
+		evicted: "session-lost",
+		unmount: "unmount",
+		gone: "stream-gone",
+		superseded: "superseded"
+	}[detach];
+	const batch = s.pending;
+	const detachFailure = (entry) => {
+		const state = entry.state;
+		if (state.at === "awaiting-result") return {
+			fate: "result-unavailable",
+			cause
+		};
+		if (state.at === "queued") return {
+			fate: "aborted",
+			cause: batch.some((p) => p.seq < entry.seq && p.state.at !== "queued") ? "cascade" : cause
+		};
+		return {
+			fate: "lost",
+			cause
+		};
+	};
+	for (const entry of [...batch]) {
+		const failure = entry === verdict?.entry ? verdict.failure : detachFailure(entry);
+		transition(s, entry, { at: "done" }, {
+			ok: false,
+			failure
+		});
+	}
+};
+const evict = (s, verdict) => {
+	settleAll(s, "evicted", verdict);
+	s.record = {
+		clientId: newClientId(),
+		nextSeq: 1
+	};
+	s.store.save(s.record);
+	s.attach = "detached";
+	publish(s);
+	wake(s);
+};
+const noteAcked = (s, seq) => {
+	for (const entry of s.pending) {
+		if (entry.seq > seq || isStateSettled(entry.state)) continue;
+		s.lifecycle?.onAck(entry.inv);
+	}
+};
+const spliceAcked = (s, seq, settleVoid) => {
+	for (const entry of [...s.pending]) {
+		const state = entry.state;
+		if (entry.seq > seq || isStateSettled(state)) continue;
+		if (state.at === "settled-live") transition(s, entry, { at: "done" });
+		else if (settleVoid && !state.pendingMarked) transition(s, entry, { at: "done" }, {
+			ok: true,
+			payload: void 0
+		});
+		else transition(s, entry, {
+			at: "awaiting-result",
+			...carried(state)
+		});
+	}
+};
+const protocolError = (message) => {
+	throw new Error(`statewire: protocol error: ${message}`);
+};
+const applyResponse = (s, response) => {
+	const entry = s.pending.find((p) => p.seq === response.seq);
+	if (!entry) return;
+	const state = entry.state;
+	if (state.at === "done") return;
+	switch (response.type) {
+		case "pending":
+			if (state.at === "queued" || state.at === "trying" || state.at === "posted") transition(s, entry, {
+				...state,
+				pendingMarked: true
+			});
+			break;
+		case "accepted":
+			if (state.at === "settled-live") break;
+			transition(s, entry, state.at === "awaiting-result" ? { at: "done" } : {
+				at: "settled-live",
+				...carried(state)
+			}, {
+				ok: true,
+				payload: response.payload
+			});
+			break;
+		case "rejected":
+			transition(s, entry, { at: "done" }, {
+				ok: false,
+				failure: response.code === "unknown-command" ? {
+					fate: "unknown-command",
+					cause: "server"
+				} : response.code === "invalid-params" ? {
+					fate: "invalid-params",
+					cause: "server",
+					message: response.message ?? protocolError("rejected response missing message")
+				} : {
+					fate: "rejected",
+					cause: "server",
+					message: response.message ?? protocolError("rejected response missing message"),
+					...response.payload !== void 0 && { payload: response.payload }
+				}
+			});
+			break;
+		case "crashed":
+		case "result-unavailable":
+			if (state.at === "settled-live") break;
+			transition(s, entry, state.at === "awaiting-result" ? { at: "done" } : {
+				at: "settled-live",
+				...carried(state)
+			}, {
+				ok: false,
+				failure: {
+					fate: response.type,
+					cause: "server"
+				}
+			});
+			break;
+	}
+};
+const ingestOps = (s, ops) => {
+	const applied = applyOps(s.canonical, ops);
+	s.canonical = applied.state;
+	s.changed.push(...applied.changedPaths);
+	return applied.events;
+};
+const publishIngested = (s, events) => {
+	publish(s);
+	for (const event of events) s.emitEvent(event);
+	wake(s);
+};
+const handleSnapshot = (s, { ops, lastSeq }) => {
+	if (lastSeq === -1 && s.attach !== "detached") {
+		evict(s);
+		s.transport?.connection.reconnect();
+		publishIngested(s, ingestOps(s, ops));
+		return;
+	}
+	const events = ingestOps(s, ops);
+	s.attach = "attached";
+	s.attachEpoch += 1;
+	noteAcked(s, lastSeq);
+	spliceAcked(s, lastSeq, false);
+	s.lastAck = lastSeq;
+	for (const entry of s.pending) {
+		const state = entry.state;
+		if (entry.seq <= lastSeq) {
+			if (state.at === "awaiting-result" && state.posted) transition(s, entry, {
+				...state,
+				posted: false
+			});
+			if (state.at === "awaiting-result") pump(s);
+		} else if (state.at === "posted") {
+			transition(s, entry, {
+				at: "trying",
+				pendingMarked: state.pendingMarked,
+				failedAttempts: state.failedAttempts
+			});
+			pump(s);
+		} else if (state.at === "settled-live" && state.posted) {
+			transition(s, entry, {
+				...state,
+				posted: false
+			});
+			pump(s);
+		}
+	}
+	publishIngested(s, events);
+};
+const handleOps = (s, { ops, res, ack }) => {
+	const horizon = ack === void 0 ? s.lastAck : Math.max(s.lastAck, ack);
+	if (res !== void 0) {
+		for (const response of res) if (response.seq > horizon) protocolError("response seq beyond the ack");
+	}
+	const events = ingestOps(s, ops);
+	if (ack !== void 0) noteAcked(s, ack);
+	if (res !== void 0) for (const response of res) applyResponse(s, response);
+	if (ack !== void 0) {
+		spliceAcked(s, ack, true);
+		s.lastAck = Math.max(s.lastAck, ack);
+	}
+	publishIngested(s, events);
+};
+const handleFinish = (s, { reason }) => {
+	if (reason === "evicted" || reason === "error") return;
+	s.attach = "finished";
+	settleAll(s, reason === "superseded" ? "superseded" : "gone");
+	publish(s);
+	wake(s);
+};
+const isFinished = (s) => s.attach === "finished";
+const sendable = (p) => p.state.at === "queued" || p.state.at === "trying" || (p.state.at === "awaiting-result" || p.state.at === "settled-live") && !p.state.posted;
+const pump = async (s) => {
+	if (s.pumping) return;
+	s.pumping = true;
+	try {
+		while (s.running && !isFinished(s)) {
+			const entry = s.pending.find(sendable);
+			if (!entry) return;
+			const transport = s.transport;
+			if (s.attach !== "attached" || !transport) {
+				await waitForWake(s);
+				continue;
+			}
+			const clientId = s.record.clientId;
+			const epoch = s.attachEpoch;
+			if (entry.state.at === "queued") transition(s, entry, {
+				at: "trying",
+				pendingMarked: entry.state.pendingMarked,
+				failedAttempts: 0
+			});
+			let result;
+			try {
+				result = await transport.send({
+					seq: entry.seq,
+					command: entry.command
+				});
+			} catch (error) {
+				if (!s.running || isFinished(s)) return;
+				if (!s.pending.includes(entry)) continue;
+				const state = inFlight(entry.state);
+				transition(s, entry, {
+					...state,
+					failedAttempts: state.failedAttempts + 1
+				});
+				await sleepUntilWake(s, retryDelay(error, state.failedAttempts + 1));
+				continue;
+			}
+			if (!s.running) return;
+			if (!s.pending.includes(entry)) continue;
+			if (result.type === "receipt") {
+				const response = result.response;
+				const state = entry.state;
+				if (state.at === "trying" || state.at === "posted") transition(s, entry, {
+					at: "posted",
+					pendingMarked: state.pendingMarked,
+					failedAttempts: state.failedAttempts
+				});
+				else if (state.at === "awaiting-result" || state.at === "settled-live") transition(s, entry, {
+					...state,
+					posted: true
+				});
+				s.lifecycle?.onPosted?.(entry.inv);
+				if (response !== void 0) {
+					applyResponse(s, response);
+					publish(s);
+				}
+			} else if (result.type === "rejected") {
+				transition(s, entry, { at: "done" }, {
+					ok: false,
+					failure: {
+						fate: "rejected",
+						cause: "server",
+						message: result.message
+					}
+				});
+				publish(s);
+			} else if (result.type === "stale-lease") {
+				if (epoch === s.attachEpoch) await waitForWake(s);
+			} else if (result.type === "unknown-client") {
+				if (epoch === s.attachEpoch) {
+					const state = entry.state;
+					if (state.at === "trying" && state.failedAttempts === 0) transition(s, entry, {
+						at: "queued",
+						pendingMarked: state.pendingMarked
+					});
+					s.transport?.connection.reconnect();
+					while (s.running && !isFinished(s) && epoch === s.attachEpoch && clientId === s.record.clientId) await waitForWake(s);
+				}
+			} else if (result.type === "seq-gap") {
+				if (clientId === s.record.clientId) {
+					console.error(`statewire: server reports a seq gap for seq ${entry.seq}; treating the session as corrupt and rotating the client id`);
+					const state = inFlight(entry.state);
+					const failure = state.at === "awaiting-result" ? {
+						fate: "result-unavailable",
+						cause: "session-lost"
+					} : {
+						fate: state.failedAttempts > 0 ? "lost" : "aborted",
+						cause: "session-lost"
+					};
+					evict(s, {
+						entry,
+						failure
+					});
+					s.transport?.connection.reconnect();
+				}
+			}
+		}
+	} finally {
+		s.pumping = false;
+	}
+};
+const start = (s) => {
+	if (!s.recordPersisted) {
+		s.recordPersisted = true;
+		s.store.save(s.record);
+	}
+	s.running = true;
+	pump(s);
+};
+const stop = (s) => {
+	s.running = false;
+	wake(s);
+	settleAll(s, "unmount");
+};
+const setTransport = (s, transport) => {
+	if (s.transport === transport) return;
+	s.transport = transport;
+	wake(s);
+};
+const sendCommand = (s, command) => {
+	if (!s.running) return rejectedSend({
+		fate: "aborted",
+		cause: "unmount"
+	});
+	if (isFinished(s)) return rejectedSend({
+		fate: "aborted",
+		cause: "stream-gone"
+	});
+	const seq = s.record.nextSeq;
+	s.record = {
+		...s.record,
+		nextSeq: seq + 1
+	};
+	s.store.save(s.record);
+	const entry = {
+		seq,
+		command,
+		inv: {
+			method: command.method,
+			params: command.params,
+			ts: Date.now(),
+			seq,
+			clientId: s.record.clientId
+		},
+		state: {
+			at: "queued",
+			pendingMarked: false
+		},
+		resolve: () => {},
+		reject: () => {}
+	};
+	const result = new Promise((resolve, reject) => {
+		entry.resolve = resolve;
+		entry.reject = reject;
+	});
+	result.catch(() => {});
+	s.pending.push(entry);
+	s.lifecycle?.onStart(entry.inv);
+	pump(s);
+	return result;
+};
+const useStatewireSession = (options, emit) => {
+	const [s] = useState(() => createSession(options));
+	useEffect(() => {
+		s.emitEvent = emit;
+		return () => {
+			s.emitEvent = () => {};
+		};
+	}, [s, emit]);
+	useEffect(() => {
+		start(s);
+		return () => stop(s);
+	}, [s]);
+	return s;
+};
+//#endregion
+export { setTransport, useStatewireSession };
+
+//# sourceMappingURL=session.js.map

package/dist/client/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","names":["useEffect","useState","applyOps","StatewirePath","StatewireResponse","bindCommandsHost","CommandsInvocation","CommandsListener","Statewire","StatewireClient","createMemorySessionStore","StatewireSessionRecord","StatewireSessionStore","StatewireSessionStoreOptions","retryDelay","createMethodProxy","randomId","StatewireSendError","RemoteLink","StatewireRemoteProps","StatewireSubmitResult","StatewireWireCommand","PendingState","at","pendingMarked","failedAttempts","posted","Pending","seq","command","inv","state","resolve","payload","reject","error","Outcome","ok","failure","SendFailure","isResolved","isStateSettled","inFlight","Error","legalTransitions","Record","queued","trying","done","transition","s","Session","entry","next","outcome","prev","includes","settles","undefined","covers","lifecycle","onCovered","onSettle","type","pending","filter","p","carried","Exclude","newClientId","rejectedSend","Promise","result","catch","AttachState","record","ctx","recordPersisted","store","lastAck","canonical","lastPublished","changed","source","StateSource","attach","attachEpoch","running","pumping","transport","waiters","notify","emitEvent","event","send","commands","params","createSession","options","sessionStore","stored","load","clientId","nextSeq","onSnapshot","args","handleSnapshot","onOps","handleOps","onFinish","handleFinish","snapshot","takeChanged","setOnChange","listener","sendCommand","method","setListener","publish","wake","waiter","waitForWake","r","push","sleepUntilWake","delayMs","clearTimeout","timer","setTimeout","w","settleAll","detach","verdict","cause","evicted","unmount","gone","superseded","const","batch","detachFailure","fate","cascades","some","evict","save","noteAcked","onAck","spliceAcked","settleVoid","protocolError","message","applyResponse","response","find","code","ingestOps","ops","applied","changedPaths","events","publishIngested","lastSeq","connection","reconnect","pump","res","ack","horizon","Math","max","reason","isFinished","sendable","epoch","onPosted","console","start","stop","setTransport","ts","Date","now","onStart","useStatewireSession","emit"],"sources":["../../src/client/session.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { applyOps } from \"../wire/ops\";\nimport type { StatewirePath } from \"../wire/ops\";\nimport type { StatewireResponse } from \"./connection\";\nimport { bindCommandsHost } from \"../host/host\";\nimport type { CommandsInvocation, CommandsListener } from \"../host/host\";\nimport type { Statewire } from \"../types\";\nimport type { StatewireClient } from \"../statewire\";\nimport { createMemorySessionStore } from \"./sessionStore\";\nimport type {\n  StatewireSessionRecord,\n  StatewireSessionStore,\n  StatewireSessionStoreOptions,\n} from \"./sessionStore\";\nimport { retryDelay } from \"./timing\";\nimport { createMethodProxy } from \"../util/methodProxy\";\nimport { randomId } from \"../util/randomId\";\nimport { StatewireSendError } from \"../types\";\nimport type {\n  RemoteLink,\n  StatewireRemoteProps,\n  StatewireSubmitResult,\n  StatewireWireCommand,\n} from \"../transports/sse\";\n\n/**\n * queued/trying/posted: overlay live, result pending. awaiting-result: acked\n * (overlay gone) but the result rides a late res; `posted: false` re-sends.\n * settled-live: result settled but the overlay stays until the covering ack.\n * done: removed from the queue.\n */\ntype PendingState =\n  | { at: \"queued\"; pendingMarked: boolean }\n  | { at: \"trying\"; pendingMarked: boolean; failedAttempts: number }\n  | { at: \"posted\"; pendingMarked: boolean; failedAttempts: number }\n  | { at: \"awaiting-result\"; posted: boolean; failedAttempts: number }\n  | { at: \"settled-live\"; posted: boolean; failedAttempts: number }\n  | { at: \"done\" };\n\ntype Pending = {\n  readonly seq: number;\n  readonly command: StatewireWireCommand;\n  readonly inv: CommandsInvocation;\n  state: PendingState;\n  resolve: (payload: unknown) => void;\n  reject: (error: StatewireSendError) => void;\n};\n\ntype Outcome =\n  | { ok: true; payload: unknown }\n  | { ok: false; failure: StatewireClient.SendFailure };\n\nconst isResolved = (state: PendingState) =>\n  state.at === \"settled-live\" || state.at === \"done\";\n\nconst isStateSettled = (state: PendingState) =>\n  state.at === \"awaiting-result\" || state.at === \"done\";\n\n// The pump admits an entry as trying before sending; only the pump itself\n// requeues, and a done entry is never still pending.\nconst inFlight = (state: PendingState) => {\n  if (state.at === \"queued\" || state.at === \"done\") {\n    throw new Error(`statewire: ${state.at} entry observed after a send`);\n  }\n  return state;\n};\n\nconst legalTransitions: Record<PendingState[\"at\"], PendingState[\"at\"][]> = {\n  queued: [\"queued\", \"trying\", \"awaiting-result\", \"settled-live\", \"done\"],\n  // trying -> queued: an answered unknown-client proves the seq was never admitted.\n  trying: [\n    \"queued\",\n    \"trying\",\n    \"posted\",\n    \"awaiting-result\",\n    \"settled-live\",\n    \"done\",\n  ],\n  posted: [\"posted\", \"trying\", \"awaiting-result\", \"settled-live\", \"done\"],\n  \"awaiting-result\": [\"awaiting-result\", \"done\"],\n  \"settled-live\": [\"settled-live\", \"done\"],\n  done: [],\n};\n\nconst transition = (\n  s: Session,\n  entry: Pending,\n  next: PendingState,\n  outcome?: Outcome,\n) => {\n  const prev = entry.state;\n  if (!legalTransitions[prev.at].includes(next.at)) {\n    throw new Error(\n      `statewire: illegal pending transition ${prev.at} -> ${next.at}`,\n    );\n  }\n  const settles = !isResolved(prev) && isResolved(next);\n  if (settles && outcome === undefined) {\n    throw new Error(\n      `statewire: settling transition ${prev.at} -> ${next.at} without an outcome`,\n    );\n  }\n  const covers = !isStateSettled(prev) && isStateSettled(next);\n  entry.state = next;\n  if (covers) s.lifecycle?.onCovered?.(entry.inv);\n  if (settles && outcome !== undefined) {\n    if (outcome.ok) {\n      entry.resolve(outcome.payload);\n      s.lifecycle?.onSettle(entry.inv, {\n        type: \"accepted\",\n        payload: outcome.payload,\n      });\n    } else {\n      entry.reject(new StatewireSendError(outcome.failure));\n      s.lifecycle?.onSettle(entry.inv, {\n        type: \"rejected\",\n        error: new StatewireSendError(outcome.failure),\n      });\n    }\n  }\n  if (next.at === \"done\") {\n    s.pending = s.pending.filter((p) => p !== entry);\n  }\n};\n\nconst carried = (\n  state: Exclude<PendingState, { at: \"done\" }>,\n): { posted: boolean; failedAttempts: number } =>\n  state.at === \"queued\"\n    ? { posted: false, failedAttempts: 0 }\n    : state.at === \"trying\" || state.at === \"posted\"\n      ? { posted: state.at === \"posted\", failedAttempts: state.failedAttempts }\n      : { posted: state.posted, failedAttempts: state.failedAttempts };\n\nconst newClientId = () => `c-${randomId()}`;\n\nconst rejectedSend = (\n  failure: StatewireClient.SendFailure,\n): Promise<unknown> => {\n  const result = Promise.reject<unknown>(new StatewireSendError(failure));\n  result.catch(() => {});\n  return result;\n};\n\ntype AttachState = \"detached\" | \"attached\" | \"finished\";\n\ntype Session = {\n  record: StatewireSessionRecord;\n  ctx: StatewireRemoteProps;\n  recordPersisted: boolean;\n  store: StatewireSessionStore;\n  lastAck: number;\n  pending: Pending[];\n  canonical: unknown;\n  lastPublished: unknown;\n  changed: StatewirePath[];\n  source: Statewire.StateSource;\n  attach: AttachState;\n  attachEpoch: number;\n  running: boolean;\n  pumping: boolean;\n  transport: RemoteLink | null;\n  waiters: (() => void)[];\n  lifecycle: CommandsListener | null;\n  notify: () => void;\n  emitEvent: (event: unknown) => void;\n  send: (command: StatewireWireCommand) => Promise<unknown>;\n  commands: Record<string, (...params: unknown[]) => Promise<unknown>>;\n};\n\nconst createSession = (options: StatewireSessionStoreOptions): Session => {\n  const store = options.sessionStore ?? createMemorySessionStore();\n  const stored = store.load();\n  const record = stored ?? { clientId: newClientId(), nextSeq: 1 };\n  const s: Session = {\n    record,\n    ctx: {\n      get clientId() {\n        return s.record.clientId;\n      },\n      onSnapshot: (args) => handleSnapshot(s, args),\n      onOps: (args) => handleOps(s, args),\n      onFinish: (args) => handleFinish(s, args),\n    },\n    recordPersisted: stored !== null,\n    store,\n    lastAck: -1,\n    pending: [],\n    canonical: undefined,\n    lastPublished: undefined,\n    changed: [],\n    source: {\n      snapshot: () => s.canonical,\n      takeChanged: () => {\n        const changed = s.changed;\n        s.changed = [];\n        return changed;\n      },\n      setOnChange: (listener) => {\n        s.notify = listener ?? (() => {});\n      },\n    },\n    attach: \"detached\",\n    attachEpoch: 0,\n    running: false,\n    pumping: false,\n    transport: null,\n    waiters: [],\n    lifecycle: null,\n    notify: () => {},\n    emitEvent: () => {},\n    send: (command) => sendCommand(s, command),\n    commands: createMethodProxy((method, params) => s.send({ method, params })),\n  };\n  bindCommandsHost(s.commands, {\n    setListener: (listener) => {\n      s.lifecycle = listener;\n    },\n  });\n  return s;\n};\n\nconst publish = (s: Session) => {\n  if (s.canonical === s.lastPublished) return;\n  s.lastPublished = s.canonical;\n  s.notify();\n};\n\nconst wake = (s: Session) => {\n  const waiters = s.waiters;\n  s.waiters = [];\n  for (const waiter of waiters) waiter();\n};\n\nconst waitForWake = (s: Session) => new Promise<void>((r) => s.waiters.push(r));\n\nconst sleepUntilWake = (s: Session, delayMs: number) =>\n  new Promise<void>((resolve) => {\n    const waiter = () => {\n      clearTimeout(timer);\n      resolve();\n    };\n    const timer = setTimeout(() => {\n      s.waiters = s.waiters.filter((w) => w !== waiter);\n      resolve();\n    }, delayMs);\n    s.waiters.push(waiter);\n  });\n\nconst settleAll = (\n  s: Session,\n  detach: \"evicted\" | \"unmount\" | \"gone\" | \"superseded\",\n  verdict?: {\n    entry: Pending;\n    failure: StatewireClient.SendFailure;\n  },\n) => {\n  const cause = (\n    {\n      evicted: \"session-lost\",\n      unmount: \"unmount\",\n      gone: \"stream-gone\",\n      superseded: \"superseded\",\n    } as const\n  )[detach];\n  const batch = s.pending;\n  const detachFailure = (entry: Pending): StatewireClient.SendFailure => {\n    const state = entry.state;\n    if (state.at === \"awaiting-result\")\n      return { fate: \"result-unavailable\", cause };\n    if (state.at === \"queued\") {\n      const cascades = batch.some(\n        (p) => p.seq < entry.seq && p.state.at !== \"queued\",\n      );\n      return { fate: \"aborted\", cause: cascades ? \"cascade\" : cause };\n    }\n    return { fate: \"lost\", cause };\n  };\n  for (const entry of [...batch]) {\n    const failure =\n      entry === verdict?.entry ? verdict.failure : detachFailure(entry);\n    transition(s, entry, { at: \"done\" }, { ok: false, failure });\n  }\n};\n\nconst evict = (\n  s: Session,\n  verdict?: {\n    entry: Pending;\n    failure: StatewireClient.SendFailure;\n  },\n) => {\n  settleAll(s, \"evicted\", verdict);\n  s.record = { clientId: newClientId(), nextSeq: 1 };\n  s.store.save(s.record);\n  s.attach = \"detached\";\n  publish(s);\n  wake(s);\n};\n\nconst noteAcked = (s: Session, seq: number) => {\n  for (const entry of s.pending) {\n    if (entry.seq > seq || isStateSettled(entry.state)) continue;\n    s.lifecycle?.onAck(entry.inv);\n  }\n};\n\nconst spliceAcked = (s: Session, seq: number, settleVoid: boolean) => {\n  for (const entry of [...s.pending]) {\n    const state = entry.state;\n    if (entry.seq > seq || isStateSettled(state)) continue;\n    if (state.at === \"settled-live\") {\n      transition(s, entry, { at: \"done\" });\n    } else if (settleVoid && !state.pendingMarked) {\n      transition(s, entry, { at: \"done\" }, { ok: true, payload: undefined });\n    } else {\n      transition(s, entry, { at: \"awaiting-result\", ...carried(state) });\n    }\n  }\n};\n\nconst protocolError = (message: string): never => {\n  throw new Error(`statewire: protocol error: ${message}`);\n};\n\nconst applyResponse = (s: Session, response: StatewireResponse) => {\n  const entry = s.pending.find((p) => p.seq === response.seq);\n  if (!entry) return;\n  const state = entry.state;\n  if (state.at === \"done\") return;\n  switch (response.type) {\n    case \"pending\":\n      if (\n        state.at === \"queued\" ||\n        state.at === \"trying\" ||\n        state.at === \"posted\"\n      ) {\n        transition(s, entry, { ...state, pendingMarked: true });\n      }\n      break;\n    case \"accepted\":\n      if (state.at === \"settled-live\") break;\n      transition(\n        s,\n        entry,\n        state.at === \"awaiting-result\"\n          ? { at: \"done\" }\n          : { at: \"settled-live\", ...carried(state) },\n        { ok: true, payload: response.payload },\n      );\n      break;\n    case \"rejected\":\n      transition(\n        s,\n        entry,\n        { at: \"done\" },\n        {\n          ok: false,\n          failure:\n            response.code === \"unknown-command\"\n              ? { fate: \"unknown-command\", cause: \"server\" }\n              : response.code === \"invalid-params\"\n                ? {\n                    fate: \"invalid-params\",\n                    cause: \"server\",\n                    message:\n                      response.message ??\n                      protocolError(\"rejected response missing message\"),\n                  }\n                : {\n                    fate: \"rejected\",\n                    cause: \"server\",\n                    message:\n                      response.message ??\n                      protocolError(\"rejected response missing message\"),\n                    ...(response.payload !== undefined && {\n                      payload: response.payload,\n                    }),\n                  },\n        },\n      );\n      break;\n    case \"crashed\":\n    case \"result-unavailable\":\n      if (state.at === \"settled-live\") break;\n      transition(\n        s,\n        entry,\n        state.at === \"awaiting-result\"\n          ? { at: \"done\" }\n          : { at: \"settled-live\", ...carried(state) },\n        { ok: false, failure: { fate: response.type, cause: \"server\" } },\n      );\n      break;\n  }\n};\n\nconst ingestOps = (s: Session, ops: unknown[]) => {\n  const applied = applyOps(s.canonical, ops);\n  s.canonical = applied.state;\n  s.changed.push(...applied.changedPaths);\n  return applied.events;\n};\n\nconst publishIngested = (s: Session, events: unknown[]) => {\n  publish(s);\n  for (const event of events) s.emitEvent(event);\n  wake(s);\n};\n\nconst handleSnapshot = (\n  s: Session,\n  { ops, lastSeq }: { ops: unknown[]; lastSeq: number },\n) => {\n  if (lastSeq === -1 && s.attach !== \"detached\") {\n    evict(s);\n    s.transport?.connection.reconnect();\n    publishIngested(s, ingestOps(s, ops));\n    return;\n  }\n  const events = ingestOps(s, ops);\n  s.attach = \"attached\";\n  s.attachEpoch += 1;\n  // The attach snapshot is not the true covering envelope: acked entries\n  // stay awaiting their result and re-send under seq dedup.\n  noteAcked(s, lastSeq);\n  spliceAcked(s, lastSeq, false);\n  s.lastAck = lastSeq;\n  for (const entry of s.pending) {\n    const state = entry.state;\n    if (entry.seq <= lastSeq) {\n      if (state.at === \"awaiting-result\" && state.posted) {\n        transition(s, entry, { ...state, posted: false });\n      }\n      if (state.at === \"awaiting-result\") void pump(s);\n    } else if (state.at === \"posted\") {\n      // Above the ack watermark a prior receipt no longer counts.\n      transition(s, entry, {\n        at: \"trying\",\n        pendingMarked: state.pendingMarked,\n        failedAttempts: state.failedAttempts,\n      });\n      void pump(s);\n    } else if (state.at === \"settled-live\" && state.posted) {\n      transition(s, entry, { ...state, posted: false });\n      void pump(s);\n    }\n  }\n  publishIngested(s, events);\n};\n\nconst handleOps = (\n  s: Session,\n  {\n    ops,\n    res,\n    ack,\n  }: { ops: unknown[]; res?: StatewireResponse[]; ack?: number },\n) => {\n  const horizon = ack === undefined ? s.lastAck : Math.max(s.lastAck, ack);\n  if (res !== undefined) {\n    for (const response of res) {\n      if (response.seq > horizon) {\n        protocolError(\"response seq beyond the ack\");\n      }\n    }\n  }\n  const events = ingestOps(s, ops);\n  if (ack !== undefined) noteAcked(s, ack);\n  if (res !== undefined) for (const response of res) applyResponse(s, response);\n  if (ack !== undefined) {\n    spliceAcked(s, ack, true);\n    s.lastAck = Math.max(s.lastAck, ack);\n  }\n  publishIngested(s, events);\n};\n\nconst handleFinish = (s: Session, { reason }: { reason: string }) => {\n  if (reason === \"evicted\" || reason === \"error\") return;\n  s.attach = \"finished\";\n  settleAll(s, reason === \"superseded\" ? \"superseded\" : \"gone\");\n  publish(s);\n  wake(s);\n};\n\nconst isFinished = (s: Session) => s.attach === \"finished\";\n\nconst sendable = (p: Pending) =>\n  p.state.at === \"queued\" ||\n  p.state.at === \"trying\" ||\n  ((p.state.at === \"awaiting-result\" || p.state.at === \"settled-live\") &&\n    !p.state.posted);\n\nconst pump = async (s: Session) => {\n  if (s.pumping) return;\n  s.pumping = true;\n  try {\n    while (s.running && !isFinished(s)) {\n      const entry = s.pending.find(sendable);\n      if (!entry) return;\n      const transport = s.transport;\n      if (s.attach !== \"attached\" || !transport) {\n        await waitForWake(s);\n        continue;\n      }\n      const clientId = s.record.clientId;\n      const epoch = s.attachEpoch;\n      if (entry.state.at === \"queued\") {\n        transition(s, entry, {\n          at: \"trying\",\n          pendingMarked: entry.state.pendingMarked,\n          failedAttempts: 0,\n        });\n      }\n      let result: StatewireSubmitResult;\n      try {\n        result = await transport.send({\n          seq: entry.seq,\n          command: entry.command,\n        });\n      } catch (error) {\n        if (!s.running || isFinished(s)) return;\n        if (!s.pending.includes(entry)) continue;\n        const state = inFlight(entry.state);\n        transition(s, entry, {\n          ...state,\n          failedAttempts: state.failedAttempts + 1,\n        });\n        await sleepUntilWake(s, retryDelay(error, state.failedAttempts + 1));\n        continue;\n      }\n      if (!s.running) return;\n      if (!s.pending.includes(entry)) continue;\n      if (result.type === \"receipt\") {\n        const response = result.response;\n        const state = entry.state;\n        if (state.at === \"trying\" || state.at === \"posted\") {\n          transition(s, entry, {\n            at: \"posted\",\n            pendingMarked: state.pendingMarked,\n            failedAttempts: state.failedAttempts,\n          });\n        } else if (\n          state.at === \"awaiting-result\" ||\n          state.at === \"settled-live\"\n        ) {\n          transition(s, entry, { ...state, posted: true });\n        }\n        s.lifecycle?.onPosted?.(entry.inv);\n        if (response !== undefined) {\n          applyResponse(s, response);\n          publish(s);\n        }\n      } else if (result.type === \"rejected\") {\n        transition(\n          s,\n          entry,\n          { at: \"done\" },\n          {\n            ok: false,\n            failure: {\n              fate: \"rejected\",\n              cause: \"server\",\n              message: result.message,\n            },\n          },\n        );\n        publish(s);\n      } else if (result.type === \"stale-lease\") {\n        if (epoch === s.attachEpoch) await waitForWake(s);\n      } else if (result.type === \"unknown-client\") {\n        // Eviction is never decided on the POST leg: re-attach first and let\n        // the snapshot's lastSeq deliver the verdict. An answered attempt\n        // proves the server never admitted this seq, so a clean entry requeues.\n        if (epoch === s.attachEpoch) {\n          const state = entry.state;\n          if (state.at === \"trying\" && state.failedAttempts === 0) {\n            transition(s, entry, {\n              at: \"queued\",\n              pendingMarked: state.pendingMarked,\n            });\n          }\n          s.transport?.connection.reconnect();\n          while (\n            s.running &&\n            !isFinished(s) &&\n            epoch === s.attachEpoch &&\n            clientId === s.record.clientId\n          ) {\n            await waitForWake(s);\n          }\n        }\n      } else if (result.type === \"seq-gap\") {\n        if (clientId === s.record.clientId) {\n          console.error(\n            `statewire: server reports a seq gap for seq ${entry.seq}; ` +\n              \"treating the session as corrupt and rotating the client id\",\n          );\n          // Every attempt answered means the server never saw it; a thrown\n          // attempt may have left the machine unanswered, so the verdict is \"lost\".\n          const state = inFlight(entry.state);\n          const failure: StatewireClient.SendFailure =\n            state.at === \"awaiting-result\"\n              ? { fate: \"result-unavailable\", cause: \"session-lost\" }\n              : {\n                  fate: state.failedAttempts > 0 ? \"lost\" : \"aborted\",\n                  cause: \"session-lost\",\n                };\n          evict(s, { entry, failure });\n          s.transport?.connection.reconnect();\n        }\n      }\n    }\n  } finally {\n    s.pumping = false;\n  }\n};\n\nconst start = (s: Session) => {\n  if (!s.recordPersisted) {\n    s.recordPersisted = true;\n    s.store.save(s.record);\n  }\n  s.running = true;\n  void pump(s);\n};\n\nconst stop = (s: Session) => {\n  s.running = false;\n  wake(s);\n  settleAll(s, \"unmount\");\n};\n\nconst setTransport = (s: Session, transport: RemoteLink) => {\n  if (s.transport === transport) return;\n  s.transport = transport;\n  wake(s);\n};\n\nconst sendCommand = (\n  s: Session,\n  command: StatewireWireCommand,\n): Promise<unknown> => {\n  if (!s.running) {\n    return rejectedSend({ fate: \"aborted\", cause: \"unmount\" });\n  }\n  if (isFinished(s)) {\n    return rejectedSend({ fate: \"aborted\", cause: \"stream-gone\" });\n  }\n  const seq = s.record.nextSeq;\n  s.record = { ...s.record, nextSeq: seq + 1 };\n  s.store.save(s.record);\n  const entry: Pending = {\n    seq,\n    command,\n    inv: {\n      method: command.method,\n      params: command.params,\n      ts: Date.now(),\n      seq,\n      clientId: s.record.clientId,\n    },\n    state: { at: \"queued\", pendingMarked: false },\n    resolve: () => {},\n    reject: () => {},\n  };\n  const result = new Promise<unknown>((resolve, reject) => {\n    entry.resolve = resolve;\n    entry.reject = reject;\n  });\n  result.catch(() => {});\n  s.pending.push(entry);\n  s.lifecycle?.onStart(entry.inv);\n  void pump(s);\n  return result;\n};\n\nexport const useStatewireSession = (\n  options: StatewireSessionStoreOptions,\n  emit: (event: unknown) => void,\n): Session => {\n  const [s] = useState(() => createSession(options));\n  useEffect(() => {\n    s.emitEvent = emit;\n    return () => {\n      s.emitEvent = () => {};\n    };\n  }, [s, emit]);\n  useEffect(() => {\n    start(s);\n    return () => stop(s);\n  }, [s]);\n  return s;\n};\n\nexport { setTransport };\n"],"mappings":"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"}

package/dist/client/sessionStore.d.ts

@@ -0,0 +1,16 @@
+//#region src/client/sessionStore.d.ts
+type StatewireSessionRecord = {
+  clientId: string;
+  nextSeq: number;
+};
+type StatewireSessionStore = {
+  load: () => StatewireSessionRecord | null;
+  save: (record: StatewireSessionRecord) => void;
+};
+type StatewireSessionStoreOptions = {
+  sessionStore?: StatewireSessionStore | undefined;
+};
+declare const createMemorySessionStore: () => StatewireSessionStore;
+//#endregion
+export { StatewireSessionRecord, StatewireSessionStore, StatewireSessionStoreOptions, createMemorySessionStore };
+//# sourceMappingURL=sessionStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sessionStore.d.ts","names":[],"sources":["../../src/client/sessionStore.ts"],"mappings":";KAAY;EACV;EACA;;KAGU;EACV,YAAY;EACZ,OAAO,QAAQ;;KAGL;EACV,eAAe;;cAGJ,gCAA+B"}

package/dist/client/sessionStore.js

@@ -0,0 +1,14 @@
+//#region src/client/sessionStore.ts
+const createMemorySessionStore = () => {
+	let record = null;
+	return {
+		load: () => record,
+		save: (next) => {
+			record = next;
+		}
+	};
+};
+//#endregion
+export { createMemorySessionStore };
+
+//# sourceMappingURL=sessionStore.js.map

package/dist/client/sessionStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionStore.js","names":["StatewireSessionRecord","clientId","nextSeq","StatewireSessionStore","load","save","record","StatewireSessionStoreOptions","sessionStore","createMemorySessionStore","next"],"sources":["../../src/client/sessionStore.ts"],"sourcesContent":["export type StatewireSessionRecord = {\n  clientId: string;\n  nextSeq: number;\n};\n\nexport type StatewireSessionStore = {\n  load: () => StatewireSessionRecord | null;\n  save: (record: StatewireSessionRecord) => void;\n};\n\nexport type StatewireSessionStoreOptions = {\n  sessionStore?: StatewireSessionStore | undefined;\n};\n\nexport const createMemorySessionStore = (): StatewireSessionStore => {\n  let record: StatewireSessionRecord | null = null;\n  return {\n    load: () => record,\n    save: (next) => {\n      record = next;\n    },\n  };\n};\n"],"mappings":";AAcA,MAAaS,iCAAwD;CACnE,IAAIH,SAAwC;CAC5C,OAAO;EACLF,YAAYE;EACZD,OAAOK,SAAS;GACdJ,SAASI;EACX;CACF;AACF"}

package/dist/client/timing.d.ts

@@ -0,0 +1,11 @@
+//#region src/client/timing.d.ts
+declare const timing: {
+  backoffBaseMs: number;
+  backoffMaxMs: number;
+  heartbeatTimeoutMs: number;
+};
+declare const backoff: (attempt: number) => number;
+declare const retryDelay: (error: unknown, attempt: number) => number;
+//#endregion
+export { backoff, retryDelay, timing };
+//# sourceMappingURL=timing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timing.d.ts","names":[],"sources":["../../src/client/timing.ts"],"mappings":";cAAa;;;;;cAMA,UAAW;cAGX,aAAc,gBAAgB"}