@webex/internal-plugin-mercury 3.11.0-webex-services-ready.1 → 3.12.0-auth-prejoin-fetch.1

package/dist/mercury.js

@@ -1,5 +1,9 @@
 "use strict";
 
+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$isArray = require("@babel/runtime-corejs2/core-js/array/is-array");
 var _Object$keys2 = require("@babel/runtime-corejs2/core-js/object/keys");
 var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
 var _Object$getOwnPropertyDescriptor2 = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
@@ -11,12 +15,15 @@ _Object$defineProperty(exports, "__esModule", {
   value: true
 });
 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 _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
 var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
 var _assign = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/assign"));
 var _deleteProperty = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/reflect/delete-property"));
 var _getOwnPropertyDescriptor = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
 var _applyDecoratedDescriptor2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/applyDecoratedDescriptor"));
@@ -34,10 +41,15 @@ var _dec, _dec2, _obj;
  */
 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$getOwnPropertyDescriptor2(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$getOwnPropertyDescriptor2(t, r)); }); } return e; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof _Symbol && r[_Symbol$iterator] || r["@@iterator"]; if (!t) { if (_Array$isArray(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; }
 var normalReconnectReasons = ['idle', 'done (forced)', 'pong not received', 'pong mismatch'];
+var MERCURY_CLOSE_4000_METRIC = 'JS_SDK_MERCURY_CLOSE_4000';
 var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mercury#listen(): Use Mercury#connect() instead'), _dec2 = (0, _common.deprecated)('Mercury#stopListening(): Use Mercury#disconnect() instead'), _obj = {
   namespace: 'Mercury',
   lastError: undefined,
+  defaultSessionId: 'mercury-default-session',
   session: {
     connected: {
       default: false,
@@ -51,7 +63,30 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
       default: false,
       type: 'boolean'
     },
-    socket: 'object',
+    sockets: {
+      default: function _default() {
+        return new _map.default();
+      },
+      type: 'object'
+    },
+    sessionWebSocketUrls: {
+      default: function _default() {
+        return new _map.default();
+      },
+      type: 'object'
+    },
+    backoffCalls: {
+      default: function _default() {
+        return new _map.default();
+      },
+      type: 'object'
+    },
+    _shutdownSwitchoverBackoffCalls: {
+      default: function _default() {
+        return new _map.default();
+      },
+      type: 'object'
+    },
     localClusterServiceUrls: 'object',
     mercuryTimeOffset: {
       default: undefined,
@@ -105,60 +140,70 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
   /**
    * 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}
    */
-  _attachSocketEventListeners: function _attachSocketEventListeners(socket) {
+  _attachSocketEventListeners: function _attachSocketEventListeners(socket, sessionId) {
     var _this2 = this;
     socket.on('close', function (event) {
-      return _this2._onclose(event, socket);
+      return _this2._onclose(sessionId, event, socket);
     });
     socket.on('message', function () {
-      return _this2._onmessage.apply(_this2, arguments);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return _this2._onmessage.apply(_this2, [sessionId].concat(args));
     });
     socket.on('pong', function () {
-      return _this2._setTimeOffset.apply(_this2, arguments);
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return _this2._setTimeOffset.apply(_this2, [sessionId].concat(args));
     });
     socket.on('sequence-mismatch', function () {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
       }
-      return _this2._emit.apply(_this2, ['sequence-mismatch'].concat(args));
+      return _this2._emit.apply(_this2, [sessionId, 'sequence-mismatch'].concat(args));
     });
     socket.on('ping-pong-latency', function () {
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
       }
-      return _this2._emit.apply(_this2, ['ping-pong-latency'].concat(args));
+      return _this2._emit.apply(_this2, [sessionId, 'ping-pong-latency'].concat(args));
     });
   },
   /**
    * 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}
    */
-  _handleImminentShutdown: function _handleImminentShutdown() {
+  _handleImminentShutdown: function _handleImminentShutdown(sessionId) {
     var _this3 = this;
+    var oldSocket = this.sockets.get(sessionId);
     try {
-      if (this._shutdownSwitchoverInProgress) {
-        this.logger.info("".concat(this.namespace, ": [shutdown] switchover already in progress"));
+      // 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(this.namespace, ": [shutdown] switchover already in progress for ").concat(sessionId));
         return;
       }
-      this._shutdownSwitchoverInProgress = true;
       this._shutdownSwitchoverId = "".concat((0, _now.default)());
-      this.logger.info("".concat(this.namespace, ": [shutdown] switchover start, id=").concat(this._shutdownSwitchoverId));
-      this._connectWithBackoff(undefined, {
+      this.logger.info("".concat(this.namespace, ": [shutdown] switchover start, id=").concat(this._shutdownSwitchoverId, " for ").concat(sessionId));
+      this._connectWithBackoff(undefined, sessionId, {
         isShutdownSwitchover: true,
         attemptOptions: {
           isShutdownSwitchover: true,
           onSuccess: function onSuccess(newSocket, webSocketUrl) {
-            _this3.logger.info("".concat(_this3.namespace, ": [shutdown] switchover connected, url: ").concat(webSocketUrl));
-            var oldSocket = _this3.socket;
+            _this3.logger.info("".concat(_this3.namespace, ": [shutdown] switchover connected, url: ").concat(webSocketUrl, " for ").concat(sessionId));
+
             // Atomically switch active socket reference
-            _this3.socket = newSocket;
-            _this3.connected = true; // remain connected throughout
+            _this3.socket = _this3.sockets.get(_this3.defaultSessionId);
+            _this3.connected = _this3.hasConnectedSockets(); // remain connected throughout
 
-            _this3._emit('event:mercury_shutdown_switchover_complete', {
+            _this3._emit(sessionId, 'event:mercury_shutdown_switchover_complete', {
               url: webSocketUrl
             });
             if (oldSocket) {
@@ -167,18 +212,18 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
           }
         }
       }).then(function () {
-        _this3.logger.info("".concat(_this3.namespace, ": [shutdown] switchover completed successfully"));
+        _this3.logger.info("".concat(_this3.namespace, ": [shutdown] switchover completed successfully for ").concat(sessionId));
       }).catch(function (err) {
-        _this3.logger.info("".concat(_this3.namespace, ": [shutdown] switchover exhausted retries; will fall back to normal reconnection"), err);
-        _this3._emit('event:mercury_shutdown_switchover_failed', {
+        _this3.logger.info("".concat(_this3.namespace, ": [shutdown] switchover exhausted retries; will fall back to normal reconnection for ").concat(sessionId, ": "), err);
+        _this3._emit(sessionId, 'event:mercury_shutdown_switchover_failed', {
           reason: err
         });
         // Old socket will eventually close with 4001, triggering normal reconnection
       });
     } catch (e) {
-      this.logger.error("".concat(this.namespace, ": [shutdown] error during switchover"), e);
-      this._shutdownSwitchoverInProgress = false;
-      this._emit('event:mercury_shutdown_switchover_failed', {
+      this.logger.error("".concat(this.namespace, ": [shutdown] error during switchover for ").concat(sessionId), e);
+      this._shutdownSwitchoverBackoffCalls.delete(sessionId);
+      this._emit(sessionId, 'event:mercury_shutdown_switchover_failed', {
         reason: e
       });
     }
@@ -190,45 +235,154 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
   getLastError: function getLastError() {
     return this.lastError;
   },
+  /**
+   * Get all active socket connections
+   * @returns {Map} Map of sessionId to socket instances
+   */
+  getSockets: 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
+   */
+  getSocket: function getSocket() {
+    var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.defaultSessionId;
+    return this.sockets.get(sessionId);
+  },
+  /**
+   * Check if a socket is connected
+   * @param {string} [sessionId=this.defaultSessionId] - The session identifier
+   * @returns {boolean|undefined} True if the socket is connected
+   */
+  hasConnectedSockets: function hasConnectedSockets() {
+    var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.defaultSessionId;
+    var socket = this.sockets.get(sessionId || this.defaultSessionId);
+    return socket === null || socket === void 0 ? void 0 : socket.connected;
+  },
+  /**
+   * Check if any sockets are connecting
+   * @param {string} [sessionId=this.defaultSessionId] - The session identifier
+   * @returns {boolean|undefined} True if the socket is connecting
+   */
+  hasConnectingSockets: function hasConnectingSockets() {
+    var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.defaultSessionId;
+    var socket = this.sockets.get(sessionId || this.defaultSessionId);
+    return socket === null || socket === void 0 ? void 0 : socket.connecting;
+  },
+  /**
+   * Connect to Mercury for a specific session.
+   * @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.
+   */
   connect: function connect(webSocketUrl) {
     var _this4 = this;
-    if (this.connected) {
-      this.logger.info("".concat(this.namespace, ": already connected, will not connect again"));
+    var sessionId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.defaultSessionId;
+    if (!this._connectPromises) this._connectPromises = new _map.default();
+
+    // First check if there's already a connection promise for this session
+    if (this._connectPromises.has(sessionId)) {
+      this.logger.info("".concat(this.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(this.namespace, ": connection ").concat(sessionId, " already connected, will not connect again"));
       return _promise.default.resolve();
     }
     this.connecting = true;
-    this.logger.info("".concat(this.namespace, ": starting connection attempt"));
+    this.logger.info("".concat(this.namespace, ": starting connection attempt for ").concat(sessionId));
     this.logger.info("".concat(this.namespace, ": debug_mercury_logging stack: "), new Error('debug_mercury_logging').stack);
-    return _promise.default.resolve(this.webex.internal.device.registered || this.webex.internal.device.register()).then(function () {
-      _this4.logger.info("".concat(_this4.namespace, ": connecting"));
-      return _this4._connectWithBackoff(webSocketUrl);
+    var connectPromise = _promise.default.resolve(this.webex.internal.device.registered || this.webex.internal.device.register()).then(function () {
+      _this4.logger.info("".concat(_this4.namespace, ": connecting ").concat(sessionId));
+      return _this4._connectWithBackoff(webSocketUrl, sessionId);
+    }).finally(function () {
+      _this4._connectPromises.delete(sessionId);
     });
+    this._connectPromises.set(sessionId, connectPromise);
+    return connectPromise;
   },
   logout: function logout() {
     this.logger.info("".concat(this.namespace, ": logout() called"));
     this.logger.info("".concat(this.namespace, ": debug_mercury_logging stack: "), new Error('debug_mercury_logging').stack);
-    return this.disconnect(this.config.beforeLogoutOptionsCloseReason && !normalReconnectReasons.includes(this.config.beforeLogoutOptionsCloseReason) ? {
+    return this.disconnectAll(this.config.beforeLogoutOptionsCloseReason && !normalReconnectReasons.includes(this.config.beforeLogoutOptionsCloseReason) ? {
       code: 3050,
       reason: this.config.beforeLogoutOptionsCloseReason
     } : undefined);
   },
+  /**
+   * Disconnect a Mercury 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: function disconnect(options) {
     var _this5 = this;
+    var sessionId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.defaultSessionId;
+    this.logger.info("".concat(this.namespace, "#disconnect: connecting state: ").concat(this.connecting, ", connected state: ").concat(this.connected, ", socket exists: ").concat(!!this.socket, ", options: ").concat((0, _stringify.default)(options)));
     return new _promise.default(function (resolve) {
-      if (_this5.backoffCall) {
-        _this5.logger.info("".concat(_this5.namespace, ": aborting connection"));
-        _this5.backoffCall.abort();
+      var backoffCall = _this5.backoffCalls.get(sessionId);
+      if (backoffCall) {
+        _this5.logger.info("".concat(_this5.namespace, ": aborting connection ").concat(sessionId));
+        backoffCall.abort();
+        _this5.backoffCalls.delete(sessionId);
+      }
+      var shutdownSwitchoverBackoffCall = _this5._shutdownSwitchoverBackoffCalls.get(sessionId);
+      if (shutdownSwitchoverBackoffCall) {
+        _this5.logger.info("".concat(_this5.namespace, ": aborting shutdown switchover connection ").concat(sessionId));
+        shutdownSwitchoverBackoffCall.abort();
+        _this5._shutdownSwitchoverBackoffCalls.delete(sessionId);
       }
-      if (_this5._shutdownSwitchoverBackoffCall) {
-        _this5.logger.info("".concat(_this5.namespace, ": aborting shutdown switchover"));
-        _this5._shutdownSwitchoverBackoffCall.abort();
+      // Clean up any pending connection promises
+      if (_this5._connectPromises) {
+        _this5._connectPromises.delete(sessionId);
       }
-      if (_this5.socket) {
-        _this5.socket.removeAllListeners('message');
-        _this5.once('offline', resolve);
-        resolve(_this5.socket.close(options || undefined));
+      var sessionSocket = _this5.sockets.get(sessionId);
+      var suffix = sessionId === _this5.defaultSessionId ? '' : ":".concat(sessionId);
+      if (sessionSocket) {
+        sessionSocket.removeAllListeners('message');
+        sessionSocket.connecting = false;
+        sessionSocket.connected = false;
+        _this5.once(sessionId === _this5.defaultSessionId ? 'offline' : "offline".concat(suffix), resolve);
+        resolve(sessionSocket.close(options || undefined));
       }
       resolve();
+
+      // Update overall connected status
+      _this5.connected = _this5.hasConnectedSockets();
+    });
+  },
+  /**
+   * Disconnect all socket connections
+   * @param {object} options - Close options
+   * @returns {Promise} Promise that resolves when all connections are closed
+   */
+  disconnectAll: function disconnectAll(options) {
+    var _this6 = this;
+    var disconnectPromises = [];
+    var _iterator = _createForOfIteratorHelper(this.sockets.keys()),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var sessionId = _step.value;
+        disconnectPromises.push(this.disconnect(options, sessionId));
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return _promise.default.all(disconnectPromises).then(function () {
+      _this6.connected = false;
+      _this6.sockets.clear();
+      _this6.sessionWebSocketUrls.clear();
+      _this6.backoffCalls.clear();
+      // Clear connection promises to prevent stale promises
+      if (_this6._connectPromises) {
+        _this6._connectPromises.clear();
+      }
     });
   },
   listen: function listen() {
@@ -252,7 +406,7 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
     });
   },
   _prepareUrl: function _prepareUrl(webSocketUrl) {
-    var _this6 = this;
+    var _this7 = this;
     if (!webSocketUrl) {
       webSocketUrl = this.webex.internal.device.webSocketUrl;
     }
@@ -260,16 +414,16 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
       if (haMessagingEnabled) {
         var highPrioritySocketUrl;
         try {
-          highPrioritySocketUrl = _this6.webex.internal.services.convertUrlToPriorityHostUrl(webSocketUrl);
+          highPrioritySocketUrl = _this7.webex.internal.services.convertUrlToPriorityHostUrl(webSocketUrl);
         } catch (e) {
-          _this6.logger.warn("".concat(_this6.namespace, ": error converting to high priority url"), e);
+          _this7.logger.warn("".concat(_this7.namespace, ": error converting to high priority url"), e);
         }
         if (!highPrioritySocketUrl) {
           var _url$parse;
           var hostFromUrl = (_url$parse = _url.default.parse(webSocketUrl, true)) === null || _url$parse === void 0 ? void 0 : _url$parse.host;
-          var isValidHost = _this6.webex.internal.services.isValidHost(hostFromUrl);
+          var isValidHost = _this7.webex.internal.services.isValidHost(hostFromUrl);
           if (!isValidHost) {
-            _this6.logger.error("".concat(_this6.namespace, ": host ").concat(hostFromUrl, " is not a valid host from host catalog"));
+            _this7.logger.error("".concat(_this7.namespace, ": host ").concat(hostFromUrl, " is not a valid host from host catalog"));
             return '';
           }
         }
@@ -279,7 +433,7 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
     }).then(function (wsUrl) {
       webSocketUrl = wsUrl;
     }).then(function () {
-      return _this6.webex.internal.feature.getFeature('developer', 'web-shared-mercury');
+      return _this7.webex.internal.feature.getFeature('developer', 'web-shared-mercury');
     }).then(function (webSharedMercury) {
       if (!webSocketUrl) {
         return '';
@@ -297,27 +451,31 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
         });
         (0, _deleteProperty.default)(webSocketUrl.query, 'bufferStates');
       }
-      if ((0, _lodash.get)(_this6, 'webex.config.device.ephemeral', false)) {
+      if ((0, _lodash.get)(_this7, 'webex.config.device.ephemeral', false)) {
         webSocketUrl.query.multipleConnections = true;
       }
       webSocketUrl.query.clientTimestamp = (0, _now.default)();
+      delete webSocketUrl.search;
       return _url.default.format(webSocketUrl);
     });
   },
-  _attemptConnection: function _attemptConnection(socketUrl, callback) {
-    var _this7 = this;
-    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  _attemptConnection: function _attemptConnection(socketUrl, sessionId, callback) {
+    var _this8 = this;
+    var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
     var _options$isShutdownSw = options.isShutdownSwitchover,
       isShutdownSwitchover = _options$isShutdownSw === void 0 ? false : _options$isShutdownSw,
       _options$onSuccess = options.onSuccess,
       onSuccess = _options$onSuccess === void 0 ? null : _options$onSuccess;
     var socket = new _socket.default();
+    socket.connecting = true;
     var newWSUrl;
-    this._attachSocketEventListeners(socket);
+    this._attachSocketEventListeners(socket, sessionId);
+    var backoffCall = isShutdownSwitchover ? this._shutdownSwitchoverBackoffCalls.get(sessionId) : this.backoffCalls.get(sessionId);
 
     // Check appropriate backoff call based on connection type
-    if (isShutdownSwitchover && !this._shutdownSwitchoverBackoffCall) {
-      var msg = "".concat(this.namespace, ": prevent socket open when switchover backoff call no longer defined");
+    if (!backoffCall) {
+      var mode = isShutdownSwitchover ? 'switchover backoff call' : 'backoffCall';
+      var msg = "".concat(this.namespace, ": prevent socket open when ").concat(mode, " no longer defined for ").concat(sessionId);
       var err = new Error(msg);
       this.logger.info(msg);
 
@@ -325,24 +483,15 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
       callback(err);
       return _promise.default.reject(err);
     }
-    if (!isShutdownSwitchover && !this.backoffCall) {
-      var _msg = "".concat(this.namespace, ": prevent socket open when backoffCall 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);
-    }
 
     // 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.socket = socket;
+      this.sockets.set(sessionId, socket);
     }
-    return this._prepareAndOpenSocket(socket, socketUrl, isShutdownSwitchover).then(function (webSocketUrl) {
+    return this._prepareAndOpenSocket(socket, socketUrl, sessionId, isShutdownSwitchover).then(function (webSocketUrl) {
       newWSUrl = webSocketUrl;
-      _this7.logger.info("".concat(_this7.namespace, ": ").concat(isShutdownSwitchover ? '[shutdown] switchover' : '', " connected to mercury, success, action: connected, url: ").concat(newWSUrl));
+      _this8.logger.info("".concat(_this8.namespace, ": ").concat(isShutdownSwitchover ? '[shutdown] switchover' : '', " connected to mercury, success, action: connected for ").concat(sessionId, ", url: ").concat(newWSUrl));
 
       // Custom success handler for shutdown switchover
       if (onSuccess) {
@@ -353,46 +502,46 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
 
       // Default behavior for normal connection
       callback();
-      return _this7.webex.internal.feature.getFeature('developer', 'web-high-availability').then(function (haMessagingEnabled) {
+      return _this8.webex.internal.feature.getFeature('developer', 'web-high-availability').then(function (haMessagingEnabled) {
         if (haMessagingEnabled) {
-          return _this7.webex.internal.device.refresh();
+          return _this8.webex.internal.device.refresh();
         }
         return _promise.default.resolve();
       });
     }).catch(function (reason) {
-      var _this7$backoffCall, _this7$backoffCall3;
       // For shutdown, simpler error handling - just callback for retry
       if (isShutdownSwitchover) {
-        _this7.logger.info("".concat(_this7.namespace, ": [shutdown] switchover attempt failed"), reason);
+        _this8.logger.info("".concat(_this8.namespace, ": [shutdown] switchover attempt failed for ").concat(sessionId), reason);
         return callback(reason);
       }
 
       // Normal connection error handling (existing complex logic)
-      _this7.lastError = reason; // remember the last error
+      _this8.lastError = reason; // remember the last error
 
+      var backoffCallNormal = _this8.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).
-      if (reason.code !== 1006 && _this7.backoffCall && ((_this7$backoffCall = _this7.backoffCall) === null || _this7$backoffCall === void 0 ? void 0 : _this7$backoffCall.getNumRetries()) > 0) {
-        var _this7$backoffCall2;
-        _this7._emit('connection_failed', reason, {
-          retries: (_this7$backoffCall2 = _this7.backoffCall) === null || _this7$backoffCall2 === void 0 ? void 0 : _this7$backoffCall2.getNumRetries()
+      if (reason.code !== 1006 && backoffCallNormal && (backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()) > 0) {
+        _this8._emit(sessionId, 'connection_failed', reason, {
+          sessionId: sessionId,
+          retries: backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()
         });
       }
-      _this7.logger.info("".concat(_this7.namespace, ": connection attempt failed"), reason, ((_this7$backoffCall3 = _this7.backoffCall) === null || _this7$backoffCall3 === void 0 ? void 0 : _this7$backoffCall3.getNumRetries()) === 0 ? reason.stack : '');
+      _this8.logger.info("".concat(_this8.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
       // web socket url and let WDM handle the token checking
       if (reason instanceof _errors.UnknownResponse) {
-        _this7.logger.info("".concat(_this7.namespace, ": received unknown response code, refreshing device registration"));
-        return _this7.webex.internal.device.refresh().then(function () {
+        _this8.logger.info("".concat(_this8.namespace, ": received unknown response code for ").concat(sessionId, ", refreshing device registration"));
+        return _this8.webex.internal.device.refresh().then(function () {
           return callback(reason);
         });
       }
       // NotAuthorized implies expired token
       if (reason instanceof _errors.NotAuthorized) {
-        _this7.logger.info("".concat(_this7.namespace, ": received authorization error, reauthorizing"));
-        return _this7.webex.credentials.refresh({
+        _this8.logger.info("".concat(_this8.namespace, ": received authorization error for ").concat(sessionId, ", reauthorizing"));
+        return _this8.webex.credentials.refresh({
           force: true
         }).then(function () {
           return callback(reason);
@@ -407,15 +556,20 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
       // BadRequest implies current credentials are for a Service Account
       // Forbidden implies current user is not entitle for Webex
       if (reason instanceof _errors.BadRequest || reason instanceof _errors.Forbidden) {
-        _this7.logger.warn("".concat(_this7.namespace, ": received unrecoverable response from mercury"));
-        _this7.backoffCall.abort();
+        _this8.logger.warn("".concat(_this8.namespace, ": received unrecoverable response from mercury for ").concat(sessionId));
+        backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.abort();
         return callback(reason);
       }
       if (reason instanceof _errors.ConnectionError) {
-        return _this7.webex.internal.feature.getFeature('developer', 'web-high-availability').then(function (haMessagingEnabled) {
+        return _this8.webex.internal.feature.getFeature('developer', 'web-high-availability').then(function (haMessagingEnabled) {
+          var wsUrl = newWSUrl || reason.webSocketUrl;
           if (haMessagingEnabled) {
-            _this7.logger.info("".concat(_this7.namespace, ": received a generic connection error, will try to connect to another datacenter. failed, action: 'failed', url: ").concat(newWSUrl, " error: ").concat(reason.message));
-            return _this7.webex.internal.services.markFailedUrl(newWSUrl);
+            _this8.logger.info("".concat(_this8.namespace, ": received a generic connection error for ").concat(sessionId, ", will try to connect to another datacenter. failed, action: 'failed', url: ").concat(wsUrl, " error: ").concat(reason.message));
+            if (wsUrl) {
+              _this8.logger.info("".concat(_this8.namespace, ": marking ").concat(wsUrl, " as failed for ").concat(sessionId, " due to connection error"));
+              return _this8.webex.internal.services.markFailedUrl(wsUrl);
+            }
+            _this8.logger.info("".concat(_this8.namespace, ": no socket url available to mark as failed for ").concat(sessionId, " due to connection error"));
           }
           return null;
         }).then(function () {
@@ -424,129 +578,186 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
       }
       return callback(reason);
     }).catch(function (reason) {
-      _this7.logger.error("".concat(_this7.namespace, ": failed to handle connection failure"), reason);
+      _this8.logger.error("".concat(_this8.namespace, ": failed to handle connection failure for ").concat(sessionId), reason);
       callback(reason);
     });
   },
-  _prepareAndOpenSocket: function _prepareAndOpenSocket(socket, socketUrl) {
-    var _this8 = this;
-    var isShutdownSwitchover = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  _prepareAndOpenSocket: function _prepareAndOpenSocket(socket, socketUrl, sessionId) {
+    var _this9 = this;
+    var isShutdownSwitchover = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
     var logPrefix = isShutdownSwitchover ? '[shutdown] switchover' : 'connection';
     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: _this8.config.forceCloseDelay,
-        pingInterval: _this8.config.pingInterval,
-        pongTimeout: _this8.config.pongTimeout,
+        forceCloseDelay: _this9.config.forceCloseDelay,
+        pingInterval: _this9.config.pingInterval,
+        pongTimeout: _this9.config.pongTimeout,
         token: token.toString(),
-        trackingId: "".concat(_this8.webex.sessionId, "_").concat((0, _now.default)()),
-        logger: _this8.logger
+        trackingId: "".concat(_this9.webex.sessionId, "_").concat((0, _now.default)()),
+        logger: _this9.logger
       };
-      if (_this8.webex.config.defaultMercuryOptions) {
+      if (_this9.webex.config.defaultMercuryOptions) {
         var customOptionsMsg = isShutdownSwitchover ? 'setting custom options for switchover' : 'setting custom options';
-        _this8.logger.info("".concat(_this8.namespace, ": ").concat(customOptionsMsg));
-        options = _objectSpread(_objectSpread({}, options), _this8.webex.config.defaultMercuryOptions);
+        _this9.logger.info("".concat(_this9.namespace, ": ").concat(customOptionsMsg));
+        options = _objectSpread(_objectSpread({}, options), _this9.webex.config.defaultMercuryOptions);
       }
-      _this8.logger.info("".concat(_this8.namespace, ": ").concat(logPrefix, " url: ").concat(webSocketUrl));
+
+      // Set the socket before opening it. This allows a disconnect() to close
+      // the socket if it is in the process of being opened.
+      _this9.sockets.set(sessionId, socket);
+      _this9.socket = _this9.sockets.get(_this9.defaultSessionId);
+      _this9.logger.info("".concat(_this9.namespace, " ").concat(logPrefix, " url for ").concat(sessionId, ": ").concat(webSocketUrl));
+
+      // Remember the resolved URL used to open this socket so that
+      // reconnection in _onclose re-derives from a catalog-valid host. This is
+      // captured before socket.open(), which a lower layer (e.g. the same-site
+      // websocket proxy done with interceptors) may rewrite into a non-catalog host.
+      // Reusing the post-proxy native socket URL would fail
+      // host-catalog validation in _prepareUrl and block reconnection.
+      _this9.sessionWebSocketUrls.set(sessionId, webSocketUrl);
       return socket.open(webSocketUrl, options).then(function () {
         return webSocketUrl;
+      }).catch(function (err) {
+        err.webSocketUrl = webSocketUrl;
+        return _promise.default.reject(err);
       });
     });
   },
-  _connectWithBackoff: function _connectWithBackoff(webSocketUrl) {
-    var _this9 = this;
-    var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  _connectWithBackoff: function _connectWithBackoff(webSocketUrl, sessionId) {
+    var _this0 = this;
+    var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     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 or not call is actually used
+      // eslint gets confused about whether call is actually used
       // eslint-disable-next-line prefer-const
       var call;
       var onComplete = function onComplete(err) {
-        // Clear state flags based on connection type
+        var sid = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : sessionId;
         if (isShutdownSwitchover) {
-          _this9._shutdownSwitchoverInProgress = false;
-          _this9._shutdownSwitchoverBackoffCall = undefined;
+          _this0._shutdownSwitchoverBackoffCalls.delete(sid);
         } else {
-          _this9.connecting = false;
-          _this9.backoffCall = undefined;
+          _this0.backoffCalls.delete(sid);
         }
+        var sessionSocket = _this0.sockets.get(sid);
         if (err) {
           var msg = isShutdownSwitchover ? "[shutdown] switchover failed after ".concat(call.getNumRetries(), " retries") : "failed to connect after ".concat(call.getNumRetries(), " retries");
-          _this9.logger.info("".concat(_this9.namespace, ": ").concat(msg, "; log statement about next retry was inaccurate; ").concat(err));
+          _this0.logger.info("".concat(_this0.namespace, ": ").concat(msg, "; log statement about next retry was inaccurate; ").concat(err));
+          if (sessionSocket) {
+            sessionSocket.connecting = false;
+            sessionSocket.connected = false;
+          }
           return reject(err);
         }
 
+        // Update overall connected status
+        if (sessionSocket) {
+          sessionSocket.connecting = false;
+          sessionSocket.connected = true;
+        }
         // Default success handling for normal connections
         if (!isShutdownSwitchover) {
-          _this9.connected = true;
-          _this9.hasEverConnected = true;
-          _this9._emit('online');
-          _this9.webex.internal.newMetrics.callDiagnosticMetrics.setMercuryConnectedStatus(true);
+          _this0.connecting = _this0.hasConnectingSockets();
+          _this0.connected = _this0.hasConnectedSockets();
+          _this0.hasEverConnected = true;
+          _this0._emit(sid, 'online');
+          if (_this0.connected) {
+            _this0.webex.internal.newMetrics.callDiagnosticMetrics.setMercuryConnectedStatus(true);
+          }
         }
         return resolve();
       };
-
       // eslint-disable-next-line prefer-reflect
       call = _backoff.default.call(function (callback) {
         var attemptNum = call.getNumRetries();
         var logPrefix = isShutdownSwitchover ? '[shutdown] switchover' : 'connection';
-        _this9.logger.info("".concat(_this9.namespace, ": executing ").concat(logPrefix, " attempt ").concat(attemptNum));
-        _this9._attemptConnection(webSocketUrl, callback, attemptOptions);
-      }, onComplete);
+        _this0.logger.info("".concat(_this0.namespace, ": executing ").concat(logPrefix, " attempt ").concat(attemptNum, " for ").concat(sessionId));
+        _this0._attemptConnection(webSocketUrl, sessionId, callback, attemptOptions);
+      }, function (err) {
+        return onComplete(err, sessionId);
+      });
       call.setStrategy(new _backoff.default.ExponentialStrategy({
-        initialDelay: _this9.config.backoffTimeReset,
-        maxDelay: _this9.config.backoffTimeMax
+        initialDelay: _this0.config.backoffTimeReset,
+        maxDelay: _this0.config.backoffTimeMax
       }));
-      if (_this9.config.initialConnectionMaxRetries && !_this9.hasEverConnected && !isShutdownSwitchover) {
-        call.failAfter(_this9.config.initialConnectionMaxRetries);
-      } else if (_this9.config.maxRetries) {
-        call.failAfter(_this9.config.maxRetries);
+      if (_this0.config.initialConnectionMaxRetries && !_this0.hasEverConnected && !isShutdownSwitchover) {
+        call.failAfter(_this0.config.initialConnectionMaxRetries);
+      } else if (_this0.config.maxRetries) {
+        call.failAfter(_this0.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)
+      if (isShutdownSwitchover) {
+        _this0._shutdownSwitchoverBackoffCalls.set(sessionId, call);
+      } else {
+        _this0.backoffCalls.set(sessionId, call);
       }
       call.on('abort', function () {
         var msg = isShutdownSwitchover ? 'Shutdown Switchover' : 'Connection';
-        _this9.logger.info("".concat(_this9.namespace, ": ").concat(msg, " aborted"));
-        reject(new Error("Mercury ".concat(msg, " Aborted")));
+        _this0.logger.info("".concat(_this0.namespace, ": ").concat(msg, " aborted for ").concat(sessionId));
+        reject(new Error("Mercury ".concat(msg, " Aborted for ").concat(sessionId)));
       });
       call.on('callback', function (err) {
         if (err) {
           var number = call.getNumRetries();
-          var delay = Math.min(call.strategy_.nextBackoffDelay_, _this9.config.backoffTimeMax);
+          var delay = Math.min(call.strategy_.nextBackoffDelay_, _this0.config.backoffTimeMax);
           var logPrefix = isShutdownSwitchover ? '[shutdown] switchover' : '';
-          _this9.logger.info("".concat(_this9.namespace, ": ").concat(logPrefix, " failed to connect; attempting retry ").concat(number + 1, " in ").concat(delay, " ms"));
+          _this0.logger.info("".concat(_this0.namespace, ": ").concat(logPrefix, " failed to connect; attempting retry ").concat(number + 1, " in ").concat(delay, " ms for ").concat(sessionId));
           /* istanbul ignore if */
           if (process.env.NODE_ENV === 'development') {
-            _this9.logger.debug("".concat(_this9.namespace, ": "), err, err.stack);
+            _this0.logger.debug("".concat(_this0.namespace, ": "), err, err.stack);
           }
           return;
         }
-        _this9.logger.info("".concat(_this9.namespace, ": connected"));
+        _this0.logger.info("".concat(_this0.namespace, ": connected ").concat(sessionId));
       });
-
-      // Store backoff call reference BEFORE starting (so it's available in _attemptConnection)
-      if (isShutdownSwitchover) {
-        _this9._shutdownSwitchoverBackoffCall = call;
-      } else {
-        _this9.backoffCall = call;
-      }
       call.start();
     });
   },
   _emit: function _emit() {
-    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-      args[_key3] = arguments[_key3];
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
     }
     try {
-      this.trigger.apply(this, args);
+      if (!args || args.length === 0) {
+        return;
+      }
+
+      // New signature: _emit(sessionId, eventName, ...rest)
+      // Backwards compatibility: if the first arg isn't a known sessionId (or defaultSessionId),
+      // treat the call as the old signature and forward directly to trigger(...)
+      var first = args[0],
+        second = args[1],
+        rest = _arrayLikeToArray(args).slice(2);
+      if (typeof first === 'string' && typeof second === 'string') {
+        var sessionId = first;
+        var eventName = second;
+        var suffix = sessionId === this.defaultSessionId ? '' : ":".concat(sessionId);
+        this.trigger.apply(this, ["".concat(eventName).concat(suffix)].concat((0, _toConsumableArray2.default)(rest)));
+      } else {
+        // Old usage: _emit(eventName, ...args)
+        this.trigger.apply(this, args);
+      }
     } catch (error) {
-      this.logger.error("".concat(this.namespace, ": error occurred in event handler:"), error, ' with args: ', args);
+      // Safely handle errors without causing additional issues during cleanup
+      try {
+        this.logger.error("".concat(this.namespace, ": error occurred in event handler:"), error, ' with args: ', args);
+      } catch (logError) {
+        // If even logging fails, just ignore to prevent cascading errors during cleanup
+        // eslint-disable-next-line no-console
+        console.error('Mercury _emit error handling failed:', logError);
+      }
     }
   },
   _getEventHandlers: function _getEventHandlers(eventType) {
+    if (!eventType) {
+      return [];
+    }
     var _eventType$split = eventType.split('.'),
       _eventType$split2 = (0, _slicedToArray2.default)(_eventType$split, 2),
       namespace = _eventType$split2[0],
@@ -564,33 +775,63 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
     }
     return handlers;
   },
-  _onclose: function _onclose(event, sourceSocket) {
+  _submitMercuryClose4000Metric: function _submitMercuryClose4000Metric(sessionId, event, options) {
+    var action = options.action,
+      isActiveSocket = options.isActiveSocket,
+      messageType = options.messageType;
+    try {
+      this.webex.internal.metrics.submitClientMetrics(MERCURY_CLOSE_4000_METRIC, {
+        fields: {
+          action: action,
+          close_code: event.code,
+          close_reason: event.reason || '',
+          is_active_socket: isActiveSocket,
+          message_type: messageType,
+          session_id: sessionId
+        },
+        tags: {
+          action: action,
+          message_type: messageType
+        }
+      });
+    } catch (error) {
+      this.logger.warn("".concat(this.namespace, ": failed to submit Mercury 4000 close metric"), error);
+    }
+  },
+  _onclose: function _onclose(sessionId, event, sourceSocket) {
     // I don't see any way to avoid the complexity or statement count in here.
     /* eslint complexity: [0] */
 
     try {
-      var isActiveSocket = sourceSocket === this.socket;
       var reason = event.reason && event.reason.toLowerCase();
-      var socketUrl;
-      if (isActiveSocket && this.socket) {
-        // Active socket closed - get URL from current socket reference
-        socketUrl = this.socket.url;
-      } else if (sourceSocket) {
-        // Old socket closed - get URL from the closed socket
-        socketUrl = sourceSocket.url;
-      }
+      var sessionSocket = this.sockets.get(sessionId);
+      event.sessionId = sessionId;
+      var isActiveSocket = sourceSocket === sessionSocket;
+      // Reconnect using the resolved URL this session's socket was
+      // opened with, captured in _prepareAndOpenSocket. Do NOT reuse
+      // sourceSocket.url: that reflects the URL the native WebSocket was
+      // actually opened with, which a lower layer may have rewritten
+      // (e.g. via interceptors) into a host that is not in the SDK host
+      // catalog. Feeding such a URL back into _prepareUrl fails host-catalog
+      // validation and permanently blocks reconnection.
+      var socketUrl = this.sessionWebSocketUrls.get(sessionId);
+      this.sockets.delete(sessionId);
       if (isActiveSocket) {
         // Only tear down state if the currently active socket closed
-        if (this.socket) {
-          this.socket.removeAllListeners();
+        if (sessionSocket) {
+          sessionSocket.removeAllListeners();
+          if (sessionId === this.defaultSessionId) this.unset('socket');
+          this._emit(sessionId, 'offline', event);
+        }
+        // Update overall connected status
+        this.connecting = this.hasConnectingSockets();
+        this.connected = this.hasConnectedSockets();
+        if (!this.connected) {
+          this.webex.internal.newMetrics.callDiagnosticMetrics.setMercuryConnectedStatus(false);
         }
-        this.unset('socket');
-        this.connected = false;
-        this._emit('offline', event);
-        this.webex.internal.newMetrics.callDiagnosticMetrics.setMercuryConnectedStatus(false);
       } else {
         // Old socket closed; do not flip connection state
-        this.logger.info("".concat(this.namespace, ": [shutdown] non-active socket closed, code=").concat(event.code));
+        this.logger.info("".concat(this.namespace, ": [shutdown] non-active socket closed, code=").concat(event.code, " for ").concat(sessionId));
         // Clean up listeners from old socket now that it's closed
         if (sourceSocket) {
           sourceSocket.removeAllListeners();
@@ -599,14 +840,31 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
       switch (event.code) {
         case 1003:
           // metric: disconnect
-          this.logger.info("".concat(this.namespace, ": Mercury service rejected last message; will not reconnect: ").concat(event.reason));
-          if (isActiveSocket) this._emit('offline.permanent', event);
+          this.logger.info("".concat(this.namespace, ": Mercury service rejected last message for ").concat(sessionId, "; will not reconnect: ").concat(event.reason));
+          if (isActiveSocket) this._emit(sessionId, 'offline.permanent', event);
           break;
         case 4000:
           // metric: disconnect
-          this.logger.info("".concat(this.namespace, ": socket replaced; will not reconnect"));
-          if (isActiveSocket) this._emit('offline.replaced', event);
-          // If not active, nothing to do
+          if (reason === 'replaced') {
+            this._submitMercuryClose4000Metric(sessionId, event, {
+              action: 'no_action',
+              isActiveSocket: isActiveSocket,
+              messageType: 'replaced'
+            });
+            this.logger.info("".concat(this.namespace, ": socket ").concat(sessionId, " replaced; will not reconnect"));
+            if (isActiveSocket) this._emit(sessionId, 'offline.replaced', event);
+          } else {
+            this._submitMercuryClose4000Metric(sessionId, event, {
+              action: isActiveSocket ? 'reconnect' : 'ignore_non_active',
+              isActiveSocket: isActiveSocket,
+              messageType: 'other'
+            });
+            this.logger.info("".concat(this.namespace, ": socket ").concat(sessionId, " disconnected with 4000: ").concat(event.reason, "; reconnecting"));
+            if (isActiveSocket) {
+              this._emit(sessionId, 'offline.transient', event);
+              this._reconnect(socketUrl, sessionId);
+            }
+          }
           break;
         case 4001:
           // replaced during shutdown
@@ -614,23 +872,23 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
             // 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(this.namespace, ": active socket closed with 4001; shutdown switchover failed"));
-            this._emit('offline.permanent', event);
+            this.logger.warn("".concat(this.namespace, ": active socket closed with 4001; shutdown switchover failed for ").concat(sessionId));
+            this._emit(sessionId, 'offline.permanent', event);
           } else {
             // Expected: old socket closed after successful switchover
-            this.logger.info("".concat(this.namespace, ": old socket closed with 4001 (replaced during shutdown); no reconnect needed"));
-            this._emit('offline.replaced', event);
+            this.logger.info("".concat(this.namespace, ": old socket closed with 4001 (replaced during shutdown); no reconnect needed for ").concat(sessionId));
+            this._emit(sessionId, 'offline.replaced', event);
           }
           break;
         case 1001:
         case 1005:
         case 1006:
         case 1011:
-          this.logger.info("".concat(this.namespace, ": socket disconnected; reconnecting"));
+          this.logger.info("".concat(this.namespace, ": socket ").concat(sessionId, " disconnected; reconnecting"));
           if (isActiveSocket) {
-            this._emit('offline.transient', event);
-            this.logger.info("".concat(this.namespace, ": [shutdown] reconnecting active socket to recover"));
-            this._reconnect(socketUrl);
+            this._emit(sessionId, 'offline.transient', event);
+            this.logger.info("".concat(this.namespace, ": [shutdown] reconnecting active socket to recover for ").concat(sessionId));
+            this._reconnect(socketUrl, sessionId);
           }
           // metric: disconnect
           // if (code == 1011 && reason !== ping error) metric: unexpected disconnect
@@ -639,81 +897,88 @@ var Mercury = _webexCore.WebexPlugin.extend((_dec = (0, _common.deprecated)('Mer
         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(this.namespace, ": socket disconnected; reconnecting"));
+            this.logger.info("".concat(this.namespace, ": socket ").concat(sessionId, " disconnected; reconnecting"));
             if (isActiveSocket) {
-              this._emit('offline.transient', event);
-              this.logger.info("".concat(this.namespace, ": [shutdown] reconnecting due to normal close"));
-              this._reconnect(socketUrl);
+              this._emit(sessionId, 'offline.transient', event);
+              this.logger.info("".concat(this.namespace, ": [shutdown] reconnecting due to normal close for ").concat(sessionId));
+              this._reconnect(socketUrl, sessionId);
             }
             // metric: disconnect
             // if (reason === done forced) metric: force closure
           } else {
-            this.logger.info("".concat(this.namespace, ": socket disconnected; will not reconnect: ").concat(event.reason));
-            if (isActiveSocket) this._emit('offline.permanent', event);
+            this.logger.info("".concat(this.namespace, ": socket ").concat(sessionId, " disconnected; will not reconnect: ").concat(event.reason));
+            if (isActiveSocket) this._emit(sessionId, 'offline.permanent', event);
           }
           break;
         default:
-          this.logger.info("".concat(this.namespace, ": socket disconnected unexpectedly; will not reconnect"));
+          this.logger.info("".concat(this.namespace, ": socket ").concat(sessionId, " disconnected unexpectedly; will not reconnect"));
           // unexpected disconnect
-          if (isActiveSocket) this._emit('offline.permanent', event);
+          if (isActiveSocket) this._emit(sessionId, 'offline.permanent', event);
       }
     } catch (error) {
-      this.logger.error("".concat(this.namespace, ": error occurred in close handler"), error);
+      this.logger.error("".concat(this.namespace, ": error occurred in close handler for ").concat(sessionId), error);
     }
   },
-  _onmessage: function _onmessage(event) {
-    var _this0 = this;
-    this._setTimeOffset(event);
+  _onmessage: function _onmessage(sessionId, event) {
+    var _this1 = this;
+    this._setTimeOffset(sessionId, event);
     var envelope = event.data;
     if (process.env.ENABLE_MERCURY_LOGGING) {
-      this.logger.debug("".concat(this.namespace, ": message envelope: "), envelope);
+      this.logger.debug("".concat(this.namespace, ": message envelope from ").concat(sessionId, ": "), envelope);
     }
+    envelope.sessionId = sessionId;
 
     // Handle shutdown message shape: { type: 'shutdown' }
     if (envelope && envelope.type === 'shutdown') {
-      this.logger.info("".concat(this.namespace, ": [shutdown] imminent shutdown message received"));
-      this._emit('event:mercury_shutdown_imminent', envelope);
-      this._handleImminentShutdown();
+      this.logger.info("".concat(this.namespace, ": [shutdown] imminent shutdown message received for ").concat(sessionId));
+      this._emit(sessionId, 'event:mercury_shutdown_imminent', envelope);
+      this._handleImminentShutdown(sessionId);
       return _promise.default.resolve();
     }
+    envelope.sessionId = sessionId;
     var data = envelope.data;
     this._applyOverrides(data);
+    if (!data || !data.eventType) {
+      this._emit(sessionId, 'event', envelope);
+      return _promise.default.resolve();
+    }
     return this._getEventHandlers(data.eventType).reduce(function (promise, handler) {
       return promise.then(function () {
         var namespace = handler.namespace,
           name = handler.name;
         return new _promise.default(function (resolve) {
-          return resolve((_this0.webex[namespace] || _this0.webex.internal[namespace])[name](data));
+          return resolve((_this1.webex[namespace] || _this1.webex.internal[namespace])[name](data));
         }).catch(function (reason) {
-          return _this0.logger.error("".concat(_this0.namespace, ": error occurred in autowired event handler for ").concat(data.eventType), reason);
+          return _this1.logger.error("".concat(_this1.namespace, ": error occurred in autowired event handler for ").concat(data.eventType, " from ").concat(sessionId), reason);
         });
       });
     }, _promise.default.resolve()).then(function () {
-      _this0._emit('event', event.data);
+      _this1._emit(sessionId, 'event', envelope);
       var _data$eventType$split = data.eventType.split('.'),
         _data$eventType$split2 = (0, _slicedToArray2.default)(_data$eventType$split, 1),
         namespace = _data$eventType$split2[0];
       if (namespace === data.eventType) {
-        _this0._emit("event:".concat(namespace), envelope);
+        _this1._emit(sessionId, "event:".concat(namespace), envelope);
       } else {
-        _this0._emit("event:".concat(namespace), envelope);
-        _this0._emit("event:".concat(data.eventType), envelope);
+        _this1._emit(sessionId, "event:".concat(namespace), envelope);
+        _this1._emit(sessionId, "event:".concat(data.eventType), envelope);
       }
     }).catch(function (reason) {
-      _this0.logger.error("".concat(_this0.namespace, ": error occurred processing socket message"), reason);
+      _this1.logger.error("".concat(_this1.namespace, ": error occurred processing socket message from ").concat(sessionId), reason);
     });
   },
-  _setTimeOffset: function _setTimeOffset(event) {
+  _setTimeOffset: function _setTimeOffset(sessionId, event) {
     var wsWriteTimestamp = event.data.wsWriteTimestamp;
     if (typeof wsWriteTimestamp === 'number' && wsWriteTimestamp > 0) {
       this.mercuryTimeOffset = (0, _now.default)() - wsWriteTimestamp;
     }
   },
   _reconnect: function _reconnect(webSocketUrl) {
-    this.logger.info("".concat(this.namespace, ": reconnecting"));
-    return this.connect(webSocketUrl);
+    var sessionId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.defaultSessionId;
+    this.logger.info("".concat(this.namespace, ": reconnecting ").concat(sessionId));
+    return this.connect(webSocketUrl, sessionId);
   },
-  version: "3.11.0-webex-services-ready.1"
-}, (0, _applyDecoratedDescriptor2.default)(_obj, "connect", [_common.oneFlight], (0, _getOwnPropertyDescriptor.default)(_obj, "connect"), _obj), (0, _applyDecoratedDescriptor2.default)(_obj, "disconnect", [_common.oneFlight], (0, _getOwnPropertyDescriptor.default)(_obj, "disconnect"), _obj), (0, _applyDecoratedDescriptor2.default)(_obj, "listen", [_dec], (0, _getOwnPropertyDescriptor.default)(_obj, "listen"), _obj), (0, _applyDecoratedDescriptor2.default)(_obj, "stopListening", [_dec2], (0, _getOwnPropertyDescriptor.default)(_obj, "stopListening"), _obj), _obj));
-var _default = exports.default = Mercury;
+  version: "3.12.0-auth-prejoin-fetch.1"
+}, (0, _applyDecoratedDescriptor2.default)(_obj, "listen", [_dec], (0, _getOwnPropertyDescriptor.default)(_obj, "listen"), _obj), (0, _applyDecoratedDescriptor2.default)(_obj, "stopListening", [_dec2], (0, _getOwnPropertyDescriptor.default)(_obj, "stopListening"), _obj), _obj));
+var _default2 = exports.default = Mercury;
 //# sourceMappingURL=mercury.js.map