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

package/test/unit/spec/hashTree/hashTreeParser.ts

@@ -5,6 +5,9 @@ import HashTree from '@webex/plugin-meetings/src/hashTree/hashTree';
 import {expect} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
+import {EMPTY_HASH} from '@webex/plugin-meetings/src/hashTree/constants';
+
+const visibleDataSetsUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/visibleDataSets';
 
 const exampleInitialLocus = {
   dataSets: [
@@ -46,6 +49,7 @@ const exampleInitialLocus = {
       },
       dataSetNames: ['main'],
     },
+    links: {resources: {visibleDataSets: {url: visibleDataSetsUrl}}},
     participants: [
       {
         url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/11941033',
@@ -62,7 +66,6 @@ const exampleInitialLocus = {
     ],
     self: {
       url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/11941033',
-      visibleDataSets: ['main', 'self', 'atd-unmuted'],
       person: {},
       htMeta: {
         elementId: {
@@ -76,6 +79,28 @@ const exampleInitialLocus = {
   },
 };
 
+const exampleMetadata = {
+  htMeta: {
+    elementId: {
+      type: 'metadata',
+      id: 5,
+      version: 50,
+    },
+    dataSetNames: ['self'],
+  },
+  visibleDataSets: [
+    {name: 'main', url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main'},
+    {
+      name: 'self',
+      url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+    },
+    {
+      name: 'atd-unmuted',
+      url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/atd-unmuted',
+    },
+  ],
+};
+
 function createDataSet(name: string, leafCount: number, version = 1) {
   return {
     url: `https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/${name}`,
@@ -119,7 +144,6 @@ function mockSyncRequest(webexRequest: sinon.SinonStub, datasetUrl: string, resp
 }
 
 describe('HashTreeParser', () => {
-  const visibleDataSetsUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/visibleDataSets';
   const locusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f';
 
   let clock;
@@ -139,9 +163,13 @@ describe('HashTreeParser', () => {
   });
 
   // Helper to create a HashTreeParser instance with common defaults
-  function createHashTreeParser(initialLocus: any = exampleInitialLocus) {
+  function createHashTreeParser(
+    initialLocus: any = exampleInitialLocus,
+    metadata: any = exampleMetadata
+  ) {
     return new HashTreeParser({
       initialLocus,
+      metadata,
       webexRequest,
       locusInfoUpdateCallback: callback,
       debugId: 'test',
@@ -197,9 +225,50 @@ describe('HashTreeParser', () => {
         body: response,
       });
   }
+
+  async function checkAsyncDatasetInitialization(
+    parser: HashTreeParser,
+    newDataSet: {name: string; leafCount: number; url: string}
+  ) {
+    // immediately we don't have the dataset yet, so it should not be in visibleDataSets
+    // and no hash tree should exist yet
+    expect(parser.visibleDataSets.some((vds) => vds.name === newDataSet.name)).to.be.false;
+    assert.isUndefined(parser.dataSets[newDataSet.name]);
+
+    // Wait for the async initialization to complete (queued as microtask)
+    await clock.tickAsync(0);
+
+    // The visibleDataSets is updated from the metadata object data
+    expect(parser.visibleDataSets.some((vds) => vds.name === newDataSet.name)).to.be.true;
+
+    // Verify that a hash tree was created for newDataSet
+    assert.exists(parser.dataSets[newDataSet.name].hashTree);
+    assert.equal(parser.dataSets[newDataSet.name].hashTree.numLeaves, newDataSet.leafCount);
+
+    // Verify getAllDataSetsMetadata was called for async initialization
+    assert.calledWith(
+      webexRequest,
+      sinon.match({
+        method: 'GET',
+        uri: visibleDataSetsUrl,
+      })
+    );
+
+    // Verify sync request was sent for the new dataset
+    assert.calledWith(
+      webexRequest,
+      sinon.match({
+        method: 'POST',
+        uri: `${newDataSet.url}/sync`,
+      })
+    );
+  }
   it('should correctly initialize trees from initialLocus data', () => {
     const parser = createHashTreeParser();
 
+    // verify that visibleDataSetsUrl is read out from inside locus
+    expect(parser.visibleDataSetsUrl).to.equal(visibleDataSetsUrl);
+
     // Check that the correct number of trees are created
     expect(Object.keys(parser.dataSets).length).to.equal(3);
 
@@ -215,7 +284,11 @@ describe('HashTreeParser', () => {
     const selfTree = parser.dataSets.self.hashTree;
     expect(selfTree).to.be.instanceOf(HashTree);
     const expectedSelfLeaves = new Array(1).fill(null).map(() => ({}));
-    expectedSelfLeaves[4 % 1] = {self: {4: {type: 'self', id: 4, version: 100}}};
+    // Both self (id=4) and metadata (id=5) map to the same leaf (4%1=0, 5%1=0)
+    expectedSelfLeaves[0] = {
+      self: {4: {type: 'self', id: 4, version: 100}},
+      metadata: {5: {type: 'metadata', id: 5, version: 50}},
+    };
     expect(selfTree.leaves).to.deep.equal(expectedSelfLeaves);
     expect(selfTree.numLeaves).to.equal(1);
 
@@ -247,7 +320,7 @@ describe('HashTreeParser', () => {
       name: 'empty-set',
     });
 
-    const parser = createHashTreeParser(modifiedLocus);
+    const parser = createHashTreeParser(modifiedLocus, exampleMetadata);
 
     expect(Object.keys(parser.dataSets).length).to.equal(4); // main, self, atd-unmuted (now empty), empty-set
 
@@ -260,7 +333,10 @@ describe('HashTreeParser', () => {
 
     const selfTree = parser.dataSets.self.hashTree;
     const expectedSelfLeaves = new Array(1).fill(null).map(() => ({}));
-    expectedSelfLeaves[4 % 1] = {self: {4: {type: 'self', id: 4, version: 100}}};
+    expectedSelfLeaves[4 % 1] = {
+      self: {4: {type: 'self', id: 4, version: 100}},
+      metadata: {5: exampleMetadata.htMeta.elementId},
+    };
     expect(selfTree.leaves).to.deep.equal(expectedSelfLeaves);
     expect(selfTree.numLeaves).to.equal(1);
 
@@ -283,25 +359,34 @@ describe('HashTreeParser', () => {
     // Create a parser with minimal initial data
     const minimalInitialLocus = {
       dataSets: [],
-      locus: {
-        self: {
-          visibleDataSets: ['main', 'self'],
+      locus: null,
+    };
+
+    const minimalMetadata = {
+      htMeta: {
+        elementId: {
+          type: 'metadata',
+          id: 5,
+          version: 50,
         },
+        dataSetNames: ['self'],
       },
+      visibleDataSets: [
+        {name: 'main', url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main'},
+        {
+          name: 'self',
+          url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+        },
+      ],
     };
 
-    const hashTreeParser = createHashTreeParser(minimalInitialLocus);
+    const hashTreeParser = createHashTreeParser(minimalInitialLocus, minimalMetadata);
 
     // Setup the datasets that will be returned from getAllDataSetsMetadata
     const mainDataSet = createDataSet('main', 16, 1100);
     const selfDataSet = createDataSet('self', 1, 2100);
-    const invisibleDataSet = createDataSet('invisible', 4, 4000);
 
-    mockGetAllDataSetsMetadata(webexRequest, visibleDataSetsUrl, [
-      mainDataSet,
-      selfDataSet,
-      invisibleDataSet,
-    ]);
+    mockGetAllDataSetsMetadata(webexRequest, visibleDataSetsUrl, [mainDataSet, selfDataSet]);
 
     // Mock sync requests for visible datasets with some updated objects
     const mainSyncResponse = {
@@ -357,15 +442,16 @@ describe('HashTreeParser', () => {
       })
     );
 
-    // Verify all datasets are added to dataSets
+    // verify that visibleDataSetsUrl is set on the parser
+    expect(hashTreeParser.visibleDataSetsUrl).to.equal(visibleDataSetsUrl);
+
+    // Verify all datasets returned from visibleDataSetsUrl are added to dataSets
     expect(hashTreeParser.dataSets.main).to.exist;
     expect(hashTreeParser.dataSets.self).to.exist;
-    expect(hashTreeParser.dataSets.invisible).to.exist;
 
     // Verify hash trees are created only for visible datasets
     expect(hashTreeParser.dataSets.main.hashTree).to.be.instanceOf(HashTree);
     expect(hashTreeParser.dataSets.self.hashTree).to.be.instanceOf(HashTree);
-    expect(hashTreeParser.dataSets.invisible.hashTree).to.be.undefined;
 
     // Verify hash trees have correct leaf counts
     expect(hashTreeParser.dataSets.main.hashTree.numLeaves).to.equal(16);
@@ -403,15 +489,6 @@ describe('HashTreeParser', () => {
       })
     );
 
-    // Verify sync request was NOT sent for invisible dataset
-    assert.neverCalledWith(
-      webexRequest,
-      sinon.match({
-        method: 'POST',
-        uri: `${invisibleDataSet.url}/sync`,
-      })
-    );
-
     // Verify callback was called with OBJECTS_UPDATED and correct updatedObjects list
     assert.calledWith(callback, LocusInfoUpdateType.OBJECTS_UPDATED, {
       updatedObjects: [
@@ -443,8 +520,6 @@ describe('HashTreeParser', () => {
     // verify that sync timers are set for visible datasets
     expect(hashTreeParser.dataSets.main.timer).to.not.be.undefined;
     expect(hashTreeParser.dataSets.self.timer).to.not.be.undefined;
-    // and not for invisible dataset
-    expect(hashTreeParser.dataSets.invisible.timer).to.be.undefined;
   };
 
   describe('#initializeFromMessage', () => {
@@ -461,7 +536,7 @@ describe('HashTreeParser', () => {
 
   describe('#initializeFromGetLociResponse', () => {
     it('does nothing if url for visibleDataSets is missing from locus', async () => {
-      const parser = createHashTreeParser({dataSets: [], locus: {}});
+      const parser = createHashTreeParser({dataSets: [], locus: {}}, null);
 
       await parser.initializeFromGetLociResponse({participants: []});
 
@@ -488,12 +563,9 @@ describe('HashTreeParser', () => {
     it('updates hash trees based on provided new locus', () => {
       const parser = createHashTreeParser();
 
-      const mainPutItemsSpy = sinon
-        .spy(parser.dataSets.main.hashTree, 'putItems');
-      const selfPutItemsSpy = sinon
-        .spy(parser.dataSets.self.hashTree, 'putItems');
-      const atdUnmutedPutItemsSpy = sinon
-        .spy(parser.dataSets['atd-unmuted'].hashTree, 'putItems');
+      const mainPutItemsSpy = sinon.spy(parser.dataSets.main.hashTree, 'putItems');
+      const selfPutItemsSpy = sinon.spy(parser.dataSets.self.hashTree, 'putItems');
+      const atdUnmutedPutItemsSpy = sinon.spy(parser.dataSets['atd-unmuted'].hashTree, 'putItems');
 
       // Create a locus update with new htMeta information for some things
       const locusUpdate = {
@@ -540,7 +612,6 @@ describe('HashTreeParser', () => {
           ],
           self: {
             url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/11941033',
-            visibleDataSets: ['main', 'self', 'atd-unmuted'],
             person: {},
             htMeta: {
               elementId: {
@@ -711,6 +782,211 @@ describe('HashTreeParser', () => {
         ],
       });
     });
+
+    it('handles metadata updates with new version', async () => {
+      const parser = createHashTreeParser();
+
+      const selfPutItemSpy = sinon.spy(parser.dataSets.self.hashTree, 'putItem');
+
+      // Create a locus update with updated metadata
+      const locusUpdate = {
+        dataSets: [createDataSet('self', 1, 2100), createDataSet('attendees', 8, 4000)],
+        locus: {
+          links: {resources: {visibleDataSets: {url: visibleDataSetsUrl}}},
+          participants: [
+            {
+              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/15',
+              person: {},
+              htMeta: {
+                elementId: {
+                  type: 'participant',
+                  id: 15, // new participant
+                  version: 999,
+                },
+                dataSetNames: ['attendees'],
+              },
+            },
+          ],
+        },
+        metadata: {
+          htMeta: {
+            elementId: {
+              type: 'metadata',
+              id: 5,
+              version: 51, // incremented version
+            },
+            dataSetNames: ['self'],
+          },
+          // new visibleDataSets: atd-unmuted removed, "attendees" and "new-dataset" added
+          visibleDataSets: [
+            {
+              name: 'main',
+              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
+            },
+            {
+              name: 'self',
+              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+            },
+            {
+              name: 'new-dataset', // this one is not in dataSets, so will require async initialization
+              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/new-dataset',
+            },
+            {
+              name: 'attendees', // this one is in dataSets, so should be processed immediately
+              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/attendees',
+            },
+          ],
+        },
+      };
+
+      // Mock the async initialization of the new dataset
+      const newDataSet = createDataSet('new-dataset', 4, 5000);
+      mockGetAllDataSetsMetadata(webexRequest, visibleDataSetsUrl, [newDataSet]);
+      mockSyncRequest(webexRequest, newDataSet.url, {
+        dataSets: [newDataSet],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [],
+      });
+
+      // Call handleLocusUpdate
+      parser.handleLocusUpdate(locusUpdate);
+
+      // Verify putItem was called on self hash tree with metadata
+      assert.calledOnceWithExactly(selfPutItemSpy, {type: 'metadata', id: 5, version: 51});
+
+      console.log(
+        'callback calls',
+        callback.getCalls().map((call) => JSON.stringify(call.args, null, 2))
+      );
+      // Verify callback was called with metadata object and removed dataset objects
+      assert.calledOnceWithExactly(callback, LocusInfoUpdateType.OBJECTS_UPDATED, {
+        updatedObjects: [
+          // updated metadata object:
+          {
+            htMeta: {
+              elementId: {
+                type: 'metadata',
+                id: 5,
+                version: 51,
+              },
+              dataSetNames: ['self'],
+            },
+            data: {
+              htMeta: {
+                elementId: {
+                  type: 'metadata',
+                  id: 5,
+                  version: 51,
+                },
+                dataSetNames: ['self'],
+              },
+              visibleDataSets: [
+                {
+                  name: 'main',
+                  url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
+                },
+                {
+                  name: 'self',
+                  url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+                },
+                {
+                  name: 'new-dataset',
+                  url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/new-dataset',
+                },
+                {
+                  name: 'attendees',
+                  url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/attendees',
+                },
+              ],
+            },
+          },
+          // removed participant from a removed dataset 'atd-unmuted':
+          {
+            htMeta: {
+              elementId: {
+                type: 'participant',
+                id: 14,
+                version: 300,
+              },
+              dataSetNames: ['atd-unmuted'],
+            },
+            data: null,
+          },
+          // new participant from a new data set 'attendees':
+          {
+            htMeta: {
+              elementId: {
+                type: 'participant',
+                id: 15,
+                version: 999,
+              },
+              dataSetNames: ['attendees'],
+            },
+            data: {
+              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/15',
+              person: {},
+              htMeta: {
+                elementId: {
+                  type: 'participant',
+                  id: 15,
+                  version: 999,
+                },
+                dataSetNames: ['attendees'],
+              },
+            },
+          },
+        ],
+      });
+
+      // verify also that an async initialization was done for
+      await checkAsyncDatasetInitialization(parser, newDataSet);
+    });
+
+    it('handles metadata updates with same version (no callback)', () => {
+      const parser = createHashTreeParser();
+
+      const selfPutItemSpy = sinon.spy(parser.dataSets.self.hashTree, 'putItem');
+
+      // Create a locus update with metadata that has the same version and same visibleDataSets
+      const locusUpdate = {
+        dataSets: [createDataSet('self', 1, 2100)],
+        locus: {},
+        metadata: {
+          htMeta: {
+            elementId: {
+              type: 'metadata',
+              id: 5,
+              version: 50, // same version as initial
+            },
+            dataSetNames: ['self'],
+          },
+          visibleDataSets: [
+            {
+              name: 'main',
+              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
+            },
+            {
+              name: 'self',
+              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+            },
+            {
+              name: 'atd-unmuted',
+              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/atd-unmuted',
+            },
+          ],
+        },
+      };
+
+      // Call handleLocusUpdate
+      parser.handleLocusUpdate(locusUpdate);
+
+      // Verify putItem was called on self hash tree
+      assert.calledOnceWithExactly(selfPutItemSpy, {type: 'metadata', id: 5, version: 50});
+
+      // Verify callback was NOT called because version didn't change
+      assert.notCalled(callback);
+    });
   });
 
   describe('#handleMessage', () => {
@@ -910,13 +1186,6 @@ describe('HashTreeParser', () => {
       // Verify callback was called with OBJECTS_UPDATED and all updated objects
       assert.calledOnceWithExactly(callback, LocusInfoUpdateType.OBJECTS_UPDATED, {
         updatedObjects: [
-          {
-            htMeta: {
-              elementId: {type: 'self', id: 4, version: 101},
-              dataSetNames: ['self'],
-            },
-            data: {person: {name: 'updated self name'}},
-          },
           {
             htMeta: {
               elementId: {type: 'locus', id: 0, version: 201},
@@ -924,10 +1193,6 @@ describe('HashTreeParser', () => {
             },
             data: {info: {id: 'updated-locus-info'}},
           },
-          // self updates appear twice, because they are processed twice in HashTreeParser.parseMessage()
-          // (first for checking for visibleDataSets changes and again with the rest of updates in the main part of parseMessage())
-          // this is only temporary until SPARK-744859 is done and having them twice here is not harmful
-          // so keeping it like this for now
           {
             htMeta: {
               elementId: {type: 'self', id: 4, version: 101},
@@ -1179,6 +1444,9 @@ describe('HashTreeParser', () => {
           sinon.match({
             method: 'GET',
             uri: `${mainDataSetUrl}/hashtree`,
+            qs: {
+              rootHash: hashTree.getRootHash(),
+            },
           })
         );
 
@@ -1186,6 +1454,7 @@ describe('HashTreeParser', () => {
         assert.calledWith(webexRequest, {
           method: 'POST',
           uri: `${mainDataSetUrl}/sync`,
+          qs: {rootHash: hashTree.getRootHash()},
           body: {
             leafCount: 16,
             leafDataEntries: [
@@ -1239,10 +1508,17 @@ describe('HashTreeParser', () => {
         assert.calledWith(webexRequest, {
           method: 'POST',
           uri: `${parser.dataSets.self.url}/sync`,
+          qs: {rootHash: parser.dataSets.self.hashTree.getRootHash()},
           body: {
             leafCount: 1,
             leafDataEntries: [
-              {leafIndex: 0, elementIds: [{type: 'self', id: 4, version: 102}]},
+              {
+                leafIndex: 0,
+                elementIds: [
+                  {type: 'self', id: 4, version: 102},
+                  {type: 'metadata', id: 5, version: 50},
+                ],
+              },
             ],
           },
         });
@@ -1257,7 +1533,7 @@ describe('HashTreeParser', () => {
         // Stub updateItems on self hash tree to return true
         sinon.stub(parser.dataSets.self.hashTree, 'updateItems').returns([true]);
 
-        // Send a message with SELF object that has a new visibleDataSets list
+        // Send a message with Metadata object that has a new visibleDataSets list
         const message = {
           dataSets: [createDataSet('self', 1, 2100), createDataSet('attendees', 8, 4000)],
           visibleDataSetsUrl,
@@ -1266,14 +1542,31 @@ describe('HashTreeParser', () => {
             {
               htMeta: {
                 elementId: {
-                  type: 'self' as const,
-                  id: 4,
-                  version: 101,
+                  type: 'metadata' as const,
+                  id: 5,
+                  version: 51,
                 },
                 dataSetNames: ['self'],
               },
               data: {
-                visibleDataSets: ['main', 'self', 'atd-unmuted', 'attendees'], // added 'attendees'
+                visibleDataSets: [
+                  {
+                    name: 'main',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
+                  },
+                  {
+                    name: 'self',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+                  },
+                  {
+                    name: 'atd-unmuted',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/atd-unmuted',
+                  },
+                  {
+                    name: 'attendees',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/attendees',
+                  },
+                ], // added 'attendees'
               },
             },
           ],
@@ -1282,31 +1575,65 @@ describe('HashTreeParser', () => {
         await parser.handleMessage(message, 'add visible dataset');
 
         // Verify that 'attendees' was added to visibleDataSets
-        assert.include(parser.visibleDataSets, 'attendees');
+        expect(parser.visibleDataSets.some((vds) => vds.name === 'attendees')).to.be.true;
 
         // Verify that a hash tree was created for 'attendees'
         assert.exists(parser.dataSets.attendees.hashTree);
         assert.equal(parser.dataSets.attendees.hashTree.numLeaves, 8);
 
-        // Verify callback was called with the self update (appears twice due to SPARK-744859)
+        // Verify callback was called with the metadata update (appears twice - processed once for visible dataset changes, once in main loop)
         assert.calledOnceWithExactly(callback, LocusInfoUpdateType.OBJECTS_UPDATED, {
           updatedObjects: [
             {
               htMeta: {
-                elementId: {type: 'self', id: 4, version: 101},
+                elementId: {type: 'metadata', id: 5, version: 51},
                 dataSetNames: ['self'],
               },
               data: {
-                visibleDataSets: ['main', 'self', 'atd-unmuted', 'attendees'],
+                visibleDataSets: [
+                  {
+                    name: 'main',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
+                  },
+                  {
+                    name: 'self',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+                  },
+                  {
+                    name: 'atd-unmuted',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/atd-unmuted',
+                  },
+                  {
+                    name: 'attendees',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/attendees',
+                  },
+                ],
               },
             },
             {
               htMeta: {
-                elementId: {type: 'self', id: 4, version: 101},
+                elementId: {type: 'metadata', id: 5, version: 51},
                 dataSetNames: ['self'],
               },
               data: {
-                visibleDataSets: ['main', 'self', 'atd-unmuted', 'attendees'],
+                visibleDataSets: [
+                  {
+                    name: 'main',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
+                  },
+                  {
+                    name: 'self',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+                  },
+                  {
+                    name: 'atd-unmuted',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/atd-unmuted',
+                  },
+                  {
+                    name: 'attendees',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/attendees',
+                  },
+                ],
               },
             },
           ],
@@ -1320,7 +1647,7 @@ describe('HashTreeParser', () => {
         // Stub updateItems on self hash tree to return true
         sinon.stub(parser.dataSets.self.hashTree, 'updateItems').returns([true]);
 
-        // Send a message with SELF object that has a new visibleDataSets list (adding 'new-dataset')
+        // Send a message with Metadata object that has a new visibleDataSets list (adding 'new-dataset')
         // but WITHOUT providing info about the new dataset in dataSets array
         const message = {
           dataSets: [createDataSet('self', 1, 2100)],
@@ -1330,14 +1657,31 @@ describe('HashTreeParser', () => {
             {
               htMeta: {
                 elementId: {
-                  type: 'self' as const,
-                  id: 4,
-                  version: 101,
+                  type: 'metadata' as const,
+                  id: 5,
+                  version: 51,
                 },
                 dataSetNames: ['self'],
               },
               data: {
-                visibleDataSets: ['main', 'self', 'atd-unmuted', 'new-dataset'],
+                visibleDataSets: [
+                  {
+                    name: 'main',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
+                  },
+                  {
+                    name: 'self',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+                  },
+                  {
+                    name: 'atd-unmuted',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/atd-unmuted',
+                  },
+                  {
+                    name: 'new-dataset',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/new-dataset',
+                  },
+                ],
               },
             },
           ],
@@ -1355,38 +1699,7 @@ describe('HashTreeParser', () => {
 
         await parser.handleMessage(message, 'add new dataset requiring async init');
 
-        // immediately we don't have the dataset yet, so it should not be in visibleDataSets
-        // and no hash tree should exist yet
-        assert.isFalse(parser.visibleDataSets.includes('new-dataset'));
-        assert.isUndefined(parser.dataSets['new-dataset']);
-
-        // Wait for the async initialization to complete (queued as microtask)
-        await clock.tickAsync(0);
-
-        // The visibleDataSets is updated from the self object data
-        assert.include(parser.visibleDataSets, 'new-dataset');
-
-        // Verify that a hash tree was created for 'new-dataset'
-        assert.exists(parser.dataSets['new-dataset'].hashTree);
-        assert.equal(parser.dataSets['new-dataset'].hashTree.numLeaves, 4);
-
-        // Verify getAllDataSetsMetadata was called for async initialization
-        assert.calledWith(
-          webexRequest,
-          sinon.match({
-            method: 'GET',
-            uri: visibleDataSetsUrl,
-          })
-        );
-
-        // Verify sync request was sent for the new dataset
-        assert.calledWith(
-          webexRequest,
-          sinon.match({
-            method: 'POST',
-            uri: `${newDataSet.url}/sync`,
-          })
-        );
+        await checkAsyncDatasetInitialization(parser, newDataSet);
       });
 
       it('handles removal of visible data set', async () => {
@@ -1406,7 +1719,7 @@ describe('HashTreeParser', () => {
         // Stub updateItems on self hash tree to return true
         sinon.stub(parser.dataSets.self.hashTree, 'updateItems').returns([true]);
 
-        // Send a message with SELF object that has removed 'atd-unmuted' from visibleDataSets
+        // Send a message with Metadata object that has removed 'atd-unmuted' from visibleDataSets
         const message = {
           dataSets: [createDataSet('self', 1, 2100)],
           visibleDataSetsUrl,
@@ -1415,14 +1728,23 @@ describe('HashTreeParser', () => {
             {
               htMeta: {
                 elementId: {
-                  type: 'self' as const,
-                  id: 4,
-                  version: 101,
+                  type: 'metadata' as const,
+                  id: 5,
+                  version: 51,
                 },
                 dataSetNames: ['self'],
               },
               data: {
-                visibleDataSets: ['main', 'self'], // removed 'atd-unmuted'
+                visibleDataSets: [
+                  {
+                    name: 'main',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
+                  },
+                  {
+                    name: 'self',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+                  },
+                ], // removed 'atd-unmuted'
               },
             },
           ],
@@ -1431,7 +1753,7 @@ describe('HashTreeParser', () => {
         await parser.handleMessage(message, 'remove visible dataset');
 
         // Verify that 'atd-unmuted' was removed from visibleDataSets
-        assert.notInclude(parser.visibleDataSets, 'atd-unmuted');
+        expect(parser.visibleDataSets.some((vds) => vds.name === 'atd-unmuted')).to.be.false;
 
         // Verify that the hash tree for 'atd-unmuted' was deleted
         assert.isUndefined(parser.dataSets['atd-unmuted'].hashTree);
@@ -1439,16 +1761,25 @@ describe('HashTreeParser', () => {
         // Verify that the timer was cleared
         assert.isUndefined(parser.dataSets['atd-unmuted'].timer);
 
-        // Verify callback was called with both the self update and the removed objects
+        // Verify callback was called with the metadata update and the removed objects (metadata appears twice - processed once for dataset changes, once in main loop)
         assert.calledOnceWithExactly(callback, LocusInfoUpdateType.OBJECTS_UPDATED, {
           updatedObjects: [
             {
               htMeta: {
-                elementId: {type: 'self', id: 4, version: 101},
+                elementId: {type: 'metadata', id: 5, version: 51},
                 dataSetNames: ['self'],
               },
               data: {
-                visibleDataSets: ['main', 'self'],
+                visibleDataSets: [
+                  {
+                    name: 'main',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
+                  },
+                  {
+                    name: 'self',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+                  },
+                ],
               },
             },
             {
@@ -1460,11 +1791,20 @@ describe('HashTreeParser', () => {
             },
             {
               htMeta: {
-                elementId: {type: 'self', id: 4, version: 101}, // 2nd self because of SPARK-744859
+                elementId: {type: 'metadata', id: 5, version: 51},
                 dataSetNames: ['self'],
               },
               data: {
-                visibleDataSets: ['main', 'self'],
+                visibleDataSets: [
+                  {
+                    name: 'main',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
+                  },
+                  {
+                    name: 'self',
+                    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
+                  },
+                ],
               },
             },
           ],
@@ -1489,7 +1829,7 @@ describe('HashTreeParser', () => {
         });
 
         // Verify attendees is NOT in visibleDataSets
-        assert.notInclude(parser.visibleDataSets, 'attendees');
+        expect(parser.visibleDataSets.some((vds) => vds.name === 'attendees')).to.be.false;
 
         // Send a message with attendees data
         const message = {
@@ -1521,4 +1861,496 @@ describe('HashTreeParser', () => {
       });
     });
   });
+
+  describe('#callLocusInfoUpdateCallback filtering', () => {
+    // Helper to setup parser with initial objects and reset callback history
+    async function setupParserWithObjects(locusStateElements: any[]) {
+      const parser = createHashTreeParser();
+
+      if (locusStateElements.length > 0) {
+        // Determine which datasets to include based on the objects' dataSetNames
+        const dataSetNames = new Set<string>();
+        locusStateElements.forEach((element) => {
+          element.htMeta?.dataSetNames?.forEach((name) => dataSetNames.add(name));
+        });
+
+        const dataSets = [];
+        if (dataSetNames.has('main')) dataSets.push(createDataSet('main', 16, 1100));
+        if (dataSetNames.has('self')) dataSets.push(createDataSet('self', 1, 2100));
+        if (dataSetNames.has('atd-unmuted')) dataSets.push(createDataSet('atd-unmuted', 16, 3100));
+
+        const setupMessage = {
+          dataSets,
+          visibleDataSetsUrl,
+          locusUrl,
+          locusStateElements,
+        };
+
+        await parser.handleMessage(setupMessage, 'setup');
+      }
+
+      callback.resetHistory();
+      return parser;
+    }
+
+    it('filters out updates when a dataset has a higher version', async () => {
+      const parser = await setupParserWithObjects([
+        {
+          htMeta: {
+            elementId: {type: 'locus' as const, id: 5, version: 100},
+            dataSetNames: ['main'],
+          },
+          data: {existingField: 'existing'},
+        },
+      ]);
+
+      // Try to update with an older version (90)
+      const updateMessage = {
+        dataSets: [createDataSet('main', 16, 1101)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [
+          {
+            htMeta: {
+              elementId: {type: 'locus' as const, id: 5, version: 90},
+              dataSetNames: ['main'],
+            },
+            data: {someField: 'value'},
+          },
+        ],
+      };
+
+      await parser.handleMessage(updateMessage, 'update with older version');
+
+      // Callback should not be called because the update was filtered out
+      assert.notCalled(callback);
+    });
+
+    it('allows updates when version is newer than existing', async () => {
+      const parser = await setupParserWithObjects([
+        {
+          htMeta: {
+            elementId: {type: 'locus' as const, id: 5, version: 100},
+            dataSetNames: ['main'],
+          },
+          data: {existingField: 'existing'},
+        },
+      ]);
+
+      // Try to update with a newer version (110)
+      const updateMessage = {
+        dataSets: [createDataSet('main', 16, 1101)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [
+          {
+            htMeta: {
+              elementId: {type: 'locus' as const, id: 5, version: 110},
+              dataSetNames: ['main'],
+            },
+            data: {someField: 'new value'},
+          },
+        ],
+      };
+
+      await parser.handleMessage(updateMessage, 'update with newer version');
+
+      // Callback should be called with the update
+      assert.calledOnceWithExactly(callback, LocusInfoUpdateType.OBJECTS_UPDATED, {
+        updatedObjects: [
+          {
+            htMeta: {
+              elementId: {type: 'locus', id: 5, version: 110},
+              dataSetNames: ['main'],
+            },
+            data: {someField: 'new value'},
+          },
+        ],
+      });
+    });
+
+    it('filters out removal when object still exists in any dataset', async () => {
+      const parser = await setupParserWithObjects([
+        {
+          htMeta: {
+            elementId: {type: 'participant' as const, id: 10, version: 50},
+            dataSetNames: ['main', 'atd-unmuted'],
+          },
+          data: {name: 'participant'},
+        },
+      ]);
+
+      // Try to remove the object from main only (it still exists in atd-unmuted)
+      const removalMessage = {
+        dataSets: [createDataSet('main', 16, 1101)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [
+          {
+            htMeta: {
+              elementId: {type: 'participant' as const, id: 10, version: 50},
+              dataSetNames: ['main'],
+            },
+            data: null, // removal
+          },
+        ],
+      };
+
+      await parser.handleMessage(removalMessage, 'removal from one dataset');
+
+      // Callback should not be called because object still exists in atd-unmuted
+      assert.notCalled(callback);
+    });
+
+    it('allows removal when object does not exist in any dataset', async () => {
+      const parser = await setupParserWithObjects([]);
+
+      // Stub updateItems to return true (simulating that the removal was "applied")
+      sinon.stub(parser.dataSets.main.hashTree, 'updateItems').returns([true]);
+
+      // Try to remove an object that doesn't exist anywhere
+      const removalMessage = {
+        dataSets: [createDataSet('main', 16, 1100)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [
+          {
+            htMeta: {
+              elementId: {type: 'participant' as const, id: 99, version: 10},
+              dataSetNames: ['main'],
+            },
+            data: null, // removal
+          },
+        ],
+      };
+
+      await parser.handleMessage(removalMessage, 'removal of non-existent object');
+
+      // Callback should be called with the removal
+      assert.calledOnceWithExactly(callback, LocusInfoUpdateType.OBJECTS_UPDATED, {
+        updatedObjects: [
+          {
+            htMeta: {
+              elementId: {type: 'participant', id: 99, version: 10},
+              dataSetNames: ['main'],
+            },
+            data: null,
+          },
+        ],
+      });
+    });
+
+    it('filters out removal when object exists in another dataset with newer version', async () => {
+      const parser = createHashTreeParser();
+
+      // Setup: Add object to main with version 40
+      await parser.handleMessage(
+        {
+          dataSets: [createDataSet('main', 16, 1100)],
+          visibleDataSetsUrl,
+          locusUrl,
+          locusStateElements: [
+            {
+              htMeta: {
+                elementId: {type: 'participant' as const, id: 10, version: 40},
+                dataSetNames: ['main'],
+              },
+              data: {name: 'participant v40'},
+            },
+          ],
+        },
+        'setup main'
+      );
+
+      // Add object to atd-unmuted with version 50
+      await parser.handleMessage(
+        {
+          dataSets: [createDataSet('atd-unmuted', 16, 3100)],
+          visibleDataSetsUrl,
+          locusUrl,
+          locusStateElements: [
+            {
+              htMeta: {
+                elementId: {type: 'participant' as const, id: 10, version: 50},
+                dataSetNames: ['atd-unmuted'],
+              },
+              data: {name: 'participant v50'},
+            },
+          ],
+        },
+        'setup atd-unmuted'
+      );
+      callback.resetHistory();
+
+      // Try to remove with version 40 from main
+      const removalMessage = {
+        dataSets: [createDataSet('main', 16, 1101)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [
+          {
+            htMeta: {
+              elementId: {type: 'participant' as const, id: 10, version: 40},
+              dataSetNames: ['main'],
+            },
+            data: null, // removal
+          },
+        ],
+      };
+
+      await parser.handleMessage(removalMessage, 'removal with older version');
+
+      // Callback should not be called because object still exists with newer version
+      assert.notCalled(callback);
+    });
+
+    it('filters mixed updates correctly - some pass, some filtered', async () => {
+      const parser = await setupParserWithObjects([
+        {
+          htMeta: {
+            elementId: {type: 'participant' as const, id: 1, version: 100},
+            dataSetNames: ['main'],
+          },
+          data: {name: 'participant 1'},
+        },
+        {
+          htMeta: {
+            elementId: {type: 'participant' as const, id: 2, version: 50},
+            dataSetNames: ['atd-unmuted'],
+          },
+          data: {name: 'participant 2'},
+        },
+      ]);
+
+      // Send mixed updates
+      const mixedMessage = {
+        dataSets: [createDataSet('main', 16, 1101)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [
+          {
+            htMeta: {
+              elementId: {type: 'participant' as const, id: 1, version: 110}, // newer version - should pass
+              dataSetNames: ['main'],
+            },
+            data: {name: 'updated'},
+          },
+          {
+            htMeta: {
+              elementId: {type: 'participant' as const, id: 1, version: 90}, // older version - should be filtered
+              dataSetNames: ['main'],
+            },
+            data: {name: 'old'},
+          },
+          {
+            htMeta: {
+              elementId: {type: 'participant' as const, id: 3, version: 10}, // new object - should pass
+              dataSetNames: ['main'],
+            },
+            data: {name: 'new'},
+          },
+          {
+            htMeta: {
+              elementId: {type: 'participant' as const, id: 2, version: 50}, // removal but exists in atd-unmuted - should be filtered
+              dataSetNames: ['main'],
+            },
+            data: null,
+          },
+        ],
+      };
+
+      await parser.handleMessage(mixedMessage, 'mixed updates');
+
+      // Callback should be called with only the valid updates (participant 1 v110 and participant 3 v10)
+      assert.calledOnceWithExactly(callback, LocusInfoUpdateType.OBJECTS_UPDATED, {
+        updatedObjects: [
+          {
+            htMeta: {
+              elementId: {type: 'participant', id: 1, version: 110},
+              dataSetNames: ['main'],
+            },
+            data: {name: 'updated'},
+          },
+          {
+            htMeta: {
+              elementId: {type: 'participant', id: 3, version: 10},
+              dataSetNames: ['main'],
+            },
+            data: {name: 'new'},
+          },
+        ],
+      });
+    });
+
+    it('does not call callback when all updates are filtered out', async () => {
+      const parser = await setupParserWithObjects([
+        {
+          htMeta: {
+            elementId: {type: 'locus' as const, id: 5, version: 100},
+            dataSetNames: ['main'],
+          },
+          data: {existingField: 'existing'},
+        },
+      ]);
+
+      // Try to update with older versions (all should be filtered)
+      const updateMessage = {
+        dataSets: [createDataSet('main', 16, 1101)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [
+          {
+            htMeta: {
+              elementId: {type: 'locus' as const, id: 5, version: 80},
+              dataSetNames: ['main'],
+            },
+            data: {someField: 'value'},
+          },
+          {
+            htMeta: {
+              elementId: {type: 'locus' as const, id: 5, version: 90},
+              dataSetNames: ['main'],
+            },
+            data: {someField: 'another value'},
+          },
+        ],
+      };
+
+      await parser.handleMessage(updateMessage, 'all filtered updates');
+
+      // Callback should not be called at all
+      assert.notCalled(callback);
+    });
+
+    it('checks all visible datasets when filtering', async () => {
+      const parser = createHashTreeParser();
+
+      // Setup: Add same object to multiple datasets with different versions
+      await parser.handleMessage(
+        {
+          dataSets: [createDataSet('main', 16, 1100)],
+          visibleDataSetsUrl,
+          locusUrl,
+          locusStateElements: [
+            {
+              htMeta: {
+                elementId: {type: 'participant' as const, id: 10, version: 100},
+                dataSetNames: ['main'],
+              },
+              data: {name: 'v100'},
+            },
+          ],
+        },
+        'setup main'
+      );
+
+      await parser.handleMessage(
+        {
+          dataSets: [createDataSet('self', 1, 2100)],
+          visibleDataSetsUrl,
+          locusUrl,
+          locusStateElements: [
+            {
+              htMeta: {
+                elementId: {type: 'participant' as const, id: 10, version: 120}, // highest
+                dataSetNames: ['self'],
+              },
+              data: {name: 'v120'},
+            },
+          ],
+        },
+        'setup self'
+      );
+
+      await parser.handleMessage(
+        {
+          dataSets: [createDataSet('atd-unmuted', 16, 3100)],
+          visibleDataSetsUrl,
+          locusUrl,
+          locusStateElements: [
+            {
+              htMeta: {
+                elementId: {type: 'participant' as const, id: 10, version: 110},
+                dataSetNames: ['atd-unmuted'],
+              },
+              data: {name: 'v110'},
+            },
+          ],
+        },
+        'setup atd-unmuted'
+      );
+      callback.resetHistory();
+
+      // Try to update with version 115 (newer than main and atd-unmuted, but older than self)
+      const updateMessage = {
+        dataSets: [createDataSet('main', 16, 1101)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [
+          {
+            htMeta: {
+              elementId: {type: 'participant' as const, id: 10, version: 115},
+              dataSetNames: ['main'],
+            },
+            data: {name: 'update'},
+          },
+        ],
+      };
+
+      await parser.handleMessage(updateMessage, 'update with v115');
+
+      // Should be filtered out because self dataset has version 120
+      assert.notCalled(callback);
+    });
+
+    it('does not call callback for empty locusStateElements', async () => {
+      const parser = await setupParserWithObjects([]);
+
+      const emptyMessage = {
+        dataSets: [createDataSet('main', 16, 1100)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [],
+      };
+
+      await parser.handleMessage(emptyMessage, 'empty elements');
+
+      assert.notCalled(callback);
+    });
+
+    it('always calls callback for MEETING_ENDED regardless of filtering', async () => {
+      const parser = await setupParserWithObjects([
+        {
+          htMeta: {
+            elementId: {type: 'locus' as const, id: 0, version: 100},
+            dataSetNames: ['main'],
+          },
+          data: {info: 'data'},
+        },
+      ]);
+
+      // Send roster drop message (SELF object with no data) to trigger MEETING_ENDED
+      const rosterDropMessage = {
+        dataSets: [createDataSet('self', 1, 2101)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [
+          {
+            htMeta: {
+              elementId: {type: 'self' as const, id: 4, version: 102},
+              dataSetNames: ['self'],
+            },
+            data: undefined, // roster drop triggers MEETING_ENDED
+          },
+        ],
+      };
+
+      await parser.handleMessage(rosterDropMessage, 'roster drop message');
+
+      // Callback should be called with MEETING_ENDED
+      assert.calledOnceWithExactly(callback, LocusInfoUpdateType.MEETING_ENDED, {
+        updatedObjects: undefined,
+      });
+    });
+  });
 });