statewire 0.8.1 → 0.9.0

package/dist/client/session.js

@@ -2,78 +2,14 @@ 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 { encodeParams, encodeValue, reviveResponse } from "../wire/meta.js";
+import { backoff } from "./timing.js";
 import { createMemorySessionStore } from "./sessionStore.js";
+import { randomId } from "../util/randomId.js";
 import { useEffect, useState } from "@assistant-ui/tap/react-shim";
 //#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 && entry.inv) s.lifecycle?.onCovered?.(entry.inv);
-	if (settles && outcome !== void 0) {
-		if (outcome.ok) {
-			entry.resolve(outcome.payload);
-			if (entry.inv) s.lifecycle?.onSettle(entry.inv, {
-				type: "accepted",
-				payload: outcome.payload
-			});
-		} else {
-			entry.reject(new StatewireSendError(outcome.failure));
-			if (entry.inv) 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 protocolError = (message) => {
+	throw new Error(`statewire: protocol error: ${message}`);
 };
 const newClientId = () => `c-${randomId()}`;
 const rejectedSend = (failure) => {
@@ -81,61 +17,6 @@ const rejectedSend = (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,
-		context: void 0,
-		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;
@@ -158,22 +39,48 @@ const sleepUntilWake = (s, delayMs) => new Promise((resolve) => {
 	}, delayMs);
 	s.waiters.push(waiter);
 });
-const settleAll = (s, detach, verdict) => {
+const setRecord = (s, record) => {
+	s.record = record;
+	if (!s.ephemeral) s.store.save(record);
+};
+const setIdle = (s, level) => {
+	if (level === s.idle) return;
+	s.idle = level;
+	s.notify();
+	if (level) s.onDone?.();
+};
+const cover = (s, entry) => {
+	if (entry.applied) return;
+	entry.applied = true;
+	s.lifecycle?.onApplied(entry.inv);
+	s.lifecycle?.onCovered?.(entry.inv);
+};
+const settleEntry = (s, entry, outcome) => {
+	s.pending = s.pending.filter((p) => p !== entry);
+	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)
+		});
+	}
+};
+const settleAll = (s, detach) => {
 	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") {
-			const predecessorLost = batch.some((p) => p.seq < entry.seq && p.state.at !== "queued");
+		if (!entry.attempted) {
+			const predecessorLost = batch.some((p) => p.seq < entry.seq && p.attempted);
 			return predecessorLost ? {
 				fate: "aborted",
 				cause,
@@ -189,177 +96,198 @@ const settleAll = (s, detach, verdict) => {
 		};
 	};
 	for (const entry of [...batch]) {
-		const failure = entry === verdict?.entry ? verdict.failure : detachFailure(entry);
-		transition(s, entry, { at: "done" }, {
+		s.lifecycle?.onCovered?.(entry.inv);
+		settleEntry(s, entry, {
 			ok: false,
-			failure
+			failure: detachFailure(entry)
 		});
 	}
 };
-const claimReplays = (s) => {
-	const claimed = s.pending.filter((entry) => entry.inv !== null && !isResolved(entry.state));
-	if (claimed.length === 0) return [];
-	s.pending = s.pending.filter((p) => !claimed.includes(p));
-	return claimed;
-};
-const evict = (s, verdict) => {
-	const replays = claimReplays(s);
-	settleAll(s, "evicted", verdict);
-	s.record = {
-		clientId: newClientId(),
-		nextSeq: 1
-	};
-	s.store.save(s.record);
-	s.attach = "detached";
-	if (s.context !== void 0) s.send({ context: s.context });
-	for (const old of replays) {
-		if (old.inv) s.lifecycle?.onCovered?.(old.inv);
-		enqueue(s, old.command, old.resolve, old.reject);
+const restateContext = (s) => {
+	s.ctxPending = [];
+	if (s.ctxOps === void 0) return;
+	const seq = s.record.ctxNextSeq;
+	setRecord(s, {
+		...s.record,
+		ctxNextSeq: seq + 1
+	});
+	s.ctxPending.push({
+		seq,
+		ops: s.ctxOps,
+		posted: false
+	});
+};
+const resetRecord = (s, clientId) => {
+	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;
+	setRecord(s, {
+		clientId,
+		nextSeq: 1,
+		ctxNextSeq: 1
+	});
+	for (const old of survivors) {
+		s.lifecycle?.onCovered?.(old.inv);
+		enqueue(s, old.command, old.inv.params, old.resolve, old.reject);
 	}
+	restateContext(s);
 	publish(s);
 	wake(s);
 };
-const noteAcked = (s, seq) => {
-	for (const entry of s.pending) {
-		if (entry.seq > seq || isStateSettled(entry.state)) continue;
-		if (entry.inv) s.lifecycle?.onAck(entry.inv);
-	}
+const ephemeralDetach = (s) => {
+	s.ephemeral = false;
+	s.sessionKnown = false;
+	resetRecord(s, newClientId());
 };
-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 rejectedFailure = (cmd) => {
+	const code = cmd.code === void 0 || cmd.code === "unknown-command" || cmd.code === "invalid-params" ? cmd.code : protocolError(`unknown rejected code: ${cmd.code}`);
+	return {
+		fate: "rejected",
+		cause: "server",
+		...code !== void 0 && { code },
+		...cmd.message !== void 0 && { message: cmd.message },
+		...cmd.payload !== void 0 && { payload: cmd.payload }
+	};
 };
-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"
-				}
-			});
+const handleCmd = (s, cmd) => {
+	if (typeof cmd.seq !== "number") protocolError("cmd entry missing seq");
+	if (cmd.dur === true) {
+		s.durableSeq = Math.max(s.durableSeq, cmd.seq);
+		for (const entry of s.pending) if (entry.seq <= s.durableSeq) entry.posted = true;
+	}
+	if (cmd.type === void 0) return;
+	const entry = s.pending.find((p) => p.seq === cmd.seq);
+	if (cmd.type === "applied") {
+		if (entry) cover(s, entry);
+		return;
 	}
+	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);
+};
+const handleCmds = (s, cmds) => {
+	for (const cmd of cmds) handleCmd(s, cmd);
+	wake(s);
 };
 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) => {
+const publishIngested = (s) => {
 	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 RECORDS = [
+	"fresh",
+	"resumed",
+	"ephemeral"
+];
+const snapClocks = (s, seqWm, ctxWm) => {
+	const tail = s.pending.filter((p) => p.seq > seqWm);
+	if (!(tail.every((p, i) => p.seq === seqWm + 1 + i) && s.record.nextSeq === seqWm + tail.length + 1)) {
+		s.pending = s.pending.filter((p) => p.seq <= seqWm);
+		setRecord(s, {
+			...s.record,
+			nextSeq: seqWm + 1
+		});
+		for (const old of tail) {
+			s.lifecycle?.onCovered?.(old.inv);
+			enqueue(s, old.command, old.inv.params, old.resolve, old.reject);
+		}
+	}
+	if (!(s.ctxPending.every((c, i) => c.seq === ctxWm + 1 + i) && s.record.ctxNextSeq === ctxWm + s.ctxPending.length + 1)) {
+		setRecord(s, {
+			...s.record,
+			ctxNextSeq: ctxWm + 1
+		});
+		restateContext(s);
 	}
-	const events = ingestOps(s, ops);
+};
+const handleHello = (s, { ops, syn }) => {
+	const record = syn.record ?? "fresh";
+	if (!RECORDS.includes(record)) protocolError(`unknown record: ${String(record)}`);
+	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);
+	s.frameFailures = 0;
+	s.resumeAt = 0;
+	s.ephemeral = record === "ephemeral";
+	const [attachCmd, attachCtx] = s.attachLaneSeqs;
+	s.attachLaneSeqs = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
+	if (record === "resumed") {
+		for (const entry of s.pending) entry.posted = attachCmd.has(entry.seq);
+		const ctxWatermark = syn.ctxSeq ?? 0;
+		s.ctxPending = s.ctxPending.filter((c) => c.seq > ctxWatermark);
+		for (const c of s.ctxPending) c.posted = attachCtx.has(c.seq);
+		snapClocks(s, syn.seq ?? 0, ctxWatermark);
+	} else resetRecord(s, s.record.clientId);
+	s.sessionKnown = true;
+	publishIngested(s);
+	pump(s);
 };
-const 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 handleOps = (s, { ops, cmds }) => {
+	ingestOps(s, ops);
+	for (const cmd of cmds) handleCmd(s, cmd);
+	publishIngested(s);
+};
+const handleRefusal = (s, syn) => {
+	const { seq, ctxSeq } = syn;
+	if (typeof seq === "number") {
+		const watermark = Math.max(seq, s.durableSeq);
+		for (const entry of s.pending) entry.posted = entry.seq <= watermark;
 	}
-	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);
+	if (typeof ctxSeq === "number") {
+		s.ctxPending = s.ctxPending.filter((c) => c.seq > ctxSeq);
+		for (const c of s.ctxPending) c.posted = false;
 	}
-	publishIngested(s, events);
+	if (typeof syn.retry === "number") s.resumeAt = Date.now() + Math.max(0, syn.retry);
+	const firstCmd = s.pending.find((p) => !p.posted);
+	const firstCtx = s.ctxPending.find((c) => !c.posted);
+	if (typeof syn.seq === "number" && firstCmd !== void 0 && firstCmd.seq > Math.max(syn.seq, s.durableSeq) + 1 || typeof syn.ctxSeq === "number" && firstCtx !== void 0 && firstCtx.seq > syn.ctxSeq + 1) s.transport?.connection.reconnect();
+	wake(s);
+	pump(s);
+};
+const handleDetach = (s) => {
+	if (s.attach === "attached") s.attach = "detached";
+	if (s.ephemeral) ephemeralDetach(s);
+	wake(s);
 };
 const handleFinish = (s, { reason }) => {
 	if (reason === "evicted" || reason === "error") return;
@@ -369,100 +297,98 @@ const handleFinish = (s, { reason }) => {
 	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 buildLanes = (s) => {
+	const ctxEntries = [];
+	for (const entry of s.ctxPending) {
+		if (entry.posted) continue;
+		if (ctxEntries.length > 0 && entry.seq !== ctxEntries.at(-1).seq + 1) break;
+		ctxEntries.push(entry);
+	}
+	const cmdEntries = [];
+	for (const entry of s.pending) {
+		if (entry.posted) continue;
+		if (cmdEntries.length > 0 && entry.seq !== cmdEntries.at(-1).seq + 1) break;
+		cmdEntries.push(entry);
+	}
+	if (ctxEntries.length === 0 && cmdEntries.length === 0) return null;
+	return {
+		frame: {
+			...ctxEntries.length > 0 && { ctx: ctxEntries.map((c) => ({
+				ops: c.ops,
+				seq: c.seq
+			})) },
+			...cmdEntries.length > 0 && { cmd: cmdEntries.map((p) => ({
+				...p.command,
+				seq: p.seq
+			})) }
+		},
+		cmdEntries,
+		ctxEntries
+	};
+};
+const takeAttachLanes = (s) => {
+	s.attachLaneSeqs = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
+	const wanted = s.lanesOnAttach;
+	s.lanesOnAttach = false;
+	if (!wanted || !s.sessionKnown) return null;
+	const lanes = buildLanes(s);
+	if (!lanes) return null;
+	s.attachLaneSeqs = [new Set(lanes.cmdEntries.map((p) => p.seq)), new Set(lanes.ctxEntries.map((c) => c.seq))];
+	for (const entry of lanes.cmdEntries) entry.attempted = true;
+	return lanes.frame;
+};
 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 (buildLanes(s) === null) return;
 			if (s.attach !== "attached" || !transport) {
+				if (transport?.connection.status === "idle") transport.connection.reconnect();
 				await waitForWake(s);
 				continue;
 			}
-			const clientId = s.record.clientId;
+			const resumeDelay = s.resumeAt - Date.now();
+			if (resumeDelay > 0) {
+				await sleepUntilWake(s, resumeDelay);
+				continue;
+			}
+			const lanes = buildLanes(s);
+			if (!lanes) continue;
 			const epoch = s.attachEpoch;
-			if (entry.state.at === "queued") transition(s, entry, {
-				at: "trying",
-				pendingMarked: entry.state.pendingMarked,
-				failedAttempts: 0
-			});
+			for (const entry of lanes.cmdEntries) entry.attempted = true;
 			let result;
 			try {
-				result = await transport.send({
-					seq: entry.seq,
-					command: entry.command
-				});
-			} catch (error) {
+				result = await transport.send(lanes.frame);
+			} catch {
 				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));
+				s.frameFailures += 1;
+				await sleepUntilWake(s, backoff(s.frameFailures));
 				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
-				});
-				if (entry.inv) 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
+			s.frameFailures = 0;
+			if (result.type === "ok") {
+				if (epoch === s.attachEpoch) {
+					for (const entry of lanes.cmdEntries) if (s.pending.includes(entry)) {
+						entry.posted = true;
+						s.lifecycle?.onPosted?.(entry.inv);
 					}
-				});
-				publish(s);
+					for (const entry of lanes.ctxEntries) entry.posted = true;
+				}
+			} else if (result.type === "refusal") {
+				if (epoch === s.attachEpoch) handleRefusal(s, result.syn);
 			} 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);
+					transport.connection.reconnect();
+					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();
+			} else if (result.type === "no-lease") {
+				if (epoch === s.attachEpoch) {
+					s.lanesOnAttach = true;
+					transport.connection.reconnect();
+					while (s.running && !isFinished(s) && epoch === s.attachEpoch) await waitForWake(s);
 				}
 			}
 		}
@@ -488,35 +414,33 @@ const setTransport = (s, transport) => {
 	s.transport = transport;
 	wake(s);
 };
-const enqueue = (s, command, resolve, reject) => {
+const enqueue = (s, command, params, resolve, reject) => {
 	const seq = s.record.nextSeq;
-	s.record = {
+	setRecord(s, {
 		...s.record,
 		nextSeq: seq + 1
-	};
-	s.store.save(s.record);
+	});
 	const entry = {
 		seq,
 		command,
-		inv: command.method === void 0 ? null : {
+		inv: {
 			method: command.method,
-			params: command.params,
+			params,
 			ts: Date.now(),
 			seq,
 			clientId: s.record.clientId
 		},
-		state: {
-			at: "queued",
-			pendingMarked: false
-		},
+		attempted: false,
+		posted: false,
+		applied: false,
 		resolve,
 		reject
 	};
 	s.pending.push(entry);
-	if (entry.inv) s.lifecycle?.onStart(entry.inv);
+	s.lifecycle?.onStart(entry.inv);
 	pump(s);
 };
-const sendCommand = (s, command) => {
+const sendCommand = (s, method, params) => {
 	if (!s.running) return rejectedSend({
 		fate: "aborted",
 		cause: "unmount"
@@ -526,24 +450,107 @@ const sendCommand = (s, command) => {
 		cause: "stream-gone"
 	});
 	const result = new Promise((resolve, reject) => {
-		enqueue(s, command, resolve, reject);
+		const { params: encoded, meta } = encodeParams(params);
+		enqueue(s, {
+			method,
+			params: encoded,
+			...meta !== void 0 && { meta }
+		}, params, resolve, reject);
 	});
 	result.catch(() => {});
 	return result;
 };
 const setContext = (s, value) => {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("statewire: context must be a plain object");
-	s.context = value;
-	return s.send({ context: value });
+	const { value: encoded, meta } = encodeValue(value);
+	s.ctxOps = [{
+		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
+	});
+	wake(s);
+	pump(s);
 };
-const useStatewireSession = (options, emit) => {
-	const [s] = useState(() => createSession(options));
-	useEffect(() => {
-		s.emitEvent = emit;
-		return () => {
-			s.emitEvent = () => {};
+const useStatewireSession = (options) => {
+	const [defaultStore] = useState(createMemorySessionStore);
+	const store = options.sessionStore ?? defaultStore;
+	const [s] = useState(() => {
+		const stored = store.load();
+		const session = {
+			record: stored ?? {
+				clientId: newClientId(),
+				nextSeq: 1,
+				ctxNextSeq: 1
+			},
+			ctx: {
+				get clientId() {
+					return session.record.clientId;
+				},
+				takeAttachLanes: () => takeAttachLanes(session),
+				onHello: (args) => handleHello(session, args),
+				onOps: (args_0) => handleOps(session, args_0),
+				onCmds: (cmds) => handleCmds(session, cmds),
+				onRefusal: (syn) => handleRefusal(session, syn),
+				onIdle: (level) => setIdle(session, level),
+				onDetach: () => handleDetach(session),
+				onFinish: (args_1) => handleFinish(session, args_1)
+			},
+			recordPersisted: stored !== null,
+			store,
+			ephemeral: false,
+			sessionKnown: false,
+			durableSeq: 0,
+			resumeAt: 0,
+			idle: false,
+			onDone: void 0,
+			ctxOps: void 0,
+			ctxPending: [],
+			lanesOnAttach: false,
+			attachLaneSeqs: [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()],
+			frameFailures: 0,
+			pending: [],
+			canonical: void 0,
+			lastPublished: void 0,
+			changed: [],
+			source: {
+				snapshot: () => session.canonical,
+				takeChanged: () => {
+					const changed = session.changed;
+					session.changed = [];
+					return changed;
+				},
+				setOnChange: (listener) => {
+					session.notify = listener ?? (() => {});
+				}
+			},
+			attach: "detached",
+			attachEpoch: 0,
+			running: false,
+			pumping: false,
+			transport: null,
+			waiters: [],
+			lifecycle: null,
+			notify: () => {},
+			commands: createMethodProxy((method, params) => sendCommand(session, method, params))
 		};
-	}, [s, emit]);
+		bindCommandsHost(session.commands, { setListener: (listener_0) => {
+			session.lifecycle = listener_0;
+		} });
+		return session;
+	});
+	s.store = store;
+	s.onDone = options.onDone;
 	useEffect(() => {
 		start(s);
 		return () => stop(s);