statewire 0.18.2 → 0.19.0

package/dist/client/session.js

@@ -1,13 +1,13 @@
-import { encodeDocument, reviveDocumentValue } from "../document.js";
+import { reviveDocumentValue } from "../document.js";
 import { inRange, protocolOffers } from "../wire/protocol.js";
-import { encodeParams, reviveResponse } from "../wire/meta.js";
-import { applyDocumentOps, findDocument, mainDocument, resolveDocumentKey } from "../wire/documents.js";
 import { createMethodProxy } from "../util/methodProxy.js";
 import { StatewireSendError } from "../types.js";
 import { bindCommandsHost } from "../host/host.js";
+import { encodeParams, reviveResponse } from "../wire/meta.js";
 import "../wire/limits.js";
+import { applyDocumentOps, findDocument, mainDocument, resolveDocumentKey } from "../wire/documents.js";
 import { DocumentStorageContext, SessionStorageContext, createMemorySessionStore } from "./sessionStore.js";
-import { backoff } from "./timing.js";
+import { backoff, retryHint } from "./timing.js";
 import { wrapStorageError } from "./storageError.js";
 import { TERMINAL } from "./connection.js";
 import { randomId } from "../util/randomId.js";
@@ -21,6 +21,21 @@ const rejectedSend = (failure) => {
 	result.catch(() => {});
 	return result;
 };
+const EMPTY_LANE = {
+	nextSeq: 1,
+	commands: []
+};
+const laneOf = (record, protocol) => record.lanes[protocol] ?? EMPTY_LANE;
+const withLane = (record, protocol, lane) => ({
+	...record,
+	lanes: {
+		...record.lanes,
+		[protocol]: lane
+	}
+});
+const isEphemeral = (s, protocol) => s.selection?.protocols.some((p) => p.name === protocol && p.record === "ephemeral") ?? false;
+const durableSeqOf = (s, protocol) => s.durableSeq[protocol] ?? 0;
+const laneEntries = (s, protocol) => s.pending.filter((p) => p.command.protocol === protocol);
 const publish = (s) => {
 	if (s.canonical === s.lastPublished) return;
 	s.lastPublished = s.canonical;
@@ -58,26 +73,43 @@ const setRecord = (s, record) => {
 		throw s.storageError;
 	}
 };
-const backlog = (s) => s.pending.filter((p) => p.seq > s.durableSeq).map((p) => ({
-	seq: p.seq,
-	...p.command
-}));
-const mergeBacklog = (s) => {
-	const own = backlog(s);
+const toStored = (p) => {
+	const { protocol: _protocol, ...command } = p.command;
+	return {
+		seq: p.seq,
+		...command
+	};
+};
+const backlog = (s, protocol) => laneEntries(s, protocol).filter((p) => p.seq > durableSeqOf(s, protocol)).map(toStored);
+const mergeBacklog = (s, protocol) => {
+	const own = backlog(s, protocol);
 	if (!s.shared) return own;
-	const known = new Set(s.pending.map((p) => p.seq));
-	return [...s.record.commands.filter((c) => !known.has(c.seq) && c.seq > s.durableSeq), ...own].sort((a, b) => a.seq - b.seq);
+	const known = new Set(laneEntries(s, protocol).map((p) => p.seq));
+	return [...laneOf(s.record, protocol).commands.filter((c) => !known.has(c.seq) && c.seq > durableSeqOf(s, protocol)), ...own].sort((a, b) => a.seq - b.seq);
 };
+const durableLanes = (s) => [.../* @__PURE__ */ new Set([...Object.keys(s.record.lanes), ...s.pending.map((p) => p.command.protocol).filter((protocol) => !isEphemeral(s, protocol))])];
 const syncBacklogInner = (s) => {
 	const parked = s.shared ? s.shared.parked.splice(0) : [];
-	const parkedSeqs = new Set(parked.map((v) => v.seq));
-	const commands = mergeBacklog(s).filter((c) => !parkedSeqs.has(c.seq));
-	const verdicts = parked.length > 0 ? [...s.record.verdicts ?? [], ...parked].slice(-64) : s.record.verdicts;
-	if (verdicts === s.record.verdicts && commands.length === s.record.commands.length && commands.every((c, i) => c.seq === s.record.commands[i].seq)) return;
-	setRecord(s, {
+	let lanes = s.record.lanes;
+	for (const protocol of durableLanes(s)) {
+		const lane = laneOf(s.record, protocol);
+		const parkedHere = parked.filter((v) => v.protocol === protocol).map((v) => v.verdict);
+		const parkedSeqs = new Set(parkedHere.map((v) => v.seq));
+		const commands = mergeBacklog(s, protocol).filter((c) => !parkedSeqs.has(c.seq));
+		const verdicts = parkedHere.length > 0 ? [...lane.verdicts ?? [], ...parkedHere].slice(-64) : lane.verdicts;
+		if (verdicts === lane.verdicts && commands.length === lane.commands.length && commands.every((c, i) => c.seq === lane.commands[i].seq)) continue;
+		lanes = {
+			...lanes,
+			[protocol]: {
+				...lane,
+				commands,
+				...verdicts !== void 0 && { verdicts }
+			}
+		};
+	}
+	if (lanes !== s.record.lanes) setRecord(s, {
 		...s.record,
-		commands,
-		...verdicts !== void 0 && { verdicts }
+		lanes
 	});
 };
 const syncBacklog = (s) => {
@@ -119,12 +151,19 @@ const cover = (s, entry) => {
 	s.lifecycle?.onApplied(entry.inv);
 	s.lifecycle?.onCovered?.(entry.inv);
 };
-const NO_FAILED = [];
-const failedCommands = (s) => s.record.failed ?? NO_FAILED;
+const failedCommands = (s) => {
+	const parts = Object.values(s.record.lanes).flatMap((lane) => lane.failed === void 0 ? [] : [lane.failed]);
+	if (!(parts.length === s.failedParts.length && parts.every((part, i) => part === s.failedParts[i]))) {
+		s.failedParts = parts;
+		s.failedList = parts.flat();
+	}
+	return s.failedList;
+};
 const retainFailedInner = (s, entry, failure) => {
-	setRecord(s, {
-		...s.record,
-		failed: [...s.record.failed ?? [], {
+	const lane = laneOf(s.record, entry.command.protocol);
+	setRecord(s, withLane(s.record, entry.command.protocol, {
+		...lane,
+		failed: [...lane.failed ?? [], {
 			protocol: entry.command.protocol,
 			...entry.command.produced !== void 0 && { produced: entry.command.produced },
 			command: entry.command.method,
@@ -134,7 +173,7 @@ const retainFailedInner = (s, entry, failure) => {
 			ts: entry.inv.ts,
 			seq: entry.seq
 		}]
-	});
+	}));
 	s.notify();
 };
 const retainFailed = (s, entry, failure) => {
@@ -153,7 +192,7 @@ const settleEntry = (s, entry, outcome) => {
 			payload: outcome.payload
 		});
 	} else {
-		if (!((outcome.failure.cause === "unmount" || outcome.failure.cause === "stream-gone") && entry.seq > s.durableSeq)) retainFailed(s, entry, outcome.failure);
+		if (!((outcome.failure.cause === "unmount" || outcome.failure.cause === "stream-gone") && entry.seq > durableSeqOf(s, entry.command.protocol)) && !isEphemeral(s, entry.command.protocol)) retainFailed(s, entry, outcome.failure);
 		entry.reject(new StatewireSendError(outcome.failure));
 		s.lifecycle?.onSettle(entry.inv, {
 			type: "rejected",
@@ -166,7 +205,7 @@ const settleAll = (s, detach) => {
 	const batch = s.pending;
 	const detachFailure = (entry) => {
 		if (!entry.attempted) {
-			const predecessorLost = batch.some((p) => p.seq < entry.seq && p.attempted);
+			const predecessorLost = batch.some((p) => p.command.protocol === entry.command.protocol && p.seq < entry.seq && p.attempted);
 			return predecessorLost ? {
 				fate: "aborted",
 				cause,
@@ -201,30 +240,45 @@ const settleLost = (s, entries) => {
 		});
 	}
 };
+const requeue = (s, survivors) => {
+	for (const old of survivors) {
+		s.lifecycle?.onCovered?.(old.inv);
+		enqueueInner(s, old.command, old.inv.params, old.resolve, old.reject);
+	}
+};
 const rebaseRecord = (s, adopt) => {
 	const held = [...s.pending];
 	const survivors = held.filter((p) => !p.attempted && !p.applied);
 	settleLost(s, held.filter((p) => p.attempted || p.applied));
 	s.pending = [];
-	s.durableSeq = 0;
-	const failed = s.record.failed;
+	s.durableSeq = {};
+	const previous = s.record.lanes;
 	adopt();
-	if (failed !== void 0 && s.record.failed !== failed) setRecord(s, {
+	let lanes = s.record.lanes;
+	for (const [protocol, lane] of Object.entries(previous)) {
+		const failed = lane.failed;
+		if (failed === void 0 || laneOf(s.record, protocol).failed === failed) continue;
+		const current = laneOf(s.record, protocol);
+		lanes = {
+			...lanes,
+			[protocol]: {
+				...current,
+				failed: [...current.failed ?? [], ...failed]
+			}
+		};
+	}
+	if (lanes !== s.record.lanes) setRecord(s, {
 		...s.record,
-		failed: [...s.record.failed ?? [], ...failed]
+		lanes
 	});
-	for (const old of survivors) {
-		s.lifecycle?.onCovered?.(old.inv);
-		enqueueInner(s, old.command, old.inv.params, old.resolve, old.reject);
-	}
+	requeue(s, survivors);
 	publish(s);
 	wake(s);
 	pump(s);
 };
 const resetRecord = (s, clientId) => rebaseRecord(s, () => setRecord(s, {
 	clientId,
-	nextSeq: 1,
-	commands: []
+	lanes: {}
 }));
 const adoptReset = (s, stored) => rebaseRecord(s, () => {
 	s.record = stored;
@@ -234,6 +288,14 @@ const ephemeralDetach = (s) => {
 	s.sessionKnown = false;
 	resetRecord(s, randomId());
 };
+const detachEphemeralLanes = (s) => {
+	const held = s.pending.filter((p) => isEphemeral(s, p.command.protocol));
+	if (held.length === 0) return;
+	s.pending = s.pending.filter((p) => !held.includes(p));
+	settleLost(s, held.filter((p) => p.attempted));
+	requeue(s, held.filter((p) => !p.attempted));
+	publish(s);
+};
 const rejectedFailure = (cmd) => {
 	return {
 		fate: "rejected",
@@ -278,50 +340,72 @@ const outcomeOf = (cmd) => {
 		default: return protocolError(`unknown cmd type: ${String(cmd.type)}`);
 	}
 };
+const settleVerdict = (s, entry, cmd) => {
+	const outcome = outcomeOf(cmd);
+	if (outcome.ok) cover(s, entry);
+	else s.lifecycle?.onCovered?.(entry.inv);
+	settleEntry(s, entry, outcome);
+};
 const TERMINAL_CMD_TYPES = new Set(TERMINAL);
 const parkVerdict = (s, cmd) => {
 	if (!s.shared || !TERMINAL_CMD_TYPES.has(cmd.type)) return;
+	if (isEphemeral(s, cmd.protocol)) return;
 	s.shared.parked.push({
-		seq: cmd.seq,
-		type: cmd.type,
-		...cmd.code !== void 0 && { code: cmd.code },
-		...cmd.message !== void 0 && { message: cmd.message },
-		...cmd.payload !== void 0 && { payload: cmd.payload },
-		...cmd.meta !== void 0 && { meta: cmd.meta }
+		protocol: cmd.protocol,
+		verdict: {
+			seq: cmd.seq,
+			type: cmd.type,
+			...cmd.code !== void 0 && { code: cmd.code },
+			...cmd.message !== void 0 && { message: cmd.message },
+			...cmd.payload !== void 0 && { payload: cmd.payload },
+			...cmd.meta !== void 0 && { meta: cmd.meta }
+		}
 	});
 };
 const handleCmd = (s, cmd) => {
-	if (!Number.isSafeInteger(cmd.seq) || cmd.seq <= 0) protocolError("cmd.seq must be a positive safe integer");
-	if (cmd.dur === true) {
-		s.durableSeq = Math.max(s.durableSeq, cmd.seq);
-		for (const entry of s.pending) if (entry.seq <= s.durableSeq) entry.posted = true;
+	if (cmd.dur === true && !isEphemeral(s, cmd.protocol)) {
+		const watermark = Math.max(durableSeqOf(s, cmd.protocol), cmd.seq);
+		s.durableSeq[cmd.protocol] = watermark;
+		for (const entry of laneEntries(s, cmd.protocol)) if (entry.seq <= watermark) entry.posted = true;
 	}
 	if (cmd.type === void 0) return;
-	const entry = s.pending.find((p) => p.seq === cmd.seq);
+	const entry = s.pending.find((p) => p.command.protocol === cmd.protocol && p.seq === cmd.seq);
 	if (cmd.type === "applied") {
 		if (entry) cover(s, entry);
 		return;
 	}
 	if (!entry) return;
 	parkVerdict(s, cmd);
-	cover(s, entry);
-	settleEntry(s, entry, outcomeOf(cmd));
+	settleVerdict(s, entry, cmd);
 };
 const consumeVerdicts = (s) => {
-	const verdicts = s.record.verdicts ?? [];
-	const consumed = /* @__PURE__ */ new Set();
-	for (const verdict of verdicts) {
-		const entry = s.pending.find((p) => p.seq === verdict.seq);
-		if (!entry) continue;
-		consumed.add(verdict.seq);
-		cover(s, entry);
-		settleEntry(s, entry, outcomeOf(verdict));
+	let lanes = s.record.lanes;
+	for (const [protocol, lane] of Object.entries(s.record.lanes)) {
+		const verdicts = lane.verdicts ?? [];
+		const consumed = /* @__PURE__ */ new Set();
+		for (const verdict of verdicts) {
+			const entry = laneEntries(s, protocol).find((p) => p.seq === verdict.seq);
+			if (!entry) continue;
+			consumed.add(verdict.seq);
+			settleVerdict(s, entry, {
+				...verdict,
+				protocol
+			});
+		}
+		if (consumed.size === 0) continue;
+		lanes = {
+			...lanes,
+			[protocol]: {
+				...lane,
+				commands: lane.commands.filter((c) => !consumed.has(c.seq)),
+				verdicts: verdicts.filter((v) => !consumed.has(v.seq))
+			}
+		};
 	}
-	if (consumed.size === 0) return;
+	if (lanes === s.record.lanes) return;
 	setRecord(s, {
 		...s.record,
-		commands: s.record.commands.filter((c) => !consumed.has(c.seq)),
-		verdicts: verdicts.filter((v) => !consumed.has(v.seq))
+		lanes
 	});
 	publish(s);
 	wake(s);
@@ -359,28 +443,36 @@ const publishIngested = (s) => {
 	for (const listener of s.documentListeners) listener();
 	wake(s);
 };
-const sessionLostInner = (s, seqWm) => {
-	const held = [...s.pending];
+const sessionLostInner = (s, protocol, seqWm) => {
+	const held = laneEntries(s, protocol);
 	settleLost(s, held);
-	s.pending = [];
-	s.durableSeq = seqWm;
-	setRecord(s, {
-		clientId: s.record.clientId,
+	s.durableSeq[protocol] = seqWm;
+	const failed = laneOf(s.record, protocol).failed;
+	setRecord(s, withLane(s.record, protocol, {
 		nextSeq: seqWm + 1,
 		commands: [],
-		...s.record.failed !== void 0 && { failed: s.record.failed }
-	});
+		...failed !== void 0 && { failed }
+	}));
 	if (held.length > 0 && s.onSessionLost?.(held.map((p) => p.inv)) === "requeue") for (const old of held) enqueueInner(s, old.command, old.inv.params, () => {}, () => {});
 	publish(s);
 	wake(s);
 };
-const handleHello = (s, { ops, syn }) => {
-	if (syn.record !== void 0 && syn.record !== "ephemeral") protocolError(`unknown record: ${String(syn.record)}`);
-	if (syn.ctxSeq !== void 0 && syn.ctxSeq !== 0) protocolError(`hello ctxSeq must be 0, got ${syn.ctxSeq}`);
-	s.selection = syn.version === void 0 || syn.protocols === void 0 ? void 0 : {
+const selectionOf = (syn) => {
+	if (syn.version === void 0 || syn.protocols === void 0) return void 0;
+	return {
 		version: syn.version,
-		protocols: syn.protocols
+		protocols: syn.protocols.map(({ name, version, record }) => {
+			if (version === void 0) return protocolError(`hello lane ${name} has no version`);
+			return {
+				name,
+				version,
+				...record !== void 0 && { record }
+			};
+		})
 	};
+};
+const handleHello = (s, { ops, syn }) => {
+	s.selection = selectionOf(syn);
 	s.documents = {
 		mode: null,
 		documents: /* @__PURE__ */ new Map()
@@ -390,15 +482,16 @@ const handleHello = (s, { ops, syn }) => {
 	s.attachEpoch += 1;
 	s.frameFailures = 0;
 	s.resumeAt = 0;
-	s.ephemeral = syn.record === "ephemeral";
+	const lanes = syn.protocols ?? [];
+	s.ephemeral = lanes.length > 0 && lanes.every((lane) => lane.record === "ephemeral");
 	if (s.ephemeral) s.deactivated = true;
-	const [attachCmd, attachCtx] = s.attachLaneSeqs;
-	s.attachLaneSeqs = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
+	const attached = s.attachEntries;
+	s.attachEntries = /* @__PURE__ */ new Set();
 	const reconcile = () => {
 		if (s.shared) adoptStored(s);
-		s.durableSeq = syn.seq ?? 0;
-		for (const entry of s.pending) entry.posted = attachCmd.has(entry.seq);
-		for (const c of s.ctxPending) c.posted = attachCtx.has(c.seq);
+		for (const lane of lanes) if (lane.record === "ephemeral") s.ephemeralSeqs[lane.name] = Math.max(s.ephemeralSeqs[lane.name] ?? 0, ...laneEntries(s, lane.name).map((p) => p.seq));
+		else s.durableSeq[lane.name] = lane.seq ?? 0;
+		for (const entry of s.pending) entry.posted = attached.has(entry);
 		syncBacklogInner(s);
 		s.sessionKnown = true;
 	};
@@ -420,26 +513,26 @@ const handleOps = (s, { ops, cmds }) => {
 	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;
-	}
-	if (typeof ctxSeq === "number") {
-		s.ctxPending = s.ctxPending.filter((c) => c.seq > ctxSeq);
-		for (const c of s.ctxPending) c.posted = false;
-		const firstCtx = s.ctxPending.find((c) => !c.posted);
-		if (firstCtx !== void 0 && firstCtx.seq > ctxSeq + 1) protocolError(`ctx gap on a live attach: seq ${firstCtx.seq} after watermark ${ctxSeq}`);
+	const lanes = (syn.protocols ?? []).filter((lane) => lane.seq !== void 0);
+	for (const { name, seq } of lanes) {
+		const watermark = isEphemeral(s, name) ? seq : Math.max(seq, durableSeqOf(s, name));
+		for (const entry of laneEntries(s, name)) entry.posted = entry.seq <= watermark;
 	}
 	if (typeof syn.retry === "number") {
-		s.resumeAt = Date.now() + syn.retry;
+		s.resumeAt = Date.now() + retryHint(syn.retry);
 		wake(s);
 		pump(s);
 		return;
 	}
-	const firstCmd = s.pending.find((p) => !p.posted);
-	if (typeof seq === "number" && firstCmd !== void 0 && firstCmd.seq > Math.max(seq, s.durableSeq) + 1) {
-		transactBackground(s, () => sessionLostInner(s, seq), () => {
+	const gaps = lanes.filter(({ name, seq }) => {
+		const first = laneEntries(s, name).find((p) => !p.posted);
+		return first !== void 0 && first.seq > Math.max(seq, durableSeqOf(s, name)) + 1;
+	});
+	for (const { name, seq } of gaps) if (isEphemeral(s, name)) protocolError(`gap on ephemeral lane ${name} after watermark ${seq}`);
+	if (gaps.length > 0) {
+		transactBackground(s, () => {
+			for (const { name, seq } of gaps) sessionLostInner(s, name, seq);
+		}, () => {
 			wake(s);
 			pump(s);
 		});
@@ -450,7 +543,9 @@ const handleRefusal = (s, syn) => {
 };
 const handleDetach = (s) => {
 	if (s.attach === "attached") s.attach = "detached";
+	s.ephemeralSeqs = {};
 	if (s.ephemeral) ephemeralDetach(s);
+	else detachEphemeralLanes(s);
 	wake(s);
 };
 const handleFinish = (s, { reason }) => {
@@ -462,59 +557,40 @@ const handleFinish = (s, { reason }) => {
 };
 const isFinished = (s) => s.attach === "finished";
 const buildLanes = (s, cmdGate = "all") => {
-	const ctxEntries = [];
-	for (const entry of s.ctxPending) {
-		if (entry.posted) continue;
-		if (ctxEntries.length >= 256) break;
-		if (ctxEntries.length > 0 && entry.seq !== ctxEntries.at(-1).seq + 1) break;
-		ctxEntries.push(entry);
-	}
-	const cmdEntries = [];
+	const entries = [];
+	const last = {};
+	const stopped = /* @__PURE__ */ new Set();
 	for (const entry of s.pending) {
-		if (cmdGate === "none") break;
-		if (entry.posted) continue;
-		if (cmdGate === "persisted" && (s.persistedRecord?.clientId !== s.record.clientId || entry.seq >= s.persistedRecord.nextSeq)) break;
-		if (cmdEntries.length >= 256) break;
-		if (cmdEntries.length > 0 && entry.seq !== cmdEntries.at(-1).seq + 1) break;
-		cmdEntries.push(entry);
+		if (entries.length >= 256) break;
+		const protocol = entry.command.protocol;
+		if (entry.posted || stopped.has(protocol)) continue;
+		if (!isEphemeral(s, protocol) && (cmdGate === "none" || cmdGate === "persisted" && (s.persistedRecord?.clientId !== s.record.clientId || entry.seq >= laneOf(s.persistedRecord, protocol).nextSeq)) || protocol in last && entry.seq !== last[protocol] + 1) {
+			stopped.add(protocol);
+			continue;
+		}
+		last[protocol] = entry.seq;
+		entries.push(entry);
 	}
-	if (ctxEntries.length === 0 && cmdEntries.length === 0) return null;
+	if (entries.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) => {
-				const { produced: _produced, ...command } = p.command;
-				return {
-					...command,
-					seq: p.seq
-				};
-			}) }
-		},
-		cmdEntries,
-		ctxEntries
+		frame: { cmd: entries.map((p) => {
+			const { produced: _produced, ...command } = p.command;
+			return {
+				...command,
+				seq: p.seq
+			};
+		}) },
+		entries
 	};
 };
-const resetContextLane = (s) => {
-	const ops = contextSnapshot(s.contextDocuments);
-	s.ctxPending = ops.length === 0 ? [] : [{
-		seq: 1,
-		ops,
-		posted: false
-	}];
-	s.ctxNextSeq = s.ctxPending.length + 1;
-};
 const takeAttachLanes = (s) => {
-	s.attachLaneSeqs = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
-	resetContextLane(s);
+	s.attachEntries = /* @__PURE__ */ new Set();
 	const wanted = s.lanesOnAttach;
 	s.lanesOnAttach = false;
 	const lanes = buildLanes(s, wanted && s.sessionKnown ? "persisted" : "none");
 	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;
+	s.attachEntries = new Set(lanes.entries);
+	for (const entry of lanes.entries) entry.attempted = true;
 	return lanes.frame;
 };
 const persistBeforeSend = (s) => {
@@ -558,7 +634,7 @@ const pump = async (s) => {
 			if (persistence) await persistence;
 			if (!s.running || isFinished(s)) return;
 			if (epoch !== s.attachEpoch || s.attach !== "attached") continue;
-			for (const entry of lanes.cmdEntries) entry.attempted = true;
+			for (const entry of lanes.entries) entry.attempted = true;
 			let result;
 			try {
 				const send = () => transport.send(lanes.frame);
@@ -573,11 +649,10 @@ const pump = async (s) => {
 			s.frameFailures = 0;
 			if (result.type === "ok") {
 				if (epoch === s.attachEpoch) {
-					for (const entry of lanes.cmdEntries) if (s.pending.includes(entry)) {
+					for (const entry of lanes.entries) if (s.pending.includes(entry)) {
 						entry.posted = true;
 						s.lifecycle?.onPosted?.(entry.inv);
 					}
-					for (const entry of lanes.ctxEntries) entry.posted = true;
 				}
 			} else if (result.type === "refusal") {
 				if (epoch === s.attachEpoch) handleRefusal(s, result.syn);
@@ -644,12 +719,14 @@ const setTransport = (s, transport) => {
 	wake(s);
 };
 const enqueueInner = (s, command, params, resolve, reject) => {
-	const seq = Math.max(s.record.nextSeq, s.durableSeq + 1);
+	const protocol = command.protocol;
+	const ephemeral = isEphemeral(s, protocol);
+	const seq = ephemeral ? (s.ephemeralSeqs[protocol] ?? 0) + 1 : Math.max(laneOf(s.record, protocol).nextSeq, durableSeqOf(s, protocol) + 1);
 	const entry = {
 		seq,
 		command,
 		inv: {
-			protocol: command.protocol,
+			protocol,
 			method: command.method,
 			params,
 			ts: Date.now(),
@@ -663,11 +740,12 @@ const enqueueInner = (s, command, params, resolve, reject) => {
 		reject
 	};
 	s.pending.push(entry);
-	setRecord(s, {
-		...s.record,
+	if (ephemeral) s.ephemeralSeqs[protocol] = seq;
+	else setRecord(s, withLane(s.record, protocol, {
+		...laneOf(s.record, protocol),
 		nextSeq: seq + 1,
-		commands: mergeBacklog(s)
-	});
+		commands: mergeBacklog(s, protocol)
+	}));
 	s.lifecycle?.onStart(entry.inv);
 };
 const enqueue = (s, command, params, resolve, reject) => {
@@ -698,37 +776,47 @@ const enqueue = (s, command, params, resolve, reject) => {
 		pump(s);
 	}, reject);
 };
+const offered = (s, protocol) => {
+	const offers = protocolOffers(s.options);
+	return offers === "*" || offers.some((offer) => offer.name === protocol);
+};
 const adoptStored = (s) => {
-	const known = new Set(s.pending.map((p) => p.seq));
-	const stored = s.record.commands.filter((c) => !known.has(c.seq));
-	if (stored.length === 0) return;
-	for (const { seq, ...command } of stored) {
-		const offers = protocolOffers(s.options);
-		if (offers !== "*" && !offers.some((offer) => offer.name === command.protocol)) continue;
-		const params = command.meta === void 0 ? command.params : reviveDocumentValue([...command.params], command.meta);
-		const entry = {
-			seq,
-			command,
-			inv: {
-				protocol: command.protocol,
-				method: command.method,
-				params,
-				ts: Date.now(),
+	let adopted = false;
+	for (const [protocol, lane] of Object.entries(s.record.lanes)) {
+		if (!offered(s, protocol)) continue;
+		const known = new Set(laneEntries(s, protocol).map((p) => p.seq));
+		for (const { seq, ...command } of lane.commands) {
+			if (known.has(seq)) continue;
+			const params = command.meta === void 0 ? command.params : reviveDocumentValue([...command.params], command.meta);
+			const entry = {
 				seq,
-				clientId: s.record.clientId
-			},
-			attempted: true,
-			posted: false,
-			applied: false,
-			resolve: () => {},
-			reject: () => {}
-		};
-		s.pending.push(entry);
-		s.lifecycle?.onStart(entry.inv);
+				command: {
+					protocol,
+					...command
+				},
+				inv: {
+					protocol,
+					method: command.method,
+					params,
+					ts: Date.now(),
+					seq,
+					clientId: s.record.clientId
+				},
+				attempted: true,
+				posted: false,
+				applied: false,
+				resolve: () => {},
+				reject: () => {}
+			};
+			s.pending.push(entry);
+			s.lifecycle?.onStart(entry.inv);
+			adopted = true;
+		}
 	}
-	s.pending.sort((a, b) => a.seq - b.seq);
+	if (adopted) s.pending.sort((a, b) => a.seq - b.seq);
 };
 const sendCommand = (s, method, params, protocol = s.options.protocol ?? "default") => {
+	if (!(s.selection ? s.selection.protocols.some((p) => p.name === protocol) : offered(s, protocol))) throw new Error(`statewire: protocol "${protocol}" is not negotiated`);
 	if (!s.hydrated) {
 		const result = s.ready.then(() => sendCommand(s, method, params, protocol));
 		result.catch(() => {});
@@ -752,7 +840,7 @@ const sendCommand = (s, method, params, protocol = s.options.protocol ?? "defaul
 		enqueue(s, {
 			protocol,
 			produced: {
-				wire: s.options.wireVersion ?? { version: "2026-09-07" },
+				wire: s.options.wireVersion ?? { version: "2026-09-13" },
 				protocols: protocolOffers(s.options) === "*" && s.selection ? s.selection.protocols : protocolOffers(s.options)
 			},
 			method,
@@ -763,16 +851,16 @@ const sendCommand = (s, method, params, protocol = s.options.protocol ?? "defaul
 	result.catch(() => {});
 	return result;
 };
-const findFailed = (s, entry) => (s.record.failed ?? []).find((f) => f.seq === entry.seq && f.ts === entry.ts && f.command === entry.command);
+const findFailed = (s, entry) => (laneOf(s.record, entry.protocol).failed ?? []).find((f) => f.seq === entry.seq && f.ts === entry.ts && f.command === entry.command);
 const unknownFailed = (entry) => /* @__PURE__ */ new Error(`statewire: unknown failed command "${entry.command}"`);
 const takeFailed = (s, entry) => {
-	const failed = s.record.failed ?? [];
+	const lane = laneOf(s.record, entry.protocol);
 	const found = findFailed(s, entry);
 	if (found === void 0) throw unknownFailed(entry);
-	setRecord(s, {
-		...s.record,
-		failed: failed.filter((f) => f !== found)
-	});
+	setRecord(s, withLane(s.record, entry.protocol, {
+		...lane,
+		failed: (lane.failed ?? []).filter((f) => f !== found)
+	}));
 	s.notify();
 	return found;
 };
@@ -842,60 +930,6 @@ const retryFailed = (s, entry) => {
 	result.catch(() => {});
 	return result;
 };
-const contextSnapshot = (documents) => [...documents.documents].map(([doc, d]) => {
-	const encoded = encodeDocument(d.value);
-	return {
-		op: "mount",
-		...doc === 0 ? {} : { doc },
-		protocol: d.protocol,
-		...d.main ? { main: true } : {},
-		...d.key === null ? {} : { key: d.key },
-		value: encoded.value,
-		...encoded.meta === void 0 ? {} : { meta: encoded.meta }
-	};
-});
-const changeContext = (s, build) => {
-	if (!s.running || isFinished(s)) return;
-	const operations = build(s.contextDocuments);
-	if (!operations.length) throw new Error("statewire: context operations must not be empty");
-	const offers = protocolOffers(s.options);
-	const protocols = s.selection?.protocols ?? (offers === "*" ? void 0 : offers);
-	s.contextDocuments = applyDocumentOps(s.contextDocuments, operations, protocols, true);
-	s.ctxPending = [...s.ctxPending, {
-		seq: s.ctxNextSeq++,
-		ops: operations.map((op) => {
-			const value = op;
-			if (value["doc"] !== 0) return value;
-			const { doc: _doc, ...rest } = value;
-			return rest;
-		}),
-		posted: false
-	}];
-	wake(s);
-	pump(s);
-};
-const updateContext = (s, operations) => changeContext(s, () => operations);
-const setContext = (s, value, protocol = s.options.protocol ?? "default") => {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("statewire: context must be a plain object");
-	const encoded = encodeDocument(value);
-	changeContext(s, (documents) => {
-		const found = [...documents.documents].find(([, d]) => d.protocol === protocol && d.main);
-		const doc = found?.[0] ?? Math.max(-1, ...documents.documents.keys()) + 1;
-		return [{
-			...found === void 0 ? {
-				op: "mount",
-				protocol,
-				main: true
-			} : {
-				op: "replace",
-				path: []
-			},
-			...doc === 0 ? {} : { doc },
-			value: encoded.value,
-			...encoded.meta === void 0 ? {} : { meta: encoded.meta }
-		}];
-	});
-};
 const documentSource = (s) => ({
 	get: (protocol, key, prefix = s.options.keyPrefixes?.[protocol]) => {
 		const mounted = findDocument(s.documents, protocol, key, prefix);
@@ -922,33 +956,38 @@ const documentSource = (s) => ({
 	}
 });
 const invokeProtocol = (s, protocol, method, params) => sendCommand(s, method, params, protocol);
-const storedCommandCompatible = (command, current) => {
-	if (!command.produced || !command.protocol || !inRange(command.produced.wire.version, current.wire)) return false;
+const storedCommandCompatible = (protocol, command, current) => {
+	if (!command.produced || !inRange(command.produced.wire.version, current.wire)) return false;
 	const previous = command.produced.protocols;
 	if (current.protocols === "*") return true;
 	if (previous === "*") return false;
-	const produced = previous.find((p) => p.name === command.protocol);
-	const offer = current.protocols.find((p) => p.name === command.protocol);
+	const produced = previous.find((p) => p.name === protocol);
+	const offer = current.protocols.find((p) => p.name === protocol);
 	return produced !== void 0 && offer !== void 0 && inRange(produced.version, offer);
 };
+const validateLanes = (record) => {
+	if (typeof record.lanes !== "object" || record.lanes === null || Object.values(record.lanes).some((lane) => !Array.isArray(lane.commands))) throw new Error("statewire: session storage loaded a record without command lanes");
+};
 const loadSessionRecord = (store, options) => {
 	let stored = store.load();
-	if (stored !== null && !Array.isArray(stored.commands)) throw new Error("statewire: session storage loaded a record without a commands array");
+	if (stored !== null) validateLanes(stored);
 	const current = {
-		wire: options.wireVersion ?? { version: "2026-09-07" },
+		wire: options.wireVersion ?? { version: "2026-09-13" },
 		protocols: protocolOffers(options)
 	};
-	if (stored !== null && !stored.commands.every((command) => storedCommandCompatible(command, current))) {
+	const compatible = (record) => Object.entries(record.lanes).every(([protocol, lane]) => lane.commands.every((command) => storedCommandCompatible(protocol, command, current)));
+	if (stored !== null && !compatible(stored)) {
 		if (!store.migrate) throw new Error("statewire: stored commands require a storage migration");
 		stored = store.migrate(stored, current);
-		if (stored !== null && !stored.commands.every((command) => storedCommandCompatible(command, current))) throw new Error("statewire: migrated commands are incompatible");
-		if (stored !== null) store.save(stored);
+		if (stored !== null) {
+			validateLanes(stored);
+			if (!compatible(stored)) throw new Error("statewire: migrated commands are incompatible");
+			store.save(stored);
+		}
 	}
-	if (stored !== null && !Array.isArray(stored.commands)) throw new Error("statewire: session storage loaded a record without a commands array");
 	const record = stored ?? {
 		clientId: randomId(),
-		nextSeq: 1,
-		commands: []
+		lanes: {}
 	};
 	if (stored === null) store.save(record);
 	return record;
@@ -963,16 +1002,11 @@ const useStatewireSession = (options) => {
 	const [s] = useState(() => {
 		const record = store.ready === void 0 ? loadSessionRecord(store, options) : {
 			clientId: randomId(),
-			nextSeq: 1,
-			commands: []
+			lanes: {}
 		};
 		const session = {
 			options,
 			selection: void 0,
-			contextDocuments: {
-				mode: "mounted",
-				documents: /* @__PURE__ */ new Map()
-			},
 			record,
 			ctx: {
 				beforeAttach: () => persistBeforeSend(session),
@@ -1003,17 +1037,18 @@ const useStatewireSession = (options) => {
 			ephemeral: false,
 			deactivated: false,
 			sessionKnown: false,
-			durableSeq: 0,
+			durableSeq: {},
+			ephemeralSeqs: {},
 			resumeAt: 0,
 			idle: false,
 			onSessionLost: void 0,
 			onDone: void 0,
-			ctxNextSeq: 1,
-			ctxPending: [],
 			lanesOnAttach: false,
-			attachLaneSeqs: [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()],
+			attachEntries: /* @__PURE__ */ new Set(),
 			frameFailures: 0,
 			pending: [],
+			failedList: [],
+			failedParts: [],
 			canonical: void 0,
 			documentListeners: /* @__PURE__ */ new Set(),
 			documents: {
@@ -1087,6 +1122,6 @@ const useStatewireSession = (options) => {
 	return s;
 };
 //#endregion
-export { discardFailed, documentSource, failedCommands, invokeProtocol, retryFailed, setContext, setTransport, updateContext, useStatewireSession };
+export { discardFailed, documentSource, failedCommands, invokeProtocol, retryFailed, setTransport, useStatewireSession };
 
 //# sourceMappingURL=session.js.map