@webex/plugin-meetings 3.12.0-next.8 → 3.12.0-task-refactor.1

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, {createLocusFromHashTreeMessage, findMeetingForHashTreeMessage} from '@webex/plugin-meetings/src/locus-info';
+import LocusInfo 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,8 +29,7 @@ import {
 } from '../../../../src/constants';
 
 import {self, selfWithInactivity} from './selfConstant';
-import {MEETING_REMOVED_REASON} from '@webex/plugin-meetings/src/constants';
-import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+import { MEETING_REMOVED_REASON } from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings', () => {
   describe('LocusInfo index', () => {
@@ -105,10 +104,9 @@ describe('plugin-meetings', () => {
       });
 
       const createHashTreeMessage = (visibleDataSets) => ({
-        locusUrl: 'http://locus-url.com',
         locusStateElements: [
           {
-            htMeta: {elementId: {type: 'metadata'}},
+            htMeta: {elementId: {type: 'self'}},
             data: {visibleDataSets},
           },
         ],
@@ -116,7 +114,6 @@ describe('plugin-meetings', () => {
       });
 
       const createLocusWithVisibleDataSets = (visibleDataSets) => ({
-        url: 'http://locus-url.com',
         self: {visibleDataSets},
         participants: [],
         links: {
@@ -139,12 +136,8 @@ describe('plugin-meetings', () => {
           HashTreeParserStub,
           sinon.match({
             initialLocus: {
-              locus: null,
-              dataSets: hashTreeMessage.dataSets,
-            },
-            metadata: {
-              htMeta: hashTreeMessage.locusStateElements[0].htMeta,
-              visibleDataSets,
+              locus: {self: {visibleDataSets}},
+              dataSets: [],
             },
             webexRequest: sinon.match.func,
             locusInfoUpdateCallback: sinon.match.func,
@@ -176,16 +169,11 @@ 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(
@@ -195,7 +183,6 @@ describe('plugin-meetings', () => {
               locus,
               dataSets,
             },
-            metadata,
             webexRequest: sinon.match.func,
             locusInfoUpdateCallback: sinon.match.func,
             debugId: sinon.match.string,
@@ -233,13 +220,12 @@ describe('plugin-meetings', () => {
           HashTreeParserStub,
           sinon.match({
             initialLocus: {
-              locus: null,
+              locus: {self: {visibleDataSets}},
               dataSets: [],
             },
             webexRequest: sinon.match.func,
             locusInfoUpdateCallback: sinon.match.func,
             debugId: sinon.match.string,
-            metadata: null,
           })
         );
         assert.calledOnceWithExactly(mockHashTreeParser.initializeFromGetLociResponse, locus);
@@ -263,30 +249,6 @@ 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;
@@ -301,11 +263,10 @@ describe('plugin-meetings', () => {
           await locusInfo.initialSetup({
             trigger: 'locus-message',
             hashTreeMessage: {
-              locusUrl: 'fake-locus-url',
               locusStateElements: [
                 {
-                  htMeta: {elementId: {type: 'Metadata'}},
-                  data: {visibleDataSets: [{name: 'dataset1', url: 'test-url'}]},
+                  htMeta: {elementId: {type: 'self'}},
+                  data: {visibleDataSets: ['dataset1']},
                 },
               ],
               dataSets: [{name: 'dataset1', url: 'test-url'}],
@@ -332,16 +293,6 @@ 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'},
@@ -360,13 +311,6 @@ 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'},
@@ -384,18 +328,8 @@ 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: [], forceReplaceMembers: false},
+            jsSdkMeta: {removedParticipantIds: []},
             participants: [], // empty means there were no participant updates
             replaces: {id: 'fake-replaces'},
             self: {id: 'fake-self'},
@@ -424,134 +358,11 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('should process locus update correctly when called with updated SELF (webinar non-attendee)', () => {
-          const newSelf = {
-            id: 'new-self',
-            visibleDataSets: ['dataset1', 'dataset2'],
-            controls: {
-              role: {
-                roles: [
-                  {type: 'PANELIST', hasRole: true},
-                  {type: 'ATTENDEE', hasRole: false},
-                ],
-              },
-            },
-          };
-          locusInfo.info.isWebinar = true;
-
-          // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
-            updatedObjects: [{htMeta: {elementId: {type: 'self'}}, data: newSelf}],
-          });
-
-          // check onDeltaLocus() was called with correctly updated locus info
-          // without any participant generated
-          assert.calledOnceWithExactly(onDeltaLocusStub, {
-            ...expectedLocusInfo,
-            info: {
-              ...expectedLocusInfo.info,
-              isWebinar: true,
-            },
-            self: newSelf,
-          });
-        });
-
-        it('should generate a participant when called with updated SELF for webinar attendee', () => {
-          const newSelf = {
-            id: 'new-self',
-            visibleDataSets: ['dataset1', 'dataset2'],
-            controls: {
-              role: {
-                roles: [
-                  {type: 'something else - should be ignored', hasRole: true},
-                  {type: 'ATTENDEE', hasRole: true},
-                ],
-              },
-            },
-          };
-
-          locusInfo.info.isWebinar = true;
-
-          // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
-            updatedObjects: [{htMeta: {elementId: {type: 'self'}}, data: newSelf}],
-          });
-
-          // check onDeltaLocus() was called with correctly updated locus info
-          // that contains a participant created from self
-          assert.calledOnceWithExactly(onDeltaLocusStub, {
-            ...expectedLocusInfo,
-            info: {
-              ...expectedLocusInfo.info,
-              isWebinar: true,
-            },
-            self: newSelf,
-            participants: [
-              {
-                ...newSelf,
-              },
-            ],
-          });
-        });
-
-        it('should process locus update correctly when called with updated fullState', () => {
-          const newFullState = {
-            id: 'new-fullState',
-            visibleDataSets: ['dataset1', 'dataset2'],
-          };
-
-          // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
-            updatedObjects: [{htMeta: {elementId: {type: 'fullState'}}, data: newFullState}],
-          });
-
-          // check onDeltaLocus() was called with correctly updated locus info
-          assert.calledOnceWithExactly(onDeltaLocusStub, {
-            ...expectedLocusInfo,
-            fullState: newFullState,
-          });
-        });
-
-        it('should process locus update correctly when called with updated info', () => {
-          const newInfo = {
-            id: 'new-info',
-            visibleDataSets: ['dataset1', 'dataset2'],
-          };
-
-          // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
-            updatedObjects: [{htMeta: {elementId: {type: 'info'}}, data: newInfo}],
-          });
-
-          // check onDeltaLocus() was called with correctly updated locus info
-          assert.calledOnceWithExactly(onDeltaLocusStub, {
-            ...expectedLocusInfo,
-            info: newInfo,
-          });
-        });
-
-        it('should process locus update correctly when called with updated links', () => {
-          const newLinks = {
-            id: 'new-links',
-            visibleDataSets: ['dataset1', 'dataset2'],
-          };
-
-          // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
-            updatedObjects: [{htMeta: {elementId: {type: 'links'}}, data: newLinks}],
-          });
-
-          // check onDeltaLocus() was called with correctly updated locus info
-          assert.calledOnceWithExactly(onDeltaLocusStub, {
-            ...expectedLocusInfo,
-            links: newLinks,
-          });
-        });
-
         it('should process locus update correctly when called with updated LOCUS object', () => {
           // setup new updated locus that has many things missing
           const newLocusHtMeta = {elementId: {type: 'locus', version: 42}};
           const newLocus = {
+            conntrols: 'new-controls',
             host: 'new-host',
             htMeta: newLocusHtMeta,
           };
@@ -563,67 +374,10 @@ describe('plugin-meetings', () => {
 
           // check onDeltaLocus() was called with correctly updated locus info
           assert.calledOnceWithExactly(onDeltaLocusStub, {
-            // these fields are not part of Locus object, so should keep their old values:
-            controls: {id: 'fake-controls'},
-            info: {id: 'fake-info'},
-            fullState: {id: 'fake-full-state'},
-            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: [], forceReplaceMembers: false}, // no participants were removed
-          });
-        });
-
-        // this test is checking that we cope with an edge case if Locus
-        // sends us something that they shouldn't
-        it('should process locus update correctly when called with updated LOCUS object that contains info/fullState/self/participants etc', () => {
-          // setup new updated locus that has many things missing
-          const newLocusHtMeta = {elementId: {type: 'locus', version: 42}};
-          const newLocus = {
-            host: 'new-host',
-            htMeta: newLocusHtMeta,
-          };
-
-          // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
-            updatedObjects: [
-              {
-                htMeta: newLocusHtMeta,
-                data: {
-                  ...newLocus,
-                  // all these fields below should be ignored and not override the existing ones in our "old" Locus
-                  controls: {id: 'new-controls'},
-                  info: 'new-info',
-                  fullState: 'new-fullState',
-                  self: 'new-self',
-                  participants: 'new-participants',
-                  mediaShares: 'new-mediaShares',
-                  embeddedApps: 'new-embeddedApps',
-                },
-              },
-            ],
-          });
-
-          // check onDeltaLocus() was called with correctly updated locus info
-          // with old values for the fields that should be ignored (like "info" or "fullState")
-          assert.calledOnceWithExactly(onDeltaLocusStub, {
-            // these fields have the "old" values:
-            controls: {id: 'fake-controls'},
-            info: {id: 'fake-info'},
-            fullState: {id: 'fake-full-state'},
-            self: {id: 'fake-self'},
-            links: {id: 'fake-links'},
-            mediaShares: expectedLocusInfo.mediaShares,
-            embeddedApps: expectedLocusInfo.embeddedApps,
-            participants: [], // empty means there were no participant updates
-            jsSdkMeta: {removedParticipantIds: [], forceReplaceMembers: false}, // no participants were removed
-            ...newLocus,
-            htMeta: newLocusHtMeta,
+            jsSdkMeta: {removedParticipantIds: []}, // no participants were removed
           });
         });
 
@@ -648,19 +402,10 @@ describe('plugin-meetings', () => {
 
           // check onDeltaLocus() was called with correctly updated locus info
           assert.calledOnceWithExactly(onDeltaLocusStub, {
-            // these fields are not part of Locus object, so should keep their old values:
-            controls: {id: 'fake-controls'},
-            info: {id: 'fake-info'},
-            fullState: {id: 'fake-full-state'},
-            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: [], forceReplaceMembers: false}, // no participants were removed
+            jsSdkMeta: {removedParticipantIds: []}, // no participants were removed
           });
         });
 
@@ -748,7 +493,7 @@ describe('plugin-meetings', () => {
           assert.calledOnceWithExactly(onDeltaLocusStub, {
             ...expectedLocusInfo,
             participants: [newParticipant, updatedParticipant2],
-            jsSdkMeta: {removedParticipantIds: ['fake-participant-1'], forceReplaceMembers: false},
+            jsSdkMeta: {removedParticipantIds: ['fake-participant-1']},
           });
           // and that the hashTreeObjectId2ParticipantId map was updated correctly
           assert.isUndefined(locusInfo.hashTreeObjectId2ParticipantId.get('fake-ht-participant-1'));
@@ -795,39 +540,6 @@ 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',
@@ -873,60 +585,6 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('should process locus update correctly when called with multiple CONTROL object updates', () => {
-          const firstControl = {
-            muteOnEntry: {enabled: true},
-            lock: {locked: true, meta: {lastModified: 'YESTERDAY', modifiedBy: 'John Doe'}},
-          };
-          const secondControl = {
-            reactions: {enabled: true},
-          };
-
-          // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
-          locusInfoUpdateCallback(OBJECTS_UPDATED, {
-            updatedObjects: [
-              {
-                htMeta: {elementId: {type: 'controlentry', id: 'control-1'}},
-                data: firstControl,
-              },
-              {
-                htMeta: {elementId: {type: 'controlentry', id: 'control-2'}},
-                data: secondControl,
-              },
-            ],
-          });
-
-          // check onDeltaLocus() was called with correctly updated locus info
-          // all keys from both controls should be merged into the controls object
-          assert.calledOnceWithExactly(onDeltaLocusStub, {
-            ...expectedLocusInfo,
-            controls: {
-              id: 'fake-controls',
-              muteOnEntry: {enabled: true},
-              lock: {locked: true, meta: {lastModified: 'YESTERDAY', modifiedBy: 'John Doe'}},
-              reactions: {enabled: true},
-            },
-          });
-        });
-
-        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, {
-            updatedObjects: [
-              {
-                htMeta: {elementId: {type: 'controlentry', id: 'some-control-id'}},
-                data: null,
-              },
-            ],
-          });
-
-          // check onDeltaLocus() was called with correctly updated locus info
-          // when data is null, it should be ignored and not change the controls
-          assert.calledOnceWithExactly(onDeltaLocusStub, {
-            ...expectedLocusInfo,
-          });
-        });
-
         it('should handle MEETING_ENDED correctly', () => {
           const fakeMeeting = {id: 'fake-meeting-from-collection'};
           const collectionGetStub = sinon
@@ -944,78 +602,6 @@ 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');
-        });
       });
     });
 
@@ -1251,7 +837,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(
@@ -1513,62 +1099,6 @@ describe('plugin-meetings', () => {
         );
       });
 
-      it('should update the hesiod llm id', () => {
-        locusInfo.emitScoped = sinon.stub();
-        locusInfo.controls = {
-          transcribe: {
-            transcribing: false,
-            caption: true,
-            hesiodLlmId: '123a-456b-789c',
-          },
-        };
-        newControls.transcribe.transcribing = false;
-        newControls.transcribe.caption = true;
-        newControls.transcribe.hesiodLlmId = '789d-456e-123f';
-
-        locusInfo.updateControls(newControls);
-
-        assert.calledWith(
-          locusInfo.emitScoped,
-          {
-            file: 'locus-info',
-            function: 'updateControls',
-          },
-          LOCUSINFO.EVENTS.CONTROLS_MEETING_HESIOD_LLM_ID_UPDATED,
-          {
-            hesiodLlmId: '789d-456e-123f',
-          }
-        );
-      });
-
-      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 = {
@@ -1834,6 +1364,7 @@ describe('plugin-meetings', () => {
         );
       });
 
+
       it('should call with participant display name', () => {
         const failureParticipant = [
           {
@@ -1858,7 +1389,7 @@ describe('plugin-meetings', () => {
             displayName: 'Test User',
           }
         );
-      });
+      })
     });
 
     describe('#updateSelf', () => {
@@ -2659,8 +2190,8 @@ describe('plugin-meetings', () => {
           {
             isInitializing: !self,
           }
-        );
-      });
+          );
+        });
 
       const checkMeetingInfoUpdatedCalled = (expected, payload) => {
         const expectedArgs = [
@@ -3008,359 +2539,32 @@ describe('plugin-meetings', () => {
 
         const clonedApps = cloneDeep(newEmbeddedApps);
 
-        locusInfo.updateEmbeddedApps(clonedApps);
-
-        assert.notCalled(locusInfo.emitScoped);
-      });
-
-      it('emits EMBEDDED_APPS_UPDATED when apps changed', () => {
-        locusInfo.updateEmbeddedApps(newEmbeddedApps);
-
-        locusInfo.emitScoped = sinon.stub();
-
-        const clonedApps = cloneDeep(newEmbeddedApps);
-
-        clonedApps[0].state = 'STOPPED';
-        const expectedApps = EmbeddedAppsUtils.parse(clonedApps);
-
-        locusInfo.updateEmbeddedApps(clonedApps);
-
-        assert.calledWith(
-          locusInfo.emitScoped,
-          {
-            file: 'locus-info',
-            function: 'updateEmbeddedApps',
-          },
-          LOCUSINFO.EVENTS.EMBEDDED_APPS_UPDATED,
-          expectedApps
-        );
-      });
-    });
-
-    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,
-        });
+        locusInfo.updateEmbeddedApps(clonedApps);
 
-        assert.isTrue(locusInfo.hashTreeParsers.has(locusUrlB));
-        assert.equal(locusInfo.hashTreeParsers.get(locusUrlA).replacedAt, '2026-05-01T00:00:00Z');
+        assert.notCalled(locusInfo.emitScoped);
       });
-    });
-
-    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,
-        });
+      it('emits EMBEDDED_APPS_UPDATED when apps changed', () => {
+        locusInfo.updateEmbeddedApps(newEmbeddedApps);
 
-        assert.notCalled(parserA.handleMessage);
-      });
+        locusInfo.emitScoped = sinon.stub();
 
-      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 clonedApps = cloneDeep(newEmbeddedApps);
 
-        const message = {
-          locusUrl: locusUrlA,
-          locusStateElements: [],
-          dataSets: [],
-        };
+        clonedApps[0].state = 'STOPPED';
+        const expectedApps = EmbeddedAppsUtils.parse(clonedApps);
 
-        locusInfo.parse(mockMeeting, {
-          eventType: LOCUSEVENT.HASH_TREE_DATA_UPDATED,
-          stateElementsMessage: message,
-        });
+        locusInfo.updateEmbeddedApps(clonedApps);
 
-        assert.calledOnceWithExactly(parserA.handleMessage, message);
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateEmbeddedApps',
+          },
+          LOCUSINFO.EVENTS.EMBEDDED_APPS_UPDATED,
+          expectedApps
+        );
       });
     });
 
@@ -3374,8 +2578,8 @@ 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, url: 'http://locus-url.com'};
+      it('does nothing when we are using hash trees', () => {
+        const fakeLocus = {eventType: LOCUSEVENT.DIFFERENCE};
         const fakeDataSets = [{name: 'dataset1', url: 'http://test.com'}];
         const responseBody = {locus: fakeLocus, dataSets: fakeDataSets};
 
@@ -3383,53 +2587,14 @@ describe('plugin-meetings', () => {
         const mockHashTreeParser = {
           handleLocusUpdate: sinon.stub(),
         };
-        locusInfo.hashTreeParsers.set(fakeLocus.url, {
-          parser: mockHashTreeParser,
-          initializedFromHashTree: true,
-        });
+        locusInfo.hashTreeParser = mockHashTreeParser;
 
         sinon.stub(locusInfo, 'onDeltaLocus');
 
         locusInfo.handleLocusAPIResponse(mockMeeting, responseBody);
 
-        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);
+        assert.notCalled(mockHashTreeParser.handleLocusUpdate);
+        assert.notCalled(locusInfo.onDeltaLocus);
       });
     });
 
@@ -3492,28 +2657,31 @@ 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, '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, "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, "updateParticipantsUrl");
+        sinon.stub(locusInfo, "updateReplace");
+        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, "updateMemberShip");
+        sinon.stub(locusInfo, "updateIdentifiers");
+        sinon.stub(locusInfo, "updateEmbeddedApps");
+        sinon.stub(locusInfo, "updateResources");
+        sinon.stub(locusInfo, "compareAndUpdate");
 
         locusInfo.updateLocusInfo(locus);
 
@@ -3536,14 +2704,17 @@ describe('plugin-meetings', () => {
         locusInfo.updateHostInfo = sinon.stub();
         locusInfo.updateMeetingInfo = sinon.stub();
         locusInfo.updateMediaShares = sinon.stub();
-        locusInfo.updateReplaces = sinon.stub();
+        locusInfo.updateParticipantsUrl = sinon.stub();
+        locusInfo.updateReplace = sinon.stub();
         locusInfo.updateSelf = sinon.stub();
         locusInfo.updateLocusUrl = sinon.stub();
         locusInfo.updateAclUrl = sinon.stub();
         locusInfo.updateBasequence = sinon.stub();
         locusInfo.updateSequence = sinon.stub();
+        locusInfo.updateMemberShip = sinon.stub();
+        locusInfo.updateIdentifiers = sinon.stub();
         locusInfo.updateEmbeddedApps = sinon.stub();
-        locusInfo.updateLinks = sinon.stub();
+        locusInfo.updateResources = sinon.stub();
         locusInfo.compareAndUpdate = sinon.stub();
 
         locusInfo.updateLocusInfo(newLocus);
@@ -3555,49 +2726,21 @@ describe('plugin-meetings', () => {
         assert.notCalled(locusInfo.updateHostInfo);
         assert.notCalled(locusInfo.updateMeetingInfo);
         assert.notCalled(locusInfo.updateMediaShares);
-        assert.notCalled(locusInfo.updateReplaces);
+        assert.notCalled(locusInfo.updateParticipantsUrl);
+        assert.notCalled(locusInfo.updateReplace);
         assert.notCalled(locusInfo.updateSelf);
         assert.notCalled(locusInfo.updateLocusUrl);
         assert.notCalled(locusInfo.updateAclUrl);
         assert.notCalled(locusInfo.updateBasequence);
         assert.notCalled(locusInfo.updateSequence);
+        assert.notCalled(locusInfo.updateMemberShip);
+        assert.notCalled(locusInfo.updateIdentifiers);
         assert.notCalled(locusInfo.updateEmbeddedApps);
-        assert.notCalled(locusInfo.updateLinks);
+        assert.notCalled(locusInfo.updateResources);
         assert.notCalled(locusInfo.compareAndUpdate);
       });
 
-      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 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'}};
-        const self = {id: 'self id'};
-        const mediaShares = [{id: 'fake media share'}];
-
-        sinon.stub(SelfUtils, 'getSelves').returns({
-          current: {},
-          previous: {},
-          updates: {},
-        });
-
-        const newLocus = {
-          info,
-          fullState,
-          links,
-          self,
-          mediaShares,
-        };
-
-        locusInfo.updateLocusInfo(newLocus);
 
-        assert.deepEqual(locusInfo.info, newLocus.info);
-        assert.deepEqual(locusInfo.fullState, newLocus.fullState);
-        assert.deepEqual(locusInfo.links, newLocus.links);
-        assert.deepEqual(locusInfo.self, newLocus.self);
-        assert.deepEqual(locusInfo.mediaShares, newLocus.mediaShares);
-      });
 
       it('onFullLocus() updates the working-copy of locus parser', () => {
         const eventType = 'fakeEvent';
@@ -3608,7 +2751,7 @@ describe('plugin-meetings', () => {
         sandbox.stub(locusInfo, 'handleOneOnOneEvent');
         sandbox.stub(locusParser, 'isNewFullLocus').returns(true);
 
-        locusInfo.onFullLocus('test', fakeLocus, eventType);
+        locusInfo.onFullLocus(fakeLocus, eventType);
 
         assert.equal(fakeLocus, locusParser.workingCopy);
       });
@@ -3629,7 +2772,7 @@ describe('plugin-meetings', () => {
 
         sandbox.stub(locusParser, 'isNewFullLocus').returns(false);
 
-        locusInfo.onFullLocus('test', fakeLocus, eventType);
+        locusInfo.onFullLocus(fakeLocus, eventType);
 
         spies.forEach((spy) => {
           assert.notCalled(spy);
@@ -3779,11 +2922,7 @@ describe('plugin-meetings', () => {
         }).then(() => {
           assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'oldLocusUrl'});
 
-          assert.calledOnceWithExactly(
-            meeting.locusInfo.onFullLocus,
-            'classic Locus sync',
-            fakeFullLocusDto
-          );
+          assert.calledOnceWithExactly(meeting.locusInfo.onFullLocus, fakeFullLocusDto);
           assert.calledOnce(locusInfo.locusParser.resume);
         });
       });
@@ -3881,11 +3020,7 @@ describe('plugin-meetings', () => {
             });
 
             assert.notCalled(meeting.locusInfo.handleLocusDelta);
-            assert.calledOnceWithExactly(
-              meeting.locusInfo.onFullLocus,
-              'classic Locus sync',
-              fakeFullLocusDto
-            );
+            assert.calledOnceWithExactly(meeting.locusInfo.onFullLocus, fakeFullLocusDto);
             assert.calledOnce(locusInfo.locusParser.resume);
           });
         });
@@ -4061,11 +3196,7 @@ describe('plugin-meetings', () => {
           url: 'fake locus DELTA url',
         });
         assert.notCalled(meeting.locusInfo.handleLocusDelta);
-        assert.calledOnceWithExactly(
-          meeting.locusInfo.onFullLocus,
-          'classic Locus sync',
-          fakeFullLocusDto
-        );
+        assert.calledOnceWithExactly(meeting.locusInfo.onFullLocus, fakeFullLocusDto);
         assert.calledOnce(locusInfo.locusParser.resume);
       });
     });
@@ -4086,137 +3217,6 @@ 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', () => {
@@ -4568,7 +3568,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);
 
@@ -4581,12 +3581,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);
 
@@ -4599,8 +3599,8 @@ describe('plugin-meetings', () => {
           EVENTS.LOCUS_INFO_UPDATE_URL,
           {
             url: fakeUrl,
-            isMainLocus: false,
-          }
+            isMainLocus: false
+          },
         );
       });
     });
@@ -4652,8 +3652,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;
@@ -4662,7 +3662,7 @@ describe('plugin-meetings', () => {
           getLocusDTO: syncRequestStub,
         };
 
-        locusInfo.onFullLocus('test', {
+        locusInfo.onFullLocus({
           sequence: {
             rangeStart: 0,
             rangeEnd: 0,
@@ -4900,9 +3900,7 @@ 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'}},
@@ -4921,377 +3919,12 @@ describe('plugin-meetings', () => {
         const mockHashTreeParser = {
           handleMessage: sinon.stub(),
         };
-        locusInfo.hashTreeParsers.set(fakeLocusUrl, {
-          parser: mockHashTreeParser,
-          initializedFromHashTree: true,
-        });
+        locusInfo.hashTreeParser = mockHashTreeParser;
 
         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);
     });
   });
 });