react-websocket 3.5.0 → 4.0.0

package/dist/core.d.cts

@@ -29,7 +29,10 @@ interface Snapshot<In> {
   readonly status: Status;
   /** Most recent message (after `parse`/`json` and `schema`), kept across reconnects. */
   readonly lastMessage: In | undefined;
-  /** Consecutive failed attempts since the last successful open. `0` while open. */
+  /**
+   * Consecutive failed attempts since the last stable connection. A connection that closes
+   * within `reconnect.minUptime` of opening counts as failed. `0` while open.
+   */
   readonly attempt: number;
 }
 /** Details of a closed connection, from the browser's `CloseEvent`. */
@@ -51,6 +54,14 @@ interface ReconnectOptions {
    * @default Infinity
    */
   maxAttempts?: number;
+  /**
+   * How long a connection must stay open, in ms, before the backoff resets. One that closes
+   * sooner counts as a failed attempt, so a server that accepts and then closes right away
+   * (e.g. rejecting the credentials sent on open) is retried with a growing delay, and
+   * `maxAttempts` still applies. `0` resets on every open.
+   * @default 5000
+   */
+  minUptime?: number;
   /**
    * Delay before the first retry, in ms.
    * @default 1000
@@ -68,19 +79,26 @@ interface ReconnectOptions {
   factor?: number;
   /**
    * Randomly shave up to this fraction (0–1) off each delay, so that many clients
-   * dropped at once don't all reconnect at the same moment.
-   * @default 0.5
+   * dropped at once don't all reconnect at the same moment. The default `1` picks each
+   * delay at random between 0 and the backoff ("full jitter").
+   * @default 1
    */
   jitter?: number;
   /**
    * Called on every unexpected close. Return `false` to stop reconnecting.
    *
+   * The default, `retryableClose`, retries everything except `1002` (protocol error), `1003`
+   * (unsupported data) and `1008` (policy violation). Your own function replaces it; call
+   * `retryableClose` from it to keep that rule, or return `true` to retry every close.
+   *
    * @example
    * ```ts
-   * // Don't retry when the server rejects our credentials.
-   * shouldReconnect: close => close.code !== 4001
+   * import { retryableClose } from 'react-websocket';
+   *
+   * // Also stop when our server rejects the credentials.
+   * shouldReconnect: close => close.code !== 4001 && retryableClose(close)
    * ```
-   * @default () => true
+   * @default retryableClose
    */
   shouldReconnect?: (close: CloseInfo) => boolean;
 }
@@ -155,7 +173,8 @@ interface QueueOptions {
   /**
    * Maximum number of messages held while not connected. When full, the oldest
    * message is dropped, skipping `priority` messages unless nothing else is queued.
-   * @default Infinity
+   * `Infinity` keeps every message.
+   * @default 100
    */
   limit?: number;
 }
@@ -231,8 +250,8 @@ interface WebSocketOptions<In = unknown, Out = unknown> {
   heartbeat?: HeartbeatOptions;
   /**
    * Buffer `send()` calls made while not connected and send them, in order, on open
-   * (right after `open` listeners run).
-   * `false` drops them instead. `{ limit }` caps the buffer, dropping the oldest.
+   * (right after `open` listeners run). It holds up to 100 messages, dropping the oldest;
+   * `{ limit }` changes that. `false` drops messages instead of queueing them.
    * The queue is cleared by `close()` or when the client gives up.
    * @default true
    */
@@ -374,6 +393,20 @@ interface WebSocketClient<In = unknown, Out = unknown> {
 }
 //#endregion
 //#region src/client.d.ts
+/**
+ * The default `reconnect.shouldReconnect`: retry every close except `1002` (protocol error),
+ * `1003` (unsupported data) and `1008` (policy violation, often a rejected login), which
+ * retrying the same way can't fix. Call it from your own `shouldReconnect` to keep that rule.
+ *
+ * @example
+ * ```ts
+ * createWebSocket(url, {
+ *   // Also stop on our server's "invalid token" code.
+ *   reconnect: { shouldReconnect: close => close.code !== 4001 && retryableClose(close) }
+ * });
+ * ```
+ */
+export declare function retryableClose(close: CloseInfo): boolean;
 /**
  * Create a WebSocket client, usually at module level, to share across components.
  *
@@ -487,20 +520,36 @@ interface WebSocketRequestsOptions<Req, In, Out> {
   reply: (message: In) => number | string | null | undefined;
   /**
    * Called on a reply. Return something other than `undefined` to reject the request with
-   * it instead of resolving, e.g. for a server-side error reply.
+   * it instead of resolving, e.g. for a server-side error reply. A stream throws it.
    */
   error?: (message: In) => unknown;
   /**
-   * Default time to wait for a reply, in ms. `Infinity` waits forever.
+   * Whether a reply is the last one of a stream. `stream()` needs it. That reply is yielded
+   * too, then the stream ends.
+   */
+  done?: (message: In) => boolean;
+  /**
+   * Build the message that tells the server to stop working on request `id`. Sent when this
+   * side gives up: the request's `signal` aborts, it times out, a loop over a stream exits
+   * early, or the manager is disposed. Not sent after the last reply, an error reply, a lost
+   * connection or `close()`.
+   */
+  cancel?: (id: number) => Out;
+  /**
+   * Default time to wait for a reply, in ms. For a stream, the time to wait for each reply,
+   * including the first. `Infinity` waits forever.
    * @default 10000
    */
   timeout?: number;
 }
-/** Per-call options for {@link WebSocketRequests.request}. */
+/** Per-call options for {@link WebSocketRequests.request} and {@link WebSocketRequests.stream}. */
 interface RequestOptions extends SendOptions {
-  /** Time to wait for a reply, in ms. Overrides the manager's `timeout`. */
+  /**
+   * Time to wait for a reply (for a stream, for each reply), in ms. Overrides the manager's
+   * `timeout`.
+   */
   timeout?: number;
-  /** Abort the request. It rejects with `signal.reason`. A late reply is ignored. */
+  /** Abort the request. It rejects (a stream throws) with `signal.reason`. A late reply is ignored. */
   signal?: AbortSignal;
 }
 /** Request/response over one client. Create with {@link createWebSocketRequests}. */
@@ -517,7 +566,26 @@ interface WebSocketRequests<Req, In> {
    * queue (replaced by a newer request with the same `key`, or evicted by `queue.limit`).
    */
   request(message: Req, options?: RequestOptions): Promise<In>;
-  /** Number of requests waiting for a reply. */
+  /**
+   * Send a request and iterate over its replies, up to and including the one `done` matches.
+   * Holds the connection until the stream ends. Needs the `done` option.
+   *
+   * `timeout` is the time to wait for each reply. Replies that arrive before the loop reads
+   * them are buffered. The stream is one-shot: iterate it once.
+   *
+   * Fails where `request()` rejects, with the same errors, after yielding the replies already
+   * received. Aborting `signal` throws `signal.reason` right away and discards them. Leaving
+   * the loop early, aborting and timing out send `cancel`.
+   *
+   * @example
+   * ```ts
+   * for await (const reply of rpc.stream({ type: 'ask', prompt }, { signal })) {
+   *   text += reply.delta;
+   * }
+   * ```
+   */
+  stream(message: Req, options?: RequestOptions): AsyncIterableIterator<In>;
+  /** Number of requests and streams waiting for a reply. */
   pending(): number;
   /** Reject every pending request and stop listening. Only needed for managers created dynamically. */
   dispose(): void;

package/dist/core.d.ts

@@ -29,7 +29,10 @@ interface Snapshot<In> {
   readonly status: Status;
   /** Most recent message (after `parse`/`json` and `schema`), kept across reconnects. */
   readonly lastMessage: In | undefined;
-  /** Consecutive failed attempts since the last successful open. `0` while open. */
+  /**
+   * Consecutive failed attempts since the last stable connection. A connection that closes
+   * within `reconnect.minUptime` of opening counts as failed. `0` while open.
+   */
   readonly attempt: number;
 }
 /** Details of a closed connection, from the browser's `CloseEvent`. */
@@ -51,6 +54,14 @@ interface ReconnectOptions {
    * @default Infinity
    */
   maxAttempts?: number;
+  /**
+   * How long a connection must stay open, in ms, before the backoff resets. One that closes
+   * sooner counts as a failed attempt, so a server that accepts and then closes right away
+   * (e.g. rejecting the credentials sent on open) is retried with a growing delay, and
+   * `maxAttempts` still applies. `0` resets on every open.
+   * @default 5000
+   */
+  minUptime?: number;
   /**
    * Delay before the first retry, in ms.
    * @default 1000
@@ -68,19 +79,26 @@ interface ReconnectOptions {
   factor?: number;
   /**
    * Randomly shave up to this fraction (0–1) off each delay, so that many clients
-   * dropped at once don't all reconnect at the same moment.
-   * @default 0.5
+   * dropped at once don't all reconnect at the same moment. The default `1` picks each
+   * delay at random between 0 and the backoff ("full jitter").
+   * @default 1
    */
   jitter?: number;
   /**
    * Called on every unexpected close. Return `false` to stop reconnecting.
    *
+   * The default, `retryableClose`, retries everything except `1002` (protocol error), `1003`
+   * (unsupported data) and `1008` (policy violation). Your own function replaces it; call
+   * `retryableClose` from it to keep that rule, or return `true` to retry every close.
+   *
    * @example
    * ```ts
-   * // Don't retry when the server rejects our credentials.
-   * shouldReconnect: close => close.code !== 4001
+   * import { retryableClose } from 'react-websocket';
+   *
+   * // Also stop when our server rejects the credentials.
+   * shouldReconnect: close => close.code !== 4001 && retryableClose(close)
    * ```
-   * @default () => true
+   * @default retryableClose
    */
   shouldReconnect?: (close: CloseInfo) => boolean;
 }
@@ -155,7 +173,8 @@ interface QueueOptions {
   /**
    * Maximum number of messages held while not connected. When full, the oldest
    * message is dropped, skipping `priority` messages unless nothing else is queued.
-   * @default Infinity
+   * `Infinity` keeps every message.
+   * @default 100
    */
   limit?: number;
 }
@@ -231,8 +250,8 @@ interface WebSocketOptions<In = unknown, Out = unknown> {
   heartbeat?: HeartbeatOptions;
   /**
    * Buffer `send()` calls made while not connected and send them, in order, on open
-   * (right after `open` listeners run).
-   * `false` drops them instead. `{ limit }` caps the buffer, dropping the oldest.
+   * (right after `open` listeners run). It holds up to 100 messages, dropping the oldest;
+   * `{ limit }` changes that. `false` drops messages instead of queueing them.
    * The queue is cleared by `close()` or when the client gives up.
    * @default true
    */
@@ -374,6 +393,20 @@ interface WebSocketClient<In = unknown, Out = unknown> {
 }
 //#endregion
 //#region src/client.d.ts
+/**
+ * The default `reconnect.shouldReconnect`: retry every close except `1002` (protocol error),
+ * `1003` (unsupported data) and `1008` (policy violation, often a rejected login), which
+ * retrying the same way can't fix. Call it from your own `shouldReconnect` to keep that rule.
+ *
+ * @example
+ * ```ts
+ * createWebSocket(url, {
+ *   // Also stop on our server's "invalid token" code.
+ *   reconnect: { shouldReconnect: close => close.code !== 4001 && retryableClose(close) }
+ * });
+ * ```
+ */
+export declare function retryableClose(close: CloseInfo): boolean;
 /**
  * Create a WebSocket client, usually at module level, to share across components.
  *
@@ -487,20 +520,36 @@ interface WebSocketRequestsOptions<Req, In, Out> {
   reply: (message: In) => number | string | null | undefined;
   /**
    * Called on a reply. Return something other than `undefined` to reject the request with
-   * it instead of resolving, e.g. for a server-side error reply.
+   * it instead of resolving, e.g. for a server-side error reply. A stream throws it.
    */
   error?: (message: In) => unknown;
   /**
-   * Default time to wait for a reply, in ms. `Infinity` waits forever.
+   * Whether a reply is the last one of a stream. `stream()` needs it. That reply is yielded
+   * too, then the stream ends.
+   */
+  done?: (message: In) => boolean;
+  /**
+   * Build the message that tells the server to stop working on request `id`. Sent when this
+   * side gives up: the request's `signal` aborts, it times out, a loop over a stream exits
+   * early, or the manager is disposed. Not sent after the last reply, an error reply, a lost
+   * connection or `close()`.
+   */
+  cancel?: (id: number) => Out;
+  /**
+   * Default time to wait for a reply, in ms. For a stream, the time to wait for each reply,
+   * including the first. `Infinity` waits forever.
    * @default 10000
    */
   timeout?: number;
 }
-/** Per-call options for {@link WebSocketRequests.request}. */
+/** Per-call options for {@link WebSocketRequests.request} and {@link WebSocketRequests.stream}. */
 interface RequestOptions extends SendOptions {
-  /** Time to wait for a reply, in ms. Overrides the manager's `timeout`. */
+  /**
+   * Time to wait for a reply (for a stream, for each reply), in ms. Overrides the manager's
+   * `timeout`.
+   */
   timeout?: number;
-  /** Abort the request. It rejects with `signal.reason`. A late reply is ignored. */
+  /** Abort the request. It rejects (a stream throws) with `signal.reason`. A late reply is ignored. */
   signal?: AbortSignal;
 }
 /** Request/response over one client. Create with {@link createWebSocketRequests}. */
@@ -517,7 +566,26 @@ interface WebSocketRequests<Req, In> {
    * queue (replaced by a newer request with the same `key`, or evicted by `queue.limit`).
    */
   request(message: Req, options?: RequestOptions): Promise<In>;
-  /** Number of requests waiting for a reply. */
+  /**
+   * Send a request and iterate over its replies, up to and including the one `done` matches.
+   * Holds the connection until the stream ends. Needs the `done` option.
+   *
+   * `timeout` is the time to wait for each reply. Replies that arrive before the loop reads
+   * them are buffered. The stream is one-shot: iterate it once.
+   *
+   * Fails where `request()` rejects, with the same errors, after yielding the replies already
+   * received. Aborting `signal` throws `signal.reason` right away and discards them. Leaving
+   * the loop early, aborting and timing out send `cancel`.
+   *
+   * @example
+   * ```ts
+   * for await (const reply of rpc.stream({ type: 'ask', prompt }, { signal })) {
+   *   text += reply.delta;
+   * }
+   * ```
+   */
+  stream(message: Req, options?: RequestOptions): AsyncIterableIterator<In>;
+  /** Number of requests and streams waiting for a reply. */
   pending(): number;
   /** Reject every pending request and stop listening. Only needed for managers created dynamically. */
   dispose(): void;

package/dist/core.js

@@ -30,8 +30,26 @@ const RECONNECT_DEFAULTS = {
 	minDelay: 1e3,
 	maxDelay: 3e4,
 	factor: 2,
-	jitter: .5
+	jitter: 1,
+	minUptime: 5e3
 };
+const QUEUE_LIMIT = 100;
+/**
+* The default `reconnect.shouldReconnect`: retry every close except `1002` (protocol error),
+* `1003` (unsupported data) and `1008` (policy violation, often a rejected login), which
+* retrying the same way can't fix. Call it from your own `shouldReconnect` to keep that rule.
+*
+* @example
+* ```ts
+* createWebSocket(url, {
+*   // Also stop on our server's "invalid token" code.
+*   reconnect: { shouldReconnect: close => close.code !== 4001 && retryableClose(close) }
+* });
+* ```
+*/
+function retryableClose(close) {
+	return close.code !== 1002 && close.code !== 1003 && close.code !== 1008;
+}
 const READY_GRACE = 5e3;
 function createDeferred() {
 	let resolve;
@@ -83,7 +101,7 @@ function createClient(url, options = {}) {
 		...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;
+	const queueLimit = options.queue === false ? 0 : Math.max(0, (typeof options.queue === "object" ? options.queue.limit : void 0) ?? QUEUE_LIMIT);
 	let snapshot = {
 		status: "idle",
 		lastMessage: void 0,
@@ -108,8 +126,10 @@ function createClient(url, options = {}) {
 	let inbox = null;
 	let generation = 0;
 	let windowBound = false;
+	let failures = 0;
 	let retryTimer;
 	let teardownTimer;
+	let stableTimer;
 	let heartbeatTimer;
 	let pongTimer;
 	function set(patch) {
@@ -176,10 +196,12 @@ function createClient(url, options = {}) {
 			}, heartbeat.timeout);
 		}, heartbeat.interval);
 	}
-	function stopHeartbeat() {
+	/** Stop the timers that belong to the current open socket. */
+	function stopSocketTimers() {
 		clearInterval(heartbeatTimer);
 		clearTimeout(pongTimer);
-		heartbeatTimer = pongTimer = void 0;
+		clearTimeout(stableTimer);
+		heartbeatTimer = pongTimer = stableTimer = void 0;
 	}
 	/** Stop tracking `socket`. Its eventual close event is still reported unless `reportClose` is false. */
 	function detach(socket, reportClose) {
@@ -250,6 +272,7 @@ function createClient(url, options = {}) {
 				status: "open",
 				attempt: 0
 			});
+			if (retry) stableTimer = setTimeout(() => failures = 0, retry.minUptime);
 			startHeartbeat(socket);
 			ready?.resolve();
 			if (refs === 0 && !pinned) {
@@ -274,14 +297,14 @@ function createClient(url, options = {}) {
 		};
 	}
 	function handleClose(info) {
-		stopHeartbeat();
+		stopSocketTimers();
 		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;
+		if (wanted && retry && failures < retry.maxAttempts && (retry.shouldReconnect ?? retryableClose)(info)) {
+			const attempt = ++failures;
 			const delay = backoff(attempt);
 			set({
 				status: "reconnecting",
@@ -296,7 +319,10 @@ function createClient(url, options = {}) {
 		opened = false;
 		unbindWindow();
 		pending = [];
-		set({ status: "closed" });
+		set({
+			status: "closed",
+			attempt: failures
+		});
 		rejectReady(reason);
 	}
 	function receive(event, socket) {
@@ -401,6 +427,7 @@ function createClient(url, options = {}) {
 			opened = false;
 			if (ready?.settled) ready = null;
 		}
+		failures = 0;
 		snapshot = {
 			...snapshot,
 			attempt: 0
@@ -422,7 +449,8 @@ function createClient(url, options = {}) {
 		generation++;
 		clearTimeout(retryTimer);
 		retryTimer = void 0;
-		stopHeartbeat();
+		failures = 0;
+		stopSocketTimers();
 		unbindWindow();
 		pending = [];
 		if (ws) {
@@ -445,7 +473,7 @@ function createClient(url, options = {}) {
 		if (!getImpl()) return;
 		clearTimeout(retryTimer);
 		retryTimer = void 0;
-		stopHeartbeat();
+		stopSocketTimers();
 		if (ws) {
 			const socket = ws;
 			detach(socket, true);
@@ -659,6 +687,8 @@ function createWebSocketLatency(client, options) {
 //#endregion
 //#region src/requests.ts
 const lastIds = /* @__PURE__ */ new WeakMap();
+const VOLATILE$2 = { volatile: true };
+const noop = () => {};
 /**
 * Send requests and await their replies, matched by an id the library generates.
 *
@@ -679,8 +709,8 @@ const lastIds = /* @__PURE__ */ new WeakMap();
 */
 function createWebSocketRequests(client, options) {
 	const waiting = /* @__PURE__ */ new Map();
-	function rejectWhere(test, reason) {
-		for (const entry of [...waiting.values()]) if (test(entry)) entry.reject(reason());
+	function endWhere(test, reason, cancel) {
+		for (const entry of [...waiting.values()]) if (test(entry)) entry.end(true, reason(), cancel);
 	}
 	const offs = [
 		client.on("message", (message) => {
@@ -688,78 +718,131 @@ function createWebSocketRequests(client, options) {
 			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);
+			if (error === void 0) entry.receive(message);
+			else entry.end(true, 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"));
+			if (status === "closed" || status === "idle") endWhere(() => true, () => /* @__PURE__ */ new Error("WebSocket was closed before the request was answered"));
+			else endWhere((entry) => entry.socket !== null && entry.socket !== client.socket, () => /* @__PURE__ */ new Error("WebSocket connection was lost before the request was answered"));
 		})
 	];
+	/**
+	* Send `message` as a new request. `next` gets each reply that isn't an error and returns
+	* whether it was the last; `done` runs once, when the request ends. Returns a function that
+	* ends it from this side and tells the server.
+	*/
+	function start(message, requestOptions, next, done) {
+		const { signal, priority } = requestOptions;
+		if (signal?.aborted) {
+			done(true, signal.reason);
+			return noop;
+		}
+		const id = (lastIds.get(client) ?? 0) + 1;
+		lastIds.set(client, id);
+		const key = String(id);
+		const timeout = requestOptions.timeout ?? options.timeout ?? 1e4;
+		const release = client.acquire();
+		let timer;
+		const onAbort = () => entry.end(true, signal.reason, true);
+		function arm() {
+			clearTimeout(timer);
+			if (timeout > 0 && timeout < Infinity) timer = setTimeout(() => entry.end(true, new DOMException(`Request ${id} timed out after ${timeout}ms`, "TimeoutError"), true), timeout);
+		}
+		const entry = {
+			socket: null,
+			receive(reply) {
+				if (next(reply)) entry.end(false);
+				else arm();
+			},
+			end(failed, reason, cancel) {
+				if (!waiting.delete(key)) return;
+				clearTimeout(timer);
+				signal?.removeEventListener("abort", onAbort);
+				release();
+				done(failed, reason);
+				if (cancel && options.cancel) try {
+					client.send(options.cancel(id), entry.socket ? VOLATILE$2 : { priority });
+				} catch (error) {
+					queueMicrotask(() => {
+						throw error;
+					});
+				}
+			}
+		};
+		waiting.set(key, entry);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		arm();
+		const { status } = client.getSnapshot();
+		if (status === "closed" || status === "idle") entry.end(true, /* @__PURE__ */ new Error(`WebSocket is ${status}: request not sent`));
+		else try {
+			if (client.send(options.send(message, id), {
+				...requestOptions,
+				onDrop() {
+					entry.end(true, /* @__PURE__ */ new Error("Request was dropped from the send queue before it was sent"));
+					requestOptions.onDrop?.();
+				}
+			})) entry.socket = client.socket;
+			else if (client.socket?.readyState === 1) entry.end(true, /* @__PURE__ */ new Error("WebSocket send buffer is full: request dropped"));
+			else if (requestOptions.volatile) entry.end(true, /* @__PURE__ */ new Error("WebSocket is not open: request dropped"));
+		} catch (error) {
+			entry.end(true, error);
+		}
+		return () => entry.end(false, void 0, true);
+	}
 	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;
+				start(message, requestOptions, (reply) => {
+					resolve(reply);
+					return true;
+				}, (failed, reason) => {
+					if (failed) reject(reason);
+				});
+			});
+		},
+		stream(message, requestOptions = {}) {
+			const last = options.done;
+			if (!last) throw new TypeError("stream() needs the `done` option");
+			const replies = [];
+			let ended;
+			let wake = noop;
+			const stop = start(message, requestOptions, (reply) => {
+				replies.push(reply);
+				wake();
+				return last(reply);
+			}, (failed, reason) => {
+				if (requestOptions.signal?.aborted) replies.length = 0;
+				ended = [failed, reason];
+				wake();
+			});
+			async function* read() {
 				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;
+					for (;;) if (replies.length) yield replies.shift();
+					else if (ended) {
+						if (ended[0]) throw ended[1];
+						return;
+					} else await new Promise((resolve) => wake = resolve);
+				} finally {
+					stop();
 				}
-				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"));
-			});
+			}
+			const iterator = read();
+			const close = iterator.return;
+			iterator.return = (value) => {
+				stop();
+				return close.call(iterator, value);
+			};
+			return iterator;
 		},
 		pending: () => waiting.size,
 		dispose() {
 			offs.forEach((off) => off());
-			rejectWhere(() => true, () => /* @__PURE__ */ new Error("Requests were disposed"));
+			endWhere(() => true, () => /* @__PURE__ */ new Error("Requests were disposed"), true);
 		}
 	};
 }
@@ -1168,6 +1251,6 @@ function createWebSocketTopics(client, options) {
 	};
 }
 //#endregion
-export { MessageError, createWebSocket, createWebSocketLatency, createWebSocketRequests, createWebSocketResponder, createWebSocketSendRate, createWebSocketState, createWebSocketTopics };
+export { MessageError, createWebSocket, createWebSocketLatency, createWebSocketRequests, createWebSocketResponder, createWebSocketSendRate, createWebSocketState, createWebSocketTopics, retryableClose };
 
 //# sourceMappingURL=core.js.map