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

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

@@ -24,6 +24,9 @@ var _testHelperChai = require("@webex/test-helper-chai");
 var _testHelperMockWebex = _interopRequireDefault(require("@webex/test-helper-mock-webex"));
 var _testHelperMockWebSocket = _interopRequireDefault(require("@webex/test-helper-mock-web-socket"));
 var _index = _interopRequireWildcard(require("./index"));
+var _errors = require("./errors");
+var _config = _interopRequireDefault(require("./config"));
+var _socket = _interopRequireDefault(require("./socket"));
 var _mochaHelpers = require("./test/mocha-helpers");
 var _constants = require("./socket/constants");
 var _promiseTick = _interopRequireDefault(require("./test/promise-tick"));
@@ -50,7 +53,7 @@ describe('plugin-mobius-socket', function () {
       var configuredWebex = new _testHelperMockWebex.default();
       var instance = (0, _index.getMobiusSocketInstance)(configuredWebex);
       _testHelperChai.assert.instanceOf(instance, _index.default);
-      _testHelperChai.assert.deepEqual(instance.config, _index.config.mobiusSocket);
+      _testHelperChai.assert.deepEqual(instance.config, _config.default.mobiusSocket);
     });
     it('uses consumer config when it is provided', function () {
       var configuredWebex = new _testHelperMockWebex.default();
@@ -60,7 +63,7 @@ describe('plugin-mobius-socket', function () {
       };
       var instance = (0, _index.getMobiusSocketInstance)(configuredWebex, consumerConfig);
       _testHelperChai.assert.instanceOf(instance, _index.default);
-      _testHelperChai.assert.deepEqual(instance.config, _objectSpread(_objectSpread({}, _index.config.mobiusSocket), consumerConfig));
+      _testHelperChai.assert.deepEqual(instance.config, _objectSpread(_objectSpread({}, _config.default.mobiusSocket), consumerConfig));
     });
   });
   describe('MobiusSocket', function () {
@@ -116,9 +119,9 @@ describe('plugin-mobius-socket', function () {
         removeAllListeners: _sinon.default.stub()
       };
     };
-    var countGenericEventEmits = function countGenericEventEmits(emitSpy, sessionId) {
+    var countGenericEventEmits = function countGenericEventEmits(emitSpy) {
       return emitSpy.getCalls().filter(function (call) {
-        return call.args[0] === sessionId && call.args[1] === 'event';
+        return call.args[0] === 'event';
       }).length;
     };
     beforeEach(function () {
@@ -155,7 +158,7 @@ describe('plugin-mobius-socket', function () {
       webex.internal.metrics.submitClientMetrics = _sinon.default.stub();
       webex.trackingId = 'fakeTrackingId';
       webex.logger = console;
-      _sinon.default.stub(_index.Socket, 'getWebSocketConstructor').callsFake(function () {
+      _sinon.default.stub(_socket.default, 'getWebSocketConstructor').callsFake(function () {
         return function () {
           for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
             args[_key] = arguments[_key];
@@ -164,8 +167,8 @@ describe('plugin-mobius-socket', function () {
           return mockWebSocket;
         };
       });
-      var origOpen = _index.Socket.prototype.open;
-      socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open').callsFake(function () {
+      var origOpen = _socket.default.prototype.open;
+      socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open').callsFake(function () {
         for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
           args[_key2] = arguments[_key2];
         }
@@ -179,8 +182,7 @@ describe('plugin-mobius-socket', function () {
         });
         return promise;
       });
-      mobiusSocket = new _index.default(webex, _objectSpread({}, _index.config.mobiusSocket));
-      mobiusSocket.defaultSessionId = 'mobius-websocket-session';
+      mobiusSocket = new _index.default(webex, _objectSpread({}, _config.default.mobiusSocket));
     });
     afterEach(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
       var _t;
@@ -194,12 +196,12 @@ describe('plugin-mobius-socket', function () {
 
             // Clean up MobiusSocket connections and internal state
             if (!mobiusSocket) {
-              _context.next = 5;
+              _context.next = 4;
               break;
             }
             _context.prev = 1;
             _context.next = 2;
-            return mobiusSocket.disconnectAll();
+            return mobiusSocket.disconnect();
           case 2:
             _context.next = 4;
             break;
@@ -207,11 +209,6 @@ describe('plugin-mobius-socket', function () {
             _context.prev = 3;
             _t = _context["catch"](1);
           case 4:
-            // Clear any remaining connection promises
-            if (mobiusSocket._connectPromises) {
-              mobiusSocket._connectPromises.clear();
-            }
-          case 5:
             // Ensure mock socket is properly closed
             if (mockWebSocket && typeof mockWebSocket.close === 'function') {
               try {
@@ -223,16 +220,16 @@ describe('plugin-mobius-socket', function () {
             if (socketOpenStub) {
               socketOpenStub.restore();
             }
-            if (_index.Socket.getWebSocketConstructor.restore) {
-              _index.Socket.getWebSocketConstructor.restore();
+            if (_socket.default.getWebSocketConstructor.restore) {
+              _socket.default.getWebSocketConstructor.restore();
             }
 
             // Small delay to ensure all async operations complete
-            _context.next = 6;
+            _context.next = 5;
             return new _promise.default(function (resolve) {
               setTimeout(resolve, 10);
             });
-          case 6:
+          case 5:
           case "end":
             return _context.stop();
         }
@@ -248,15 +245,7 @@ describe('plugin-mobius-socket', function () {
         });
       });
       it('connects to MobiusSocket using default url', function () {
-        webex.internal.feature.updateFeature = _sinon.default.stub();
         var promise = mobiusSocket.connect();
-        var envelope = {
-          data: {
-            featureToggle: {
-              'feature-name': true
-            }
-          }
-        };
         _testHelperChai.assert.isFalse(mobiusSocket.connected, 'MobiusSocket is not connected');
         _testHelperChai.assert.isTrue(mobiusSocket.connecting, 'MobiusSocket is connecting');
         mockWebSocket.open();
@@ -264,94 +253,31 @@ describe('plugin-mobius-socket', function () {
           _testHelperChai.assert.isTrue(mobiusSocket.connected, 'MobiusSocket is connected');
           _testHelperChai.assert.isFalse(mobiusSocket.connecting, 'MobiusSocket is not connecting');
           _testHelperChai.assert.calledWith(socketOpenStub, 'ws://example.com', _sinon.default.match.any);
-          mobiusSocket.emit('event:featureToggle_update', envelope);
-          _testHelperChai.assert.calledOnceWithExactly(webex.internal.feature.updateFeature, envelope.data.featureToggle);
-          _sinon.default.restore();
-        });
-      });
-      it('connects to MobiusSocket but does not call updateFeature', function () {
-        webex.internal.feature.updateFeature = _sinon.default.stub();
-        var promise = mobiusSocket.connect();
-        var envelope = {};
-        return promise.then(function () {
-          mobiusSocket.emit('event:featureToggle_update', envelope);
-          _testHelperChai.assert.notCalled(webex.internal.feature.updateFeature);
-          _sinon.default.restore();
-        });
-      });
-      it('MobiusSocket emit event:ActiveClusterStatusEvent, call services switchActiveClusterIds', function () {
-        var promise = mobiusSocket.connect();
-        var activeClusterEventEnvelope = {
-          data: {
-            activeClusters: {
-              wdm: 'wdm-cluster-id.com'
-            }
-          }
-        };
-        mockWebSocket.open();
-        return promise.then(function () {
-          mobiusSocket.emit('event:ActiveClusterStatusEvent', activeClusterEventEnvelope);
-          _testHelperChai.assert.calledOnceWithExactly(webex.internal.services.switchActiveClusterIds, activeClusterEventEnvelope.data.activeClusters);
-          _sinon.default.restore();
-        });
-      });
-      it('MobiusSocket emit event:ActiveClusterStatusEvent with no data, not call services switchActiveClusterIds', function () {
-        webex.internal.feature.updateFeature = _sinon.default.stub();
-        var promise = mobiusSocket.connect();
-        var envelope = {};
-        return promise.then(function () {
-          mobiusSocket.emit('event:ActiveClusterStatusEvent', envelope);
-          _testHelperChai.assert.notCalled(webex.internal.services.switchActiveClusterIds);
-          _sinon.default.restore();
-        });
-      });
-      it('MobiusSocket emit event:u2c.cache-invalidation, call services invalidateCache', function () {
-        var promise = mobiusSocket.connect();
-        var u2cInvalidateEventEnvelope = {
-          data: {
-            timestamp: '1759289614'
-          }
-        };
-        mockWebSocket.open();
-        return promise.then(function () {
-          mobiusSocket.emit('event:u2c.cache-invalidation', u2cInvalidateEventEnvelope);
-          _testHelperChai.assert.calledOnceWithExactly(webex.internal.services.invalidateCache, u2cInvalidateEventEnvelope.data.timestamp);
-          _sinon.default.restore();
-        });
-      });
-      it('MobiusSocket emit event:u2c.cache-invalidation with no data, not call services switchActiveClusterIds', function () {
-        webex.internal.feature.updateFeature = _sinon.default.stub();
-        var promise = mobiusSocket.connect();
-        var envelope = {};
-        return promise.then(function () {
-          mobiusSocket.emit('event:u2c.cache-invalidation', envelope);
-          _testHelperChai.assert.notCalled(webex.internal.services.invalidateCache);
-          _sinon.default.restore();
         });
       });
       describe('when `maxRetries` is set', function () {
         var check = function check() {
           socketOpenStub.restore();
-          socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open');
-          socketOpenStub.returns(_promise.default.reject(new _index.ConnectionError()));
-          _testHelperChai.assert.notCalled(_index.Socket.prototype.open);
+          socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open');
+          socketOpenStub.returns(_promise.default.reject(new _errors.ConnectionError()));
+          _testHelperChai.assert.notCalled(_socket.default.prototype.open);
           var promise = mobiusSocket.connect();
           return (0, _promiseTick.default)(5).then(function () {
-            _testHelperChai.assert.calledOnce(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledOnce(_socket.default.prototype.open);
             return (0, _promiseTick.default)(5);
           }).then(function () {
             jest.advanceTimersByTime(mobiusSocket.config.backoffTimeReset);
             return (0, _promiseTick.default)(5);
           }).then(function () {
-            _testHelperChai.assert.calledTwice(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledTwice(_socket.default.prototype.open);
             jest.advanceTimersByTime(2 * mobiusSocket.config.backoffTimeReset);
             return (0, _promiseTick.default)(5);
           }).then(function () {
-            _testHelperChai.assert.calledThrice(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledThrice(_socket.default.prototype.open);
             jest.advanceTimersByTime(5 * mobiusSocket.config.backoffTimeReset);
             return _testHelperChai.assert.isRejected(promise);
           }).then(function () {
-            _testHelperChai.assert.calledThrice(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledThrice(_socket.default.prototype.open);
           });
         };
 
@@ -368,15 +294,15 @@ describe('plugin-mobius-socket', function () {
           mobiusSocket.config.maxRetries = 2;
           mobiusSocket.config.initialConnectionMaxRetries = 0;
           socketOpenStub.restore();
-          socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open');
-          socketOpenStub.returns(_promise.default.reject(new _index.ConnectionError()));
-          _testHelperChai.assert.notCalled(_index.Socket.prototype.open);
+          socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open');
+          socketOpenStub.returns(_promise.default.reject(new _errors.ConnectionError()));
+          _testHelperChai.assert.notCalled(_socket.default.prototype.open);
           var promise = mobiusSocket.connect();
           return (0, _promiseTick.default)(5).then(function () {
-            _testHelperChai.assert.calledOnce(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledOnce(_socket.default.prototype.open);
             return _testHelperChai.assert.isRejected(promise);
           }).then(function () {
-            _testHelperChai.assert.calledOnce(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledOnce(_socket.default.prototype.open);
           });
         });
 
@@ -406,7 +332,7 @@ describe('plugin-mobius-socket', function () {
         var promise = _promise.default.all([mobiusSocket.connect(), mobiusSocket.connect(), mobiusSocket.connect(), mobiusSocket.connect()]);
         mockWebSocket.open();
         return promise.then(function () {
-          _testHelperChai.assert.calledOnce(_index.Socket.prototype.open);
+          _testHelperChai.assert.calledOnce(_socket.default.prototype.open);
         });
       });
 
@@ -415,16 +341,16 @@ describe('plugin-mobius-socket', function () {
         it('backs off exponentially', function () {
           mobiusSocket.config.initialConnectionMaxRetries = 2;
           socketOpenStub.restore();
-          socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open');
-          socketOpenStub.returns(_promise.default.reject(new _index.ConnectionError({
+          socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open');
+          socketOpenStub.returns(_promise.default.reject(new _errors.ConnectionError({
             code: 4001
           })));
           // Note: onCall is zero-based
           socketOpenStub.onCall(2).returns(_promise.default.resolve(new _testHelperMockWebSocket.default()));
-          _testHelperChai.assert.notCalled(_index.Socket.prototype.open);
+          _testHelperChai.assert.notCalled(_socket.default.prototype.open);
           var promise = mobiusSocket.connect();
           return (0, _promiseTick.default)(5).then(function () {
-            _testHelperChai.assert.calledOnce(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledOnce(_socket.default.prototype.open);
 
             // I'm not sure why, but it's important the clock doesn't advance
             // until a tick happens
@@ -433,19 +359,19 @@ describe('plugin-mobius-socket', function () {
             jest.advanceTimersByTime(mobiusSocket.config.backoffTimeReset);
             return (0, _promiseTick.default)(5);
           }).then(function () {
-            _testHelperChai.assert.calledTwice(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledTwice(_socket.default.prototype.open);
             jest.advanceTimersByTime(2 * mobiusSocket.config.backoffTimeReset);
             return (0, _promiseTick.default)(5);
           }).then(function () {
-            _testHelperChai.assert.calledThrice(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledThrice(_socket.default.prototype.open);
             jest.advanceTimersByTime(5 * mobiusSocket.config.backoffTimeReset);
             return promise;
           }).then(function () {
-            _testHelperChai.assert.calledThrice(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledThrice(_socket.default.prototype.open);
             jest.advanceTimersByTime(8 * mobiusSocket.config.backoffTimeReset);
             return (0, _promiseTick.default)(5);
           }).then(function () {
-            _testHelperChai.assert.calledThrice(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledThrice(_socket.default.prototype.open);
           });
         });
         describe('with `BadRequest`', function () {
@@ -453,7 +379,7 @@ describe('plugin-mobius-socket', function () {
             jest.useRealTimers();
             usingFakeTimers = false;
             socketOpenStub.restore();
-            socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open').returns(_promise.default.reject(new _index.BadRequest({
+            socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open').returns(_promise.default.reject(new _errors.BadRequest({
               code: 4400
             })));
             return _testHelperChai.assert.isRejected(mobiusSocket.connect());
@@ -463,8 +389,8 @@ describe('plugin-mobius-socket', function () {
           it('triggers a device refresh', function () {
             mobiusSocket.config.initialConnectionMaxRetries = 1;
             socketOpenStub.restore();
-            socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open').returns(_promise.default.resolve());
-            socketOpenStub.onCall(0).returns(_promise.default.reject(new _index.UnknownResponse({
+            socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open').returns(_promise.default.resolve());
+            socketOpenStub.onCall(0).returns(_promise.default.reject(new _errors.UnknownResponse({
               code: 4444
             })));
             _testHelperChai.assert.notCalled(webex.credentials.refresh);
@@ -482,8 +408,8 @@ describe('plugin-mobius-socket', function () {
           it('triggers a token refresh', function () {
             mobiusSocket.config.initialConnectionMaxRetries = 1;
             socketOpenStub.restore();
-            socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open').returns(_promise.default.resolve());
-            socketOpenStub.onCall(0).returns(_promise.default.reject(new _index.NotAuthorized({
+            socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open').returns(_promise.default.resolve());
+            socketOpenStub.onCall(0).returns(_promise.default.reject(new _errors.NotAuthorized({
               code: 4401
             })));
             _testHelperChai.assert.notCalled(webex.credentials.refresh);
@@ -502,7 +428,7 @@ describe('plugin-mobius-socket', function () {
             jest.useRealTimers();
             usingFakeTimers = false;
             socketOpenStub.restore();
-            socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open').returns(_promise.default.reject(new _index.Forbidden({
+            socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open').returns(_promise.default.reject(new _errors.Forbidden({
               code: 4403
             })));
             return _testHelperChai.assert.isRejected(mobiusSocket.connect());
@@ -550,7 +476,7 @@ describe('plugin-mobius-socket', function () {
               jest.advanceTimersByTime(6 * mobiusSocket.config.backoffTimeReset);
               return (0, _promiseTick.default)(2);
             }).then(function () {
-              _testHelperChai.assert.calledOnce(_index.Socket.prototype.open);
+              _testHelperChai.assert.calledOnce(_socket.default.prototype.open);
             });
           });
         });
@@ -565,13 +491,13 @@ describe('plugin-mobius-socket', function () {
           return promise.then(function () {
             _testHelperChai.assert.isTrue(mobiusSocket.connected, 'MobiusSocket is connected');
             _testHelperChai.assert.isFalse(mobiusSocket.connecting, 'MobiusSocket is not connecting');
-            _testHelperChai.assert.calledWith(_index.Socket.prototype.open, 'ws://providedurl.com', _sinon.default.match.any);
+            _testHelperChai.assert.calledWith(_socket.default.prototype.open, 'ws://providedurl.com', _sinon.default.match.any);
           });
         });
       });
       describe('when config.initialConnectionMaxRetries is set to 0', function () {
         it('connects successfully through the shared backoff flow', function () {
-          var backoffSpy = _sinon.default.spy(mobiusSocket, '_connectWithBackoff');
+          var backoffSpy = _sinon.default.spy(mobiusSocket, 'connectWithBackoff');
           mobiusSocket.config.initialConnectionMaxRetries = 0;
           var promise = mobiusSocket.connect('ws://example.com');
           _testHelperChai.assert.isTrue(mobiusSocket.connecting, 'MobiusSocket is connecting');
@@ -581,7 +507,7 @@ describe('plugin-mobius-socket', function () {
             _testHelperChai.assert.isTrue(mobiusSocket.connected, 'MobiusSocket is connected');
             _testHelperChai.assert.isFalse(mobiusSocket.connecting, 'MobiusSocket is not connecting');
             _testHelperChai.assert.isTrue(mobiusSocket.hasEverConnected, 'hasEverConnected is true');
-            _testHelperChai.assert.calledOnce(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledOnce(_socket.default.prototype.open);
             _testHelperChai.assert.calledOnce(backoffSpy);
             _testHelperChai.assert.isUndefined((_backoffSpy$firstCall = backoffSpy.firstCall.args[2]) === null || _backoffSpy$firstCall === void 0 ? void 0 : _backoffSpy$firstCall.initialConnectionMaxRetries);
             backoffSpy.restore();
@@ -591,18 +517,18 @@ describe('plugin-mobius-socket', function () {
           jest.useRealTimers();
           usingFakeTimers = false;
           socketOpenStub.restore();
-          socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open').returns(_promise.default.reject(new _index.ConnectionError({
+          socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open').returns(_promise.default.reject(new _errors.ConnectionError({
             code: 4001
           })));
           mobiusSocket.config.initialConnectionMaxRetries = 0;
           var promise = mobiusSocket.connect('ws://example.com');
           return _testHelperChai.assert.isRejected(promise).then(function () {
-            _testHelperChai.assert.calledOnce(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledOnce(_socket.default.prototype.open);
             _testHelperChai.assert.isFalse(mobiusSocket.connected, 'MobiusSocket is not connected');
           });
         });
         it('uses config-driven initial retry behavior in the shared backoff strategy', function () {
-          var backoffSpy = _sinon.default.spy(mobiusSocket, '_connectWithBackoff');
+          var backoffSpy = _sinon.default.spy(mobiusSocket, 'connectWithBackoff');
           mobiusSocket.config.initialConnectionMaxRetries = 0;
           var promise = mobiusSocket.connect('ws://example.com');
           mockWebSocket.open();
@@ -621,12 +547,12 @@ describe('plugin-mobius-socket', function () {
           mobiusSocket.config.initialConnectionMaxRetries = 0;
           mobiusSocket.config.maxRetries = 5;
           socketOpenStub.restore();
-          socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open').returns(_promise.default.reject(new _index.ConnectionError({
+          socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open').returns(_promise.default.reject(new _errors.ConnectionError({
             code: 4001
           })));
           var promise = mobiusSocket.connect('ws://new-url.com');
           return _testHelperChai.assert.isRejected(promise).then(function () {
-            _testHelperChai.assert.calledOnce(_index.Socket.prototype.open);
+            _testHelperChai.assert.calledOnce(_socket.default.prototype.open);
             _testHelperChai.assert.equal(mobiusSocket.socketUrl, 'ws://new-url.com');
             _testHelperChai.assert.isFalse(mobiusSocket.hasEverConnected, 'hasEverConnected is false');
           });
@@ -670,40 +596,6 @@ describe('plugin-mobius-socket', function () {
         });
       });
     });
-    describe('#logout()', function () {
-      it('calls disconnectAll and logs', function () {
-        _sinon.default.stub(mobiusSocket.logger, 'info');
-        _sinon.default.stub(mobiusSocket, 'disconnectAll');
-        mobiusSocket.logout();
-        _testHelperChai.assert.called(mobiusSocket.disconnectAll);
-        _testHelperChai.assert.calledOnce(mobiusSocket.logger.info);
-        _testHelperChai.assert.calledWith(mobiusSocket.logger.info.getCall(0), 'MobiusSocket: logout() called');
-      });
-      it('uses the config.beforeLogoutOptionsCloseReason to disconnect and will send code 3050 for logout', function () {
-        _sinon.default.stub(mobiusSocket, 'disconnectAll');
-        mobiusSocket.config.beforeLogoutOptionsCloseReason = 'done (permanent)';
-        mobiusSocket.logout();
-        _testHelperChai.assert.calledWith(mobiusSocket.disconnectAll, {
-          code: 3050,
-          reason: 'done (permanent)'
-        });
-      });
-      it('uses the config.beforeLogoutOptionsCloseReason to disconnect and will send code 3050 for logout if the reason is different than standard', function () {
-        _sinon.default.stub(mobiusSocket, 'disconnectAll');
-        mobiusSocket.config.beforeLogoutOptionsCloseReason = 'test';
-        mobiusSocket.logout();
-        _testHelperChai.assert.calledWith(mobiusSocket.disconnectAll, {
-          code: 3050,
-          reason: 'test'
-        });
-      });
-      it('uses the config.beforeLogoutOptionsCloseReason to disconnect and will send undefined for logout if the reason is same as standard', function () {
-        _sinon.default.stub(mobiusSocket, 'disconnectAll');
-        mobiusSocket.config.beforeLogoutOptionsCloseReason = 'done (forced)';
-        mobiusSocket.logout();
-        _testHelperChai.assert.calledWith(mobiusSocket.disconnectAll, undefined);
-      });
-    });
     describe('#disconnect()', function () {
       it('disconnects the WebSocket', function () {
         return mobiusSocket.connect().then(function () {
@@ -777,7 +669,7 @@ describe('plugin-mobius-socket', function () {
       describe('when there is a connection attempt inflight', function () {
         it('stops the attempt when disconnect called', function () {
           socketOpenStub.restore();
-          socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open');
+          socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open');
           socketOpenStub.onCall(0).returns(
           // Delay the opening of the socket so that disconnect is called while open
           // is in progress
@@ -796,20 +688,17 @@ describe('plugin-mobius-socket', function () {
                 case 0:
                   // By this time backoffCall and mobiusSocket socket should be defined by the
                   // 'connect' call
-                  _testHelperChai.assert.isDefined(mobiusSocket.backoffCalls.get('mobius-websocket-session'), 'MobiusSocket backoffCall is not defined');
+                  _testHelperChai.assert.isDefined(mobiusSocket.backoffCall, 'MobiusSocket backoffCall is not defined');
                   _testHelperChai.assert.isDefined(mobiusSocket.socket, 'MobiusSocket socket is not defined');
                   // Calling disconnect will abort the backoffCall, close the socket, and
                   // reject the connect
                   mobiusSocket.disconnect();
-                  _testHelperChai.assert.isUndefined(mobiusSocket.backoffCalls.get('mobius-websocket-session'), 'MobiusSocket backoffCall is still defined');
+                  _testHelperChai.assert.isUndefined(mobiusSocket.backoffCall, 'MobiusSocket backoffCall is still defined');
                   // The socket will never be unset (which seems bad)
                   _testHelperChai.assert.isDefined(mobiusSocket.socket, 'MobiusSocket socket is not defined');
                   _context2.next = 1;
                   return _testHelperChai.assert.isRejected(promise);
                 case 1:
-                  // connection did not fail, so no last error
-                  _testHelperChai.assert.isUndefined(mobiusSocket.getLastError());
-                case 2:
                 case "end":
                   return _context2.stop();
               }
@@ -818,64 +707,32 @@ describe('plugin-mobius-socket', function () {
         });
         it('stops the attempt when backoffCall is undefined', function () {
           socketOpenStub.restore();
-          socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open');
+          socketOpenStub = _sinon.default.stub(_socket.default.prototype, 'open');
           socketOpenStub.returns(_promise.default.resolve());
           var reason;
-          mobiusSocket.backoffCalls.clear();
-          var promise = mobiusSocket._attemptConnection('ws://example.com', 'mobius-websocket-session', function (_reason) {
+          mobiusSocket.backoffCall = undefined;
+          var promise = mobiusSocket.attemptConnection('ws://example.com', function (_reason) {
             reason = _reason;
           });
           return (0, _promiseTick.default)(mobiusSocket.config.backoffTimeReset).then(function () {
-            _testHelperChai.assert.equal(reason.message, "MobiusSocket: prevent socket open when backoffCall no longer defined for ".concat(mobiusSocket.defaultSessionId));
+            _testHelperChai.assert.match(reason.message, /prevent socket open when backoffCall no longer defined/);
 
             // Ensure the promise was actually rejected (short-circuited)
             return _testHelperChai.assert.isRejected(promise);
           });
         });
-        it('sets lastError when retrying', function () {
-          var realError = new Error('FORCED');
-          mobiusSocket.config.initialConnectionMaxRetries = 1;
-          socketOpenStub.restore();
-          socketOpenStub = _sinon.default.stub(_index.Socket.prototype, 'open');
-          socketOpenStub.onCall(0).returns(_promise.default.reject(realError));
-          var promise = mobiusSocket.connect();
-
-          // Wait for the connect call to setup
-          return (0, _promiseTick.default)(mobiusSocket.config.backoffTimeReset).then(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
-            var error, lastError;
-            return _regenerator.default.wrap(function (_context3) {
-              while (1) switch (_context3.prev = _context3.next) {
-                case 0:
-                  // Calling disconnect will abort the backoffCall, close the socket, and
-                  // reject the connect
-                  mobiusSocket.disconnect();
-                  _context3.next = 1;
-                  return _testHelperChai.assert.isRejected(promise);
-                case 1:
-                  error = _context3.sent;
-                  lastError = mobiusSocket.getLastError();
-                  _testHelperChai.assert.match(error.message, /MobiusSocket Connection Aborted/);
-                  _testHelperChai.assert.isDefined(lastError);
-                  _testHelperChai.assert.equal(lastError, realError);
-                case 2:
-                case "end":
-                  return _context3.stop();
-              }
-            }, _callee3);
-          })));
-        });
       });
     });
     describe('#sendWssRequest()', function () {
       beforeEach(function () {
         mobiusSocket.config.wssResponseTimeout = 100;
       });
-      it('resolves when a matching response_event arrives', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      it('resolves when a matching response_event arrives', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
         var requestPromise, requestPayload, response;
-        return _regenerator.default.wrap(function (_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
+        return _regenerator.default.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
             case 0:
-              _context4.next = 1;
+              _context3.next = 1;
               return mobiusSocket.connect();
             case 1:
               requestPromise = mobiusSocket.sendWssRequest({
@@ -884,7 +741,7 @@ describe('plugin-mobius-socket', function () {
                   token: 'test'
                 }
               });
-              _context4.next = 2;
+              _context3.next = 2;
               return (0, _promiseTick.default)();
             case 2:
               requestPayload = JSON.parse(mockWebSocket.send.lastCall.args[0]);
@@ -898,26 +755,26 @@ describe('plugin-mobius-socket', function () {
                   statusMessage: 'OK'
                 })
               });
-              _context4.next = 3;
+              _context3.next = 3;
               return requestPromise;
             case 3:
-              response = _context4.sent;
+              response = _context3.sent;
               _testHelperChai.assert.equal(response.type, 'response_event');
               _testHelperChai.assert.equal(response.subtype, 'auth');
               _testHelperChai.assert.equal(response.trackingId, requestPayload.trackingId);
               _testHelperChai.assert.equal(response.statusCode, 200);
             case 4:
             case "end":
-              return _context4.stop();
+              return _context3.stop();
           }
-        }, _callee4);
+        }, _callee3);
       })));
-      it('strips the Bearer prefix from connect-time auth token', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      it('strips the Bearer prefix from connect-time auth token', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
         var authPayload;
-        return _regenerator.default.wrap(function (_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
+        return _regenerator.default.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
             case 0:
-              _context5.next = 1;
+              _context4.next = 1;
               return mobiusSocket.connect();
             case 1:
               authPayload = JSON.parse(mockWebSocket.send.firstCall.args[0]);
@@ -925,16 +782,16 @@ describe('plugin-mobius-socket', function () {
               _testHelperChai.assert.equal(authPayload.data.token, 'FAKE');
             case 2:
             case "end":
-              return _context5.stop();
+              return _context4.stop();
           }
-        }, _callee5);
+        }, _callee4);
       })));
-      it('rejects when a matching response_event is non-2xx', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6() {
+      it('rejects when a matching response_event is non-2xx', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5() {
         var requestPromise, requestPayload, error;
-        return _regenerator.default.wrap(function (_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
+        return _regenerator.default.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
             case 0:
-              _context6.next = 1;
+              _context5.next = 1;
               return mobiusSocket.connect();
             case 1:
               requestPromise = mobiusSocket.sendWssRequest({
@@ -943,7 +800,7 @@ describe('plugin-mobius-socket', function () {
                   token: 'test'
                 }
               });
-              _context6.next = 2;
+              _context5.next = 2;
               return (0, _promiseTick.default)();
             case 2:
               requestPayload = JSON.parse(mockWebSocket.send.lastCall.args[0]);
@@ -956,26 +813,26 @@ describe('plugin-mobius-socket', function () {
                   statusMessage: 'Forbidden'
                 })
               });
-              _context6.next = 3;
+              _context5.next = 3;
               return _testHelperChai.assert.isRejected(requestPromise);
             case 3:
-              error = _context6.sent;
+              error = _context5.sent;
               _testHelperChai.assert.equal(error.name, 'MobiusSocketResponseError');
               _testHelperChai.assert.equal(error.statusCode, 403);
               _testHelperChai.assert.equal(error.statusMessage, 'Forbidden');
               _testHelperChai.assert.equal(error.trackingId, requestPayload.trackingId);
             case 4:
             case "end":
-              return _context6.stop();
+              return _context5.stop();
           }
-        }, _callee6);
+        }, _callee5);
       })));
-      it('rejects when the matching response does not arrive before timeout', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
+      it('rejects when the matching response does not arrive before timeout', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6() {
         var requestPromise, error;
-        return _regenerator.default.wrap(function (_context7) {
-          while (1) switch (_context7.prev = _context7.next) {
+        return _regenerator.default.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
             case 0:
-              _context7.next = 1;
+              _context6.next = 1;
               return mobiusSocket.connect();
             case 1:
               requestPromise = mobiusSocket.sendWssRequest({
@@ -985,28 +842,28 @@ describe('plugin-mobius-socket', function () {
                 }
               });
               jest.advanceTimersByTime(101);
-              _context7.next = 2;
+              _context6.next = 2;
               return (0, _promiseTick.default)();
             case 2:
-              _context7.next = 3;
+              _context6.next = 3;
               return _testHelperChai.assert.isRejected(requestPromise);
             case 3:
-              error = _context7.sent;
+              error = _context6.sent;
               _testHelperChai.assert.equal(error.name, 'MobiusSocketResponseError');
               _testHelperChai.assert.equal(error.statusCode, 408);
               _testHelperChai.assert.equal(error.statusMessage, 'Mobius websocket response timed out');
             case 4:
             case "end":
-              return _context7.stop();
+              return _context6.stop();
           }
-        }, _callee7);
+        }, _callee6);
       })));
-      it('rejects with a clear error when the matching response is missing status code', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
+      it('rejects with a clear error when the matching response is missing status code', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
         var requestPromise, requestPayload, error;
-        return _regenerator.default.wrap(function (_context8) {
-          while (1) switch (_context8.prev = _context8.next) {
+        return _regenerator.default.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
             case 0:
-              _context8.next = 1;
+              _context7.next = 1;
               return mobiusSocket.connect();
             case 1:
               requestPromise = mobiusSocket.sendWssRequest({
@@ -1015,7 +872,7 @@ describe('plugin-mobius-socket', function () {
                   token: 'test'
                 }
               });
-              _context8.next = 2;
+              _context7.next = 2;
               return (0, _promiseTick.default)();
             case 2:
               requestPayload = JSON.parse(mockWebSocket.send.lastCall.args[0]);
@@ -1026,25 +883,25 @@ describe('plugin-mobius-socket', function () {
                   trackingId: requestPayload.trackingId
                 })
               });
-              _context8.next = 3;
+              _context7.next = 3;
               return _testHelperChai.assert.isRejected(requestPromise);
             case 3:
-              error = _context8.sent;
+              error = _context7.sent;
               _testHelperChai.assert.equal(error.name, 'MobiusSocketResponseError');
               _testHelperChai.assert.isUndefined(error.statusCode);
               _testHelperChai.assert.equal(error.statusMessage, 'Socket response missing status code');
             case 4:
             case "end":
-              return _context8.stop();
+              return _context7.stop();
           }
-        }, _callee8);
+        }, _callee7);
       })));
-      it('rejects pending requests when the active socket closes', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9() {
+      it('rejects pending requests when the active socket closes', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
         var requestPromise, error;
-        return _regenerator.default.wrap(function (_context9) {
-          while (1) switch (_context9.prev = _context9.next) {
+        return _regenerator.default.wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
             case 0:
-              _context9.next = 1;
+              _context8.next = 1;
               return mobiusSocket.connect();
             case 1:
               requestPromise = mobiusSocket.sendWssRequest({
@@ -1057,52 +914,52 @@ describe('plugin-mobius-socket', function () {
                 code: 1003,
                 reason: 'service rejected request'
               });
-              _context9.next = 2;
+              _context8.next = 2;
               return _testHelperChai.assert.isRejected(requestPromise);
             case 2:
-              error = _context9.sent;
-              _testHelperChai.assert.instanceOf(error, _index.ConnectionError);
+              error = _context8.sent;
+              _testHelperChai.assert.instanceOf(error, _errors.ConnectionError);
               _testHelperChai.assert.equal(error.code, 1003);
               _testHelperChai.assert.equal(error.reason, 'service rejected request');
             case 3:
             case "end":
-              return _context9.stop();
+              return _context8.stop();
           }
-        }, _callee9);
+        }, _callee8);
       })));
-      it('rejects array payloads', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee0() {
+      it('rejects array payloads', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9() {
         var error;
-        return _regenerator.default.wrap(function (_context0) {
-          while (1) switch (_context0.prev = _context0.next) {
+        return _regenerator.default.wrap(function (_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
             case 0:
-              _context0.next = 1;
+              _context9.next = 1;
               return mobiusSocket.connect();
             case 1:
-              _context0.next = 2;
+              _context9.next = 2;
               return _testHelperChai.assert.isRejected(mobiusSocket.sendWssRequest([]));
             case 2:
-              error = _context0.sent;
+              error = _context9.sent;
               _testHelperChai.assert.equal(error.message, '`payload` is required');
             case 3:
             case "end":
-              return _context0.stop();
+              return _context9.stop();
           }
-        }, _callee0);
+        }, _callee9);
       })));
     });
     describe('#getConnectedWebSocketUrl()', function () {
-      it('returns the connected websocket url for the session', function () {
-        mobiusSocket.sockets.set(mobiusSocket.defaultSessionId, {
+      it('returns the connected websocket url', function () {
+        mobiusSocket.socket = {
           connected: true,
           url: 'ws://connected-url.com'
-        });
+        };
         _testHelperChai.assert.equal(mobiusSocket.getConnectedWebSocketUrl(), 'ws://connected-url.com');
       });
-      it('returns undefined when the session is not connected', function () {
-        mobiusSocket.sockets.set(mobiusSocket.defaultSessionId, {
+      it('returns undefined when not connected', function () {
+        mobiusSocket.socket = {
           connected: false,
           url: 'ws://disconnected-url.com'
-        });
+        };
         _testHelperChai.assert.isUndefined(mobiusSocket.getConnectedWebSocketUrl());
       });
     });
@@ -1116,96 +973,20 @@ describe('plugin-mobius-socket', function () {
           throw error;
         });
         _sinon.default.stub(mobiusSocket.logger, 'error');
-        return _promise.default.resolve(mobiusSocket._emit(mobiusSocket.defaultSessionId, 'break', event)).then(function (res) {
-          _testHelperChai.assert.calledWith(mobiusSocket.logger.error, 'MobiusSocket: error occurred in event handler:', error, ' with args: ', [mobiusSocket.defaultSessionId, 'break', event]);
+        return _promise.default.resolve(mobiusSocket.emitEvent('break', event)).then(function (res) {
+          _testHelperChai.assert.calledWith(mobiusSocket.logger.error, 'MobiusSocket: error occurred in event handler:', error, ' with args: ', ['break', event]);
           return res;
         });
       });
     });
-    describe('#_applyOverrides()', function () {
-      var lastSeenActivityDate = 'Some date';
-      var lastReadableActivityDate = 'Some other date';
-      it('merges a single header field with data', function () {
-        var envelope = {
-          headers: {
-            'data.activity.target.lastSeenActivityDate': lastSeenActivityDate
-          },
-          data: {
-            activity: {}
-          }
-        };
-        mobiusSocket._applyOverrides(envelope);
-        _testHelperChai.assert.equal(envelope.data.activity.target.lastSeenActivityDate, lastSeenActivityDate);
-      });
-      it('merges a multiple header fields with data', function () {
-        var envelope = {
-          headers: {
-            'data.activity.target.lastSeenActivityDate': lastSeenActivityDate,
-            'data.activity.target.lastReadableActivityDate': lastReadableActivityDate
-          },
-          data: {
-            activity: {}
-          }
-        };
-        mobiusSocket._applyOverrides(envelope);
-        _testHelperChai.assert.equal(envelope.data.activity.target.lastSeenActivityDate, lastSeenActivityDate);
-        _testHelperChai.assert.equal(envelope.data.activity.target.lastReadableActivityDate, lastReadableActivityDate);
-      });
-      it('merges headers when MobiusSocket messages arrive', function () {
-        var envelope = {
-          headers: {
-            'data.activity.target.lastSeenActivityDate': lastSeenActivityDate
-          },
-          data: {
-            activity: {}
-          }
-        };
-        mobiusSocket._applyOverrides(envelope);
-        _testHelperChai.assert.equal(envelope.data.activity.target.lastSeenActivityDate, lastSeenActivityDate);
-      });
-    });
-    describe('#_setTimeOffset', function () {
-      it('sets mercuryTimeOffset based on the difference between wsWriteTimestamp and now', function () {
-        var event = {
-          data: {
-            wsWriteTimestamp: (0, _now.default)() - 60000
-          }
-        };
-        _testHelperChai.assert.isUndefined(mobiusSocket.mercuryTimeOffset);
-        mobiusSocket._setTimeOffset('mobius-websocket-session', event);
-        _testHelperChai.assert.isDefined(mobiusSocket.mercuryTimeOffset);
-        _testHelperChai.assert.isTrue(mobiusSocket.mercuryTimeOffset > 0);
-      });
-      it('handles negative offsets', function () {
-        var event = {
-          data: {
-            wsWriteTimestamp: (0, _now.default)() + 60000
-          }
-        };
-        mobiusSocket._setTimeOffset('mobius-websocket-session', event);
-        _testHelperChai.assert.isTrue(mobiusSocket.mercuryTimeOffset < 0);
-      });
-      it('handles invalid wsWriteTimestamp', function () {
-        var invalidTimestamps = [null, -1, 'invalid', undefined];
-        invalidTimestamps.forEach(function (invalidTimestamp) {
-          var event = {
-            data: {
-              wsWriteTimestamp: invalidTimestamp
-            }
-          };
-          mobiusSocket._setTimeOffset('mobius-websocket-session', event);
-          _testHelperChai.assert.isUndefined(mobiusSocket.mercuryTimeOffset);
-        });
-      });
-    });
     describe('#_prepareUrl()', function () {
       it('returns the provided URL as-is (no Mercury URL transforms)', function () {
-        return mobiusSocket._prepareUrl('ws://provided.com').then(function (wsUrl) {
+        return mobiusSocket.prepareUrl('ws://provided.com').then(function (wsUrl) {
           _testHelperChai.assert.equal(wsUrl, 'ws://provided.com');
         });
       });
       it('falls back to device webSocketUrl when no URL is provided', function () {
-        return mobiusSocket._prepareUrl().then(function (wsUrl) {
+        return mobiusSocket.prepareUrl().then(function (wsUrl) {
           _testHelperChai.assert.equal(wsUrl, 'ws://example.com');
         });
       });
@@ -1213,78 +994,66 @@ describe('plugin-mobius-socket', function () {
     describe('shutdown protocol', function () {
       describe('#_handleImminentShutdown()', function () {
         var connectWithBackoffStub;
-        var sessionId = 'mobius-websocket-session';
         beforeEach(function () {
           mobiusSocket.connected = true;
-          mobiusSocket.sockets.set(sessionId, {
+          mobiusSocket.socket = {
             url: 'ws://old-socket.com',
             removeAllListeners: _sinon.default.stub()
-          });
-          mobiusSocket.socket = mobiusSocket.sockets.get(sessionId);
-          connectWithBackoffStub = _sinon.default.stub(mobiusSocket, '_connectWithBackoff');
+          };
+          connectWithBackoffStub = _sinon.default.stub(mobiusSocket, 'connectWithBackoff');
           connectWithBackoffStub.returns(_promise.default.resolve());
-          _sinon.default.stub(mobiusSocket, '_emit');
+          _sinon.default.stub(mobiusSocket, 'emitEvent');
         });
         afterEach(function () {
           connectWithBackoffStub.restore();
-          mobiusSocket._emit.restore();
-          mobiusSocket.sockets.clear();
+          mobiusSocket.emitEvent.restore();
         });
         it('should be idempotent - no-op if already in progress', function () {
-          // Simulate an existing switchover in progress by seeding the backoff map
-          mobiusSocket._shutdownSwitchoverBackoffCalls.set(sessionId, {
+          mobiusSocket.shutdownSwitchoverBackoffCall = {
             placeholder: true
-          });
-          mobiusSocket._handleImminentShutdown(sessionId);
+          };
+          mobiusSocket.handleImminentShutdown();
           _testHelperChai.assert.notCalled(connectWithBackoffStub);
         });
         it('should set switchover flags when called', function () {
-          mobiusSocket._handleImminentShutdown(sessionId);
+          mobiusSocket.handleImminentShutdown();
           _testHelperChai.assert.calledOnce(connectWithBackoffStub);
           var callArgs = connectWithBackoffStub.firstCall.args;
           _testHelperChai.assert.isUndefined(callArgs[0]); // webSocketUrl
-          _testHelperChai.assert.equal(callArgs[1], sessionId); // sessionId
-          _testHelperChai.assert.isObject(callArgs[2]); // context
-          _testHelperChai.assert.isTrue(callArgs[2].isShutdownSwitchover);
-          _testHelperChai.assert.isObject(callArgs[2].attemptOptions);
-          _testHelperChai.assert.isTrue(callArgs[2].attemptOptions.isShutdownSwitchover);
+          _testHelperChai.assert.isObject(callArgs[1]); // context
+          _testHelperChai.assert.isTrue(callArgs[1].isShutdownSwitchover);
+          _testHelperChai.assert.isObject(callArgs[1].attemptOptions);
+          _testHelperChai.assert.isTrue(callArgs[1].attemptOptions.isShutdownSwitchover);
         });
         it('should call _connectWithBackoff with correct parameters', function (done) {
-          mobiusSocket._handleImminentShutdown(sessionId);
+          mobiusSocket.handleImminentShutdown();
           process.nextTick(function () {
             _testHelperChai.assert.calledOnce(connectWithBackoffStub);
             var callArgs = connectWithBackoffStub.firstCall.args;
             _testHelperChai.assert.isUndefined(callArgs[0]); // webSocketUrl
-            _testHelperChai.assert.equal(callArgs[1], sessionId); // sessionId
-            _testHelperChai.assert.isObject(callArgs[2]); // context
-            _testHelperChai.assert.isTrue(callArgs[2].isShutdownSwitchover);
-            _testHelperChai.assert.isObject(callArgs[2].attemptOptions);
-            _testHelperChai.assert.isTrue(callArgs[2].attemptOptions.isShutdownSwitchover);
+            _testHelperChai.assert.isObject(callArgs[1]); // context
+            _testHelperChai.assert.isTrue(callArgs[1].isShutdownSwitchover);
+            _testHelperChai.assert.isObject(callArgs[1].attemptOptions);
+            _testHelperChai.assert.isTrue(callArgs[1].attemptOptions.isShutdownSwitchover);
             done();
           });
         });
         it('should handle exceptions during switchover', function () {
           connectWithBackoffStub.restore();
-          _sinon.default.stub(mobiusSocket, '_connectWithBackoff').throws(new Error('Connection failed'));
-          mobiusSocket._handleImminentShutdown(sessionId);
-
-          // When an exception happens synchronously, the placeholder entry
-          // should be removed from the map.
-          var switchoverCall = mobiusSocket._shutdownSwitchoverBackoffCalls.get(sessionId);
-          _testHelperChai.assert.isUndefined(switchoverCall);
-          mobiusSocket._connectWithBackoff.restore();
+          _sinon.default.stub(mobiusSocket, 'connectWithBackoff').throws(new Error('Connection failed'));
+          mobiusSocket.handleImminentShutdown();
+          _testHelperChai.assert.isUndefined(mobiusSocket.shutdownSwitchoverBackoffCall);
+          mobiusSocket.connectWithBackoff.restore();
         });
       });
       describe('#_onmessage() with shutdown message', function () {
         beforeEach(function () {
-          _sinon.default.stub(mobiusSocket, '_handleImminentShutdown');
-          _sinon.default.stub(mobiusSocket, '_emit');
-          _sinon.default.stub(mobiusSocket, '_setTimeOffset');
+          _sinon.default.stub(mobiusSocket, 'handleImminentShutdown');
+          _sinon.default.stub(mobiusSocket, 'emitEvent');
         });
         afterEach(function () {
-          mobiusSocket._handleImminentShutdown.restore();
-          mobiusSocket._emit.restore();
-          mobiusSocket._setTimeOffset.restore();
+          mobiusSocket.handleImminentShutdown.restore();
+          mobiusSocket.emitEvent.restore();
         });
         it('should trigger _handleImminentShutdown on shutdown message', function () {
           var shutdownEvent = {
@@ -1292,9 +1061,9 @@ describe('plugin-mobius-socket', function () {
               type: 'shutdown'
             }
           };
-          var result = mobiusSocket._onmessage(mobiusSocket.defaultSessionId, shutdownEvent);
-          _testHelperChai.assert.calledOnce(mobiusSocket._handleImminentShutdown);
-          _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'event:mercury_shutdown_imminent', shutdownEvent.data);
+          var result = mobiusSocket.onmessage(shutdownEvent);
+          _testHelperChai.assert.calledOnce(mobiusSocket.handleImminentShutdown);
+          _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'event:mobius_shutdown_imminent', shutdownEvent.data);
           _testHelperChai.assert.instanceOf(result, _promise.default);
         });
         it('should handle shutdown message without additional data gracefully', function () {
@@ -1303,8 +1072,8 @@ describe('plugin-mobius-socket', function () {
               type: 'shutdown'
             }
           };
-          mobiusSocket._onmessage(mobiusSocket.defaultSessionId, shutdownEvent);
-          _testHelperChai.assert.calledOnce(mobiusSocket._handleImminentShutdown);
+          mobiusSocket.onmessage(shutdownEvent);
+          _testHelperChai.assert.calledOnce(mobiusSocket.handleImminentShutdown);
         });
         it('should not trigger shutdown handling for non-shutdown messages', function () {
           var regularEvent = {
@@ -1315,20 +1084,16 @@ describe('plugin-mobius-socket', function () {
               }
             }
           };
-          mobiusSocket._onmessage(mobiusSocket.defaultSessionId, regularEvent);
-          _testHelperChai.assert.notCalled(mobiusSocket._handleImminentShutdown);
+          mobiusSocket.onmessage(regularEvent);
+          _testHelperChai.assert.notCalled(mobiusSocket.handleImminentShutdown);
         });
       });
       describe('#_onmessage() with missing data or eventType', function () {
         beforeEach(function () {
-          _sinon.default.stub(mobiusSocket, '_emit');
-          _sinon.default.stub(mobiusSocket, '_setTimeOffset');
-          _sinon.default.stub(mobiusSocket, '_applyOverrides');
+          _sinon.default.stub(mobiusSocket, 'emitEvent');
         });
         afterEach(function () {
-          mobiusSocket._emit.restore();
-          mobiusSocket._setTimeOffset.restore();
-          mobiusSocket._applyOverrides.restore();
+          mobiusSocket.emitEvent.restore();
         });
         it('should not throw when envelope.data is undefined', function () {
           var event = {
@@ -1337,9 +1102,9 @@ describe('plugin-mobius-socket', function () {
               // no nested data property
             }
           };
-          var result = mobiusSocket._onmessage(mobiusSocket.defaultSessionId, event);
+          var result = mobiusSocket.onmessage(event);
           _testHelperChai.assert.instanceOf(result, _promise.default);
-          _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'event', event.data);
+          _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'event', event.data);
         });
         it('should not throw when data.eventType is undefined', function () {
           var event = {
@@ -1351,9 +1116,9 @@ describe('plugin-mobius-socket', function () {
               }
             }
           };
-          var result = mobiusSocket._onmessage(mobiusSocket.defaultSessionId, event);
+          var result = mobiusSocket.onmessage(event);
           _testHelperChai.assert.instanceOf(result, _promise.default);
-          _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'event', event.data);
+          _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'event', event.data);
         });
         it('should emit generic event for messages without eventType (e.g. subscription responses)', function () {
           var event = {
@@ -1365,15 +1130,15 @@ describe('plugin-mobius-socket', function () {
               }
             }
           };
-          var result = mobiusSocket._onmessage(mobiusSocket.defaultSessionId, event);
+          var result = mobiusSocket.onmessage(event);
           _testHelperChai.assert.instanceOf(result, _promise.default);
-          _testHelperChai.assert.calledOnce(mobiusSocket._emit);
-          _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'event', event.data);
+          _testHelperChai.assert.calledOnce(mobiusSocket.emitEvent);
+          _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'event', event.data);
         });
-        it('should still process messages with a valid eventType', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee1() {
+        it('should still process messages with a valid eventType', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee0() {
           var event;
-          return _regenerator.default.wrap(function (_context1) {
-            while (1) switch (_context1.prev = _context1.next) {
+          return _regenerator.default.wrap(function (_context0) {
+            while (1) switch (_context0.prev = _context0.next) {
               case 0:
                 event = {
                   data: {
@@ -1382,18 +1147,16 @@ describe('plugin-mobius-socket', function () {
                     }
                   }
                 };
-                _context1.next = 1;
-                return mobiusSocket._onmessage(mobiusSocket.defaultSessionId, event);
+                _context0.next = 1;
+                return mobiusSocket.onmessage(event);
               case 1:
-                // Normal flow emits namespace-specific events after processing handlers.
-                // The early-return guard only emits 'event', so asserting these proves the normal path was taken.
-                _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'event:conversation', event.data);
-                _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'event:conversation.activity', event.data);
+                _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'event:conversation', event.data);
+                _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'event:conversation.activity', event.data);
               case 2:
               case "end":
-                return _context1.stop();
+                return _context0.stop();
             }
-          }, _callee1);
+          }, _callee0);
         })));
       });
       describe('#_onmessage() async_event deduplication', function () {
@@ -1404,19 +1167,41 @@ describe('plugin-mobius-socket', function () {
         afterEach(function () {
           mobiusSocket.config.dedupCacheMaxSize = originalDedupCacheMaxSize;
         });
-        it('suppresses duplicate async_event messages for the same session', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee10() {
+        it('suppresses duplicate async_event messages', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee1() {
+          var emitSpy;
+          return _regenerator.default.wrap(function (_context1) {
+            while (1) switch (_context1.prev = _context1.next) {
+              case 0:
+                emitSpy = _sinon.default.spy(mobiusSocket, 'emitEvent');
+                _context1.next = 1;
+                return mobiusSocket.onmessage(createAsyncEvent('evt-1'));
+              case 1:
+                _context1.next = 2;
+                return mobiusSocket.onmessage(createAsyncEvent('evt-1'));
+              case 2:
+                _testHelperChai.assert.equal(countGenericEventEmits(emitSpy), 1);
+                emitSpy.restore();
+              case 3:
+              case "end":
+                return _context1.stop();
+            }
+          }, _callee1);
+        })));
+        it('suppresses duplicate async_event messages across socket replacement without disconnect', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee10() {
           var emitSpy;
           return _regenerator.default.wrap(function (_context10) {
             while (1) switch (_context10.prev = _context10.next) {
               case 0:
-                emitSpy = _sinon.default.spy(mobiusSocket, '_emit');
+                emitSpy = _sinon.default.spy(mobiusSocket, 'emitEvent');
+                mobiusSocket.socket = createSessionSocket();
                 _context10.next = 1;
-                return mobiusSocket._onmessage('session-a', createAsyncEvent('evt-1'));
+                return mobiusSocket.onmessage(createAsyncEvent('evt-2'));
               case 1:
+                mobiusSocket.socket = createSessionSocket();
                 _context10.next = 2;
-                return mobiusSocket._onmessage('session-a', createAsyncEvent('evt-1'));
+                return mobiusSocket.onmessage(createAsyncEvent('evt-2'));
               case 2:
-                _testHelperChai.assert.equal(countGenericEventEmits(emitSpy, 'session-a'), 1);
+                _testHelperChai.assert.equal(countGenericEventEmits(emitSpy), 1);
                 emitSpy.restore();
               case 3:
               case "end":
@@ -1424,105 +1209,63 @@ describe('plugin-mobius-socket', function () {
             }
           }, _callee10);
         })));
-        it('suppresses duplicate async_event messages across socket replacement without disconnect', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee11() {
-          var sessionId, emitSpy;
+        it('evicts only the oldest eventId when the dedup cache exceeds max size', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee11() {
+          var emitSpy;
           return _regenerator.default.wrap(function (_context11) {
             while (1) switch (_context11.prev = _context11.next) {
               case 0:
-                sessionId = 'session-a';
-                emitSpy = _sinon.default.spy(mobiusSocket, '_emit');
-                mobiusSocket.sockets.set(sessionId, createSessionSocket());
+                emitSpy = _sinon.default.spy(mobiusSocket, 'emitEvent');
+                mobiusSocket.config.dedupCacheMaxSize = 3;
                 _context11.next = 1;
-                return mobiusSocket._onmessage(sessionId, createAsyncEvent('evt-2'));
+                return mobiusSocket.onmessage(createAsyncEvent('e1'));
               case 1:
-                mobiusSocket.sockets.set(sessionId, createSessionSocket());
                 _context11.next = 2;
-                return mobiusSocket._onmessage(sessionId, createAsyncEvent('evt-2'));
+                return mobiusSocket.onmessage(createAsyncEvent('e2'));
               case 2:
-                _testHelperChai.assert.equal(countGenericEventEmits(emitSpy, sessionId), 1);
-                emitSpy.restore();
+                _context11.next = 3;
+                return mobiusSocket.onmessage(createAsyncEvent('e3'));
               case 3:
+                _context11.next = 4;
+                return mobiusSocket.onmessage(createAsyncEvent('e4'));
+              case 4:
+                _context11.next = 5;
+                return mobiusSocket.onmessage(createAsyncEvent('e2'));
+              case 5:
+                _context11.next = 6;
+                return mobiusSocket.onmessage(createAsyncEvent('e1'));
+              case 6:
+                _testHelperChai.assert.equal(countGenericEventEmits(emitSpy), 5);
+                emitSpy.restore();
+              case 7:
               case "end":
                 return _context11.stop();
             }
           }, _callee11);
         })));
-        it('evicts only the oldest eventId when the dedup cache exceeds max size', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee12() {
+        it('clears the dedup cache on disconnect', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee12() {
           var emitSpy;
           return _regenerator.default.wrap(function (_context12) {
             while (1) switch (_context12.prev = _context12.next) {
               case 0:
-                emitSpy = _sinon.default.spy(mobiusSocket, '_emit');
-                mobiusSocket.config.dedupCacheMaxSize = 3;
+                emitSpy = _sinon.default.spy(mobiusSocket, 'emitEvent');
                 _context12.next = 1;
-                return mobiusSocket._onmessage('session-a', createAsyncEvent('e1'));
+                return mobiusSocket.onmessage(createAsyncEvent('evt-3'));
               case 1:
+                mobiusSocket.socket = createSessionSocket();
                 _context12.next = 2;
-                return mobiusSocket._onmessage('session-a', createAsyncEvent('e2'));
+                return mobiusSocket.disconnect();
               case 2:
                 _context12.next = 3;
-                return mobiusSocket._onmessage('session-a', createAsyncEvent('e3'));
+                return mobiusSocket.onmessage(createAsyncEvent('evt-3'));
               case 3:
-                _context12.next = 4;
-                return mobiusSocket._onmessage('session-a', createAsyncEvent('e4'));
-              case 4:
-                _context12.next = 5;
-                return mobiusSocket._onmessage('session-a', createAsyncEvent('e2'));
-              case 5:
-                _context12.next = 6;
-                return mobiusSocket._onmessage('session-a', createAsyncEvent('e1'));
-              case 6:
-                _testHelperChai.assert.equal(countGenericEventEmits(emitSpy, 'session-a'), 5);
+                _testHelperChai.assert.equal(countGenericEventEmits(emitSpy), 2);
                 emitSpy.restore();
-              case 7:
+              case 4:
               case "end":
                 return _context12.stop();
             }
           }, _callee12);
         })));
-        it('clears the session dedup cache on disconnect', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee13() {
-          var sessionId, emitSpy;
-          return _regenerator.default.wrap(function (_context13) {
-            while (1) switch (_context13.prev = _context13.next) {
-              case 0:
-                sessionId = 'session-a';
-                emitSpy = _sinon.default.spy(mobiusSocket, '_emit');
-                _context13.next = 1;
-                return mobiusSocket._onmessage(sessionId, createAsyncEvent('evt-3'));
-              case 1:
-                mobiusSocket.sockets.set(sessionId, createSessionSocket());
-                _context13.next = 2;
-                return mobiusSocket.disconnect(undefined, sessionId);
-              case 2:
-                _context13.next = 3;
-                return mobiusSocket._onmessage(sessionId, createAsyncEvent('evt-3'));
-              case 3:
-                _testHelperChai.assert.equal(countGenericEventEmits(emitSpy, sessionId), 2);
-                emitSpy.restore();
-              case 4:
-              case "end":
-                return _context13.stop();
-            }
-          }, _callee13);
-        })));
-      });
-      describe('#_getEventHandlers()', function () {
-        it('should return an empty array when eventType is undefined', function () {
-          var result = mobiusSocket._getEventHandlers(undefined);
-          _testHelperChai.assert.deepEqual(result, []);
-        });
-        it('should return an empty array when eventType is null', function () {
-          var result = mobiusSocket._getEventHandlers(null);
-          _testHelperChai.assert.deepEqual(result, []);
-        });
-        it('should return an empty array when eventType is an empty string', function () {
-          var result = mobiusSocket._getEventHandlers('');
-          _testHelperChai.assert.deepEqual(result, []);
-        });
-        it('should return an empty array when namespace is not registered', function () {
-          var result = mobiusSocket._getEventHandlers('unknownNamespace.someEvent');
-          _testHelperChai.assert.deepEqual(result, []);
-        });
       });
       describe('#_onclose() with code 4001 (shutdown replacement)', function () {
         var mockSocket;
@@ -1537,23 +1280,22 @@ describe('plugin-mobius-socket', function () {
             removeAllListeners: _sinon.default.stub()
           };
           mobiusSocket.socket = mockSocket;
-          mobiusSocket.sockets.set(mobiusSocket.defaultSessionId, mockSocket);
           mobiusSocket.connected = true;
-          _sinon.default.stub(mobiusSocket, '_emit');
-          _sinon.default.stub(mobiusSocket, '_reconnect');
+          _sinon.default.stub(mobiusSocket, 'emitEvent');
+          _sinon.default.stub(mobiusSocket, 'reconnect');
         });
         afterEach(function () {
-          mobiusSocket._emit.restore();
-          mobiusSocket._reconnect.restore();
+          mobiusSocket.emitEvent.restore();
+          mobiusSocket.reconnect.restore();
         });
         it('should handle active socket close with 4001 - permanent failure', function () {
           var closeEvent = {
             code: 4001,
             reason: 'replaced during shutdown'
           };
-          mobiusSocket._onclose(mobiusSocket.defaultSessionId, closeEvent, mockSocket);
-          _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'offline.permanent', closeEvent);
-          _testHelperChai.assert.notCalled(mobiusSocket._reconnect); // No reconnect for 4001 on active socket
+          mobiusSocket.onclose(closeEvent, mockSocket);
+          _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'offline.permanent', closeEvent);
+          _testHelperChai.assert.notCalled(mobiusSocket.reconnect);
           _testHelperChai.assert.isFalse(mobiusSocket.connected);
         });
         it('should handle non-active socket close with 4001 - no reconnect needed', function () {
@@ -1561,10 +1303,10 @@ describe('plugin-mobius-socket', function () {
             code: 4001,
             reason: 'replaced during shutdown'
           };
-          mobiusSocket._onclose(mobiusSocket.defaultSessionId, closeEvent, anotherSocket);
-          _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'offline.replaced', closeEvent);
-          _testHelperChai.assert.notCalled(mobiusSocket._reconnect);
-          _testHelperChai.assert.isTrue(mobiusSocket.connected); // Should remain connected
+          mobiusSocket.onclose(closeEvent, anotherSocket);
+          _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'offline.replaced', closeEvent);
+          _testHelperChai.assert.notCalled(mobiusSocket.reconnect);
+          _testHelperChai.assert.isTrue(mobiusSocket.connected);
           _testHelperChai.assert.strictEqual(mobiusSocket.socket, mockSocket);
         });
         it('should distinguish between active and non-active socket closes', function () {
@@ -1574,40 +1316,31 @@ describe('plugin-mobius-socket', function () {
           };
 
           // Test non-active socket
-          mobiusSocket._onclose(mobiusSocket.defaultSessionId, closeEvent, anotherSocket);
-          _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'offline.replaced', closeEvent);
+          mobiusSocket.onclose(closeEvent, anotherSocket);
+          _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'offline.replaced', closeEvent);
 
           // Reset the spy call history
-          mobiusSocket._emit.resetHistory();
+          mobiusSocket.emitEvent.resetHistory();
 
           // Test active socket
-          mobiusSocket.sockets.set(mobiusSocket.defaultSessionId, mockSocket);
-          mobiusSocket._onclose(mobiusSocket.defaultSessionId, closeEvent, mockSocket);
-          _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'offline.permanent', closeEvent);
+          mobiusSocket.onclose(closeEvent, mockSocket);
+          _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'offline.permanent', closeEvent);
         });
         it('should handle missing sourceSocket parameter (treats as non-active)', function () {
           var closeEvent = {
             code: 4001,
             reason: 'replaced during shutdown'
           };
-          mobiusSocket._onclose(mobiusSocket.defaultSessionId, closeEvent); // No sourceSocket parameter
-
-          // With simplified logic, undefined !== this.socket, so isActiveSocket = false
-          _testHelperChai.assert.calledWith(mobiusSocket._emit, mobiusSocket.defaultSessionId, 'offline.replaced', closeEvent);
-          _testHelperChai.assert.notCalled(mobiusSocket._reconnect);
+          mobiusSocket.onclose(closeEvent, undefined);
+          _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'offline.replaced', closeEvent);
+          _testHelperChai.assert.notCalled(mobiusSocket.reconnect);
         });
         it('should clean up event listeners from non-active socket when it closes', function () {
           var closeEvent = {
             code: 4001,
             reason: 'replaced during shutdown'
           };
-
-          // Close non-active socket (not the active one)
-          mobiusSocket._onclose(mobiusSocket.defaultSessionId, closeEvent, anotherSocket);
-
-          // Verify listeners were removed from the old socket
-          // The _onclose method checks if sourceSocket !== this.socket (non-active)
-          // and then calls removeAllListeners in the else branch
+          mobiusSocket.onclose(closeEvent, anotherSocket);
           _testHelperChai.assert.calledOnce(anotherSocket.removeAllListeners);
         });
         it('should not clean up listeners from active socket listeners until close handler runs', function () {
@@ -1615,128 +1348,115 @@ describe('plugin-mobius-socket', function () {
             code: 4001,
             reason: 'replaced during shutdown'
           };
-
-          // Close active socket
-          mobiusSocket._onclose(mobiusSocket.defaultSessionId, closeEvent, mockSocket);
-
-          // Verify listeners were removed from active socket
+          mobiusSocket.onclose(closeEvent, mockSocket);
           _testHelperChai.assert.calledOnce(mockSocket.removeAllListeners);
         });
       });
       describe('shutdown switchover with retry logic', function () {
         var connectWithBackoffStub;
-        var sessionId = 'mobius-websocket-session';
         beforeEach(function () {
           mobiusSocket.connected = true;
-          mobiusSocket.sockets.set(sessionId, {
+          mobiusSocket.socket = {
             url: 'ws://old-socket.com',
             removeAllListeners: _sinon.default.stub()
-          });
-          mobiusSocket.socket = mobiusSocket.sockets.get(sessionId);
-          connectWithBackoffStub = _sinon.default.stub(mobiusSocket, '_connectWithBackoff');
-          _sinon.default.stub(mobiusSocket, '_emit');
+          };
+          connectWithBackoffStub = _sinon.default.stub(mobiusSocket, 'connectWithBackoff');
+          _sinon.default.stub(mobiusSocket, 'emitEvent');
         });
         afterEach(function () {
           connectWithBackoffStub.restore();
-          mobiusSocket._emit.restore();
-          mobiusSocket.sockets.clear();
+          mobiusSocket.emitEvent.restore();
         });
         it('should call _connectWithBackoff with shutdown switchover context', function (done) {
           connectWithBackoffStub.returns(_promise.default.resolve());
-          mobiusSocket._handleImminentShutdown(sessionId);
+          mobiusSocket.handleImminentShutdown();
           process.nextTick(function () {
             _testHelperChai.assert.calledOnce(connectWithBackoffStub);
             var callArgs = connectWithBackoffStub.firstCall.args;
             _testHelperChai.assert.isUndefined(callArgs[0]); // webSocketUrl
-            _testHelperChai.assert.equal(callArgs[1], sessionId);
-            _testHelperChai.assert.isObject(callArgs[2]);
-            _testHelperChai.assert.isTrue(callArgs[2].isShutdownSwitchover);
-            _testHelperChai.assert.isObject(callArgs[2].attemptOptions);
-            _testHelperChai.assert.isTrue(callArgs[2].attemptOptions.isShutdownSwitchover);
+            _testHelperChai.assert.isObject(callArgs[1]);
+            _testHelperChai.assert.isTrue(callArgs[1].isShutdownSwitchover);
+            _testHelperChai.assert.isObject(callArgs[1].attemptOptions);
+            _testHelperChai.assert.isTrue(callArgs[1].attemptOptions.isShutdownSwitchover);
             done();
           });
         });
-        it('should set _shutdownSwitchoverInProgress flag during switchover', function () {
-          // With the new behavior, "in progress" is represented by the presence
-          // of an entry in _shutdownSwitchoverBackoffCalls.
-          // Since _connectWithBackoff is stubbed in this suite, simulate its side-effect
-          // of seeding the backoff-call map entry.
+        it('should set shutdownSwitchoverBackoffCall during switchover', function () {
           connectWithBackoffStub.callsFake(function () {
-            mobiusSocket._shutdownSwitchoverBackoffCalls.set(sessionId, {
+            mobiusSocket.shutdownSwitchoverBackoffCall = {
               placeholder: true
-            });
+            };
             return new _promise.default(function () {}); // Never resolves
           });
-          mobiusSocket._handleImminentShutdown(sessionId);
-          var switchoverBackoffCall = mobiusSocket._shutdownSwitchoverBackoffCalls.get(sessionId);
-          _testHelperChai.assert.isOk(switchoverBackoffCall);
+          mobiusSocket.handleImminentShutdown();
+          _testHelperChai.assert.isOk(mobiusSocket.shutdownSwitchoverBackoffCall);
         });
-        it('should emit success event when switchover completes', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee14() {
+        it('should emit success event when switchover completes', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee13() {
           var emitCalls, hasCompleteEvent;
-          return _regenerator.default.wrap(function (_context14) {
-            while (1) switch (_context14.prev = _context14.next) {
+          return _regenerator.default.wrap(function (_context13) {
+            while (1) switch (_context13.prev = _context13.next) {
               case 0:
-                connectWithBackoffStub.callsFake(function (url, sid, context) {
+                connectWithBackoffStub.callsFake(function (url, context) {
                   if (context && context.attemptOptions && context.attemptOptions.onSuccess) {
-                    var mockSocket = {
+                    var newSocket = {
                       url: 'ws://new-socket.com'
                     };
-                    context.attemptOptions.onSuccess(mockSocket, 'ws://new-socket.com');
+                    context.attemptOptions.onSuccess(newSocket, 'ws://new-socket.com');
                   }
                   return _promise.default.resolve();
                 });
-                mobiusSocket._handleImminentShutdown(sessionId);
-                _context14.next = 1;
+                mobiusSocket.handleImminentShutdown();
+                _context13.next = 1;
                 return (0, _promiseTick.default)(50);
               case 1:
-                emitCalls = mobiusSocket._emit.getCalls();
+                emitCalls = mobiusSocket.emitEvent.getCalls();
                 hasCompleteEvent = emitCalls.some(function (call) {
-                  return call.args[0] === sessionId && call.args[1] === 'event:mercury_shutdown_switchover_complete';
+                  return call.args[0] === 'event:mobius_shutdown_switchover_complete';
                 });
                 _testHelperChai.assert.isTrue(hasCompleteEvent, 'Should emit switchover complete event');
               case 2:
               case "end":
-                return _context14.stop();
+                return _context13.stop();
             }
-          }, _callee14);
+          }, _callee13);
         })));
-        it('should emit failure event when switchover exhausts retries', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee15() {
+        it('should emit failure event when switchover exhausts retries', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee14() {
           var testError, emitCalls, hasFailureEvent;
-          return _regenerator.default.wrap(function (_context15) {
-            while (1) switch (_context15.prev = _context15.next) {
+          return _regenerator.default.wrap(function (_context14) {
+            while (1) switch (_context14.prev = _context14.next) {
               case 0:
                 testError = new Error('Connection failed');
                 connectWithBackoffStub.returns(_promise.default.reject(testError));
-                mobiusSocket._handleImminentShutdown(sessionId);
-                _context15.next = 1;
+                mobiusSocket.handleImminentShutdown();
+                _context14.next = 1;
                 return (0, _promiseTick.default)(50);
               case 1:
-                emitCalls = mobiusSocket._emit.getCalls();
+                emitCalls = mobiusSocket.emitEvent.getCalls();
                 hasFailureEvent = emitCalls.some(function (call) {
-                  return call.args[0] === sessionId && call.args[1] === 'event:mercury_shutdown_switchover_failed' && call.args[2] && call.args[2].reason === testError;
+                  return call.args[0] === 'event:mobius_shutdown_switchover_failed' && call.args[1] && call.args[1].reason === testError;
                 });
                 _testHelperChai.assert.isTrue(hasFailureEvent, 'Should emit switchover failed event');
               case 2:
               case "end":
-                return _context15.stop();
+                return _context14.stop();
             }
-          }, _callee15);
+          }, _callee14);
         })));
-        it('should allow old socket to be closed by server after switchover failure', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee16() {
-          return _regenerator.default.wrap(function (_context16) {
-            while (1) switch (_context16.prev = _context16.next) {
+        it('should allow old socket to be closed by server after switchover failure', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee15() {
+          return _regenerator.default.wrap(function (_context15) {
+            while (1) switch (_context15.prev = _context15.next) {
               case 0:
                 connectWithBackoffStub.returns(_promise.default.reject(new Error('Failed')));
-                mobiusSocket._handleImminentShutdown(sessionId);
-                _context16.next = 1;
+                mobiusSocket.handleImminentShutdown();
+                _context15.next = 1;
                 return (0, _promiseTick.default)(50);
               case 1:
                 _testHelperChai.assert.equal(mobiusSocket.socket.removeAllListeners.callCount, 0);
               case 2:
               case "end":
-                return _context16.stop();
+                return _context15.stop();
             }
-          }, _callee16);
+          }, _callee15);
         })));
       });
       describe('#_prepareAndOpenSocket()', function () {
@@ -1747,7 +1467,7 @@ describe('plugin-mobius-socket', function () {
           mockSocket = {
             open: _sinon.default.stub().returns(_promise.default.resolve())
           };
-          prepareUrlStub = _sinon.default.stub(mobiusSocket, '_prepareUrl').returns(_promise.default.resolve('ws://example.com'));
+          prepareUrlStub = _sinon.default.stub(mobiusSocket, 'prepareUrl').returns(_promise.default.resolve('ws://example.com'));
           getUserTokenStub = webex.credentials.getUserToken;
           getUserTokenStub.returns(_promise.default.resolve({
             toString: function toString() {
@@ -1758,29 +1478,29 @@ describe('plugin-mobius-socket', function () {
         afterEach(function () {
           prepareUrlStub.restore();
         });
-        it('should prepare URL and get user token', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee17() {
-          return _regenerator.default.wrap(function (_context17) {
-            while (1) switch (_context17.prev = _context17.next) {
+        it('should prepare URL and get user token', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee16() {
+          return _regenerator.default.wrap(function (_context16) {
+            while (1) switch (_context16.prev = _context16.next) {
               case 0:
-                _context17.next = 1;
-                return mobiusSocket._prepareAndOpenSocket(mockSocket, 'ws://test.com', false);
+                _context16.next = 1;
+                return mobiusSocket.prepareAndOpenSocket(mockSocket, 'ws://test.com', false);
               case 1:
                 _testHelperChai.assert.calledOnce(prepareUrlStub);
                 _testHelperChai.assert.calledWith(prepareUrlStub, 'ws://test.com');
                 _testHelperChai.assert.calledOnce(getUserTokenStub);
               case 2:
               case "end":
-                return _context17.stop();
+                return _context16.stop();
             }
-          }, _callee17);
+          }, _callee16);
         })));
-        it('should open socket with correct options for normal connection', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee18() {
+        it('should open socket with correct options for normal connection', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee17() {
           var callArgs;
-          return _regenerator.default.wrap(function (_context18) {
-            while (1) switch (_context18.prev = _context18.next) {
+          return _regenerator.default.wrap(function (_context17) {
+            while (1) switch (_context17.prev = _context17.next) {
               case 0:
-                _context18.next = 1;
-                return mobiusSocket._prepareAndOpenSocket(mockSocket, undefined, false);
+                _context17.next = 1;
+                return mobiusSocket.prepareAndOpenSocket(mockSocket, undefined, false);
               case 1:
                 _testHelperChai.assert.calledOnce(mockSocket.open);
                 callArgs = mockSocket.open.firstCall.args;
@@ -1791,212 +1511,218 @@ describe('plugin-mobius-socket', function () {
                 _testHelperChai.assert.isDefined(callArgs[1].wssResponseTimeout);
               case 2:
               case "end":
-                return _context18.stop();
+                return _context17.stop();
             }
-          }, _callee18);
+          }, _callee17);
         })));
-        it('should log with correct prefix for normal connection', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee19() {
-          return _regenerator.default.wrap(function (_context19) {
-            while (1) switch (_context19.prev = _context19.next) {
+        it('should log with correct prefix for normal connection', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee18() {
+          return _regenerator.default.wrap(function (_context18) {
+            while (1) switch (_context18.prev = _context18.next) {
               case 0:
-                _context19.next = 1;
-                return mobiusSocket._prepareAndOpenSocket(mockSocket, undefined, false);
+                _context18.next = 1;
+                return mobiusSocket.prepareAndOpenSocket(mockSocket, undefined, false);
               case 1:
                 // The method should complete successfully - we're testing it runs without error
                 // Actual log message verification is complex due to existing stubs in parent scope
                 _testHelperChai.assert.calledOnce(mockSocket.open);
               case 2:
               case "end":
-                return _context19.stop();
+                return _context18.stop();
             }
-          }, _callee19);
+          }, _callee18);
         })));
-        it('should log with shutdown prefix for shutdown connection', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee20() {
-          return _regenerator.default.wrap(function (_context20) {
-            while (1) switch (_context20.prev = _context20.next) {
+        it('should log with shutdown prefix for shutdown connection', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee19() {
+          return _regenerator.default.wrap(function (_context19) {
+            while (1) switch (_context19.prev = _context19.next) {
               case 0:
-                _context20.next = 1;
-                return mobiusSocket._prepareAndOpenSocket(mockSocket, undefined, true);
+                _context19.next = 1;
+                return mobiusSocket.prepareAndOpenSocket(mockSocket, undefined, true);
               case 1:
                 // The method should complete successfully with shutdown flag
                 _testHelperChai.assert.calledOnce(mockSocket.open);
               case 2:
               case "end":
-                return _context20.stop();
+                return _context19.stop();
             }
-          }, _callee20);
+          }, _callee19);
         })));
-        it('should merge custom mobiusSocket options when provided', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee21() {
+        it('should merge custom mobiusSocket options when provided', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee20() {
           var callArgs;
-          return _regenerator.default.wrap(function (_context21) {
-            while (1) switch (_context21.prev = _context21.next) {
+          return _regenerator.default.wrap(function (_context20) {
+            while (1) switch (_context20.prev = _context20.next) {
               case 0:
                 webex.config.defaultMobiusSocketOptions = {
                   customOption: 'test-value',
                   wssResponseTimeout: 99999
                 };
-                _context21.next = 1;
-                return mobiusSocket._prepareAndOpenSocket(mockSocket, undefined, false);
+                _context20.next = 1;
+                return mobiusSocket.prepareAndOpenSocket(mockSocket, undefined, false);
               case 1:
                 callArgs = mockSocket.open.firstCall.args;
                 _testHelperChai.assert.equal(callArgs[1].customOption, 'test-value');
                 _testHelperChai.assert.equal(callArgs[1].wssResponseTimeout, 99999); // Custom value overrides default
               case 2:
               case "end":
-                return _context21.stop();
+                return _context20.stop();
             }
-          }, _callee21);
+          }, _callee20);
         })));
-        it('should return the webSocketUrl after opening', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee22() {
+        it('should return the webSocketUrl after opening', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee21() {
           var result;
-          return _regenerator.default.wrap(function (_context22) {
-            while (1) switch (_context22.prev = _context22.next) {
+          return _regenerator.default.wrap(function (_context21) {
+            while (1) switch (_context21.prev = _context21.next) {
               case 0:
-                _context22.next = 1;
-                return mobiusSocket._prepareAndOpenSocket(mockSocket, undefined, false);
+                _context21.next = 1;
+                return mobiusSocket.prepareAndOpenSocket(mockSocket, undefined, false);
               case 1:
-                result = _context22.sent;
+                result = _context21.sent;
                 _testHelperChai.assert.equal(result, 'ws://example.com');
               case 2:
               case "end":
-                return _context22.stop();
+                return _context21.stop();
             }
-          }, _callee22);
+          }, _callee21);
         })));
-        it('should handle errors during socket open', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee23() {
+        it('should handle errors during socket open', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee22() {
           var _t2;
-          return _regenerator.default.wrap(function (_context23) {
-            while (1) switch (_context23.prev = _context23.next) {
+          return _regenerator.default.wrap(function (_context22) {
+            while (1) switch (_context22.prev = _context22.next) {
               case 0:
                 mockSocket.open.returns(_promise.default.reject(new Error('Open failed')));
-                _context23.prev = 1;
-                _context23.next = 2;
-                return mobiusSocket._prepareAndOpenSocket(mockSocket, undefined, false);
+                _context22.prev = 1;
+                _context22.next = 2;
+                return mobiusSocket.prepareAndOpenSocket(mockSocket, undefined, false);
               case 2:
                 _testHelperChai.assert.fail('Should have thrown an error');
-                _context23.next = 4;
+                _context22.next = 4;
                 break;
               case 3:
-                _context23.prev = 3;
-                _t2 = _context23["catch"](1);
+                _context22.prev = 3;
+                _t2 = _context22["catch"](1);
                 _testHelperChai.assert.equal(_t2.message, 'Open failed');
               case 4:
               case "end":
-                return _context23.stop();
+                return _context22.stop();
             }
-          }, _callee23, null, [[1, 3]]);
+          }, _callee22, null, [[1, 3]]);
         })));
       });
       describe('#_attemptConnection() with shutdown switchover', function () {
         var prepareAndOpenSocketStub;
         var callback;
-        var sessionId = 'mobius-websocket-session';
         beforeEach(function () {
-          prepareAndOpenSocketStub = _sinon.default.stub(mobiusSocket, '_prepareAndOpenSocket').returns(_promise.default.resolve('ws://new-socket.com'));
+          prepareAndOpenSocketStub = _sinon.default.stub(mobiusSocket, 'prepareAndOpenSocket').returns(_promise.default.resolve('ws://new-socket.com'));
           callback = _sinon.default.stub();
-          mobiusSocket._shutdownSwitchoverBackoffCalls.set(sessionId, {
+          mobiusSocket.shutdownSwitchoverBackoffCall = {
             abort: _sinon.default.stub()
-          });
+          };
           mobiusSocket.socket = {
             url: 'ws://test.com'
           };
           mobiusSocket.connected = true;
-          _sinon.default.stub(mobiusSocket, '_emit');
-          _sinon.default.stub(mobiusSocket, '_attachSocketEventListeners');
+          _sinon.default.stub(mobiusSocket, 'emitEvent');
+          _sinon.default.stub(mobiusSocket, 'attachSocketEventListeners');
         });
         afterEach(function () {
           prepareAndOpenSocketStub.restore();
-          mobiusSocket._emit.restore();
-          mobiusSocket._attachSocketEventListeners.restore();
-          mobiusSocket._shutdownSwitchoverBackoffCalls.clear();
+          mobiusSocket.emitEvent.restore();
+          mobiusSocket.attachSocketEventListeners.restore();
+          mobiusSocket.shutdownSwitchoverBackoffCall = undefined;
         });
-        it('should not set socket reference before opening for shutdown switchover', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee24() {
+        it('should not set socket reference before opening for shutdown switchover', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee23() {
           var originalSocket;
-          return _regenerator.default.wrap(function (_context24) {
-            while (1) switch (_context24.prev = _context24.next) {
+          return _regenerator.default.wrap(function (_context23) {
+            while (1) switch (_context23.prev = _context23.next) {
               case 0:
                 originalSocket = mobiusSocket.socket;
-                _context24.next = 1;
-                return mobiusSocket._attemptConnection('ws://test.com', sessionId, callback, {
+                _context23.next = 1;
+                return mobiusSocket.attemptConnection('ws://test.com', callback, {
                   isShutdownSwitchover: true,
-                  onSuccess: function onSuccess(newSocket, url) {
-                    _testHelperChai.assert.exists(newSocket);
-                    _testHelperChai.assert.equal(url, 'ws://test.com');
-                    _testHelperChai.assert.equal(mobiusSocket.socket, originalSocket);
+                  attemptOptions: {
+                    onSuccess: function onSuccess(newSocket, url) {
+                      _testHelperChai.assert.exists(newSocket);
+                      _testHelperChai.assert.equal(url, 'ws://new-socket.com');
+                    }
                   }
                 });
               case 1:
+                // During shutdown switchover, this.socket should remain the old socket
                 _testHelperChai.assert.equal(mobiusSocket.socket, originalSocket);
               case 2:
               case "end":
-                return _context24.stop();
+                return _context23.stop();
             }
-          }, _callee24);
+          }, _callee23);
         })));
-        it('should call onSuccess callback with new socket and URL for shutdown', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee25() {
+        it('should call onSuccess callback with new socket and URL for shutdown', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee24() {
           var onSuccessStub;
-          return _regenerator.default.wrap(function (_context25) {
-            while (1) switch (_context25.prev = _context25.next) {
+          return _regenerator.default.wrap(function (_context24) {
+            while (1) switch (_context24.prev = _context24.next) {
               case 0:
                 onSuccessStub = _sinon.default.stub();
-                _context25.next = 1;
-                return mobiusSocket._attemptConnection('ws://test.com', sessionId, callback, {
+                _context24.next = 1;
+                return mobiusSocket.attemptConnection('ws://test.com', callback, {
                   isShutdownSwitchover: true,
-                  onSuccess: onSuccessStub
+                  attemptOptions: {
+                    onSuccess: onSuccessStub
+                  }
                 });
               case 1:
                 _testHelperChai.assert.calledOnce(onSuccessStub);
                 _testHelperChai.assert.equal(onSuccessStub.firstCall.args[1], 'ws://new-socket.com');
               case 2:
               case "end":
-                return _context25.stop();
+                return _context24.stop();
             }
-          }, _callee25);
+          }, _callee24);
         })));
-        it('should emit shutdown switchover complete event', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee26() {
-          return _regenerator.default.wrap(function (_context26) {
-            while (1) switch (_context26.prev = _context26.next) {
+        it('should emit shutdown switchover complete event', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee25() {
+          return _regenerator.default.wrap(function (_context25) {
+            while (1) switch (_context25.prev = _context25.next) {
               case 0:
-                _context26.next = 1;
-                return mobiusSocket._attemptConnection('ws://test.com', sessionId, callback, {
+                _context25.next = 1;
+                return mobiusSocket.attemptConnection('ws://test.com', callback, {
                   isShutdownSwitchover: true,
-                  onSuccess: function onSuccess(newSocket, url) {
-                    mobiusSocket.socket = newSocket;
-                    mobiusSocket.connected = true;
-                    mobiusSocket._emit(sessionId, 'event:mercury_shutdown_switchover_complete', {
-                      url: url
-                    });
+                  attemptOptions: {
+                    onSuccess: function onSuccess(newSocket, url) {
+                      mobiusSocket.socket = newSocket;
+                      mobiusSocket.connected = true;
+                      mobiusSocket.emitEvent('event:mobius_shutdown_switchover_complete', {
+                        url: url
+                      });
+                    }
                   }
                 });
               case 1:
-                _testHelperChai.assert.calledWith(mobiusSocket._emit, sessionId, 'event:mercury_shutdown_switchover_complete', _sinon.default.match.has('url', 'ws://new-socket.com'));
+                _testHelperChai.assert.calledWith(mobiusSocket.emitEvent, 'event:mobius_shutdown_switchover_complete', _sinon.default.match.has('url', 'ws://new-socket.com'));
               case 2:
               case "end":
-                return _context26.stop();
+                return _context25.stop();
             }
-          }, _callee26);
+          }, _callee25);
         })));
-        it('should use simpler error handling for shutdown switchover failures', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee27() {
-          return _regenerator.default.wrap(function (_context27) {
-            while (1) switch (_context27.prev = _context27.next) {
+        it('should use simpler error handling for shutdown switchover failures', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee26() {
+          return _regenerator.default.wrap(function (_context26) {
+            while (1) switch (_context26.prev = _context26.next) {
               case 0:
                 prepareAndOpenSocketStub.returns(_promise.default.reject(new Error('Connection failed')));
-                _context27.next = 1;
-                return mobiusSocket._attemptConnection('ws://test.com', sessionId, callback, {
-                  isShutdownSwitchover: true
+                _context26.next = 1;
+                return mobiusSocket.attemptConnection('ws://test.com', callback, {
+                  isShutdownSwitchover: true,
+                  attemptOptions: {}
                 }).catch(function () {});
               case 1:
                 _testHelperChai.assert.calledOnce(callback);
                 _testHelperChai.assert.instanceOf(callback.firstCall.args[0], Error);
               case 2:
               case "end":
-                return _context27.stop();
+                return _context26.stop();
             }
-          }, _callee27);
+          }, _callee26);
         })));
-        it('should check _shutdownSwitchoverBackoffCall for shutdown connections', function () {
-          mobiusSocket._shutdownSwitchoverBackoffCalls.clear();
-          var result = mobiusSocket._attemptConnection('ws://test.com', sessionId, callback, {
+        it('should check shutdownSwitchoverBackoffCall for shutdown connections', function () {
+          mobiusSocket.shutdownSwitchoverBackoffCall = undefined;
+          var result = mobiusSocket.attemptConnection('ws://test.com', callback, {
             isShutdownSwitchover: true
           });
           return result.catch(function (err) {
@@ -2006,20 +1732,19 @@ describe('plugin-mobius-socket', function () {
         });
       });
       describe('#_connectWithBackoff() with shutdown switchover', function () {
-        var sessionId = 'mobius-websocket-session';
         it('should use shutdown-specific parameters when called', function () {
-          var connectWithBackoffStub = _sinon.default.stub(mobiusSocket, '_connectWithBackoff').returns(_promise.default.resolve());
-          mobiusSocket._handleImminentShutdown(sessionId);
+          var connectWithBackoffStub = _sinon.default.stub(mobiusSocket, 'connectWithBackoff').returns(_promise.default.resolve());
+          mobiusSocket.handleImminentShutdown();
           _testHelperChai.assert.calledOnce(connectWithBackoffStub);
           var callArgs = connectWithBackoffStub.firstCall.args;
-          _testHelperChai.assert.equal(callArgs[1], sessionId);
-          _testHelperChai.assert.isObject(callArgs[2]);
-          _testHelperChai.assert.isTrue(callArgs[2].isShutdownSwitchover);
+          _testHelperChai.assert.isUndefined(callArgs[0]); // webSocketUrl
+          _testHelperChai.assert.isObject(callArgs[1]);
+          _testHelperChai.assert.isTrue(callArgs[1].isShutdownSwitchover);
           connectWithBackoffStub.restore();
         });
         it('should pass shutdown switchover options to _attemptConnection', function () {
-          var attemptStub = _sinon.default.stub(mobiusSocket, '_attemptConnection');
-          attemptStub.callsFake(function (url, sid, cb) {
+          var attemptStub = _sinon.default.stub(mobiusSocket, 'attemptConnection');
+          attemptStub.callsFake(function (url, cb) {
             return cb();
           });
           var context = {
@@ -2029,24 +1754,23 @@ describe('plugin-mobius-socket', function () {
               onSuccess: function onSuccess() {}
             }
           };
-          var promise = mobiusSocket._connectWithBackoff(undefined, sessionId, context);
+          var promise = mobiusSocket.connectWithBackoff(undefined, context);
           return promise.then(function () {
             _testHelperChai.assert.calledOnce(attemptStub);
             var callArgs = attemptStub.firstCall.args;
-            _testHelperChai.assert.equal(callArgs[1], sessionId);
-            _testHelperChai.assert.isObject(callArgs[3]);
-            _testHelperChai.assert.isTrue(callArgs[3].isShutdownSwitchover);
+            _testHelperChai.assert.isObject(callArgs[2]);
+            _testHelperChai.assert.isTrue(callArgs[2].isShutdownSwitchover);
             attemptStub.restore();
           });
         });
         it('should set and clear state flags appropriately', function () {
-          _sinon.default.stub(mobiusSocket, '_attemptConnection').callsFake(function (url, sid, cb) {
+          _sinon.default.stub(mobiusSocket, 'attemptConnection').callsFake(function (url, cb) {
             return cb();
           });
-          mobiusSocket._shutdownSwitchoverBackoffCalls.set(sessionId, {
+          mobiusSocket.shutdownSwitchoverBackoffCall = {
             placeholder: true
-          });
-          var promise = mobiusSocket._connectWithBackoff(undefined, sessionId, {
+          };
+          var promise = mobiusSocket.connectWithBackoff(undefined, {
             isShutdownSwitchover: true,
             attemptOptions: {
               isShutdownSwitchover: true,
@@ -2054,53 +1778,53 @@ describe('plugin-mobius-socket', function () {
             }
           });
           return promise.then(function () {
-            _testHelperChai.assert.isUndefined(mobiusSocket._shutdownSwitchoverBackoffCalls.get(sessionId));
-            mobiusSocket._attemptConnection.restore();
+            _testHelperChai.assert.isUndefined(mobiusSocket.shutdownSwitchoverBackoffCall);
+            mobiusSocket.attemptConnection.restore();
           });
         });
       });
       describe('#disconnect() with shutdown switchover in progress', function () {
         var abortStub;
-        var sessionId = 'mobius-websocket-session';
         beforeEach(function () {
-          mobiusSocket.sockets.clear();
-          mobiusSocket.sockets.set(sessionId, {
+          mobiusSocket.socket = {
             close: _sinon.default.stub().returns(_promise.default.resolve()),
-            removeAllListeners: _sinon.default.stub()
-          });
+            removeAllListeners: _sinon.default.stub(),
+            connecting: false,
+            connected: true
+          };
           abortStub = _sinon.default.stub();
-          mobiusSocket._shutdownSwitchoverBackoffCalls.set(sessionId, {
+          mobiusSocket.shutdownSwitchoverBackoffCall = {
             abort: abortStub
-          });
+          };
         });
-        it('should abort shutdown switchover backoff call on disconnect', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee28() {
-          return _regenerator.default.wrap(function (_context28) {
-            while (1) switch (_context28.prev = _context28.next) {
+        it('should abort shutdown switchover backoff call on disconnect', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee27() {
+          return _regenerator.default.wrap(function (_context27) {
+            while (1) switch (_context27.prev = _context27.next) {
               case 0:
-                _context28.next = 1;
-                return mobiusSocket.disconnect(undefined, sessionId);
+                _context27.next = 1;
+                return mobiusSocket.disconnect();
               case 1:
                 _testHelperChai.assert.calledOnce(abortStub);
               case 2:
               case "end":
-                return _context28.stop();
+                return _context27.stop();
             }
-          }, _callee28);
+          }, _callee27);
         })));
-        it('should handle disconnect when no switchover is in progress', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee29() {
-          return _regenerator.default.wrap(function (_context29) {
-            while (1) switch (_context29.prev = _context29.next) {
+        it('should handle disconnect when no switchover is in progress', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee28() {
+          return _regenerator.default.wrap(function (_context28) {
+            while (1) switch (_context28.prev = _context28.next) {
               case 0:
-                mobiusSocket._shutdownSwitchoverBackoffCalls.clear();
-                _context29.next = 1;
-                return mobiusSocket.disconnect(undefined, sessionId);
+                mobiusSocket.shutdownSwitchoverBackoffCall = undefined;
+                _context28.next = 1;
+                return mobiusSocket.disconnect();
               case 1:
-                _testHelperChai.assert.calledOnce(mobiusSocket.sockets.get(sessionId).close);
+                _testHelperChai.assert.calledOnce(mobiusSocket.socket.close);
               case 2:
               case "end":
-                return _context29.stop();
+                return _context28.stop();
             }
-          }, _callee29);
+          }, _callee28);
         })));
       });
     });