react-websocket 3.2.0 → 3.5.0

package/dist/core.js

@@ -1,751 +1,1173 @@
-// src/types.ts
+//#region src/types.ts
+/**
+* Reported via the `error` event (and `onError`) when an incoming message can't be
+* decoded by `parse`/`json` or fails `schema` validation. The message is not delivered.
+*
+* @example
+* ```ts
+* onError(error) {
+*   if (error instanceof MessageError) report(error.data, error.issues);
+* }
+* ```
+*/
 var MessageError = class extends Error {
-  /** The raw `event.data` that failed. */
-  data;
-  /** Schema validation issues, when the message failed `schema`. */
-  issues;
-  constructor(message, data, options) {
-    super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
-    this.name = "MessageError";
-    this.data = data;
-    this.issues = options?.issues;
-  }
+	/** The raw `event.data` that failed. */
+	data;
+	/** Schema validation issues, when the message failed `schema`. */
+	issues;
+	constructor(message, data, options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "MessageError";
+		this.data = data;
+		this.issues = options?.issues;
+	}
 };
-
-// src/client.ts
-var OPEN = 1;
-var RECONNECT_DEFAULTS = {
-  maxAttempts: Infinity,
-  minDelay: 1e3,
-  maxDelay: 3e4,
-  factor: 2,
-  jitter: 0.5
+//#endregion
+//#region src/client.ts
+const OPEN = 1;
+const RECONNECT_DEFAULTS = {
+	maxAttempts: Infinity,
+	minDelay: 1e3,
+	maxDelay: 3e4,
+	factor: 2,
+	jitter: .5
 };
+const READY_GRACE = 5e3;
 function createDeferred() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  promise.status = "pending";
-  promise.catch(() => {
-  });
-  const deferred = {
-    promise,
-    settled: false,
-    resolve() {
-      if (deferred.settled) return;
-      deferred.settled = true;
-      promise.status = "fulfilled";
-      promise.value = void 0;
-      resolve();
-    },
-    reject(reason) {
-      if (deferred.settled) return;
-      deferred.settled = true;
-      promise.status = "rejected";
-      promise.reason = reason;
-      reject(reason);
-    }
-  };
-  return deferred;
+	let resolve;
+	let reject;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	promise.status = "pending";
+	promise.catch(() => {});
+	const deferred = {
+		promise,
+		settled: false,
+		resolve() {
+			if (deferred.settled) return;
+			deferred.settled = true;
+			promise.status = "fulfilled";
+			promise.value = void 0;
+			resolve();
+		},
+		reject(reason) {
+			if (deferred.settled) return;
+			deferred.settled = true;
+			promise.status = "rejected";
+			promise.reason = reason;
+			reject(reason);
+		}
+	};
+	return deferred;
 }
 function rethrowAsync(error) {
-  queueMicrotask(() => {
-    throw error;
-  });
+	queueMicrotask(() => {
+		throw error;
+	});
 }
 function isThenable(value) {
-  return typeof value?.then === "function";
+	return typeof value?.then === "function";
 }
-var ON_TEARDOWN = /* @__PURE__ */ Symbol.for("react-websocket.onTeardown");
+/**
+* @internal Option key for a callback run when the client tears down, which lets the hooks'
+* URL registry forget clients nobody holds anymore. A registered symbol rather than an export,
+* because the hooks entry imports the client from the `core` entry at runtime.
+*/
+const ON_TEARDOWN = Symbol.for("react-websocket.onTeardown");
 function createClient(url, options = {}) {
-  const onTeardown = options[ON_TEARDOWN];
-  const log = options.logger ?? (() => {
-  });
-  const retry = options.reconnect === false ? null : {
-    ...RECONNECT_DEFAULTS,
-    ...typeof options.reconnect === "object" ? options.reconnect : {}
-  };
-  const queueLimit = options.queue === false ? 0 : typeof options.queue === "object" ? Math.max(0, options.queue.limit ?? Infinity) : Infinity;
-  let snapshot = { status: "idle", lastMessage: void 0, attempt: 0 };
-  const storeListeners = /* @__PURE__ */ new Set();
-  const listeners = {
-    open: /* @__PURE__ */ new Set(),
-    message: /* @__PURE__ */ new Set(),
-    close: /* @__PURE__ */ new Set(),
-    error: /* @__PURE__ */ new Set()
-  };
-  let ws = null;
-  let wanted = false;
-  let refs = 0;
-  let pinned = false;
-  let pending = [];
-  let ready = null;
-  let opened = false;
-  let unavailable = null;
-  let startScheduled = false;
-  let inbox = null;
-  let generation = 0;
-  let windowBound = false;
-  let retryTimer;
-  let teardownTimer;
-  let heartbeatTimer;
-  let pongTimer;
-  function set(patch) {
-    snapshot = { ...snapshot, ...patch };
-    for (const listener of [...storeListeners]) listener();
-  }
-  function emit(type, ...args) {
-    for (const listener of [...listeners[type]]) {
-      try {
-        listener(...args);
-      } catch (error) {
-        rethrowAsync(error);
-      }
-    }
-  }
-  function getImpl() {
-    if (options.WebSocket) return options.WebSocket;
-    return typeof window === "undefined" ? void 0 : globalThis.WebSocket;
-  }
-  function rejectReady(reason) {
-    if (!ready || ready.settled) ready = createDeferred();
-    ready.reject(reason);
-  }
-  function retryNow() {
-    if (retryTimer !== void 0) {
-      log("network or visibility change, retrying now");
-      open();
-    }
-  }
-  function onVisibilityChange() {
-    if (document.visibilityState === "visible") retryNow();
-  }
-  function bindWindow() {
-    if (windowBound || typeof window === "undefined") return;
-    windowBound = true;
-    window.addEventListener("online", retryNow);
-    document.addEventListener("visibilitychange", onVisibilityChange);
-  }
-  function unbindWindow() {
-    if (!windowBound) return;
-    windowBound = false;
-    window.removeEventListener("online", retryNow);
-    document.removeEventListener("visibilitychange", onVisibilityChange);
-  }
-  function startHeartbeat(socket) {
-    const heartbeat = options.heartbeat;
-    if (!heartbeat) return;
-    heartbeatTimer = setInterval(() => {
-      socket.send(heartbeat.message ?? "ping");
-      if (heartbeat.timeout && pongTimer === void 0) {
-        pongTimer = setTimeout(() => {
-          log("heartbeat timeout");
-          detach(socket, false);
-          socket.close(4e3, "heartbeat timeout");
-          handleClose({ code: 4e3, reason: "heartbeat timeout", wasClean: false });
-        }, heartbeat.timeout);
-      }
-    }, heartbeat.interval);
-  }
-  function stopHeartbeat() {
-    clearInterval(heartbeatTimer);
-    clearTimeout(pongTimer);
-    heartbeatTimer = pongTimer = void 0;
-  }
-  function detach(socket, reportClose) {
-    if (ws === socket) ws = null;
-    socket.onopen = socket.onmessage = socket.onerror = null;
-    socket.onclose = reportClose ? (event) => emit("close", { code: event.code, reason: event.reason, wasClean: event.wasClean }) : null;
-  }
-  function backoff(attempt) {
-    const { minDelay, maxDelay, factor, jitter } = retry;
-    const base = Math.min(maxDelay, minDelay * factor ** (attempt - 1));
-    return Math.round(base * (1 - jitter * Math.random()));
-  }
-  function open() {
-    clearTimeout(retryTimer);
-    retryTimer = void 0;
-    const Impl = getImpl();
-    if (!Impl) return;
-    const id = ++generation;
-    set({ status: snapshot.attempt === 0 ? "connecting" : "reconnecting" });
-    let target;
-    try {
-      target = typeof url === "string" ? url : url();
-    } catch (error) {
-      urlFailed(error);
-      return;
-    }
-    if (typeof target === "string") {
-      start(Impl, target);
-      return;
-    }
-    Promise.resolve(target).then(
-      (resolved) => {
-        if (id === generation && wanted) start(Impl, resolved);
-      },
-      (error) => {
-        if (id === generation && wanted) urlFailed(error);
-      }
-    );
-  }
-  function urlFailed(error) {
-    const reason = error instanceof Error ? error : new Error(String(error));
-    log("url() failed", reason);
-    emit("error", reason);
-    retryOrFail({ code: 1006, reason: "url() failed", wasClean: false }, reason);
-  }
-  function start(Impl, target) {
-    let socket;
-    try {
-      socket = new Impl(target, options.protocols);
-    } catch (error) {
-      emit("error", error);
-      fail(error);
-      return;
-    }
-    if (options.binaryType) socket.binaryType = options.binaryType;
-    ws = socket;
-    log("connecting", target);
-    socket.onopen = (event) => {
-      log("open");
-      opened = true;
-      set({ status: "open", attempt: 0 });
-      startHeartbeat(socket);
-      ready?.resolve();
-      emit("open", event);
-      if (ws !== socket) return;
-      const queued = pending;
-      pending = [];
-      for (const { data } of queued) socket.send(data);
-    };
-    socket.onmessage = (event) => receive(event, socket);
-    socket.onerror = (event) => emit("error", event);
-    socket.onclose = (event) => {
-      detach(socket, false);
-      handleClose({ code: event.code, reason: event.reason, wasClean: event.wasClean });
-    };
-  }
-  function handleClose(info) {
-    stopHeartbeat();
-    log("closed", info);
-    retryOrFail(info);
-    emit("close", info);
-  }
-  function retryOrFail(info, error) {
-    if (wanted && retry && snapshot.attempt < retry.maxAttempts && (retry.shouldReconnect?.(info) ?? true)) {
-      const attempt = snapshot.attempt + 1;
-      const delay = backoff(attempt);
-      set({ status: "reconnecting", attempt });
-      log(`reconnecting in ${delay}ms (attempt ${attempt})`);
-      retryTimer = setTimeout(open, delay);
-    } else {
-      fail(
-        error ?? new Error(`WebSocket closed (code ${info.code}${info.reason ? `: ${info.reason}` : ""})`)
-      );
-    }
-  }
-  function fail(reason) {
-    wanted = false;
-    opened = false;
-    unbindWindow();
-    pending = [];
-    set({ status: "closed" });
-    rejectReady(reason);
-  }
-  function receive(event, socket) {
-    clearTimeout(pongTimer);
-    pongTimer = void 0;
-    if (options.heartbeat?.pong !== void 0 && event.data === options.heartbeat.pong) return;
-    const run = () => decode(event, socket);
-    if (inbox) {
-      const next = inbox.then(run).then(() => {
-        if (inbox === next) inbox = null;
-      });
-      inbox = next;
-      return;
-    }
-    const result = run();
-    if (result) {
-      const next = result.then(() => {
-        if (inbox === next) inbox = null;
-      });
-      inbox = next;
-    }
-  }
-  function decode(event, socket) {
-    let value;
-    try {
-      value = options.parse ? options.parse(event.data) : options.json ? JSON.parse(event.data) : event.data;
-    } catch (cause) {
-      emit("error", new MessageError("Failed to parse message", event.data, { cause }));
-      return;
-    }
-    const schema = options.schema;
-    if (!schema) return deliver(value, event, socket);
-    let result;
-    try {
-      result = schema["~standard"].validate(value);
-    } catch (cause) {
-      emit("error", new MessageError("Schema validation threw", event.data, { cause }));
-      return;
-    }
-    if (isThenable(result)) {
-      return Promise.resolve(result).then(
-        (r) => validated(r, event, socket),
-        (cause) => emit("error", new MessageError("Schema validation threw", event.data, { cause }))
-      );
-    }
-    validated(result, event, socket);
-  }
-  function validated(result, event, socket) {
-    if (result.issues) {
-      emit(
-        "error",
-        new MessageError("Message failed schema validation", event.data, { issues: result.issues })
-      );
-    } else {
-      deliver(result.value, event, socket);
-    }
-  }
-  function deliver(message, event, socket) {
-    if (ws !== socket) return;
-    set({ lastMessage: message });
-    emit("message", message, event);
-  }
-  function send(message, sendOptions) {
-    const data = options.serialize ? options.serialize(message) : options.json ? JSON.stringify(message) : message;
-    if (ws && ws.readyState === OPEN) {
-      ws.send(data);
-      return true;
-    }
-    if (queueLimit === 0 || sendOptions?.volatile) {
-      log("dropped message: socket is not open");
-      return false;
-    }
-    if (!getImpl()) {
-      log("dropped message: no WebSocket implementation available");
-      return false;
-    }
-    const key = sendOptions?.key;
-    if (key !== void 0) pending = pending.filter((entry) => entry.key !== key);
-    pending.push({ data, key });
-    if (pending.length > queueLimit) {
-      pending.shift();
-      log(`dropped oldest queued message: queue limit (${queueLimit}) reached`);
-    }
-    return false;
-  }
-  function begin() {
-    wanted = true;
-    if (snapshot.status === "idle" || snapshot.status === "closed") {
-      opened = false;
-      if (ready?.settled) ready = null;
-    }
-    snapshot = { ...snapshot, attempt: 0 };
-    bindWindow();
-    open();
-  }
-  function ensureConnecting() {
-    if (wanted || !getImpl()) return;
-    begin();
-  }
-  function connect() {
-    pinned = true;
-    ensureConnecting();
-  }
-  function stop(code, reason) {
-    wanted = false;
-    generation++;
-    clearTimeout(retryTimer);
-    retryTimer = void 0;
-    stopHeartbeat();
-    unbindWindow();
-    pending = [];
-    if (ws) {
-      const socket = ws;
-      detach(socket, true);
-      socket.close(code, reason);
-    }
-  }
-  function close(code = 1e3, reason) {
-    pinned = false;
-    opened = false;
-    stop(code, reason);
-    set({ status: "closed", attempt: 0 });
-    rejectReady(new Error("WebSocket was closed"));
-  }
-  function reconnect() {
-    if (!getImpl()) return;
-    clearTimeout(retryTimer);
-    retryTimer = void 0;
-    stopHeartbeat();
-    if (ws) {
-      const socket = ws;
-      detach(socket, true);
-      socket.close(1e3, "reconnect");
-    }
-    begin();
-  }
-  function teardown() {
-    if (refs > 0 || pinned) return;
-    if (ready && !ready.settled) return;
-    stop();
-    ready = null;
-    opened = false;
-    set({ status: "idle", attempt: 0 });
-    onTeardown?.();
-  }
-  function acquire() {
-    refs++;
-    clearTimeout(teardownTimer);
-    if (snapshot.status === "idle") ensureConnecting();
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      if (--refs > 0) return;
-      clearTimeout(teardownTimer);
-      teardownTimer = setTimeout(teardown, 0);
-    };
-  }
-  return {
-    url,
-    get ready() {
-      if (!getImpl()) {
-        if (!unavailable) {
-          unavailable = createDeferred();
-          unavailable.reject(
-            new Error("react-websocket: no WebSocket available here (server render?)")
-          );
-        }
-        return unavailable.promise;
-      }
-      if (snapshot.status === "idle" && !startScheduled) {
-        startScheduled = true;
-        queueMicrotask(() => {
-          startScheduled = false;
-          if (snapshot.status === "idle") ensureConnecting();
-        });
-      }
-      if (!ready) {
-        ready = createDeferred();
-        if (opened) ready.resolve();
-      }
-      return ready.promise;
-    },
-    get socket() {
-      return ws;
-    },
-    subscribe(listener) {
-      storeListeners.add(listener);
-      return () => {
-        storeListeners.delete(listener);
-      };
-    },
-    getSnapshot: () => snapshot,
-    on(type, listener) {
-      const entry = ((...args) => listener(...args));
-      listeners[type].add(entry);
-      return () => {
-        listeners[type].delete(entry);
-      };
-    },
-    send,
-    connect,
-    close,
-    reconnect,
-    acquire
-  };
+	const onTeardown = options[ON_TEARDOWN];
+	const log = options.logger ?? (() => {});
+	const retry = options.reconnect === false ? null : {
+		...RECONNECT_DEFAULTS,
+		...typeof options.reconnect === "object" ? options.reconnect : {}
+	};
+	const queueLimit = options.queue === false ? 0 : typeof options.queue === "object" ? Math.max(0, options.queue.limit ?? Infinity) : Infinity;
+	let snapshot = {
+		status: "idle",
+		lastMessage: void 0,
+		attempt: 0
+	};
+	const storeListeners = /* @__PURE__ */ new Set();
+	const listeners = {
+		open: /* @__PURE__ */ new Set(),
+		message: /* @__PURE__ */ new Set(),
+		close: /* @__PURE__ */ new Set(),
+		error: /* @__PURE__ */ new Set()
+	};
+	let ws = null;
+	let wanted = false;
+	let refs = 0;
+	let pinned = false;
+	let pending = [];
+	let ready = null;
+	let opened = false;
+	let unavailable = null;
+	let startScheduled = false;
+	let inbox = null;
+	let generation = 0;
+	let windowBound = false;
+	let retryTimer;
+	let teardownTimer;
+	let heartbeatTimer;
+	let pongTimer;
+	function set(patch) {
+		snapshot = {
+			...snapshot,
+			...patch
+		};
+		for (const listener of [...storeListeners]) try {
+			listener();
+		} catch (error) {
+			rethrowAsync(error);
+		}
+	}
+	function emit(type, ...args) {
+		for (const listener of [...listeners[type]]) try {
+			listener(...args);
+		} catch (error) {
+			rethrowAsync(error);
+		}
+	}
+	function getImpl() {
+		if (options.WebSocket) return options.WebSocket;
+		return typeof window === "undefined" ? void 0 : globalThis.WebSocket;
+	}
+	function rejectReady(reason) {
+		if (!ready || ready.settled) ready = createDeferred();
+		ready.reject(reason);
+	}
+	function retryNow() {
+		if (retryTimer !== void 0) {
+			log("network or visibility change, retrying now");
+			open();
+		}
+	}
+	function onVisibilityChange() {
+		if (document.visibilityState === "visible") retryNow();
+	}
+	function bindWindow() {
+		if (windowBound || typeof window === "undefined") return;
+		windowBound = true;
+		window.addEventListener("online", retryNow);
+		document.addEventListener("visibilitychange", onVisibilityChange);
+	}
+	function unbindWindow() {
+		if (!windowBound) return;
+		windowBound = false;
+		window.removeEventListener("online", retryNow);
+		document.removeEventListener("visibilitychange", onVisibilityChange);
+	}
+	function startHeartbeat(socket) {
+		const heartbeat = options.heartbeat;
+		if (!heartbeat) return;
+		heartbeatTimer = setInterval(() => {
+			socket.send(heartbeat.message ?? "ping");
+			if (heartbeat.timeout && pongTimer === void 0) pongTimer = setTimeout(() => {
+				log("heartbeat timeout");
+				detach(socket, false);
+				socket.close(4e3, "heartbeat timeout");
+				handleClose({
+					code: 4e3,
+					reason: "heartbeat timeout",
+					wasClean: false
+				});
+			}, heartbeat.timeout);
+		}, heartbeat.interval);
+	}
+	function stopHeartbeat() {
+		clearInterval(heartbeatTimer);
+		clearTimeout(pongTimer);
+		heartbeatTimer = pongTimer = void 0;
+	}
+	/** Stop tracking `socket`. Its eventual close event is still reported unless `reportClose` is false. */
+	function detach(socket, reportClose) {
+		if (ws === socket) ws = null;
+		socket.onopen = socket.onmessage = socket.onerror = null;
+		socket.onclose = reportClose ? (event) => emit("close", {
+			code: event.code,
+			reason: event.reason,
+			wasClean: event.wasClean
+		}) : null;
+	}
+	function backoff(attempt) {
+		const { minDelay, maxDelay, factor, jitter } = retry;
+		const base = Math.min(maxDelay, minDelay * factor ** (attempt - 1));
+		return Math.round(base * (1 - jitter * Math.random()));
+	}
+	function open() {
+		clearTimeout(retryTimer);
+		retryTimer = void 0;
+		const Impl = getImpl();
+		if (!Impl) return;
+		const id = ++generation;
+		set({ status: snapshot.attempt === 0 ? "connecting" : "reconnecting" });
+		let target;
+		try {
+			target = typeof url === "string" ? url : url();
+		} catch (error) {
+			urlFailed(error);
+			return;
+		}
+		if (typeof target === "string") {
+			start(Impl, target);
+			return;
+		}
+		Promise.resolve(target).then((resolved) => {
+			if (id === generation && wanted) start(Impl, resolved);
+		}, (error) => {
+			if (id === generation && wanted) urlFailed(error);
+		});
+	}
+	/** `url()` threw or rejected (e.g. a token refresh failed): count it as a failed attempt. */
+	function urlFailed(error) {
+		const reason = error instanceof Error ? error : new Error(String(error));
+		log("url() failed", reason);
+		emit("error", reason);
+		retryOrFail({
+			code: 1006,
+			reason: "url() failed",
+			wasClean: false
+		}, reason);
+	}
+	function start(Impl, target) {
+		let socket;
+		try {
+			socket = new Impl(target, options.protocols);
+		} catch (error) {
+			emit("error", error);
+			fail(error);
+			return;
+		}
+		if (options.binaryType) socket.binaryType = options.binaryType;
+		ws = socket;
+		log("connecting", target);
+		socket.onopen = (event) => {
+			log("open");
+			opened = true;
+			set({
+				status: "open",
+				attempt: 0
+			});
+			startHeartbeat(socket);
+			ready?.resolve();
+			if (refs === 0 && !pinned) {
+				clearTimeout(teardownTimer);
+				teardownTimer = setTimeout(teardown, READY_GRACE);
+			}
+			emit("open", event);
+			if (ws !== socket) return;
+			const queued = pending;
+			pending = [];
+			for (const { data } of queued) socket.send(data);
+		};
+		socket.onmessage = (event) => receive(event, socket);
+		socket.onerror = (event) => emit("error", event);
+		socket.onclose = (event) => {
+			detach(socket, false);
+			handleClose({
+				code: event.code,
+				reason: event.reason,
+				wasClean: event.wasClean
+			});
+		};
+	}
+	function handleClose(info) {
+		stopHeartbeat();
+		log("closed", info);
+		retryOrFail(info);
+		emit("close", info);
+	}
+	function retryOrFail(info, error) {
+		if (wanted && retry && snapshot.attempt < retry.maxAttempts && (retry.shouldReconnect?.(info) ?? true)) {
+			const attempt = snapshot.attempt + 1;
+			const delay = backoff(attempt);
+			set({
+				status: "reconnecting",
+				attempt
+			});
+			log(`reconnecting in ${delay}ms (attempt ${attempt})`);
+			retryTimer = setTimeout(open, delay);
+		} else fail(error ?? /* @__PURE__ */ new Error(`WebSocket closed (code ${info.code}${info.reason ? `: ${info.reason}` : ""})`));
+	}
+	function fail(reason) {
+		wanted = false;
+		opened = false;
+		unbindWindow();
+		pending = [];
+		set({ status: "closed" });
+		rejectReady(reason);
+	}
+	function receive(event, socket) {
+		clearTimeout(pongTimer);
+		pongTimer = void 0;
+		if (options.heartbeat?.pong !== void 0 && event.data === options.heartbeat.pong) return;
+		const run = () => decode(event, socket);
+		if (inbox) {
+			const next = inbox.then(run).catch(rethrowAsync).then(() => {
+				if (inbox === next) inbox = null;
+			});
+			inbox = next;
+			return;
+		}
+		const result = run();
+		if (result) {
+			const next = result.catch(rethrowAsync).then(() => {
+				if (inbox === next) inbox = null;
+			});
+			inbox = next;
+		}
+	}
+	function decode(event, socket) {
+		let value;
+		try {
+			value = options.parse ? options.parse(event.data) : options.json ? JSON.parse(event.data) : event.data;
+		} catch (cause) {
+			emit("error", new MessageError("Failed to parse message", event.data, { cause }));
+			return;
+		}
+		const schema = options.schema;
+		if (!schema) return deliver(value, event, socket);
+		let result;
+		try {
+			result = schema["~standard"].validate(value);
+		} catch (cause) {
+			emit("error", new MessageError("Schema validation threw", event.data, { cause }));
+			return;
+		}
+		if (isThenable(result)) return Promise.resolve(result).then((r) => validated(r, event, socket), (cause) => emit("error", new MessageError("Schema validation threw", event.data, { cause })));
+		validated(result, event, socket);
+	}
+	function validated(result, event, socket) {
+		if (result.issues) emit("error", new MessageError("Message failed schema validation", event.data, { issues: result.issues }));
+		else deliver(result.value, event, socket);
+	}
+	function deliver(message, event, socket) {
+		if (ws !== socket) return;
+		set({ lastMessage: message });
+		emit("message", message, event);
+	}
+	function send(message, sendOptions = {}) {
+		const data = options.serialize ? options.serialize(message) : options.json ? JSON.stringify(message) : message;
+		const { key, priority, maxBuffered } = sendOptions;
+		if (ws && ws.readyState === OPEN) {
+			if (maxBuffered !== void 0 && ws.bufferedAmount > maxBuffered) {
+				log("dropped message: send buffer above maxBuffered");
+				return false;
+			}
+			ws.send(data);
+			return true;
+		}
+		if (queueLimit === 0 || sendOptions.volatile) {
+			log("dropped message: socket is not open");
+			return false;
+		}
+		if (!getImpl()) {
+			log("dropped message: no WebSocket implementation available");
+			return false;
+		}
+		if (key !== void 0) pending = pending.filter((entry) => {
+			if (entry.key !== key) return true;
+			dropped(entry);
+			return false;
+		});
+		let head = pending.findIndex((entry) => !entry.priority);
+		if (head < 0) head = pending.length;
+		const entry = {
+			data,
+			key,
+			priority,
+			onDrop: sendOptions.onDrop
+		};
+		if (priority) pending.splice(head++, 0, entry);
+		else pending.push(entry);
+		if (pending.length > queueLimit) {
+			dropped(pending.splice(head < pending.length ? head : 0, 1)[0]);
+			log(`dropped oldest queued message: queue limit (${queueLimit}) reached`);
+		}
+		return false;
+	}
+	function dropped(entry) {
+		try {
+			entry.onDrop?.();
+		} catch (error) {
+			rethrowAsync(error);
+		}
+	}
+	function begin() {
+		wanted = true;
+		if (snapshot.status === "idle" || snapshot.status === "closed") {
+			opened = false;
+			if (ready?.settled) ready = null;
+		}
+		snapshot = {
+			...snapshot,
+			attempt: 0
+		};
+		bindWindow();
+		open();
+	}
+	/** Start connecting unless already wanted. Used by holders (`acquire`, `ready`). */
+	function ensureConnecting() {
+		if (wanted || !getImpl()) return;
+		begin();
+	}
+	function connect() {
+		pinned = true;
+		ensureConnecting();
+	}
+	function stop(code, reason) {
+		wanted = false;
+		generation++;
+		clearTimeout(retryTimer);
+		retryTimer = void 0;
+		stopHeartbeat();
+		unbindWindow();
+		pending = [];
+		if (ws) {
+			const socket = ws;
+			detach(socket, true);
+			socket.close(code, reason);
+		}
+	}
+	function close(code = 1e3, reason) {
+		pinned = false;
+		opened = false;
+		stop(code, reason);
+		set({
+			status: "closed",
+			attempt: 0
+		});
+		rejectReady(/* @__PURE__ */ new Error("WebSocket was closed"));
+	}
+	function reconnect() {
+		if (!getImpl()) return;
+		clearTimeout(retryTimer);
+		retryTimer = void 0;
+		stopHeartbeat();
+		if (ws) {
+			const socket = ws;
+			detach(socket, true);
+			socket.close(1e3, "reconnect");
+		}
+		begin();
+	}
+	function teardown() {
+		if (refs > 0 || pinned) return;
+		if (ready && !ready.settled) return;
+		stop();
+		ready = null;
+		opened = false;
+		set({
+			status: "idle",
+			attempt: 0
+		});
+		onTeardown?.();
+	}
+	function acquire() {
+		refs++;
+		clearTimeout(teardownTimer);
+		if (snapshot.status === "idle") ensureConnecting();
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			if (--refs > 0) return;
+			clearTimeout(teardownTimer);
+			teardownTimer = setTimeout(teardown, 0);
+		};
+	}
+	return {
+		url,
+		get ready() {
+			if (!getImpl()) {
+				if (!unavailable) {
+					unavailable = createDeferred();
+					unavailable.reject(/* @__PURE__ */ new Error("react-websocket: no WebSocket available here (server render?)"));
+				}
+				return unavailable.promise;
+			}
+			if (snapshot.status === "idle" && !startScheduled) {
+				startScheduled = true;
+				queueMicrotask(() => {
+					startScheduled = false;
+					if (snapshot.status === "idle") ensureConnecting();
+				});
+			}
+			if (!ready) {
+				ready = createDeferred();
+				if (opened) ready.resolve();
+			}
+			return ready.promise;
+		},
+		get socket() {
+			return ws;
+		},
+		subscribe(listener) {
+			storeListeners.add(listener);
+			return () => {
+				storeListeners.delete(listener);
+			};
+		},
+		getSnapshot: () => snapshot,
+		on(type, listener) {
+			const entry = ((...args) => listener(...args));
+			listeners[type].add(entry);
+			return () => {
+				listeners[type].delete(entry);
+			};
+		},
+		send,
+		connect,
+		close,
+		reconnect,
+		acquire
+	};
 }
+/**
+* Create a WebSocket client, usually at module level, to share across components.
+*
+* Nothing connects until a hook uses it, `ready` is read, or `connect()` is called.
+* It closes one tick after the last hook unmounts, unless `connect()` was called.
+*
+* @param url - A URL, or a function (sync or async) called before every connection
+*   attempt, e.g. to put a fresh auth token in the URL on each reconnect.
+* @typeParam In - Type of incoming messages. Inferred from `options.schema` if given.
+* @typeParam Out - Type accepted by `send()`.
+*
+* @example
+* ```ts
+* type ChatIn = { user: string; text: string };
+* type ChatOut = { text: string };
+*
+* export const chat = createWebSocket<ChatIn, ChatOut>('wss://api.example.com/chat', { json: true });
+* ```
+*/
 function createWebSocket(url, options) {
-  return createClient(url, options);
+	return createClient(url, options);
 }
-
-// src/latency.ts
-var EMPTY = Object.freeze({ rtt: void 0, offset: void 0 });
+//#endregion
+//#region src/latency.ts
+const EMPTY = Object.freeze({
+	rtt: void 0,
+	offset: void 0
+});
 function median(values) {
-  const sorted = [...values].sort((a, b) => a - b);
-  const middle = sorted.length >> 1;
-  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+	const sorted = [...values].sort((a, b) => a - b);
+	const middle = sorted.length >> 1;
+	return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
 }
+/**
+* Measure round-trip time and estimate the server's clock, for ping displays, countdowns
+* and timestamps that must agree across players.
+*
+* Pings are sent on an interval while the socket is open, and paused otherwise. Measurements
+* from a previous connection are discarded on reconnect, but the last values stay readable
+* until new ones arrive. It doesn't open the connection by itself.
+*
+* Pongs are ordinary messages: they also reach `onMessage`, `lastMessage` and state stores.
+*
+* @example
+* ```ts
+* export const latency = createWebSocketLatency(game, {
+*   ping: id => ({ type: 'ping', id }),
+*   pong: message => (message.type === 'pong' ? { id: message.id, time: message.time } : undefined)
+* });
+*
+* // In a component:
+* const { rtt } = useWebSocketLatency(latency);
+*
+* // Anywhere: seconds left in a round that ends at the server's `endsAt`.
+* const left = (endsAt - latency.serverNow()) / 1000;
+* ```
+*/
 function createWebSocketLatency(client, options) {
-  const interval = options.interval ?? 2e3;
-  const keep = Math.max(1, options.samples ?? 5);
-  const listeners = /* @__PURE__ */ new Set();
-  let snapshot = EMPTY;
-  const inFlight = /* @__PURE__ */ new Map();
-  let samples = [];
-  let nextId = 0;
-  let timer;
-  function ping() {
-    if (client.getSnapshot().status !== "open") return;
-    const id = ++nextId;
-    inFlight.set(String(id), performance.now());
-    if (inFlight.size > keep * 2) inFlight.delete(inFlight.keys().next().value);
-    client.send(options.ping(id), { volatile: true });
-  }
-  function start() {
-    stop();
-    inFlight.clear();
-    samples = [];
-    ping();
-    timer = setInterval(ping, interval);
-  }
-  function stop() {
-    clearInterval(timer);
-    timer = void 0;
-  }
-  function measure(id, serverTime) {
-    const sentAt = inFlight.get(id);
-    if (sentAt === void 0) return;
-    inFlight.delete(id);
-    const rtt = performance.now() - sentAt;
-    const offset = serverTime === void 0 ? void 0 : serverTime + rtt / 2 - Date.now();
-    samples.push({ rtt, offset });
-    if (samples.length > keep) samples.shift();
-    let best;
-    for (const sample of samples) {
-      if (sample.offset !== void 0 && (!best || sample.rtt < best.rtt)) best = sample;
-    }
-    snapshot = {
-      rtt: median(samples.map((sample) => sample.rtt)),
-      offset: best ? best.offset : snapshot.offset
-    };
-    for (const listener of [...listeners]) listener();
-  }
-  const offs = [
-    client.on("open", start),
-    client.on("message", (message) => {
-      const pong = options.pong(message);
-      if (pong != null) measure(String(pong.id), pong.time);
-    }),
-    client.subscribe(() => {
-      if (client.getSnapshot().status !== "open") stop();
-    })
-  ];
-  if (client.getSnapshot().status === "open") start();
-  return {
-    client,
-    getSnapshot: () => snapshot,
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    serverNow: () => Date.now() + (snapshot.offset ?? 0),
-    ping,
-    dispose() {
-      stop();
-      offs.forEach((off) => off());
-    }
-  };
+	const interval = options.interval ?? 2e3;
+	const keep = Math.max(1, options.samples ?? 5);
+	const listeners = /* @__PURE__ */ new Set();
+	let snapshot = EMPTY;
+	const inFlight = /* @__PURE__ */ new Map();
+	let samples = [];
+	let nextId = 0;
+	let timer;
+	function ping() {
+		if (client.getSnapshot().status !== "open") return;
+		const id = ++nextId;
+		inFlight.set(String(id), performance.now());
+		if (inFlight.size > keep * 2) inFlight.delete(inFlight.keys().next().value);
+		client.send(options.ping(id), { volatile: true });
+	}
+	function start() {
+		stop();
+		inFlight.clear();
+		samples = [];
+		ping();
+		timer = setInterval(ping, interval);
+	}
+	function stop() {
+		clearInterval(timer);
+		timer = void 0;
+	}
+	function measure(id, serverTime) {
+		const sentAt = inFlight.get(id);
+		if (sentAt === void 0) return;
+		inFlight.delete(id);
+		const rtt = performance.now() - sentAt;
+		const offset = serverTime === void 0 ? void 0 : serverTime + rtt / 2 - Date.now();
+		samples.push({
+			rtt,
+			offset
+		});
+		if (samples.length > keep) samples.shift();
+		let best;
+		for (const sample of samples) if (sample.offset !== void 0 && (!best || sample.rtt < best.rtt)) best = sample;
+		snapshot = {
+			rtt: median(samples.map((sample) => sample.rtt)),
+			offset: best ? best.offset : snapshot.offset
+		};
+		for (const listener of [...listeners]) listener();
+	}
+	const offs = [
+		client.on("open", start),
+		client.on("message", (message) => {
+			const pong = options.pong(message);
+			if (pong != null) measure(String(pong.id), pong.time);
+		}),
+		client.subscribe(() => {
+			if (client.getSnapshot().status !== "open") stop();
+		})
+	];
+	if (client.getSnapshot().status === "open") start();
+	return {
+		client,
+		getSnapshot: () => snapshot,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		serverNow: () => Date.now() + (snapshot.offset ?? 0),
+		ping,
+		dispose() {
+			stop();
+			offs.forEach((off) => off());
+		}
+	};
 }
-
-// src/requests.ts
+//#endregion
+//#region src/requests.ts
+const lastIds = /* @__PURE__ */ new WeakMap();
+/**
+* Send requests and await their replies, matched by an id the library generates.
+*
+* Replies are ordinary messages: they also reach `onMessage`, `lastMessage` and state stores.
+*
+* @example
+* ```ts
+* type Request = { type: 'join'; room: string } | { type: 'leave' };
+*
+* export const rpc = createWebSocketRequests(game, {
+*   send: (message: Request, id) => ({ ...message, id }),
+*   reply: message => (message.type === 'reply' ? message.id : undefined),
+*   error: message => (message.type === 'reply' && message.error ? new Error(message.error) : undefined)
+* });
+*
+* const reply = await rpc.request({ type: 'join', room: 'lobby' }, { timeout: 5000 });
+* ```
+*/
 function createWebSocketRequests(client, options) {
-  const waiting = /* @__PURE__ */ new Map();
-  let nextId = 0;
-  function rejectWhere(test, reason) {
-    for (const entry of [...waiting.values()]) if (test(entry)) entry.reject(reason());
-  }
-  const offs = [
-    client.on("message", (message) => {
-      const id = options.reply(message);
-      const entry = id == null ? void 0 : waiting.get(String(id));
-      if (!entry) return;
-      const error = options.error?.(message);
-      if (error === void 0) entry.resolve(message);
-      else entry.reject(error);
-    }),
-    // `open` listeners run before the client flushes its queue: queued requests go out on this socket.
-    client.on("open", () => {
-      for (const entry of waiting.values()) entry.socket ??= client.socket;
-    }),
-    client.subscribe(() => {
-      const { status } = client.getSnapshot();
-      if (status === "closed" || status === "idle") {
-        rejectWhere(
-          () => true,
-          () => new Error("WebSocket was closed before the request was answered")
-        );
-      } else {
-        rejectWhere(
-          (entry) => entry.socket !== null && entry.socket !== client.socket,
-          () => new Error("WebSocket connection was lost before the request was answered")
-        );
-      }
-    })
-  ];
-  return {
-    client,
-    request(message, requestOptions = {}) {
-      const { signal } = requestOptions;
-      if (signal?.aborted) return Promise.reject(signal.reason);
-      const id = ++nextId;
-      const key = String(id);
-      const timeout = requestOptions.timeout ?? options.timeout ?? 1e4;
-      return new Promise((resolve, reject) => {
-        let timer;
-        const release = client.acquire();
-        const onAbort = () => entry.reject(signal.reason);
-        function settle() {
-          waiting.delete(key);
-          clearTimeout(timer);
-          signal?.removeEventListener("abort", onAbort);
-          release();
-        }
-        const entry = {
-          socket: null,
-          resolve(reply) {
-            settle();
-            resolve(reply);
-          },
-          reject(reason) {
-            settle();
-            reject(reason);
-          }
-        };
-        waiting.set(key, entry);
-        signal?.addEventListener("abort", onAbort, { once: true });
-        if (timeout > 0 && timeout < Infinity) {
-          timer = setTimeout(
-            () => entry.reject(
-              new DOMException(`Request ${id} timed out after ${timeout}ms`, "TimeoutError")
-            ),
-            timeout
-          );
-        }
-        const { status } = client.getSnapshot();
-        if (status === "closed" || status === "idle") {
-          entry.reject(new Error(`WebSocket is ${status}: request not sent`));
-          return;
-        }
-        let sent;
-        try {
-          sent = client.send(options.send(message, id), requestOptions);
-        } catch (error) {
-          entry.reject(error);
-          return;
-        }
-        if (sent) entry.socket = client.socket;
-        else if (requestOptions.volatile)
-          entry.reject(new Error("WebSocket is not open: request dropped"));
-      });
-    },
-    pending: () => waiting.size,
-    dispose() {
-      offs.forEach((off) => off());
-      rejectWhere(
-        () => true,
-        () => new Error("Requests were disposed")
-      );
-    }
-  };
+	const waiting = /* @__PURE__ */ new Map();
+	function rejectWhere(test, reason) {
+		for (const entry of [...waiting.values()]) if (test(entry)) entry.reject(reason());
+	}
+	const offs = [
+		client.on("message", (message) => {
+			const id = options.reply(message);
+			const entry = id == null ? void 0 : waiting.get(String(id));
+			if (!entry) return;
+			const error = options.error?.(message);
+			if (error === void 0) entry.resolve(message);
+			else entry.reject(error);
+		}),
+		client.on("open", () => {
+			for (const entry of waiting.values()) entry.socket ??= client.socket;
+		}),
+		client.subscribe(() => {
+			const { status } = client.getSnapshot();
+			if (status === "closed" || status === "idle") rejectWhere(() => true, () => /* @__PURE__ */ new Error("WebSocket was closed before the request was answered"));
+			else rejectWhere((entry) => entry.socket !== null && entry.socket !== client.socket, () => /* @__PURE__ */ new Error("WebSocket connection was lost before the request was answered"));
+		})
+	];
+	return {
+		client,
+		request(message, requestOptions = {}) {
+			const { signal } = requestOptions;
+			if (signal?.aborted) return Promise.reject(signal.reason);
+			const id = (lastIds.get(client) ?? 0) + 1;
+			lastIds.set(client, id);
+			const key = String(id);
+			const timeout = requestOptions.timeout ?? options.timeout ?? 1e4;
+			return new Promise((resolve, reject) => {
+				let timer;
+				const release = client.acquire();
+				const onAbort = () => entry.reject(signal.reason);
+				function settle() {
+					waiting.delete(key);
+					clearTimeout(timer);
+					signal?.removeEventListener("abort", onAbort);
+					release();
+				}
+				const entry = {
+					socket: null,
+					resolve(reply) {
+						settle();
+						resolve(reply);
+					},
+					reject(reason) {
+						settle();
+						reject(reason);
+					}
+				};
+				waiting.set(key, entry);
+				signal?.addEventListener("abort", onAbort, { once: true });
+				if (timeout > 0 && timeout < Infinity) timer = setTimeout(() => entry.reject(new DOMException(`Request ${id} timed out after ${timeout}ms`, "TimeoutError")), timeout);
+				const { status } = client.getSnapshot();
+				if (status === "closed" || status === "idle") {
+					entry.reject(/* @__PURE__ */ new Error(`WebSocket is ${status}: request not sent`));
+					return;
+				}
+				let sent;
+				try {
+					sent = client.send(options.send(message, id), {
+						...requestOptions,
+						onDrop() {
+							entry.reject(/* @__PURE__ */ new Error("Request was dropped from the send queue before it was sent"));
+							requestOptions.onDrop?.();
+						}
+					});
+				} catch (error) {
+					entry.reject(error);
+					return;
+				}
+				if (sent) entry.socket = client.socket;
+				else if (client.socket?.readyState === 1) entry.reject(/* @__PURE__ */ new Error("WebSocket send buffer is full: request dropped"));
+				else if (requestOptions.volatile) entry.reject(/* @__PURE__ */ new Error("WebSocket is not open: request dropped"));
+			});
+		},
+		pending: () => waiting.size,
+		dispose() {
+			offs.forEach((off) => off());
+			rejectWhere(() => true, () => /* @__PURE__ */ new Error("Requests were disposed"));
+		}
+	};
 }
-
-// src/state.ts
+//#endregion
+//#region src/responder.ts
+const VOLATILE$1 = { volatile: true };
+const abortError = (message) => new DOMException(message, "AbortError");
+/**
+* Answer requests the server sends: run a handler for tools that only exist in the browser
+* (selection, clipboard, geolocation), or let a person answer, e.g. to approve an agent's action.
+* The reverse of `createWebSocketRequests`.
+*
+* Every request gets exactly one reply while its connection lives: the handler's result, an
+* `error` reply when it throws, has no registration or times out. When the connection a request
+* arrived on closes, the request is dropped and nothing is sent, since the server can't match a
+* reply on a new connection. Replies are never queued.
+*
+* Requests are ordinary messages: they also reach `onMessage`, `lastMessage` and state stores.
+*
+* @example
+* ```ts
+* export const tools = createWebSocketResponder(agent, {
+*   request: message => (message.type === 'call' ? message : undefined),
+*   respond: (id, result: unknown) => ({ type: 'result', id, result }),
+*   error: (id, error) => ({ type: 'result', id, error: String(error) })
+* });
+*
+* tools.onRequest('get_selection', () => window.getSelection()?.toString() ?? '');
+*
+* // In a component: requests a person answers.
+* const approvals = useAgentApproval(tools, 'approve');
+* approvals[0]?.respond({ approved: true });
+* ```
+*/
+function createWebSocketResponder(client, options) {
+	const entries = /* @__PURE__ */ new Map();
+	const registrations = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let waiting = [];
+	function setWaiting(next) {
+		waiting = next;
+		for (const listener of [...listeners]) listener();
+	}
+	/** Send a reply, or an `error` reply if building or encoding it throws. */
+	function reply(id, build) {
+		try {
+			return client.send(build(), VOLATILE$1);
+		} catch (error) {
+			return client.send(options.error(id, error), VOLATILE$1);
+		}
+	}
+	function receive(incoming) {
+		const { id, method } = incoming;
+		const key = String(id);
+		if (entries.has(key)) return;
+		const registration = registrations.get(method)?.at(-1);
+		if (!registration) {
+			const error = new DOMException(`No handler for request method "${method}"`, "NotFoundError");
+			reply(id, () => options.error(id, error));
+			return;
+		}
+		const controller = new AbortController();
+		let timer;
+		let done = false;
+		let running = false;
+		function settle(build, reason) {
+			if (done) return false;
+			done = true;
+			entries.delete(key);
+			clearTimeout(timer);
+			if (waiting.includes(request)) setWaiting(waiting.filter((entry) => entry !== request));
+			if (reason !== void 0) controller.abort(reason);
+			return build ? reply(id, build) : false;
+		}
+		const answeredElsewhere = () => running ? abortError(`Request ${id} was answered elsewhere`) : void 0;
+		const request = {
+			id,
+			method,
+			params: incoming.params,
+			signal: controller.signal,
+			respond: (result) => settle(() => options.respond(id, result), answeredElsewhere()),
+			reject: (error) => settle(() => options.error(id, error), answeredElsewhere())
+		};
+		const fail = (error) => {
+			settle(() => options.error(id, error), error);
+		};
+		entries.set(key, {
+			socket: client.socket,
+			drop: (reason) => {
+				settle(null, reason);
+			},
+			fail
+		});
+		const timeout = incoming.timeout ?? options.timeout ?? Infinity;
+		if (timeout > 0 && timeout < Infinity) timer = setTimeout(() => fail(new DOMException(`Request ${id} was not answered within ${timeout}ms`, "TimeoutError")), timeout);
+		const { handler } = registration;
+		if (!handler) {
+			setWaiting([...waiting, request]);
+			return;
+		}
+		running = true;
+		new Promise((resolve) => resolve(handler(request.params, request))).then((result) => {
+			running = false;
+			request.respond(result);
+		}, (error) => {
+			running = false;
+			request.reject(error);
+		});
+	}
+	const offs = [client.on("message", (message) => {
+		const incoming = options.request(message);
+		if (incoming != null) {
+			receive(incoming);
+			return;
+		}
+		const id = options.cancel?.(message);
+		if (id != null) entries.get(String(id))?.drop(abortError(`Request ${id} was cancelled`));
+	}), client.subscribe(() => {
+		for (const entry of [...entries.values()]) if (entry.socket !== client.socket) entry.drop(abortError("WebSocket connection was lost before the request was answered"));
+	})];
+	return {
+		client,
+		onRequest(method, handler) {
+			let stack = registrations.get(method);
+			if (!stack) registrations.set(method, stack = []);
+			const registration = { handler };
+			stack.push(registration);
+			return () => {
+				const index = stack.indexOf(registration);
+				if (index !== -1) stack.splice(index, 1);
+			};
+		},
+		getSnapshot: () => waiting,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		dispose() {
+			offs.forEach((off) => off());
+			registrations.clear();
+			for (const entry of [...entries.values()]) entry.fail(abortError("Responder was disposed"));
+		}
+	};
+}
+//#endregion
+//#region src/sendrate.ts
+const VOLATILE = { volatile: true };
+/**
+* Send high-rate state, such as aim, cursor or position, at a rate that adapts to the
+* connection. Messages are coalesced per key between ticks. The rate drops by half when the
+* send buffer fills up or the round trip grows, and climbs back one tick per second at a time
+* when the link keeps up, so players on a poor connection degrade smoothly instead of building
+* up lag.
+*
+* Ticks run only while the socket is open and something is waiting. Messages waiting during a
+* reconnect go out after it; `close()` drops them. It doesn't open the connection by itself.
+*
+* @example
+* ```ts
+* export const stream = createWebSocketSendRate(game, { latency, maxRate: 30 });
+*
+* // On every pointer move: at most 30 a second, fewer on a congested link.
+* stream.send({ type: 'aim', angle }, 'aim');
+* ```
+*/
+function createWebSocketSendRate(client, options = {}) {
+	const { maxBuffered = 1024, latency, maxRttIncrease = 100 } = options;
+	const maxRate = options.maxRate ?? 30;
+	const minRate = Math.min(options.minRate ?? 5, maxRate);
+	const listeners = /* @__PURE__ */ new Set();
+	const pending = /* @__PURE__ */ new Map();
+	let rate = maxRate;
+	let snapshot = {
+		rate: maxRate,
+		congested: false
+	};
+	let last = -Infinity;
+	let best = Infinity;
+	let slow = false;
+	let measured;
+	let timer;
+	let disposed = false;
+	function flush() {
+		for (const [key, message] of pending) {
+			if (!client.send(message, VOLATILE)) return;
+			pending.delete(key);
+		}
+	}
+	function publish(congested) {
+		const rounded = Math.round(rate);
+		if (rounded === snapshot.rate && congested === snapshot.congested) return;
+		snapshot = {
+			rate: rounded,
+			congested
+		};
+		for (const listener of [...listeners]) listener();
+	}
+	function schedule() {
+		if (disposed || timer !== void 0 || !pending.size || client.getSnapshot().status !== "open") return;
+		timer = setTimeout(tick, Math.max(0, last + 1e3 / rate - performance.now()));
+	}
+	function stop() {
+		clearTimeout(timer);
+		timer = void 0;
+	}
+	function tick() {
+		timer = void 0;
+		last = performance.now();
+		const measurement = latency?.getSnapshot();
+		if (measurement !== measured) {
+			measured = measurement;
+			const rtt = measurement?.rtt;
+			if (rtt !== void 0) {
+				best = Math.min(best, rtt);
+				slow = rtt - best > maxRttIncrease;
+				if (slow) rate /= 2;
+			}
+		}
+		const full = (client.socket?.bufferedAmount ?? 0) > maxBuffered;
+		if (full) rate /= 2;
+		else {
+			flush();
+			if (!slow) rate++;
+		}
+		rate = Math.min(maxRate, Math.max(minRate, rate));
+		publish(full || slow);
+		schedule();
+	}
+	const offs = [client.on("open", () => {
+		best = Infinity;
+		slow = false;
+		measured = latency?.getSnapshot();
+		schedule();
+	}), client.subscribe(() => {
+		const { status } = client.getSnapshot();
+		if (status !== "open") stop();
+		if (status === "closed" || status === "idle") pending.clear();
+	})];
+	return {
+		client,
+		send(message, key) {
+			pending.delete(key);
+			pending.set(key, message);
+			schedule();
+		},
+		flush,
+		getSnapshot: () => snapshot,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		dispose() {
+			disposed = true;
+			stop();
+			pending.clear();
+			offs.forEach((off) => off());
+		}
+	};
+}
+//#endregion
+//#region src/state.ts
+/**
+* Keep state derived from a client's messages, like a reducer that runs on every message.
+* It starts listening immediately and keeps the state across reconnects; it doesn't open
+* the connection by itself.
+*
+* @example
+* ```ts
+* const prices = createWebSocket<Tick>('wss://api.example.com/prices', { json: true });
+*
+* export const priceState = createWebSocketState(prices, {
+*   initialState: {} as Record<string, number>,
+*   reduce: (state, tick) => ({ ...state, [tick.symbol]: tick.price })
+* });
+*
+* // In a component: re-renders only when ACME's price changes.
+* const acme = useWebSocketState(priceState, state => state.ACME);
+* ```
+*/
 function createWebSocketState(client, options) {
-  const { initialState, reduce } = options;
-  let state = initialState;
-  const listeners = /* @__PURE__ */ new Set();
-  function setState(update) {
-    const next = typeof update === "function" ? update(state) : update;
-    if (Object.is(next, state)) return;
-    state = next;
-    for (const listener of [...listeners]) listener();
-  }
-  const off = client.on("message", (message) => setState((current) => reduce(current, message)));
-  return {
-    client,
-    initialState,
-    getState: () => state,
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    setState,
-    reset: () => setState(initialState),
-    dispose: off
-  };
+	const { initialState, reduce, batch } = options;
+	let state = initialState;
+	let notified = state;
+	let frame = false;
+	const listeners = /* @__PURE__ */ new Set();
+	function notify() {
+		if (Object.is(state, notified)) return;
+		notified = state;
+		for (const listener of [...listeners]) listener();
+	}
+	function flush() {
+		frame = false;
+		notify();
+	}
+	function update(change, later) {
+		const next = typeof change === "function" ? change(state) : change;
+		if (Object.is(next, state)) return;
+		state = next;
+		if (!later) notify();
+		else if (!frame) {
+			frame = true;
+			if (typeof requestAnimationFrame === "function") requestAnimationFrame(flush);
+			else setTimeout(flush, 16);
+		}
+	}
+	return {
+		client,
+		initialState,
+		getState: () => state,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		setState: (change) => update(change),
+		reset: () => update(initialState),
+		dispose: client.on("message", (message) => update((current) => reduce(current, message), batch === "frame"))
+	};
 }
-
-// src/topics.ts
+//#endregion
+//#region src/topics.ts
+/**
+* Manage topic subscriptions that survive reconnects.
+*
+* - The first holder of a topic sends `subscribe(topic)`. Later holders share it.
+* - A tick after the last holder releases it, `unsubscribe(topic)` is sent, so StrictMode
+*   and route transitions don't churn subscriptions.
+* - After every reconnect, every held topic is subscribed again on the new socket, before
+*   messages queued while disconnected are sent.
+*
+* Subscriptions are only sent while the socket is open; nothing is queued for them.
+*
+* @example
+* ```ts
+* export const topics = createWebSocketTopics(live, {
+*   subscribe: topic => ({ type: 'subscribe', topic }),
+*   unsubscribe: topic => ({ type: 'unsubscribe', topic })
+* });
+*
+* // In a component:
+* useWebSocketTopic(topics, `prices:${symbol}`);
+* ```
+*/
 function createWebSocketTopics(client, options) {
-  const counts = /* @__PURE__ */ new Map();
-  const pendingRemoval = /* @__PURE__ */ new Map();
-  let sentOn = null;
-  let sent = /* @__PURE__ */ new Set();
-  function isOpen() {
-    return client.getSnapshot().status === "open" && client.socket !== null;
-  }
-  function subscribe(topic) {
-    if (!isOpen()) return;
-    if (client.socket !== sentOn) {
-      sentOn = client.socket;
-      sent = /* @__PURE__ */ new Set();
-    }
-    if (sent.has(topic)) return;
-    sent.add(topic);
-    client.send(options.subscribe(topic));
-  }
-  function unsubscribe(topic) {
-    if (!isOpen() || client.socket !== sentOn || !sent.delete(topic)) return;
-    if (options.unsubscribe) client.send(options.unsubscribe(topic));
-  }
-  const off = client.on("open", () => {
-    sentOn = client.socket;
-    sent = /* @__PURE__ */ new Set();
-    for (const topic of counts.keys()) subscribe(topic);
-  });
-  return {
-    client,
-    acquire(topic) {
-      const releaseConnection = client.acquire();
-      clearTimeout(pendingRemoval.get(topic));
-      pendingRemoval.delete(topic);
-      counts.set(topic, (counts.get(topic) ?? 0) + 1);
-      subscribe(topic);
-      let released = false;
-      return () => {
-        if (released) return;
-        released = true;
-        const remaining = (counts.get(topic) ?? 1) - 1;
-        if (remaining > 0) {
-          counts.set(topic, remaining);
-        } else {
-          counts.delete(topic);
-          pendingRemoval.set(
-            topic,
-            setTimeout(() => {
-              pendingRemoval.delete(topic);
-              if (!counts.has(topic)) unsubscribe(topic);
-            }, 0)
-          );
-        }
-        releaseConnection();
-      };
-    },
-    active: () => [...counts.keys()],
-    dispose() {
-      off();
-      for (const timer of pendingRemoval.values()) clearTimeout(timer);
-      pendingRemoval.clear();
-    }
-  };
+	const counts = /* @__PURE__ */ new Map();
+	const pendingRemoval = /* @__PURE__ */ new Map();
+	let sentOn = null;
+	let sent = /* @__PURE__ */ new Set();
+	function isOpen() {
+		return client.getSnapshot().status === "open" && client.socket !== null;
+	}
+	function subscribe(topic) {
+		if (!isOpen()) return;
+		if (client.socket !== sentOn) {
+			sentOn = client.socket;
+			sent = /* @__PURE__ */ new Set();
+		}
+		if (sent.has(topic)) return;
+		sent.add(topic);
+		client.send(options.subscribe(topic));
+	}
+	function unsubscribe(topic) {
+		if (!isOpen() || client.socket !== sentOn || !sent.delete(topic)) return;
+		if (options.unsubscribe) client.send(options.unsubscribe(topic));
+	}
+	const off = client.on("open", () => {
+		sentOn = client.socket;
+		sent = /* @__PURE__ */ new Set();
+		for (const topic of counts.keys()) subscribe(topic);
+	});
+	return {
+		client,
+		acquire(topic) {
+			const releaseConnection = client.acquire();
+			clearTimeout(pendingRemoval.get(topic));
+			pendingRemoval.delete(topic);
+			counts.set(topic, (counts.get(topic) ?? 0) + 1);
+			subscribe(topic);
+			let released = false;
+			return () => {
+				if (released) return;
+				released = true;
+				const remaining = (counts.get(topic) ?? 1) - 1;
+				if (remaining > 0) counts.set(topic, remaining);
+				else {
+					counts.delete(topic);
+					pendingRemoval.set(topic, setTimeout(() => {
+						pendingRemoval.delete(topic);
+						if (!counts.has(topic)) unsubscribe(topic);
+					}, 0));
+				}
+				releaseConnection();
+			};
+		},
+		active: () => [...counts.keys()],
+		dispose() {
+			off();
+			for (const timer of pendingRemoval.values()) clearTimeout(timer);
+			pendingRemoval.clear();
+		}
+	};
 }
-export {
-  MessageError,
-  createWebSocket,
-  createWebSocketLatency,
-  createWebSocketRequests,
-  createWebSocketState,
-  createWebSocketTopics
-};
+//#endregion
+export { MessageError, createWebSocket, createWebSocketLatency, createWebSocketRequests, createWebSocketResponder, createWebSocketSendRate, createWebSocketState, createWebSocketTopics };
+
 //# sourceMappingURL=core.js.map