@metamask/core-backend 4.0.0 → 4.1.0

package/dist/BackendWebSocketService.mjs

@@ -9,13 +9,18 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _BackendWebSocketService_instances, _BackendWebSocketService_messenger, _BackendWebSocketService_options, _BackendWebSocketService_isEnabled, _BackendWebSocketService_trace, _BackendWebSocketService_ws, _BackendWebSocketService_state, _BackendWebSocketService_reconnectAttempts, _BackendWebSocketService_reconnectTimer, _BackendWebSocketService_connectionTimeout, _BackendWebSocketService_stableConnectionTimer, _BackendWebSocketService_connectionPromise, _BackendWebSocketService_pendingRequests, _BackendWebSocketService_connectedAt, _BackendWebSocketService_manualDisconnect, _BackendWebSocketService_subscriptions, _BackendWebSocketService_channelCallbacks, _BackendWebSocketService_backoff, _BackendWebSocketService_subscribeEvents, _BackendWebSocketService_buildAuthenticatedUrl, _BackendWebSocketService_establishConnection, _BackendWebSocketService_handleMessage, _BackendWebSocketService_isServerResponse, _BackendWebSocketService_isSubscriptionNotification, _BackendWebSocketService_isChannelMessage, _BackendWebSocketService_handleServerResponse, _BackendWebSocketService_handleChannelMessage, _BackendWebSocketService_handleSubscriptionNotification, _BackendWebSocketService_parseMessage, _BackendWebSocketService_handleClose, _BackendWebSocketService_handleError, _BackendWebSocketService_scheduleReconnect, _BackendWebSocketService_newBackoff, _BackendWebSocketService_clearTimers, _BackendWebSocketService_clearPendingRequests, _BackendWebSocketService_clearSubscriptions, _BackendWebSocketService_setState;
+var _BackendWebSocketService_instances, _BackendWebSocketService_messenger, _BackendWebSocketService_options, _BackendWebSocketService_isEnabled, _BackendWebSocketService_trace, _BackendWebSocketService_ws, _BackendWebSocketService_state, _BackendWebSocketService_reconnectAttempts, _BackendWebSocketService_reconnectTimer, _BackendWebSocketService_connectionTimeout, _BackendWebSocketService_stableConnectionTimer, _BackendWebSocketService_connectionPromise, _BackendWebSocketService_pendingRequests, _BackendWebSocketService_connectedAt, _BackendWebSocketService_subscriptions, _BackendWebSocketService_channelCallbacks, _BackendWebSocketService_backoff, _BackendWebSocketService_subscribeEvents, _BackendWebSocketService_buildAuthenticatedUrl, _BackendWebSocketService_establishConnection, _BackendWebSocketService_handleMessage, _BackendWebSocketService_isServerResponse, _BackendWebSocketService_isSubscriptionNotification, _BackendWebSocketService_isChannelMessage, _BackendWebSocketService_handleServerResponse, _BackendWebSocketService_handleChannelMessage, _BackendWebSocketService_handleSubscriptionNotification, _BackendWebSocketService_parseMessage, _BackendWebSocketService_handleError, _BackendWebSocketService_scheduleReconnect, _BackendWebSocketService_newBackoff, _BackendWebSocketService_clearTimers, _BackendWebSocketService_clearPendingRequests, _BackendWebSocketService_clearSubscriptions, _BackendWebSocketService_setState;
 import { ExponentialBackoff } from "@metamask/controller-utils";
 import { getErrorMessage } from "@metamask/utils";
 import { v4 as uuidV4 } from "uuid";
 import { projectLogger, createModuleLogger } from "./logger.mjs";
 const SERVICE_NAME = 'BackendWebSocketService';
 const log = createModuleLogger(projectLogger, SERVICE_NAME);
+// WebSocket close codes and reasons for internal operations
+const MANUAL_DISCONNECT_CODE = 4999;
+const MANUAL_DISCONNECT_REASON = 'Internal: Manual disconnect';
+const FORCE_RECONNECT_CODE = 4998;
+const FORCE_RECONNECT_REASON = 'Internal: Force reconnect';
 const MESSENGER_EXPOSED_METHODS = [
     'connect',
     'disconnect',
@@ -88,8 +93,10 @@ export var WebSocketState;
 (function (WebSocketState) {
     WebSocketState["CONNECTING"] = "connecting";
     WebSocketState["CONNECTED"] = "connected";
+    /** @deprecated This value is no longer used internally and will be removed in a future major release */
     WebSocketState["DISCONNECTING"] = "disconnecting";
     WebSocketState["DISCONNECTED"] = "disconnected";
+    /** @deprecated TThis value is no longer used internally and will be removed in a future major release */
     WebSocketState["ERROR"] = "error";
 })(WebSocketState || (WebSocketState = {}));
 /**
@@ -155,8 +162,6 @@ export class BackendWebSocketService {
         _BackendWebSocketService_connectionPromise.set(this, null);
         _BackendWebSocketService_pendingRequests.set(this, new Map());
         _BackendWebSocketService_connectedAt.set(this, 0);
-        // Track manual disconnects to prevent automatic reconnection
-        _BackendWebSocketService_manualDisconnect.set(this, false);
         // Simplified subscription storage (single flat map)
         // Key: subscription ID string (e.g., 'sub_abc123def456')
         // Value: WebSocketSubscription object with channels, callback and metadata
@@ -176,8 +181,8 @@ export class BackendWebSocketService {
         __classPrivateFieldSet(this, _BackendWebSocketService_options, {
             url: options.url,
             timeout: options.timeout ?? 10000,
-            reconnectDelay: options.reconnectDelay ?? 500,
-            maxReconnectDelay: options.maxReconnectDelay ?? 5000,
+            reconnectDelay: options.reconnectDelay ?? 10000,
+            maxReconnectDelay: options.maxReconnectDelay ?? 60000,
             requestTimeout: options.requestTimeout ?? 30000,
         }, "f");
         // Initialize backoff for reconnection delays
@@ -204,8 +209,6 @@ export class BackendWebSocketService {
      * @returns Promise that resolves when connection is established
      */
     async connect() {
-        // Reset manual disconnect flag when explicitly connecting
-        __classPrivateFieldSet(this, _BackendWebSocketService_manualDisconnect, false, "f");
         // Priority 1: Check if feature is enabled via callback (feature flag check)
         // If feature is disabled, stop all connection attempts
         if (__classPrivateFieldGet(this, _BackendWebSocketService_isEnabled, "f") && !__classPrivateFieldGet(this, _BackendWebSocketService_isEnabled, "f").call(this)) {
@@ -244,17 +247,8 @@ export class BackendWebSocketService {
                 log('Failed to check authentication requirements', { error });
                 throw error;
             }
-            __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.CONNECTING);
             // Establish the actual WebSocket connection
-            try {
-                await __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_establishConnection).call(this, bearerToken);
-            }
-            catch (error) {
-                const errorMessage = getErrorMessage(error);
-                log('Connection attempt failed', { errorMessage, error });
-                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.ERROR);
-                throw error;
-            }
+            await __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_establishConnection).call(this, bearerToken);
         })(), "f");
         try {
             await __classPrivateFieldGet(this, _BackendWebSocketService_connectionPromise, "f");
@@ -273,22 +267,11 @@ export class BackendWebSocketService {
      * Closes WebSocket connection
      */
     disconnect() {
-        if (__classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.DISCONNECTED ||
-            __classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.DISCONNECTING) {
+        if (__classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.DISCONNECTED || !__classPrivateFieldGet(this, _BackendWebSocketService_ws, "f")) {
             return;
         }
-        // Mark this as a manual disconnect to prevent automatic reconnection
-        __classPrivateFieldSet(this, _BackendWebSocketService_manualDisconnect, true, "f");
-        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.DISCONNECTING);
-        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearTimers).call(this);
-        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearPendingRequests).call(this, new Error('WebSocket disconnected'));
-        // Clear any pending connection promise
-        __classPrivateFieldSet(this, _BackendWebSocketService_connectionPromise, null, "f");
-        // Reset reconnect attempts on manual disconnect
-        __classPrivateFieldSet(this, _BackendWebSocketService_reconnectAttempts, 0, "f");
-        if (__classPrivateFieldGet(this, _BackendWebSocketService_ws, "f")) {
-            __classPrivateFieldGet(this, _BackendWebSocketService_ws, "f").close(1000, 'Normal closure');
-        }
+        // Close WebSocket with manual disconnect code and reason
+        __classPrivateFieldGet(this, _BackendWebSocketService_ws, "f").close(MANUAL_DISCONNECT_CODE, MANUAL_DISCONNECT_REASON);
         log('WebSocket manually disconnected');
     }
     /**
@@ -308,16 +291,15 @@ export class BackendWebSocketService {
      * @returns Promise that resolves when disconnection is complete (reconnection is scheduled)
      */
     async forceReconnection() {
-        // If a reconnect is already scheduled, don't force another one
-        if (__classPrivateFieldGet(this, _BackendWebSocketService_reconnectTimer, "f")) {
-            log('Reconnect already scheduled, skipping force reconnection');
+        if (__classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.DISCONNECTED || !__classPrivateFieldGet(this, _BackendWebSocketService_ws, "f")) {
+            log('WebSocket already disconnected, scheduling reconnect');
+            __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_scheduleReconnect).call(this);
             return;
         }
         log('Forcing WebSocket reconnection to clean up subscription state');
-        // Perform controlled disconnect
-        this.disconnect();
-        // Schedule reconnection with exponential backoff
-        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_scheduleReconnect).call(this);
+        // This ensures ws.onclose will schedule a reconnect (not treat it as manual disconnect)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        __classPrivateFieldGet(this, _BackendWebSocketService_ws, "f").close(FORCE_RECONNECT_CODE, FORCE_RECONNECT_REASON);
     }
     /**
      * Sends a message through the WebSocket (fire-and-forget, no response expected)
@@ -559,17 +541,13 @@ export class BackendWebSocketService {
      * Called when service is being destroyed or app is terminating
      */
     destroy() {
+        // Always clear timers first to prevent reconnection attempts after destruction
+        // This handles the case where destroy() is called while DISCONNECTED with a pending reconnect timer
         __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearTimers).call(this);
-        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearSubscriptions).call(this);
-        // Clear any pending connection promise
-        __classPrivateFieldSet(this, _BackendWebSocketService_connectionPromise, null, "f");
-        // Clear all pending requests
-        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearPendingRequests).call(this, new Error('Service cleanup'));
-        if (__classPrivateFieldGet(this, _BackendWebSocketService_ws, "f") && __classPrivateFieldGet(this, _BackendWebSocketService_ws, "f").readyState === WebSocket.OPEN) {
-            __classPrivateFieldGet(this, _BackendWebSocketService_ws, "f").close(1000, 'Service cleanup');
-        }
-        // Set state to disconnected immediately
-        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.DISCONNECTED);
+        // Reset reconnect attempts to prevent any future reconnection logic
+        __classPrivateFieldSet(this, _BackendWebSocketService_reconnectAttempts, 0, "f");
+        // Disconnect the WebSocket if connected (will be no-op if already disconnected)
+        this.disconnect();
     }
     /**
      * Create and manage a subscription with server-side registration (recommended for most use cases)
@@ -654,7 +632,7 @@ export class BackendWebSocketService {
         // Store subscription with subscription ID as key
         __classPrivateFieldGet(this, _BackendWebSocketService_subscriptions, "f").set(subscriptionId, {
             subscriptionId,
-            channels: [...channels],
+            channels: [...channels], // Store copy of channels
             channelType,
             callback,
             unsubscribe,
@@ -662,7 +640,7 @@ export class BackendWebSocketService {
         return subscription;
     }
 }
-_BackendWebSocketService_messenger = new WeakMap(), _BackendWebSocketService_options = new WeakMap(), _BackendWebSocketService_isEnabled = new WeakMap(), _BackendWebSocketService_trace = new WeakMap(), _BackendWebSocketService_ws = new WeakMap(), _BackendWebSocketService_state = new WeakMap(), _BackendWebSocketService_reconnectAttempts = new WeakMap(), _BackendWebSocketService_reconnectTimer = new WeakMap(), _BackendWebSocketService_connectionTimeout = new WeakMap(), _BackendWebSocketService_stableConnectionTimer = new WeakMap(), _BackendWebSocketService_connectionPromise = new WeakMap(), _BackendWebSocketService_pendingRequests = new WeakMap(), _BackendWebSocketService_connectedAt = new WeakMap(), _BackendWebSocketService_manualDisconnect = new WeakMap(), _BackendWebSocketService_subscriptions = new WeakMap(), _BackendWebSocketService_channelCallbacks = new WeakMap(), _BackendWebSocketService_backoff = new WeakMap(), _BackendWebSocketService_instances = new WeakSet(), _BackendWebSocketService_subscribeEvents = function _BackendWebSocketService_subscribeEvents() {
+_BackendWebSocketService_messenger = new WeakMap(), _BackendWebSocketService_options = new WeakMap(), _BackendWebSocketService_isEnabled = new WeakMap(), _BackendWebSocketService_trace = new WeakMap(), _BackendWebSocketService_ws = new WeakMap(), _BackendWebSocketService_state = new WeakMap(), _BackendWebSocketService_reconnectAttempts = new WeakMap(), _BackendWebSocketService_reconnectTimer = new WeakMap(), _BackendWebSocketService_connectionTimeout = new WeakMap(), _BackendWebSocketService_stableConnectionTimer = new WeakMap(), _BackendWebSocketService_connectionPromise = new WeakMap(), _BackendWebSocketService_pendingRequests = new WeakMap(), _BackendWebSocketService_connectedAt = new WeakMap(), _BackendWebSocketService_subscriptions = new WeakMap(), _BackendWebSocketService_channelCallbacks = new WeakMap(), _BackendWebSocketService_backoff = new WeakMap(), _BackendWebSocketService_instances = new WeakSet(), _BackendWebSocketService_subscribeEvents = function _BackendWebSocketService_subscribeEvents() {
     // Subscribe to authentication state changes (sign in/out)
     __classPrivateFieldGet(this, _BackendWebSocketService_messenger, "f").subscribe('AuthenticationController:stateChange', (state) => {
         if (state.isSignedIn) {
@@ -697,34 +675,31 @@ _BackendWebSocketService_messenger = new WeakMap(), _BackendWebSocketService_opt
  */
 async function _BackendWebSocketService_establishConnection(bearerToken) {
     const wsUrl = __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_buildAuthenticatedUrl).call(this, bearerToken);
-    const connectionStartTime = Date.now();
-    return new Promise((resolve, reject) => {
-        const ws = new WebSocket(wsUrl);
-        __classPrivateFieldSet(this, _BackendWebSocketService_connectionTimeout, setTimeout(() => {
-            log('WebSocket connection timeout - forcing close', {
-                timeout: __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").timeout,
-            });
-            ws.close();
-            reject(new Error(`Failed to connect to WebSocket: Connection timeout after ${__classPrivateFieldGet(this, _BackendWebSocketService_options, "f").timeout}ms`));
-        }, __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").timeout), "f");
-        ws.onopen = () => {
-            if (__classPrivateFieldGet(this, _BackendWebSocketService_connectionTimeout, "f")) {
-                clearTimeout(__classPrivateFieldGet(this, _BackendWebSocketService_connectionTimeout, "f"));
-                __classPrivateFieldSet(this, _BackendWebSocketService_connectionTimeout, null, "f");
-            }
-            // Calculate connection latency
-            const connectionLatency = Date.now() - connectionStartTime;
-            // Trace successful connection with latency
-            __classPrivateFieldGet(this, _BackendWebSocketService_trace, "f").call(this, {
-                name: `${SERVICE_NAME} Connection`,
-                data: {
-                    reconnectAttempt: __classPrivateFieldGet(this, _BackendWebSocketService_reconnectAttempts, "f"),
-                    latency_ms: connectionLatency,
-                },
-                tags: {
-                    service: SERVICE_NAME,
-                },
-            }, () => {
+    // Transition to CONNECTING state before creating WebSocket
+    __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.CONNECTING);
+    return __classPrivateFieldGet(this, _BackendWebSocketService_trace, "f").call(this, {
+        name: `${SERVICE_NAME} Connection`,
+        data: {
+            reconnectAttempt: __classPrivateFieldGet(this, _BackendWebSocketService_reconnectAttempts, "f"),
+        },
+        tags: {
+            service: SERVICE_NAME,
+        },
+    }, () => {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(wsUrl);
+            __classPrivateFieldSet(this, _BackendWebSocketService_connectionTimeout, setTimeout(() => {
+                log('WebSocket connection timeout - forcing close', {
+                    timeout: __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").timeout,
+                });
+                // Close the WebSocket - onclose will handle rejection and state change
+                ws.close();
+            }, __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").timeout), "f");
+            ws.onopen = () => {
+                if (__classPrivateFieldGet(this, _BackendWebSocketService_connectionTimeout, "f")) {
+                    clearTimeout(__classPrivateFieldGet(this, _BackendWebSocketService_connectionTimeout, "f"));
+                    __classPrivateFieldSet(this, _BackendWebSocketService_connectionTimeout, null, "f");
+                }
                 __classPrivateFieldSet(this, _BackendWebSocketService_ws, ws, "f");
                 __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.CONNECTED);
                 __classPrivateFieldSet(this, _BackendWebSocketService_connectedAt, Date.now(), "f");
@@ -738,45 +713,79 @@ async function _BackendWebSocketService_establishConnection(bearerToken) {
                     log('Connection stable - reset reconnect attempts and backoff');
                 }, 10000), "f");
                 resolve();
-            });
-        };
-        ws.onerror = (event) => {
-            log('WebSocket onerror event triggered', { event });
-            if (__classPrivateFieldGet(this, _BackendWebSocketService_connectionTimeout, "f")) {
-                clearTimeout(__classPrivateFieldGet(this, _BackendWebSocketService_connectionTimeout, "f"));
-                __classPrivateFieldSet(this, _BackendWebSocketService_connectionTimeout, null, "f");
-            }
-            const error = new Error(`WebSocket connection error to ${wsUrl}`);
-            reject(error);
-        };
-        ws.onclose = (event) => {
-            log('WebSocket onclose event triggered', {
-                code: event.code,
-                reason: event.reason,
-                wasClean: event.wasClean,
-            });
-            if (__classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.CONNECTING) {
-                // Handle connection-phase close events
-                if (__classPrivateFieldGet(this, _BackendWebSocketService_connectionTimeout, "f")) {
-                    clearTimeout(__classPrivateFieldGet(this, _BackendWebSocketService_connectionTimeout, "f"));
-                    __classPrivateFieldSet(this, _BackendWebSocketService_connectionTimeout, null, "f");
+            };
+            ws.onclose = (event) => {
+                log('WebSocket onclose event triggered', {
+                    code: event.code,
+                    reason: event.reason || getCloseReason(event.code),
+                    wasClean: event.wasClean,
+                });
+                // Guard against duplicate close events
+                if (__classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.DISCONNECTED) {
+                    return;
                 }
-                reject(new Error(`WebSocket connection closed during connection: ${event.code} ${event.reason}`));
-            }
-            else {
-                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_handleClose).call(this, event);
-            }
-        };
-        // Set up message handler immediately - no need to wait for connection
-        ws.onmessage = (event) => {
-            try {
-                const message = __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_parseMessage).call(this, event.data);
-                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_handleMessage).call(this, message);
-            }
-            catch {
-                // Silently ignore invalid JSON messages
-            }
-        };
+                // Detect if this is a manual disconnect or service cleanup based on close code
+                const isManualDisconnect = event.code === MANUAL_DISCONNECT_CODE &&
+                    event.reason === MANUAL_DISCONNECT_REASON;
+                // If connection hasn't been established yet, handle the connection promise
+                if (__classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.CONNECTING) {
+                    if (isManualDisconnect) {
+                        // Manual disconnect during connection - resolve to prevent reconnection
+                        resolve();
+                    }
+                    else {
+                        // Failed connection attempt - reject to trigger reconnection
+                        reject(new Error(`WebSocket connection closed during connection: ${event.code} ${event.reason}`));
+                    }
+                }
+                // Calculate connection duration before we clear state (only if we were connected)
+                const connectionDuration_ms = __classPrivateFieldGet(this, _BackendWebSocketService_connectedAt, "f") > 0 ? Date.now() - __classPrivateFieldGet(this, _BackendWebSocketService_connectedAt, "f") : 0;
+                // Clear all timers
+                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearTimers).call(this);
+                // Clear WebSocket reference to allow garbage collection
+                __classPrivateFieldSet(this, _BackendWebSocketService_ws, undefined, "f");
+                // Clear connection tracking
+                __classPrivateFieldSet(this, _BackendWebSocketService_connectionPromise, null, "f");
+                __classPrivateFieldSet(this, _BackendWebSocketService_connectedAt, 0, "f");
+                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearPendingRequests).call(this, new Error(`WebSocket connection closed: ${event.code} ${event.reason || getCloseReason(event.code)}`));
+                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearSubscriptions).call(this);
+                // Update state to disconnected
+                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.DISCONNECTED);
+                // Check if this was a manual disconnect
+                if (isManualDisconnect) {
+                    // Manual disconnect - reset attempts and don't reconnect
+                    __classPrivateFieldSet(this, _BackendWebSocketService_reconnectAttempts, 0, "f");
+                }
+                else {
+                    // Unexpected disconnect - schedule reconnection
+                    __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_scheduleReconnect).call(this);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                __classPrivateFieldGet(this, _BackendWebSocketService_trace, "f").call(this, {
+                    name: `${SERVICE_NAME} Disconnection`,
+                    data: {
+                        code: event.code,
+                        reason: event.reason || getCloseReason(event.code),
+                        wasClean: event.wasClean,
+                        reconnectAttempts: __classPrivateFieldGet(this, _BackendWebSocketService_reconnectAttempts, "f"),
+                        ...(connectionDuration_ms > 0 && { connectionDuration_ms }),
+                    },
+                    tags: {
+                        service: SERVICE_NAME,
+                    },
+                });
+            };
+            // Set up message handler immediately - no need to wait for connection
+            ws.onmessage = (event) => {
+                try {
+                    const message = __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_parseMessage).call(this, event.data);
+                    __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_handleMessage).call(this, message);
+                }
+                catch {
+                    // Silently ignore invalid JSON messages
+                }
+            };
+        });
     });
 }, _BackendWebSocketService_handleMessage = function _BackendWebSocketService_handleMessage(message) {
     // Handle server responses (correlated with requests) first
@@ -826,23 +835,7 @@ async function _BackendWebSocketService_establishConnection(bearerToken) {
     if (__classPrivateFieldGet(this, _BackendWebSocketService_channelCallbacks, "f").size === 0) {
         return;
     }
-    // Calculate notification latency: time from server sent to client received
-    const receivedAt = Date.now();
-    const latency = receivedAt - message.timestamp;
-    // Trace channel message processing with latency data
-    __classPrivateFieldGet(this, _BackendWebSocketService_trace, "f").call(this, {
-        name: `${SERVICE_NAME} Channel Message`,
-        data: {
-            latency_ms: latency,
-            event: message.event,
-        },
-        tags: {
-            service: SERVICE_NAME,
-        },
-    }, () => {
-        // Direct lookup for exact channel match
-        __classPrivateFieldGet(this, _BackendWebSocketService_channelCallbacks, "f").get(message.channel)?.callback(message);
-    });
+    __classPrivateFieldGet(this, _BackendWebSocketService_channelCallbacks, "f").get(message.channel)?.callback(message);
 }, _BackendWebSocketService_handleSubscriptionNotification = function _BackendWebSocketService_handleSubscriptionNotification(message) {
     const { subscriptionId, timestamp, channel } = message;
     // Only handle if subscriptionId is defined and not null (allows "0" as valid ID)
@@ -856,6 +849,8 @@ async function _BackendWebSocketService_establishConnection(bearerToken) {
         const latency = receivedAt - timestamp;
         // Trace notification processing wi th latency data
         // Use stored channelType instead of parsing each time
+        // Promise result intentionally not awaited
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         __classPrivateFieldGet(this, _BackendWebSocketService_trace, "f").call(this, {
             name: `${SERVICE_NAME} Notification`,
             data: {
@@ -875,47 +870,6 @@ async function _BackendWebSocketService_establishConnection(bearerToken) {
     return false;
 }, _BackendWebSocketService_parseMessage = function _BackendWebSocketService_parseMessage(data) {
     return JSON.parse(data);
-}, _BackendWebSocketService_handleClose = function _BackendWebSocketService_handleClose(event) {
-    // Calculate connection duration before we clear state
-    const connectionDuration = Date.now() - __classPrivateFieldGet(this, _BackendWebSocketService_connectedAt, "f");
-    if (__classPrivateFieldGet(this, _BackendWebSocketService_connectionTimeout, "f")) {
-        clearTimeout(__classPrivateFieldGet(this, _BackendWebSocketService_connectionTimeout, "f"));
-        __classPrivateFieldSet(this, _BackendWebSocketService_connectionTimeout, null, "f");
-    }
-    if (__classPrivateFieldGet(this, _BackendWebSocketService_stableConnectionTimer, "f")) {
-        clearTimeout(__classPrivateFieldGet(this, _BackendWebSocketService_stableConnectionTimer, "f"));
-        __classPrivateFieldSet(this, _BackendWebSocketService_stableConnectionTimer, null, "f");
-    }
-    __classPrivateFieldSet(this, _BackendWebSocketService_connectedAt, 0, "f");
-    // Clear any pending connection promise
-    __classPrivateFieldSet(this, _BackendWebSocketService_connectionPromise, null, "f");
-    // Clear subscriptions and pending requests on any disconnect
-    // This ensures clean state for reconnection
-    __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearPendingRequests).call(this, new Error('WebSocket connection closed'));
-    __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearSubscriptions).call(this);
-    // Update state to disconnected
-    __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.DISCONNECTED);
-    // Check if this was a manual disconnect
-    if (__classPrivateFieldGet(this, _BackendWebSocketService_manualDisconnect, "f")) {
-        // Manual disconnect - don't reconnect
-        return;
-    }
-    // Trace unexpected disconnect with details
-    __classPrivateFieldGet(this, _BackendWebSocketService_trace, "f").call(this, {
-        name: `${SERVICE_NAME} Disconnect`,
-        data: {
-            code: event.code,
-            reason: event.reason || getCloseReason(event.code),
-            connectionDuration_ms: connectionDuration,
-        },
-        tags: {
-            service: SERVICE_NAME,
-            disconnect_type: 'unexpected',
-        },
-    }, () => {
-        // Empty trace callback - just measuring the event
-    });
-    __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_scheduleReconnect).call(this);
 }, _BackendWebSocketService_handleError = function _BackendWebSocketService_handleError(_error) {
     // Placeholder for future error handling logic
 }, _BackendWebSocketService_scheduleReconnect = function _BackendWebSocketService_scheduleReconnect() {