redweb-client 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.3.0
+
+- Accept typed socket commands emitted by Redweb's server TSX controls on the page's custom route, reusing existing form feedback and DOM reconciliation. Requires Redweb 0.15.0 for socket-bound pages; ordinary Live HTML remains compatible with Redweb 0.14.0.
+- Add optional `request(..., { responseType })` filtering so intermediate correlated events do not complete a request before its terminal reply. Correlated protocol errors still reject immediately; omitting the option retains existing behavior.
+- Preserve explicitly bound JSON payloads, including `null`, and merge form fields over bound object payloads. Commands retain cancellation, deadlines and no-replay behavior.
+- Rebuild distribution files automatically before packing/publishing, and include these release notes in the package.
+
+Prepared for manual publication. No new runtime dependencies.

package/README.md

@@ -1,6 +1,67 @@
 # redweb-client
 
-Browser-first WebSocket client for [Redweb](https://redweb.magnisolution.com/). It adds connection lifecycle, typed message subscriptions, request correlation, bounded queuing, opt-in reconnection, and exact Redweb 0.9 protocol envelopes without adding runtime dependencies.
+Browser-first WebSocket client for [Redweb](https://redweb.magnisolution.com/). It adds connection lifecycle, typed message subscriptions, request correlation, bounded queuing, opt-in reconnection, and versioned Redweb protocol envelopes without adding runtime dependencies.
+
+## Connection lifecycle
+
+Connection attempts stop when a synchronous state observer calls `close()` or `dispose()`. Attempts are identified across callback boundaries; a reentrant `connect()` shares an existing attempt, and an explicit replacement is not cleared by an older attempt finishing. Cancelled transport-factory results are closed after their lifecycle listeners are attached.
+
+Integration regressions use real WebSocket connections and timers for observer-driven cancellation, upgrade-refusal retries, queued delivery, cancellation without replay, and rejected sends after disposal. Unit tests use isolated transport fixtures and explicitly simulated stale scheduling; integration tests do not mock transports. The complete verification command and its coverage scope are described below.
+
+## Live HTML integration
+
+### Typed socket-page commands (0.3.0)
+
+Version 0.3.0 accepts server-emitted command bindings on
+existing Live HTML controls. It sends the actual `join`/`move` message type on
+the page's custom route and reuses pending/error feedback and DOM reconciliation.
+No application browser module is necessary. Socket-bound pages require Redweb
+0.15.0; the earlier client 0.2.0 does not support these command bindings.
+
+Direct request users may pass `{ responseType: 'redweb:result' }` to wait for a
+specific terminal reply. Intermediate correlated events still reach subscribers
+but do not settle that request. Correlated protocol errors reject immediately.
+Omitting `responseType` preserves existing request behavior. Requests retain their
+deadline/cancellation and no-replay guarantees.
+
+The optional `redweb-client/live-html` entry owns reactive DOM updates, keyed
+reconciliation, delegated actions/forms, feedback and connection status for pages
+rendered by Redweb. The root import stays
+socket-only. Redweb serves the optional self-contained module and automatically
+calls `mountLivePage()`; ordinary applications need no additional browser glue.
+
+For explicit lifecycle ownership in a browser bundle:
+
+```ts
+import { mountLivePage } from 'redweb-client/live-html'
+
+const page = mountLivePage() // Same owner if already mounted on this document.
+// Later, when leaving the page:
+page.dispose() // Closes transport and removes owned listeners/feedback.
+```
+
+Mount only after Redweb's `__redweb_page` configuration and page DOM exist.
+Calling it again after disposal creates a fresh owner. Importing the module alone
+does not access the DOM or open a socket. A connection listener that calls mount
+again shares the same owner; a disposed page cannot later reset a submitted draft.
+
+For local development with sibling repositories, run `npm run build` and
+`npm link --ignore-scripts` here, then `npm link redweb-client --no-save --ignore-scripts`
+in Redweb. Rebuild here after source changes; no repacking is needed. The link is
+not saved in either lockfile. The optional entry was introduced in 0.2.0;
+socket-bound page commands and terminal-response filtering are added in 0.3.0.
+
+Redweb's headed-browser gates check the server-side counter, multi-user chat,
+dashboard, forms and socket-bound multiplayer tutorial using real HTTP/WebSockets.
+These are not cross-browser certification or a guarantee about application security.
+
+From the linked Redweb repository, `npm run verify:client:source-coverage` runs
+the complete client test inventory both plain and instrumented, then headed browser tests with
+the same original-source coverage maps. Plain browser bundles must match this
+client's `dist` output. It retains separate Node/browser results and currently
+covers all 800 statements, 543 branches, 125 functions and 667 lines (100% each).
+The same gate runs through the default `npm test` command. This metric does not
+replace V8 coverage or independently count every optional-chain short circuit.
 
 ## Install
 
@@ -142,7 +203,7 @@ TypeScript improves application ergonomics; it does not validate arbitrary appli
 
 - `connect()` is idempotent while connecting or open and resolves after the socket opens.
 - `close(code?, reason?)` suppresses reconnection, rejects pending requests, and discards unsent queued data.
-- `dispose()` closes once, clears subscriptions and queued messages, and permanently prevents reuse.
+- `dispose()` closes once, clears subscriptions and queued messages, and prevents reconnection and new sends/requests. Sends throw and requests reject after disposal, even when outbound queue capacity is available.
 - `send(type, payload, metadata?)` builds a legacy or protocol message.
 - `sendRaw(data)` sends text or binary data without encoding it.
 - Sends while disconnected throw by default. Set a finite `maxQueueSize` to queue a bounded number of messages until the next open. A queued request is removed if it times out, is aborted, or is rejected by `close()`; a command cannot execute later after its caller has been told it was cancelled.
@@ -183,7 +244,35 @@ Browser WebSockets cannot set arbitrary request headers. Use secure, same-site c
 ## Development and verification
 
 ```bash
-npm run check
+npm test
+```
+
+`npm test` delegates to `npm run check`; there is one complete verification path.
+It requires the matching sibling `../redweb` development checkout, with this
+client linked into it using `npm link`. The link's canonical path is checked
+**before** building, so a different installed client cannot silently be verified.
+The command then builds, checks declarations through the package export map, and
+delegates to Redweb's existing combined source/browser runner. It runs the complete
+unit and mock-free HTTP/WebSocket test inventory plus native Chromium rendering
+and transport tests. Chrome/Chromium must be installed.
+
+After a build, `npm run test:source` runs just that full verification, with the
+same checkout check. You can also run from the matching Redweb checkout:
+
+```bash
+npm run verify:client:source-coverage
 ```
 
-The clean-worktree gate builds first, resolves the public declarations through the package export map, then runs unit tests plus mock-free integration tests against a real local Redweb HTTP/WebSocket server. Coverage is enforced at 100% for statements, branches, functions, and lines.
+The combined gate shares the same original-source instrumentation across the complete
+Node test inventory and native Chromium rendering/transport tests. Plain and
+instrumented behavior must agree, and all tracked statements, branches, functions
+and lines must reach 100%. This is not exhaustive accounting of compiler-generated
+or optional-chain branches. Packed-pair verification and publication are separate
+release steps; this checkout-aware command is development tooling, not a runtime
+dependency on the Redweb repository.
+
+The separate `npm run test:v8` command retains the original Node-only V8 coverage gate
+and its unchanged thresholds. It currently fails because browser modules are not
+executed in Node. Renaming that diagnostic does not fix or waive its failure:
+the default command uses the explicitly documented combined original-source
+denominator, including actual browser execution, rather than the Node-only report.

package/dist/client-D35g1hrL.d.cts

@@ -0,0 +1,134 @@
+type ClientState = 'idle' | 'connecting' | 'open' | 'reconnecting' | 'closing' | 'closed';
+interface ProtocolMetadata {
+    requestId?: string;
+    sequence?: number;
+}
+interface ProtocolEnvelope<T = unknown> extends ProtocolMetadata {
+    v: string;
+    type: string;
+    payload: T;
+}
+interface ProtocolErrorEnvelope extends ProtocolMetadata {
+    v: string;
+    type: 'error';
+    error: {
+        code: string;
+        message: string;
+    };
+}
+interface LegacyErrorMessage extends ProtocolMetadata {
+    error: string;
+    type?: never;
+}
+type RedwebMessage<T = unknown> = ProtocolEnvelope<T> | ProtocolErrorEnvelope | LegacyErrorMessage | ({
+    type: string;
+    requestId?: string;
+    sequence?: number;
+} & Record<string, unknown>);
+interface SocketEventLike {
+    data?: unknown;
+    code?: number;
+    reason?: string;
+    wasClean?: boolean;
+    error?: unknown;
+}
+interface WebSocketLike {
+    readonly readyState: number;
+    binaryType?: string;
+    send(data: string | ArrayBufferLike | ArrayBufferView | Blob): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'open' | 'message' | 'error' | 'close', listener: (event: SocketEventLike) => void): void;
+    removeEventListener(type: 'open' | 'message' | 'error' | 'close', listener: (event: SocketEventLike) => void): void;
+}
+interface ReconnectOptions {
+    enabled?: boolean;
+    maxAttempts?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    factor?: number;
+    jitter?: number;
+    shouldReconnect?: (event: SocketEventLike) => boolean;
+}
+interface RedwebClientOptions {
+    version?: string;
+    reconnect?: ReconnectOptions;
+    maxQueueSize?: number;
+    requestTimeoutMs?: number;
+    webSocketFactory?: (url: string) => WebSocketLike;
+    createRequestId?: () => string;
+    baseUrl?: string | URL;
+    random?: () => number;
+}
+interface RequestOptions extends ProtocolMetadata {
+    /** Ignore intermediate correlated events; protocol errors still reject immediately. */
+    responseType?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface WaitOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+type MessageListener<T = unknown> = (message: RedwebMessage<T>) => void;
+type BinaryListener = (data: ArrayBuffer | ArrayBufferView | Blob) => void;
+type ErrorListener = (error: Error) => void;
+type StateListener = (state: ClientState) => void;
+type CloseListener = (event: SocketEventLike) => void;
+
+declare class RedwebClient<IncomingEvents extends object = Record<string, unknown>, OutgoingEvents extends object = Record<string, unknown>> {
+    readonly url: string;
+    readonly version: string | undefined;
+    state: ClientState;
+    socket: WebSocketLike | undefined;
+    private readonly factory;
+    private readonly reconnect;
+    private readonly maxQueueSize;
+    private readonly requestTimeoutMs;
+    private readonly createRequestId;
+    private readonly random;
+    private readonly listeners;
+    private readonly anyListeners;
+    private readonly binaryListeners;
+    private readonly errorListeners;
+    private readonly stateListeners;
+    private readonly closeListeners;
+    private readonly queue;
+    private readonly pending;
+    private connectPromise;
+    private reconnectTimer;
+    private reconnectAttempts;
+    private manualClose;
+    private disposed;
+    private requestSequence;
+    private generation;
+    constructor(url: string, options?: RedwebClientOptions);
+    connect(): Promise<void>;
+    private current;
+    private retire;
+    private openSocket;
+    close(code?: number, reason?: string): void;
+    dispose(): void;
+    send<K extends keyof OutgoingEvents & string>(type: K, payload: OutgoingEvents[K], metadata?: ProtocolMetadata): void;
+    sendRaw(data: string | ArrayBufferLike | ArrayBufferView | Blob): void;
+    private transmit;
+    request<TResponse = unknown, TPayload = unknown>(type: string, payload: TPayload, options?: RequestOptions): Promise<RedwebMessage<TResponse>>;
+    waitFor<K extends keyof IncomingEvents & string>(type: K, options?: WaitOptions): Promise<RedwebMessage<IncomingEvents[K]>>;
+    on<K extends keyof IncomingEvents & string>(type: K, listener: MessageListener<IncomingEvents[K]>): () => void;
+    onAny(listener: MessageListener): () => void;
+    onBinary(listener: BinaryListener): () => void;
+    onError(listener: ErrorListener): () => void;
+    onStateChange(listener: StateListener): () => void;
+    onClose(listener: CloseListener): () => void;
+    private subscribe;
+    private connectionUrl;
+    private transition;
+    private handleIncoming;
+    private finishPending;
+    private rejectPending;
+    private emitError;
+    private notify;
+    private flushQueue;
+    private scheduleReconnect;
+}
+
+export { type BinaryListener as B, type ClientState as C, type ErrorListener as E, type LegacyErrorMessage as L, type MessageListener as M, type ProtocolErrorEnvelope as P, type RedwebMessage as R, type SocketEventLike as S, type WaitOptions as W, type ProtocolMetadata as a, type ProtocolEnvelope as b, type CloseListener as c, type ReconnectOptions as d, RedwebClient as e, type RedwebClientOptions as f, type RequestOptions as g, type StateListener as h, type WebSocketLike as i };

package/dist/client-D35g1hrL.d.ts

@@ -0,0 +1,134 @@
+type ClientState = 'idle' | 'connecting' | 'open' | 'reconnecting' | 'closing' | 'closed';
+interface ProtocolMetadata {
+    requestId?: string;
+    sequence?: number;
+}
+interface ProtocolEnvelope<T = unknown> extends ProtocolMetadata {
+    v: string;
+    type: string;
+    payload: T;
+}
+interface ProtocolErrorEnvelope extends ProtocolMetadata {
+    v: string;
+    type: 'error';
+    error: {
+        code: string;
+        message: string;
+    };
+}
+interface LegacyErrorMessage extends ProtocolMetadata {
+    error: string;
+    type?: never;
+}
+type RedwebMessage<T = unknown> = ProtocolEnvelope<T> | ProtocolErrorEnvelope | LegacyErrorMessage | ({
+    type: string;
+    requestId?: string;
+    sequence?: number;
+} & Record<string, unknown>);
+interface SocketEventLike {
+    data?: unknown;
+    code?: number;
+    reason?: string;
+    wasClean?: boolean;
+    error?: unknown;
+}
+interface WebSocketLike {
+    readonly readyState: number;
+    binaryType?: string;
+    send(data: string | ArrayBufferLike | ArrayBufferView | Blob): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'open' | 'message' | 'error' | 'close', listener: (event: SocketEventLike) => void): void;
+    removeEventListener(type: 'open' | 'message' | 'error' | 'close', listener: (event: SocketEventLike) => void): void;
+}
+interface ReconnectOptions {
+    enabled?: boolean;
+    maxAttempts?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    factor?: number;
+    jitter?: number;
+    shouldReconnect?: (event: SocketEventLike) => boolean;
+}
+interface RedwebClientOptions {
+    version?: string;
+    reconnect?: ReconnectOptions;
+    maxQueueSize?: number;
+    requestTimeoutMs?: number;
+    webSocketFactory?: (url: string) => WebSocketLike;
+    createRequestId?: () => string;
+    baseUrl?: string | URL;
+    random?: () => number;
+}
+interface RequestOptions extends ProtocolMetadata {
+    /** Ignore intermediate correlated events; protocol errors still reject immediately. */
+    responseType?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface WaitOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+type MessageListener<T = unknown> = (message: RedwebMessage<T>) => void;
+type BinaryListener = (data: ArrayBuffer | ArrayBufferView | Blob) => void;
+type ErrorListener = (error: Error) => void;
+type StateListener = (state: ClientState) => void;
+type CloseListener = (event: SocketEventLike) => void;
+
+declare class RedwebClient<IncomingEvents extends object = Record<string, unknown>, OutgoingEvents extends object = Record<string, unknown>> {
+    readonly url: string;
+    readonly version: string | undefined;
+    state: ClientState;
+    socket: WebSocketLike | undefined;
+    private readonly factory;
+    private readonly reconnect;
+    private readonly maxQueueSize;
+    private readonly requestTimeoutMs;
+    private readonly createRequestId;
+    private readonly random;
+    private readonly listeners;
+    private readonly anyListeners;
+    private readonly binaryListeners;
+    private readonly errorListeners;
+    private readonly stateListeners;
+    private readonly closeListeners;
+    private readonly queue;
+    private readonly pending;
+    private connectPromise;
+    private reconnectTimer;
+    private reconnectAttempts;
+    private manualClose;
+    private disposed;
+    private requestSequence;
+    private generation;
+    constructor(url: string, options?: RedwebClientOptions);
+    connect(): Promise<void>;
+    private current;
+    private retire;
+    private openSocket;
+    close(code?: number, reason?: string): void;
+    dispose(): void;
+    send<K extends keyof OutgoingEvents & string>(type: K, payload: OutgoingEvents[K], metadata?: ProtocolMetadata): void;
+    sendRaw(data: string | ArrayBufferLike | ArrayBufferView | Blob): void;
+    private transmit;
+    request<TResponse = unknown, TPayload = unknown>(type: string, payload: TPayload, options?: RequestOptions): Promise<RedwebMessage<TResponse>>;
+    waitFor<K extends keyof IncomingEvents & string>(type: K, options?: WaitOptions): Promise<RedwebMessage<IncomingEvents[K]>>;
+    on<K extends keyof IncomingEvents & string>(type: K, listener: MessageListener<IncomingEvents[K]>): () => void;
+    onAny(listener: MessageListener): () => void;
+    onBinary(listener: BinaryListener): () => void;
+    onError(listener: ErrorListener): () => void;
+    onStateChange(listener: StateListener): () => void;
+    onClose(listener: CloseListener): () => void;
+    private subscribe;
+    private connectionUrl;
+    private transition;
+    private handleIncoming;
+    private finishPending;
+    private rejectPending;
+    private emitError;
+    private notify;
+    private flushQueue;
+    private scheduleReconnect;
+}
+
+export { type BinaryListener as B, type ClientState as C, type ErrorListener as E, type LegacyErrorMessage as L, type MessageListener as M, type ProtocolErrorEnvelope as P, type RedwebMessage as R, type SocketEventLike as S, type WaitOptions as W, type ProtocolMetadata as a, type ProtocolEnvelope as b, type CloseListener as c, type ReconnectOptions as d, RedwebClient as e, type RedwebClientOptions as f, type RequestOptions as g, type StateListener as h, type WebSocketLike as i };

package/dist/index.cjs

@@ -178,6 +178,7 @@ var RedwebClient = class {
   manualClose = false;
   disposed = false;
   requestSequence = 0;
+  generation = 0;
   constructor(url, options = {}) {
     this.url = resolveWebSocketUrl(url, options.baseUrl);
     const queryVersion = new URL(this.url).searchParams.get("redwebVersion") ?? void 0;
@@ -216,27 +217,51 @@ var RedwebClient = class {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = void 0;
     }
-    this.connectPromise = this.openSocket(false).finally(() => {
-      this.connectPromise = void 0;
+    let resolve;
+    let reject;
+    const promise = new Promise((yes, no) => {
+      resolve = yes;
+      reject = no;
     });
-    return this.connectPromise;
+    this.connectPromise = promise;
+    const finish = () => this.retire(promise);
+    void this.openSocket(false).then(() => {
+      finish();
+      resolve();
+    }, (error) => {
+      finish();
+      reject(error);
+    });
+    return promise;
+  }
+  current(generation) {
+    return this.generation === generation && !this.manualClose && !this.disposed;
+  }
+  retire(promise) {
+    if (this.connectPromise === promise) this.connectPromise = void 0;
   }
   openSocket(reconnecting) {
+    const opening = this.connectPromise;
+    const generation = ++this.generation;
     this.transition(reconnecting ? "reconnecting" : "connecting");
+    if (!this.current(generation)) return Promise.reject(new Error("WebSocket connection attempt was cancelled."));
     let socket;
     try {
       socket = this.factory(this.connectionUrl());
     } catch (error) {
-      this.transition("closed");
-      if (reconnecting && !this.manualClose) this.scheduleReconnect();
+      if (this.current(generation)) {
+        this.retire(opening);
+        this.transition("closed");
+        if (reconnecting && this.current(generation)) this.scheduleReconnect();
+      }
       return Promise.reject(toError(error, "Unable to create WebSocket."));
     }
-    this.socket = socket;
+    if (this.current(generation)) this.socket = socket;
     if ("binaryType" in socket) socket.binaryType = "arraybuffer";
     return new Promise((resolve, reject) => {
       let settled = false;
       const onOpen = () => {
-        if (this.socket !== socket) {
+        if (this.socket !== socket || !this.current(generation)) {
           if (!settled) reject(new Error("WebSocket connection attempt was superseded."));
           socket.close(1e3, "Superseded");
           return;
@@ -244,11 +269,15 @@ var RedwebClient = class {
         settled = true;
         this.reconnectAttempts = 0;
         this.transition("open");
+        if (!this.current(generation)) {
+          reject(new Error("WebSocket connection attempt was cancelled."));
+          return;
+        }
         this.flushQueue();
         resolve();
       };
       const onMessage = (event) => {
-        if (this.socket === socket) void this.handleIncoming(event.data);
+        if (this.socket === socket && this.current(generation)) void this.handleIncoming(event.data);
       };
       const onError = (event) => {
         if (this.socket !== socket) return;
@@ -270,18 +299,27 @@ var RedwebClient = class {
           reject(new Error("WebSocket closed before opening."));
         }
         this.rejectPending(new Error("WebSocket connection closed."));
+        const closedGeneration = this.generation;
+        this.retire(opening);
         this.transition("closed");
         this.notify(this.closeListeners, event);
-        if (!this.manualClose && this.reconnect.shouldReconnect(event)) this.scheduleReconnect();
+        if (!this.manualClose && this.reconnect.shouldReconnect(event) && this.generation === closedGeneration) this.scheduleReconnect();
       };
       socket.addEventListener("open", onOpen);
       socket.addEventListener("message", onMessage);
       socket.addEventListener("error", onError);
       socket.addEventListener("close", onClose);
+      if (!this.current(generation)) {
+        settled = true;
+        reject(new Error("WebSocket connection attempt was cancelled."));
+        socket.close(1e3, "Cancelled");
+      }
     });
   }
   close(code = 1e3, reason = "Client closed") {
     this.manualClose = true;
+    this.generation++;
+    this.connectPromise = void 0;
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = void 0;
@@ -316,6 +354,7 @@ var RedwebClient = class {
     this.transmit(data);
   }
   transmit(data, requestId) {
+    if (this.disposed) throw new Error("RedwebClient has been disposed.");
     if (this.socket?.readyState === OPEN) {
       this.socket.send(data);
       return;
@@ -329,6 +368,9 @@ var RedwebClient = class {
     const requestId = options.requestId ?? this.createRequestId();
     const timeoutMs = options.timeoutMs ?? this.requestTimeoutMs;
     assertNonNegativeInteger(timeoutMs, "timeoutMs");
+    if (options.responseType !== void 0 && (typeof options.responseType !== "string" || !options.responseType || options.responseType.length > 256)) {
+      return Promise.reject(new TypeError("responseType must be a non-empty string of at most 256 characters."));
+    }
     if (options.signal?.aborted) return Promise.reject(new DOMException("The request was aborted.", "AbortError"));
     if (this.pending.has(requestId)) return Promise.reject(new Error(`A Redweb request with id "${requestId}" is already pending.`));
     return new Promise((resolve, reject) => {
@@ -336,7 +378,7 @@ var RedwebClient = class {
         this.finishPending(requestId);
         reject(new Error(`Redweb request timed out after ${timeoutMs}ms.`));
       }, timeoutMs);
-      const pending = { resolve, reject, timer };
+      const pending = { resolve, reject, timer, responseType: options.responseType };
       if (options.signal) {
         pending.signal = options.signal;
         pending.abort = () => {
@@ -443,7 +485,7 @@ var RedwebClient = class {
     const requestId = message.requestId;
     if (typeof requestId === "string") {
       const pending = this.pending.get(requestId);
-      if (pending) {
+      if (pending && (pending.responseType === void 0 || message.type === pending.responseType || message.type === "error" && "error" in message)) {
         this.finishPending(requestId);
         if (message.type === "error" && "error" in message) pending.reject(new RedwebProtocolError(message));
         else pending.resolve(message);
@@ -490,21 +532,25 @@ var RedwebClient = class {
   flushQueue() {
     while (this.socket?.readyState === OPEN && this.queue.length > 0) {
       const entry = this.queue.shift();
-      if (entry !== void 0) this.socket.send(entry.data);
+      this.socket.send(entry.data);
     }
   }
   scheduleReconnect() {
-    if (this.disposed || !this.reconnect.enabled || this.reconnectAttempts >= this.reconnect.maxAttempts) return;
+    if (this.disposed || this.manualClose || !this.reconnect.enabled || this.reconnectAttempts >= this.reconnect.maxAttempts) return;
+    const generation = this.generation;
     const baseDelay = Math.min(
       this.reconnect.maxDelayMs,
       this.reconnect.initialDelayMs * this.reconnect.factor ** this.reconnectAttempts
     );
     const spread = baseDelay * this.reconnect.jitter;
     const delay = Math.max(0, Math.round(baseDelay - spread + this.random() * spread * 2));
+    if (!this.current(generation)) return;
     this.reconnectAttempts += 1;
     this.transition("reconnecting");
+    if (!this.current(generation)) return;
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = void 0;
+      if (!this.current(generation)) return;
       void this.openSocket(true).catch(() => {
       });
     }, delay);