@supabase/realtime-js 2.99.3-canary.0 → 2.99.3

package/dist/main/RealtimeClient.js

@@ -4,9 +4,10 @@ const tslib_1 = require("tslib");
 const websocket_factory_1 = tslib_1.__importDefault(require("./lib/websocket-factory"));
 const constants_1 = require("./lib/constants");
 const serializer_1 = tslib_1.__importDefault(require("./lib/serializer"));
+const timer_1 = tslib_1.__importDefault(require("./lib/timer"));
 const transformers_1 = require("./lib/transformers");
 const RealtimeChannel_1 = tslib_1.__importDefault(require("./RealtimeChannel"));
-const socketAdapter_1 = tslib_1.__importDefault(require("./phoenix/socketAdapter"));
+const noop = () => { };
 // Connection-related constants
 const CONNECTION_TIMEOUTS = {
     HEARTBEAT_INTERVAL: 25000,
@@ -22,54 +23,6 @@ const WORKER_SCRIPT = `
     }
   });`;
 class RealtimeClient {
-    get endPoint() {
-        return this.socketAdapter.endPoint;
-    }
-    get timeout() {
-        return this.socketAdapter.timeout;
-    }
-    get transport() {
-        return this.socketAdapter.transport;
-    }
-    get heartbeatCallback() {
-        return this.socketAdapter.heartbeatCallback;
-    }
-    get heartbeatIntervalMs() {
-        return this.socketAdapter.heartbeatIntervalMs;
-    }
-    get heartbeatTimer() {
-        if (this.worker) {
-            return this._workerHeartbeatTimer;
-        }
-        return this.socketAdapter.heartbeatTimer;
-    }
-    get pendingHeartbeatRef() {
-        if (this.worker) {
-            return this._pendingWorkerHeartbeatRef;
-        }
-        return this.socketAdapter.pendingHeartbeatRef;
-    }
-    get reconnectTimer() {
-        return this.socketAdapter.reconnectTimer;
-    }
-    get vsn() {
-        return this.socketAdapter.vsn;
-    }
-    get encode() {
-        return this.socketAdapter.encode;
-    }
-    get decode() {
-        return this.socketAdapter.decode;
-    }
-    get reconnectAfterMs() {
-        return this.socketAdapter.reconnectAfterMs;
-    }
-    get sendBuffer() {
-        return this.socketAdapter.sendBuffer;
-    }
-    get stateChangeCallbacks() {
-        return this.socketAdapter.stateChangeCallbacks;
-    }
     /**
      * Initializes the Socket.
      *
@@ -101,20 +54,39 @@ class RealtimeClient {
      */
     constructor(endPoint, options) {
         var _a;
-        this.channels = new Array();
         this.accessTokenValue = null;
-        this.accessToken = null;
         this.apiKey = null;
+        this._manuallySetToken = false;
+        this.channels = new Array();
+        this.endPoint = '';
         this.httpEndpoint = '';
         /** @deprecated headers cannot be set on websocket connections */
         this.headers = {};
         this.params = {};
+        this.timeout = constants_1.DEFAULT_TIMEOUT;
+        this.transport = null;
+        this.heartbeatIntervalMs = CONNECTION_TIMEOUTS.HEARTBEAT_INTERVAL;
+        this.heartbeatTimer = undefined;
+        this.pendingHeartbeatRef = null;
+        this.heartbeatCallback = noop;
         this.ref = 0;
+        this.reconnectTimer = null;
+        this.vsn = constants_1.DEFAULT_VSN;
+        this.logger = noop;
+        this.conn = null;
+        this.sendBuffer = [];
         this.serializer = new serializer_1.default();
-        this._manuallySetToken = false;
+        this.stateChangeCallbacks = {
+            open: [],
+            close: [],
+            error: [],
+            message: [],
+        };
+        this.accessToken = null;
+        this._connectionState = 'disconnected';
+        this._wasManualDisconnect = false;
         this._authPromise = null;
-        this._workerHeartbeatTimer = undefined;
-        this._pendingWorkerHeartbeatRef = null;
+        this._heartbeatSentAt = null;
         /**
          * Use either custom fetch, if provided, or default fetch to make HTTP requests
          *
@@ -131,9 +103,11 @@ class RealtimeClient {
             throw new Error('API key is required to connect to Realtime');
         }
         this.apiKey = options.params.apikey;
-        const socketAdapterOptions = this._initializeOptions(options);
-        this.socketAdapter = new socketAdapter_1.default(endPoint, socketAdapterOptions);
+        // Initialize endpoint URLs
+        this.endPoint = `${endPoint}/${constants_1.TRANSPORTS.websocket}`;
         this.httpEndpoint = (0, transformers_1.httpEndpointURL)(endPoint);
+        this._initializeOptions(options);
+        this._setupReconnectionTimer();
         this.fetch = this._resolveFetch(options === null || options === void 0 ? void 0 : options.fetch);
     }
     /**
@@ -141,44 +115,55 @@ class RealtimeClient {
      */
     connect() {
         // Skip if already connecting, disconnecting, or connected
-        if (this.isConnecting() || this.isDisconnecting() || this.isConnected()) {
+        if (this.isConnecting() ||
+            this.isDisconnecting() ||
+            (this.conn !== null && this.isConnected())) {
             return;
         }
+        this._setConnectionState('connecting');
         // Trigger auth if needed and not already in progress
         // This ensures auth is called for standalone RealtimeClient usage
         // while avoiding race conditions with SupabaseClient's immediate setAuth call
         if (this.accessToken && !this._authPromise) {
             this._setAuthSafely('connect');
         }
-        this._setupConnectionHandlers();
-        try {
-            this.socketAdapter.connect();
-        }
-        catch (error) {
-            const errorMessage = error.message;
-            // Provide helpful error message based on environment
-            if (errorMessage.includes('Node.js')) {
-                throw new Error(`${errorMessage}\n\n` +
-                    'To use Realtime in Node.js, you need to provide a WebSocket implementation:\n\n' +
-                    'Option 1: Use Node.js 22+ which has native WebSocket support\n' +
-                    'Option 2: Install and provide the "ws" package:\n\n' +
-                    '  npm install ws\n\n' +
-                    '  import ws from "ws"\n' +
-                    '  const client = new RealtimeClient(url, {\n' +
-                    '    ...options,\n' +
-                    '    transport: ws\n' +
-                    '  })');
+        // Establish WebSocket connection
+        if (this.transport) {
+            // Use custom transport if provided
+            this.conn = new this.transport(this.endpointURL());
+        }
+        else {
+            // Try to use native WebSocket
+            try {
+                this.conn = websocket_factory_1.default.createWebSocket(this.endpointURL());
+            }
+            catch (error) {
+                this._setConnectionState('disconnected');
+                const errorMessage = error.message;
+                // Provide helpful error message based on environment
+                if (errorMessage.includes('Node.js')) {
+                    throw new Error(`${errorMessage}\n\n` +
+                        'To use Realtime in Node.js, you need to provide a WebSocket implementation:\n\n' +
+                        'Option 1: Use Node.js 22+ which has native WebSocket support\n' +
+                        'Option 2: Install and provide the "ws" package:\n\n' +
+                        '  npm install ws\n\n' +
+                        '  import ws from "ws"\n' +
+                        '  const client = new RealtimeClient(url, {\n' +
+                        '    ...options,\n' +
+                        '    transport: ws\n' +
+                        '  })');
+                }
+                throw new Error(`WebSocket not available: ${errorMessage}`);
             }
-            throw new Error(`WebSocket not available: ${errorMessage}`);
         }
-        this._handleNodeJsRaceCondition();
+        this._setupConnectionHandlers();
     }
     /**
      * Returns the URL of the websocket.
      * @returns string The URL of the websocket.
      */
     endpointURL() {
-        return this.socketAdapter.endPointURL();
+        return this._appendParams(this.endPoint, Object.assign({}, this.params, { vsn: this.vsn }));
     }
     /**
      * Disconnects the socket.
@@ -186,14 +171,34 @@ class RealtimeClient {
      * @param code A numeric status code to send on disconnect.
      * @param reason A custom reason for the disconnect.
      */
-    async disconnect(code, reason) {
+    disconnect(code, reason) {
         if (this.isDisconnecting()) {
-            return 'ok';
+            return;
+        }
+        this._setConnectionState('disconnecting', true);
+        if (this.conn) {
+            // Setup fallback timer to prevent hanging in disconnecting state
+            const fallbackTimer = setTimeout(() => {
+                this._setConnectionState('disconnected');
+            }, 100);
+            this.conn.onclose = () => {
+                clearTimeout(fallbackTimer);
+                this._setConnectionState('disconnected');
+            };
+            // Close the WebSocket connection if close method exists
+            if (typeof this.conn.close === 'function') {
+                if (code) {
+                    this.conn.close(code, reason !== null && reason !== void 0 ? reason : '');
+                }
+                else {
+                    this.conn.close();
+                }
+            }
+            this._teardownConnection();
+        }
+        else {
+            this._setConnectionState('disconnected');
         }
-        return await this.socketAdapter.disconnect(() => {
-            clearInterval(this._workerHeartbeatTimer);
-            this._terminateWorker();
-        }, code, reason);
     }
     /**
      * Returns all created channels
@@ -202,63 +207,65 @@ class RealtimeClient {
         return this.channels;
     }
     /**
-     * Unsubscribes, removes and tears down a single channel
+     * Unsubscribes and removes a single channel
      * @param channel A RealtimeChannel instance
      */
     async removeChannel(channel) {
         const status = await channel.unsubscribe();
-        if (status === 'ok') {
-            channel.teardown();
-        }
         if (this.channels.length === 0) {
             this.disconnect();
         }
         return status;
     }
     /**
-     * Unsubscribes, removes and tears down all channels
+     * Unsubscribes and removes all channels
      */
     async removeAllChannels() {
-        const promises = this.channels.map(async (channel) => {
-            const result = await channel.unsubscribe();
-            channel.teardown();
-            return result;
-        });
-        const result = await Promise.all(promises);
+        const values_1 = await Promise.all(this.channels.map((channel) => channel.unsubscribe()));
+        this.channels = [];
         this.disconnect();
-        return result;
+        return values_1;
     }
     /**
      * Logs the message.
      *
-     * For customized logging, `this.logger` can be overridden in Client constructor.
+     * For customized logging, `this.logger` can be overridden.
      */
     log(kind, msg, data) {
-        this.socketAdapter.log(kind, msg, data);
+        this.logger(kind, msg, data);
     }
     /**
      * Returns the current state of the socket.
      */
     connectionState() {
-        return this.socketAdapter.connectionState() || constants_1.CONNECTION_STATE.closed;
+        switch (this.conn && this.conn.readyState) {
+            case constants_1.SOCKET_STATES.connecting:
+                return constants_1.CONNECTION_STATE.Connecting;
+            case constants_1.SOCKET_STATES.open:
+                return constants_1.CONNECTION_STATE.Open;
+            case constants_1.SOCKET_STATES.closing:
+                return constants_1.CONNECTION_STATE.Closing;
+            default:
+                return constants_1.CONNECTION_STATE.Closed;
+        }
     }
     /**
      * Returns `true` is the connection is open.
      */
     isConnected() {
-        return this.socketAdapter.isConnected();
+        return this.connectionState() === constants_1.CONNECTION_STATE.Open;
     }
     /**
      * Returns `true` if the connection is currently connecting.
      */
     isConnecting() {
-        return this.socketAdapter.isConnecting();
+        return this._connectionState === 'connecting';
     }
     /**
      * Returns `true` if the connection is currently disconnecting.
      */
     isDisconnecting() {
-        return this.socketAdapter.isDisconnecting();
+        return this._connectionState === 'disconnecting';
     }
     /**
      * Creates (or reuses) a {@link RealtimeChannel} for the provided topic.
@@ -285,7 +292,20 @@ class RealtimeClient {
      * If the socket is not connected, the message gets enqueued within a local buffer, and sent out when a connection is next established.
      */
     push(data) {
-        this.socketAdapter.push(data);
+        const { topic, event, payload, ref } = data;
+        const callback = () => {
+            this.encode(data, (result) => {
+                var _a;
+                (_a = this.conn) === null || _a === void 0 ? void 0 : _a.send(result);
+            });
+        };
+        this.log('push', `${topic} ${event} (${ref})`, payload);
+        if (this.isConnected()) {
+            callback();
+        }
+        else {
+            this.sendBuffer.push(callback);
+        }
     }
     /**
      * Sets the JWT access token used for channel subscription authorization and Realtime RLS.
@@ -328,14 +348,70 @@ class RealtimeClient {
      * Sends a heartbeat message if the socket is connected.
      */
     async sendHeartbeat() {
-        this.socketAdapter.sendHeartbeat();
+        var _a;
+        if (!this.isConnected()) {
+            try {
+                this.heartbeatCallback('disconnected');
+            }
+            catch (e) {
+                this.log('error', 'error in heartbeat callback', e);
+            }
+            return;
+        }
+        // Handle heartbeat timeout and force reconnection if needed
+        if (this.pendingHeartbeatRef) {
+            this.pendingHeartbeatRef = null;
+            this._heartbeatSentAt = null;
+            this.log('transport', 'heartbeat timeout. Attempting to re-establish connection');
+            try {
+                this.heartbeatCallback('timeout');
+            }
+            catch (e) {
+                this.log('error', 'error in heartbeat callback', e);
+            }
+            // Force reconnection after heartbeat timeout
+            this._wasManualDisconnect = false;
+            (_a = this.conn) === null || _a === void 0 ? void 0 : _a.close(constants_1.WS_CLOSE_NORMAL, 'heartbeat timeout');
+            setTimeout(() => {
+                var _a;
+                if (!this.isConnected()) {
+                    (_a = this.reconnectTimer) === null || _a === void 0 ? void 0 : _a.scheduleTimeout();
+                }
+            }, CONNECTION_TIMEOUTS.HEARTBEAT_TIMEOUT_FALLBACK);
+            return;
+        }
+        // Send heartbeat message to server
+        this._heartbeatSentAt = Date.now();
+        this.pendingHeartbeatRef = this._makeRef();
+        this.push({
+            topic: 'phoenix',
+            event: 'heartbeat',
+            payload: {},
+            ref: this.pendingHeartbeatRef,
+        });
+        try {
+            this.heartbeatCallback('sent');
+        }
+        catch (e) {
+            this.log('error', 'error in heartbeat callback', e);
+        }
+        this._setAuthSafely('heartbeat');
     }
     /**
      * Sets a callback that receives lifecycle events for internal heartbeat messages.
      * Useful for instrumenting connection health (e.g. sent/ok/timeout/disconnected).
      */
     onHeartbeat(callback) {
-        this.socketAdapter.heartbeatCallback = this._wrapHeartbeatCallback(callback);
+        this.heartbeatCallback = callback;
+    }
+    /**
+     * Flushes send buffer
+     */
+    flushSendBuffer() {
+        if (this.isConnected() && this.sendBuffer.length > 0) {
+            this.sendBuffer.forEach((callback) => callback());
+            this.sendBuffer = [];
+        }
     }
     /**
      * Return the next message ref, accounting for overflows
@@ -343,10 +419,29 @@ class RealtimeClient {
      * @internal
      */
     _makeRef() {
-        return this.socketAdapter.makeRef();
+        let newRef = this.ref + 1;
+        if (newRef === this.ref) {
+            this.ref = 0;
+        }
+        else {
+            this.ref = newRef;
+        }
+        return this.ref.toString();
     }
     /**
-     * Removes a channel from RealtimeClient
+     * Unsubscribe from channels with the specified topic.
+     *
+     * @internal
+     */
+    _leaveOpenTopic(topic) {
+        let dupChannel = this.channels.find((c) => c.topic === topic && (c._isJoined() || c._isJoining()));
+        if (dupChannel) {
+            this.log('transport', `leaving duplicate topic "${topic}"`);
+            dupChannel.unsubscribe();
+        }
+    }
+    /**
+     * Removes a subscription from the socket.
      *
      * @param channel An open subscription.
      *
@@ -355,6 +450,262 @@ class RealtimeClient {
     _remove(channel) {
         this.channels = this.channels.filter((c) => c.topic !== channel.topic);
     }
+    /** @internal */
+    _onConnMessage(rawMessage) {
+        this.decode(rawMessage.data, (msg) => {
+            // Handle heartbeat responses
+            if (msg.topic === 'phoenix' &&
+                msg.event === 'phx_reply' &&
+                msg.ref &&
+                msg.ref === this.pendingHeartbeatRef) {
+                const latency = this._heartbeatSentAt ? Date.now() - this._heartbeatSentAt : undefined;
+                try {
+                    this.heartbeatCallback(msg.payload.status === 'ok' ? 'ok' : 'error', latency);
+                }
+                catch (e) {
+                    this.log('error', 'error in heartbeat callback', e);
+                }
+                this._heartbeatSentAt = null;
+                this.pendingHeartbeatRef = null;
+            }
+            // Log incoming message
+            const { topic, event, payload, ref } = msg;
+            const refString = ref ? `(${ref})` : '';
+            const status = payload.status || '';
+            this.log('receive', `${status} ${topic} ${event} ${refString}`.trim(), payload);
+            // Route message to appropriate channels
+            this.channels
+                .filter((channel) => channel._isMember(topic))
+                .forEach((channel) => channel._trigger(event, payload, ref));
+            this._triggerStateCallbacks('message', msg);
+        });
+    }
+    /**
+     * Clear specific timer
+     * @internal
+     */
+    _clearTimer(timer) {
+        var _a;
+        if (timer === 'heartbeat' && this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = undefined;
+        }
+        else if (timer === 'reconnect') {
+            (_a = this.reconnectTimer) === null || _a === void 0 ? void 0 : _a.reset();
+        }
+    }
+    /**
+     * Clear all timers
+     * @internal
+     */
+    _clearAllTimers() {
+        this._clearTimer('heartbeat');
+        this._clearTimer('reconnect');
+    }
+    /**
+     * Setup connection handlers for WebSocket events
+     * @internal
+     */
+    _setupConnectionHandlers() {
+        if (!this.conn)
+            return;
+        // Set binary type if supported (browsers and most WebSocket implementations)
+        if ('binaryType' in this.conn) {
+            ;
+            this.conn.binaryType = 'arraybuffer';
+        }
+        this.conn.onopen = () => this._onConnOpen();
+        this.conn.onerror = (error) => this._onConnError(error);
+        this.conn.onmessage = (event) => this._onConnMessage(event);
+        this.conn.onclose = (event) => this._onConnClose(event);
+        if (this.conn.readyState === constants_1.SOCKET_STATES.open) {
+            this._onConnOpen();
+        }
+    }
+    /**
+     * Teardown connection and cleanup resources
+     * @internal
+     */
+    _teardownConnection() {
+        if (this.conn) {
+            if (this.conn.readyState === constants_1.SOCKET_STATES.open ||
+                this.conn.readyState === constants_1.SOCKET_STATES.connecting) {
+                try {
+                    this.conn.close();
+                }
+                catch (e) {
+                    this.log('error', 'Error closing connection', e);
+                }
+            }
+            this.conn.onopen = null;
+            this.conn.onerror = null;
+            this.conn.onmessage = null;
+            this.conn.onclose = null;
+            this.conn = null;
+        }
+        this._clearAllTimers();
+        this._terminateWorker();
+        this.channels.forEach((channel) => channel.teardown());
+    }
+    /** @internal */
+    _onConnOpen() {
+        this._setConnectionState('connected');
+        this.log('transport', `connected to ${this.endpointURL()}`);
+        // Wait for any pending auth operations before flushing send buffer
+        // This ensures channel join messages include the correct access token
+        const authPromise = this._authPromise ||
+            (this.accessToken && !this.accessTokenValue ? this.setAuth() : Promise.resolve());
+        authPromise
+            .then(() => {
+            // When subscribe() is called before the accessToken callback has
+            // resolved (common on React Native / Expo where token storage is
+            // async), the phx_join payload captured at subscribe()-time will
+            // have no access_token.  By this point auth has settled and
+            // this.accessTokenValue holds the real JWT.
+            //
+            // The stale join messages sitting in sendBuffer captured the old
+            // (token-less) payload in a closure, so we cannot simply flush
+            // them.  Instead we:
+            //   1. Patch each channel's joinPush payload with the real token
+            //   2. Drop the stale buffered messages
+            //   3. Re-send the join for any channel still in "joining" state
+            //
+            // On browsers this is a harmless no-op: accessTokenValue was
+            // already set synchronously before subscribe() ran, so the join
+            // payload already had the correct token.
+            if (this.accessTokenValue) {
+                this.channels.forEach((channel) => {
+                    channel.updateJoinPayload({ access_token: this.accessTokenValue });
+                });
+                this.sendBuffer = [];
+                this.channels.forEach((channel) => {
+                    if (channel._isJoining()) {
+                        channel.joinPush.sent = false;
+                        channel.joinPush.send();
+                    }
+                });
+            }
+            this.flushSendBuffer();
+        })
+            .catch((e) => {
+            this.log('error', 'error waiting for auth on connect', e);
+            // Proceed anyway to avoid hanging connections
+            this.flushSendBuffer();
+        });
+        this._clearTimer('reconnect');
+        if (!this.worker) {
+            this._startHeartbeat();
+        }
+        else {
+            if (!this.workerRef) {
+                this._startWorkerHeartbeat();
+            }
+        }
+        this._triggerStateCallbacks('open');
+    }
+    /** @internal */
+    _startHeartbeat() {
+        this.heartbeatTimer && clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = setInterval(() => this.sendHeartbeat(), this.heartbeatIntervalMs);
+    }
+    /** @internal */
+    _startWorkerHeartbeat() {
+        if (this.workerUrl) {
+            this.log('worker', `starting worker for from ${this.workerUrl}`);
+        }
+        else {
+            this.log('worker', `starting default worker`);
+        }
+        const objectUrl = this._workerObjectUrl(this.workerUrl);
+        this.workerRef = new Worker(objectUrl);
+        this.workerRef.onerror = (error) => {
+            this.log('worker', 'worker error', error.message);
+            this._terminateWorker();
+        };
+        this.workerRef.onmessage = (event) => {
+            if (event.data.event === 'keepAlive') {
+                this.sendHeartbeat();
+            }
+        };
+        this.workerRef.postMessage({
+            event: 'start',
+            interval: this.heartbeatIntervalMs,
+        });
+    }
+    /**
+     * Terminate the Web Worker and clear the reference
+     * @internal
+     */
+    _terminateWorker() {
+        if (this.workerRef) {
+            this.log('worker', 'terminating worker');
+            this.workerRef.terminate();
+            this.workerRef = undefined;
+        }
+    }
+    /** @internal */
+    _onConnClose(event) {
+        var _a;
+        this._setConnectionState('disconnected');
+        this.log('transport', 'close', event);
+        this._triggerChanError();
+        this._clearTimer('heartbeat');
+        // Only schedule reconnection if it wasn't a manual disconnect
+        if (!this._wasManualDisconnect) {
+            (_a = this.reconnectTimer) === null || _a === void 0 ? void 0 : _a.scheduleTimeout();
+        }
+        this._triggerStateCallbacks('close', event);
+    }
+    /** @internal */
+    _onConnError(error) {
+        this._setConnectionState('disconnected');
+        this.log('transport', `${error}`);
+        this._triggerChanError();
+        this._triggerStateCallbacks('error', error);
+        try {
+            this.heartbeatCallback('error');
+        }
+        catch (e) {
+            this.log('error', 'error in heartbeat callback', e);
+        }
+    }
+    /** @internal */
+    _triggerChanError() {
+        this.channels.forEach((channel) => channel._trigger(constants_1.CHANNEL_EVENTS.error));
+    }
+    /** @internal */
+    _appendParams(url, params) {
+        if (Object.keys(params).length === 0) {
+            return url;
+        }
+        const prefix = url.match(/\?/) ? '&' : '?';
+        const query = new URLSearchParams(params);
+        return `${url}${prefix}${query}`;
+    }
+    _workerObjectUrl(url) {
+        let result_url;
+        if (url) {
+            result_url = url;
+        }
+        else {
+            const blob = new Blob([WORKER_SCRIPT], { type: 'application/javascript' });
+            result_url = URL.createObjectURL(blob);
+        }
+        return result_url;
+    }
+    /**
+     * Set connection state with proper state management
+     * @internal
+     */
+    _setConnectionState(state, manual = false) {
+        this._connectionState = state;
+        if (state === 'connecting') {
+            this._wasManualDisconnect = false;
+        }
+        else if (state === 'disconnecting') {
+            this._wasManualDisconnect = manual;
+        }
+    }
     /**
      * Perform the actual auth operation
      * @internal
@@ -397,8 +748,8 @@ class RealtimeClient {
                     version: constants_1.DEFAULT_VERSION,
                 };
                 tokenToSend && channel.updateJoinPayload(payload);
-                if (channel.joinedOnce && channel.channelAdapter.isJoined()) {
-                    channel.channelAdapter.push(constants_1.CHANNEL_EVENTS.access_token, {
+                if (channel.joinedOnce && channel._isJoined()) {
+                    channel._push(constants_1.CHANNEL_EVENTS.access_token, {
                         access_token: tokenToSend,
                     });
                 }
@@ -426,139 +777,85 @@ class RealtimeClient {
             });
         }
     }
-    /** @internal */
-    _setupConnectionHandlers() {
-        this.socketAdapter.onOpen(() => {
-            const authPromise = this._authPromise ||
-                (this.accessToken && !this.accessTokenValue ? this.setAuth() : Promise.resolve());
-            authPromise.catch((e) => {
-                this.log('error', 'error waiting for auth on connect', e);
+    /**
+     * Trigger state change callbacks with proper error handling
+     * @internal
+     */
+    _triggerStateCallbacks(event, data) {
+        try {
+            this.stateChangeCallbacks[event].forEach((callback) => {
+                try {
+                    callback(data);
+                }
+                catch (e) {
+                    this.log('error', `error in ${event} callback`, e);
+                }
             });
-            if (this.worker && !this.workerRef) {
-                this._startWorkerHeartbeat();
-            }
-        });
-        this.socketAdapter.onClose(() => {
-            if (this.worker && this.workerRef) {
-                this._terminateWorker();
-            }
-        });
-        this.socketAdapter.onMessage((message) => {
-            if (message.ref && message.ref === this._pendingWorkerHeartbeatRef) {
-                this._pendingWorkerHeartbeatRef = null;
-            }
-        });
-    }
-    /** @internal */
-    _handleNodeJsRaceCondition() {
-        if (this.socketAdapter.isConnected()) {
-            // hack: ensure onConnOpen is called
-            this.socketAdapter.getSocket().onConnOpen();
         }
-    }
-    /** @internal */
-    _wrapHeartbeatCallback(heartbeatCallback) {
-        return (status, latency) => {
-            if (status == 'sent')
-                this._setAuthSafely();
-            if (heartbeatCallback)
-                heartbeatCallback(status, latency);
-        };
-    }
-    /** @internal */
-    _startWorkerHeartbeat() {
-        if (this.workerUrl) {
-            this.log('worker', `starting worker for from ${this.workerUrl}`);
-        }
-        else {
-            this.log('worker', `starting default worker`);
+        catch (e) {
+            this.log('error', `error triggering ${event} callbacks`, e);
         }
-        const objectUrl = this._workerObjectUrl(this.workerUrl);
-        this.workerRef = new Worker(objectUrl);
-        this.workerRef.onerror = (error) => {
-            this.log('worker', 'worker error', error.message);
-            this._terminateWorker();
-            this.disconnect();
-        };
-        this.workerRef.onmessage = (event) => {
-            if (event.data.event === 'keepAlive') {
-                this.sendHeartbeat();
-            }
-        };
-        this.workerRef.postMessage({
-            event: 'start',
-            interval: this.heartbeatIntervalMs,
-        });
     }
     /**
-     * Terminate the Web Worker and clear the reference
+     * Setup reconnection timer with proper configuration
      * @internal
      */
-    _terminateWorker() {
-        if (this.workerRef) {
-            this.log('worker', 'terminating worker');
-            this.workerRef.terminate();
-            this.workerRef = undefined;
-        }
-    }
-    /** @internal */
-    _workerObjectUrl(url) {
-        let result_url;
-        if (url) {
-            result_url = url;
-        }
-        else {
-            const blob = new Blob([WORKER_SCRIPT], { type: 'application/javascript' });
-            result_url = URL.createObjectURL(blob);
-        }
-        return result_url;
+    _setupReconnectionTimer() {
+        this.reconnectTimer = new timer_1.default(async () => {
+            setTimeout(async () => {
+                await this._waitForAuthIfNeeded();
+                if (!this.isConnected()) {
+                    this.connect();
+                }
+            }, CONNECTION_TIMEOUTS.RECONNECT_DELAY);
+        }, this.reconnectAfterMs);
     }
     /**
-     * Initialize socket options with defaults
+     * Initialize client options with defaults
      * @internal
      */
     _initializeOptions(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        this.worker = (_a = options === null || options === void 0 ? void 0 : options.worker) !== null && _a !== void 0 ? _a : false;
-        this.accessToken = (_b = options === null || options === void 0 ? void 0 : options.accessToken) !== null && _b !== void 0 ? _b : null;
-        const result = {};
-        result.timeout = (_c = options === null || options === void 0 ? void 0 : options.timeout) !== null && _c !== void 0 ? _c : constants_1.DEFAULT_TIMEOUT;
-        result.heartbeatIntervalMs =
-            (_d = options === null || options === void 0 ? void 0 : options.heartbeatIntervalMs) !== null && _d !== void 0 ? _d : CONNECTION_TIMEOUTS.HEARTBEAT_INTERVAL;
-        result.vsn = (_e = options === null || options === void 0 ? void 0 : options.vsn) !== null && _e !== void 0 ? _e : constants_1.DEFAULT_VSN;
-        // @ts-ignore - mismatch between phoenix and supabase
-        result.transport = (_f = options === null || options === void 0 ? void 0 : options.transport) !== null && _f !== void 0 ? _f : websocket_factory_1.default.getWebSocketConstructor();
-        result.params = options === null || options === void 0 ? void 0 : options.params;
-        result.logger = options === null || options === void 0 ? void 0 : options.logger;
-        result.heartbeatCallback = this._wrapHeartbeatCallback(options === null || options === void 0 ? void 0 : options.heartbeatCallback);
-        result.reconnectAfterMs =
-            (_g = options === null || options === void 0 ? void 0 : options.reconnectAfterMs) !== null && _g !== void 0 ? _g : ((tries) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        // Set defaults
+        this.transport = (_a = options === null || options === void 0 ? void 0 : options.transport) !== null && _a !== void 0 ? _a : null;
+        this.timeout = (_b = options === null || options === void 0 ? void 0 : options.timeout) !== null && _b !== void 0 ? _b : constants_1.DEFAULT_TIMEOUT;
+        this.heartbeatIntervalMs =
+            (_c = options === null || options === void 0 ? void 0 : options.heartbeatIntervalMs) !== null && _c !== void 0 ? _c : CONNECTION_TIMEOUTS.HEARTBEAT_INTERVAL;
+        this.worker = (_d = options === null || options === void 0 ? void 0 : options.worker) !== null && _d !== void 0 ? _d : false;
+        this.accessToken = (_e = options === null || options === void 0 ? void 0 : options.accessToken) !== null && _e !== void 0 ? _e : null;
+        this.heartbeatCallback = (_f = options === null || options === void 0 ? void 0 : options.heartbeatCallback) !== null && _f !== void 0 ? _f : noop;
+        this.vsn = (_g = options === null || options === void 0 ? void 0 : options.vsn) !== null && _g !== void 0 ? _g : constants_1.DEFAULT_VSN;
+        // Handle special cases
+        if (options === null || options === void 0 ? void 0 : options.params)
+            this.params = options.params;
+        if (options === null || options === void 0 ? void 0 : options.logger)
+            this.logger = options.logger;
+        if ((options === null || options === void 0 ? void 0 : options.logLevel) || (options === null || options === void 0 ? void 0 : options.log_level)) {
+            this.logLevel = options.logLevel || options.log_level;
+            this.params = Object.assign(Object.assign({}, this.params), { log_level: this.logLevel });
+        }
+        // Set up functions with defaults
+        this.reconnectAfterMs =
+            (_h = options === null || options === void 0 ? void 0 : options.reconnectAfterMs) !== null && _h !== void 0 ? _h : ((tries) => {
                 return RECONNECT_INTERVALS[tries - 1] || DEFAULT_RECONNECT_FALLBACK;
             });
-        let defaultEncode;
-        let defaultDecode;
-        switch (result.vsn) {
+        switch (this.vsn) {
             case constants_1.VSN_1_0_0:
-                defaultEncode = (payload, callback) => {
-                    return callback(JSON.stringify(payload));
-                };
-                defaultDecode = (payload, callback) => {
-                    return callback(JSON.parse(payload));
-                };
+                this.encode =
+                    (_j = options === null || options === void 0 ? void 0 : options.encode) !== null && _j !== void 0 ? _j : ((payload, callback) => {
+                        return callback(JSON.stringify(payload));
+                    });
+                this.decode =
+                    (_k = options === null || options === void 0 ? void 0 : options.decode) !== null && _k !== void 0 ? _k : ((payload, callback) => {
+                        return callback(JSON.parse(payload));
+                    });
                 break;
             case constants_1.VSN_2_0_0:
-                defaultEncode = this.serializer.encode.bind(this.serializer);
-                defaultDecode = this.serializer.decode.bind(this.serializer);
+                this.encode = (_l = options === null || options === void 0 ? void 0 : options.encode) !== null && _l !== void 0 ? _l : this.serializer.encode.bind(this.serializer);
+                this.decode = (_m = options === null || options === void 0 ? void 0 : options.decode) !== null && _m !== void 0 ? _m : this.serializer.decode.bind(this.serializer);
                 break;
             default:
-                throw new Error(`Unsupported serializer version: ${result.vsn}`);
-        }
-        result.encode = (_h = options === null || options === void 0 ? void 0 : options.encode) !== null && _h !== void 0 ? _h : defaultEncode;
-        result.decode = (_j = options === null || options === void 0 ? void 0 : options.decode) !== null && _j !== void 0 ? _j : defaultDecode;
-        result.beforeReconnect = this._reconnectAuth.bind(this);
-        if ((options === null || options === void 0 ? void 0 : options.logLevel) || (options === null || options === void 0 ? void 0 : options.log_level)) {
-            this.logLevel = options.logLevel || options.log_level;
-            result.params = Object.assign(Object.assign({}, result.params), { log_level: this.logLevel });
+                throw new Error(`Unsupported serializer version: ${this.vsn}`);
         }
         // Handle worker setup
         if (this.worker) {
@@ -566,15 +863,6 @@ class RealtimeClient {
                 throw new Error('Web Worker is not supported');
             }
             this.workerUrl = options === null || options === void 0 ? void 0 : options.workerUrl;
-            result.autoSendHeartbeat = !this.worker;
-        }
-        return result;
-    }
-    /** @internal */
-    async _reconnectAuth() {
-        await this._waitForAuthIfNeeded();
-        if (!this.isConnected()) {
-            this.connect();
         }
     }
 }