statewire 0.19.4 → 0.21.0

package/dist/client/session.js

@@ -1,10 +1,11 @@
 import { reviveDocumentValue } from "../document.js";
+import "../wire/limits.js";
 import { inRange, protocolOffers } from "../wire/protocol.js";
+import { encodeContext } from "../wire/context.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, retryHint } from "./timing.js";
@@ -65,13 +66,13 @@ const storageFailed = (s, cause) => {
 	s.transport?.storageFailed(error);
 };
 const setRecord = (s, record) => {
-	s.record = record;
 	if (!s.deactivated) try {
 		s.store.save(record);
 	} catch (cause) {
 		storageFailed(s, cause);
 		throw s.storageError;
 	}
+	s.record = record;
 };
 const toStored = (p) => {
 	const { protocol: _protocol, ...command } = p.command;
@@ -113,8 +114,16 @@ const syncBacklogInner = (s) => {
 	});
 };
 const syncBacklog = (s) => {
-	if (!s.shared) return syncBacklogInner(s);
-	transactBackground(s, () => syncBacklogInner(s));
+	const shared = s.shared;
+	if (!shared) return syncBacklogInner(s);
+	if (shared.syncQueued) return;
+	shared.syncQueued = true;
+	transact(s, () => {
+		shared.syncQueued = false;
+		syncBacklogInner(s);
+	}).catch(() => {
+		shared.syncQueued = false;
+	});
 };
 const transact = (s, fn) => {
 	if (!s.shared || s.deactivated) {
@@ -125,7 +134,7 @@ const transact = (s, fn) => {
 	const result = shared.txq.then(() => s.store.lock(async () => {
 		const stored = s.store.load();
 		if (stored !== null && stored.clientId !== s.record.clientId) adoptReset(s, stored);
-		else if (stored !== null) s.record = stored;
+		else if (stored !== null) s.record = boundRecord(stored);
 		fn();
 		const persistence = s.store.flush?.();
 		if (persistence) await persistence;
@@ -159,11 +168,27 @@ const failedCommands = (s) => {
 	}
 	return s.failedList;
 };
+const MAX_FAILED_RETAINED = 256;
+const boundFailed = (failed) => failed.length > 256 ? [...failed].sort((a, b) => a.ts - b.ts).slice(-256) : failed;
+const boundRecord = (record) => {
+	let lanes = record.lanes;
+	for (const [protocol, lane] of Object.entries(lanes)) if (lane.failed !== void 0 && lane.failed.length > 256) lanes = {
+		...lanes,
+		[protocol]: {
+			...lane,
+			failed: boundFailed(lane.failed)
+		}
+	};
+	return lanes === record.lanes ? record : {
+		...record,
+		lanes
+	};
+};
 const retainFailedInner = (s, entry, failure) => {
 	const lane = laneOf(s.record, entry.command.protocol);
 	setRecord(s, withLane(s.record, entry.command.protocol, {
 		...lane,
-		failed: [...lane.failed ?? [], {
+		failed: boundFailed([...lane.failed ?? [], {
 			protocol: entry.command.protocol,
 			...entry.command.produced !== void 0 && { produced: entry.command.produced },
 			command: entry.command.method,
@@ -172,7 +197,7 @@ const retainFailedInner = (s, entry, failure) => {
 			failure,
 			ts: entry.inv.ts,
 			seq: entry.seq
-		}]
+		}])
 	}));
 	s.notify();
 };
@@ -263,7 +288,7 @@ const rebaseRecord = (s, adopt) => {
 			...lanes,
 			[protocol]: {
 				...current,
-				failed: [...current.failed ?? [], ...failed]
+				failed: boundFailed([...current.failed ?? [], ...failed])
 			}
 		};
 	}
@@ -282,7 +307,7 @@ const resetRecord = (s, clientId) => rebaseRecord(s, () => setRecord(s, {
 }));
 const adoptReset = (s, stored) => {
 	rebaseRecord(s, () => {
-		s.record = stored;
+		s.record = boundRecord(stored);
 	});
 	if (s.attach === "attached") s.transport?.connection.reconnect();
 };
@@ -475,6 +500,13 @@ const selectionOf = (syn) => {
 	};
 };
 const handleHello = (s, { ops, syn }) => {
+	if (s.attach === "attached") {
+		s.ephemeralSeqs = {};
+		detachEphemeralLanes(s);
+	}
+	for (const [protocol, value] of s.contexts) if (s.attachContexts.get(protocol) === value) s.dirtyContexts.delete(protocol);
+	else s.dirtyContexts.add(protocol);
+	s.attachContexts.clear();
 	s.selection = selectionOf(syn);
 	s.documents = {
 		mode: null,
@@ -512,7 +544,7 @@ const handleHello = (s, { ops, syn }) => {
 const handleOps = (s, { ops, cmds }) => {
 	ingestOps(s, ops);
 	for (const cmd of cmds) handleCmd(s, cmd);
-	syncBacklog(s);
+	if (cmds.length > 0) syncBacklog(s);
 	publishIngested(s);
 };
 const handleRefusal = (s, syn) => {
@@ -574,15 +606,19 @@ const buildLanes = (s, cmdGate = "all") => {
 		last[protocol] = entry.seq;
 		entries.push(entry);
 	}
-	if (entries.length === 0) return null;
+	const ctx = [...s.dirtyContexts].map((protocol) => s.contexts.get(protocol));
+	if (entries.length === 0 && ctx.length === 0) return null;
 	return {
-		frame: { cmd: entries.map((p) => {
-			const { produced: _produced, ...command } = p.command;
-			return {
-				...command,
-				seq: p.seq
-			};
-		}) },
+		frame: {
+			...ctx.length > 0 && { ctx },
+			...entries.length > 0 && { cmd: entries.map((p) => {
+				const { produced: _produced, ...command } = p.command;
+				return {
+					...command,
+					seq: p.seq
+				};
+			}) }
+		},
 		entries
 	};
 };
@@ -590,6 +626,8 @@ const takeAttachLanes = (s) => {
 	s.attachEntries = /* @__PURE__ */ new Set();
 	const wanted = s.lanesOnAttach;
 	s.lanesOnAttach = false;
+	for (const protocol of s.contexts.keys()) s.dirtyContexts.add(protocol);
+	s.attachContexts = new Map(s.contexts);
 	const lanes = buildLanes(s, wanted && s.sessionKnown ? "persisted" : "none");
 	if (!lanes) return null;
 	s.attachEntries = new Set(lanes.entries);
@@ -620,6 +658,7 @@ const pump = async (s) => {
 			if (!s.hydrated) await s.ready;
 			const transport = s.transport;
 			if (buildLanes(s) === null) return;
+			if (transport?.parked && s.pending.length === 0) return;
 			if (s.attach !== "attached" || !transport) {
 				if (transport?.connection.status === "standby" && transport.connection.reason === "idle" || transport?.parked && s.pending.length > 0) transport.connection.reconnect();
 				await waitForWake(s);
@@ -641,15 +680,24 @@ const pump = async (s) => {
 			let result;
 			try {
 				const send = () => transport.send(lanes.frame);
-				result = await (s.shared && !s.deactivated ? s.store.lock(send) : send());
+				result = await (s.shared && !s.deactivated && lanes.entries.length > 0 ? s.store.lock(send) : send());
 			} catch {
 				if (!s.running || isFinished(s)) return;
+				if (lanes.frame.ctx?.length) {
+					s.lanesOnAttach = true;
+					transport.connection.reconnect();
+					await waitForWake(s);
+					continue;
+				}
 				s.frameFailures += 1;
 				await sleepUntilWake(s, backoff(s.frameFailures));
 				continue;
 			}
 			if (!s.running) return;
 			s.frameFailures = 0;
+			if (epoch === s.attachEpoch && (result.type === "ok" || result.type === "refusal")) {
+				for (const entry of lanes.frame.ctx ?? []) if (s.contexts.get(entry.protocol) === entry) s.dirtyContexts.delete(entry.protocol);
+			}
 			if (result.type === "ok") {
 				if (epoch === s.attachEpoch) {
 					for (const entry of lanes.entries) if (s.pending.includes(entry)) {
@@ -783,7 +831,7 @@ const adoptStored = (s) => {
 		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 params = command.meta === void 0 ? command.params : reviveDocumentValue(structuredClone(command.params), command.meta);
 			const entry = {
 				seq,
 				command: {
@@ -836,7 +884,7 @@ const sendCommand = (s, method, params, protocol = s.options.protocol ?? "defaul
 		enqueue(s, {
 			protocol,
 			produced: {
-				wire: s.options.wireVersion ?? { version: "2026-09-13" },
+				wire: s.options.wireVersion ?? { version: "2026-09-30" },
 				protocols: protocolOffers(s.options) === "*" && s.selection ? s.selection.protocols : protocolOffers(s.options)
 			},
 			method,
@@ -881,7 +929,7 @@ const retryFailed = (s, entry) => {
 	});
 	const found = findFailed(s, entry);
 	if (found === void 0) throw unknownFailed(entry);
-	const params = found.meta === void 0 ? found.params : reviveDocumentValue([...found.params], found.meta);
+	const params = found.meta === void 0 ? found.params : reviveDocumentValue(structuredClone(found.params), found.meta);
 	const result = new Promise((resolve, reject) => {
 		const retry = () => {
 			if (!s.running) {
@@ -968,7 +1016,7 @@ const loadSessionRecord = (store, options) => {
 	let stored = store.load();
 	if (stored !== null) validateLanes(stored);
 	const current = {
-		wire: options.wireVersion ?? { version: "2026-09-13" },
+		wire: options.wireVersion ?? { version: "2026-09-30" },
 		protocols: protocolOffers(options)
 	};
 	const compatible = (record) => Object.entries(record.lanes).every(([protocol, lane]) => lane.commands.every((command) => storedCommandCompatible(protocol, command, current)));
@@ -981,13 +1029,20 @@ const loadSessionRecord = (store, options) => {
 			store.save(stored);
 		}
 	}
-	const record = stored ?? {
+	const record = stored === null ? {
 		clientId: randomId(),
 		lanes: {}
-	};
-	if (stored === null) store.save(record);
+	} : boundRecord(stored);
+	if (record !== stored) store.save(record);
 	return record;
 };
+const setContext = (s, protocol, value) => {
+	if (s.selection ? !s.selection.protocols.some((p) => p.name === protocol) : !offered(s, protocol)) throw new Error(`statewire: protocol "${protocol}" is not negotiated`);
+	s.contexts.set(protocol, encodeContext(protocol, value));
+	s.dirtyContexts.add(protocol);
+	wake(s);
+	pump(s);
+};
 const useStatewireSession = (options) => {
 	const [defaultStore] = useState(createMemorySessionStore);
 	const mounted = useContext(SessionStorageContext);
@@ -1002,6 +1057,10 @@ const useStatewireSession = (options) => {
 		};
 		const session = {
 			options,
+			configuredContext: options.context,
+			contexts: new Map(Object.entries(options.context ?? {}).map(([protocol, value]) => [protocol, encodeContext(protocol, value)])),
+			dirtyContexts: new Set(Object.keys(options.context ?? {})),
+			attachContexts: /* @__PURE__ */ new Map(),
 			selection: void 0,
 			record,
 			ctx: {
@@ -1027,6 +1086,7 @@ const useStatewireSession = (options) => {
 			documentStore,
 			shared: store.lock !== void 0 ? {
 				txq: Promise.resolve(),
+				syncQueued: false,
 				parked: [],
 				unsubscribe: null
 			} : false,
@@ -1095,6 +1155,11 @@ const useStatewireSession = (options) => {
 		return session;
 	});
 	if (store.lock !== void 0 !== (s.shared !== false)) throw new Error("statewire: session storage changed sharedness across renders — lock/subscribe must be present from the first render or never");
+	useEffect(() => {
+		if (s.configuredContext === options.context) return;
+		s.configuredContext = options.context;
+		for (const [protocol_0, value_0] of Object.entries(options.context ?? {})) setContext(s, protocol_0, value_0);
+	}, [s, options.context]);
 	s.options = options;
 	s.store = store;
 	s.documentStore = documentStore;
@@ -1118,6 +1183,6 @@ const useStatewireSession = (options) => {
 	return s;
 };
 //#endregion
-export { discardFailed, documentSource, failedCommands, invokeProtocol, retryFailed, setTransport, useStatewireSession };
+export { MAX_FAILED_RETAINED, discardFailed, documentSource, failedCommands, invokeProtocol, retryFailed, setContext, setTransport, useStatewireSession };
 
 //# sourceMappingURL=session.js.map