@webex/plugin-meetings 3.12.0-next.6 → 3.12.0-next.61

package/test/unit/spec/locus-info/index.js

@@ -13,6 +13,7 @@ import MediaSharesUtils from '@webex/plugin-meetings/src/locus-info//mediaShares
 import LocusDeltaParser from '@webex/plugin-meetings/src/locus-info/parser';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 import * as HashTreeParserModule from '@webex/plugin-meetings/src/hashTree/hashTreeParser';
+import MeetingsUtil from '@webex/plugin-meetings/src/meetings/util';
 
 import {
   LOCUSINFO,
@@ -220,6 +221,47 @@ describe('plugin-meetings', () => {
         assert.isTrue(locusInfo.emitChange);
       });
 
+      it('calls onLocusSynced callback passed as second argument with full locus from join response', async () => {
+        const syncedLocus = {url: 'http://locus-url.com', participants: []};
+        const onLocusSynced = sinon.stub();
+
+        await locusInfo.initialSetup(
+          {
+            trigger: 'join-response',
+            locus: syncedLocus,
+          },
+          onLocusSynced
+        );
+
+        assert.calledOnceWithExactly(onLocusSynced, syncedLocus);
+      });
+
+      it('swallows onLocusSynced callback errors and logs warn', async () => {
+        const syncedLocus = {url: 'http://locus-url.com', participants: []};
+        const callbackError = new Error('onLocusSynced failed');
+        const onLocusSynced = sinon.stub().throws(callbackError);
+        const loggerWarnStub = LoggerProxy.logger.warn?.isSinonProxy
+          ? LoggerProxy.logger.warn
+          : sinon.stub(LoggerProxy.logger, 'warn');
+
+        loggerWarnStub.resetHistory();
+
+        await locusInfo.initialSetup(
+          {
+            trigger: 'join-response',
+            locus: syncedLocus,
+          },
+          onLocusSynced
+        );
+
+        assert.calledOnceWithExactly(onLocusSynced, syncedLocus);
+        assert.calledOnce(loggerWarnStub);
+        assert.match(
+          loggerWarnStub.firstCall.args[0],
+          /Locus-info:index#initialSetup --> onLocusSynced callback failed/
+        );
+      });
+
       it('should initialize the hash tree parser correctly when triggered from a get loci response containing visible datasets', async () => {
         const visibleDataSets = ['dataset1', 'dataset2'];
         const locus = createLocusWithVisibleDataSets(visibleDataSets);
@@ -290,6 +332,7 @@ describe('plugin-meetings', () => {
       describe('should setup correct locusInfoUpdateCallback when creating HashTreeParser', () => {
         const OBJECTS_UPDATED = HashTreeParserModule.LocusInfoUpdateType.OBJECTS_UPDATED;
         const MEETING_ENDED = HashTreeParserModule.LocusInfoUpdateType.MEETING_ENDED;
+        const LOCUS_NOT_FOUND = HashTreeParserModule.LocusInfoUpdateType.LOCUS_NOT_FOUND;
 
         let locusInfoUpdateCallback;
         let onDeltaLocusStub;
@@ -413,7 +456,7 @@ describe('plugin-meetings', () => {
           };
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [{htMeta: {elementId: {type: 'self'}}, data: newSelf}],
           });
 
@@ -440,7 +483,7 @@ describe('plugin-meetings', () => {
           locusInfo.info.isWebinar = true;
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [{htMeta: {elementId: {type: 'self'}}, data: newSelf}],
           });
 
@@ -473,7 +516,7 @@ describe('plugin-meetings', () => {
           locusInfo.info.isWebinar = true;
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [{htMeta: {elementId: {type: 'self'}}, data: newSelf}],
           });
 
@@ -501,7 +544,7 @@ describe('plugin-meetings', () => {
           };
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [{htMeta: {elementId: {type: 'fullState'}}, data: newFullState}],
           });
 
@@ -519,7 +562,7 @@ describe('plugin-meetings', () => {
           };
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [{htMeta: {elementId: {type: 'info'}}, data: newInfo}],
           });
 
@@ -537,7 +580,7 @@ describe('plugin-meetings', () => {
           };
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [{htMeta: {elementId: {type: 'links'}}, data: newLinks}],
           });
 
@@ -557,7 +600,7 @@ describe('plugin-meetings', () => {
           };
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [{htMeta: newLocusHtMeta, data: newLocus}],
           });
 
@@ -590,7 +633,7 @@ describe('plugin-meetings', () => {
           };
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               {
                 htMeta: newLocusHtMeta,
@@ -637,7 +680,7 @@ describe('plugin-meetings', () => {
           };
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               // first, a removal of LOCUS object
               {htMeta: {elementId: {type: 'locus'}}, data: null},
@@ -671,7 +714,7 @@ describe('plugin-meetings', () => {
           const newLocusHtMeta = {elementId: {type: 'locus', version: 99}};
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               // first, an update
               {htMeta: newLocusHtMeta, data: newLocus},
@@ -700,7 +743,7 @@ describe('plugin-meetings', () => {
           };
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               // first, an update
               {htMeta: {elementId: {type: 'locus'}}, data: newLocus1},
@@ -730,7 +773,7 @@ describe('plugin-meetings', () => {
           };
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
           // with 1 participant added, 1 updated, and 1 removed
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               {htMeta: {elementId: {type: 'participant', id: 'fake-ht-participant-1'}}, data: null},
               {
@@ -774,7 +817,7 @@ describe('plugin-meetings', () => {
           };
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
           // with 1 participant added, 1 updated, and 1 removed
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               {htMeta: {elementId: {type: 'mediashare', id: 'fake-ht-mediaShare-1'}}, data: null},
               {
@@ -807,7 +850,7 @@ describe('plugin-meetings', () => {
           };
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
           // with 1 embedded app added, 1 updated, and 1 removed
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               {htMeta: {elementId: {type: 'embeddedapp', id: 'fake-ht-embeddedApp-1'}}, data: null},
               {
@@ -844,7 +887,7 @@ describe('plugin-meetings', () => {
           };
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               {
                 htMeta: {elementId: {type: 'mediashare', id: 'fake-ht-mediaShare-2'}},
@@ -883,7 +926,7 @@ describe('plugin-meetings', () => {
           };
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               {
                 htMeta: {elementId: {type: 'controlentry', id: 'control-1'}},
@@ -911,7 +954,7 @@ describe('plugin-meetings', () => {
 
         it('should process locus update correctly when CONTROL object is received with no data', () => {
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               {
                 htMeta: {elementId: {type: 'controlentry', id: 'some-control-id'}},
@@ -935,7 +978,7 @@ describe('plugin-meetings', () => {
           const destroyStub = sinon.stub(locusInfo.webex.meetings, 'destroy');
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(MEETING_ENDED);
+          locusInfoUpdateCallback({updateType: MEETING_ENDED});
 
           assert.calledOnceWithExactly(collectionGetStub, locusInfo.meetingId);
           assert.calledOnceWithExactly(
@@ -953,17 +996,48 @@ describe('plugin-meetings', () => {
           const destroyStub = sinon.stub(locusInfo.webex.meetings, 'destroy');
 
           // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(MEETING_ENDED);
+          locusInfoUpdateCallback({updateType: MEETING_ENDED});
 
           assert.calledOnceWithExactly(collectionGetStub, locusInfo.meetingId);
           assert.notCalled(destroyStub);
         });
 
+        it('should handle LOCUS_NOT_FOUND by calling syncMeetings with skipHashTreeSync', () => {
+          const syncMeetingsStub = sinon.stub(locusInfo.webex.meetings, 'syncMeetings').resolves();
+
+          locusInfoUpdateCallback({updateType: LOCUS_NOT_FOUND});
+
+          assert.calledOnceWithExactly(syncMeetingsStub, {keepOnlyLocusMeetings: false, skipHashTreeSync: true});
+        });
+
+        it('should handle LOCUS_NOT_FOUND and log error if syncMeetings fails', async () => {
+          const syncError = new Error('sync failed');
+          const syncMeetingsStub = sinon.stub(locusInfo.webex.meetings, 'syncMeetings').rejects(syncError);
+          const logErrorStub = LoggerProxy.logger.error?.isSinonProxy
+            ? LoggerProxy.logger.error
+            : sinon.stub(LoggerProxy.logger, 'error');
+
+          logErrorStub.resetHistory();
+
+          locusInfoUpdateCallback({updateType: LOCUS_NOT_FOUND});
+
+          assert.calledOnceWithExactly(syncMeetingsStub, {keepOnlyLocusMeetings: false, skipHashTreeSync: true});
+
+          // wait for the promise rejection to be handled
+          await testUtils.flushPromises();
+
+          assert.calledOnce(logErrorStub);
+          assert.match(
+            logErrorStub.firstCall.args[0],
+            /syncMeetings failed after LOCUS_NOT_FOUND/
+          );
+        });
+
         it('should set forceReplaceMembers to true on the first update for a locusUrl (initializedFromHashTree is false)', () => {
           const createdHashTreeParser = locusInfo.hashTreeParsers.get('fake-locus-url');
           createdHashTreeParser.initializedFromHashTree = false;
 
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               {
                 htMeta: {elementId: {type: 'self'}},
@@ -978,7 +1052,7 @@ describe('plugin-meetings', () => {
         });
 
         it('should set forceReplaceMembers to false on subsequent updates (initializedFromHashTree is true)', () => {
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               {
                 htMeta: {elementId: {type: 'self'}},
@@ -994,7 +1068,7 @@ describe('plugin-meetings', () => {
         it('should copy participant data to self when participant matches self identity and state is LEFT with reason MOVED', () => {
           locusInfo.self = {id: 'fake-self', identity: 'user-123'};
 
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+          locusInfoUpdateCallback({updateType: OBJECTS_UPDATED,
             updatedObjects: [
               {
                 htMeta: {elementId: {type: 'participant', id: 99}},
@@ -1289,6 +1363,8 @@ describe('plugin-meetings', () => {
             state: RECORDING_STATE.IDLE,
             modifiedBy: 'George Kittle',
             lastModified: 'TODAY',
+            modifiedByServiceAppName: undefined,
+            modifiedByServiceAppId: undefined,
           }
         );
       });
@@ -1323,6 +1399,8 @@ describe('plugin-meetings', () => {
             state: RECORDING_STATE.RECORDING,
             modifiedBy: 'George Kittle',
             lastModified: 'TODAY',
+            modifiedByServiceAppName: undefined,
+            modifiedByServiceAppId: undefined,
           }
         );
       });
@@ -1358,6 +1436,8 @@ describe('plugin-meetings', () => {
             state: RECORDING_STATE.PAUSED,
             modifiedBy: 'George Kittle',
             lastModified: 'TODAY',
+            modifiedByServiceAppName: undefined,
+            modifiedByServiceAppId: undefined,
           }
         );
       });
@@ -1394,6 +1474,8 @@ describe('plugin-meetings', () => {
             state: RECORDING_STATE.RESUMED,
             modifiedBy: 'George Kittle',
             lastModified: 'TODAY',
+            modifiedByServiceAppName: undefined,
+            modifiedByServiceAppId: undefined,
           }
         );
       });
@@ -1429,6 +1511,44 @@ describe('plugin-meetings', () => {
             state: RECORDING_STATE.IDLE,
             modifiedBy: 'George Kittle',
             lastModified: 'TODAY',
+            modifiedByServiceAppName: undefined,
+            modifiedByServiceAppId: undefined,
+          }
+        );
+      });
+
+      it('should include service app fields in the recording event when present', () => {
+        locusInfo.controls = {
+          record: {
+            recording: false,
+            paused: false,
+            meta: {
+              lastModified: 'TODAY',
+              modifiedBy: 'George Kittle',
+            },
+          },
+          shareControl: {},
+          transcribe: {},
+        };
+        newControls.record.recording = true;
+        newControls.record.meta.modifiedByServiceAppName = 'My Bot';
+        newControls.record.meta.modifiedByServiceAppId = 'app-id-123';
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.CONTROLS_RECORDING_UPDATED,
+          {
+            state: RECORDING_STATE.RECORDING,
+            modifiedBy: 'George Kittle',
+            lastModified: 'TODAY',
+            modifiedByServiceAppName: 'My Bot',
+            modifiedByServiceAppId: 'app-id-123',
           }
         );
       });
@@ -2024,7 +2144,7 @@ describe('plugin-meetings', () => {
             function: 'updateSelf',
           },
           LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED,
-          {muted: true, unmuteAllowed: true}
+          {muted: true, unmuteAllowed: true, modifiedBy: null}
         );
 
         // but sometimes "previous self" is defined, but without controls.audio.muted, so we test this here:
@@ -2039,7 +2159,7 @@ describe('plugin-meetings', () => {
             function: 'updateSelf',
           },
           LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED,
-          {muted: true, unmuteAllowed: true}
+          {muted: true, unmuteAllowed: true, modifiedBy: null}
         );
       });
 
@@ -2098,7 +2218,7 @@ describe('plugin-meetings', () => {
             function: 'updateSelf',
           },
           LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED,
-          {muted: true, unmuteAllowed: true}
+          {muted: true, unmuteAllowed: true, modifiedBy: null}
         );
       });
 
@@ -2237,7 +2357,7 @@ describe('plugin-meetings', () => {
             function: 'updateSelf',
           },
           LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED,
-          {muted: true, unmuteAllowed: false}
+          {muted: true, unmuteAllowed: false, modifiedBy: null}
         );
 
         // now change only disallowUnmute
@@ -2255,7 +2375,28 @@ describe('plugin-meetings', () => {
             function: 'updateSelf',
           },
           LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED,
-          {muted: true, unmuteAllowed: true}
+          {muted: true, unmuteAllowed: true, modifiedBy: null}
+        );
+      });
+
+      it('should include modifiedBy in payload when muted by host', () => {
+        locusInfo.webex.internal.device.url = self.deviceUrl;
+        locusInfo.updateSelf(self);
+        const newSelf = cloneDeep(self);
+        newSelf.controls.audio.muted = true;
+        newSelf.controls.audio.meta = {modifiedBy: 'host-uuid-123'};
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateSelf(newSelf);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED,
+          {muted: true, unmuteAllowed: true, modifiedBy: 'host-uuid-123'}
         );
       });
 
@@ -3154,13 +3295,14 @@ describe('plugin-meetings', () => {
       const createMockParser = (state = 'active') => ({
         state,
         stop: sinon.stub(),
-        resume: sinon.stub(),
+        resumeFromMessage: sinon.stub(),
         handleMessage: sinon.stub(),
       });
 
       const createSelfElementWithReplaces = (replacedLocusUrl, replacedAt) => ({
         htMeta: {elementId: {type: 'Self'}},
         data: {
+          deviceUrl,
           devices: [{url: deviceUrl, replaces: [{locusUrl: replacedLocusUrl, replacedAt}]}],
         },
       });
@@ -3236,7 +3378,7 @@ describe('plugin-meetings', () => {
           stateElementsMessage: message,
         });
 
-        assert.calledOnce(parserA.resume);
+        assert.calledOnce(parserA.resumeFromMessage);
         assert.calledOnce(parserB.stop);
       });
 
@@ -3259,7 +3401,7 @@ describe('plugin-meetings', () => {
           stateElementsMessage: message,
         });
 
-        assert.notCalled(parserA.resume);
+        assert.notCalled(parserA.resumeFromMessage);
         assert.notCalled(parserB.stop);
       });
 
@@ -3278,7 +3420,7 @@ describe('plugin-meetings', () => {
           stateElementsMessage: message,
         });
 
-        assert.notCalled(parserA.resume);
+        assert.notCalled(parserA.resumeFromMessage);
         assert.notCalled(parserA.handleMessage);
       });
 
@@ -3362,6 +3504,51 @@ describe('plugin-meetings', () => {
 
         assert.calledOnceWithExactly(parserA.handleMessage, message);
       });
+
+      it('should send mismatch metric when eventType is not HASH_TREE_DATA_UPDATED', () => {
+        const locusUrlA = 'http://locus-url-A.com';
+        const parserA = {state: 'active', handleMessage: sinon.stub()};
+        locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, initializedFromHashTree: true});
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.SELF_CHANGED,
+          stateElementsMessage: {locusUrl: locusUrlA, locusStateElements: [], dataSets: []},
+        });
+
+        assert.calledOnceWithExactly(
+          sendBehavioralMetricStub,
+          'js_sdk_locus_classic_vs_hash_tree_mismatch',
+          {
+            correlationId: mockMeeting.correlationId,
+            message: `got ${LOCUSEVENT.SELF_CHANGED}, expected ${LOCUSEVENT.HASH_TREE_DATA_UPDATED}`,
+          }
+        );
+        assert.notCalled(parserA.handleMessage);
+      });
+    });
+
+    describe('#sendClassicVsHashTreeMismatchMetric', () => {
+      it('should send the metric when called for the first time', () => {
+        locusInfo.sendClassicVsHashTreeMismatchMetric(mockMeeting, 'some mismatch');
+
+        assert.calledOnceWithExactly(
+          sendBehavioralMetricStub,
+          'js_sdk_locus_classic_vs_hash_tree_mismatch',
+          {
+            correlationId: mockMeeting.correlationId,
+            message: 'some mismatch',
+          }
+        );
+      });
+
+      it('should send the metric up to 5 times and stop after that', () => {
+        for (let i = 0; i < 7; i += 1) {
+          locusInfo.sendClassicVsHashTreeMismatchMetric(mockMeeting, `mismatch ${i}`);
+        }
+
+        assert.callCount(sendBehavioralMetricStub, 5);
+        assert.equal(locusInfo.classicVsHashTreeMismatchMetricCounter, 5);
+      });
     });
 
     describe('#handleLocusAPIResponse', () => {
@@ -3417,19 +3604,174 @@ describe('plugin-meetings', () => {
         assert.calledOnceWithExactly(locusInfo.handleLocusDelta, fakeLocus, mockMeeting);
       });
 
-      it('should send mismatch metric when hash tree parser exists but dataSets are missing in wrapped response', () => {
+      it('should send mismatch metric in classic mode when wrapped response has dataSets', () => {
         const fakeLocus = {url: 'http://locus-url.com'};
-        const mockHashTreeParser = {handleLocusUpdate: sinon.stub()};
-        locusInfo.hashTreeParsers.set(fakeLocus.url, {
-          parser: mockHashTreeParser,
-          initializedFromHashTree: true,
+        sinon.stub(locusInfo, 'handleLocusDelta');
+
+        locusInfo.handleLocusAPIResponse(mockMeeting, {
+          locus: fakeLocus,
+          dataSets: [{name: 'dataset1', url: 'test-url'}],
         });
-        sinon.stub(locusInfo, 'sendClassicVsHashTreeMismatchMetric');
 
-        locusInfo.handleLocusAPIResponse(mockMeeting, {locus: fakeLocus});
+        assert.calledOnceWithExactly(
+          sendBehavioralMetricStub,
+          'js_sdk_locus_classic_vs_hash_tree_mismatch',
+          {
+            correlationId: mockMeeting.correlationId,
+            message: 'unexpected hash tree dataSets in API response',
+          }
+        );
+        assert.calledOnce(locusInfo.handleLocusDelta);
+      });
 
-        assert.calledOnce(locusInfo.sendClassicVsHashTreeMismatchMetric);
-        assert.calledOnce(mockHashTreeParser.handleLocusUpdate);
+      describe('parser switch via API response', () => {
+        const deviceUrl = 'http://device-url.com';
+        const locusUrlA = 'http://locus-url-A.com';
+        const locusUrlB = 'http://locus-url-B.com';
+
+        let HashTreeParserStub;
+
+        const createMockApiParser = (state = 'active') => ({
+          state,
+          stop: sinon.stub(),
+          resumeFromApiResponse: sinon.stub(),
+          handleLocusUpdate: sinon.stub(),
+          initializeFromGetLociResponse: sinon.stub(),
+        });
+
+        const createLocusWithReplaces = (url, replacedLocusUrl, replacedAt) => ({
+          url,
+          self: {
+            devices: [{url: deviceUrl, replaces: [{locusUrl: replacedLocusUrl, replacedAt}]}],
+          },
+        });
+
+        const createLocusWithoutReplaces = (url) => ({
+          url,
+          self: {devices: [{url: deviceUrl}]},
+        });
+
+        beforeEach(() => {
+          locusInfo.webex.internal.device.url = deviceUrl;
+          HashTreeParserStub = sinon
+            .stub(HashTreeParserModule, 'default')
+            .returns(createMockApiParser());
+        });
+
+        it('should create a new parser and initialize it when no entry exists for the locusUrl', () => {
+          // existing parser for a different url so hashTreeParsers.size > 0
+          locusInfo.hashTreeParsers.set(locusUrlA, {parser: createMockApiParser(), initializedFromHashTree: true});
+
+          const locus = createLocusWithReplaces(locusUrlB, locusUrlA, '2026-01-01T00:00:00Z');
+          sinon.stub(locusInfo, 'handleLocusDelta');
+
+          locusInfo.handleLocusAPIResponse(mockMeeting, {locus});
+
+          assert.isTrue(locusInfo.hashTreeParsers.has(locusUrlB));
+          const newEntry = locusInfo.hashTreeParsers.get(locusUrlB);
+          assert.isFalse(newEntry.initializedFromHashTree);
+
+          // the stub returns the mock, so initializeFromGetLociResponse should be called on it
+          const createdParser = HashTreeParserStub.returnValues[0];
+          assert.calledOnceWithExactly(createdParser.initializeFromGetLociResponse, locus);
+          assert.notCalled(locusInfo.handleLocusDelta);
+        });
+
+        it('should reactivate a stopped parser when replaces info is newer', () => {
+          const parserA = createMockApiParser('stopped');
+          const parserB = createMockApiParser('active');
+          locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, replacedAt: '2026-01-01T00:00:00Z', initializedFromHashTree: true});
+          locusInfo.hashTreeParsers.set(locusUrlB, {parser: parserB, initializedFromHashTree: true});
+
+          const locus = createLocusWithReplaces(locusUrlA, locusUrlB, '2026-02-01T00:00:00Z');
+
+          locusInfo.handleLocusAPIResponse(mockMeeting, {locus});
+
+          assert.calledOnce(parserA.resumeFromApiResponse);
+          assert.calledWithExactly(parserA.resumeFromApiResponse, locus);
+          assert.calledOnce(parserB.stop);
+          assert.equal(locusInfo.hashTreeParsers.get(locusUrlB).replacedAt, '2026-02-01T00:00:00Z');
+          assert.isFalse(locusInfo.hashTreeParsers.get(locusUrlA).initializedFromHashTree);
+        });
+
+        it('should not reactivate a stopped parser when replaces info is not newer', () => {
+          const parserA = createMockApiParser('stopped');
+          const parserB = createMockApiParser('active');
+          locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, replacedAt: '2026-03-01T00:00:00Z', initializedFromHashTree: true});
+          locusInfo.hashTreeParsers.set(locusUrlB, {parser: parserB, initializedFromHashTree: true});
+
+          const locus = createLocusWithReplaces(locusUrlA, locusUrlB, '2026-01-01T00:00:00Z');
+
+          locusInfo.handleLocusAPIResponse(mockMeeting, {locus});
+
+          assert.notCalled(parserA.resumeFromApiResponse);
+          assert.notCalled(parserB.stop);
+        });
+
+        it('should not reactivate a stopped parser when no replaces info is available', () => {
+          const parserA = createMockApiParser('stopped');
+          locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, initializedFromHashTree: true});
+
+          const locus = createLocusWithoutReplaces(locusUrlA);
+
+          locusInfo.handleLocusAPIResponse(mockMeeting, {locus});
+
+          assert.notCalled(parserA.resumeFromApiResponse);
+        });
+      });
+    });
+
+    describe('#syncAllHashTreeDatasets', () => {
+      it('should call syncAllDatasets on each parser that has an entry', async () => {
+        const parser1 = {syncAllDatasets: sinon.stub().resolves()};
+        const parser2 = {syncAllDatasets: sinon.stub().resolves()};
+        locusInfo.hashTreeParsers.set('url1', {parser: parser1});
+        locusInfo.hashTreeParsers.set('url2', {parser: parser2});
+
+        await locusInfo.syncAllHashTreeDatasets();
+
+        assert.calledOnce(parser1.syncAllDatasets);
+        assert.calledOnce(parser2.syncAllDatasets);
+      });
+
+      it('should skip parser entries without a parser object', async () => {
+        const parser1 = {syncAllDatasets: sinon.stub().resolves()};
+        locusInfo.hashTreeParsers.set('url1', {parser: parser1});
+        locusInfo.hashTreeParsers.set('url2', {parser: undefined});
+
+        await locusInfo.syncAllHashTreeDatasets();
+
+        assert.calledOnce(parser1.syncAllDatasets);
+      });
+
+      it('should await each parsers syncAllDatasets sequentially', async () => {
+        const callOrder = [];
+        const parser1 = {syncAllDatasets: sinon.stub().callsFake(() => {
+          callOrder.push('start1');
+          return new Promise((resolve) => {
+            setTimeout(() => {
+              callOrder.push('end1');
+              resolve();
+            }, 100);
+          });
+        })};
+        const parser2 = {syncAllDatasets: sinon.stub().callsFake(() => {
+          callOrder.push('start2');
+          return Promise.resolve();
+        })};
+        locusInfo.hashTreeParsers.set('url1', {parser: parser1});
+        locusInfo.hashTreeParsers.set('url2', {parser: parser2});
+
+        const clock = sinon.useFakeTimers();
+        const promise = locusInfo.syncAllHashTreeDatasets();
+        // parser1 started but parser2 not yet
+        assert.deepEqual(callOrder, ['start1']);
+
+        await clock.tickAsync(100);
+        await promise;
+        // parser1 finished, then parser2 started and finished
+        assert.deepEqual(callOrder, ['start1', 'end1', 'start2']);
+        clock.restore();
       });
     });
 
@@ -3521,49 +3863,23 @@ describe('plugin-meetings', () => {
         assert.deepEqual(callOrder, ['updateLocusUrl', 'updateMeetingInfo']);
       });
 
-      it('#updateLocusInfo ignores breakout LEFT message', () => {
-        const newLocus = {
-          self: {
-            reason: 'MOVED',
-            state: 'LEFT',
-          },
-        };
+      it('#updateLocusInfo ignores locus when isSelfMovedOrBreakoutEnded returns true', () => {
+        const newLocus = {self: {state: 'JOINED'}};
+
+        sinon.stub(MeetingsUtil, 'isSelfMovedOrBreakoutEnded').returns(true);
 
         locusInfo.updateControls = sinon.stub();
-        locusInfo.updateConversationUrl = sinon.stub();
-        locusInfo.updateCreated = sinon.stub();
         locusInfo.updateFullState = sinon.stub();
-        locusInfo.updateHostInfo = sinon.stub();
-        locusInfo.updateMeetingInfo = sinon.stub();
-        locusInfo.updateMediaShares = sinon.stub();
-        locusInfo.updateReplaces = sinon.stub();
         locusInfo.updateSelf = sinon.stub();
-        locusInfo.updateLocusUrl = sinon.stub();
-        locusInfo.updateAclUrl = sinon.stub();
-        locusInfo.updateBasequence = sinon.stub();
-        locusInfo.updateSequence = sinon.stub();
-        locusInfo.updateEmbeddedApps = sinon.stub();
-        locusInfo.updateLinks = sinon.stub();
-        locusInfo.compareAndUpdate = sinon.stub();
 
         locusInfo.updateLocusInfo(newLocus);
 
+        assert.calledOnceWithExactly(MeetingsUtil.isSelfMovedOrBreakoutEnded, newLocus);
         assert.notCalled(locusInfo.updateControls);
-        assert.notCalled(locusInfo.updateConversationUrl);
-        assert.notCalled(locusInfo.updateCreated);
         assert.notCalled(locusInfo.updateFullState);
-        assert.notCalled(locusInfo.updateHostInfo);
-        assert.notCalled(locusInfo.updateMeetingInfo);
-        assert.notCalled(locusInfo.updateMediaShares);
-        assert.notCalled(locusInfo.updateReplaces);
         assert.notCalled(locusInfo.updateSelf);
-        assert.notCalled(locusInfo.updateLocusUrl);
-        assert.notCalled(locusInfo.updateAclUrl);
-        assert.notCalled(locusInfo.updateBasequence);
-        assert.notCalled(locusInfo.updateSequence);
-        assert.notCalled(locusInfo.updateEmbeddedApps);
-        assert.notCalled(locusInfo.updateLinks);
-        assert.notCalled(locusInfo.compareAndUpdate);
+
+        MeetingsUtil.isSelfMovedOrBreakoutEnded.restore();
       });
 
       it('#updateLocusInfo puts the Locus DTO top level properties at the right place in LocusInfo class', () => {
@@ -4413,6 +4729,31 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#cleanUp', () => {
+      it('calls cleanUp on all hash tree parsers and clears maps', () => {
+        const parser1 = {cleanUp: sinon.stub()};
+        const parser2 = {cleanUp: sinon.stub()};
+
+        locusInfo.hashTreeParsers.set('url1', {parser: parser1, initializedFromHashTree: true});
+        locusInfo.hashTreeParsers.set('url2', {parser: parser2, initializedFromHashTree: true});
+        locusInfo.hashTreeObjectId2ParticipantId.set(1, 'participant1');
+
+        locusInfo.cleanUp();
+
+        assert.calledOnce(parser1.cleanUp);
+        assert.calledOnce(parser2.cleanUp);
+        assert.equal(locusInfo.hashTreeParsers.size, 0);
+        assert.equal(locusInfo.hashTreeObjectId2ParticipantId.size, 0);
+      });
+
+      it('works when there are no hash tree parsers', () => {
+        locusInfo.cleanUp();
+
+        assert.equal(locusInfo.hashTreeParsers.size, 0);
+        assert.equal(locusInfo.hashTreeObjectId2ParticipantId.size, 0);
+      });
+    });
+
     describe('#handleOneonOneEvent', () => {
       beforeEach(() => {
         locusInfo.emitScoped = sinon.stub();
@@ -4455,6 +4796,9 @@ describe('plugin-meetings', () => {
     });
 
     describe('#isMeetingActive', () => {
+      beforeEach(() => {
+        webex.internal.newMetrics.submitClientEvent.resetHistory();
+      });
       forEach([_CALL_, _SIP_BRIDGE_, _SPACE_SHARE_], (type) => {
         describe(`type = ${type}`, () => {
           it('sends client event correctly for state = inactive', () => {
@@ -4521,7 +4865,7 @@ describe('plugin-meetings', () => {
         });
       });
 
-      it('sends client event correctly for state = MEETING_INACTIVE_TERMINATING', () => {
+      it('sends client event correctly for state = MEETING_INACTIVE', () => {
         locusInfo.getLocusPartner = sinon.stub().returns({state: MEETING_STATE.STATES.LEFT});
         locusInfo.parsedLocus = {
           fullState: {
@@ -4543,7 +4887,7 @@ describe('plugin-meetings', () => {
         });
       });
 
-      it('sends client event correctly for state = FULLSTATE_REMOVED', () => {
+      it('does not send client event when state = INACTIVE and endMeetingReason = BREAKOUT_ENDED', () => {
         locusInfo.getLocusPartner = sinon.stub().returns({state: MEETING_STATE.STATES.LEFT});
         locusInfo.parsedLocus = {
           fullState: {
@@ -4552,17 +4896,41 @@ describe('plugin-meetings', () => {
         };
 
         locusInfo.fullState = {
-          removed: true,
+          state: LOCUS.STATE.INACTIVE,
+          endMeetingReason: 'BREAKOUT_ENDED',
         };
 
         locusInfo.isMeetingActive();
 
-        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-          name: 'client.call.remote-ended',
-          options: {
-            meetingId: locusInfo.meetingId,
+        assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+      });
+
+      it('sends client event correctly for state self removed', () => {
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.parsedLocus = {
+          fullState: {
+            type: _MEETING_,
           },
-        });
+          self: {
+            removed: true,
+          }
+        };
+
+        locusInfo.isMeetingActive();
+
+        assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+        assert.calledOnceWithExactly(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'isMeetingActive',
+          },
+          EVENTS.DESTROY_MEETING,
+          {
+            reason: MEETING_REMOVED_REASON.SELF_REMOVED,
+            shouldLeave: false,
+          }
+        );
       });
     });
 
@@ -4954,6 +5322,31 @@ describe('plugin-meetings', () => {
         );
         assert.notCalled(getTheLocusToUpdateStub);
       });
+
+      it('should call handleLocusAPIResponse for SDK_LOCUS_FROM_SYNC_MEETINGS when hash tree parsers exist', () => {
+        const fakeLocusUrl = 'http://locus-url.com';
+        const fakeLocus = {url: fakeLocusUrl, fullState: {state: 'ACTIVE'}};
+        const mockHashTreeParser = {
+          handleMessage: sinon.stub(),
+          handleLocusUpdate: sinon.stub(),
+        };
+        locusInfo.hashTreeParsers.set(fakeLocusUrl, {
+          parser: mockHashTreeParser,
+          initializedFromHashTree: true,
+        });
+
+        sinon.stub(locusInfo, 'handleLocusDelta');
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.SDK_LOCUS_FROM_SYNC_MEETINGS,
+          locus: fakeLocus,
+        });
+
+        // should route through handleLocusAPIResponse which passes unwrapped LocusDTO to parser
+        assert.calledOnce(mockHashTreeParser.handleLocusUpdate);
+        assert.notCalled(mockHashTreeParser.handleMessage);
+        assert.notCalled(locusInfo.handleLocusDelta);
+      });
     });
   });
 
@@ -5146,6 +5539,7 @@ describe('plugin-meetings', () => {
       return {
         htMeta: {elementId: {type: 'Self'}},
         data: {
+          deviceUrl,
           devices,
         },
       };