experimental-a2 0.9.0 → 0.11.0

package/dist/client-Bf6uSEAk.js

@@ -0,0 +1,1342 @@
+import { n as validateSync } from "./validate-XKT4FSNn.js";
+import { t as A2Error } from "./errors-DCk6ch5n.js";
+import { a as PRESENCE_TIMINGS, c as STREAM_TIMINGS, h as nullProtoRecord, o as RESERVED_PARTICIPANT_IDS } from "./internal-Dq2qYxou.js";
+import { c as isWireEvent, d as parseSocketFrame, f as presencePatchFromWire, l as isWirePresencePatch, m as presenceSnapshotFromWire, o as eventFromWire, r as errorFromWire, u as isWirePresenceSnapshot } from "./wire-BO5wWCb1.js";
+//#region src/client-errors.ts
+var A2ClientError = class extends A2Error {
+	status;
+	closeCode;
+	closeReason;
+	phase;
+	timeoutMs;
+	constructor(code, message, options) {
+		super(code, message, options);
+		this.name = "A2ClientError";
+		this.status = options?.status;
+		this.closeCode = options?.closeCode;
+		this.closeReason = options?.closeReason;
+		this.phase = options?.phase;
+		this.timeoutMs = options?.timeoutMs;
+	}
+};
+function asClientError(error, options) {
+	if (error instanceof A2ClientError) return error;
+	if (error instanceof A2Error) return new A2ClientError(error.code, error.message, {
+		details: error.details,
+		cause: error
+	});
+	return new A2ClientError(options?.code ?? "UNKNOWN", error instanceof Error ? error.message : "client operation failed", { cause: error });
+}
+//#endregion
+//#region src/client.ts
+/**
+* experimental-a2/client — the framework-agnostic session client.
+*
+* Everything the browser needs to read a session live and push
+* optimistically, with no framework attached: the SSE subscription with
+* frontier resume and reconnection, the optimistic push queue with
+* ack/rollback, and the local fold through the same reducer the server
+* uses. `experimental-a2/react`'s `createReact` is a thin binding over it, and the
+* store contract (`subscribe`/`getSnapshot`) is exactly what
+* `useSyncExternalStore` wants.
+*
+* The client is a replica, never an access path — the routes it talks
+* to authorize every read and write.
+*/
+const PUSH_ATTEMPTS = 3;
+const RETRYABLE_PUSH_CODES = /* @__PURE__ */ new Set([
+	"STORE_UNAVAILABLE",
+	"TIMEOUT",
+	"HTTP_ERROR",
+	"CONNECTION_FAILED",
+	"UNKNOWN"
+]);
+const DEFAULT_GC_TIME_MS = 3e5;
+const DEFAULT_HISTORY_LIMIT = 50;
+const sessionUrl = (url, sessionId) => {
+	const resolved = typeof url === "function" ? url(sessionId) : url;
+	if (typeof resolved !== "string") throw new TypeError("a session URL function must return a string");
+	return resolved;
+};
+const httpError = async (response) => {
+	const error = errorFromWire(await response.json().catch(() => null));
+	return error === null ? new A2ClientError("HTTP_ERROR", `request failed with ${response.status}`, { status: response.status }) : new A2ClientError(error.code, error.message, {
+		details: error.details,
+		status: response.status,
+		cause: error
+	});
+};
+const httpTransport = (routes, fetchImpl, presence) => ({
+	async *connect({ sessionId, startAfter, signal }) {
+		const streamUrl = sessionUrl(routes.stream, sessionId);
+		const res = await fetchImpl(`${streamUrl}${streamUrl.includes("?") ? "&" : "?"}sessionId=${encodeURIComponent(sessionId)}&index=${startAfter}`, {
+			headers: { accept: "text/event-stream" },
+			signal
+		});
+		if (!res.ok) throw await httpError(res);
+		if (!res.body) throw new A2ClientError("UNKNOWN", "stream response has no body", { status: res.status });
+		yield { kind: "ping" };
+		const decoder = new TextDecoder();
+		const reader = res.body.getReader();
+		let buffer = "";
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) return;
+				yield { kind: "ping" };
+				buffer += decoder.decode(value, { stream: true });
+				for (;;) {
+					const boundary = buffer.indexOf("\n\n");
+					if (boundary === -1) break;
+					const frame = buffer.slice(0, boundary);
+					buffer = buffer.slice(boundary + 2);
+					let eventName;
+					const dataLines = [];
+					for (const line of frame.split("\n")) if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+					else if (line.startsWith("event:")) eventName = line.slice(6).trim();
+					const data = dataLines.join("\n");
+					if (!data) continue;
+					if (eventName === void 0) {
+						const parsed = JSON.parse(data);
+						if (isWireEvent(parsed)) yield {
+							kind: "event",
+							event: parsed
+						};
+					} else if (presence && eventName === "presence-snapshot") {
+						const parsed = JSON.parse(data);
+						if (isWirePresenceSnapshot(parsed)) yield {
+							kind: "presence-snapshot",
+							snapshot: parsed
+						};
+					} else if (presence && eventName === "presence") {
+						const parsed = JSON.parse(data);
+						if (isWirePresencePatch(parsed)) yield {
+							kind: "presence",
+							patch: parsed
+						};
+					} else if (eventName === "a2-activity" && (data === "idle" || data === "active")) yield {
+						kind: "activity",
+						idle: data === "idle"
+					};
+				}
+			}
+		} finally {
+			reader.cancel().catch(() => {});
+		}
+	},
+	async push(body) {
+		const res = await fetchImpl(sessionUrl(routes.push, body.sessionId), {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(body)
+		});
+		if (res.ok) {
+			const rows = await res.json();
+			if (!Array.isArray(rows) || !rows.every(isWireEvent)) throw new A2ClientError("STORE_UNAVAILABLE", "push ack was not a list of events");
+			return rows;
+		}
+		throw await httpError(res);
+	},
+	async history({ sessionId, gte, lte }) {
+		const streamUrl = sessionUrl(routes.stream, sessionId);
+		const res = await fetchImpl(`${streamUrl}${streamUrl.includes("?") ? "&" : "?"}sessionId=${encodeURIComponent(sessionId)}&gte=${gte}&lte=${lte}`, { headers: { accept: "application/json" } });
+		if (!res.ok) throw await httpError(res);
+		const rows = await res.json();
+		if (!Array.isArray(rows) || !rows.every(isWireEvent)) throw new A2ClientError("STORE_UNAVAILABLE", "history response was not a list of events");
+		return rows;
+	},
+	sendPresence(envelope) {
+		(async () => {
+			try {
+				await (await fetchImpl(sessionUrl(routes.push, envelope.sessionId), {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify(envelope)
+				})).arrayBuffer();
+			} catch {}
+		})();
+	}
+});
+/** `WebSocket.OPEN` — fixed by the spec, identical in every runtime. */
+const WS_OPEN = 1;
+const webSocketUrl = (value) => {
+	let resolved;
+	if (/^(https?|wss?):\/\//i.test(value)) resolved = new URL(value);
+	else {
+		const base = globalThis.location?.href;
+		if (base === void 0) throw new TypeError(`cannot resolve the relative ws url '${value}' without a browser location — pass an absolute ws:// or wss:// url`);
+		resolved = new URL(value, base);
+	}
+	if (resolved.protocol === "http:") resolved.protocol = "ws:";
+	else if (resolved.protocol === "https:") resolved.protocol = "wss:";
+	return resolved;
+};
+const socketReadyWaiters = () => {
+	const sessions = /* @__PURE__ */ new Map();
+	const notify = (sessionId) => {
+		const waiters = sessions.get(sessionId);
+		if (!waiters) return;
+		sessions.delete(sessionId);
+		for (const waiter of waiters) waiter();
+	};
+	const wait = (sessionId, maxWaitMs) => new Promise((resolve) => {
+		let waiters = sessions.get(sessionId);
+		if (!waiters) {
+			waiters = /* @__PURE__ */ new Set();
+			sessions.set(sessionId, waiters);
+		}
+		let settled = false;
+		const done = () => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			waiters.delete(done);
+			if (waiters.size === 0) sessions.delete(sessionId);
+			resolve();
+		};
+		const timer = setTimeout(done, maxWaitMs);
+		timer.unref?.();
+		waiters.add(done);
+	});
+	return {
+		notify,
+		wait
+	};
+};
+const rejectPendingAcks = (pending) => {
+	if (pending.size === 0) return;
+	const error = new A2ClientError("STORE_UNAVAILABLE", "socket closed with the ack outstanding");
+	for (const waiter of pending.values()) waiter.reject(error);
+	pending.clear();
+};
+const sessionWsTransport = (url, webSocketImpl, presence) => {
+	const connections = /* @__PURE__ */ new Map();
+	const ready = socketReadyWaiters();
+	let nextReq = 1;
+	const socketUrl = (sessionId, startAfter) => {
+		const resolved = webSocketUrl(sessionUrl(url, sessionId));
+		resolved.searchParams.set("sessionId", sessionId);
+		resolved.searchParams.set("index", String(startAfter));
+		return resolved.href;
+	};
+	return {
+		async *connect({ sessionId, startAfter, signal }) {
+			if (webSocketImpl === void 0) throw new TypeError("no WebSocket implementation available — pass one via createClient({ webSocket }) where the global is missing");
+			const socket = new webSocketImpl(socketUrl(sessionId, startAfter));
+			const connection = {
+				socket,
+				pending: /* @__PURE__ */ new Map()
+			};
+			connections.set(sessionId, connection);
+			const queue = [];
+			let ended = false;
+			let failure = null;
+			let wake = null;
+			const notify = () => {
+				wake?.();
+				wake = null;
+			};
+			const finish = (error) => {
+				if (ended) return;
+				ended = true;
+				failure = error;
+				if (connections.get(sessionId) === connection) connections.delete(sessionId);
+				rejectPendingAcks(connection.pending);
+				notify();
+			};
+			socket.addEventListener("open", () => {
+				if (connections.get(sessionId) !== connection || ended) return;
+				queue.push({ kind: "ping" });
+				notify();
+				ready.notify(sessionId);
+			});
+			socket.addEventListener("message", (event) => {
+				if (connections.get(sessionId) !== connection || ended) return;
+				if (typeof event.data !== "string") return;
+				const frame = parseSocketFrame(event.data);
+				if (frame === null) return;
+				switch (frame.kind) {
+					case "ack": {
+						const waiter = connection.pending.get(frame.req);
+						if (waiter === void 0) return;
+						connection.pending.delete(frame.req);
+						if (frame.sessionId !== void 0 || "events" in frame && frame.events.some((row) => row.sessionId !== sessionId)) {
+							waiter.reject(new A2ClientError("STORE_UNAVAILABLE", "ack does not belong to the socket session"));
+							return;
+						}
+						if ("events" in frame) waiter.resolve(frame.events);
+						else waiter.reject(asClientError(frame.error));
+						return;
+					}
+					case "event":
+						if (frame.event.sessionId !== sessionId) return;
+						queue.push({
+							kind: "event",
+							event: frame.event
+						});
+						break;
+					case "presence":
+						if (presence && frame.sessionId === void 0) queue.push({
+							kind: "presence",
+							patch: frame.patch
+						});
+						break;
+					case "presence-snapshot":
+						if (presence && frame.sessionId === void 0) queue.push({
+							kind: "presence-snapshot",
+							snapshot: frame.snapshot
+						});
+						break;
+					case "ping":
+						queue.push(frame);
+						break;
+					case "subscribed":
+					case "unsubscribed": return;
+				}
+				notify();
+			});
+			socket.addEventListener("close", (event) => {
+				finish(event.code === 1e3 ? null : new A2ClientError("CONNECTION_FAILED", `socket closed (${event.code}${event.reason ? `: ${event.reason}` : ""})`, {
+					closeCode: event.code,
+					closeReason: event.reason
+				}));
+			});
+			socket.addEventListener("error", () => {
+				finish(new A2ClientError("CONNECTION_FAILED", "socket error"));
+			});
+			const onAbort = () => {
+				finish(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("stream aborted"));
+				try {
+					socket.close(1e3);
+				} catch {}
+			};
+			if (signal.aborted) onAbort();
+			else signal.addEventListener("abort", onAbort, { once: true });
+			try {
+				for (;;) {
+					while (queue.length > 0) yield queue.shift();
+					if (ended) {
+						if (failure) throw failure;
+						return;
+					}
+					await new Promise((resolve) => {
+						wake = resolve;
+					});
+				}
+			} finally {
+				signal.removeEventListener("abort", onAbort);
+				finish(null);
+				try {
+					socket.close(1e3);
+				} catch {}
+			}
+		},
+		async push(body) {
+			const connection = connections.get(body.sessionId);
+			if (connection === void 0 || connection.socket.readyState !== WS_OPEN) throw new A2ClientError("STORE_UNAVAILABLE", "no open socket for the session");
+			const req = nextReq;
+			nextReq += 1;
+			return await new Promise((resolve, reject) => {
+				connection.pending.set(req, {
+					resolve,
+					reject
+				});
+				const frame = {
+					kind: "push",
+					req,
+					events: body.events
+				};
+				try {
+					connection.socket.send(JSON.stringify(frame));
+				} catch (cause) {
+					connection.pending.delete(req);
+					reject(new A2ClientError("STORE_UNAVAILABLE", "socket send failed", { cause }));
+				}
+			});
+		},
+		awaitReady(sessionId, maxWaitMs) {
+			if (connections.get(sessionId)?.socket.readyState === WS_OPEN) return Promise.resolve();
+			return ready.wait(sessionId, maxWaitMs);
+		},
+		sendPresence(envelope) {
+			const connection = connections.get(envelope.sessionId);
+			if (connection === void 0 || connection.socket.readyState !== WS_OPEN) return;
+			const frame = {
+				kind: "presence",
+				...envelope.presence
+			};
+			try {
+				connection.socket.send(JSON.stringify(frame));
+			} catch {
+				return;
+			}
+		}
+	};
+};
+const wakeChannel = (channel) => {
+	channel.wake?.();
+	channel.wake = null;
+};
+const subscribeFrame = (sessions) => {
+	return JSON.stringify({
+		kind: "subscribe",
+		sessions
+	});
+};
+const multiplexedWsTransport = (url, webSocketImpl, presence) => {
+	const channels = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	/** Push retries parked in `awaitReady`, flushed per session on its
+	* subscribe confirmation. */
+	const ready = socketReadyWaiters();
+	let socket = null;
+	let socketOpen = false;
+	let watchdog;
+	let nextReq = 1;
+	const trySend = (data) => {
+		if (socket === null || !socketOpen) return;
+		try {
+			socket.send(data);
+		} catch {}
+	};
+	const deliver = (channel, frame) => {
+		channel.queue.push(frame);
+		wakeChannel(channel);
+	};
+	const settleChannel = (channel, failure) => {
+		if (channel.ended) return;
+		channel.ended = true;
+		channel.failure = failure;
+		wakeChannel(channel);
+	};
+	const releaseSocket = () => {
+		const current = socket;
+		socket = null;
+		socketOpen = false;
+		clearTimeout(watchdog);
+		watchdog = void 0;
+		rejectPendingAcks(pending);
+		return current;
+	};
+	const failSocket = (failure) => {
+		const current = releaseSocket();
+		for (const channel of channels.values()) settleChannel(channel, failure);
+		try {
+			current?.close(1e3);
+		} catch {}
+	};
+	const detach = (channel) => {
+		if (channels.get(channel.sessionId) !== channel) return;
+		channels.delete(channel.sessionId);
+		if (!channel.dropped) {
+			const frame = {
+				kind: "unsubscribe",
+				sessions: [channel.sessionId]
+			};
+			trySend(JSON.stringify(frame));
+		}
+		if (channels.size === 0) {
+			const current = releaseSocket();
+			try {
+				current?.close(1e3);
+			} catch {}
+		}
+	};
+	const armWatchdog = (created) => {
+		clearTimeout(watchdog);
+		watchdog = setTimeout(() => {
+			if (socket !== created) return;
+			failSocket(new A2ClientError("TIMEOUT", `socket stalled: no data for ${STREAM_TIMINGS.stallTimeoutMs}ms`, {
+				phase: "stream",
+				timeoutMs: STREAM_TIMINGS.stallTimeoutMs
+			}));
+		}, STREAM_TIMINGS.stallTimeoutMs);
+		watchdog.unref?.();
+	};
+	const route = (frame) => {
+		switch (frame.kind) {
+			case "ping":
+				for (const channel of channels.values()) if (channel.live && !channel.ended) deliver(channel, { kind: "ping" });
+				return;
+			case "subscribed": {
+				const channel = channels.get(frame.sessionId);
+				if (channel === void 0 || channel.ended || channel.live) return;
+				channel.live = true;
+				deliver(channel, { kind: "ping" });
+				ready.notify(frame.sessionId);
+				return;
+			}
+			case "unsubscribed": {
+				const channel = channels.get(frame.sessionId);
+				if (channel === void 0) return;
+				channel.dropped = true;
+				settleChannel(channel, frame.error ? asClientError(frame.error) : frame.reason === void 0 ? null : new A2ClientError("CONNECTION_FAILED", frame.reason));
+				return;
+			}
+			case "ack": {
+				const waiter = pending.get(frame.req);
+				if (waiter === void 0) return;
+				pending.delete(frame.req);
+				if ("events" in frame) waiter.resolve(frame.events);
+				else waiter.reject(asClientError(frame.error));
+				return;
+			}
+			case "event": {
+				const channel = channels.get(frame.event.sessionId);
+				if (channel !== void 0 && channel.live && !channel.ended) deliver(channel, {
+					kind: "event",
+					event: frame.event
+				});
+				return;
+			}
+			case "presence": {
+				if (!presence || frame.sessionId === void 0) return;
+				const channel = channels.get(frame.sessionId);
+				if (channel !== void 0 && channel.live && !channel.ended) deliver(channel, {
+					kind: "presence",
+					patch: frame.patch
+				});
+				return;
+			}
+			case "presence-snapshot": {
+				if (!presence || frame.sessionId === void 0) return;
+				const channel = channels.get(frame.sessionId);
+				if (channel !== void 0 && channel.live && !channel.ended) deliver(channel, {
+					kind: "presence-snapshot",
+					snapshot: frame.snapshot
+				});
+				return;
+			}
+		}
+	};
+	const ensureSocket = () => {
+		if (socket !== null) return;
+		if (webSocketImpl === void 0) throw new TypeError("no WebSocket implementation available — pass one via createClient({ webSocket }) where the global is missing");
+		const created = new webSocketImpl(webSocketUrl(url).href);
+		socket = created;
+		socketOpen = false;
+		armWatchdog(created);
+		created.addEventListener("open", () => {
+			if (socket !== created) return;
+			socketOpen = true;
+			armWatchdog(created);
+			const sessions = [...channels.values()].filter((channel) => !channel.ended).map((channel) => ({
+				id: channel.sessionId,
+				index: channel.startAfter
+			}));
+			if (sessions.length > 0) trySend(subscribeFrame(sessions));
+		});
+		created.addEventListener("message", (event) => {
+			if (socket !== created) return;
+			if (typeof event.data !== "string") return;
+			armWatchdog(created);
+			const frame = parseSocketFrame(event.data);
+			if (frame === null) return;
+			route(frame);
+		});
+		created.addEventListener("close", (event) => {
+			if (socket !== created) return;
+			failSocket(event.code === 1e3 ? null : new A2ClientError("CONNECTION_FAILED", `socket closed (${event.code}${event.reason ? `: ${event.reason}` : ""})`, {
+				closeCode: event.code,
+				closeReason: event.reason
+			}));
+		});
+		created.addEventListener("error", () => {
+			if (socket !== created) return;
+			failSocket(new A2ClientError("CONNECTION_FAILED", "socket error"));
+		});
+	};
+	return {
+		async *connect({ sessionId, startAfter, signal }) {
+			const channel = {
+				sessionId,
+				startAfter,
+				queue: [],
+				live: false,
+				dropped: false,
+				ended: false,
+				failure: null,
+				wake: null
+			};
+			channels.set(sessionId, channel);
+			try {
+				ensureSocket();
+				if (socketOpen) trySend(subscribeFrame([{
+					id: sessionId,
+					index: startAfter
+				}]));
+			} catch (error) {
+				if (channels.get(sessionId) === channel) channels.delete(sessionId);
+				throw error;
+			}
+			const onAbort = () => {
+				settleChannel(channel, signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("stream aborted"));
+				detach(channel);
+			};
+			if (signal.aborted) onAbort();
+			else signal.addEventListener("abort", onAbort, { once: true });
+			const pendingSubscribe = setTimeout(() => {
+				if (channel.live) return;
+				settleChannel(channel, new A2ClientError("TIMEOUT", "subscribe not confirmed: is the ws route calling server.fetch with upgradeWebSocket?", {
+					phase: "subscribe",
+					timeoutMs: STREAM_TIMINGS.stallTimeoutMs
+				}));
+			}, STREAM_TIMINGS.stallTimeoutMs);
+			pendingSubscribe.unref?.();
+			try {
+				for (;;) {
+					while (channel.queue.length > 0) yield channel.queue.shift();
+					if (channel.ended) {
+						if (channel.failure) throw channel.failure;
+						return;
+					}
+					await new Promise((resolve) => {
+						channel.wake = resolve;
+					});
+				}
+			} finally {
+				clearTimeout(pendingSubscribe);
+				signal.removeEventListener("abort", onAbort);
+				settleChannel(channel, null);
+				detach(channel);
+			}
+		},
+		async push(body) {
+			const channel = channels.get(body.sessionId);
+			const target = socket;
+			if (channel === void 0 || !channel.live || channel.ended || target === null || !socketOpen || target.readyState !== WS_OPEN) throw new A2ClientError("STORE_UNAVAILABLE", "no open socket for the session");
+			const req = nextReq;
+			nextReq += 1;
+			return await new Promise((resolve, reject) => {
+				pending.set(req, {
+					resolve,
+					reject
+				});
+				const frame = {
+					kind: "push",
+					req,
+					sessionId: body.sessionId,
+					events: body.events
+				};
+				try {
+					target.send(JSON.stringify(frame));
+				} catch (cause) {
+					pending.delete(req);
+					reject(new A2ClientError("STORE_UNAVAILABLE", "socket send failed", { cause }));
+				}
+			});
+		},
+		awaitReady(sessionId, maxWaitMs) {
+			const channel = channels.get(sessionId);
+			if (channel !== void 0 && channel.live && !channel.ended && socketOpen) return Promise.resolve();
+			return ready.wait(sessionId, maxWaitMs);
+		},
+		sendPresence(envelope) {
+			const channel = channels.get(envelope.sessionId);
+			if (channel === void 0 || !channel.live || channel.ended) return;
+			const frame = {
+				kind: "presence",
+				sessionId: envelope.sessionId,
+				...envelope.presence
+			};
+			trySend(JSON.stringify(frame));
+		}
+	};
+};
+const transportFor = (api, fetchImpl, webSocketImpl, presence) => {
+	if (typeof api === "string" || typeof api === "function") return httpTransport({
+		push: api,
+		stream: api
+	}, fetchImpl, presence);
+	if (api.type === "http") return httpTransport({
+		push: api.push,
+		stream: api.stream
+	}, fetchImpl, presence);
+	if (api.multiplex === true) {
+		if (typeof api.url !== "string") throw new TypeError("a multiplexed WebSocket URL must be a string");
+		return multiplexedWsTransport(api.url, webSocketImpl, presence);
+	}
+	return sessionWsTransport(api.url, webSocketImpl, presence);
+};
+function createClient(options) {
+	const { reducer, api } = options;
+	const presenceDefs = reducer.presence;
+	const declaresPresence = Object.keys(presenceDefs).length > 0;
+	const fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+	const clientFetch = async (input, init) => {
+		try {
+			return await fetchImpl(input, init);
+		} catch (error) {
+			throw asClientError(error, { code: "CONNECTION_FAILED" });
+		}
+	};
+	const webSocketImpl = options.webSocket ?? globalThis.WebSocket;
+	const transport = transportFor(api, clientFetch, webSocketImpl, declaresPresence);
+	const gcTime = options.gcTime ?? DEFAULT_GC_TIME_MS;
+	if (Number.isNaN(gcTime) || gcTime < 0) throw new RangeError("gcTime must be a non-negative number or Infinity");
+	const sessions = /* @__PURE__ */ new Map();
+	const scheduleGc = (sessionId, delay = gcTime) => {
+		const entry = sessions.get(sessionId);
+		if (!entry) return;
+		clearTimeout(entry.timer);
+		if (gcTime === Infinity) return;
+		entry.timer = setTimeout(() => {
+			if (sessions.get(sessionId) !== entry) return;
+			if (entry.runtime.canEvict()) {
+				sessions.delete(sessionId);
+				return;
+			}
+			scheduleGc(sessionId, Math.max(gcTime, 1e3));
+		}, delay);
+		entry.timer.unref?.();
+	};
+	const touch = (sessionId) => {
+		scheduleGc(sessionId);
+	};
+	const makeSession = (sessionId, sessionOptions) => {
+		let stateIndex = sessionOptions?.initialIndex ?? 0;
+		let streamIndex = sessionOptions?.initialState === void 0 ? sessionOptions?.initialIndex : stateIndex;
+		let foldedState = sessionOptions?.initialState !== void 0 ? sessionOptions.initialState : reducer.initialState;
+		const serverEvents = (sessionOptions?.initialEvents ?? []).filter((event) => event.index <= stateIndex).toSorted((a, b) => a.index - b.index);
+		let pending = [];
+		let participant = sessionOptions?.participant ?? options.participant;
+		let presenceState = nullProtoRecord();
+		let presenceLastSentAt = 0;
+		/** The last LWW stamp issued — see `nextPresenceAt`. */
+		let presenceLastAt = 0;
+		/** Values awaiting the trailing send — non-null exactly while
+		* `presenceTimer` is armed. */
+		let presenceBuffer = null;
+		let presenceTimer;
+		/** Own fields set while the stream was down — re-sent once on
+		* reconnect (their POSTs may have been lost with the network). */
+		let presenceResend = null;
+		const listeners = /* @__PURE__ */ new Set();
+		let snapshot = null;
+		let status = "idle";
+		let reconnects = 0;
+		let lastError = null;
+		let inFlightPushes = 0;
+		let pushWireTail = Promise.resolve();
+		let deferredHydration;
+		let hydrationNotification;
+		const emit = () => {
+			for (const listener of [...listeners]) listener();
+		};
+		const notify = () => {
+			snapshot = null;
+			emit();
+		};
+		const notifyHydrated = () => {
+			snapshot = null;
+			clearTimeout(hydrationNotification);
+			hydrationNotification = setTimeout(emit, 0);
+			hydrationNotification.unref?.();
+		};
+		const mergeServerEvents = (events, throughIndex) => {
+			if (!events || events.length === 0) return false;
+			const byIndex = new Map(serverEvents.map((event) => [event.index, event]));
+			let changed = false;
+			for (const event of events) {
+				if (event.index > throughIndex) continue;
+				if (byIndex.get(event.index)?.id === event.id) continue;
+				byIndex.set(event.index, event);
+				changed = true;
+			}
+			if (!changed) return false;
+			serverEvents.splice(0, serverEvents.length, ...[...byIndex.values()].toSorted((a, b) => a.index - b.index));
+			return true;
+		};
+		const overlayEvents = () => {
+			const acked = pending.filter((p) => p.acked).map((p) => p.acked).toSorted((a, b) => a.index - b.index);
+			const maxKnown = acked.at(-1)?.index ?? stateIndex;
+			const unacked = pending.filter((p) => !p.acked).map((p, i) => ({
+				id: p.id,
+				type: p.type,
+				payload: p.payload,
+				index: maxKnown + 1 + i,
+				sessionId,
+				createdAt: p.createdAt
+			}));
+			return [...acked, ...unacked];
+		};
+		const connection = () => {
+			switch (status) {
+				case "idle": return { status: "idle" };
+				case "closed": return { status: "closed" };
+				case "live": return {
+					status: "live",
+					reconnects
+				};
+				case "connecting":
+				case "paused": return {
+					status,
+					reconnects,
+					error: lastError
+				};
+			}
+		};
+		const historyState = () => {
+			const oldestLoaded = serverEvents[0]?.index ?? null;
+			return {
+				loading: historyLoads > 0,
+				complete: oldestLoaded === 1 || stateIndex === 0,
+				oldestLoaded
+			};
+		};
+		const buildSnapshot = () => {
+			const overlay = overlayEvents();
+			let state = foldedState;
+			for (const event of overlay) state = reducer.fold(state, event);
+			return {
+				state,
+				events: [...serverEvents, ...overlay],
+				index: stateIndex,
+				history: historyState(),
+				connection: connection(),
+				...declaresPresence ? { presence: presenceState } : {}
+			};
+		};
+		/**
+		* The per-session monotonic LWW stamp: wall-seeded, guarded
+		* `max(now, last + 1)`, so overlapping sends can never invert —
+		* the wall clock seeds it because it is the only monotonic state
+		* that survives a reload without A2 owning persistence.
+		*/
+		const nextPresenceAt = () => {
+			presenceLastAt = Math.max(Date.now(), presenceLastAt + 1);
+			return presenceLastAt;
+		};
+		const applyPresencePatch = (patch) => {
+			if (patch.participant === participant) return;
+			const entry = Object.assign(nullProtoRecord(), presenceState[patch.participant]);
+			let changed = false;
+			for (const [field, value] of Object.entries(patch.values)) {
+				if (value === void 0) continue;
+				const existing = entry[field];
+				if (existing && existing.at.getTime() > patch.at.getTime()) continue;
+				if (value === null) {
+					if (existing) {
+						delete entry[field];
+						changed = true;
+					}
+				} else {
+					entry[field] = {
+						value,
+						seen: patch.seen,
+						at: patch.at
+					};
+					changed = true;
+				}
+			}
+			if (!changed) return;
+			const next = Object.assign(nullProtoRecord(), presenceState);
+			if (Object.keys(entry).length === 0) delete next[patch.participant];
+			else next[patch.participant] = entry;
+			presenceState = next;
+			notify();
+		};
+		const applyPresenceSnapshot = (incoming) => {
+			const next = nullProtoRecord();
+			for (const [id, fields] of Object.entries(incoming)) {
+				if (id === participant) continue;
+				next[id] = fields;
+			}
+			const own = participant === void 0 ? void 0 : presenceState[participant];
+			if (participant !== void 0 && own !== void 0) next[participant] = own;
+			presenceState = next;
+			notify();
+		};
+		const echoPresence = (id, values, atMs) => {
+			const entry = Object.assign(nullProtoRecord(), presenceState[id]);
+			const at = new Date(atMs);
+			for (const [field, value] of Object.entries(values)) if (value === null) delete entry[field];
+			else entry[field] = {
+				value,
+				seen: stateIndex,
+				at
+			};
+			const next = Object.assign(nullProtoRecord(), presenceState);
+			if (Object.keys(entry).length === 0) delete next[id];
+			else next[id] = entry;
+			presenceState = next;
+			notify();
+		};
+		const sendPresence = (values, at) => {
+			presenceLastSentAt = Date.now();
+			transport.sendPresence({
+				sessionId,
+				presence: {
+					participant,
+					values,
+					seen: stateIndex,
+					at
+				}
+			});
+			touch(sessionId);
+		};
+		const queuePresenceSend = (values, at) => {
+			if (presenceTimer !== void 0) {
+				presenceBuffer = {
+					...presenceBuffer,
+					...values
+				};
+				return;
+			}
+			const wait = presenceLastSentAt + PRESENCE_TIMINGS.sendIntervalMs - Date.now();
+			if (wait <= 0) {
+				sendPresence(values, at ?? nextPresenceAt());
+				return;
+			}
+			presenceBuffer = {
+				...presenceBuffer,
+				...values
+			};
+			presenceTimer = setTimeout(() => {
+				presenceTimer = void 0;
+				const buffered = presenceBuffer;
+				presenceBuffer = null;
+				if (buffered) sendPresence(buffered, nextPresenceAt());
+			}, wait);
+			presenceTimer.unref?.();
+		};
+		const setPresence = (values) => {
+			if (participant === void 0) throw new TypeError("setPresence requires a participant — pass one to createClient({ participant }) or in the session options (the SessionProvider/useSession participant prop)");
+			const validated = nullProtoRecord();
+			for (const [field, value] of Object.entries(values)) {
+				if (value === void 0) continue;
+				const schema = Object.hasOwn(presenceDefs, field) ? presenceDefs[field] : RESERVED_PARTICIPANT_IDS.has(field) ? void 0 : presenceDefs["*"];
+				if (!schema) throw new A2ClientError("UNKNOWN_PRESENCE_FIELD", `no presence field '${field}' in the reducer's vocabulary`);
+				if (value === null) {
+					validated[field] = null;
+					continue;
+				}
+				const result = validateSync(schema, value, `presence field '${field}'`);
+				if (result.issues) throw new A2ClientError("INVALID_PAYLOAD", `invalid value for presence field '${field}'`, { details: result.issues });
+				validated[field] = result.value;
+			}
+			if (Object.keys(validated).length === 0) return;
+			const at = nextPresenceAt();
+			echoPresence(participant, validated, at);
+			if (status !== "live") presenceResend = {
+				...presenceResend,
+				...validated
+			};
+			queuePresenceSend(validated, at);
+			touch(sessionId);
+		};
+		/** Pushes awaiting stream confirmation — resolved by `ingest` the
+		* moment the state index passes their batch. */
+		let confirmWatchers = [];
+		/** The single ingest point: every server-confirmed event, in log
+		* order, from the stream. */
+		const ingest = (event) => {
+			if (event.index <= (streamIndex ?? 0)) return;
+			streamIndex = event.index;
+			if (event.index > stateIndex) {
+				stateIndex = event.index;
+				serverEvents.push(event);
+				foldedState = reducer.fold(foldedState, event);
+			} else mergeServerEvents([event], stateIndex);
+			pending = pending.filter((p) => p.id !== event.id);
+			if (confirmWatchers.some((w) => w.index <= stateIndex)) {
+				const due = confirmWatchers.filter((w) => w.index <= stateIndex);
+				confirmWatchers = confirmWatchers.filter((w) => w.index > stateIndex);
+				for (const watcher of due) watcher.resolve();
+			}
+			notify();
+			touch(sessionId);
+		};
+		const validated = (events) => events.map((event) => {
+			const schema = Object.hasOwn(reducer.events, event.type) ? reducer.events[event.type] : void 0;
+			if (!schema) throw new A2ClientError("UNKNOWN_EVENT_TYPE", `no event type '${String(event.type)}' in the reducer's vocabulary`);
+			const result = validateSync(schema, event.payload, `event '${String(event.type)}'`);
+			if (result.issues) throw new A2ClientError("INVALID_PAYLOAD", `invalid payload for event '${String(event.type)}'`, { details: result.issues });
+			return {
+				id: event.id ?? crypto.randomUUID(),
+				type: event.type,
+				payload: result.value
+			};
+		});
+		const post = async (body) => {
+			let lastPushError = new A2ClientError("STORE_UNAVAILABLE", "push failed");
+			for (let attempt = 1; attempt <= PUSH_ATTEMPTS; attempt += 1) {
+				try {
+					return (await transport.push(body)).map((row) => eventFromWire(row));
+				} catch (err) {
+					lastPushError = asClientError(err);
+				}
+				if (!RETRYABLE_PUSH_CODES.has(lastPushError.code)) throw lastPushError;
+				if (attempt < PUSH_ATTEMPTS) {
+					const sleepMs = 250 * attempt;
+					await Promise.all([new Promise((resolve) => setTimeout(resolve, sleepMs)), transport.awaitReady?.(sessionId, sleepMs + STREAM_TIMINGS.reconnectBaseMs * attempt)]);
+				}
+			}
+			throw lastPushError;
+		};
+		/**
+		* Decorate the ack promise into a PushResult. `confirmed` is a
+		* lazy getter — materialized on first access, so callers that
+		* ignore it can't leak an unhandled rejection.
+		*/
+		const withConfirmed = (ack) => {
+			let confirmed;
+			return Object.defineProperty(ack, "confirmed", { get() {
+				confirmed ??= ack.then((acked) => new Promise((resolve) => {
+					const last = acked.at(-1)?.index ?? 0;
+					if (stateIndex >= last) {
+						resolve(acked);
+						return;
+					}
+					confirmWatchers.push({
+						index: last,
+						resolve: () => resolve(acked)
+					});
+				}));
+				return confirmed;
+			} });
+		};
+		const push = (...events) => {
+			touch(sessionId);
+			return withConfirmed((async () => {
+				if (events.length === 0) throw new TypeError("push requires at least one event");
+				const entries = validated(events).map((e) => ({
+					id: e.id,
+					type: e.type,
+					payload: e.payload,
+					createdAt: /* @__PURE__ */ new Date()
+				}));
+				const waitForPriorPush = pushWireTail;
+				let releasePush;
+				pushWireTail = new Promise((resolve) => {
+					releasePush = resolve;
+				});
+				pending.push(...entries);
+				inFlightPushes += 1;
+				try {
+					refreshIdleStream();
+					notify();
+					await waitForPriorPush;
+					const acked = await post({
+						sessionId,
+						events: entries.map(({ id, type, payload }) => ({
+							id,
+							type,
+							payload
+						}))
+					});
+					for (const event of acked) {
+						const entry = pending.find((p) => p.id === event.id);
+						if (entry) entry.acked = event;
+					}
+					if ((acked.at(-1)?.index ?? 0) > (streamIndex ?? stateIndex)) refreshIdleStream();
+					notify();
+					return acked;
+				} catch (err) {
+					const ids = new Set(entries.map((e) => e.id));
+					pending = pending.filter((p) => !ids.has(p.id));
+					notify();
+					throw err;
+				} finally {
+					releasePush();
+					inFlightPushes -= 1;
+					if (inFlightPushes === 0 && deferredHydration) {
+						const next = deferredHydration;
+						deferredHydration = void 0;
+						runtime.hydrate(next);
+					}
+					touch(sessionId);
+				}
+			})());
+		};
+		let historyLoads = 0;
+		/** Calls chain per session: each resolves its bounds after the
+		* prior call's merge, so overlapping backscrolls page backward
+		* instead of re-fetching the same range. */
+		let historyTail = Promise.resolve();
+		const eventsBetween = (gte, lte) => serverEvents.filter((event) => event.index >= gte && event.index <= lte);
+		/** The narrowest sub-range of [gte, lte] missing from the feed, or
+		* null when the range is fully loaded (nothing to fetch). */
+		const missingBetween = (gte, lte) => {
+			const present = new Set(eventsBetween(gte, lte).map((e) => e.index));
+			let lo = gte;
+			while (lo <= lte && present.has(lo)) lo += 1;
+			if (lo > lte) return null;
+			let hi = lte;
+			while (hi > lo && present.has(hi)) hi -= 1;
+			return {
+				gte: lo,
+				lte: hi
+			};
+		};
+		const loadHistory = (loadOptions) => {
+			const readHistory = transport.history;
+			if (readHistory === void 0) throw new TypeError("loadHistory requires an http api — the ws transport has no history lane; serve the session with server.fetch and pass its route url as the string or { type: \"http\" } api");
+			const before = loadOptions?.before;
+			const limit = loadOptions?.limit;
+			if (before !== void 0 && (!Number.isSafeInteger(before) || before < 1)) throw new TypeError("loadHistory before must be a positive safe integer");
+			if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 1)) throw new TypeError("loadHistory limit must be a positive safe integer");
+			touch(sessionId);
+			const run = historyTail.then(async () => {
+				const upper = before ?? serverEvents[0]?.index ?? stateIndex + 1;
+				const lte = Math.min(upper - 1, stateIndex);
+				const gte = Math.max(1, upper - (limit ?? DEFAULT_HISTORY_LIMIT));
+				if (gte > lte) return [];
+				const missing = missingBetween(gte, lte);
+				if (missing === null) return eventsBetween(gte, lte);
+				historyLoads += 1;
+				notify();
+				try {
+					const rows = await readHistory({
+						sessionId,
+						...missing
+					});
+					mergeServerEvents(rows.map((row) => eventFromWire(row)), stateIndex);
+					return eventsBetween(gte, lte);
+				} catch (error) {
+					throw asClientError(error);
+				} finally {
+					historyLoads -= 1;
+					notify();
+					touch(sessionId);
+				}
+			});
+			historyTail = run.catch(() => {});
+			return run;
+		};
+		let generation = 0;
+		let active = false;
+		let streamIdle = false;
+		let abort = null;
+		let leases = 0;
+		let leaseEpoch = 0;
+		const stopStream = () => {
+			touch(sessionId);
+			if (!active) return;
+			active = false;
+			streamIdle = false;
+			generation += 1;
+			abort?.abort();
+			abort = null;
+			clearTimeout(presenceTimer);
+			presenceTimer = void 0;
+			presenceBuffer = null;
+			status = "closed";
+			notify();
+		};
+		const runStream = async (run) => {
+			let backoff = STREAM_TIMINGS.reconnectBaseMs;
+			let attempt = 0;
+			while (generation === run) {
+				streamIdle = false;
+				const controller = new AbortController();
+				abort = controller;
+				let stall;
+				let stalled = false;
+				const armStall = () => {
+					clearTimeout(stall);
+					stall = setTimeout(() => {
+						stalled = true;
+						controller.abort();
+					}, STREAM_TIMINGS.stallTimeoutMs);
+					stall.unref?.();
+				};
+				let wasLive = false;
+				try {
+					const frames = transport.connect({
+						sessionId,
+						startAfter: streamIndex ??= stateIndex,
+						signal: controller.signal
+					});
+					for await (const frame of frames) {
+						if (generation !== run) break;
+						armStall();
+						if (!wasLive) {
+							backoff = STREAM_TIMINGS.reconnectBaseMs;
+							attempt = 0;
+							wasLive = true;
+							status = "live";
+							lastError = null;
+							notify();
+							if (generation !== run) break;
+							if (presenceResend) {
+								const values = presenceResend;
+								presenceResend = null;
+								queuePresenceSend(values);
+							}
+						}
+						if (frame.kind === "event") {
+							streamIdle = false;
+							ingest(eventFromWire(frame.event));
+						} else if (frame.kind === "activity") {
+							streamIdle = frame.idle;
+							if (streamIdle && (inFlightPushes > 0 || pending.some((entry) => (entry.acked?.index ?? 0) > (streamIndex ?? stateIndex)))) refreshIdleStream();
+						} else if (frame.kind === "presence") applyPresencePatch(presencePatchFromWire(frame.patch));
+						else if (frame.kind === "presence-snapshot") applyPresenceSnapshot(presenceSnapshotFromWire(frame.snapshot).snapshot);
+					}
+					if (generation === run) lastError = null;
+				} catch (err) {
+					if (generation === run) lastError = stalled ? new A2ClientError("TIMEOUT", `stream stalled: no data for ${STREAM_TIMINGS.stallTimeoutMs}ms`, {
+						phase: "stream",
+						timeoutMs: STREAM_TIMINGS.stallTimeoutMs
+					}) : asClientError(err);
+				} finally {
+					clearTimeout(stall);
+				}
+				if (generation !== run) break;
+				streamIdle = false;
+				if (wasLive) reconnects += 1;
+				attempt += 1;
+				let delay;
+				try {
+					delay = options.reconnect ? options.reconnect({
+						sessionId,
+						error: lastError,
+						attempt
+					}) : backoff;
+					if (delay !== false && (!Number.isFinite(delay) || delay < 0 || delay > 2147483647)) throw new RangeError("reconnect must return false or a delay from 0 to 2147483647 ms");
+				} catch (error) {
+					if (generation !== run) break;
+					lastError = asClientError(error);
+					delay = false;
+				}
+				if (generation !== run) break;
+				if (delay === false) {
+					abort = null;
+					status = "paused";
+					notify();
+					return;
+				}
+				const waiting = new AbortController();
+				abort = waiting;
+				status = "connecting";
+				notify();
+				if (generation !== run) break;
+				await new Promise((resolve) => {
+					let settled = false;
+					const finish = () => {
+						if (settled) return;
+						settled = true;
+						clearTimeout(timer);
+						waiting.signal.removeEventListener("abort", finish);
+						resolve();
+					};
+					const timer = setTimeout(finish, delay);
+					timer.unref?.();
+					if (waiting.signal.aborted) finish();
+					else waiting.signal.addEventListener("abort", finish, { once: true });
+				});
+				backoff = Math.min(backoff * 2, STREAM_TIMINGS.reconnectMaxMs);
+			}
+		};
+		const refreshIdleStream = () => {
+			if (streamIdle && status !== "paused") reconnectStream();
+		};
+		const reconnectStream = () => {
+			touch(sessionId);
+			if (!active) return;
+			streamIdle = false;
+			generation += 1;
+			const run = generation;
+			const previous = abort;
+			abort = null;
+			reconnects += 1;
+			status = "connecting";
+			lastError = null;
+			notify();
+			if (active && generation === run) runStream(run);
+			previous?.abort();
+		};
+		const runtime = {
+			sessionId,
+			...declaresPresence ? { setPresence } : {},
+			subscribe(listener) {
+				touch(sessionId);
+				listeners.add(listener);
+				return () => {
+					listeners.delete(listener);
+					touch(sessionId);
+				};
+			},
+			getSnapshot() {
+				snapshot ??= buildSnapshot();
+				return snapshot;
+			},
+			push,
+			loadHistory,
+			reconnect: reconnectStream,
+			connect() {
+				touch(sessionId);
+				leases += 1;
+				const epoch = leaseEpoch;
+				if (!active) {
+					active = true;
+					status = "connecting";
+					lastError = null;
+					const run = generation;
+					notify();
+					if (active && generation === run) runStream(run);
+				}
+				let released = false;
+				return () => {
+					if (released || leaseEpoch !== epoch) return;
+					released = true;
+					touch(sessionId);
+					leases -= 1;
+					if (leases === 0) stopStream();
+				};
+			},
+			close() {
+				leases = 0;
+				leaseEpoch += 1;
+				stopStream();
+			},
+			hydrate(next) {
+				touch(sessionId);
+				if (!next) return;
+				participant ??= next.participant;
+				const nextIndex = next.initialIndex ?? 0;
+				if (nextIndex > stateIndex && inFlightPushes > 0) {
+					if (!deferredHydration || nextIndex > (deferredHydration.initialIndex ?? 0)) deferredHydration = next;
+					return;
+				}
+				const historyChanged = mergeServerEvents(next.initialEvents, Math.min(nextIndex, stateIndex));
+				if (next.initialState !== void 0) streamIndex ??= nextIndex;
+				if (next.initialState === void 0 || nextIndex <= stateIndex) {
+					if (historyChanged) notifyHydrated();
+					return;
+				}
+				stateIndex = nextIndex;
+				foldedState = next.initialState;
+				mergeServerEvents(next.initialEvents, stateIndex);
+				pending = pending.filter((entry) => !entry.acked || entry.acked.index > stateIndex);
+				if (confirmWatchers.some((watcher) => watcher.index <= stateIndex)) {
+					const due = confirmWatchers.filter((watcher) => watcher.index <= stateIndex);
+					confirmWatchers = confirmWatchers.filter((watcher) => watcher.index > stateIndex);
+					for (const watcher of due) watcher.resolve();
+				}
+				notifyHydrated();
+			},
+			canEvict() {
+				return listeners.size === 0 && !active && inFlightPushes === 0 && historyLoads === 0 && confirmWatchers.length === 0 && presenceTimer === void 0;
+			}
+		};
+		return runtime;
+	};
+	return { session(sessionId, sessionOptions) {
+		const existing = sessions.get(sessionId);
+		if (existing) {
+			existing.runtime.hydrate(sessionOptions);
+			touch(sessionId);
+			return existing.runtime;
+		}
+		const runtime = makeSession(sessionId, sessionOptions);
+		sessions.set(sessionId, { runtime });
+		touch(sessionId);
+		return runtime;
+	} };
+}
+//#endregion
+export { A2ClientError as n, createClient as t };
+
+//# sourceMappingURL=client-Bf6uSEAk.js.map