redweb-client 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,57 @@
 # 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.
+
+## Unreleased lifecycle hardening
+
+The development branch fixes connection attempts continuing after a synchronous state observer calls `close()` or `dispose()`. Connection 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. These changes are not yet published in npm version 0.1.0.
+
+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.
+
+## Unreleased Live HTML integration
+
+The optional `redweb-client/live-html` entry owns reactive DOM updates, keyed
+reconciliation, delegated actions/forms, feedback and connection status for pages
+rendered by the matching Redweb development branch. 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. Published 0.1.0 does not include this entry; client
+publication and Redweb dependency/lockfile updates remain release prerequisites.
+
+Redweb's native-browser gate checks the server-side counter, multi-user chat,
+dashboard and forms using real HTTP/WebSockets. Its rendering coverage verifier
+measures all bundled Live HTML modules separately from transport and currently
+covers 426 statements, 262 branches, 64 functions and 351 lines (100% each).
+This is emitted-frontend coverage, not complete original-source/client-package or
+cross-browser certification. Separate V8 measurements are not substituted for
+the complete original-source gate below; the full release gate is not approved.
+
+From the linked Redweb repository, `npm run verify:client:source-coverage` runs
+all 77 client tests both plain and instrumented, then native 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 791 statements, 521 branches, 125 functions and 659 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 +193,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 +234,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-Dq8oKJwh.d.cts

@@ -0,0 +1,132 @@
+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 {
+    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-Dq8oKJwh.d.ts

@@ -0,0 +1,132 @@
+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 {
+    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;
@@ -490,21 +529,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);

package/dist/index.d.cts

@@ -1,130 +1,5 @@
-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 {
-    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;
-    constructor(url: string, options?: RedwebClientOptions);
-    connect(): Promise<void>;
-    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;
-}
+import { P as ProtocolErrorEnvelope, a as ProtocolMetadata, R as RedwebMessage, b as ProtocolEnvelope } from './client-Dq8oKJwh.cjs';
+export { B as BinaryListener, C as ClientState, c as CloseListener, E as ErrorListener, L as LegacyErrorMessage, M as MessageListener, d as ReconnectOptions, e as RedwebClient, f as RedwebClientOptions, g as RequestOptions, S as SocketEventLike, h as StateListener, W as WaitOptions, i as WebSocketLike } from './client-Dq8oKJwh.cjs';
 
 declare const ERROR_CODES: Readonly<{
     readonly INVALID_MESSAGE: "INVALID_MESSAGE";
@@ -146,4 +21,4 @@ declare class RedwebProtocolError extends Error {
     constructor(envelope: ProtocolErrorEnvelope);
 }
 
-export { type BinaryListener, type ClientState, type CloseListener, ERROR_CODES, type ErrorListener, type LegacyErrorMessage, type MessageListener, type ProtocolEnvelope, type ProtocolErrorEnvelope, type ProtocolMetadata, type ReconnectOptions, RedwebClient, type RedwebClientOptions, type RedwebMessage, RedwebProtocolError, type RequestOptions, type SocketEventLike, type StateListener, type WaitOptions, type WebSocketLike, createLegacyEnvelope, createProtocolEnvelope, parseMessage, resolveWebSocketUrl };
+export { ERROR_CODES, ProtocolEnvelope, ProtocolErrorEnvelope, ProtocolMetadata, RedwebMessage, RedwebProtocolError, createLegacyEnvelope, createProtocolEnvelope, parseMessage, resolveWebSocketUrl };