snapreq 0.0.3 → 0.0.5

package/build/websocket/websocket-client.js

@@ -0,0 +1,920 @@
+// @ts-check
+import SnapReqWebSocketConnection from "./websocket-connection.js";
+import SnapReqWebSocketChannel from "./websocket-channel.js";
+const DEFAULT_RECONNECT_DELAYS = [1000, 2000, 4000, 8000, 15000];
+/**
+ * A small WebSocket client that mirrors simple HTTP-style calls and channel
+ * subscriptions over `globalThis.WebSocket`, so the same code runs on web, Expo
+ * / React Native and Node. Supports optional auto-reconnect with exponential
+ * backoff, session resumption and listener re-subscription.
+ *
+ * Response bodies are returned as raw parsed JSON; apps that need their own
+ * (de)serialization should apply it around `post`/`get` and the response
+ * `json()`.
+ */
+export default class SnapReqWebSocketClient {
+    /**
+     * @param {object} args - Options object.
+     * @param {string} args.url - Full WebSocket URL, e.g. `ws://localhost:3006/websocket`.
+     * @param {boolean} [args.autoReconnect] - Enable auto-reconnect with exponential backoff.
+     * @param {boolean} [args.debug] - Whether to log debug output.
+     * @param {{getIsOnline?: () => boolean | Promise<boolean>, subscribe?: (callback: (isOnline: boolean) => void) => (() => void) | {remove: () => void}}} [args.networkMonitor] - Optional online-state adapter. When provided, auto-reconnect can wait for the network to report online before reconnecting, and open sockets are closed when the monitor reports offline.
+     * @param {number[]} [args.reconnectDelays] - Backoff delays in ms (default: [1000, 2000, 4000, 8000, 15000]).
+     * @param {{get: () => string | null | undefined | Promise<string | null | undefined>, set: (sessionId: string) => void | Promise<void>, clear: () => void | Promise<void>}} [args.sessionStore] - Optional sessionId persistence hook surviving reloads (localStorage, a cookie, SQLite, etc.).
+     * @param {(value: any) => any} [args.deserialize] - Optional transform applied to a response body inside `response.json()`. Lets an app re-hydrate its own wire format. Defaults to identity.
+     */
+    constructor({ autoReconnect = true, debug = false, deserialize, networkMonitor, reconnectDelays, sessionStore, url } = /** @type {any} */ ({})) {
+        /**
+         * @param {MessageEvent<any>} event - Event payload.
+         * @returns {void}
+         */
+        this.onMessage = (event) => {
+            const raw = typeof event.data === "string" ? event.data : event.data?.toString?.();
+            if (!raw)
+                return;
+            /** @type {Record<string, any>} */
+            let message;
+            try {
+                message = JSON.parse(raw);
+            }
+            catch (error) {
+                this._debug("Failed to parse websocket message", error);
+                return;
+            }
+            const { type } = message;
+            if (type === "response") {
+                const { id } = message;
+                const pending = id ? this.pendingRequests.get(id) : undefined;
+                if (pending) {
+                    this.pendingRequests.delete(id);
+                    pending.resolve(new SnapReqWebSocketResponse(message, this._deserialize));
+                }
+                else {
+                    this._debug(`No pending request for response id ${id}`);
+                }
+            }
+            else if (type === "subscribed") {
+                const subscriptionKey = this._subscriptionKey(message.channel, message.params);
+                const pendingSubscription = this.pendingSubscriptions.get(subscriptionKey);
+                if (pendingSubscription) {
+                    this.pendingSubscriptions.delete(subscriptionKey);
+                    pendingSubscription.resolve();
+                }
+            }
+            else if (type === "event") {
+                const { channel, payload } = message;
+                for (const listenerEntry of this.listeners.values()) {
+                    if (listenerEntry.channel !== channel)
+                        continue;
+                    listenerEntry.callbacks.forEach((/** @type {(payload: any, message?: Record<string, any>) => void} */ callback) => {
+                        try {
+                            callback(payload, message);
+                        }
+                        catch (error) {
+                            this._debug("Listener error", error);
+                        }
+                    });
+                }
+            }
+            else if (type === "replay-gap") {
+                const subscriptionKey = this._subscriptionKey(message.channel, message.params);
+                const pendingSubscription = this.pendingSubscriptions.get(subscriptionKey);
+                if (pendingSubscription) {
+                    this.pendingSubscriptions.delete(subscriptionKey);
+                    pendingSubscription.reject(new Error(`Replay gap for ${message.channel}`));
+                }
+            }
+            else if (type === "connection-opened") {
+                const connection = this._connections.get(message.connectionId);
+                connection?._handleOpened();
+            }
+            else if (type === "connection-message") {
+                const connection = this._connections.get(message.connectionId);
+                connection?._handleMessage(message.body);
+            }
+            else if (type === "connection-closed") {
+                const connection = this._connections.get(message.connectionId);
+                if (connection) {
+                    this._connections.delete(message.connectionId);
+                    connection._handleClosed(message.reason || "server_close");
+                }
+            }
+            else if (type === "connection-error") {
+                const connection = this._connections.get(message.connectionId);
+                if (connection) {
+                    this._connections.delete(message.connectionId);
+                    connection._handleClosed(`error: ${message.message || "connection-error"}`);
+                }
+            }
+            else if (type === "channel-subscribed") {
+                const sub = this._channelSubscriptions.get(message.subscriptionId);
+                sub?._handleSubscribed();
+            }
+            else if (type === "channel-message") {
+                const sub = this._channelSubscriptions.get(message.subscriptionId);
+                sub?._handleMessage(message.body);
+            }
+            else if (type === "channel-unsubscribed") {
+                const sub = this._channelSubscriptions.get(message.subscriptionId);
+                if (sub) {
+                    this._channelSubscriptions.delete(message.subscriptionId);
+                    sub._handleClosed("server_unsubscribe");
+                }
+            }
+            else if (type === "channel-error") {
+                const sub = this._channelSubscriptions.get(message.subscriptionId);
+                if (sub) {
+                    this._channelSubscriptions.delete(message.subscriptionId);
+                    sub._handleClosed(`error: ${message.message || "channel-error"}`);
+                }
+            }
+            else if (type === "session-established") {
+                this._pendingSessionId = typeof message.sessionId === "string" ? message.sessionId : null;
+                // First connect: cache sessionId for future resume attempts.
+                if (!this._awaitingResume) {
+                    this._sessionId = this._pendingSessionId;
+                    if (this._sessionId) {
+                        this._persistSessionId(this._sessionId);
+                    }
+                    this._markSessionReady();
+                    this._sendPendingChannelSubscriptions();
+                }
+            }
+            else if (type === "session-resumed") {
+                this._awaitingResume = false;
+                this._pendingSessionId = null;
+                this._sessionId = message.sessionId;
+                this._persistSessionId(message.sessionId);
+                this._markSessionReady();
+                this._sendPendingChannelSubscriptions();
+                // Fire onResume on every live handle so user code knows the session came
+                // back with state intact.
+                for (const connection of this._connections.values())
+                    connection._handleResumed();
+                for (const subscription of this._channelSubscriptions.values())
+                    subscription._handleResumed();
+            }
+            else if (type === "session-gone") {
+                this._awaitingResume = false;
+                this._sessionId = null;
+                this._pendingSessionId = null;
+                this._clearPersistedSessionId();
+                // Tear down every live handle — their server-side counterparts are gone.
+                const connections = [...this._connections.values()];
+                this._connections.clear();
+                for (const connection of connections)
+                    connection._handleClosed("session_gone");
+                const subs = [...this._channelSubscriptions.values()];
+                this._channelSubscriptions.clear();
+                for (const subscription of subs)
+                    subscription._handleClosed("session_gone");
+                this._markSessionReady();
+            }
+            else if (type === "error" && message.id) {
+                const pending = this.pendingRequests.get(message.id);
+                if (pending) {
+                    this.pendingRequests.delete(message.id);
+                    pending.reject(new Error(message.error || "Unknown websocket error"));
+                }
+            }
+        };
+        /**
+         * Rejects all pending requests when the socket closes. Schedules reconnect if
+         * enabled.
+         * @returns {void}
+         */
+        this.onClose = () => {
+            this.disconnectedSince || (this.disconnectedSince = Date.now());
+            this._resetSessionReadyState();
+            for (const [id, { reject }] of this.pendingRequests.entries()) {
+                reject(new Error(`Websocket closed before response for ${id}`));
+            }
+            for (const { reject } of this.pendingSubscriptions.values()) {
+                reject(new Error("Websocket closed before subscription acknowledgement"));
+            }
+            if (this._sessionId && this.autoReconnect) {
+                // Session may resume when we reconnect — keep the handles alive and fire
+                // onDisconnect so user code can pause UI work.
+                for (const connection of this._connections.values())
+                    connection._handleDisconnected();
+                for (const subscription of this._channelSubscriptions.values())
+                    subscription._handleDisconnected();
+            }
+            else {
+                // No resume path: tear down every live connection / channel sub.
+                const connections = [...this._connections.values()];
+                this._connections.clear();
+                for (const connection of connections) {
+                    connection._handleClosed("session_destroyed");
+                }
+                const channelSubs = [...this._channelSubscriptions.values()];
+                this._channelSubscriptions.clear();
+                for (const subscription of channelSubs) {
+                    subscription._handleClosed("session_destroyed");
+                }
+                this._sessionId = null;
+            }
+            this.pendingRequests.clear();
+            this.pendingSubscriptions.clear();
+            this.connectPromise = undefined;
+            if (!this.autoReconnect)
+                return;
+            void this._shouldWaitForOnline().then((shouldWaitForOnline) => {
+                if (!shouldWaitForOnline) {
+                    this._scheduleReconnect();
+                }
+            });
+        };
+        if (!globalThis.WebSocket)
+            throw new Error("WebSocket global is not available");
+        if (!url)
+            throw new Error("SnapReqWebSocketClient requires a url");
+        /** @type {(value: any) => any} */
+        this._deserialize = deserialize || ((value) => value);
+        /** @type {boolean} */
+        this.autoReconnect = autoReconnect;
+        this.debug = debug;
+        /** @type {number | null} */
+        this.disconnectedSince = null;
+        this.pendingRequests = new Map();
+        this.pendingSubscriptions = new Map();
+        /** @type {number} */
+        this.reconnectAttempt = 0;
+        /** @type {number} */
+        this.connectionAttempts = 0;
+        /** @type {number[]} */
+        this.reconnectDelays = reconnectDelays || DEFAULT_RECONNECT_DELAYS;
+        /** @type {ReturnType<typeof setTimeout> | null} */
+        this.reconnectTimer = null;
+        this.url = url;
+        this.listeners = new Map();
+        this.nextID = 1;
+        /** @type {(() => void | Promise<void>) | null} */
+        this.onReconnect = null;
+        /** @type {Record<string, any>} */
+        this._metadata = {};
+        /** @type {Map<string, SnapReqWebSocketConnection>} */
+        this._connections = new Map();
+        /** @type {Map<string, SnapReqWebSocketChannel>} */
+        this._channelSubscriptions = new Map();
+        this._nextConnectionIdSeq = 1;
+        this._nextSubscriptionIdSeq = 1;
+        /** @type {string | null} - sessionId received from `session-established`; sent on reconnect for resumption. */
+        this._sessionId = null;
+        /** @type {boolean} - true between a reconnect and the session-resumed / session-gone reply. */
+        this._awaitingResume = false;
+        /** @type {boolean} - true once the current socket has an active session ready for app messages. */
+        this._sessionReady = false;
+        /** @type {string | null} - provisional session id announced before a resume attempt finishes. */
+        this._pendingSessionId = null;
+        /** @type {Promise<void> | null} */
+        this._sessionReadyPromise = null;
+        /** @type {(() => void) | null} */
+        this._resolveSessionReady = null;
+        /** @type {unknown | null} */
+        this._sessionReadyError = null;
+        /** @type {{get: () => string | null | undefined | Promise<string | null | undefined>, set: (sessionId: string) => void | Promise<void>, clear: () => void | Promise<void>} | undefined} */
+        this._sessionStore = sessionStore;
+        /** @type {boolean} - true once the sessionStore has been consulted for a restored id. */
+        this._sessionStoreRestored = false;
+        /** @type {{getIsOnline?: () => boolean | Promise<boolean>, subscribe?: (callback: (isOnline: boolean) => void) => (() => void) | {remove: () => void}} | undefined} */
+        this._networkMonitor = networkMonitor;
+        /** @type {null | (() => void) | {remove: () => void}} */
+        this._networkMonitorSubscription = null;
+        /** @type {boolean} */
+        this._waitingForOnline = false;
+    }
+    /** @returns {boolean} - Whether the socket is open. */
+    isOpen() {
+        return Boolean(this.socket && this.socket.readyState === this.socket.OPEN);
+    }
+    /** @returns {boolean} - Whether the session is ready for app messages. */
+    isSessionReady() {
+        return this._sessionReady;
+    }
+    /**
+     * Opens a 1:1 connection of the given type against the server. Requires the
+     * socket to already be connected (call `connect()` first).
+     * @param {string} connectionType - Name the server registered the class under.
+     * @param {{params?: Record<string, any>, onConnect?: () => void, onMessage?: (body: any) => void, onDisconnect?: () => void, onResume?: () => void, onClose?: (reason: string) => void}} [options] - Connection options.
+     * @returns {SnapReqWebSocketConnection} - The connection handle.
+     */
+    openConnection(connectionType, options = {}) {
+        if (!this.isOpen())
+            throw new Error("Websocket is not open; call connect() first");
+        const connectionId = `c${this._nextConnectionIdSeq++}`;
+        const connection = new SnapReqWebSocketConnection({
+            client: this,
+            connectionId,
+            connectionType,
+            params: options.params,
+            onConnect: options.onConnect,
+            onMessage: options.onMessage,
+            onDisconnect: options.onDisconnect,
+            onResume: options.onResume,
+            onClose: options.onClose
+        });
+        this._connections.set(connectionId, connection);
+        this._sendMessage({
+            type: "connection-open",
+            connectionId,
+            connectionType,
+            params: options.params || {}
+        });
+        return connection;
+    }
+    /**
+     * Drops a connection handle from the registry.
+     * @param {string} connectionId - The connection id.
+     * @returns {void}
+     */
+    _removeConnection(connectionId) {
+        this._connections.delete(connectionId);
+    }
+    /**
+     * Subscribes to a named channel. If the socket is not yet open, the
+     * subscription is queued and sent once a connection is established.
+     * @param {string} channelType - Name the server registered the channel under.
+     * @param {{params?: Record<string, any>, lastEventId?: string, onMessage?: (body: any) => void, onDisconnect?: () => void, onResume?: () => void, onClose?: (reason: string) => void}} [options] - Subscription options.
+     * @returns {SnapReqWebSocketChannel} - The subscription handle.
+     */
+    subscribeChannel(channelType, options = {}) {
+        const subscriptionId = `s${this._nextSubscriptionIdSeq++}`;
+        const subscription = new SnapReqWebSocketChannel({
+            client: this,
+            subscriptionId,
+            channelType,
+            lastEventId: options.lastEventId,
+            params: options.params,
+            onMessage: options.onMessage,
+            onDisconnect: options.onDisconnect,
+            onResume: options.onResume,
+            onClose: options.onClose
+        });
+        this._channelSubscriptions.set(subscriptionId, subscription);
+        this._sendChannelSubscribe(subscription);
+        return subscription;
+    }
+    /**
+     * @param {string} subscriptionId - The subscription id.
+     * @returns {void}
+     */
+    _removeChannelSubscription(subscriptionId) {
+        this._channelSubscriptions.delete(subscriptionId);
+    }
+    /**
+     * @param {SnapReqWebSocketChannel} subscription - The subscription to send.
+     * @returns {void}
+     */
+    _sendChannelSubscribe(subscription) {
+        if (!this.isOpen() || !this.isSessionReady() || !subscription._needsSubscribe())
+            return;
+        // Send first and only mark as sent on success. If the socket closes between
+        // `isOpen()` and `send()` and `_sendMessage` throws, `_subscribeSent` must
+        // stay false so the reconnect path's `_sendPendingChannelSubscriptions()`
+        // can retry.
+        try {
+            this._sendMessage({
+                type: "channel-subscribe",
+                subscriptionId: subscription.subscriptionId,
+                channelType: subscription.channelType,
+                params: subscription.params,
+                ...(subscription.lastEventId ? { lastEventId: subscription.lastEventId } : {})
+            });
+            subscription._markSubscribeSent();
+        }
+        catch (error) {
+            // Transient closed-socket race: leave the subscription retryable so
+            // `_sendPendingChannelSubscriptions()` can resend after reconnect.
+            if (!this.isOpen())
+                throw error;
+            // Non-recoverable send failure on an open socket (e.g. JSON.stringify
+            // failing on BigInt/cyclic params). Close the subscription and remove it
+            // so it cannot poison future `_sendPendingChannelSubscriptions()` loops.
+            this._channelSubscriptions.delete(subscription.subscriptionId);
+            subscription._handleClosed(`send_failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /** @returns {void} */
+    _sendPendingChannelSubscriptions() {
+        for (const subscription of this._channelSubscriptions.values()) {
+            this._sendChannelSubscribe(subscription);
+        }
+    }
+    /** @returns {Promise<boolean>} - Whether the network reports online. */
+    async _isOnline() {
+        if (!this._networkMonitor?.getIsOnline)
+            return true;
+        try {
+            return await this._networkMonitor.getIsOnline() !== false;
+        }
+        catch (error) {
+            this._debug("networkMonitor.getIsOnline failed", error);
+            return true;
+        }
+    }
+    /** @returns {Promise<boolean>} - Whether reconnect should wait for online. */
+    async _shouldWaitForOnline() {
+        if (!this._networkMonitor)
+            return false;
+        const isOnline = await this._isOnline();
+        if (isOnline)
+            return false;
+        this._waitingForOnline = true;
+        this._cancelPendingReconnect();
+        return true;
+    }
+    /** @returns {void} */
+    _ensureNetworkMonitorSubscription() {
+        if (!this._networkMonitor?.subscribe || this._networkMonitorSubscription)
+            return;
+        this._networkMonitorSubscription = this._networkMonitor.subscribe((isOnline) => {
+            if (!this.autoReconnect)
+                return;
+            if (isOnline) {
+                if (!this._waitingForOnline)
+                    return;
+                this._waitingForOnline = false;
+                void this._attemptReconnect();
+                return;
+            }
+            this._waitingForOnline = true;
+            this._cancelPendingReconnect();
+            if (this.isOpen()) {
+                void this.dropConnection();
+            }
+        });
+    }
+    /** @returns {void} */
+    _teardownNetworkMonitorSubscription() {
+        if (!this._networkMonitorSubscription)
+            return;
+        if (typeof this._networkMonitorSubscription === "function") {
+            this._networkMonitorSubscription();
+        }
+        else {
+            this._networkMonitorSubscription.remove();
+        }
+        this._networkMonitorSubscription = null;
+    }
+    /**
+     * Sets a global metadata value that is sent to the server. When the socket is
+     * open, a metadata update message is sent immediately.
+     * @param {string} key - Metadata key.
+     * @param {any} value - Metadata value (null to clear).
+     * @returns {void}
+     */
+    setMetadata(key, value) {
+        if (value === null || value === undefined) {
+            delete this._metadata[key];
+        }
+        else {
+            this._metadata[key] = value;
+        }
+        if (this.socket && this.socket.readyState === this.socket.OPEN) {
+            this._sendMessage({ type: "metadata", data: { ...this._metadata } });
+        }
+    }
+    /** @returns {Record<string, any>} - Current metadata. */
+    getMetadata() {
+        return { ...this._metadata };
+    }
+    /**
+     * Ensures a WebSocket connection is open. Auto-reconnect and online gating are
+     * enabled by default.
+     * @param {{autoReconnect?: boolean, waitForOnline?: boolean, resetReconnectState?: boolean}} [options] - Connect options.
+     * @returns {Promise<void>} - Resolves once connected and the session is ready.
+     */
+    async connect({ autoReconnect = this.autoReconnect, waitForOnline = true, resetReconnectState = true } = {}) {
+        this.autoReconnect = autoReconnect;
+        if (this.autoReconnect) {
+            this._ensureNetworkMonitorSubscription();
+        }
+        else {
+            this._waitingForOnline = false;
+            this._cancelPendingReconnect();
+            this._teardownNetworkMonitorSubscription();
+        }
+        if (waitForOnline && this.autoReconnect && !await this._isOnline()) {
+            this._waitingForOnline = true;
+            return;
+        }
+        if (resetReconnectState) {
+            this.reconnectAttempt = 0;
+        }
+        if (this.socket && this.socket.readyState === this.socket.OPEN)
+            return;
+        if (this.connectPromise)
+            return this.connectPromise;
+        this._resetSessionReadyState();
+        this._waitingForOnline = false;
+        this.connectionAttempts += 1;
+        this.connectPromise = new Promise((resolve, reject) => {
+            this.socket = new WebSocket(this.url);
+            const cleanup = () => {
+                this.socket?.removeEventListener("open", onOpen);
+                this.socket?.removeEventListener("error", onError);
+            };
+            const onOpen = () => {
+                cleanup();
+                resolve(undefined);
+            };
+            const onError = (/** @type {Event & {error?: unknown}} */ event) => {
+                cleanup();
+                const error = event?.error || new Error("Websocket connection error");
+                reject(error);
+            };
+            this.socket.addEventListener("open", onOpen);
+            this.socket.addEventListener("error", onError);
+            this.socket.addEventListener("message", this.onMessage);
+            this.socket.addEventListener("close", this.onClose);
+        });
+        await this.connectPromise;
+        // Cold restore from external persistence (sessionStore) on the very first
+        // connect: apps wire this up to survive a full page reload.
+        if (!this._sessionId && !this._sessionStoreRestored && this._sessionStore) {
+            this._sessionStoreRestored = true;
+            try {
+                const storedId = await this._sessionStore.get();
+                if (typeof storedId === "string" && storedId.length > 0) {
+                    this._sessionId = storedId;
+                }
+            }
+            catch (error) {
+                this._debug("sessionStore.get failed", error);
+            }
+        }
+        // If we have a cached sessionId from a prior connect, ask the server to
+        // resume it. The server replies with either `session-resumed` (state
+        // preserved) or `session-gone` (start fresh).
+        if (this._sessionId) {
+            this._awaitingResume = true;
+            this._sendMessage({ type: "session-resume", sessionId: this._sessionId });
+            // Fire onDisconnect on live handles so apps can pause UI work until
+            // session-resumed / session-gone arrives.
+            for (const connection of this._connections.values())
+                connection._handleDisconnected();
+            for (const subscription of this._channelSubscriptions.values())
+                subscription._handleDisconnected();
+        }
+        if (Object.keys(this._metadata).length > 0) {
+            this._sendMessage({ type: "metadata", data: { ...this._metadata } });
+        }
+        await this._waitForSessionReady();
+        this.disconnectedSince = null;
+    }
+    /**
+     * Closes the WebSocket and clears pending state.
+     * @returns {Promise<void>} - Resolves once closed.
+     */
+    async close() {
+        this.autoReconnect = false;
+        this._waitingForOnline = false;
+        this._cancelPendingReconnect();
+        this._teardownNetworkMonitorSubscription();
+        if (!this.socket)
+            return;
+        if (this.socket.readyState === this.socket.CLOSED) {
+            this.socket = undefined;
+            this.connectPromise = undefined;
+            this._resetSessionReadyState();
+            return;
+        }
+        await new Promise((resolve) => {
+            this.socket?.addEventListener("close", () => resolve(undefined));
+            this.socket?.close();
+        });
+        this.socket = undefined;
+        this.connectPromise = undefined;
+        this._resetSessionReadyState();
+    }
+    /**
+     * Disables auto-reconnect and closes the WebSocket.
+     * @returns {Promise<void>} - Resolves once closed.
+     */
+    async disconnectAndStopReconnect() {
+        await this.close();
+    }
+    /**
+     * Closes the raw socket without disabling auto-reconnect. Used by tests to
+     * simulate an unexpected network drop.
+     * @returns {Promise<void>} - Resolves once the socket has closed.
+     */
+    async dropConnection() {
+        if (!this.socket)
+            return;
+        await new Promise((resolve) => {
+            this.socket?.addEventListener("close", () => resolve(undefined));
+            this.socket?.close();
+        });
+        this.connectPromise = undefined;
+        this._resetSessionReadyState();
+    }
+    /**
+     * Performs a POST request over the WebSocket.
+     * @param {string} path - Path.
+     * @param {any} [body] - Request body.
+     * @param {{headers?: Record<string, string>}} [options] - Request options such as headers.
+     * @returns {Promise<SnapReqWebSocketResponse>} - The response.
+     */
+    async post(path, body, options = {}) {
+        return await this.request("POST", path, { ...options, body });
+    }
+    /**
+     * Performs a GET request over the WebSocket.
+     * @param {string} path - Path.
+     * @param {{headers?: Record<string, string>}} [options] - Request options such as headers.
+     * @returns {Promise<SnapReqWebSocketResponse>} - The response.
+     */
+    async get(path, options = {}) {
+        return await this.request("GET", path, options);
+    }
+    /**
+     * Subscribes to a channel for server-sent events.
+     * @param {string} channel - Channel name.
+     * @param {(payload: any) => void} callback - Callback function.
+     * @returns {() => void} - Unsubscribe function.
+     */
+    on(channel, callback) {
+        return this.subscribe(channel, {}, callback);
+    }
+    /**
+     * Returns a snapshot of the client's connection state.
+     * @returns {{disconnectedSince: number | null, isOpen: boolean, listenerCount: number}} - State snapshot.
+     */
+    state() {
+        return {
+            disconnectedSince: this.disconnectedSince,
+            isOpen: !!this.socket && this.socket.readyState === this.socket.OPEN,
+            listenerCount: this.listeners.size + this._channelSubscriptions.size
+        };
+    }
+    /**
+     * Subscribes to a channel for server-sent events with optional params.
+     * @param {string} channel - Channel name.
+     * @param {{lastEventId?: string, params?: Record<string, any>}} options - Subscription options.
+     * @param {(payload: any, message?: Record<string, any>) => void} callback - Callback function.
+     * @returns {(() => void) & {ready: Promise<void>}} - Unsubscribe function with readiness promise.
+     */
+    subscribe(channel, options, callback) {
+        const params = options?.params;
+        const lastEventId = options?.lastEventId;
+        const subscriptionKey = this._subscriptionKey(channel, params);
+        if (!this.listeners.has(subscriptionKey)) {
+            /** @type {((value?: void) => void) | undefined} */
+            let resolveReady;
+            /** @type {((error: unknown) => void) | undefined} */
+            let rejectReady;
+            const ready = new Promise((resolve, reject) => {
+                resolveReady = resolve;
+                rejectReady = reject;
+            });
+            this.listeners.set(subscriptionKey, {
+                callbacks: new Set(),
+                channel,
+                params,
+                ready
+            });
+            this.pendingSubscriptions.set(subscriptionKey, {
+                reject: rejectReady || (() => { }),
+                resolve: resolveReady || (() => { })
+            });
+            void this.connect().then(() => {
+                this._sendMessage({ channel, lastEventId, params, type: "subscribe" });
+            }).catch((error) => this._debug("Subscribe failed", error));
+        }
+        const listenerEntry = this.listeners.get(subscriptionKey);
+        if (!listenerEntry)
+            throw new Error("Listeners map not initialized");
+        listenerEntry.callbacks.add(callback);
+        const unsubscribe = () => {
+            listenerEntry.callbacks.delete(callback);
+            if (listenerEntry.callbacks.size === 0) {
+                this.listeners.delete(subscriptionKey);
+            }
+        };
+        unsubscribe.ready = listenerEntry.ready;
+        return unsubscribe;
+    }
+    /**
+     * Subscribes to a channel and waits until the server acknowledges it.
+     * @param {string} channel - Channel name.
+     * @param {{lastEventId?: string, params?: Record<string, any>}} options - Subscription options.
+     * @param {(payload: any, message?: Record<string, any>) => void} callback - Callback function.
+     * @returns {Promise<(() => void) & {ready: Promise<void>}>} - Ready unsubscribe handle.
+     */
+    async subscribeAndWait(channel, options, callback) {
+        const unsubscribe = this.subscribe(channel, options, callback);
+        await unsubscribe.ready;
+        return unsubscribe;
+    }
+    /**
+     * @param {string} method - HTTP method.
+     * @param {string} path - Path.
+     * @param {object} [options] - Options object.
+     * @param {any} [options.body] - Request body.
+     * @param {Record<string, string>} [options.headers] - Header list.
+     * @returns {Promise<SnapReqWebSocketResponse>} - The response.
+     */
+    async request(method, path, { body, headers } = {}) {
+        await this.connect();
+        const id = `ws-${this.nextID++}`;
+        const payload = {
+            body,
+            headers,
+            id,
+            method,
+            path,
+            type: "request"
+        };
+        return await new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, { resolve, reject });
+            this._sendMessage(payload);
+        });
+    }
+    /**
+     * @param {string} channel - Channel name.
+     * @param {Record<string, any> | undefined} params - Subscription params.
+     * @returns {string} - Stable subscription key.
+     */
+    _subscriptionKey(channel, params) {
+        return JSON.stringify([channel, params || null]);
+    }
+    /**
+     * @param {Record<string, any>} payload - Payload data.
+     * @returns {void}
+     */
+    _sendMessage(payload) {
+        if (!this.socket || this.socket.readyState !== this.socket.OPEN) {
+            throw new Error("Websocket is not open");
+        }
+        const json = JSON.stringify(payload);
+        this._debug("Sending", json);
+        this.socket.send(json);
+    }
+    /** @returns {void} */
+    _cancelPendingReconnect() {
+        if (this.reconnectTimer) {
+            globalThis.clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    /** @returns {void} */
+    _scheduleReconnect() {
+        this._cancelPendingReconnect();
+        const delay = this.reconnectDelays[Math.min(this.reconnectAttempt, this.reconnectDelays.length - 1)];
+        this.reconnectTimer = globalThis.setTimeout(() => {
+            this.reconnectTimer = null;
+            void this._attemptReconnect();
+        }, delay);
+        this.reconnectAttempt += 1;
+    }
+    /** @returns {Promise<void>} */
+    async _attemptReconnect() {
+        if (!this.autoReconnect)
+            return;
+        if (!await this._isOnline()) {
+            this._waitingForOnline = true;
+            return;
+        }
+        try {
+            this._waitingForOnline = false;
+            this.connectionAttempts += 1;
+            await this.connect({ autoReconnect: this.autoReconnect, resetReconnectState: false, waitForOnline: false });
+            this.reconnectAttempt = 0;
+            this.disconnectedSince = null;
+            this._resubscribeActiveListeners();
+            if (typeof this.onReconnect === "function") {
+                await this.onReconnect();
+            }
+        }
+        catch (error) {
+            this._debug("Reconnect attempt failed:", error);
+            if (this.autoReconnect) {
+                this._scheduleReconnect();
+            }
+        }
+    }
+    /**
+     * Re-sends subscribe messages for all active listeners after reconnection.
+     * @returns {void}
+     */
+    _resubscribeActiveListeners() {
+        for (const [, listenerEntry] of this.listeners) {
+            try {
+                this._sendMessage({
+                    channel: listenerEntry.channel,
+                    params: listenerEntry.params,
+                    type: "subscribe"
+                });
+            }
+            catch (error) {
+                this._debug("Re-subscribe failed:", error);
+            }
+        }
+    }
+    /**
+     * @param  {...any} args - Log arguments.
+     * @returns {void}
+     */
+    _debug(...args) {
+        if (!this.debug)
+            return;
+        console.debug("[SnapReqWebSocketClient]", ...args);
+    }
+    /**
+     * @param {string} sessionId - Id to persist through the configured sessionStore.
+     * @returns {void}
+     */
+    _persistSessionId(sessionId) {
+        if (!this._sessionStore)
+            return;
+        try {
+            const result = this._sessionStore.set(sessionId);
+            if (result && typeof result.then === "function") {
+                result.catch((/** @type {unknown} */ error) => this._debug("sessionStore.set failed", error));
+            }
+        }
+        catch (error) {
+            this._debug("sessionStore.set failed", error);
+        }
+    }
+    /** @returns {void} */
+    _clearPersistedSessionId() {
+        if (!this._sessionStore)
+            return;
+        try {
+            const result = this._sessionStore.clear();
+            if (result && typeof result.then === "function") {
+                result.catch((/** @type {unknown} */ error) => this._debug("sessionStore.clear failed", error));
+            }
+        }
+        catch (error) {
+            this._debug("sessionStore.clear failed", error);
+        }
+    }
+    /** @returns {Promise<void>} - Resolves once the session is ready. */
+    _waitForSessionReady() {
+        if (this._sessionReady)
+            return Promise.resolve();
+        if (!this._sessionReadyPromise || !this._resolveSessionReady) {
+            this._sessionReadyPromise = new Promise((resolve) => {
+                this._resolveSessionReady = resolve;
+            });
+        }
+        return this._sessionReadyPromise.then(() => {
+            if (this._sessionReadyError) {
+                const error = this._sessionReadyError;
+                this._sessionReadyError = null;
+                throw error;
+            }
+        });
+    }
+    /** @returns {void} */
+    _markSessionReady() {
+        if (this._sessionReady)
+            return;
+        this._sessionReady = true;
+        this._sessionReadyError = null;
+        this._resolveSessionReady?.();
+        this._resolveSessionReady = null;
+        this._sessionReadyPromise = null;
+    }
+    /**
+     * @param {unknown} [error] - Reason for the reset.
+     * @returns {void}
+     */
+    _resetSessionReadyState(error = new Error("Websocket session readiness was reset")) {
+        this._sessionReady = false;
+        this._pendingSessionId = null;
+        this._sessionReadyError = error;
+        this._resolveSessionReady?.();
+        this._sessionReadyPromise = null;
+        this._resolveSessionReady = null;
+    }
+}
+/** A response to a request made over the WebSocket transport. */
+export class SnapReqWebSocketResponse {
+    /**
+     * @param {object} message - The response message.
+     * @param {(value: any) => any} [deserialize] - Transform applied to the parsed body in `json()`. Defaults to identity.
+     */
+    constructor(message, deserialize) {
+        const responseMessage = /** @type {{body?: any, headers?: Record<string, any>, id?: string | number | null, statusCode?: number, statusMessage?: string, type?: string}} */ (message);
+        this.body = responseMessage.body;
+        this.headers = responseMessage.headers || {};
+        this.id = responseMessage.id;
+        this.statusCode = responseMessage.statusCode || 200;
+        this.statusMessage = responseMessage.statusMessage || "OK";
+        this.type = responseMessage.type;
+        this._deserialize = deserialize || ((value) => value);
+    }
+    /** @returns {any} - The parsed (and optionally deserialized) JSON body. */
+    json() {
+        if (typeof this.body !== "string") {
+            throw new Error("Response body is not a string");
+        }
+        return this._deserialize(JSON.parse(this.body));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-client.js","sourceRoot":"","sources":["../../src/websocket/websocket-client.js"],"names":[],"mappings":"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"}