@metamask-previews/core-backend 1.0.1-preview-25cab83 → 1.0.1-preview-8da5960

package/dist/BackendWebSocketService.mjs

@@ -9,7 +9,7 @@ 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_connectionPromise, _BackendWebSocketService_pendingRequests, _BackendWebSocketService_connectedAt, _BackendWebSocketService_manualDisconnect, _BackendWebSocketService_subscriptions, _BackendWebSocketService_channelCallbacks, _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_clearTimers, _BackendWebSocketService_clearPendingRequests, _BackendWebSocketService_clearSubscriptions, _BackendWebSocketService_setState;
+var _BackendWebSocketService_instances, _BackendWebSocketService_messenger, _BackendWebSocketService_options, _BackendWebSocketService_isEnabled, _BackendWebSocketService_ws, _BackendWebSocketService_state, _BackendWebSocketService_reconnectAttempts, _BackendWebSocketService_reconnectTimer, _BackendWebSocketService_connectionTimeout, _BackendWebSocketService_connectionPromise, _BackendWebSocketService_pendingRequests, _BackendWebSocketService_connectedAt, _BackendWebSocketService_subscriptions, _BackendWebSocketService_channelCallbacks, _BackendWebSocketService_setupAuthentication, _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_clearTimers, _BackendWebSocketService_clearPendingRequests, _BackendWebSocketService_clearSubscriptions, _BackendWebSocketService_setState, _BackendWebSocketService_shouldReconnectOnClose;
 import { getErrorMessage } from "@metamask/utils";
 import { v4 as uuidV4 } from "uuid";
 import { projectLogger, createModuleLogger } from "./logger.mjs";
@@ -105,24 +105,18 @@ export var WebSocketEventType;
 /**
  * WebSocket Service with automatic reconnection, session management and direct callback routing
  *
- * Connection Management:
- * - Automatically subscribes to AuthenticationController:stateChange (sign in/out)
- * - Automatically subscribes to KeyringController:lock/unlock events
- * - Idempotent connect() function safe for multiple rapid calls
- * - Auto-reconnects on unexpected disconnects (manualDisconnect = false)
- *
- * Platform Responsibilities:
- * - Call connect() when app opens/foregrounds
- * - Call disconnect() when app closes/backgrounds
- * - Provide isEnabled() callback (feature flag)
- * - Call destroy() on app termination
- *
  * Real-Time Performance Optimizations:
  * - Fast path message routing (zero allocations)
  * - Production mode removes try-catch overhead
  * - Optimized JSON parsing with fail-fast
  * - Direct callback routing bypasses event emitters
  * - Memory cleanup and resource management
+ *
+ * Mobile Integration:
+ * Mobile apps should handle lifecycle events (background/foreground) by:
+ * 1. Calling disconnect() when app goes to background
+ * 2. Calling connect() when app returns to foreground
+ * 3. Calling destroy() on app termination
  */
 export class BackendWebSocketService {
     // =============================================================================
@@ -142,7 +136,6 @@ export class BackendWebSocketService {
         _BackendWebSocketService_messenger.set(this, void 0);
         _BackendWebSocketService_options.set(this, void 0);
         _BackendWebSocketService_isEnabled.set(this, void 0);
-        _BackendWebSocketService_trace.set(this, void 0);
         _BackendWebSocketService_ws.set(this, void 0);
         _BackendWebSocketService_state.set(this, WebSocketState.DISCONNECTED);
         _BackendWebSocketService_reconnectAttempts.set(this, 0);
@@ -151,9 +144,7 @@ export class BackendWebSocketService {
         // Track the current connection promise to handle concurrent connection attempts
         _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);
+        _BackendWebSocketService_connectedAt.set(this, null);
         // Simplified subscription storage (single flat map)
         // Key: subscription ID string (e.g., 'sub_abc123def456')
         // Value: WebSocketSubscription object with channels, callback and metadata
@@ -164,10 +155,6 @@ export class BackendWebSocketService {
         _BackendWebSocketService_channelCallbacks.set(this, new Map());
         __classPrivateFieldSet(this, _BackendWebSocketService_messenger, options.messenger, "f");
         __classPrivateFieldSet(this, _BackendWebSocketService_isEnabled, options.isEnabled, "f");
-        // Default to no-op trace function to keep core platform-agnostic
-        __classPrivateFieldSet(this, _BackendWebSocketService_trace, options.traceFn ??
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            ((_request, fn) => fn?.()), "f");
         __classPrivateFieldSet(this, _BackendWebSocketService_options, {
             url: options.url,
             timeout: options.timeout ?? 10000,
@@ -175,8 +162,8 @@ export class BackendWebSocketService {
             maxReconnectDelay: options.maxReconnectDelay ?? 5000,
             requestTimeout: options.requestTimeout ?? 30000,
         }, "f");
-        // Subscribe to authentication and keyring controller events
-        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_subscribeEvents).call(this);
+        // Setup authentication (always enabled)
+        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setupAuthentication).call(this);
         // Register action handlers using the method actions pattern
         __classPrivateFieldGet(this, _BackendWebSocketService_messenger, "f").registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
     }
@@ -186,23 +173,18 @@ export class BackendWebSocketService {
     /**
      * Establishes WebSocket connection with smart reconnection behavior
      *
-     * Connection Requirements (all must be true):
-     * 1. Feature enabled (isEnabled() = true)
-     * 2. Wallet unlocked (checked by getBearerToken)
-     * 3. User signed in (checked by getBearerToken)
-     *
-     * Platform code should call this when app opens/foregrounds.
-     * Automatically called on KeyringController:unlock event.
+     * Simplified Priority System (using AuthenticationController):
+     * 1. App closed/backgrounded → Stop all attempts (save resources)
+     * 2. User not signed in (wallet locked OR not authenticated) → Keep retrying
+     * 3. User signed in (wallet unlocked + authenticated) → Connect successfully
      *
      * @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
+        // Priority 1: Check if connection is enabled via callback (app lifecycle check)
+        // If app is closed/backgrounded, stop all connection attempts to save resources
         if (__classPrivateFieldGet(this, _BackendWebSocketService_isEnabled, "f") && !__classPrivateFieldGet(this, _BackendWebSocketService_isEnabled, "f").call(this)) {
-            // Clear any pending reconnection attempts since feature is disabled
+            // Clear any pending reconnection attempts since app is disabled
             __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearTimers).call(this);
             __classPrivateFieldSet(this, _BackendWebSocketService_reconnectAttempts, 0, "f");
             return;
@@ -216,9 +198,10 @@ export class BackendWebSocketService {
             await __classPrivateFieldGet(this, _BackendWebSocketService_connectionPromise, "f");
             return;
         }
-        // Priority 2: Check authentication requirements (signed in)
+        // Priority 2: Check authentication requirements (simplified - just check if signed in)
         let bearerToken;
         try {
+            // AuthenticationController.getBearerToken() handles wallet unlock checks internally
             const token = await __classPrivateFieldGet(this, _BackendWebSocketService_messenger, "f").call('AuthenticationController:getBearerToken');
             if (!token) {
                 __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_scheduleReconnect).call(this);
@@ -228,7 +211,7 @@ export class BackendWebSocketService {
         }
         catch (error) {
             log('Failed to check authentication requirements', { error });
-            // Can't connect - schedule retry
+            // If we can't connect for ANY reason, schedule a retry
             __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_scheduleReconnect).call(this);
             return;
         }
@@ -242,8 +225,7 @@ export class BackendWebSocketService {
             const errorMessage = getErrorMessage(error);
             log('Connection attempt failed', { errorMessage, error });
             __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.ERROR);
-            // Rethrow to propagate error to caller
-            throw error;
+            throw new Error(`Failed to connect to WebSocket: ${errorMessage}`);
         }
         finally {
             // Clear the connection promise when done (success or failure)
@@ -260,8 +242,6 @@ export class BackendWebSocketService {
             __classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.DISCONNECTING) {
             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'));
@@ -270,6 +250,7 @@ export class BackendWebSocketService {
         if (__classPrivateFieldGet(this, _BackendWebSocketService_ws, "f")) {
             __classPrivateFieldGet(this, _BackendWebSocketService_ws, "f").close(1000, 'Normal closure');
         }
+        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.DISCONNECTED);
         log('WebSocket manually disconnected');
     }
     /**
@@ -370,12 +351,8 @@ export class BackendWebSocketService {
         return {
             state: __classPrivateFieldGet(this, _BackendWebSocketService_state, "f"),
             url: __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").url,
-            timeout: __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").timeout,
-            reconnectDelay: __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").reconnectDelay,
-            maxReconnectDelay: __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").maxReconnectDelay,
-            requestTimeout: __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").requestTimeout,
             reconnectAttempts: __classPrivateFieldGet(this, _BackendWebSocketService_reconnectAttempts, "f"),
-            connectedAt: __classPrivateFieldGet(this, _BackendWebSocketService_connectedAt, "f"),
+            connectedAt: __classPrivateFieldGet(this, _BackendWebSocketService_connectedAt, "f") ?? undefined,
         };
     }
     /**
@@ -391,7 +368,6 @@ export class BackendWebSocketService {
                 matchingSubscriptions.push({
                     subscriptionId,
                     channels: subscription.channels,
-                    channelType: subscription.channelType,
                     unsubscribe: subscription.unsubscribe,
                 });
             }
@@ -427,7 +403,6 @@ export class BackendWebSocketService {
                 matchingSubscriptions.push({
                     subscriptionId,
                     channels: subscription.channels,
-                    channelType: subscription.channelType,
                     unsubscribe: subscription.unsubscribe,
                 });
             }
@@ -521,8 +496,6 @@ export class BackendWebSocketService {
         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);
     }
     /**
      * Create and manage a subscription with server-side registration (recommended for most use cases)
@@ -551,7 +524,6 @@ export class BackendWebSocketService {
      * @param options.channels - Array of channel names to subscribe to
      * @param options.callback - Callback function for handling notifications
      * @param options.requestId - Optional request ID for testing (will generate UUID if not provided)
-     * @param options.channelType - Channel type identifier
      * @returns Subscription object with unsubscribe method
      *
      * @example
@@ -571,7 +543,7 @@ export class BackendWebSocketService {
      * @see addChannelCallback for local callbacks without server-side subscription
      */
     async subscribe(options) {
-        const { channels, channelType, callback, requestId } = options;
+        const { channels, callback, requestId } = options;
         if (__classPrivateFieldGet(this, _BackendWebSocketService_state, "f") !== WebSocketState.CONNECTED) {
             throw new Error(`Cannot create subscription(s) ${channels.join(', ')}: WebSocket is ${__classPrivateFieldGet(this, _BackendWebSocketService_state, "f")}`);
         }
@@ -584,6 +556,10 @@ export class BackendWebSocketService {
             throw new Error('Invalid subscription response: missing subscription ID');
         }
         const { subscriptionId } = subscriptionResponse;
+        // Check for failures
+        if (subscriptionResponse.failed && subscriptionResponse.failed.length > 0) {
+            throw new Error(`Subscription failed for channels: ${subscriptionResponse.failed.join(', ')}`);
+        }
         // Create unsubscribe function
         const unsubscribe = async (unsubRequestId) => {
             // Send unsubscribe request first
@@ -601,42 +577,45 @@ export class BackendWebSocketService {
         const subscription = {
             subscriptionId,
             channels: [...channels],
-            channelType,
             unsubscribe,
         };
         // Store subscription with subscription ID as key
         __classPrivateFieldGet(this, _BackendWebSocketService_subscriptions, "f").set(subscriptionId, {
             subscriptionId,
             channels: [...channels],
-            channelType,
             callback,
             unsubscribe,
         });
         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_connectionPromise = new WeakMap(), _BackendWebSocketService_pendingRequests = new WeakMap(), _BackendWebSocketService_connectedAt = new WeakMap(), _BackendWebSocketService_manualDisconnect = new WeakMap(), _BackendWebSocketService_subscriptions = new WeakMap(), _BackendWebSocketService_channelCallbacks = 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) {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this.connect();
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this.disconnect();
-        }
-    }, (state) => ({ isSignedIn: state.isSignedIn }));
-    // Subscribe to wallet unlock event
-    __classPrivateFieldGet(this, _BackendWebSocketService_messenger, "f").subscribe('KeyringController:unlock', () => {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.connect();
-    });
-    // Subscribe to wallet lock event
-    __classPrivateFieldGet(this, _BackendWebSocketService_messenger, "f").subscribe('KeyringController:lock', () => {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.disconnect();
-    });
+_BackendWebSocketService_messenger = new WeakMap(), _BackendWebSocketService_options = new WeakMap(), _BackendWebSocketService_isEnabled = new WeakMap(), _BackendWebSocketService_ws = new WeakMap(), _BackendWebSocketService_state = new WeakMap(), _BackendWebSocketService_reconnectAttempts = new WeakMap(), _BackendWebSocketService_reconnectTimer = new WeakMap(), _BackendWebSocketService_connectionTimeout = new WeakMap(), _BackendWebSocketService_connectionPromise = new WeakMap(), _BackendWebSocketService_pendingRequests = new WeakMap(), _BackendWebSocketService_connectedAt = new WeakMap(), _BackendWebSocketService_subscriptions = new WeakMap(), _BackendWebSocketService_channelCallbacks = new WeakMap(), _BackendWebSocketService_instances = new WeakSet(), _BackendWebSocketService_setupAuthentication = function _BackendWebSocketService_setupAuthentication() {
+    try {
+        // Subscribe to authentication state changes - this includes wallet unlock state
+        // AuthenticationController can only be signed in if wallet is unlocked
+        // Using selector to only listen for isSignedIn property changes for better performance
+        __classPrivateFieldGet(this, _BackendWebSocketService_messenger, "f").subscribe('AuthenticationController:stateChange', (isSignedIn) => {
+            if (isSignedIn) {
+                // User signed in (wallet unlocked + authenticated) - try to connect
+                // Clear any pending reconnection timer since we're attempting connection
+                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearTimers).call(this);
+                this.connect().catch((error) => {
+                    log('Failed to connect after sign-in', { error });
+                });
+            }
+            else {
+                // User signed out (wallet locked OR signed out) - disconnect and stop reconnection attempts
+                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearTimers).call(this);
+                __classPrivateFieldSet(this, _BackendWebSocketService_reconnectAttempts, 0, "f");
+                this.disconnect().catch((error) => {
+                    log('Failed to disconnect after sign-out', { error });
+                });
+            }
+        }, (state) => state.isSignedIn);
+    }
+    catch (error) {
+        throw new Error(`Authentication setup failed: ${getErrorMessage(error)}`);
+    }
 }, _BackendWebSocketService_buildAuthenticatedUrl = function _BackendWebSocketService_buildAuthenticatedUrl(bearerToken) {
     const baseUrl = __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").url;
     // Add token as query parameter to the WebSocket URL
@@ -652,7 +631,6 @@ _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(() => {
@@ -660,47 +638,40 @@ async function _BackendWebSocketService_establishConnection(bearerToken) {
                 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`));
+            reject(new Error(`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,
-                },
-            }, () => {
-                __classPrivateFieldSet(this, _BackendWebSocketService_ws, ws, "f");
-                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.CONNECTED);
-                __classPrivateFieldSet(this, _BackendWebSocketService_connectedAt, Date.now(), "f");
-                // Reset reconnect attempts on successful connection
-                __classPrivateFieldSet(this, _BackendWebSocketService_reconnectAttempts, 0, "f");
-                resolve();
-            });
+            __classPrivateFieldSet(this, _BackendWebSocketService_ws, ws, "f");
+            __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.CONNECTED);
+            __classPrivateFieldSet(this, _BackendWebSocketService_connectedAt, Date.now(), "f");
+            // Reset reconnect attempts on successful connection
+            __classPrivateFieldSet(this, _BackendWebSocketService_reconnectAttempts, 0, "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");
+            if (__classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.CONNECTING) {
+                // Handle connection-phase errors
+                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);
+            }
+            else {
+                // Handle runtime errors
+                __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_handleError).call(this, new Error(`WebSocket error: ${event.type}`));
             }
-            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,
+                reason: event.reason || 'none',
                 wasClean: event.wasClean,
             });
             if (__classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.CONNECTING) {
@@ -734,8 +705,7 @@ async function _BackendWebSocketService_establishConnection(bearerToken) {
     }
     // Handle subscription notifications with valid subscriptionId
     if (__classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_isSubscriptionNotification).call(this, message)) {
-        const notificationMsg = message;
-        const handled = __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_handleSubscriptionNotification).call(this, notificationMsg);
+        const handled = __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_handleSubscriptionNotification).call(this, message);
         // If subscription notification wasn't handled (falsy subscriptionId), fall through to channel handling
         if (handled) {
             return;
@@ -743,8 +713,7 @@ async function _BackendWebSocketService_establishConnection(bearerToken) {
     }
     // Trigger channel callbacks for any message with a channel property
     if (__classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_isChannelMessage).call(this, message)) {
-        const channelMsg = message;
-        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_handleChannelMessage).call(this, channelMsg);
+        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_handleChannelMessage).call(this, message);
     }
 }, _BackendWebSocketService_isServerResponse = function _BackendWebSocketService_isServerResponse(message) {
     return ('data' in message &&
@@ -774,104 +743,58 @@ 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: {
-            channel: message.channel,
-            latency_ms: latency,
-            event: message.event,
-        },
-        tags: {
-            service: SERVICE_NAME,
-            channel_type: message.channel,
-        },
-    }, () => {
-        // Direct lookup for exact channel match
-        __classPrivateFieldGet(this, _BackendWebSocketService_channelCallbacks, "f").get(message.channel)?.callback(message);
-    });
+    // Direct lookup for exact channel match
+    __classPrivateFieldGet(this, _BackendWebSocketService_channelCallbacks, "f").get(message.channel)?.callback(message);
 }, _BackendWebSocketService_handleSubscriptionNotification = function _BackendWebSocketService_handleSubscriptionNotification(message) {
-    const { subscriptionId, timestamp, channel } = message;
+    const { subscriptionId } = message;
     // Only handle if subscriptionId is defined and not null (allows "0" as valid ID)
     if (subscriptionId !== null && subscriptionId !== undefined) {
-        const subscription = __classPrivateFieldGet(this, _BackendWebSocketService_subscriptions, "f").get(subscriptionId);
-        if (!subscription) {
-            return false;
-        }
-        // Calculate notification latency: time from server sent to client received
-        const receivedAt = Date.now();
-        const latency = receivedAt - timestamp;
-        // Trace notification processing with latency data
-        // Use stored channelType instead of parsing each time
-        __classPrivateFieldGet(this, _BackendWebSocketService_trace, "f").call(this, {
-            name: `${SERVICE_NAME} Notification`,
-            data: {
-                channel,
-                latency_ms: latency,
-                subscriptionId,
-            },
-            tags: {
-                service: SERVICE_NAME,
-                notification_type: subscription.channelType,
-            },
-        }, () => {
-            subscription.callback?.(message);
-        });
+        __classPrivateFieldGet(this, _BackendWebSocketService_subscriptions, "f").get(subscriptionId)?.callback?.(message);
         return true;
     }
     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");
     __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_clearTimers).call(this);
-    __classPrivateFieldSet(this, _BackendWebSocketService_connectedAt, 0, "f");
+    __classPrivateFieldSet(this, _BackendWebSocketService_connectedAt, null, "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
+    if (__classPrivateFieldGet(this, _BackendWebSocketService_state, "f") === WebSocketState.DISCONNECTING) {
+        // Manual disconnect
+        __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.DISCONNECTED);
         return;
     }
-    // Trace unexpected disconnect with details
-    __classPrivateFieldGet(this, _BackendWebSocketService_trace, "f").call(this, {
-        name: `${SERVICE_NAME} Disconnect`,
-        data: {
+    // For unexpected disconnects, update the state to reflect that we're disconnected
+    __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_setState).call(this, WebSocketState.DISCONNECTED);
+    // Check if we should attempt reconnection based on close code
+    const shouldReconnect = __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_shouldReconnectOnClose).call(this, event.code);
+    if (shouldReconnect) {
+        log('Connection lost unexpectedly, will attempt reconnection', {
             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
-    });
-    // For any unexpected disconnects, attempt reconnection
-    // The manualDisconnect flag is the only gate - if it's false, we reconnect
-    __classPrivateFieldGet(this, _BackendWebSocketService_instances, "m", _BackendWebSocketService_scheduleReconnect).call(this);
+        });
+        __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() {
     __classPrivateFieldSet(this, _BackendWebSocketService_reconnectAttempts, __classPrivateFieldGet(this, _BackendWebSocketService_reconnectAttempts, "f") + 1, "f");
     const rawDelay = __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").reconnectDelay * Math.pow(1.5, __classPrivateFieldGet(this, _BackendWebSocketService_reconnectAttempts, "f") - 1);
     const delay = Math.min(rawDelay, __classPrivateFieldGet(this, _BackendWebSocketService_options, "f").maxReconnectDelay);
+    log('Scheduling reconnection attempt', {
+        attempt: __classPrivateFieldGet(this, _BackendWebSocketService_reconnectAttempts, "f"),
+        delayMs: delay,
+    });
     __classPrivateFieldSet(this, _BackendWebSocketService_reconnectTimer, setTimeout(() => {
         // Clear timer reference first
         __classPrivateFieldSet(this, _BackendWebSocketService_reconnectTimer, null, "f");
         // Check if connection is still enabled before reconnecting
         if (__classPrivateFieldGet(this, _BackendWebSocketService_isEnabled, "f") && !__classPrivateFieldGet(this, _BackendWebSocketService_isEnabled, "f").call(this)) {
+            log('Reconnection disabled by isEnabled - stopping all attempts');
             __classPrivateFieldSet(this, _BackendWebSocketService_reconnectAttempts, 0, "f");
             return;
         }
@@ -901,9 +824,13 @@ async function _BackendWebSocketService_establishConnection(bearerToken) {
     const oldState = __classPrivateFieldGet(this, _BackendWebSocketService_state, "f");
     __classPrivateFieldSet(this, _BackendWebSocketService_state, newState, "f");
     if (oldState !== newState) {
+        log('WebSocket state changed', { oldState, newState });
         // Publish connection state change event
         // Messenger handles listener errors internally, no need for try-catch
         __classPrivateFieldGet(this, _BackendWebSocketService_messenger, "f").publish('BackendWebSocketService:connectionStateChanged', this.getConnectionInfo());
     }
+}, _BackendWebSocketService_shouldReconnectOnClose = function _BackendWebSocketService_shouldReconnectOnClose(code) {
+    // Don't reconnect only on normal closure (manual disconnect)
+    return code !== 1000;
 };
 //# sourceMappingURL=BackendWebSocketService.mjs.map