@webex/calling 3.12.0-mobius-socket.18 → 3.12.0-mobius-socket.19

package/dist/mobius-socket/mobius-socket.js

@@ -1,11 +1,7 @@
 "use strict";
 
 var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
-var _Array$from = require("@babel/runtime-corejs2/core-js/array/from");
-var _Symbol = require("@babel/runtime-corejs2/core-js/symbol");
-var _Symbol$iterator = require("@babel/runtime-corejs2/core-js/symbol/iterator");
-var _Array$isArray2 = require("@babel/runtime-corejs2/core-js/array/is-array");
-var _Object$keys2 = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$keys = require("@babel/runtime-corejs2/core-js/object/keys");
 var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
 var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
 var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
@@ -17,11 +13,10 @@ _Object$defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _map = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/map"));
-var _now = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/date/now"));
-var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
 var _isArray = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/array/is-array"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
 var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
-var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
+var _now = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/date/now"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
 var _typeof2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/typeof"));
@@ -31,17 +26,12 @@ var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
 var _get2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/get"));
 var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
-var _set2 = _interopRequireDefault(require("lodash/set"));
-var _camelCase2 = _interopRequireDefault(require("lodash/camelCase"));
 var _events = require("events");
 var _backoff = _interopRequireDefault(require("backoff"));
 var _socket = _interopRequireDefault(require("./socket"));
 var _errors = require("./errors");
-function ownKeys(e, r) { var t = _Object$keys2(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function ownKeys(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof _Symbol && r[_Symbol$iterator] || r["@@iterator"]; if (!t) { if (_Array$isArray2(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? _Array$from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; } // @ts-nocheck
@@ -49,7 +39,6 @@ function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototyp
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file
  */
 var normalReconnectReasons = ['idle', 'done (forced)'];
-var DEFAULT_MOBIUS_WEBSOCKET_SESSION = 'mobius-websocket-session';
 var MOBIUS_SOCKET_NAMESPACE = 'MobiusSocket';
 var TOKEN_REFRESH_INTERVAL_MS = 1 * 60 * 60 * 1000; // 1 hour
 
@@ -68,20 +57,16 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
     _this.webex = webex;
     _this.config = config;
     _this.logger = webex.logger || console;
-    _this.defaultSessionId = DEFAULT_MOBIUS_WEBSOCKET_SESSION;
     _this.connected = false;
     _this.connecting = false;
     _this.hasEverConnected = false;
     _this.socket = undefined;
-    _this.sockets = new _map.default();
-    _this.backoffCalls = new _map.default();
-    _this._shutdownSwitchoverBackoffCalls = new _map.default();
-    _this._seenAsyncEventIdsBySession = new _map.default();
-    _this._connectPromises = new _map.default();
-    _this.mercuryTimeOffset = undefined;
-    _this._tokenRefreshTimer = undefined;
-    _this._tokenRefreshInFlight = undefined;
-    _this._bindInternalEvents();
+    _this.backoffCall = undefined;
+    _this.shutdownSwitchoverBackoffCall = undefined;
+    _this.seenAsyncEventIds = new _map.default();
+    _this.connectPromise = undefined;
+    _this.tokenRefreshTimer = undefined;
+    _this.tokenRefreshInFlight = undefined;
     return _this;
   }
   (0, _inherits2.default)(MobiusSocket, _EventEmitter);
@@ -94,143 +79,50 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       this.removeAllListeners(eventName);
       return this;
     }
-  }, {
-    key: "_bindInternalEvents",
-    value: function _bindInternalEvents() {
-      var _this2 = this;
-      /*
-        When one of these legacy feature gets updated, this event would be triggered
-          * group-message-notifications
-          * mention-notifications
-          * thread-notifications
-      */
-      this.on('event:featureToggle_update', function (envelope) {
-        if (envelope && envelope.data) {
-          _this2.webex.internal.feature.updateFeature(envelope.data.featureToggle);
-        }
-      });
-      /*
-       * When Cluster Migrations, notify clients using ActiveClusterStatusEvent via mercury
-       * https://wwwin-github.cisco.com/pages/Webex/crr-docs/techdocs/rr-002.html#wip-notifying-clients-of-cluster-migrations
-       * */
-      this.on('event:ActiveClusterStatusEvent', function (envelope) {
-        var _this2$webex$internal;
-        if (typeof ((_this2$webex$internal = _this2.webex.internal.services) === null || _this2$webex$internal === void 0 ? void 0 : _this2$webex$internal.switchActiveClusterIds) === 'function' && envelope && envelope.data) {
-          var _envelope$data;
-          _this2.webex.internal.services.switchActiveClusterIds((_envelope$data = envelope.data) === null || _envelope$data === void 0 ? void 0 : _envelope$data.activeClusters);
-        }
-      });
-      /*
-       * Using cache-invalidation via mercury to instead the method of polling via the new /timestamp endpoint from u2c
-       * https://wwwin-github.cisco.com/pages/Webex/crr-docs/techdocs/rr-005.html#websocket-notifications
-       * */
-      this.on('event:u2c.cache-invalidation', function (envelope) {
-        var _this2$webex$internal2;
-        if (typeof ((_this2$webex$internal2 = _this2.webex.internal.services) === null || _this2$webex$internal2 === void 0 ? void 0 : _this2$webex$internal2.invalidateCache) === 'function' && envelope && envelope.data) {
-          var _envelope$data2;
-          _this2.webex.internal.services.invalidateCache((_envelope$data2 = envelope.data) === null || _envelope$data2 === void 0 ? void 0 : _envelope$data2.timestamp);
-        }
-      });
-    }
 
     /**
      * Attach event listeners to a socket.
      * @param {Socket} socket - The socket to attach listeners to
-     * @param {sessionId} sessionId - The socket related session ID
      * @returns {void}
      */
   }, {
-    key: "_attachSocketEventListeners",
-    value: function _attachSocketEventListeners(socket, sessionId) {
-      var _this3 = this;
+    key: "attachSocketEventListeners",
+    value: function attachSocketEventListeners(socket) {
+      var _this2 = this;
       socket.on('close', function (event) {
-        return _this3._onclose(sessionId, event, socket);
+        return _this2.onclose(event, socket);
       });
       socket.on('message', function () {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
-        }
-        return _this3._onmessage.apply(_this3, [sessionId].concat(args));
-      });
-      socket.on('pong', function () {
-        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-          args[_key2] = arguments[_key2];
-        }
-        return _this3._setTimeOffset.apply(_this3, [sessionId].concat(args));
-      });
-      socket.on('sequence-mismatch', function () {
-        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-          args[_key3] = arguments[_key3];
-        }
-        return _this3._emit.apply(_this3, [sessionId, 'sequence-mismatch'].concat(args));
-      });
-      socket.on('ping-pong-latency', function () {
-        for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-          args[_key4] = arguments[_key4];
-        }
-        return _this3._emit.apply(_this3, [sessionId, 'ping-pong-latency'].concat(args));
+        return _this2.onmessage.apply(_this2, arguments);
       });
     }
 
-    /**
-     * Returns the per-session cache of seen async_event IDs, creating it on first access.
-     * @param {string} sessionId - The session identifier.
-     * @returns {Map<string, boolean>} Ordered cache of seen event IDs for the session.
-     */
-  }, {
-    key: "_getSeenAsyncEventIds",
-    value: function _getSeenAsyncEventIds(sessionId) {
-      var seenAsyncEventIds = this._seenAsyncEventIdsBySession.get(sessionId);
-      if (!seenAsyncEventIds) {
-        seenAsyncEventIds = new _map.default();
-        this._seenAsyncEventIdsBySession.set(sessionId, seenAsyncEventIds);
-      }
-      return seenAsyncEventIds;
-    }
-
-    /**
-     * Clears the dedup cache for one session or for all sessions when omitted.
-     * @param {string} [sessionId] - Optional session identifier.
-     * @returns {void}
-     */
-  }, {
-    key: "_clearSeenAsyncEventIds",
-    value: function _clearSeenAsyncEventIds(sessionId) {
-      if (sessionId) {
-        this._seenAsyncEventIdsBySession.delete(sessionId);
-        return;
-      }
-      this._seenAsyncEventIdsBySession.clear();
-    }
-
     /**
      * Tracks a newly seen async_event ID and reports whether a duplicate should be suppressed.
-     * @param {string} sessionId - The session identifier.
      * @param {object} envelope - Parsed websocket message envelope.
-     * @returns {boolean} True when the event has already been seen for this session.
+     * @returns {boolean} True when the event has already been seen.
      */
   }, {
-    key: "_trackAsyncEventAndShouldSuppressDuplicate",
-    value: function _trackAsyncEventAndShouldSuppressDuplicate(sessionId, envelope) {
+    key: "trackAsyncEventAndShouldSuppressDuplicate",
+    value: function trackAsyncEventAndShouldSuppressDuplicate(envelope) {
       if ((envelope === null || envelope === void 0 ? void 0 : envelope.type) !== 'async_event' || !envelope.eventId) {
         return false;
       }
-      var seenAsyncEventIds = this._getSeenAsyncEventIds(sessionId);
-      if (seenAsyncEventIds.has(envelope.eventId)) {
-        var previousValue = seenAsyncEventIds.get(envelope.eventId);
-
+      if (this.seenAsyncEventIds.has(envelope.eventId)) {
         // Refresh recency so frequently retransmitted eventIds stay protected longer.
-        seenAsyncEventIds.delete(envelope.eventId);
-        seenAsyncEventIds.set(envelope.eventId, previousValue);
-        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": duplicate async_event suppressed for ").concat(sessionId, ", eventId=").concat(envelope.eventId));
+        // This deletion and setting again makes the data recent since javascript map maintains order as well
+        var previousValue = this.seenAsyncEventIds.get(envelope.eventId);
+        this.seenAsyncEventIds.delete(envelope.eventId);
+        this.seenAsyncEventIds.set(envelope.eventId, previousValue);
+        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": duplicate async_event suppressed, eventId=").concat(envelope.eventId));
         return true;
       }
-      this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": tracking async_event for ").concat(sessionId, ", eventId=").concat(envelope.eventId));
-      seenAsyncEventIds.set(envelope.eventId, true);
-      if (seenAsyncEventIds.size > this.config.dedupCacheMaxSize) {
-        var oldestEventId = seenAsyncEventIds.keys().next().value;
-        seenAsyncEventIds.delete(oldestEventId);
-        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": evicted oldest async_event from dedup cache for ").concat(sessionId, ", eventId=").concat(oldestEventId));
+      this.logger.log("".concat(MOBIUS_SOCKET_NAMESPACE, ": tracking async_event, eventId=").concat(envelope.eventId));
+      this.seenAsyncEventIds.set(envelope.eventId, true);
+      if (this.seenAsyncEventIds.size > this.config.dedupCacheMaxSize) {
+        var oldestEventId = this.seenAsyncEventIds.keys().next().value;
+        this.seenAsyncEventIds.delete(oldestEventId);
+        this.logger.log("".concat(MOBIUS_SOCKET_NAMESPACE, ": evicted oldest async_event from dedup cache, eventId=").concat(oldestEventId));
       }
       return false;
     }
@@ -239,154 +131,88 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
      * Handle imminent shutdown by establishing a new connection while keeping
      * the current one alive (make-before-break).
      * Idempotent: will no-op if already in progress.
-     * @param {string} sessionId - The session ID for which the shutdown is imminent
-     * @returns {void}
      */
   }, {
-    key: "_handleImminentShutdown",
-    value: function _handleImminentShutdown(sessionId) {
-      var _this4 = this;
-      var oldSocket = this.sockets.get(sessionId);
+    key: "handleImminentShutdown",
+    value: function handleImminentShutdown() {
+      var _this3 = this;
+      var oldSocket = this.socket;
       try {
-        // Idempotent: if we already have a switchover backoff call for this session,
-        // a switchover is in progress – do nothing.
-        if (this._shutdownSwitchoverBackoffCalls.get(sessionId)) {
-          this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover already in progress for ").concat(sessionId));
+        if (this.shutdownSwitchoverBackoffCall) {
+          this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover already in progress"));
           return;
         }
-        var switchoverId = "".concat((0, _now.default)());
-        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover start, id=").concat(switchoverId, " for ").concat(sessionId));
-        this._connectWithBackoff(undefined, sessionId, {
+        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover start"));
+        this.connectWithBackoff(undefined, {
           isShutdownSwitchover: true,
           attemptOptions: {
             isShutdownSwitchover: true,
             onSuccess: function onSuccess(newSocket, webSocketUrl) {
-              _this4.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover connected, url: ").concat(webSocketUrl, " for ").concat(sessionId));
-
-              // Atomically switch active socket reference
-              _this4.socket = _this4.sockets.get(_this4.defaultSessionId);
-              _this4.connected = _this4.hasConnectedSockets(); // remain connected throughout
-
-              _this4._emit(sessionId, 'event:mercury_shutdown_switchover_complete', {
+              _this3.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover connected, url: ").concat(webSocketUrl));
+
+              // Promote the new socket now that the switchover succeeded
+              newSocket.connecting = false;
+              newSocket.connected = true;
+              _this3.socket = newSocket;
+              _this3.connected = true;
+              _this3.emitEvent('event:mobius_shutdown_switchover_complete', {
                 url: webSocketUrl
               });
               if (oldSocket) {
-                _this4.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] old socket retained; server will close with 4001"));
+                _this3.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] old socket retained; server will close with 4001"));
               }
             }
           }
         }).then(function () {
-          _this4.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover completed successfully for ").concat(sessionId));
+          _this3.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover completed successfully"));
         }).catch(function (err) {
-          _this4.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover exhausted retries; will fall back to normal reconnection for ").concat(sessionId, ": "), err);
-          _this4._emit(sessionId, 'event:mercury_shutdown_switchover_failed', {
+          _this3.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover exhausted retries; will fall back to normal reconnection: "), err);
+          _this3.emitEvent('event:mobius_shutdown_switchover_failed', {
             reason: err
           });
-          // Old socket will eventually close with 4001, triggering normal reconnection
         });
       } catch (e) {
-        this.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] error during switchover for ").concat(sessionId), e);
-        this._shutdownSwitchoverBackoffCalls.delete(sessionId);
-        this._emit(sessionId, 'event:mercury_shutdown_switchover_failed', {
+        this.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] error during switchover"), e);
+        this.shutdownSwitchoverBackoffCall = undefined;
+        this.emitEvent('event:mobius_shutdown_switchover_failed', {
           reason: e
         });
       }
     }
 
     /**
-     * Get the last error.
-     * @returns {unknown} The last error.
-     */
-  }, {
-    key: "getLastError",
-    value: function getLastError() {
-      return this.lastError;
-    }
-
-    /**
-     * Get all active socket connections
-     * @returns {Map} Map of sessionId to socket instances
-     */
-  }, {
-    key: "getSockets",
-    value: function getSockets() {
-      return this.sockets;
-    }
-
-    /**
-     * Get a specific socket by connection ID
-     * @param {string} sessionId - The connection identifier
-     * @returns {Socket|undefined} The socket instance or undefined if not found
-     */
-  }, {
-    key: "getSocket",
-    value: function getSocket() {
-      var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.defaultSessionId;
-      return this.sockets.get(sessionId);
-    }
-
-    /**
-     * Get the websocket URL for a currently connected session.
-     * @param {string} [sessionId=this.defaultSessionId] - The session identifier.
+     * Get the websocket URL for the currently connected socket.
      * @returns {string|undefined} The connected websocket URL, or undefined when not connected.
      */
   }, {
     key: "getConnectedWebSocketUrl",
     value: function getConnectedWebSocketUrl() {
-      var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.defaultSessionId;
-      var socket = this.getSocket(sessionId);
-      if (!(socket !== null && socket !== void 0 && socket.connected)) {
+      var _this$socket;
+      if (!((_this$socket = this.socket) !== null && _this$socket !== void 0 && _this$socket.connected)) {
         return undefined;
       }
-      return socket.url;
-    }
-
-    /**
-     * Sends a payload on the active connected socket
-     * @param {Object} payload - The data to send
-     * @param {string} [sessionId=this.defaultSessionId] - The session identifier
-     * @returns {Promise}
-     */
-  }, {
-    key: "send",
-    value: function send(payload) {
-      var sessionId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.defaultSessionId;
-      var socket = this.getSocket(sessionId);
-      if (!socket || !socket.connected) {
-        return _promise.default.reject(new Error("Mobius socket is not connected for session ".concat(sessionId)));
-      }
-      return socket.send(payload);
+      return this.socket.url;
     }
 
     /**
      * Sends a websocket request and resolves when the matching response arrives.
-     * @param {Object} payload - The websocket request payload.
-     * @param {string|Object} [sessionIdOrRequestOptions=this.defaultSessionId] - Session ID or request options.
-     * @param {Object} [options={}] - Additional request options.
-     * @returns {Promise<Object>}
+     * @param {MobiusSocketRequestPayload} payload - The websocket request payload.
+     * @param {MobiusSocketRequestOptions} [options={}] - Additional request options.
+     * @returns {Promise<SocketResponse>}
      */
   }, {
     key: "sendWssRequest",
     value: function sendWssRequest(payload) {
-      var _this5 = this;
-      var sessionIdOrRequestOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.defaultSessionId;
-      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var _this4 = this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       if (!payload || (0, _typeof2.default)(payload) !== 'object' || (0, _isArray.default)(payload)) {
         return _promise.default.reject(new Error('`payload` is required'));
       }
-      var sessionId = this.defaultSessionId;
-      var requestOptions = options;
-      if (typeof sessionIdOrRequestOptions === 'string') {
-        sessionId = sessionIdOrRequestOptions;
-      } else if (sessionIdOrRequestOptions && (0, _typeof2.default)(sessionIdOrRequestOptions) === 'object') {
-        requestOptions = sessionIdOrRequestOptions;
+      if (!this.socket || !this.socket.connected) {
+        return _promise.default.reject(new Error('Mobius socket is not connected'));
       }
-      var socket = this.getSocket(sessionId);
-      if (!socket || !socket.connected) {
-        return _promise.default.reject(new Error("Mobius socket is not connected for session ".concat(sessionId)));
-      }
-      return socket.sendRequest(payload, {
-        timeout: requestOptions.timeout,
+      var requestConfigOptions = {
+        timeout: options.timeout,
         matchesResponse: function matchesResponse(response, request) {
           return (response === null || response === void 0 ? void 0 : response.type) === 'response_event' && (response === null || response === void 0 ? void 0 : response.subtype) === request.type && (response === null || response === void 0 ? void 0 : response.trackingId) === request.trackingId;
         },
@@ -397,21 +223,22 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
           return response === null || response === void 0 ? void 0 : response.statusMessage;
         },
         createError: function createError(response, statusCode, statusMessage) {
-          return _this5._createWssResponseError(response, statusCode, statusMessage);
+          return _this4.createWssResponseError(response, statusCode, statusMessage);
         },
         createTimeoutError: function createTimeoutError(request) {
-          return _this5._createWssResponseError({
+          return _this4.createWssResponseError({
             type: 'response_event',
             subtype: request.type,
             trackingId: request.trackingId
           }, 408, 'Mobius websocket response timed out');
         }
-      });
+      };
+      return this.socket.sendRequest(payload, requestConfigOptions);
     }
 
     /**
-     * Check if the plugin is connected
-     * @returns {boolean} True if connected
+     * Check if the socket is connected.
+     * @returns {boolean} True if connected.
      */
   }, {
     key: "isConnected",
@@ -420,66 +247,22 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
     }
 
     /**
-     * Check if a socket is connected
-     * @param {string} [sessionId] - Optional session identifier
-     * @returns {boolean|undefined} True if the socket is connected
-     */
-  }, {
-    key: "hasConnectedSockets",
-    value: function hasConnectedSockets(sessionId) {
-      if (sessionId) {
-        var _this$sockets$get;
-        return Boolean((_this$sockets$get = this.sockets.get(sessionId)) === null || _this$sockets$get === void 0 ? void 0 : _this$sockets$get.connected);
-      }
-      var _iterator = _createForOfIteratorHelper(this.sockets.values()),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var socket = _step.value;
-          if (socket !== null && socket !== void 0 && socket.connected) {
-            return true;
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-      return false;
-    }
-
-    /**
-     * Check if any sockets are connecting
-     * @param {string} [sessionId=this.defaultSessionId] - The session identifier
-     * @returns {boolean|undefined} True if the socket is connecting
-     */
-  }, {
-    key: "hasConnectingSockets",
-    value: function hasConnectingSockets() {
-      var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.defaultSessionId;
-      var socket = this.sockets.get(sessionId || this.defaultSessionId);
-      return Boolean(socket === null || socket === void 0 ? void 0 : socket.connecting);
-    }
-
-    /**
-     * Connect to Mobius for a specific session.
+     * Connect to Mobius.
      * @param {string} [webSocketUrl] - Optional websocket URL override. Falls back to the device websocket URL.
-     * @param {string} [sessionId=this.defaultSessionId] - The session identifier for this connection.
-     * @returns {Promise<void>} Resolves when connection flow completes for the session.
+     * @returns {Promise<void>} Resolves when connection flow completes.
      */
   }, {
     key: "connect",
     value: function connect(webSocketUrl) {
-      var _this6 = this;
-      var sessionId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.defaultSessionId;
-      // First check if there's already a connection promise for this session
-      if (this._connectPromises.has(sessionId)) {
-        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connection ").concat(sessionId, " already in progress, returning existing promise"));
-        return this._connectPromises.get(sessionId);
-      }
-      var sessionSocket = this.sockets.get(sessionId);
-      if (sessionSocket !== null && sessionSocket !== void 0 && sessionSocket.connected || sessionSocket !== null && sessionSocket !== void 0 && sessionSocket.connecting) {
-        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connection ").concat(sessionId, " already connected, will not connect again"));
+      var _this$socket2,
+        _this$socket3,
+        _this5 = this;
+      if (this.connectPromise) {
+        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connection already in progress, returning existing promise"));
+        return this.connectPromise;
+      }
+      if ((_this$socket2 = this.socket) !== null && _this$socket2 !== void 0 && _this$socket2.connected || (_this$socket3 = this.socket) !== null && _this$socket3 !== void 0 && _this$socket3.connecting) {
+        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": already connected, will not connect again"));
         return _promise.default.resolve();
       }
 
@@ -490,120 +273,61 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       }
 
       // Cache the caller-provided URL for reconnect
-      var resolvedUrl = webSocketUrl || this.socketUrl;
       if (webSocketUrl) {
         this.socketUrl = webSocketUrl;
       }
       this.connecting = true;
-      this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": starting connection attempt for ").concat(sessionId).concat(Number(this.config.initialConnectionMaxRetries) === 0 && !this.hasEverConnected ? ' (initial retries disabled)' : ''));
+      this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": starting connection attempt").concat(Number(this.config.initialConnectionMaxRetries) === 0 && !this.hasEverConnected ? ' (initial retries disabled)' : ''));
       var connectPromise = _promise.default.resolve(this.webex.internal.device.registered || this.webex.internal.device.register()).then(function () {
-        _this6.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connecting ").concat(sessionId));
-        return _this6._connectWithBackoff(resolvedUrl, sessionId);
+        _this5.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connecting"));
+        return _this5.connectWithBackoff(_this5.socketUrl);
       }).finally(function () {
-        _this6._connectPromises.delete(sessionId);
+        _this5.connectPromise = undefined;
       });
-      this._connectPromises.set(sessionId, connectPromise);
+      this.connectPromise = connectPromise;
       return connectPromise;
     }
-  }, {
-    key: "logout",
-    value: function logout() {
-      this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": logout() called"));
-      return this.disconnectAll(this.config.beforeLogoutOptionsCloseReason && !normalReconnectReasons.includes(this.config.beforeLogoutOptionsCloseReason) ? {
-        code: 3050,
-        reason: this.config.beforeLogoutOptionsCloseReason
-      } : undefined);
-    }
 
     /**
-     * Disconnect a Mobius socket for a specific session.
-     * @param {object} [options] - Optional websocket close options (for example: `{code, reason}`).
-     * @param {string} [sessionId=this.defaultSessionId] - The session identifier to disconnect.
-     * @returns {Promise<void>} Resolves after disconnect cleanup and close handling are initiated/completed.
+     * Disconnect the Mobius socket.
+     * @param {MobiusSocketCloseOptions} [options] - Optional websocket close options (code, reason).
+     * @returns {Promise<void>} Resolves after disconnect cleanup and close handling complete.
      */
   }, {
     key: "disconnect",
     value: function disconnect(options) {
-      var _this7 = this;
-      var sessionId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.defaultSessionId;
-      this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, "#disconnect: connecting state: ").concat(this.connecting, ", connected state: ").concat(this.connected, ", socket exists: ").concat(!!this.socket, ", options: ").concat((0, _stringify.default)(options)));
-      var backoffCall = this.backoffCalls.get(sessionId);
-      if (backoffCall) {
-        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": aborting connection ").concat(sessionId));
-        backoffCall.abort();
-        this.backoffCalls.delete(sessionId);
-      }
-      var shutdownSwitchoverBackoffCall = this._shutdownSwitchoverBackoffCalls.get(sessionId);
-      if (shutdownSwitchoverBackoffCall) {
-        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": aborting shutdown switchover connection ").concat(sessionId));
-        shutdownSwitchoverBackoffCall.abort();
-        this._shutdownSwitchoverBackoffCalls.delete(sessionId);
-      }
-      // Clean up any pending connection promises
-      this._connectPromises.delete(sessionId);
-      var sessionSocket = this.sockets.get(sessionId);
-      this._clearSeenAsyncEventIds(sessionId);
-      if (!sessionSocket) {
-        this.connected = this.hasConnectedSockets();
-        if (!this.hasConnectedSockets()) {
-          this._stopTokenRefreshTimer();
-        }
+      var _this6 = this;
+      this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, "#disconnect: connecting state: ").concat(this.connecting, ",\n       connected state: ").concat(this.connected, ", socket exists: ").concat(!!this.socket, ",\n       options: ").concat((0, _stringify.default)(options)));
+      if (this.backoffCall) {
+        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": aborting connection"));
+        this.backoffCall.abort();
+        this.backoffCall = undefined;
+      }
+      if (this.shutdownSwitchoverBackoffCall) {
+        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": aborting shutdown switchover connection"));
+        this.shutdownSwitchoverBackoffCall.abort();
+        this.shutdownSwitchoverBackoffCall = undefined;
+      }
+      this.connectPromise = undefined;
+      this.seenAsyncEventIds.clear();
+      if (!this.socket) {
+        this.connected = false;
+        this.stopTokenRefreshTimer();
         return _promise.default.resolve();
       }
-      sessionSocket.removeAllListeners('message');
-      sessionSocket.connecting = false;
-      sessionSocket.connected = false;
-      return _promise.default.resolve(sessionSocket.close(options || undefined)).finally(function () {
-        _this7.connected = _this7.hasConnectedSockets();
-        if (!_this7.hasConnectedSockets()) {
-          _this7._stopTokenRefreshTimer();
-        }
-      });
-    }
-
-    /**
-     * Disconnect all socket connections
-     * @param {object} options - Close options
-     * @returns {Promise} Promise that resolves when all connections are closed
-     */
-  }, {
-    key: "disconnectAll",
-    value: function disconnectAll(options) {
-      var _this8 = this;
-      var disconnectPromises = [];
-      var _iterator2 = _createForOfIteratorHelper(this.sockets.keys()),
-        _step2;
-      try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var sessionId = _step2.value;
-          disconnectPromises.push(this.disconnect(options, sessionId));
-        }
-      } catch (err) {
-        _iterator2.e(err);
-      } finally {
-        _iterator2.f();
-      }
-      return _promise.default.all(disconnectPromises).then(function () {
-        _this8.connected = false;
-        _this8.socket = undefined;
-        _this8.sockets.clear();
-        _this8.backoffCalls.clear();
-        _this8._shutdownSwitchoverBackoffCalls.clear();
-        _this8._clearSeenAsyncEventIds();
-        _this8._stopTokenRefreshTimer();
-        _this8._connectPromises.clear();
+      this.socket.removeAllListeners('message');
+      this.socket.connecting = false;
+      this.socket.connected = false;
+      return _promise.default.resolve(this.socket.close(options || undefined)).finally(function () {
+        _this6.connected = false;
+        _this6.stopTokenRefreshTimer();
       });
     }
-  }, {
-    key: "processRegistrationStatusEvent",
-    value: function processRegistrationStatusEvent(message) {
-      this.localClusterServiceUrls = message.localClusterServiceUrls;
-    }
 
     // eslint-disable-next-line class-methods-use-this
   }, {
-    key: "_createWssResponseError",
-    value: function _createWssResponseError(response, statusCode, statusMessage) {
+    key: "createWssResponseError",
+    value: function createWssResponseError(response, statusCode, statusMessage) {
       var error = new Error(statusMessage || "Mobius websocket request failed with status ".concat(statusCode || 'unknown'));
       error.name = 'MobiusSocketResponseError';
       error.statusCode = statusCode;
@@ -612,43 +336,20 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       error.trackingId = response === null || response === void 0 ? void 0 : response.trackingId;
       return error;
     }
-
-    // eslint-disable-next-line class-methods-use-this
   }, {
-    key: "_applyOverrides",
-    value: function _applyOverrides(event) {
-      if (!event || !event.headers) {
-        return;
-      }
-      var headerKeys = (0, _keys.default)(event.headers);
-      headerKeys.forEach(function (keyPath) {
-        (0, _set2.default)(event, keyPath, event.headers[keyPath]);
-      });
-    }
-  }, {
-    key: "_prepareUrl",
-    value: function _prepareUrl(webSocketUrl) {
+    key: "prepareUrl",
+    value: function prepareUrl(webSocketUrl) {
       if (!webSocketUrl) {
+        // TODO: Circle back to this logic when mobius implements the shutdown switchover
         webSocketUrl = this.webex.internal.device.webSocketUrl;
       }
-
-      // TODO: Validate the host against the service catalog
-      // const hostFromUrl = url.parse(webSocketUrl, true)?.host;
-      // const isValidHost = this.webex.internal.services.isValidHost(hostFromUrl);
-      // if (!isValidHost) {
-      //   this.logger.error(
-      //     `${MOBIUS_SOCKET_NAMESPACE}: host ${hostFromUrl} is not a valid host from host catalog`
-      //   );
-      //   return Promise.resolve('');
-      // }
-
       return _promise.default.resolve(webSocketUrl);
     }
   }, {
-    key: "_attemptConnection",
-    value: function _attemptConnection(socketUrl, sessionId, callback) {
-      var _this9 = this;
-      var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    key: "attemptConnection",
+    value: function attemptConnection(socketUrl, callback) {
+      var _this7 = this;
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
       var _options$isShutdownSw = options.isShutdownSwitchover,
         isShutdownSwitchover = _options$isShutdownSw === void 0 ? false : _options$isShutdownSw,
         _options$onSuccess = options.onSuccess,
@@ -656,16 +357,15 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       var socket = new _socket.default();
       socket.connecting = true;
       var newWSUrl;
-      this._attachSocketEventListeners(socket, sessionId);
-      var backoffCall = isShutdownSwitchover ? this._shutdownSwitchoverBackoffCalls.get(sessionId) : this.backoffCalls.get(sessionId);
+      this.attachSocketEventListeners(socket);
+      var backoffCall = isShutdownSwitchover ? this.shutdownSwitchoverBackoffCall : this.backoffCall;
 
       // Check appropriate backoff call based on connection type
       if (!backoffCall) {
         var mode = isShutdownSwitchover ? 'switchover backoff call' : 'backoffCall';
-        var msg = "".concat(MOBIUS_SOCKET_NAMESPACE, ": prevent socket open when ").concat(mode, " no longer defined for ").concat(sessionId);
+        var msg = "".concat(MOBIUS_SOCKET_NAMESPACE, ": prevent socket open when ").concat(mode, " no longer defined");
         var err = new Error(msg);
         this.logger.info(msg);
-
         // Call the callback with the error before rejecting
         callback(err);
         return _promise.default.reject(err);
@@ -674,11 +374,11 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       // For shutdown switchover, don't set socket yet (make-before-break)
       // For normal connection, set socket before opening to allow disconnect() to close it
       if (!isShutdownSwitchover) {
-        this.sockets.set(sessionId, socket);
+        this.socket = socket;
       }
-      return this._prepareAndOpenSocket(socket, socketUrl, sessionId, isShutdownSwitchover).then(function (webSocketUrl) {
+      return this.prepareAndOpenSocket(socket, socketUrl, isShutdownSwitchover).then(function (webSocketUrl) {
         newWSUrl = webSocketUrl;
-        _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(isShutdownSwitchover ? '[shutdown] switchover' : '', " connected to mobius socket, success, action: connected for ").concat(sessionId, ", url: ").concat(newWSUrl));
+        _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(isShutdownSwitchover ? '[shutdown] switchover' : '', " connected to mobius socket, success, url: ").concat(newWSUrl));
 
         // Custom success handler for shutdown switchover
         if (onSuccess) {
@@ -693,145 +393,130 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       }).catch(function (reason) {
         // For shutdown, simpler error handling - just callback for retry
         if (isShutdownSwitchover) {
-          _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover attempt failed for ").concat(sessionId), reason);
+          _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover attempt failed"), reason);
           return callback(reason);
         }
 
-        // Normal connection error handling (existing complex logic)
-        _this9.lastError = reason; // remember the last error
-
-        var backoffCallNormal = _this9.backoffCalls.get(sessionId);
-        // Suppress connection errors that appear to be network related. This
-        // may end up suppressing metrics during outages, but we might not care
-        // (especially since many of our outages happen in a way that client
-        // metrics can't be trusted).
+        // Normal connection error handling
+        var backoffCallNormal = _this7.backoffCall;
+        // Suppress connection errors that appear to be network related (code 1006).
         if (reason.code !== 1006 && backoffCallNormal && (backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()) > 0) {
-          _this9._emit(sessionId, 'connection_failed', reason, {
-            sessionId: sessionId,
+          _this7.emitEvent('connection_failed', reason, {
             retries: backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()
           });
         }
-        _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connection attempt failed for ").concat(sessionId), reason, (backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()) === 0 ? reason.stack : '');
-        // UnknownResponse is produced by IE for any 4XXX; treated it like a bad
+        _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connection attempt failed"), reason, (backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()) === 0 ? reason.stack : '');
+
+        // UnknownResponse is produced by IE for any 4XXX; treat it like a bad
         // web socket url and let WDM handle the token checking
         if (reason instanceof _errors.UnknownResponse) {
-          _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": received unknown response code for ").concat(sessionId, ", refreshing device registration"));
-          return _this9.webex.internal.device.refresh().then(function () {
+          _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": received unknown response code, refreshing device registration"));
+          return _this7.webex.internal.device.refresh().then(function () {
             return callback(reason);
           });
         }
         // NotAuthorized implies expired token
         if (reason instanceof _errors.NotAuthorized) {
-          _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": received authorization error for ").concat(sessionId, ", reauthorizing"));
-          return _this9.webex.credentials.refresh({
+          _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": received authorization error, reauthorizing"));
+          return _this7.webex.credentials.refresh({
             force: true
           }).then(function () {
             return callback(reason);
           });
         }
-        // // NotFound implies expired web socket url
-        // else if (reason instanceof NotFound) {
-        //   this.logger.info(`mercury: received not found error, refreshing device registration`);
-        //   return this.webex.internal.device.refresh()
-        //     .then(() => callback(reason));
-        // }
-        // BadRequest implies current credentials are for a Service Account
-        // Forbidden implies current user is not entitled for Webex
         if (reason instanceof _errors.BadRequest || reason instanceof _errors.Forbidden) {
-          _this9.logger.warn("".concat(MOBIUS_SOCKET_NAMESPACE, ": received unrecoverable response from ").concat(MOBIUS_SOCKET_NAMESPACE, " for ").concat(sessionId));
+          _this7.logger.warn("".concat(MOBIUS_SOCKET_NAMESPACE, ": received unrecoverable response from ").concat(MOBIUS_SOCKET_NAMESPACE));
           backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.abort();
           return callback(reason);
         }
         return callback(reason);
       }).catch(function (reason) {
-        _this9.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": failed to handle connection failure for ").concat(sessionId), reason);
+        _this7.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": failed to handle connection failure"), reason);
         callback(reason);
       });
     }
   }, {
-    key: "_prepareAndOpenSocket",
-    value: function _prepareAndOpenSocket(socket, socketUrl, sessionId) {
-      var _this0 = this;
-      var isShutdownSwitchover = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    key: "prepareAndOpenSocket",
+    value: function prepareAndOpenSocket(socket, socketUrl) {
+      var _this8 = this;
+      var isShutdownSwitchover = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       var logPrefix = isShutdownSwitchover ? '[shutdown] switchover' : 'connection';
-      return _promise.default.all([this._prepareUrl(socketUrl), this.webex.credentials.getUserToken()]).then(function (_ref) {
+      return _promise.default.all([this.prepareUrl(socketUrl), this.webex.credentials.getUserToken()]).then(function (_ref) {
         var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
           webSocketUrl = _ref2[0],
           token = _ref2[1];
         var options = {
-          forceCloseDelay: _this0.config.forceCloseDelay,
-          wssResponseTimeout: _this0.config.wssResponseTimeout,
-          skipAckEventId: _this0.config.skipAckEventId,
-          skipAckEventType: _this0.config.skipAckEventType,
+          forceCloseDelay: _this8.config.forceCloseDelay,
+          wssResponseTimeout: _this8.config.wssResponseTimeout,
           token: normalizeMobiusAuthToken(token.toString()),
           refreshToken: function refreshToken() {
-            return _this0._refreshToken();
+            return _this8.refreshToken();
           },
-          trackingId: "".concat(_this0.webex.sessionId, "_").concat((0, _now.default)()),
-          logger: _this0.logger
+          trackingId: "".concat(_this8.webex.sessionId, "_").concat((0, _now.default)()),
+          logger: _this8.logger
         };
-        if (_this0.webex.config.defaultMobiusSocketOptions) {
+        if (_this8.webex.config.defaultMobiusSocketOptions) {
           var customOptionsMsg = isShutdownSwitchover ? 'setting custom options for switchover' : 'setting custom options';
-          _this0.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(customOptionsMsg));
-          options = _objectSpread(_objectSpread({}, options), _this0.webex.config.defaultMobiusSocketOptions);
+          _this8.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(customOptionsMsg));
+          options = _objectSpread(_objectSpread({}, options), _this8.webex.config.defaultMobiusSocketOptions);
         }
 
-        // Set the socket before opening it. This allows a disconnect() to close
-        // the socket if it is in the process of being opened.
-        _this0.sockets.set(sessionId, socket);
-        _this0.socket = _this0.sockets.get(_this0.defaultSessionId);
-        _this0.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, " ").concat(logPrefix, " url for ").concat(sessionId, ": ").concat(webSocketUrl));
+        // Only promote the socket reference for normal connections.
+        // Shutdown switchover keeps the old socket active until the new one succeeds.
+        if (!isShutdownSwitchover) {
+          _this8.socket = socket;
+        }
+        _this8.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, " ").concat(logPrefix, " url: ").concat(webSocketUrl));
         return socket.open(webSocketUrl, options).then(function () {
           return webSocketUrl;
         });
       });
     }
   }, {
-    key: "_connectWithBackoff",
-    value: function _connectWithBackoff(webSocketUrl, sessionId) {
-      var _this1 = this;
-      var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    key: "connectWithBackoff",
+    value: function connectWithBackoff(webSocketUrl) {
+      var _this9 = this;
+      var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var _context$isShutdownSw = context.isShutdownSwitchover,
         isShutdownSwitchover = _context$isShutdownSw === void 0 ? false : _context$isShutdownSw,
         _context$attemptOptio = context.attemptOptions,
         attemptOptions = _context$attemptOptio === void 0 ? {} : _context$attemptOptio;
       return new _promise.default(function (resolve, reject) {
-        // eslint gets confused about whether call is actually used
         // eslint-disable-next-line prefer-const
         var call;
-        var isInitialConnect = !isShutdownSwitchover && !_this1.hasEverConnected;
-        var initialRetryLimit = _this1.config.initialConnectionMaxRetries == null ? null : Number(_this1.config.initialConnectionMaxRetries);
+        var isInitialConnect = !isShutdownSwitchover && !_this9.hasEverConnected;
+        var initialRetryLimit = _this9.config.initialConnectionMaxRetries == null ? null : Number(_this9.config.initialConnectionMaxRetries);
         var isInitialConnectWithoutRetries = isInitialConnect && initialRetryLimit === 0;
         var onComplete = function onComplete(err) {
-          var sid = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : sessionId;
           if (isShutdownSwitchover) {
-            _this1._shutdownSwitchoverBackoffCalls.delete(sid);
+            _this9.shutdownSwitchoverBackoffCall = undefined;
           } else {
-            _this1.backoffCalls.delete(sid);
+            _this9.backoffCall = undefined;
           }
-          var sessionSocket = _this1.sockets.get(sid);
           if (err) {
             var msg = isShutdownSwitchover ? "[shutdown] switchover failed after ".concat(call.getNumRetries(), " retries") : "failed to connect after ".concat(call.getNumRetries(), " retries");
-            _this1.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(msg, "; log statement about next retry was inaccurate; ").concat(err));
-            if (sessionSocket) {
-              sessionSocket.connecting = false;
-              sessionSocket.connected = false;
+            _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(msg, "; ").concat(err));
+            // Only mutate socket flags for normal connections.
+            // During shutdown switchover, this.socket is the old live socket — don't touch it.
+            if (!isShutdownSwitchover && _this9.socket) {
+              _this9.socket.connecting = false;
+              _this9.socket.connected = false;
             }
             return reject(err);
           }
 
-          // Update overall connected status
-          if (sessionSocket) {
-            sessionSocket.connecting = false;
-            sessionSocket.connected = true;
+          // For normal connections, mark the socket as connected.
+          // Shutdown switchover promotion is handled by the onSuccess callback.
+          if (!isShutdownSwitchover && _this9.socket) {
+            _this9.socket.connecting = false;
+            _this9.socket.connected = true;
           }
-          // Default success handling for normal connections
           if (!isShutdownSwitchover) {
-            _this1.connecting = _this1.hasConnectingSockets();
-            _this1.connected = _this1.hasConnectedSockets();
-            _this1.hasEverConnected = true;
-            _this1._startTokenRefreshTimer();
-            _this1._emit(sid, 'online');
+            _this9.connecting = false;
+            _this9.connected = true;
+            _this9.hasEverConnected = true;
+            _this9.startTokenRefreshTimer();
+            _this9.emitEvent('online');
           }
           return resolve();
         };
@@ -839,14 +524,14 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
         call = _backoff.default.call(function (callback) {
           var attemptNum = call.getNumRetries();
           var attemptLogPrefix = isShutdownSwitchover ? '[shutdown] switchover' : 'connection';
-          _this1.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": executing ").concat(attemptLogPrefix, " attempt ").concat(attemptNum, " for ").concat(sessionId));
-          _this1._attemptConnection(webSocketUrl, sessionId, callback, attemptOptions);
+          _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": executing ").concat(attemptLogPrefix, " attempt ").concat(attemptNum));
+          _this9.attemptConnection(webSocketUrl, callback, attemptOptions);
         }, function (err) {
-          return onComplete(err, sessionId);
+          return onComplete(err);
         });
         call.setStrategy(new _backoff.default.ExponentialStrategy({
-          initialDelay: _this1.config.backoffTimeReset,
-          maxDelay: _this1.config.backoffTimeMax
+          initialDelay: _this9.config.backoffTimeReset,
+          maxDelay: _this9.config.backoffTimeMax
         }));
         if (isInitialConnectWithoutRetries) {
           call.retryIf(function () {
@@ -854,192 +539,141 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
           });
         } else if (isInitialConnect && initialRetryLimit > 0) {
           call.failAfter(initialRetryLimit);
-        } else if (_this1.config.maxRetries) {
-          call.failAfter(_this1.config.maxRetries);
+        } else if (_this9.config.maxRetries) {
+          call.failAfter(_this9.config.maxRetries);
         }
 
-        // Store the call BEFORE setting up event handlers to prevent race conditions
-        // Store backoff call reference BEFORE starting (so it's available in _attemptConnection)
+        // Store backoff call reference BEFORE starting (so it's available in attemptConnection)
         if (isShutdownSwitchover) {
-          _this1._shutdownSwitchoverBackoffCalls.set(sessionId, call);
+          _this9.shutdownSwitchoverBackoffCall = call;
         } else {
-          _this1.backoffCalls.set(sessionId, call);
+          _this9.backoffCall = call;
         }
         call.on('abort', function () {
           var msg = isShutdownSwitchover ? 'Shutdown Switchover' : 'Connection';
-          _this1.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(msg, " aborted for ").concat(sessionId));
-          reject(new Error("MobiusSocket ".concat(msg, " Aborted for ").concat(sessionId)));
+          _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(msg, " aborted"));
+          reject(new Error("MobiusSocket ".concat(msg, " Aborted")));
         });
         call.on('callback', function (err) {
           if (err) {
             if (isInitialConnectWithoutRetries) {
-              // retryIf(() => false) already disabled retries for this initial connect;
-              // this branch only avoids logging the generic "attempting retry" message.
-              _this1.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": initial connect failed for ").concat(sessionId, "; retries already disabled"));
+              _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": initial connect failed; retries already disabled"));
               return;
             }
             var number = call.getNumRetries();
-            var delay = Math.min(call.strategy_.nextBackoffDelay_, _this1.config.backoffTimeMax);
+            var delay = Math.min(call.strategy_.nextBackoffDelay_, _this9.config.backoffTimeMax);
             var callbackLogPrefix = isShutdownSwitchover ? '[shutdown] switchover' : '';
-            _this1.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(callbackLogPrefix, " failed to connect; attempting retry ").concat(number + 1, " in ").concat(delay, " ms for ").concat(sessionId));
+            _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(callbackLogPrefix, " failed to connect; attempting retry ").concat(number + 1, " in ").concat(delay, " ms"));
             /* istanbul ignore if */
             if (process.env.NODE_ENV === 'development') {
-              _this1.logger.debug("".concat(MOBIUS_SOCKET_NAMESPACE, ": "), err, err.stack);
+              _this9.logger.debug("".concat(MOBIUS_SOCKET_NAMESPACE, ": "), err, err.stack);
             }
             return;
           }
-          _this1.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connected ").concat(sessionId));
+          _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connected"));
         });
         call.start();
       });
     }
   }, {
-    key: "_emit",
-    value: function _emit(sessionId, eventName) {
-      for (var _len5 = arguments.length, args = new Array(_len5 > 2 ? _len5 - 2 : 0), _key5 = 2; _key5 < _len5; _key5++) {
-        args[_key5 - 2] = arguments[_key5];
+    key: "emitEvent",
+    value: function emitEvent(eventName) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
       }
       try {
-        if (!sessionId || !eventName) {
+        if (!eventName) {
           return;
         }
-        var suffix = sessionId === this.defaultSessionId ? '' : ":".concat(sessionId);
-        this.emit.apply(this, ["".concat(eventName).concat(suffix)].concat(args));
+        this.emit.apply(this, [eventName].concat(args));
       } catch (error) {
         // Safely handle errors without causing additional issues during cleanup
-        try {
-          this.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": error occurred in event handler:"), error, ' with args: ', [sessionId, eventName].concat(args));
-        } catch (logError) {
-          // If even logging fails, just ignore to prevent cascading errors during cleanup
-          // eslint-disable-next-line no-console
-          console.error('MobiusSocket _emit error handling failed:', logError);
-        }
-      }
-    }
-  }, {
-    key: "_getEventHandlers",
-    value: function _getEventHandlers(eventType) {
-      if (!eventType) {
-        return [];
-      }
-      var _eventType$split = eventType.split('.'),
-        _eventType$split2 = (0, _slicedToArray2.default)(_eventType$split, 2),
-        namespace = _eventType$split2[0],
-        name = _eventType$split2[1];
-      var handlers = [];
-      if (!this.webex[namespace] && !this.webex.internal[namespace]) {
-        return handlers;
-      }
-      var handlerName = (0, _camelCase2.default)("process_".concat(name, "_event"));
-      if ((this.webex[namespace] || this.webex.internal[namespace])[handlerName]) {
-        handlers.push({
-          name: handlerName,
-          namespace: namespace
-        });
+        this.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": error occurred in event handler:"), error, ' with args: ', [eventName].concat(args));
       }
-      return handlers;
     }
   }, {
-    key: "_startTokenRefreshTimer",
-    value: function _startTokenRefreshTimer() {
-      var _this10 = this;
-      if (this._tokenRefreshTimer || !this.hasConnectedSockets()) {
+    key: "startTokenRefreshTimer",
+    value: function startTokenRefreshTimer() {
+      var _this0 = this;
+      if (this.tokenRefreshTimer || !this.connected) {
         return;
       }
-      this._tokenRefreshTimer = setInterval(function () {
-        _this10._refreshToken().catch(function (error) {
-          _this10.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": periodic token refresh failed"), error);
+      this.tokenRefreshTimer = setInterval(function () {
+        _this0.refreshToken().catch(function (error) {
+          _this0.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": periodic token refresh failed"), error);
         });
       }, TOKEN_REFRESH_INTERVAL_MS);
     }
   }, {
-    key: "_stopTokenRefreshTimer",
-    value: function _stopTokenRefreshTimer() {
-      if (!this._tokenRefreshTimer) {
+    key: "stopTokenRefreshTimer",
+    value: function stopTokenRefreshTimer() {
+      if (!this.tokenRefreshTimer) {
         return;
       }
-      clearInterval(this._tokenRefreshTimer);
-      this._tokenRefreshTimer = undefined;
+      clearInterval(this.tokenRefreshTimer);
+      this.tokenRefreshTimer = undefined;
     }
   }, {
-    key: "_refreshToken",
-    value: function _refreshToken() {
-      var _this11 = this;
-      if (this._tokenRefreshInFlight) {
-        return this._tokenRefreshInFlight;
+    key: "refreshToken",
+    value: function refreshToken() {
+      var _this1 = this;
+      if (this.tokenRefreshInFlight) {
+        return this.tokenRefreshInFlight;
       }
-      if (!this.hasConnectedSockets()) {
-        this._stopTokenRefreshTimer();
+      if (!this.connected) {
+        this.stopTokenRefreshTimer();
         return _promise.default.resolve();
       }
       var tokenPromise = this.webex.credentials.canRefresh ? this.webex.credentials.refresh({
         force: true
       }).then(function () {
-        return _this11.webex.credentials.getUserToken();
+        return _this1.webex.credentials.getUserToken();
       }) : this.webex.credentials.getUserToken();
-      this._tokenRefreshInFlight = tokenPromise.then(function (token) {
+      this.tokenRefreshInFlight = tokenPromise.then(function (token) {
+        var _this1$socket;
         if (!token) {
           throw new Error('Mobius token refresh did not return a token');
         }
         var refreshedToken = normalizeMobiusAuthToken(token.toString());
-        var authPayloadPromises = [];
-        var _iterator3 = _createForOfIteratorHelper(_this11.sockets.values()),
-          _step3;
-        try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var socket = _step3.value;
-            if (socket !== null && socket !== void 0 && socket.connected) {
-              authPayloadPromises.push(socket.refresh(refreshedToken));
-            }
-          }
-        } catch (err) {
-          _iterator3.e(err);
-        } finally {
-          _iterator3.f();
+        if ((_this1$socket = _this1.socket) !== null && _this1$socket !== void 0 && _this1$socket.connected) {
+          return _this1.socket.refresh(refreshedToken);
         }
-        return _promise.default.all(authPayloadPromises);
+        return undefined;
       }).catch(function (error) {
-        _this11.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": failed to refresh/re-auth Mobius sockets"), error);
+        _this1.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": failed to refresh/re-auth Mobius socket"), error);
         throw error;
       }).finally(function () {
-        _this11._tokenRefreshInFlight = undefined;
+        _this1.tokenRefreshInFlight = undefined;
       });
-      return this._tokenRefreshInFlight;
+      return this.tokenRefreshInFlight;
     }
   }, {
-    key: "_onclose",
-    value: function _onclose(sessionId, event, sourceSocket) {
+    key: "onclose",
+    value: function onclose(event, sourceSocket) {
       // I don't see any way to avoid the complexity or statement count in here.
       /* eslint complexity: [0] */
 
       try {
         var reason = event.reason && event.reason.toLowerCase();
-        var sessionSocket = this.sockets.get(sessionId);
         var socketUrl;
-        event.sessionId = sessionId;
-        var isActiveSocket = sourceSocket === sessionSocket;
+        var isActiveSocket = sourceSocket === this.socket;
         if (sourceSocket) {
           socketUrl = sourceSocket.url;
         }
-        this.sockets.delete(sessionId);
+
+        // Only tear down state if the currently active socket closed
         if (isActiveSocket) {
-          // Only tear down state if the currently active socket closed
-          if (sessionSocket) {
-            sessionSocket.removeAllListeners();
-            if (sessionId === this.defaultSessionId) {
-              this.socket = undefined;
-            }
-            this._emit(sessionId, 'offline', event);
-          }
-          // Update overall connected status
-          this.connecting = this.hasConnectingSockets();
-          this.connected = this.hasConnectedSockets();
-          if (!this.hasConnectedSockets()) {
-            this._stopTokenRefreshTimer();
+          if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket = undefined;
+            this.emitEvent('offline', event);
           }
+          this.connecting = false;
+          this.connected = false;
+          this.stopTokenRefreshTimer();
         } else {
           // Old socket closed; do not flip connection state
-          this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] non-active socket closed, code=").concat(event.code, " for ").concat(sessionId));
+          this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] non-active socket closed, code=").concat(event.code));
           // Clean up listeners from old socket now that it's closed
           if (sourceSocket) {
             sourceSocket.removeAllListeners();
@@ -1047,145 +681,111 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
         }
         switch (event.code) {
           case 1003:
-            // metric: disconnect
-            this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": service rejected last message for ").concat(sessionId, "; will not reconnect: ").concat(event.reason));
-            if (isActiveSocket) this._emit(sessionId, 'offline.permanent', event);
+            this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": service rejected last message; will not reconnect: ").concat(event.reason));
+            if (isActiveSocket) this.emitEvent('offline.permanent', event);
             break;
           case 4000:
-            // metric: disconnect
-            this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket ").concat(sessionId, " replaced; will not reconnect"));
-            if (isActiveSocket) this._emit(sessionId, 'offline.replaced', event);
-            // If not active, nothing to do
+            this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket replaced; will not reconnect"));
+            if (isActiveSocket) this.emitEvent('offline.replaced', event);
             break;
           case 4001:
             // replaced during shutdown
             if (isActiveSocket) {
               // Server closed active socket with 4001, meaning it expected this connection
-              // to be replaced, but the switchover in _handleImminentShutdown failed.
-              // This is a permanent failure - do not reconnect.
-              this.logger.warn("".concat(MOBIUS_SOCKET_NAMESPACE, ": active socket closed with 4001; shutdown switchover failed for ").concat(sessionId));
-              this._emit(sessionId, 'offline.permanent', event);
+              // to be replaced, but the switchover in handleImminentShutdown failed.
+              this.logger.warn("".concat(MOBIUS_SOCKET_NAMESPACE, ": active socket closed with 4001; shutdown switchover failed"));
+              this.emitEvent('offline.permanent', event);
             } else {
               // Expected: old socket closed after successful switchover
-              this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": old socket closed with 4001 (replaced during shutdown); no reconnect needed for ").concat(sessionId));
-              this._emit(sessionId, 'offline.replaced', event);
+              this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": old socket closed with 4001 (replaced during shutdown); no reconnect needed"));
+              this.emitEvent('offline.replaced', event);
             }
             break;
           case 1001:
           case 1005:
           case 1006:
           case 1011:
-            this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket ").concat(sessionId, " disconnected; reconnecting"));
+            this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket disconnected; reconnecting"));
             if (isActiveSocket) {
-              this._emit(sessionId, 'offline.transient', event);
-              this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] reconnecting active socket to recover for ").concat(sessionId));
-              this._reconnect(socketUrl, sessionId);
+              this.emitEvent('offline.transient', event);
+              this.reconnect(socketUrl);
             }
-            // metric: disconnect
-            // if (code == 1011 && reason !== ping error) metric: unexpected disconnect
             break;
           case 1000:
           case 3050:
-            // 3050 indicates logout form of closure, default to old behavior, use config reason defined by consumer to proceed with the permanent block
             if (normalReconnectReasons.includes(reason)) {
-              this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket ").concat(sessionId, " disconnected; reconnecting"));
+              this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket disconnected; reconnecting"));
               if (isActiveSocket) {
-                this._emit(sessionId, 'offline.transient', event);
-                this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] reconnecting due to normal close for ").concat(sessionId));
-                this._reconnect(socketUrl, sessionId);
+                this.emitEvent('offline.transient', event);
+                this.reconnect(socketUrl);
               }
-              // metric: disconnect
-              // if (reason === done forced) metric: force closure
             } else {
-              this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket ").concat(sessionId, " disconnected; will not reconnect: ").concat(event.reason));
-              if (isActiveSocket) this._emit(sessionId, 'offline.permanent', event);
+              this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket disconnected; will not reconnect: ").concat(event.reason));
+              if (isActiveSocket) this.emitEvent('offline.permanent', event);
             }
             break;
           default:
-            this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket ").concat(sessionId, " disconnected unexpectedly; will not reconnect"));
-            // unexpected disconnect
-            if (isActiveSocket) this._emit(sessionId, 'offline.permanent', event);
+            this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket disconnected unexpectedly; will not reconnect"));
+            if (isActiveSocket) this.emitEvent('offline.permanent', event);
         }
       } catch (error) {
-        this.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": error occurred in close handler for ").concat(sessionId), error);
+        this.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": error occurred in close handler"), error);
       }
     }
   }, {
-    key: "_onmessage",
-    value: function _onmessage(sessionId, event) {
-      var _this12 = this;
-      this._setTimeOffset(sessionId, event);
+    key: "onmessage",
+    value: function onmessage(event) {
       var envelope = event.data;
-      if (process.env.ENABLE_MERCURY_LOGGING) {
-        this.logger.debug("".concat(MOBIUS_SOCKET_NAMESPACE, ": message envelope from ").concat(sessionId, ": "), envelope);
+      if (process.env.ENABLE_MOBIUS_LOGGING) {
+        this.logger.debug("".concat(MOBIUS_SOCKET_NAMESPACE, ": message envelope: "), envelope);
       }
-      envelope.sessionId = sessionId;
 
       // Handle shutdown message shape: { type: 'shutdown' }
       if (envelope && envelope.type === 'shutdown') {
-        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] imminent shutdown message received for ").concat(sessionId));
-        this._emit(sessionId, 'event:mercury_shutdown_imminent', envelope);
-        this._handleImminentShutdown(sessionId);
+        this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] imminent shutdown message received"));
+        this.emitEvent('event:mobius_shutdown_imminent', envelope); // This is not yet not implemented, keeping for future support
+
+        this.handleImminentShutdown();
         return _promise.default.resolve();
       }
-      if (this._trackAsyncEventAndShouldSuppressDuplicate(sessionId, envelope)) {
+      if (this.trackAsyncEventAndShouldSuppressDuplicate(envelope)) {
         return _promise.default.resolve();
       }
 
-      // Mobius: emit event:<type> for typed messages (e.g., register.response)
+      // Emit event:<type> for typed messages (e.g., register.response)
       if (envelope.type) {
-        this._emit(sessionId, "event:".concat(envelope.type), envelope);
+        this.emitEvent("event:".concat(envelope.type), envelope);
       }
-      envelope.sessionId = sessionId;
+
       // Use data/payload if present, otherwise treat the envelope itself as the data (flat format)
       var data = envelope.data || envelope;
-      this._applyOverrides(data);
 
-      // Support both Mercury-enveloped (data.eventType) and flat (eventType) formats
+      // Support both Mobius-enveloped (data.eventType) and flat (eventType) formats
       var eventType = (data === null || data === void 0 ? void 0 : data.eventType) || envelope.eventType;
       if (!eventType) {
-        this._emit(sessionId, 'event', envelope);
+        this.emitEvent('event', envelope);
         return _promise.default.resolve();
       }
-      return this._getEventHandlers(eventType).reduce(function (promise, handler) {
-        return promise.then(function () {
-          var namespace = handler.namespace,
-            name = handler.name;
-          return new _promise.default(function (resolve) {
-            resolve((_this12.webex[namespace] || _this12.webex.internal[namespace])[name](data));
-          }).catch(function (reason) {
-            return _this12.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": error occurred in autowired event handler for ").concat(eventType, " from ").concat(sessionId), reason);
-          });
-        });
-      }, _promise.default.resolve()).then(function () {
-        _this12._emit(sessionId, 'event', envelope);
-        var _eventType$split3 = eventType.split('.'),
-          _eventType$split4 = (0, _slicedToArray2.default)(_eventType$split3, 1),
-          namespace = _eventType$split4[0];
-        if (namespace === eventType) {
-          _this12._emit(sessionId, "event:".concat(namespace), envelope);
-        } else {
-          _this12._emit(sessionId, "event:".concat(namespace), envelope);
-          _this12._emit(sessionId, "event:".concat(eventType), envelope);
+      try {
+        // TODO: Remove if event:namespace is not required
+        this.emitEvent('event', envelope);
+        var _eventType$split = eventType.split('.'),
+          _eventType$split2 = (0, _slicedToArray2.default)(_eventType$split, 1),
+          namespace = _eventType$split2[0];
+        this.emitEvent("event:".concat(namespace), envelope);
+        if (namespace !== eventType) {
+          this.emitEvent("event:".concat(eventType), envelope);
         }
-      }).catch(function (reason) {
-        _this12.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": error occurred processing socket message from ").concat(sessionId), reason);
-      });
-    }
-  }, {
-    key: "_setTimeOffset",
-    value: function _setTimeOffset(sessionId, event) {
-      var wsWriteTimestamp = event.data.wsWriteTimestamp;
-      if (typeof wsWriteTimestamp === 'number' && wsWriteTimestamp > 0) {
-        this.mercuryTimeOffset = (0, _now.default)() - wsWriteTimestamp;
+      } catch (reason) {
+        this.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": error occurred processing socket message"), reason);
       }
+      return _promise.default.resolve();
     }
   }, {
-    key: "_reconnect",
-    value: function _reconnect(webSocketUrl) {
-      var sessionId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.defaultSessionId;
-      this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": reconnecting ").concat(sessionId));
-      return this.connect(webSocketUrl || this.socketUrl, sessionId);
+    key: "reconnect",
+    value: function reconnect(webSocketUrl) {
+      this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": reconnecting"));
+      return this.connect(webSocketUrl || this.socketUrl);
     }
   }]);
 }(_events.EventEmitter);