@webex/plugin-meetings 3.11.0 → 3.12.0-next.2

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

@@ -5,7 +5,7 @@ import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import testUtils from '../../../utils/testUtils';
 import Meetings from '@webex/plugin-meetings';
-import LocusInfo from '@webex/plugin-meetings/src/locus-info';
+import LocusInfo, {createLocusFromHashTreeMessage, findMeetingForHashTreeMessage} from '@webex/plugin-meetings/src/locus-info';
 import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
 import InfoUtils from '@webex/plugin-meetings/src/locus-info/infoUtils';
 import EmbeddedAppsUtils from '@webex/plugin-meetings/src/locus-info/embeddedAppsUtils';
@@ -29,7 +29,8 @@ import {
 } from '../../../../src/constants';
 
 import {self, selfWithInactivity} from './selfConstant';
-import { MEETING_REMOVED_REASON } from '@webex/plugin-meetings/src/constants';
+import {MEETING_REMOVED_REASON} from '@webex/plugin-meetings/src/constants';
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 
 describe('plugin-meetings', () => {
   describe('LocusInfo index', () => {
@@ -104,9 +105,10 @@ describe('plugin-meetings', () => {
       });
 
       const createHashTreeMessage = (visibleDataSets) => ({
+        locusUrl: 'http://locus-url.com',
         locusStateElements: [
           {
-            htMeta: {elementId: {type: 'self'}},
+            htMeta: {elementId: {type: 'metadata'}},
             data: {visibleDataSets},
           },
         ],
@@ -114,6 +116,7 @@ describe('plugin-meetings', () => {
       });
 
       const createLocusWithVisibleDataSets = (visibleDataSets) => ({
+        url: 'http://locus-url.com',
         self: {visibleDataSets},
         participants: [],
         links: {
@@ -136,8 +139,12 @@ describe('plugin-meetings', () => {
           HashTreeParserStub,
           sinon.match({
             initialLocus: {
-              locus: {self: {visibleDataSets}},
-              dataSets: [],
+              locus: null,
+              dataSets: hashTreeMessage.dataSets,
+            },
+            metadata: {
+              htMeta: hashTreeMessage.locusStateElements[0].htMeta,
+              visibleDataSets,
             },
             webexRequest: sinon.match.func,
             locusInfoUpdateCallback: sinon.match.func,
@@ -169,11 +176,16 @@ describe('plugin-meetings', () => {
         const visibleDataSets = ['dataset1', 'dataset2'];
         const locus = createLocusWithVisibleDataSets(visibleDataSets);
         const dataSets = [{name: 'dataset1', url: 'http://dataset-url.com'}];
+        const metadata = {
+          htMeta: {elementId: {type: 'metadata'}},
+          visibleDataSets,
+        };
 
         await locusInfo.initialSetup({
           trigger: 'join-response',
           locus,
           dataSets,
+          metadata,
         });
 
         assert.calledOnceWithExactly(
@@ -183,6 +195,7 @@ describe('plugin-meetings', () => {
               locus,
               dataSets,
             },
+            metadata,
             webexRequest: sinon.match.func,
             locusInfoUpdateCallback: sinon.match.func,
             debugId: sinon.match.string,
@@ -220,12 +233,13 @@ describe('plugin-meetings', () => {
           HashTreeParserStub,
           sinon.match({
             initialLocus: {
-              locus: {self: {visibleDataSets}},
+              locus: null,
               dataSets: [],
             },
             webexRequest: sinon.match.func,
             locusInfoUpdateCallback: sinon.match.func,
             debugId: sinon.match.string,
+            metadata: null,
           })
         );
         assert.calledOnceWithExactly(mockHashTreeParser.initializeFromGetLociResponse, locus);
@@ -249,6 +263,30 @@ describe('plugin-meetings', () => {
         assert.isTrue(locusInfo.emitChange);
       });
 
+      it('throws if called with "locus-message" and Metadata object without visibleDataSets', async () => {
+        const hashTreeMessage = {
+          locusStateElements: [
+            {
+              htMeta: {elementId: {type: 'Metadata'}},
+              data: {},
+            },
+          ],
+          dataSets: [{name: 'dataset1', url: 'test-url'}],
+        };
+        try {
+          await locusInfo.initialSetup({
+            trigger: 'locus-message',
+            hashTreeMessage,
+          });
+          assert.fail('should have thrown an error');
+        } catch (error) {
+          assert.equal(
+            error.message,
+            'Metadata object with visibleDataSets is missing in the message'
+          );
+        }
+      });
+
       describe('should setup correct locusInfoUpdateCallback when creating HashTreeParser', () => {
         const OBJECTS_UPDATED = HashTreeParserModule.LocusInfoUpdateType.OBJECTS_UPDATED;
         const MEETING_ENDED = HashTreeParserModule.LocusInfoUpdateType.MEETING_ENDED;
@@ -263,10 +301,11 @@ describe('plugin-meetings', () => {
           await locusInfo.initialSetup({
             trigger: 'locus-message',
             hashTreeMessage: {
+              locusUrl: 'fake-locus-url',
               locusStateElements: [
                 {
-                  htMeta: {elementId: {type: 'self'}},
-                  data: {visibleDataSets: ['dataset1']},
+                  htMeta: {elementId: {type: 'Metadata'}},
+                  data: {visibleDataSets: [{name: 'dataset1', url: 'test-url'}]},
                 },
               ],
               dataSets: [{name: 'dataset1', url: 'test-url'}],
@@ -293,6 +332,16 @@ describe('plugin-meetings', () => {
               htMeta: {elementId: {type: 'mediashare', id: 'fake-ht-mediaShare-2', version: 1}},
             },
           ];
+          locusInfo.embeddedApps = [
+            {
+              id: 'fake-embedded-app-1',
+              htMeta: {elementId: {type: 'embeddedapp', id: 'fake-ht-embeddedApp-1', version: 1}},
+            },
+            {
+              id: 'fake-embedded-app-2',
+              htMeta: {elementId: {type: 'embeddedapp', id: 'fake-ht-embeddedApp-2', version: 1}},
+            },
+          ];
           locusInfo.meetings = {id: 'fake-meetings'};
           locusInfo.participants = [
             {id: 'fake-participant-1', name: 'Participant One'},
@@ -311,6 +360,13 @@ describe('plugin-meetings', () => {
           locusInfo.url = 'fake-locus-url';
           locusInfo.htMeta = {elementId: {type: 'locus', id: 'fake-ht-locus-id', version: 1}};
 
+          const createdHashTreeParser = locusInfo.hashTreeParsers.get('fake-locus-url');
+
+          assert.isDefined(createdHashTreeParser);
+          // this flag would have been set to true on the first callback triggered by initialSetup() wa called earlier
+          // it's not because we're mocking HashTreeParser, so we have to set it manually here
+          createdHashTreeParser.initializedFromHashTree = true;
+
           // setup the default expected locus info state that each test builds upon
           expectedLocusInfo = {
             controls: {id: 'fake-controls'},
@@ -328,8 +384,18 @@ describe('plugin-meetings', () => {
                 htMeta: {elementId: {type: 'mediashare', id: 'fake-ht-mediaShare-2', version: 1}},
               },
             ],
+            embeddedApps: [
+              {
+                id: 'fake-embedded-app-1',
+                htMeta: {elementId: {type: 'embeddedapp', id: 'fake-ht-embeddedApp-1', version: 1}},
+              },
+              {
+                id: 'fake-embedded-app-2',
+                htMeta: {elementId: {type: 'embeddedapp', id: 'fake-ht-embeddedApp-2', version: 1}},
+              },
+            ],
             meetings: {id: 'fake-meetings'},
-            jsSdkMeta: {removedParticipantIds: []},
+            jsSdkMeta: {removedParticipantIds: [], forceReplaceMembers: false},
             participants: [], // empty means there were no participant updates
             replaces: {id: 'fake-replaces'},
             self: {id: 'fake-self'},
@@ -504,11 +570,12 @@ describe('plugin-meetings', () => {
             self: {id: 'fake-self'},
             links: {id: 'fake-links'},
             mediaShares: expectedLocusInfo.mediaShares,
+            embeddedApps: expectedLocusInfo.embeddedApps,
             // and now the new fields
             ...newLocus,
             htMeta: newLocusHtMeta,
             participants: [], // empty means there were no participant updates
-            jsSdkMeta: {removedParticipantIds: []}, // no participants were removed
+            jsSdkMeta: {removedParticipantIds: [], forceReplaceMembers: false}, // no participants were removed
           });
         });
 
@@ -536,6 +603,7 @@ describe('plugin-meetings', () => {
                   self: 'new-self',
                   participants: 'new-participants',
                   mediaShares: 'new-mediaShares',
+                  embeddedApps: 'new-embeddedApps',
                 },
               },
             ],
@@ -551,8 +619,9 @@ describe('plugin-meetings', () => {
             self: {id: 'fake-self'},
             links: {id: 'fake-links'},
             mediaShares: expectedLocusInfo.mediaShares,
+            embeddedApps: expectedLocusInfo.embeddedApps,
             participants: [], // empty means there were no participant updates
-            jsSdkMeta: {removedParticipantIds: []}, // no participants were removed
+            jsSdkMeta: {removedParticipantIds: [], forceReplaceMembers: false}, // no participants were removed
             ...newLocus,
             htMeta: newLocusHtMeta,
           });
@@ -586,11 +655,12 @@ describe('plugin-meetings', () => {
             self: {id: 'fake-self'},
             links: {id: 'fake-links'},
             mediaShares: expectedLocusInfo.mediaShares,
+            embeddedApps: expectedLocusInfo.embeddedApps,
             // and now the new fields
             ...newLocus,
             htMeta: newLocusHtMeta,
             participants: [], // empty means there were no participant updates
-            jsSdkMeta: {removedParticipantIds: []}, // no participants were removed
+            jsSdkMeta: {removedParticipantIds: [], forceReplaceMembers: false}, // no participants were removed
           });
         });
 
@@ -678,7 +748,7 @@ describe('plugin-meetings', () => {
           assert.calledOnceWithExactly(onDeltaLocusStub, {
             ...expectedLocusInfo,
             participants: [newParticipant, updatedParticipant2],
-            jsSdkMeta: {removedParticipantIds: ['fake-participant-1']},
+            jsSdkMeta: {removedParticipantIds: ['fake-participant-1'], forceReplaceMembers: false},
           });
           // and that the hashTreeObjectId2ParticipantId map was updated correctly
           assert.isUndefined(locusInfo.hashTreeObjectId2ParticipantId.get('fake-ht-participant-1'));
@@ -725,6 +795,39 @@ describe('plugin-meetings', () => {
           });
         });
 
+        it('should process locus update correctly when called with updated EMBEDDEDAPP objects', () => {
+          const newEmbeddedApp = {
+            id: 'new-embedded-app-3',
+            htMeta: {elementId: {type: 'embeddedapp', id: 'fake-ht-embeddedApp-3', version: 100}},
+          };
+          const updatedEmbeddedApp2 = {
+            id: 'fake-embedded-app-2',
+            someNewProp: 'newValue',
+            htMeta: {elementId: {type: 'embeddedapp', id: 'fake-ht-embeddedApp-2', version: 100}},
+          };
+          // 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, {
+            updatedObjects: [
+              {htMeta: {elementId: {type: 'embeddedapp', id: 'fake-ht-embeddedApp-1'}}, data: null},
+              {
+                htMeta: {elementId: {type: 'embeddedapp', id: 'fake-ht-embeddedApp-2'}},
+                data: updatedEmbeddedApp2,
+              },
+              {
+                htMeta: {elementId: {type: 'embeddedapp', id: 'fake-ht-embeddedApp-3'}},
+                data: newEmbeddedApp,
+              },
+            ],
+          });
+
+          // check onDeltaLocus() was called with correctly updated locus info
+          assert.calledOnceWithExactly(onDeltaLocusStub, {
+            ...expectedLocusInfo,
+            embeddedApps: [updatedEmbeddedApp2, newEmbeddedApp],
+          });
+        });
+
         it('should process locus update correctly when called with a combination of various updated objects', () => {
           const newSelf = {
             id: 'new-self',
@@ -841,6 +944,78 @@ describe('plugin-meetings', () => {
             MEETING_REMOVED_REASON.SELF_REMOVED
           );
         });
+
+        // this could happen if meeting gets destroyed while we're doing some async hash tree operation like a sync
+        it('should handle MEETING_ENDED correctly when meeting is not found in the collection', () => {
+          const collectionGetStub = sinon
+            .stub(locusInfo.webex.meetings.meetingCollection, 'get')
+            .returns(null);
+          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);
+
+          assert.calledOnceWithExactly(collectionGetStub, locusInfo.meetingId);
+          assert.notCalled(destroyStub);
+        });
+
+        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, {
+            updatedObjects: [
+              {
+                htMeta: {elementId: {type: 'self'}},
+                data: {id: 'new-self'},
+              },
+            ],
+          });
+
+          assert.calledOnce(onDeltaLocusStub);
+          assert.equal(onDeltaLocusStub.firstCall.args[0].jsSdkMeta.forceReplaceMembers, true);
+          assert.isTrue(createdHashTreeParser.initializedFromHashTree);
+        });
+
+        it('should set forceReplaceMembers to false on subsequent updates (initializedFromHashTree is true)', () => {
+          locusInfoUpdateCallback(OBJECTS_UPDATED, {
+            updatedObjects: [
+              {
+                htMeta: {elementId: {type: 'self'}},
+                data: {id: 'new-self'},
+              },
+            ],
+          });
+
+          assert.calledOnce(onDeltaLocusStub);
+          assert.equal(onDeltaLocusStub.firstCall.args[0].jsSdkMeta.forceReplaceMembers, false);
+        });
+
+        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, {
+            updatedObjects: [
+              {
+                htMeta: {elementId: {type: 'participant', id: 99}},
+                data: {
+                  id: 'participant-matching-self',
+                  identity: 'user-123',
+                  state: 'LEFT',
+                  reason: 'MOVED',
+                  roles: ['MODERATOR'],
+                },
+              },
+            ],
+          });
+
+          assert.calledOnce(onDeltaLocusStub);
+          const passedLocus = onDeltaLocusStub.firstCall.args[0];
+
+          assert.equal(passedLocus.self.identity, 'user-123');
+          assert.equal(passedLocus.self.state, 'LEFT');
+          assert.equal(passedLocus.self.reason, 'MOVED');
+        });
       });
     });
 
@@ -1076,7 +1251,7 @@ describe('plugin-meetings', () => {
       it('should trigger the CONTROLS_POLLING_QA_CHANGED event when necessary', () => {
         locusInfo.controls = {};
         locusInfo.emitScoped = sinon.stub();
-        newControls.pollingQAControl = { enabled: true };
+        newControls.pollingQAControl = {enabled: true};
         locusInfo.updateControls(newControls);
 
         assert.calledWith(
@@ -1366,6 +1541,34 @@ describe('plugin-meetings', () => {
         );
       });
 
+      it('should emit CONTROLS_AI_SUMMARY_NOTIFICATION_UPDATED when aiSummaryNotification changes', () => {
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.controls = {
+          transcribe: {
+            transcribing: false,
+            caption: false,
+            aiSummaryNotification: false,
+          },
+        };
+        newControls.transcribe.transcribing = false;
+        newControls.transcribe.caption = false;
+        newControls.transcribe.aiSummaryNotification = true;
+
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.CONTROLS_AI_SUMMARY_NOTIFICATION_UPDATED,
+          {
+            aiSummaryNotification: true,
+          }
+        );
+      });
+
       it('should update the transcribe spoken language', () => {
         locusInfo.emitScoped = sinon.stub();
         locusInfo.controls = {
@@ -1631,7 +1834,6 @@ describe('plugin-meetings', () => {
         );
       });
 
-
       it('should call with participant display name', () => {
         const failureParticipant = [
           {
@@ -1656,7 +1858,7 @@ describe('plugin-meetings', () => {
             displayName: 'Test User',
           }
         );
-      })
+      });
     });
 
     describe('#updateSelf', () => {
@@ -2457,8 +2659,8 @@ describe('plugin-meetings', () => {
           {
             isInitializing: !self,
           }
-          );
-        });
+        );
+      });
 
       const checkMeetingInfoUpdatedCalled = (expected, payload) => {
         const expectedArgs = [
@@ -2835,6 +3037,333 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#createHashTreeParser', () => {
+      let HashTreeParserStub;
+
+      beforeEach(() => {
+        HashTreeParserStub = sinon
+          .stub(HashTreeParserModule, 'default')
+          .returns({
+            initializeFromMessage: sinon.stub().resolves(),
+            initializeFromGetLociResponse: sinon.stub().resolves(),
+            state: 'active',
+            stop: sinon.stub(),
+            handleMessage: sinon.stub(),
+          });
+      });
+
+      const setupParserViaInitialSetup = async (locusUrl = 'http://locus-url-A.com') => {
+        await locusInfo.initialSetup({
+          trigger: 'locus-message',
+          hashTreeMessage: {
+            locusUrl,
+            locusStateElements: [
+              {
+                htMeta: {elementId: {type: 'Metadata'}},
+                data: {visibleDataSets: [{name: 'dataset1', url: 'test-url'}]},
+              },
+            ],
+            dataSets: [{name: 'dataset1', url: 'test-url'}],
+          },
+        });
+      };
+
+      it('should stop existing active parsers when creating a new one', async () => {
+        await setupParserViaInitialSetup('http://locus-url-A.com');
+
+        const firstParser = locusInfo.hashTreeParsers.get('http://locus-url-A.com').parser;
+
+        await setupParserViaInitialSetup('http://locus-url-B.com');
+
+        assert.calledOnce(firstParser.stop);
+      });
+
+      it('should set replacedAt on existing entries when replacedAt is provided', async () => {
+        await setupParserViaInitialSetup('http://locus-url-A.com');
+
+        // Call createHashTreeParser with replacedAt via parse -> handleHashTreeParserSwitch
+        // which calls createHashTreeParser with replacedAt from the self element
+        locusInfo.webex.internal.device.url = 'http://device-url.com';
+        const message = {
+          locusUrl: 'http://locus-url-B.com',
+          locusStateElements: [
+            {
+              htMeta: {elementId: {type: 'Metadata'}},
+              data: {visibleDataSets: [{name: 'dataset1', url: 'test-url'}]},
+            },
+            {
+              htMeta: {elementId: {type: 'Self'}},
+              data: {
+                devices: [{url: 'http://device-url.com', replaces: [{locusUrl: 'http://locus-url-A.com', replacedAt: '2026-01-01T00:00:00Z'}]}],
+              },
+            },
+          ],
+          dataSets: [{name: 'dataset1', url: 'test-url'}],
+        };
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: message,
+        });
+
+        assert.equal(locusInfo.hashTreeParsers.get('http://locus-url-A.com').replacedAt, '2026-01-01T00:00:00Z');
+      });
+
+      it('should not set replacedAt on existing entries when replacedAt is not provided', async () => {
+        await setupParserViaInitialSetup('http://locus-url-A.com');
+
+        await setupParserViaInitialSetup('http://locus-url-B.com');
+
+        assert.isUndefined(locusInfo.hashTreeParsers.get('http://locus-url-A.com').replacedAt);
+      });
+
+      it('should store the new parser in hashTreeParsers map with the correct locusUrl key', async () => {
+        await setupParserViaInitialSetup('http://locus-url-A.com');
+
+        assert.isTrue(locusInfo.hashTreeParsers.has('http://locus-url-A.com'));
+        assert.isDefined(locusInfo.hashTreeParsers.get('http://locus-url-A.com').parser);
+      });
+
+      it('should clear hashTreeObjectId2ParticipantId when creating a new parser', async () => {
+        await setupParserViaInitialSetup('http://locus-url-A.com');
+        locusInfo.hashTreeObjectId2ParticipantId.set(1, 'participant-1');
+
+        await setupParserViaInitialSetup('http://locus-url-B.com');
+
+        assert.equal(locusInfo.hashTreeObjectId2ParticipantId.size, 0);
+      });
+
+      it('should not stop already stopped parsers', async () => {
+        await setupParserViaInitialSetup('http://locus-url-A.com');
+        const firstParser = locusInfo.hashTreeParsers.get('http://locus-url-A.com').parser;
+        firstParser.state = 'stopped';
+
+        await setupParserViaInitialSetup('http://locus-url-B.com');
+
+        assert.notCalled(firstParser.stop);
+      });
+    });
+
+    describe('#handleHashTreeParserSwitch', () => {
+      const deviceUrl = 'http://device-url.com';
+      const locusUrlA = 'http://locus-url-A.com';
+      const locusUrlB = 'http://locus-url-B.com';
+
+      let HashTreeParserStub;
+
+      const createMockParser = (state = 'active') => ({
+        state,
+        stop: sinon.stub(),
+        resume: sinon.stub(),
+        handleMessage: sinon.stub(),
+      });
+
+      const createSelfElementWithReplaces = (replacedLocusUrl, replacedAt) => ({
+        htMeta: {elementId: {type: 'Self'}},
+        data: {
+          devices: [{url: deviceUrl, replaces: [{locusUrl: replacedLocusUrl, replacedAt}]}],
+        },
+      });
+
+      const createMetadataElement = () => ({
+        htMeta: {elementId: {type: 'Metadata'}},
+        data: {visibleDataSets: [{name: 'dataset1', url: 'test-url'}]},
+      });
+
+      beforeEach(() => {
+        locusInfo.webex.internal.device.url = deviceUrl;
+        HashTreeParserStub = sinon
+          .stub(HashTreeParserModule, 'default')
+          .returns(createMockParser());
+      });
+
+      it('should create a new parser when no entry exists for locusUrl and metadata has visibleDataSets', () => {
+        // set up an existing parser for a different url
+        locusInfo.hashTreeParsers.set(locusUrlA, {parser: createMockParser(), initializedFromHashTree: true});
+
+        const message = {
+          locusUrl: locusUrlB,
+          locusStateElements: [createMetadataElement()],
+          dataSets: [{name: 'dataset1', url: 'test-url'}],
+        };
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: message,
+        });
+
+        assert.isTrue(locusInfo.hashTreeParsers.has(locusUrlB));
+      });
+
+      it('should return true when no entry exists even if no metadata is available', () => {
+        locusInfo.hashTreeParsers.set(locusUrlA, {parser: createMockParser(), initializedFromHashTree: true});
+        const parserA = locusInfo.hashTreeParsers.get(locusUrlA).parser;
+
+        const message = {
+          locusUrl: locusUrlB,
+          locusStateElements: [],
+          dataSets: [],
+        };
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: message,
+        });
+
+        // no new parser created since no metadata
+        assert.isFalse(locusInfo.hashTreeParsers.has(locusUrlB));
+        // the existing parser's handleMessage should NOT have been called
+        assert.notCalled(parserA.handleMessage);
+      });
+
+      it('should resume a stopped parser when replaces info is newer', () => {
+        const parserA = createMockParser('stopped');
+        const parserB = createMockParser('active');
+        locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, replacedAt: '2026-01-01T00:00:00Z', initializedFromHashTree: true});
+        locusInfo.hashTreeParsers.set(locusUrlB, {parser: parserB, initializedFromHashTree: true});
+
+        const message = {
+          locusUrl: locusUrlA,
+          locusStateElements: [
+            createSelfElementWithReplaces(locusUrlB, '2026-02-01T00:00:00Z'),
+            createMetadataElement(),
+          ],
+          dataSets: [{name: 'dataset1', url: 'test-url'}],
+        };
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: message,
+        });
+
+        assert.calledOnce(parserA.resume);
+        assert.calledOnce(parserB.stop);
+      });
+
+      it('should not resume a stopped parser when replaces info is not newer', () => {
+        const parserA = createMockParser('stopped');
+        const parserB = createMockParser('active');
+        locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, replacedAt: '2026-03-01T00:00:00Z', initializedFromHashTree: true});
+        locusInfo.hashTreeParsers.set(locusUrlB, {parser: parserB, initializedFromHashTree: true});
+
+        const message = {
+          locusUrl: locusUrlA,
+          locusStateElements: [
+            createSelfElementWithReplaces(locusUrlB, '2026-01-01T00:00:00Z'),
+          ],
+          dataSets: [{name: 'dataset1', url: 'test-url'}],
+        };
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: message,
+        });
+
+        assert.notCalled(parserA.resume);
+        assert.notCalled(parserB.stop);
+      });
+
+      it('should return true for a stopped parser with no replaces info', () => {
+        const parserA = createMockParser('stopped');
+        locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, initializedFromHashTree: true});
+
+        const message = {
+          locusUrl: locusUrlA,
+          locusStateElements: [],
+          dataSets: [],
+        };
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: message,
+        });
+
+        assert.notCalled(parserA.resume);
+        assert.notCalled(parserA.handleMessage);
+      });
+
+      it('should return false when the entry exists and parser is active', () => {
+        const parserA = createMockParser('active');
+        locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, initializedFromHashTree: true});
+
+        const message = {
+          locusUrl: locusUrlA,
+          locusStateElements: [],
+          dataSets: [],
+        };
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: message,
+        });
+
+        assert.calledOnceWithExactly(parserA.handleMessage, message);
+      });
+
+      it('should pass replacedAt from replaces to createHashTreeParser when creating a new parser', () => {
+        locusInfo.hashTreeParsers.set(locusUrlA, {parser: createMockParser(), initializedFromHashTree: true});
+
+        const message = {
+          locusUrl: locusUrlB,
+          locusStateElements: [
+            createMetadataElement(),
+            createSelfElementWithReplaces(locusUrlA, '2026-05-01T00:00:00Z'),
+          ],
+          dataSets: [{name: 'dataset1', url: 'test-url'}],
+        };
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: message,
+        });
+
+        assert.isTrue(locusInfo.hashTreeParsers.has(locusUrlB));
+        assert.equal(locusInfo.hashTreeParsers.get(locusUrlA).replacedAt, '2026-05-01T00:00:00Z');
+      });
+    });
+
+    describe('#handleHashTreeMessage', () => {
+      it('should call handleHashTreeParserSwitch and not call handleMessage if parser was switched', () => {
+        const locusUrlA = 'http://locus-url-A.com';
+        const locusUrlB = 'http://locus-url-B.com';
+        const parserA = {state: 'stopped', handleMessage: sinon.stub(), resume: sinon.stub(), stop: sinon.stub()};
+        locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, initializedFromHashTree: true});
+
+        // message for a stopped parser without replaces -> handleHashTreeParserSwitch returns true
+        const message = {
+          locusUrl: locusUrlA,
+          locusStateElements: [],
+          dataSets: [],
+        };
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: message,
+        });
+
+        assert.notCalled(parserA.handleMessage);
+      });
+
+      it('should call handleMessage on the correct parser when no switch occurs', () => {
+        const locusUrlA = 'http://locus-url-A.com';
+        const parserA = {state: 'active', handleMessage: sinon.stub()};
+        locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, initializedFromHashTree: true});
+
+        const message = {
+          locusUrl: locusUrlA,
+          locusStateElements: [],
+          dataSets: [],
+        };
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: message,
+        });
+
+        assert.calledOnceWithExactly(parserA.handleMessage, message);
+      });
+    });
+
     describe('#handleLocusAPIResponse', () => {
       it('calls handleLocusDelta when we are not using hash trees', () => {
         const fakeLocus = {eventType: LOCUSEVENT.DIFFERENCE};
@@ -2846,7 +3375,7 @@ describe('plugin-meetings', () => {
         assert.calledWith(locusInfo.handleLocusDelta, fakeLocus, mockMeeting);
       });
       it('calls hash tree parser when we are using hash trees', () => {
-        const fakeLocus = {eventType: LOCUSEVENT.DIFFERENCE};
+        const fakeLocus = {eventType: LOCUSEVENT.DIFFERENCE, url: 'http://locus-url.com'};
         const fakeDataSets = [{name: 'dataset1', url: 'http://test.com'}];
         const responseBody = {locus: fakeLocus, dataSets: fakeDataSets};
 
@@ -2854,7 +3383,10 @@ describe('plugin-meetings', () => {
         const mockHashTreeParser = {
           handleLocusUpdate: sinon.stub(),
         };
-        locusInfo.hashTreeParser = mockHashTreeParser;
+        locusInfo.hashTreeParsers.set(fakeLocus.url, {
+          parser: mockHashTreeParser,
+          initializedFromHashTree: true,
+        });
 
         sinon.stub(locusInfo, 'onDeltaLocus');
 
@@ -2862,6 +3394,43 @@ describe('plugin-meetings', () => {
 
         assert.calledOnceWithExactly(mockHashTreeParser.handleLocusUpdate, responseBody);
       });
+
+      it('should handle unwrapped LocusDTO (without locus wrapper) when hash tree parser exists', () => {
+        const fakeLocus = {url: 'http://locus-url.com', fullState: {state: 'ACTIVE'}};
+        const mockHashTreeParser = {handleLocusUpdate: sinon.stub()};
+        locusInfo.hashTreeParsers.set(fakeLocus.url, {
+          parser: mockHashTreeParser,
+          initializedFromHashTree: true,
+        });
+
+        locusInfo.handleLocusAPIResponse(mockMeeting, fakeLocus);
+
+        assert.calledOnceWithExactly(mockHashTreeParser.handleLocusUpdate, {locus: fakeLocus});
+      });
+
+      it('should handle unwrapped LocusDTO in classic mode (no hash tree parser)', () => {
+        const fakeLocus = {url: 'http://locus-url.com', fullState: {state: 'ACTIVE'}};
+        sinon.stub(locusInfo, 'handleLocusDelta');
+
+        locusInfo.handleLocusAPIResponse(mockMeeting, fakeLocus);
+
+        assert.calledOnceWithExactly(locusInfo.handleLocusDelta, fakeLocus, mockMeeting);
+      });
+
+      it('should send mismatch metric when hash tree parser exists but dataSets are missing in wrapped response', () => {
+        const fakeLocus = {url: 'http://locus-url.com'};
+        const mockHashTreeParser = {handleLocusUpdate: sinon.stub()};
+        locusInfo.hashTreeParsers.set(fakeLocus.url, {
+          parser: mockHashTreeParser,
+          initializedFromHashTree: true,
+        });
+        sinon.stub(locusInfo, 'sendClassicVsHashTreeMismatchMetric');
+
+        locusInfo.handleLocusAPIResponse(mockMeeting, {locus: fakeLocus});
+
+        assert.calledOnce(locusInfo.sendClassicVsHashTreeMismatchMetric);
+        assert.calledOnce(mockHashTreeParser.handleLocusUpdate);
+      });
     });
 
     describe('#LocusDeltaEvents', () => {
@@ -2923,28 +3492,28 @@ describe('plugin-meetings', () => {
         assert.isFunction(locusParser.onDeltaAction);
       });
 
-      it("#updateLocusInfo invokes updateLocusUrl before updateMeetingInfo", () => {
+      it('#updateLocusInfo invokes updateLocusUrl before updateMeetingInfo', () => {
         const callOrder = [];
-        sinon.stub(locusInfo, "updateControls");
-        sinon.stub(locusInfo, "updateConversationUrl");
-        sinon.stub(locusInfo, "updateCreated");
-        sinon.stub(locusInfo, "updateFullState");
-        sinon.stub(locusInfo, "updateHostInfo");
-        sinon.stub(locusInfo, "updateMeetingInfo").callsFake(() => {
-          callOrder.push("updateMeetingInfo");
+        sinon.stub(locusInfo, 'updateControls');
+        sinon.stub(locusInfo, 'updateConversationUrl');
+        sinon.stub(locusInfo, 'updateCreated');
+        sinon.stub(locusInfo, 'updateFullState');
+        sinon.stub(locusInfo, 'updateHostInfo');
+        sinon.stub(locusInfo, 'updateMeetingInfo').callsFake(() => {
+          callOrder.push('updateMeetingInfo');
         });
-        sinon.stub(locusInfo, "updateMediaShares");
-        sinon.stub(locusInfo, "updateReplaces");
-        sinon.stub(locusInfo, "updateSelf");
-        sinon.stub(locusInfo, "updateLocusUrl").callsFake(() => {
-          callOrder.push("updateLocusUrl");
+        sinon.stub(locusInfo, 'updateMediaShares');
+        sinon.stub(locusInfo, 'updateReplaces');
+        sinon.stub(locusInfo, 'updateSelf');
+        sinon.stub(locusInfo, 'updateLocusUrl').callsFake(() => {
+          callOrder.push('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, 'updateAclUrl');
+        sinon.stub(locusInfo, 'updateBasequence');
+        sinon.stub(locusInfo, 'updateSequence');
+        sinon.stub(locusInfo, 'updateEmbeddedApps');
+        sinon.stub(locusInfo, 'updateLinks');
+        sinon.stub(locusInfo, 'compareAndUpdate');
 
         locusInfo.updateLocusInfo(locus);
 
@@ -3000,7 +3569,7 @@ describe('plugin-meetings', () => {
       it('#updateLocusInfo puts the Locus DTO top level properties at the right place in LocusInfo class', () => {
         // this test verifies that the top-level properties of Locus DTO are copied
         // into LocusInfo class and set as top level properties too
-        // this is important, because the code handling Locus hass trees relies on it, see updateFromHashTree()
+        // this is important, because the code handling Locus hash trees relies on it, see updateFromHashTree()
         const info = {id: 'info id'};
         const fullState = {id: 'fullState id'};
         const links = {services: {id: 'service links'}, resources: {id: 'resource links'}};
@@ -3039,7 +3608,7 @@ describe('plugin-meetings', () => {
         sandbox.stub(locusInfo, 'handleOneOnOneEvent');
         sandbox.stub(locusParser, 'isNewFullLocus').returns(true);
 
-        locusInfo.onFullLocus(fakeLocus, eventType);
+        locusInfo.onFullLocus('test', fakeLocus, eventType);
 
         assert.equal(fakeLocus, locusParser.workingCopy);
       });
@@ -3060,7 +3629,7 @@ describe('plugin-meetings', () => {
 
         sandbox.stub(locusParser, 'isNewFullLocus').returns(false);
 
-        locusInfo.onFullLocus(fakeLocus, eventType);
+        locusInfo.onFullLocus('test', fakeLocus, eventType);
 
         spies.forEach((spy) => {
           assert.notCalled(spy);
@@ -3210,7 +3779,11 @@ describe('plugin-meetings', () => {
         }).then(() => {
           assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'oldLocusUrl'});
 
-          assert.calledOnceWithExactly(meeting.locusInfo.onFullLocus, fakeFullLocusDto);
+          assert.calledOnceWithExactly(
+            meeting.locusInfo.onFullLocus,
+            'classic Locus sync',
+            fakeFullLocusDto
+          );
           assert.calledOnce(locusInfo.locusParser.resume);
         });
       });
@@ -3308,7 +3881,11 @@ describe('plugin-meetings', () => {
             });
 
             assert.notCalled(meeting.locusInfo.handleLocusDelta);
-            assert.calledOnceWithExactly(meeting.locusInfo.onFullLocus, fakeFullLocusDto);
+            assert.calledOnceWithExactly(
+              meeting.locusInfo.onFullLocus,
+              'classic Locus sync',
+              fakeFullLocusDto
+            );
             assert.calledOnce(locusInfo.locusParser.resume);
           });
         });
@@ -3484,7 +4061,11 @@ describe('plugin-meetings', () => {
           url: 'fake locus DELTA url',
         });
         assert.notCalled(meeting.locusInfo.handleLocusDelta);
-        assert.calledOnceWithExactly(meeting.locusInfo.onFullLocus, fakeFullLocusDto);
+        assert.calledOnceWithExactly(
+          meeting.locusInfo.onFullLocus,
+          'classic Locus sync',
+          fakeFullLocusDto
+        );
         assert.calledOnce(locusInfo.locusParser.resume);
       });
     });
@@ -3505,6 +4086,137 @@ describe('plugin-meetings', () => {
 
         assert.isNull(locusInfo.mainSessionLocusCache);
       });
+
+      it('should map participant with htMeta.elementId.id of 0 (falsy number) to hashTreeObjectId2ParticipantId', () => {
+        const locus = {
+          url: 'url',
+          participants: [
+            {
+              id: 'participant-zero',
+              htMeta: {elementId: {id: 0}},
+            },
+          ],
+        };
+
+        sinon.stub(locusInfo.locusParser, 'isNewFullLocus').returns(true);
+        sinon.stub(locusInfo, 'updateLocusInfo');
+        sinon.stub(locusInfo, 'updateParticipants');
+        sinon.stub(locusInfo, 'isMeetingActive');
+        sinon.stub(locusInfo, 'handleOneOnOneEvent');
+        sinon.stub(locusInfo, 'updateEmbeddedApps');
+        locusInfo.locusParser.workingCopy = null;
+
+        locusInfo.onFullLocus('test', locus);
+
+        assert.equal(locusInfo.hashTreeObjectId2ParticipantId.get(0), 'participant-zero');
+      });
+    });
+
+    describe('#onDeltaLocus', () => {
+      it('should use forceReplaceMembers from jsSdkMeta when it is defined', () => {
+        sinon.stub(locusInfo, 'mergeParticipants');
+        sinon.stub(locusInfo, 'updateLocusInfo').returns(true);
+        sinon.stub(locusInfo, 'updateParticipants');
+        sinon.stub(locusInfo, 'isMeetingActive');
+
+        locusInfo.onDeltaLocus({
+          participants: [],
+          jsSdkMeta: {forceReplaceMembers: true, removedParticipantIds: []},
+        });
+
+        assert.calledOnceWithExactly(locusInfo.updateParticipants, [], [], true);
+      });
+
+      it('should fall back to isNeedReplaceMembers when forceReplaceMembers is not in jsSdkMeta', () => {
+        sinon.stub(locusInfo, 'mergeParticipants');
+        sinon.stub(locusInfo, 'updateLocusInfo').returns(true);
+        sinon.stub(locusInfo, 'updateParticipants');
+        sinon.stub(locusInfo, 'isMeetingActive');
+
+        locusInfo.onDeltaLocus({participants: []});
+
+        // without jsSdkMeta.forceReplaceMembers, uses ControlsUtils.isNeedReplaceMembers result (false by default)
+        assert.calledOnceWithExactly(locusInfo.updateParticipants, [], undefined, false);
+      });
+
+      it('should not call updateParticipants when updateLocusInfo returns false', () => {
+        sinon.stub(locusInfo, 'mergeParticipants');
+        sinon.stub(locusInfo, 'updateLocusInfo').returns(false);
+        sinon.stub(locusInfo, 'updateParticipants');
+        sinon.stub(locusInfo, 'isMeetingActive');
+
+        locusInfo.onDeltaLocus({participants: [], self: {state: 'LEFT', reason: 'MOVED'}});
+
+        assert.notCalled(locusInfo.updateParticipants);
+      });
+
+      it('should call updateParticipants when updateLocusInfo returns true', () => {
+        sinon.stub(locusInfo, 'mergeParticipants');
+        sinon.stub(locusInfo, 'updateLocusInfo').returns(true);
+        sinon.stub(locusInfo, 'updateParticipants');
+        sinon.stub(locusInfo, 'isMeetingActive');
+
+        locusInfo.onDeltaLocus({participants: [{id: 'p1'}]});
+
+        assert.calledOnce(locusInfo.updateParticipants);
+      });
+
+      [
+        {forceReplaceMembers: true, selfInParticipants: false, expectedSelfCopied: true},
+        {forceReplaceMembers: true, selfInParticipants: true, expectedSelfCopied: false},
+        {forceReplaceMembers: false, selfInParticipants: false, expectedSelfCopied: false},
+        {forceReplaceMembers: false, selfInParticipants: true, expectedSelfCopied: false},
+      ].forEach(({forceReplaceMembers, selfInParticipants, expectedSelfCopied}) => {
+        it(`should ${expectedSelfCopied ? '' : 'not '}copy self into participants when forceReplaceMembers=${forceReplaceMembers} and self ${selfInParticipants ? 'is' : 'is not'} in participants`, () => {
+          const self = {identity: 'selfId', state: 'JOINED', devices: [], status: {}};
+          const participant = {identity: selfInParticipants ? 'selfId' : 'other'};
+          const locus = {
+            participants: [participant],
+            self,
+            jsSdkMeta: {forceReplaceMembers, removedParticipantIds: []},
+          };
+
+          locusInfo.onDeltaLocus(locus);
+
+          const expectedParticipants = expectedSelfCopied ? [participant, self] : [participant];
+          assert.deepEqual(locus.participants, expectedParticipants);
+        });
+      });
+    });
+
+    describe('#updateLocusInfo', () => {
+      it('should return false when self.reason is MOVED and self.state is LEFT', () => {
+        sinon.stub(locusInfo, 'updateControls');
+
+        const result = locusInfo.updateLocusInfo({self: {reason: 'MOVED', state: 'LEFT'}});
+
+        assert.isFalse(result);
+        assert.notCalled(locusInfo.updateControls);
+      });
+
+      it('should return true when self is not in MOVED/LEFT state', () => {
+        sinon.stub(locusInfo, 'updateControls');
+        sinon.stub(locusInfo, 'updateConversationUrl');
+        sinon.stub(locusInfo, 'updateCreated');
+        sinon.stub(locusInfo, 'updateFullState');
+        sinon.stub(locusInfo, 'updateHostInfo');
+        sinon.stub(locusInfo, 'updateLocusUrl');
+        sinon.stub(locusInfo, 'updateMeetingInfo');
+        sinon.stub(locusInfo, 'updateMediaShares');
+        sinon.stub(locusInfo, 'updateReplaces');
+        sinon.stub(locusInfo, 'updateSelf');
+        sinon.stub(locusInfo, 'updateAclUrl');
+        sinon.stub(locusInfo, 'updateBasequence');
+        sinon.stub(locusInfo, 'updateSequence');
+        sinon.stub(locusInfo, 'updateEmbeddedApps');
+        sinon.stub(locusInfo, 'updateLinks');
+        sinon.stub(locusInfo, 'compareAndUpdate');
+
+        const result = locusInfo.updateLocusInfo({self: {state: 'JOINED'}});
+
+        assert.isTrue(result);
+        assert.calledOnce(locusInfo.updateControls);
+      });
     });
 
     describe('#getTheLocusToUpdate', () => {
@@ -3856,7 +4568,7 @@ describe('plugin-meetings', () => {
 
     describe('#updateLocusUrl', () => {
       it('trigger LOCUS_INFO_UPDATE_URL event with isMainLocus is true as default', () => {
-        const fakeUrl = "https://fake.com/locus";
+        const fakeUrl = 'https://fake.com/locus';
         locusInfo.emitScoped = sinon.stub();
         locusInfo.updateLocusUrl(fakeUrl);
 
@@ -3869,12 +4581,12 @@ describe('plugin-meetings', () => {
           EVENTS.LOCUS_INFO_UPDATE_URL,
           {
             url: fakeUrl,
-            isMainLocus: true
-          },
+            isMainLocus: true,
+          }
         );
       });
       it('trigger LOCUS_INFO_UPDATE_URL event with isMainLocus is false', () => {
-        const fakeUrl = "https://fake.com/locus";
+        const fakeUrl = 'https://fake.com/locus';
         locusInfo.emitScoped = sinon.stub();
         locusInfo.updateLocusUrl(fakeUrl, false);
 
@@ -3887,8 +4599,8 @@ describe('plugin-meetings', () => {
           EVENTS.LOCUS_INFO_UPDATE_URL,
           {
             url: fakeUrl,
-            isMainLocus: false
-          },
+            isMainLocus: false,
+          }
         );
       });
     });
@@ -3940,8 +4652,8 @@ describe('plugin-meetings', () => {
 
         sinon.stub(locusInfo, 'updateParticipants');
         sinon.stub(locusInfo, 'isMeetingActive');
-          sinon.stub(locusInfo, 'handleOneOnOneEvent');
-          (updateLocusInfoStub = sinon.stub(locusInfo, 'updateLocusInfo'));
+        sinon.stub(locusInfo, 'handleOneOnOneEvent');
+        updateLocusInfoStub = sinon.stub(locusInfo, 'updateLocusInfo');
         syncRequestStub = sinon.stub().resolves({body: {}});
 
         mockMeeting.locusInfo = locusInfo;
@@ -3950,7 +4662,7 @@ describe('plugin-meetings', () => {
           getLocusDTO: syncRequestStub,
         };
 
-        locusInfo.onFullLocus({
+        locusInfo.onFullLocus('test', {
           sequence: {
             rangeStart: 0,
             rangeEnd: 0,
@@ -4188,7 +4900,9 @@ describe('plugin-meetings', () => {
 
     describe('#parse', () => {
       it('handles hash tree messages correctly', () => {
+        const fakeLocusUrl = 'http://locus-url.com';
         const fakeHashTreeMessage = {
+          locusUrl: fakeLocusUrl,
           locusStateElements: [
             {
               htMeta: {elementId: {type: 'self'}},
@@ -4207,12 +4921,377 @@ describe('plugin-meetings', () => {
         const mockHashTreeParser = {
           handleMessage: sinon.stub(),
         };
-        locusInfo.hashTreeParser = mockHashTreeParser;
+        locusInfo.hashTreeParsers.set(fakeLocusUrl, {
+          parser: mockHashTreeParser,
+          initializedFromHashTree: true,
+        });
 
         locusInfo.parse(mockMeeting, data);
 
         assert.calledOnceWithExactly(mockHashTreeParser.handleMessage, fakeHashTreeMessage);
       });
+
+      it('ignores hash tree event when hashTreeParser is not created yet', () => {
+        const data = {
+          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
+          stateElementsMessage: {
+            locusStateElements: [],
+            dataSets: [],
+          },
+        };
+
+        const loggerSpy = sinon.spy(LoggerProxy.logger, 'info');
+        const getTheLocusToUpdateStub = sinon.stub(locusInfo, 'getTheLocusToUpdate');
+
+        // Ensure we're not using hash trees
+        assert.equal(locusInfo.hashTreeParsers.size, 0);
+
+        locusInfo.parse(mockMeeting, data);
+
+        assert.calledWith(
+          loggerSpy,
+          'Locus-info:index#parse --> received locus hash tree event before hashTreeParser is created'
+        );
+        assert.notCalled(getTheLocusToUpdateStub);
+      });
+    });
+  });
+
+  describe('#createLocusFromHashTreeMessage', () => {
+    const LOCUS_URL = 'https://locus.example.com/loci/abc-123';
+
+    const createElement = (type, data) => ({
+      htMeta: {elementId: {type, id: 1, version: 1}},
+      data,
+    });
+
+    it('returns locus with url and empty participants when no locusStateElements', () => {
+      const result = createLocusFromHashTreeMessage({locusUrl: LOCUS_URL});
+
+      assert.deepEqual(result.locus, {participants: [], url: LOCUS_URL});
+      assert.isUndefined(result.metadata);
+    });
+
+    it('skips elements without data', () => {
+      const result = createLocusFromHashTreeMessage({
+        locusUrl: LOCUS_URL,
+        locusStateElements: [{htMeta: {elementId: {type: 'Self', id: 1, version: 1}}, data: null}],
+      });
+
+      assert.deepEqual(result.locus, {participants: [], url: LOCUS_URL});
+    });
+
+    [
+      {type: 'Self', locusKey: 'self', data: {id: 'self-1', state: 'JOINED'}},
+      {type: 'Info', locusKey: 'info', data: {webExMeetingId: '123'}},
+      {type: 'FullState', locusKey: 'fullState', data: {state: 'ACTIVE'}},
+      {type: 'Links', locusKey: 'links', data: {resources: {}}},
+    ].forEach(({type, locusKey, data}) => {
+      it(`maps ${type} element to locus.${locusKey}`, () => {
+        const result = createLocusFromHashTreeMessage({
+          locusUrl: LOCUS_URL,
+          locusStateElements: [createElement(type, data)],
+        });
+
+        assert.deepEqual(result.locus[locusKey], data);
+      });
+    });
+
+    it('pushes Participant elements to locus.participants', () => {
+      const p1 = {id: 'p1', state: 'JOINED'};
+      const p2 = {id: 'p2', state: 'LEFT'};
+
+      const result = createLocusFromHashTreeMessage({
+        locusUrl: LOCUS_URL,
+        locusStateElements: [createElement('Participant', p1), createElement('Participant', p2)],
+      });
+
+      assert.deepEqual(result.locus.participants, [p1, p2]);
+    });
+
+    it('pushes MediaShare elements to locus.mediaShares array', () => {
+      const share1 = {name: 'whiteboard'};
+      const share2 = {name: 'content'};
+
+      const result = createLocusFromHashTreeMessage({
+        locusUrl: LOCUS_URL,
+        locusStateElements: [
+          createElement('MediaShare', share1),
+          createElement('MediaShare', share2),
+        ],
+      });
+
+      assert.deepEqual(result.locus.mediaShares, [share1, share2]);
+    });
+
+    it('pushes EmbeddedApp elements to locus.embeddedApps array', () => {
+      const app = {appId: 'app-1', state: 'STARTED'};
+
+      const result = createLocusFromHashTreeMessage({
+        locusUrl: LOCUS_URL,
+        locusStateElements: [createElement('EmbeddedApp', app)],
+      });
+
+      assert.deepEqual(result.locus.embeddedApps, [app]);
+    });
+
+    it('merges ControlEntry elements into locus.controls', () => {
+      const control1 = {record: {recording: true}};
+      const control2 = {lock: {locked: false}};
+
+      const result = createLocusFromHashTreeMessage({
+        locusUrl: LOCUS_URL,
+        locusStateElements: [
+          createElement('ControlEntry', control1),
+          createElement('ControlEntry', control2),
+        ],
+      });
+
+      assert.deepEqual(result.locus.controls, {record: {recording: true}, lock: {locked: false}});
+    });
+
+    it('spreads Locus element data onto top level but removes managed keys', () => {
+      const locusData = {
+        url: 'should-be-overridden',
+        someTopLevelField: 'value',
+        // these are managed by other ObjectTypes and should be removed
+        links: {should: 'be removed'},
+        info: {should: 'be removed'},
+        fullState: {should: 'be removed'},
+        self: {should: 'be removed'},
+        participants: [{should: 'be removed'}],
+        mediaShares: [{should: 'be removed'}],
+        controls: {should: 'be removed'},
+        embeddedApps: [{should: 'be removed'}],
+      };
+
+      const result = createLocusFromHashTreeMessage({
+        locusUrl: LOCUS_URL,
+        locusStateElements: [createElement('Locus', locusData)],
+      });
+
+      assert.equal(result.locus.someTopLevelField, 'value');
+      assert.deepEqual(result.locus.participants, []);
+      assert.isUndefined(result.locus.links);
+      assert.isUndefined(result.locus.info);
+      assert.isUndefined(result.locus.fullState);
+      assert.isUndefined(result.locus.self);
+      assert.isUndefined(result.locus.mediaShares);
+      assert.isUndefined(result.locus.controls);
+      assert.isUndefined(result.locus.embeddedApps);
+    });
+
+    it('extracts Metadata element as metadata in the result', () => {
+      const metadataData = {visibleDataSets: [{name: 'ds1', url: 'http://ds1.url'}]};
+      const htMeta = {elementId: {type: 'Metadata', id: 99, version: 3}};
+
+      const result = createLocusFromHashTreeMessage({
+        locusUrl: LOCUS_URL,
+        locusStateElements: [{htMeta, data: metadataData}],
+      });
+
+      assert.deepEqual(result.metadata, {...metadataData, htMeta});
+      assert.isUndefined(result.locus.metadata);
+    });
+
+    it('handles a message with multiple element types', () => {
+      const selfData = {id: 'self-1'};
+      const participantData = {id: 'p1'};
+      const infoData = {webExMeetingId: '456'};
+
+      const result = createLocusFromHashTreeMessage({
+        locusUrl: LOCUS_URL,
+        locusStateElements: [
+          createElement('Self', selfData),
+          createElement('Participant', participantData),
+          createElement('Info', infoData),
+        ],
+      });
+
+      assert.deepEqual(result.locus.self, selfData);
+      assert.deepEqual(result.locus.participants, [participantData]);
+      assert.deepEqual(result.locus.info, infoData);
+      assert.equal(result.locus.url, LOCUS_URL);
+    });
+
+    it('ignores unknown element types', () => {
+      const result = createLocusFromHashTreeMessage({
+        locusUrl: LOCUS_URL,
+        locusStateElements: [createElement('UnknownType', {foo: 'bar'})],
+      });
+
+      assert.deepEqual(result.locus, {participants: [], url: LOCUS_URL});
+    });
+  });
+
+  describe('findMeetingForHashTreeMessage', () => {
+    const deviceUrl = 'https://devices.example.com/device1';
+
+    function createMockMeetingCollection(meetings) {
+      return {
+        getAll: () => meetings,
+      };
+    }
+
+    function createMockMeeting(id, hashTreeParsersMap) {
+      return {
+        id,
+        locusInfo: {
+          hashTreeParsers: hashTreeParsersMap,
+        },
+      };
+    }
+
+    function createSelfElement(devices) {
+      return {
+        htMeta: {elementId: {type: 'Self'}},
+        data: {
+          devices,
+        },
+      };
+    }
+
+    it('returns the meeting when locusUrl matches a hashTreeParser directly', () => {
+      const locusUrl = 'https://locus.example.com/loci/abc123';
+      const parsersMap = new Map([[locusUrl, {state: 'active'}]]);
+      const meeting = createMockMeeting('meeting1', parsersMap);
+      const collection = createMockMeetingCollection({meeting1: meeting});
+
+      const message = {locusUrl, locusStateElements: []};
+
+      const result = findMeetingForHashTreeMessage(message, collection, deviceUrl);
+
+      assert.equal(result, meeting);
+    });
+
+    it('returns undefined when no meeting matches and message has no locusStateElements', () => {
+      const locusUrl = 'https://locus.example.com/loci/unknown';
+      const parsersMap = new Map([['https://locus.example.com/loci/other', {state: 'active'}]]);
+      const meeting = createMockMeeting('meeting1', parsersMap);
+      const collection = createMockMeetingCollection({meeting1: meeting});
+
+      const message = {locusUrl};
+
+      const result = findMeetingForHashTreeMessage(message, collection, deviceUrl);
+
+      assert.isUndefined(result);
+    });
+
+    it('returns undefined when no meeting matches and self element has no replaces', () => {
+      const locusUrl = 'https://locus.example.com/loci/unknown';
+      const parsersMap = new Map([['https://locus.example.com/loci/other', {state: 'active'}]]);
+      const meeting = createMockMeeting('meeting1', parsersMap);
+      const collection = createMockMeetingCollection({meeting1: meeting});
+
+      const selfElement = createSelfElement([{url: deviceUrl}]);
+      const message = {locusUrl, locusStateElements: [selfElement]};
+
+      const result = findMeetingForHashTreeMessage(message, collection, deviceUrl);
+
+      assert.isUndefined(result);
+    });
+
+    it('returns the meeting when locusUrl from replaces matches a hashTreeParser', () => {
+      const oldLocusUrl = 'https://locus.example.com/loci/old';
+      const newLocusUrl = 'https://locus.example.com/loci/new';
+      const parsersMap = new Map([[oldLocusUrl, {state: 'active'}]]);
+      const meeting = createMockMeeting('meeting1', parsersMap);
+      const collection = createMockMeetingCollection({meeting1: meeting});
+
+      const selfElement = createSelfElement([
+        {url: deviceUrl, replaces: [{locusUrl: oldLocusUrl}]},
+      ]);
+      const message = {locusUrl: newLocusUrl, locusStateElements: [selfElement]};
+
+      const result = findMeetingForHashTreeMessage(message, collection, deviceUrl);
+
+      assert.equal(result, meeting);
+    });
+
+    it('returns undefined when replaces locusUrl does not match any hashTreeParser', () => {
+      const oldLocusUrl = 'https://locus.example.com/loci/old';
+      const newLocusUrl = 'https://locus.example.com/loci/new';
+      const parsersMap = new Map([
+        ['https://locus.example.com/loci/something-else', {state: 'active'}],
+      ]);
+      const meeting = createMockMeeting('meeting1', parsersMap);
+      const collection = createMockMeetingCollection({meeting1: meeting});
+
+      const selfElement = createSelfElement([
+        {url: deviceUrl, replaces: [{locusUrl: oldLocusUrl}]},
+      ]);
+      const message = {locusUrl: newLocusUrl, locusStateElements: [selfElement]};
+
+      const result = findMeetingForHashTreeMessage(message, collection, deviceUrl);
+
+      assert.isUndefined(result);
+    });
+
+    it('returns undefined when meetingCollection is empty', () => {
+      const collection = createMockMeetingCollection({});
+      const message = {locusUrl: 'https://locus.example.com/loci/abc', locusStateElements: []};
+
+      const result = findMeetingForHashTreeMessage(message, collection, deviceUrl);
+
+      assert.isUndefined(result);
+    });
+
+    it('checks multiple meetings and returns the correct one', () => {
+      const targetLocusUrl = 'https://locus.example.com/loci/target';
+      const meeting1 = createMockMeeting(
+        'meeting1',
+        new Map([['https://locus.example.com/loci/other', {state: 'active'}]])
+      );
+      const meeting2 = createMockMeeting(
+        'meeting2',
+        new Map([[targetLocusUrl, {state: 'active'}]])
+      );
+      const collection = createMockMeetingCollection({meeting1, meeting2});
+
+      const message = {locusUrl: targetLocusUrl, locusStateElements: []};
+
+      const result = findMeetingForHashTreeMessage(message, collection, deviceUrl);
+
+      assert.equal(result, meeting2);
+    });
+
+    it('ignores devices that do not match deviceUrl when looking for replaces', () => {
+      const oldLocusUrl = 'https://locus.example.com/loci/old';
+      const newLocusUrl = 'https://locus.example.com/loci/new';
+      const parsersMap = new Map([[oldLocusUrl, {state: 'active'}]]);
+      const meeting = createMockMeeting('meeting1', parsersMap);
+      const collection = createMockMeetingCollection({meeting1: meeting});
+
+      // self element has replaces, but on a different device
+      const selfElement = createSelfElement([
+        {url: 'https://devices.example.com/other-device', replaces: [{locusUrl: oldLocusUrl}]},
+      ]);
+      const message = {locusUrl: newLocusUrl, locusStateElements: [selfElement]};
+
+      const result = findMeetingForHashTreeMessage(message, collection, deviceUrl);
+
+      assert.isUndefined(result);
+    });
+
+    it('does not use self element if it is not of type Self', () => {
+      const oldLocusUrl = 'https://locus.example.com/loci/old';
+      const newLocusUrl = 'https://locus.example.com/loci/new';
+      const parsersMap = new Map([[oldLocusUrl, {state: 'active'}]]);
+      const meeting = createMockMeeting('meeting1', parsersMap);
+      const collection = createMockMeetingCollection({meeting1: meeting});
+
+      // element has replaces data but is not of type Self
+      const nonSelfElement = {
+        htMeta: {elementId: {type: 'Participant'}},
+        data: {
+          devices: [{url: deviceUrl, replaces: [{locusUrl: oldLocusUrl}]}],
+        },
+      };
+      const message = {locusUrl: newLocusUrl, locusStateElements: [nonSelfElement]};
+
+      const result = findMeetingForHashTreeMessage(message, collection, deviceUrl);
+
+      assert.isUndefined(result);
     });
   });
 });