@webex/calling 3.12.0-mobius-socket.9 → 3.12.0-mobius-socket.11

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

@@ -0,0 +1,1191 @@
+"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$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");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_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 _isArray = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/array/is-array"));
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
+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"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
+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 _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; } /* eslint-disable require-jsdoc */ /*!
+ * 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
+
+function normalizeMobiusAuthToken(token) {
+  if (typeof token !== 'string') {
+    return token;
+  }
+  return token.replace(/^Bearer\s+/i, '');
+}
+var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
+  function MobiusSocket(webex) {
+    var _this;
+    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _classCallCheck2.default)(this, MobiusSocket);
+    _this = _callSuper(this, MobiusSocket);
+    if (!webex) {
+      throw new Error('A Webex instance is required when initializing MobiusSocket');
+    }
+    _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();
+    return _this;
+  }
+  (0, _inherits2.default)(MobiusSocket, _EventEmitter);
+  return (0, _createClass2.default)(MobiusSocket, [{
+    key: "off",
+    value: function off(eventName, listener) {
+      if (listener) {
+        return _superPropGet(MobiusSocket, "off", this, 3)([eventName, listener]);
+      }
+      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;
+      socket.on('close', function (event) {
+        return _this3._onclose(sessionId, 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));
+      });
+    }
+
+    /**
+     * 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.
+     */
+  }, {
+    key: "_trackAsyncEventAndShouldSuppressDuplicate",
+    value: function _trackAsyncEventAndShouldSuppressDuplicate(sessionId, 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);
+
+        // 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));
+        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));
+      }
+      return false;
+    }
+
+    /**
+     * 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);
+      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));
+          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, {
+          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', {
+                url: webSocketUrl
+              });
+              if (oldSocket) {
+                _this4.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));
+        }).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', {
+            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', {
+          reason: e
+        });
+      }
+    }
+
+    /**
+     * Get the last error.
+     * @returns {any} 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.
+     * @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)) {
+        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);
+    }
+
+    /**
+     * Sends a websocket request and resolves when the matching response arrives.
+     * @param {Object} payload - The websocket request payload.
+     * @param {string|Object} [sessionIdOrOptions=this.defaultSessionId] - Session ID or request options.
+     * @param {Object} [options={}] - Additional request options.
+     * @returns {Promise<Object>}
+     */
+  }, {
+    key: "sendWssRequest",
+    value: function sendWssRequest(payload) {
+      var _this5 = this;
+      var sessionIdOrOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.defaultSessionId;
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      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 sessionIdOrOptions === 'string') {
+        sessionId = sessionIdOrOptions;
+      } else if (sessionIdOrOptions && (0, _typeof2.default)(sessionIdOrOptions) === 'object') {
+        requestOptions = sessionIdOrOptions;
+      }
+      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,
+        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;
+        },
+        getStatusCode: function getStatusCode(response) {
+          return response === null || response === void 0 ? void 0 : response.statusCode;
+        },
+        getStatusMessage: function getStatusMessage(response) {
+          return response === null || response === void 0 ? void 0 : response.statusMessage;
+        },
+        createError: function createError(response, statusCode, statusMessage) {
+          return _this5._createWssResponseError(response, statusCode, statusMessage);
+        },
+        createTimeoutError: function createTimeoutError(request) {
+          return _this5._createWssResponseError({
+            type: 'response_event',
+            subtype: request.type,
+            trackingId: request.trackingId
+          }, 408, 'Mobius websocket response timed out');
+        }
+      });
+    }
+
+    /**
+     * Check if the plugin is connected
+     * @returns {boolean} True if connected
+     */
+  }, {
+    key: "isConnected",
+    value: function isConnected() {
+      return this.connected;
+    }
+
+    /**
+     * 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.
+     * @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.
+     */
+  }, {
+    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"));
+        return _promise.default.resolve();
+      }
+
+      // Treat a connect() call that targets a different Mobius websocket URL
+      // as a fresh initial connection for retry purposes.
+      if (webSocketUrl && this.socketUrl && webSocketUrl !== this.socketUrl) {
+        this.hasEverConnected = false;
+      }
+
+      // 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)' : ''));
+      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);
+      }).finally(function () {
+        _this6._connectPromises.delete(sessionId);
+      });
+      this._connectPromises.set(sessionId, 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.
+     */
+  }, {
+    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();
+        }
+        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();
+      });
+    }
+  }, {
+    key: "processRegistrationStatusEvent",
+    value: function processRegistrationStatusEvent(message) {
+      this.localClusterServiceUrls = message.localClusterServiceUrls;
+    }
+  }, {
+    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;
+      error.statusMessage = statusMessage;
+      error.response = response;
+      error.trackingId = response === null || response === void 0 ? void 0 : response.trackingId;
+      return error;
+    }
+  }, {
+    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) {
+      if (!webSocketUrl) {
+        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] : {};
+      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, sessionId);
+      var backoffCall = isShutdownSwitchover ? this._shutdownSwitchoverBackoffCalls.get(sessionId) : this.backoffCalls.get(sessionId);
+
+      // 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 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.sockets.set(sessionId, socket);
+      }
+      return this._prepareAndOpenSocket(socket, socketUrl, sessionId, 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));
+
+        // Custom success handler for shutdown switchover
+        if (onSuccess) {
+          onSuccess(socket, webSocketUrl);
+          callback();
+          return _promise.default.resolve();
+        }
+
+        // Default behavior for normal connection
+        callback();
+        return _promise.default.resolve();
+      }).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);
+          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).
+        if (reason.code !== 1006 && backoffCallNormal && (backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()) > 0) {
+          _this9._emit(sessionId, 'connection_failed', reason, {
+            sessionId: sessionId,
+            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
+        // 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 () {
+            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({
+            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));
+          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);
+        callback(reason);
+      });
+    }
+  }, {
+    key: "_prepareAndOpenSocket",
+    value: function _prepareAndOpenSocket(socket, socketUrl, sessionId) {
+      var _this0 = 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: _this0.config.forceCloseDelay,
+          wssResponseTimeout: _this0.config.wssResponseTimeout,
+          skipAckEventId: _this0.config.skipAckEventId,
+          skipAckEventType: _this0.config.skipAckEventType,
+          token: normalizeMobiusAuthToken(token.toString()),
+          refreshToken: function refreshToken() {
+            return _this0._refreshToken();
+          },
+          trackingId: "".concat(_this0.webex.sessionId, "_").concat((0, _now.default)()),
+          logger: _this0.logger
+        };
+        if (_this0.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);
+        }
+
+        // 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));
+        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] : {};
+      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 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);
+          } else {
+            _this1.backoffCalls.delete(sid);
+          }
+          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;
+            }
+            return reject(err);
+          }
+
+          // Update overall connected status
+          if (sessionSocket) {
+            sessionSocket.connecting = false;
+            sessionSocket.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');
+          }
+          return resolve();
+        };
+        // eslint-disable-next-line prefer-reflect
+        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);
+        }, function (err) {
+          return onComplete(err, sessionId);
+        });
+        call.setStrategy(new _backoff.default.ExponentialStrategy({
+          initialDelay: _this1.config.backoffTimeReset,
+          maxDelay: _this1.config.backoffTimeMax
+        }));
+        if (isInitialConnectWithoutRetries) {
+          call.retryIf(function () {
+            return false;
+          });
+        } else if (isInitialConnect && initialRetryLimit > 0) {
+          call.failAfter(initialRetryLimit);
+        } else if (_this1.config.maxRetries) {
+          call.failAfter(_this1.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) {
+          _this1._shutdownSwitchoverBackoffCalls.set(sessionId, call);
+        } else {
+          _this1.backoffCalls.set(sessionId, 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)));
+        });
+        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"));
+              return;
+            }
+            var number = call.getNumRetries();
+            var delay = Math.min(call.strategy_.nextBackoffDelay_, _this1.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));
+            /* istanbul ignore if */
+            if (process.env.NODE_ENV === 'development') {
+              _this1.logger.debug("".concat(MOBIUS_SOCKET_NAMESPACE, ": "), err, err.stack);
+            }
+            return;
+          }
+          _this1.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connected ").concat(sessionId));
+        });
+        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];
+      }
+      try {
+        if (!sessionId || !eventName) {
+          return;
+        }
+        var suffix = sessionId === this.defaultSessionId ? '' : ":".concat(sessionId);
+        this.emit.apply(this, ["".concat(eventName).concat(suffix)].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
+        });
+      }
+      return handlers;
+    }
+  }, {
+    key: "_startTokenRefreshTimer",
+    value: function _startTokenRefreshTimer() {
+      var _this10 = this;
+      if (this._tokenRefreshTimer || !this.hasConnectedSockets()) {
+        return;
+      }
+      this._tokenRefreshTimer = setInterval(function () {
+        _this10._refreshToken().catch(function (error) {
+          _this10.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": periodic token refresh failed"), error);
+        });
+      }, TOKEN_REFRESH_INTERVAL_MS);
+    }
+  }, {
+    key: "_stopTokenRefreshTimer",
+    value: function _stopTokenRefreshTimer() {
+      if (!this._tokenRefreshTimer) {
+        return;
+      }
+      clearInterval(this._tokenRefreshTimer);
+      this._tokenRefreshTimer = undefined;
+    }
+  }, {
+    key: "_refreshToken",
+    value: function _refreshToken() {
+      var _this11 = this;
+      if (this._tokenRefreshInFlight) {
+        return this._tokenRefreshInFlight;
+      }
+      if (!this.hasConnectedSockets()) {
+        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();
+      }) : this.webex.credentials.getUserToken();
+      this._tokenRefreshInFlight = tokenPromise.then(function (token) {
+        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();
+        }
+        return _promise.default.all(authPayloadPromises);
+      }).catch(function (error) {
+        _this11.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": failed to refresh/re-auth Mobius sockets"), error);
+        throw error;
+      }).finally(function () {
+        _this11._tokenRefreshInFlight = undefined;
+      });
+      return this._tokenRefreshInFlight;
+    }
+  }, {
+    key: "_onclose",
+    value: 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 reason = event.reason && event.reason.toLowerCase();
+        var sessionSocket = this.sockets.get(sessionId);
+        var socketUrl;
+        event.sessionId = sessionId;
+        var isActiveSocket = sourceSocket === sessionSocket;
+        if (sourceSocket) {
+          socketUrl = sourceSocket.url;
+        }
+        this.sockets.delete(sessionId);
+        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();
+          }
+        } 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));
+          // Clean up listeners from old socket now that it's closed
+          if (sourceSocket) {
+            sourceSocket.removeAllListeners();
+          }
+        }
+        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);
+            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
+            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);
+            } 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);
+            }
+            break;
+          case 1001:
+          case 1005:
+          case 1006:
+          case 1011:
+            this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket ").concat(sessionId, " 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);
+            }
+            // 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"));
+              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);
+              }
+              // 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);
+            }
+            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);
+        }
+      } catch (error) {
+        this.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": error occurred in close handler for ").concat(sessionId), error);
+      }
+    }
+  }, {
+    key: "_onmessage",
+    value: function _onmessage(sessionId, event) {
+      var _this12 = this;
+      this._setTimeOffset(sessionId, event);
+      var envelope = event.data;
+      if (process.env.ENABLE_MERCURY_LOGGING) {
+        this.logger.debug("".concat(MOBIUS_SOCKET_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(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] imminent shutdown message received for ").concat(sessionId));
+        this._emit(sessionId, 'event:mercury_shutdown_imminent', envelope);
+        this._handleImminentShutdown(sessionId);
+        return _promise.default.resolve();
+      }
+      if (this._trackAsyncEventAndShouldSuppressDuplicate(sessionId, envelope)) {
+        return _promise.default.resolve();
+      }
+
+      // Mobius: emit event:<type> for typed messages (e.g., register.response)
+      if (envelope.type) {
+        this._emit(sessionId, "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
+      var eventType = (data === null || data === void 0 ? void 0 : data.eventType) || envelope.eventType;
+      if (!eventType) {
+        this._emit(sessionId, '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) {
+            return 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);
+        }
+      }).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;
+      }
+    }
+  }, {
+    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);
+    }
+  }]);
+}(_events.EventEmitter);
+var _default = exports.default = MobiusSocket;
+//# sourceMappingURL=mobius-socket.js.map