statewire 0.0.0-0 → 0.0.1

package/dist/client/session.js

@@ -0,0 +1,509 @@
+import { applyOps } from "../wire/ops.js";
+import { StatewireSendError } from "../types.js";
+import { bindCommandsHost } from "../host/host.js";
+import { backoff } from "./timing.js";
+import { createMemorySessionStore } from "./sessionStore.js";
+//#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 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-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+const rejectedSend = (failure) => {
+	const result = Promise.reject(new StatewireSendError(failure));
+	result.catch(() => {});
+	return result;
+};
+const createCommandsProxy = (send) => {
+	const memo = /* @__PURE__ */ new Map();
+	return new Proxy({}, { get: (_target, method) => {
+		if (typeof method !== "string") return void 0;
+		let fn = memo.get(method);
+		if (fn === void 0) {
+			fn = (...params) => send({
+				method,
+				params
+			});
+			memo.set(method, fn);
+		}
+		return fn;
+	} });
+};
+const createSession = (options) => {
+	const store = options.sessionStore ?? createMemorySessionStore();
+	const stored = store.load();
+	const s = {
+		record: stored ?? {
+			clientId: newClientId(),
+			nextSeq: 1
+		},
+		recordPersisted: stored !== null,
+		store,
+		lastAck: -1,
+		pending: [],
+		canonical: void 0,
+		lastPublished: void 0,
+		changed: [],
+		source: {
+			root: () => 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: createCommandsProxy((command) => s.send(command))
+	};
+	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 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 ?? ""
+				} : {
+					fate: "rejected",
+					cause: "server",
+					message: response.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 === "ended" || 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 = entry.state;
+				if (state.at === "queued" || state.at === "done") continue;
+				transition(s, entry, {
+					...state,
+					failedAttempts: state.failedAttempts + 1
+				});
+				const { retryAfterMs } = error;
+				const delay = typeof retryAfterMs === "number" ? retryAfterMs : backoff(state.failedAttempts + 1);
+				await new Promise((r) => setTimeout(r, delay));
+				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") {
+				const { message, payload } = result;
+				transition(s, entry, { at: "done" }, {
+					ok: false,
+					failure: {
+						fate: "rejected",
+						cause: "server",
+						message,
+						...payload !== void 0 && { payload }
+					}
+				});
+				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 = entry.state;
+					const failure = state.at === "awaiting-result" ? {
+						fate: "result-unavailable",
+						cause: "session-lost"
+					} : state.at === "queued" || state.at === "done" ? {
+						fate: "aborted",
+						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;
+};
+//#endregion
+export { createSession, handleFinish, handleOps, handleSnapshot, setTransport, start, stop };
+
+//# sourceMappingURL=session.js.map

package/dist/client/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","names":["applyOps","StatewirePath","StatewireResponse","bindCommandsHost","CommandsInvocation","CommandsListener","StatewireStateSource","createMemorySessionStore","StatewireSessionRecord","StatewireSessionStore","backoff","StatewireSendError","SendFailure","StatewireSendFailure","RemoteLink","StatewireSubmitResult","StatewireWireCommand","SessionOptions","sessionStore","PendingState","at","pendingMarked","failedAttempts","posted","Pending","seq","command","inv","state","resolve","payload","reject","error","Outcome","ok","failure","isResolved","isStateSettled","legalTransitions","Record","queued","trying","done","transition","s","Session","entry","next","outcome","prev","includes","Error","settles","undefined","covers","lifecycle","onCovered","onSettle","type","pending","filter","p","carried","Exclude","newClientId","Date","now","toString","Math","random","slice","rejectedSend","Promise","result","catch","AttachState","record","recordPersisted","store","lastAck","canonical","lastPublished","changed","source","attach","attachEpoch","running","pumping","transport","waiters","notify","emitEvent","event","send","commands","params","createCommandsProxy","memo","Map","Proxy","get","_target","method","fn","set","createSession","options","stored","load","clientId","nextSeq","root","takeChanged","setOnChange","listener","sendCommand","setListener","publish","wake","waiter","waitForWake","r","push","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","handleSnapshot","lastSeq","connection","reconnect","pump","handleOps","res","ack","horizon","max","handleFinish","reason","isFinished","sendable","epoch","retryAfterMs","delay","setTimeout","onPosted","console","start","stop","setTransport","ts","onStart"],"sources":["../../src/client/session.ts"],"sourcesContent":["import { 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 { StatewireStateSource } from \"../types\";\nimport { createMemorySessionStore } from \"./sessionStore\";\nimport type {\n  StatewireSessionRecord,\n  StatewireSessionStore,\n} from \"./sessionStore\";\nimport { backoff } from \"./timing\";\nimport { StatewireSendError } from \"../types\";\nimport type { SendFailure as StatewireSendFailure } from \"../types\";\nimport type {\n  RemoteLink,\n  StatewireSubmitResult,\n  StatewireWireCommand,\n} from \"../transports/sse\";\n\nexport type SessionOptions = {\n  sessionStore?: StatewireSessionStore | undefined;\n};\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: StatewireSendFailure };\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\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 = () =>\n  `c-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;\n\nconst rejectedSend = (failure: StatewireSendFailure): 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  recordPersisted: boolean;\n  store: StatewireSessionStore;\n  lastAck: number;\n  pending: Pending[];\n  canonical: unknown;\n  lastPublished: unknown;\n  changed: StatewirePath[];\n  source: StatewireStateSource;\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 createCommandsProxy = (\n  send: (command: StatewireWireCommand) => Promise<unknown>,\n): Session[\"commands\"] => {\n  const memo = new Map<string, (...params: unknown[]) => Promise<unknown>>();\n  return new Proxy({} as Session[\"commands\"], {\n    get: (_target, method) => {\n      if (typeof method !== \"string\") return undefined;\n      let fn = memo.get(method);\n      if (fn === undefined) {\n        fn = (...params: unknown[]) => send({ method, params });\n        memo.set(method, fn);\n      }\n      return fn;\n    },\n  });\n};\n\nconst createSession = (options: SessionOptions): 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    recordPersisted: stored !== null,\n    store,\n    lastAck: -1,\n    pending: [],\n    canonical: undefined,\n    lastPublished: undefined,\n    changed: [],\n    source: {\n      root: () => 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: createCommandsProxy((command) => s.send(command)),\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 settleAll = (\n  s: Session,\n  detach: \"evicted\" | \"unmount\" | \"gone\" | \"superseded\",\n  verdict?: {\n    entry: Pending;\n    failure: StatewireSendFailure;\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): StatewireSendFailure => {\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: StatewireSendFailure;\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: response.message ?? \"\",\n                  }\n                : {\n                    fate: \"rejected\",\n                    cause: \"server\",\n                    message: response.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 = (\n  s: Session,\n  events: { event: unknown; state: unknown }[],\n) => {\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 === \"ended\" || 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 = entry.state;\n        if (state.at === \"queued\" || state.at === \"done\") continue;\n        transition(s, entry, {\n          ...state,\n          failedAttempts: state.failedAttempts + 1,\n        });\n        const { retryAfterMs } = error as { retryAfterMs?: unknown };\n        const delay =\n          typeof retryAfterMs === \"number\"\n            ? retryAfterMs\n            : backoff(state.failedAttempts + 1);\n        await new Promise((r) => setTimeout(r, delay));\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        const { message, payload } = result;\n        transition(\n          s,\n          entry,\n          { at: \"done\" },\n          {\n            ok: false,\n            failure: {\n              fate: \"rejected\",\n              cause: \"server\",\n              message,\n              ...(payload !== undefined && { payload }),\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 = entry.state;\n          const failure: StatewireSendFailure =\n            state.at === \"awaiting-result\"\n              ? { fate: \"result-unavailable\", cause: \"session-lost\" }\n              : state.at === \"queued\" || state.at === \"done\"\n                ? { fate: \"aborted\", 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 {\n  createSession,\n  handleSnapshot,\n  handleFinish,\n  handleOps,\n  setTransport,\n  start,\n  stop,\n};\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;
+};
+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;\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,10 @@
+//#region src/client/timing.d.ts
+declare const timing: {
+  backoffBaseMs: number;
+  backoffMaxMs: number;
+  heartbeatTimeoutMs: number;
+};
+declare const backoff: (attempt: number) => number;
+//#endregion
+export { backoff, 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"}

package/dist/client/timing.js

@@ -0,0 +1,11 @@
+//#region src/client/timing.ts
+const timing = {
+	backoffBaseMs: 250,
+	backoffMaxMs: 3e4,
+	heartbeatTimeoutMs: 3e4
+};
+const backoff = (attempt) => Math.min(timing.backoffBaseMs * 2 ** (attempt - 1), timing.backoffMaxMs);
+//#endregion
+export { backoff, timing };
+
+//# sourceMappingURL=timing.js.map

package/dist/client/timing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.js","names":["timing","backoffBaseMs","backoffMaxMs","heartbeatTimeoutMs","backoff","attempt","Math","min"],"sources":["../../src/client/timing.ts"],"sourcesContent":["export const timing = {\n  backoffBaseMs: 250,\n  backoffMaxMs: 30_000,\n  heartbeatTimeoutMs: 30_000,\n};\n\nexport const backoff = (attempt: number) =>\n  Math.min(timing.backoffBaseMs * 2 ** (attempt - 1), timing.backoffMaxMs);\n"],"mappings":";AAAA,MAAaA,SAAS;CACpBC,eAAe;CACfC,cAAc;CACdC,oBAAoB;AACtB;AAEA,MAAaC,WAAWC,YACtBC,KAAKC,IAAIP,OAAOC,gBAAgB,MAAMI,UAAU,IAAIL,OAAOE,YAAY"}

package/dist/host/draft.d.ts

@@ -0,0 +1,14 @@
+import { StatewireOp, StatewirePath } from "../wire/ops.js";
+//#region src/host/draft.d.ts
+type ServerOp = Exclude<StatewireOp, {
+  op: "event";
+}>;
+type DraftHost = {
+  root: () => unknown;
+  record: (op: ServerOp) => void;
+};
+declare const frozen: (value: unknown) => unknown;
+declare const createStateDraft: <T>(host: DraftHost, path?: StatewirePath) => T;
+//#endregion
+export { DraftHost, ServerOp, createStateDraft, frozen };
+//# sourceMappingURL=draft.d.ts.map