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

package/dist/hashTree/hashTreeParser.js

@@ -5,7 +5,7 @@ var _Array$from = require("@babel/runtime-corejs2/core-js/array/from");
 var _Symbol = require("@babel/runtime-corejs2/core-js/symbol");
 var _Symbol$iterator = require("@babel/runtime-corejs2/core-js/symbol/iterator");
 var _Array$isArray2 = require("@babel/runtime-corejs2/core-js/array/is-array");
-var _Object$keys3 = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$keys4 = require("@babel/runtime-corejs2/core-js/object/keys");
 var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
 var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
 var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
@@ -40,7 +40,7 @@ var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy")
 var _constants = require("../constants");
 var _constants2 = require("./constants");
 var _utils = require("./utils");
-function ownKeys(e, r) { var t = _Object$keys3(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function ownKeys(e, r) { var t = _Object$keys4(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof _Symbol && r[_Symbol$iterator] || r["@@iterator"]; if (!t) { if (_Array$isArray2(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? _Array$from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
@@ -63,6 +63,11 @@ var MeetingEndedError = /*#__PURE__*/function (_Error) {
   (0, _inherits2.default)(MeetingEndedError, _Error);
   return (0, _createClass2.default)(MeetingEndedError);
 }(/*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+/* Currently Locus always sends Metadata objects only in the "self" dataset.
+ * If this ever changes, update all the code that relies on this constant.
+ */
+var MetadataDataSetName = _constants2.DataSetNames.SELF;
+
 /**
  * Parses hash tree eventing locus data
  */
@@ -73,7 +78,7 @@ var HashTreeParser = /*#__PURE__*/function () {
    * @param {Object} options.initialLocus The initial locus data containing the hash tree information
    */
   function HashTreeParser(options) {
-    var _locus$self;
+    var _locus$links, _locus$links$resource, _locus$links$resource2, _options$metadata, _options$metadata2, _options$metadata2$vi;
     (0, _classCallCheck2.default)(this, HashTreeParser);
     (0, _defineProperty2.default)(this, "dataSets", {});
     (0, _defineProperty2.default)(this, "visibleDataSetsUrl", void 0);
@@ -89,12 +94,17 @@ var HashTreeParser = /*#__PURE__*/function () {
     this.debugId = options.debugId;
     this.webexRequest = options.webexRequest;
     this.locusInfoUpdateCallback = options.locusInfoUpdateCallback;
-    this.visibleDataSets = (locus === null || locus === void 0 ? void 0 : (_locus$self = locus.self) === null || _locus$self === void 0 ? void 0 : _locus$self.visibleDataSets) || [];
-    if (this.visibleDataSets.length === 0) {
-      _loggerProxy.default.logger.warn("HashTreeParser#constructor --> ".concat(this.debugId, " No visibleDataSets found in locus.self"));
+    this.visibleDataSetsUrl = locus === null || locus === void 0 ? void 0 : (_locus$links = locus.links) === null || _locus$links === void 0 ? void 0 : (_locus$links$resource = _locus$links.resources) === null || _locus$links$resource === void 0 ? void 0 : (_locus$links$resource2 = _locus$links$resource.visibleDataSets) === null || _locus$links$resource2 === void 0 ? void 0 : _locus$links$resource2.url;
+    this.visibleDataSets = (0, _lodash.cloneDeep)(((_options$metadata = options.metadata) === null || _options$metadata === void 0 ? void 0 : _options$metadata.visibleDataSets) || []);
+    if (((_options$metadata2 = options.metadata) === null || _options$metadata2 === void 0 ? void 0 : (_options$metadata2$vi = _options$metadata2.visibleDataSets) === null || _options$metadata2$vi === void 0 ? void 0 : _options$metadata2$vi.length) === 0) {
+      _loggerProxy.default.logger.warn("HashTreeParser#constructor --> ".concat(this.debugId, " No visibleDataSets found in Metadata"));
     }
     // object mapping dataset names to arrays of leaf data
     var leafData = this.analyzeLocusHtMeta(locus);
+    if (options.metadata) {
+      // add also the metadata that's outside of locus object itself
+      this.analyzeMetadata(leafData, options.metadata);
+    }
     _loggerProxy.default.logger.info("HashTreeParser#constructor --> creating HashTreeParser for datasets: ".concat((0, _stringify.default)(dataSets.map(function (ds) {
       return ds.name;
     }))));
@@ -106,7 +116,7 @@ var HashTreeParser = /*#__PURE__*/function () {
         var name = dataSet.name,
           leafCount = dataSet.leafCount;
         this.dataSets[name] = _objectSpread(_objectSpread({}, dataSet), {}, {
-          hashTree: this.visibleDataSets.includes(name) ? new _hashTree.default(leafData[name] || [], leafCount) : undefined
+          hashTree: this.isVisibleDataSet(name) ? new _hashTree.default(leafData[name] || [], leafCount) : undefined
         });
       }
     } catch (err) {
@@ -117,30 +127,44 @@ var HashTreeParser = /*#__PURE__*/function () {
   }
 
   /**
-   * Initializes a new visible data set by creating a hash tree for it, adding it to all the internal structures,
-   * and sending an initial sync request to Locus with empty leaf data - that will trigger Locus to gives us all the data
-   * from that dataset (in the response or via messages).
-   *
-   * @param {DataSet} dataSet The new data set to be added
-   * @returns {Promise}
+   * Checks if the given data set name is in the list of visible data sets
+   * @param {string} dataSetName data set name to check
+   * @returns {Boolean} True if the data set is visible, false otherwise
    */
   return (0, _createClass2.default)(HashTreeParser, [{
+    key: "isVisibleDataSet",
+    value: function isVisibleDataSet(dataSetName) {
+      return this.visibleDataSets.some(function (vds) {
+        return vds.name === dataSetName;
+      });
+    }
+
+    /**
+     * Initializes a new visible data set by creating a hash tree for it, adding it to all the internal structures,
+     * and sending an initial sync request to Locus with empty leaf data - that will trigger Locus to gives us all the data
+     * from that dataset (in the response or via messages).
+     *
+     * @param {VisibleDataSetInfo} visibleDataSetInfo Information about the new visible data set
+     * @param {DataSet} dataSetInfo The new data set to be added
+     * @returns {Promise}
+     */
+  }, {
     key: "initializeNewVisibleDataSet",
-    value: function initializeNewVisibleDataSet(dataSet) {
-      if (this.visibleDataSets.includes(dataSet.name)) {
-        _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Data set \"").concat(dataSet.name, "\" already exists, skipping init"));
+    value: function initializeNewVisibleDataSet(visibleDataSetInfo, dataSetInfo) {
+      if (this.isVisibleDataSet(dataSetInfo.name)) {
+        _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Data set \"").concat(dataSetInfo.name, "\" already exists, skipping init"));
         return _promise.default.resolve({
           updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
           updatedObjects: []
         });
       }
-      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Adding visible data set \"").concat(dataSet.name, "\""));
-      this.visibleDataSets.push(dataSet.name);
-      var hashTree = new _hashTree.default([], dataSet.leafCount);
-      this.dataSets[dataSet.name] = _objectSpread(_objectSpread({}, dataSet), {}, {
+      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Adding visible data set \"").concat(dataSetInfo.name, "\""));
+      this.visibleDataSets.push(visibleDataSetInfo);
+      var hashTree = new _hashTree.default([], dataSetInfo.leafCount);
+      this.dataSets[dataSetInfo.name] = _objectSpread(_objectSpread({}, dataSetInfo), {}, {
         hashTree: hashTree
       });
-      return this.sendInitializationSyncRequestToLocus(dataSet.name, 'new visible data set');
+      return this.sendInitializationSyncRequestToLocus(dataSetInfo.name, 'new visible data set');
     }
 
     /**
@@ -173,17 +197,20 @@ var HashTreeParser = /*#__PURE__*/function () {
     }
 
     /**
-     * Queries Locus for information about all the data sets
+     * Queries Locus for all up-to-date information about all visible data sets
      *
-     * @param {string} url - url from which we can get info about all data sets
      * @returns {Promise}
      */
   }, {
-    key: "getAllDataSetsMetadata",
-    value: function getAllDataSetsMetadata(url) {
+    key: "getAllVisibleDataSetsFromLocus",
+    value: function getAllVisibleDataSetsFromLocus() {
+      if (!this.visibleDataSetsUrl) {
+        _loggerProxy.default.logger.warn("HashTreeParser#getAllVisibleDataSetsFromLocus --> ".concat(this.debugId, " No visibleDataSetsUrl, cannot get data sets information"));
+        return _promise.default.resolve([]);
+      }
       return this.webexRequest({
         method: _constants.HTTP_VERBS.GET,
-        uri: url
+        uri: this.visibleDataSetsUrl
       }).then(function (response) {
         return response.body.dataSets;
       });
@@ -199,17 +226,18 @@ var HashTreeParser = /*#__PURE__*/function () {
     key: "initializeFromMessage",
     value: (function () {
       var _initializeFromMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(message) {
-        var dataSets;
+        var visibleDataSets;
         return _regenerator.default.wrap(function (_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              _loggerProxy.default.logger.info("HashTreeParser#initializeFromMessage --> ".concat(this.debugId, " visibleDataSetsUrl=").concat(message.visibleDataSetsUrl));
+              this.visibleDataSetsUrl = message.visibleDataSetsUrl;
+              _loggerProxy.default.logger.info("HashTreeParser#initializeFromMessage --> ".concat(this.debugId, " visibleDataSetsUrl=").concat(this.visibleDataSetsUrl));
               _context.next = 1;
-              return this.getAllDataSetsMetadata(message.visibleDataSetsUrl);
+              return this.getAllVisibleDataSetsFromLocus();
             case 1:
-              dataSets = _context.sent;
+              visibleDataSets = _context.sent;
               _context.next = 2;
-              return this.initializeDataSets(dataSets, 'initialization from message');
+              return this.initializeDataSets(visibleDataSets, 'initialization from message');
             case 2:
             case "end":
               return _context.stop();
@@ -235,25 +263,26 @@ var HashTreeParser = /*#__PURE__*/function () {
     key: "initializeFromGetLociResponse",
     value: (function () {
       var _initializeFromGetLociResponse = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2(locus) {
-        var _locus$links, _locus$links$resource, _locus$links$resource2;
-        var dataSets;
+        var _locus$links2, _locus$links2$resourc, _locus$links2$resourc2;
+        var visibleDataSets;
         return _regenerator.default.wrap(function (_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
-              if (locus !== null && locus !== void 0 && (_locus$links = locus.links) !== null && _locus$links !== void 0 && (_locus$links$resource = _locus$links.resources) !== null && _locus$links$resource !== void 0 && (_locus$links$resource2 = _locus$links$resource.visibleDataSets) !== null && _locus$links$resource2 !== void 0 && _locus$links$resource2.url) {
+              if (locus !== null && locus !== void 0 && (_locus$links2 = locus.links) !== null && _locus$links2 !== void 0 && (_locus$links2$resourc = _locus$links2.resources) !== null && _locus$links2$resourc !== void 0 && (_locus$links2$resourc2 = _locus$links2$resourc.visibleDataSets) !== null && _locus$links2$resourc2 !== void 0 && _locus$links2$resourc2.url) {
                 _context2.next = 1;
                 break;
               }
               _loggerProxy.default.logger.warn("HashTreeParser#initializeFromGetLociResponse --> ".concat(this.debugId, " missing visibleDataSets url in GET Loci response, cannot initialize hash trees"));
               return _context2.abrupt("return");
             case 1:
-              _loggerProxy.default.logger.info("HashTreeParser#initializeFromGetLociResponse --> ".concat(this.debugId, " visibleDataSets url: ").concat(locus.links.resources.visibleDataSets.url));
+              this.visibleDataSetsUrl = locus.links.resources.visibleDataSets.url;
+              _loggerProxy.default.logger.info("HashTreeParser#initializeFromGetLociResponse --> ".concat(this.debugId, " visibleDataSets url: ").concat(this.visibleDataSetsUrl));
               _context2.next = 2;
-              return this.getAllDataSetsMetadata(locus.links.resources.visibleDataSets.url);
+              return this.getAllVisibleDataSetsFromLocus();
             case 2:
-              dataSets = _context2.sent;
+              visibleDataSets = _context2.sent;
               _context2.next = 3;
-              return this.initializeDataSets(dataSets, 'initialization from GET /loci response');
+              return this.initializeDataSets(visibleDataSets, 'initialization from GET /loci response');
             case 3:
             case "end":
               return _context2.stop();
@@ -268,7 +297,7 @@ var HashTreeParser = /*#__PURE__*/function () {
     /**
      * Initializes data sets by doing an initialization sync on each visible data set that doesn't have a hash tree yet.
      *
-     * @param {DataSet[]} dataSets Array of DataSet objects to initialize
+     * @param {DataSet[]} visibleDataSets Array of visible DataSet objects to initialize
      * @param {string} debugText Text to include in logs for debugging purposes
      * @returns {Promise}
      */
@@ -276,13 +305,13 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "initializeDataSets",
     value: (function () {
-      var _initializeDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3(dataSets, debugText) {
-        var updatedObjects, _iterator2, _step2, dataSet, name, leafCount, _data, _t;
+      var _initializeDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3(visibleDataSets, debugText) {
+        var updatedObjects, _iterator2, _step2, dataSet, name, leafCount, url, _data, _t;
         return _regenerator.default.wrap(function (_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
               updatedObjects = [];
-              _iterator2 = _createForOfIteratorHelper(dataSets);
+              _iterator2 = _createForOfIteratorHelper(visibleDataSets);
               _context3.prev = 1;
               _iterator2.s();
             case 2:
@@ -291,14 +320,20 @@ var HashTreeParser = /*#__PURE__*/function () {
                 break;
               }
               dataSet = _step2.value;
-              name = dataSet.name, leafCount = dataSet.leafCount;
+              name = dataSet.name, leafCount = dataSet.leafCount, url = dataSet.url;
               if (!this.dataSets[name]) {
                 _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " initializing dataset \"").concat(name, "\" (").concat(debugText, ")"));
                 this.dataSets[name] = _objectSpread({}, dataSet);
               } else {
                 _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " dataset \"").concat(name, "\" already exists (").concat(debugText, ")"));
               }
-              if (!(this.visibleDataSets.includes(name) && !this.dataSets[name].hashTree)) {
+              if (!this.isVisibleDataSet(name)) {
+                this.visibleDataSets.push({
+                  name: name,
+                  url: url
+                });
+              }
+              if (this.dataSets[name].hashTree) {
                 _context3.next = 5;
                 break;
               }
@@ -434,6 +469,38 @@ var HashTreeParser = /*#__PURE__*/function () {
       return leafInfo;
     }
 
+    /**
+     * Analyzes the Metadata object that is sent outside of Locus object, and appends its data to passed in leafInfo
+     * structure.
+     *
+     * @param {Record<string, LeafInfo[]>} leafInfo the structure to which the Metadata info will be appended
+     * @param {Metadata} metadata Metadata object
+     * @returns {void}
+     */
+  }, {
+    key: "analyzeMetadata",
+    value: function analyzeMetadata(leafInfo, metadata) {
+      var _htMeta$dataSetNames;
+      var htMeta = metadata.htMeta;
+      if ((htMeta === null || htMeta === void 0 ? void 0 : (_htMeta$dataSetNames = htMeta.dataSetNames) === null || _htMeta$dataSetNames === void 0 ? void 0 : _htMeta$dataSetNames.length) === 1 && htMeta.dataSetNames[0].toLowerCase() === MetadataDataSetName) {
+        var _metadata$htMeta$elem = metadata.htMeta.elementId,
+          type = _metadata$htMeta$elem.type,
+          id = _metadata$htMeta$elem.id,
+          version = _metadata$htMeta$elem.version;
+        var dataSetName = htMeta.dataSetNames[0];
+        if (!leafInfo[dataSetName]) {
+          leafInfo[dataSetName] = [];
+        }
+        leafInfo[dataSetName].push({
+          type: type,
+          id: id,
+          version: version
+        });
+      } else {
+        throw new Error("".concat(this.debugId, " Metadata htMeta has unexpected dataSetNames: ").concat(htMeta && htMeta.dataSetNames.join(',')));
+      }
+    }
+
     /**
      * Checks if the provided hash tree message indicates the end of the meeting and that there won't be any more updates.
      *
@@ -482,6 +549,51 @@ var HashTreeParser = /*#__PURE__*/function () {
       });
     }
 
+    /**
+     * Handles updates to Metadata object that we receive from Locus via other means than messages. Right now
+     * that means only in the API response alongside locus object.
+     *
+     * @param {Metadata} metadata received in Locus update other than a message (for example in an API response)
+     * @param {HashTreeObject[]} updatedObjects a list of updated hash tree objects to which any updates resulting from new Metadata will be added
+     * @returns {void}
+     */
+  }, {
+    key: "handleMetadataUpdate",
+    value: function handleMetadataUpdate(metadata, updatedObjects) {
+      var _this$dataSets$Metada,
+        _this3 = this;
+      var dataSetsRequiringInitialization = [];
+
+      // current assumption based on Locus docs is that Metadata object lives always in "self" data set
+      var hashTree = (_this$dataSets$Metada = this.dataSets[MetadataDataSetName]) === null || _this$dataSets$Metada === void 0 ? void 0 : _this$dataSets$Metada.hashTree;
+      if (!hashTree) {
+        _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received Metadata object but no hash tree for \"").concat(MetadataDataSetName, "\" data set exists"));
+      } else {
+        var metadataUpdated = hashTree.putItem(metadata.htMeta.elementId);
+        if (metadataUpdated) {
+          // metadata in Locus API response is in a slightly different format than the objects in messages, so need to adapt it
+          var metadataObject = {
+            htMeta: metadata.htMeta,
+            data: metadata
+          };
+          updatedObjects.push(metadataObject);
+          var _this$checkForVisible = this.checkForVisibleDataSetChanges([metadataObject]),
+            changeDetected = _this$checkForVisible.changeDetected,
+            removedDataSets = _this$checkForVisible.removedDataSets,
+            addedDataSets = _this$checkForVisible.addedDataSets;
+          if (changeDetected) {
+            dataSetsRequiringInitialization = this.processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects);
+          }
+          if (dataSetsRequiringInitialization.length > 0) {
+            // there are some data sets that we need to initialize asynchronously
+            queueMicrotask(function () {
+              _this3.initializeNewVisibleDataSets(dataSetsRequiringInitialization);
+            });
+          }
+        }
+      }
+    }
+
     /**
      * This method should be called when we receive a partial locus DTO that contains dataSets and htMeta information
      * It updates the hash trees with the new leaf data based on the received Locus
@@ -492,9 +604,10 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "handleLocusUpdate",
     value: function handleLocusUpdate(update) {
-      var _this3 = this;
+      var _this4 = this;
       var dataSets = update.dataSets,
-        locus = update.locus;
+        locus = update.locus,
+        metadata = update.metadata;
       if (!dataSets) {
         _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received hash tree update without dataSets"));
       }
@@ -517,11 +630,16 @@ var HashTreeParser = /*#__PURE__*/function () {
         copyData: true
       });
 
+      // if we got metadata, process it (currently that means only potential visible data set list changes)
+      if (metadata) {
+        this.handleMetadataUpdate(metadata, updatedObjects);
+      }
+
       // then process the data in hash trees, if it is a new version, then add it to updatedObjects
       (0, _keys.default)(leafInfo).forEach(function (dataSetName) {
-        if (_this3.dataSets[dataSetName]) {
-          if (_this3.dataSets[dataSetName].hashTree) {
-            var appliedChangesList = _this3.dataSets[dataSetName].hashTree.putItems(leafInfo[dataSetName].map(function (leaf) {
+        if (_this4.dataSets[dataSetName]) {
+          if (_this4.dataSets[dataSetName].hashTree) {
+            var appliedChangesList = _this4.dataSets[dataSetName].hashTree.putItems(leafInfo[dataSetName].map(function (leaf) {
               return {
                 id: leaf.id,
                 type: leaf.type,
@@ -548,10 +666,10 @@ var HashTreeParser = /*#__PURE__*/function () {
             });
           } else {
             // no hash tree means that the data set is not visible
-            _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this3.debugId, " received leaf data for data set \"").concat(dataSetName, "\" that has no hash tree created, ignoring"));
+            _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this4.debugId, " received leaf data for data set \"").concat(dataSetName, "\" that has no hash tree created, ignoring"));
           }
         } else {
-          _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this3.debugId, " received leaf data for unknown data set \"").concat(dataSetName, "\", ignoring"));
+          _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this4.debugId, " received leaf data for unknown data set \"").concat(dataSetName, "\", ignoring"));
         }
       });
       if (updatedObjects.length === 0) {
@@ -562,9 +680,6 @@ var HashTreeParser = /*#__PURE__*/function () {
           updatedObjects: updatedObjects
         });
       }
-
-      // todo: once Locus design on how visible data sets will be communicated in subsequent API responses is confirmed,
-      // we'll need to check here if visible data sets have changed and update this.visibleDataSets, remove/create hash trees etc
     }
 
     /**
@@ -578,7 +693,7 @@ var HashTreeParser = /*#__PURE__*/function () {
     value: function updateDataSetInfo(receivedDataSet) {
       if (!this.dataSets[receivedDataSet.name]) {
         this.dataSets[receivedDataSet.name] = _objectSpread({}, receivedDataSet);
-        _loggerProxy.default.logger.info("HashTreeParser#handleMessage --> ".concat(this.debugId, " created entry for \"").concat(receivedDataSet.name, "\" dataset: version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
+        _loggerProxy.default.logger.info("HashTreeParser#updateDataSetInfo --> ".concat(this.debugId, " created entry for \"").concat(receivedDataSet.name, "\" dataset: version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
         return;
       }
       // update our version of the dataSet
@@ -590,7 +705,7 @@ var HashTreeParser = /*#__PURE__*/function () {
           maxMs: receivedDataSet.backoff.maxMs,
           exponent: receivedDataSet.backoff.exponent
         };
-        _loggerProxy.default.logger.info("HashTreeParser#handleMessage --> ".concat(this.debugId, " updated \"").concat(receivedDataSet.name, "\" to version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
+        _loggerProxy.default.logger.info("HashTreeParser#updateDataSetInfo --> ".concat(this.debugId, " updated \"").concat(receivedDataSet.name, "\" dataset to version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
       }
     }
 
@@ -602,24 +717,31 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "checkForVisibleDataSetChanges",
     value: function checkForVisibleDataSetChanges(updatedObjects) {
-      var _this4 = this;
+      var _this5 = this;
       var removedDataSets = [];
       var addedDataSets = [];
 
-      // visibleDataSets can only be changed by self object updates
+      // visibleDataSets can only be changed by Metadata object updates
       updatedObjects.forEach(function (object) {
         var _object$data;
-        // todo: in the future visibleDataSets will be in "Metadata" object, not in "self"
-        if ((0, _utils.isSelf)(object) && (_object$data = object.data) !== null && _object$data !== void 0 && _object$data.visibleDataSets) {
+        if ((0, _utils.isMetadata)(object) && (_object$data = object.data) !== null && _object$data !== void 0 && _object$data.visibleDataSets) {
           var newVisibleDataSets = object.data.visibleDataSets;
-          removedDataSets = _this4.visibleDataSets.filter(function (ds) {
-            return !newVisibleDataSets.includes(ds);
+          removedDataSets = _this5.visibleDataSets.filter(function (ds) {
+            return !newVisibleDataSets.some(function (nvs) {
+              return nvs.name === ds.name;
+            });
           });
-          addedDataSets = newVisibleDataSets.filter(function (ds) {
-            return !_this4.visibleDataSets.includes(ds);
+          addedDataSets = newVisibleDataSets.filter(function (nvs) {
+            return _this5.visibleDataSets.every(function (ds) {
+              return ds.name !== nvs.name;
+            });
           });
           if (removedDataSets.length > 0 || addedDataSets.length > 0) {
-            _loggerProxy.default.logger.info("HashTreeParser#checkForVisibleDataSetChanges --> ".concat(_this4.debugId, " visible data sets change: removed: ").concat(removedDataSets.join(', '), ", added: ").concat(addedDataSets.join(', ')));
+            _loggerProxy.default.logger.info("HashTreeParser#checkForVisibleDataSetChanges --> ".concat(_this5.debugId, " visible data sets change: removed: ").concat(removedDataSets.map(function (ds) {
+              return ds.name;
+            }).join(', '), ", added: ").concat(addedDataSets.map(function (ds) {
+              return ds.name;
+            }).join(', ')));
           }
         }
       });
@@ -657,38 +779,40 @@ var HashTreeParser = /*#__PURE__*/function () {
      * visible data sets and they require async initialization, the names of these data sets
      * are returned in an array.
      *
-     * @param {string[]} removedDataSets - The list of removed data sets.
-     * @param {string[]} addedDataSets - The list of added data sets.
+     * @param {VisibleDataSetInfo[]} removedDataSets - The list of removed data sets.
+     * @param {VisibleDataSetInfo[]} addedDataSets - The list of added data sets.
      * @param {HashTreeObject[]} updatedObjects - The list of updated hash tree objects to which changes will be added.
-     * @returns {string[]} names of data sets that couldn't be initialized synchronously
+     * @returns {VisibleDataSetInfo[]} list of data sets that couldn't be initialized synchronously
      */
   }, {
     key: "processVisibleDataSetChanges",
     value: function processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects) {
-      var _this5 = this;
+      var _this6 = this;
       var dataSetsRequiringInitialization = [];
 
       // if a visible data set was removed, we need to tell our client that all objects from it are removed
       var removedObjects = [];
       removedDataSets.forEach(function (ds) {
-        var _this5$dataSets$ds;
-        if ((_this5$dataSets$ds = _this5.dataSets[ds]) !== null && _this5$dataSets$ds !== void 0 && _this5$dataSets$ds.hashTree) {
-          for (var i = 0; i < _this5.dataSets[ds].hashTree.numLeaves; i += 1) {
-            removedObjects.push.apply(removedObjects, (0, _toConsumableArray2.default)(_this5.dataSets[ds].hashTree.getLeafData(i).map(function (elementId) {
+        var _this6$dataSets$ds$na;
+        if ((_this6$dataSets$ds$na = _this6.dataSets[ds.name]) !== null && _this6$dataSets$ds$na !== void 0 && _this6$dataSets$ds$na.hashTree) {
+          for (var i = 0; i < _this6.dataSets[ds.name].hashTree.numLeaves; i += 1) {
+            removedObjects.push.apply(removedObjects, (0, _toConsumableArray2.default)(_this6.dataSets[ds.name].hashTree.getLeafData(i).map(function (elementId) {
               return {
                 htMeta: {
                   elementId: elementId,
-                  dataSetNames: [ds]
+                  dataSetNames: [ds.name]
                 },
                 data: null
               };
             })));
           }
-          _this5.deleteHashTree(ds);
+          _this6.deleteHashTree(ds.name);
         }
       });
       this.visibleDataSets = this.visibleDataSets.filter(function (vds) {
-        return !removedDataSets.includes(vds);
+        return !removedDataSets.some(function (rds) {
+          return rds.name === vds.name;
+        });
       });
       updatedObjects.push.apply(updatedObjects, removedObjects);
 
@@ -698,22 +822,22 @@ var HashTreeParser = /*#__PURE__*/function () {
       try {
         for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
           var ds = _step6.value;
-          var dataSetInfo = this.dataSets[ds];
+          var dataSetInfo = this.dataSets[ds.name];
           if (dataSetInfo) {
-            if (this.visibleDataSets.includes(dataSetInfo.name)) {
-              _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Data set \"").concat(ds, "\" is already visible, skipping"));
+            if (this.isVisibleDataSet(dataSetInfo.name)) {
+              _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Data set \"").concat(ds.name, "\" is already visible, skipping"));
 
               // eslint-disable-next-line no-continue
               continue;
             }
-            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Adding visible data set \"").concat(ds, "\""));
+            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Adding visible data set \"").concat(ds.name, "\""));
             this.visibleDataSets.push(ds);
             var hashTree = new _hashTree.default([], dataSetInfo.leafCount);
             this.dataSets[dataSetInfo.name] = _objectSpread(_objectSpread({}, dataSetInfo), {}, {
               hashTree: hashTree
             });
           } else {
-            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " visible data set \"").concat(ds, "\" added but no info about it in our dataSets structures"));
+            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " visible data set \"").concat(ds.name, "\" added but no info about it in our dataSets structures"));
             // todo: add a metric here
             dataSetsRequiringInitialization.push(ds);
           }
@@ -730,21 +854,20 @@ var HashTreeParser = /*#__PURE__*/function () {
      * Adds entries to the passed in updateObjects array
      * for the changes that result from adding and removing visible data sets.
      *
-     * @param {HashTreeMessage} message - The hash tree message that triggered the visible data set changes.
-     * @param {string[]} addedDataSets - The list of added data sets.
+     * @param {VisibleDataSetInfo[]} addedDataSets - The list of added data sets.
      * @returns {Promise<void>}
      */
   }, {
     key: "initializeNewVisibleDataSets",
     value: (function () {
-      var _initializeNewVisibleDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4(message, addedDataSets) {
-        var _this6 = this;
+      var _initializeNewVisibleDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4(addedDataSets) {
+        var _this7 = this;
         var allDataSets, _iterator7, _step7, _loop, _t2;
         return _regenerator.default.wrap(function (_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
               _context5.next = 1;
-              return this.getAllDataSetsMetadata(message.visibleDataSetsUrl);
+              return this.getAllVisibleDataSetsFromLocus();
             case 1:
               allDataSets = _context5.sent;
               _iterator7 = _createForOfIteratorHelper(addedDataSets);
@@ -756,22 +879,22 @@ var HashTreeParser = /*#__PURE__*/function () {
                     case 0:
                       ds = _step7.value;
                       dataSetInfo = allDataSets.find(function (d) {
-                        return d.name === ds;
+                        return d.name === ds.name;
                       });
-                      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this6.debugId, " initializing data set \"").concat(ds, "\""));
+                      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this7.debugId, " initializing data set \"").concat(ds.name, "\""));
                       if (dataSetInfo) {
                         _context4.next = 1;
                         break;
                       }
-                      _loggerProxy.default.logger.warn("HashTreeParser#handleHashTreeMessage --> ".concat(_this6.debugId, " missing info about data set \"").concat(ds, "\" in Locus response from visibleDataSetsUrl"));
+                      _loggerProxy.default.logger.warn("HashTreeParser#handleHashTreeMessage --> ".concat(_this7.debugId, " missing info about data set \"").concat(ds.name, "\" in Locus response from visibleDataSetsUrl"));
                       _context4.next = 3;
                       break;
                     case 1:
                       _context4.next = 2;
-                      return _this6.initializeNewVisibleDataSet(dataSetInfo);
+                      return _this7.initializeNewVisibleDataSet(ds, dataSetInfo);
                     case 2:
                       updates = _context4.sent;
-                      _this6.callLocusInfoUpdateCallback(updates);
+                      _this7.callLocusInfoUpdateCallback(updates);
                     case 3:
                     case "end":
                       return _context4.stop();
@@ -805,7 +928,7 @@ var HashTreeParser = /*#__PURE__*/function () {
           }
         }, _callee4, this, [[2, 6, 7, 8]]);
       }));
-      function initializeNewVisibleDataSets(_x5, _x6) {
+      function initializeNewVisibleDataSets(_x5) {
         return _initializeNewVisibleDataSets.apply(this, arguments);
       }
       return initializeNewVisibleDataSets;
@@ -823,8 +946,8 @@ var HashTreeParser = /*#__PURE__*/function () {
     value: (function () {
       var _parseMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(message, debugText) {
         var _message$locusStateEl,
-          _this7 = this;
-        var dataSets, visibleDataSetsUrl, isRosterDropped, updatedObjects, dataSetsRequiringInitialization, selfUpdates, updatedSelfObjects, _this$checkForVisible, changeDetected, removedDataSets, addedDataSets;
+          _this8 = this;
+        var dataSets, visibleDataSetsUrl, isRosterDropped, updatedObjects, dataSetsRequiringInitialization, metadataUpdates, updatedMetadataObjects, _this$checkForVisible2, changeDetected, removedDataSets, addedDataSets;
         return _regenerator.default.wrap(function (_context6) {
           while (1) switch (_context6.prev = _context6.next) {
             case 0:
@@ -838,7 +961,7 @@ var HashTreeParser = /*#__PURE__*/function () {
               // first, update our metadata about the datasets with info from the message
               this.visibleDataSetsUrl = visibleDataSetsUrl;
               dataSets.forEach(function (dataSet) {
-                return _this7.updateDataSetInfo(dataSet);
+                return _this8.updateDataSetInfo(dataSet);
               });
               if (!this.isEndMessage(message)) {
                 _context6.next = 1;
@@ -853,27 +976,24 @@ var HashTreeParser = /*#__PURE__*/function () {
               isRosterDropped = false;
               updatedObjects = []; // when we detect new visible datasets, it may be that the metadata about them is not
               // available in the message, they will require separate async initialization
-              dataSetsRequiringInitialization = []; // first find out if there are any visible data set changes - they're signalled in SELF object updates
-              selfUpdates = (message.locusStateElements || []).filter(function (object) {
-                return (
-                  // todo: SPARK-744859 once Locus supports it, we will filter for "Metadata" type here instead of "self"
-                  (0, _utils.isSelf)(object)
-                );
+              dataSetsRequiringInitialization = []; // first find out if there are any visible data set changes - they're signalled in Metadata object updates
+              metadataUpdates = (message.locusStateElements || []).filter(function (object) {
+                return (0, _utils.isMetadata)(object);
               });
-              if (selfUpdates.length > 0) {
-                updatedSelfObjects = [];
-                selfUpdates.forEach(function (object) {
+              if (metadataUpdates.length > 0) {
+                updatedMetadataObjects = [];
+                metadataUpdates.forEach(function (object) {
                   // todo: once Locus supports it, we will use the "view" field here instead of dataSetNames
                   var _iterator8 = _createForOfIteratorHelper(object.htMeta.dataSetNames),
                     _step8;
                   try {
                     for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-                      var _this7$dataSets$dataS;
+                      var _this8$dataSets$dataS;
                       var dataSetName = _step8.value;
-                      var hashTree = (_this7$dataSets$dataS = _this7.dataSets[dataSetName]) === null || _this7$dataSets$dataS === void 0 ? void 0 : _this7$dataSets$dataS.hashTree;
+                      var hashTree = (_this8$dataSets$dataS = _this8.dataSets[dataSetName]) === null || _this8$dataSets$dataS === void 0 ? void 0 : _this8$dataSets$dataS.hashTree;
                       if (hashTree && object.data) {
                         if (hashTree.putItem(object.htMeta.elementId)) {
-                          updatedSelfObjects.push(object);
+                          updatedMetadataObjects.push(object);
                         }
                       }
                     }
@@ -883,8 +1003,8 @@ var HashTreeParser = /*#__PURE__*/function () {
                     _iterator8.f();
                   }
                 });
-                updatedObjects.push.apply(updatedObjects, updatedSelfObjects);
-                _this$checkForVisible = this.checkForVisibleDataSetChanges(updatedSelfObjects), changeDetected = _this$checkForVisible.changeDetected, removedDataSets = _this$checkForVisible.removedDataSets, addedDataSets = _this$checkForVisible.addedDataSets;
+                updatedObjects.push.apply(updatedObjects, updatedMetadataObjects);
+                _this$checkForVisible2 = this.checkForVisibleDataSetChanges(updatedMetadataObjects), changeDetected = _this$checkForVisible2.changeDetected, removedDataSets = _this$checkForVisible2.removedDataSets, addedDataSets = _this$checkForVisible2.addedDataSets;
                 if (changeDetected) {
                   dataSetsRequiringInitialization = this.processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects);
                 }
@@ -894,8 +1014,8 @@ var HashTreeParser = /*#__PURE__*/function () {
               // and hash trees created for the new visible data sets,
               // so we can now process all the updates from the message
               dataSets.forEach(function (dataSet) {
-                if (_this7.dataSets[dataSet.name]) {
-                  var hashTree = _this7.dataSets[dataSet.name].hashTree;
+                if (_this8.dataSets[dataSet.name]) {
+                  var hashTree = _this8.dataSets[dataSet.name].hashTree;
                   if (hashTree) {
                     var locusStateElementsForThisSet = message.locusStateElements.filter(function (object) {
                       return object.htMeta.dataSetNames.includes(dataSet.name);
@@ -922,11 +1042,11 @@ var HashTreeParser = /*#__PURE__*/function () {
                       }
                     });
                   } else {
-                    _loggerProxy.default.logger.info("Locus-info:index#parseMessage --> ".concat(_this7.debugId, " unexpected (not visible) dataSet ").concat(dataSet.name, " received in hash tree message"));
+                    _loggerProxy.default.logger.info("Locus-info:index#parseMessage --> ".concat(_this8.debugId, " unexpected (not visible) dataSet ").concat(dataSet.name, " received in hash tree message"));
                   }
                 }
                 if (!isRosterDropped) {
-                  _this7.runSyncAlgorithm(dataSet);
+                  _this8.runSyncAlgorithm(dataSet);
                 }
               });
               if (!isRosterDropped) {
@@ -944,7 +1064,7 @@ var HashTreeParser = /*#__PURE__*/function () {
               if (dataSetsRequiringInitialization.length > 0) {
                 // there are some data sets that we need to initialize asynchronously
                 queueMicrotask(function () {
-                  _this7.initializeNewVisibleDataSets(message, dataSetsRequiringInitialization);
+                  _this8.initializeNewVisibleDataSets(dataSetsRequiringInitialization);
                 });
               }
               if (updatedObjects.length === 0) {
@@ -960,7 +1080,7 @@ var HashTreeParser = /*#__PURE__*/function () {
           }
         }, _callee5, this);
       }));
-      function parseMessage(_x7, _x8) {
+      function parseMessage(_x6, _x7) {
         return _parseMessage.apply(this, arguments);
       }
       return parseMessage;
@@ -1000,7 +1120,7 @@ var HashTreeParser = /*#__PURE__*/function () {
           }
         }, _callee6, this);
       }));
-      function handleMessage(_x9, _x0) {
+      function handleMessage(_x8, _x9) {
         return _handleMessage.apply(this, arguments);
       }
       return handleMessage;
@@ -1015,9 +1135,49 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "callLocusInfoUpdateCallback",
     value: function callLocusInfoUpdateCallback(updates) {
+      var _this9 = this;
       var updateType = updates.updateType,
         updatedObjects = updates.updatedObjects;
-      if (updateType !== LocusInfoUpdateType.OBJECTS_UPDATED || (updatedObjects === null || updatedObjects === void 0 ? void 0 : updatedObjects.length) > 0) {
+      if (updateType === LocusInfoUpdateType.OBJECTS_UPDATED && (updatedObjects === null || updatedObjects === void 0 ? void 0 : updatedObjects.length) > 0) {
+        // Filter out updates for objects that already have a higher version in their datasets,
+        // or removals for objects that still exist in any of their datasets
+        var filteredUpdates = updatedObjects.filter(function (object) {
+          var elementId = object.htMeta.elementId;
+          var type = elementId.type,
+            id = elementId.id,
+            version = elementId.version;
+
+          // Check all datasets
+          for (var _i2 = 0, _Object$keys3 = (0, _keys.default)(_this9.dataSets); _i2 < _Object$keys3.length; _i2++) {
+            var dataSetName = _Object$keys3[_i2];
+            var dataSet = _this9.dataSets[dataSetName];
+
+            // only visible datasets have hash trees set
+            if (dataSet !== null && dataSet !== void 0 && dataSet.hashTree) {
+              var existingVersion = dataSet.hashTree.getItemVersion(id, type);
+              if (existingVersion !== undefined) {
+                if (object.data) {
+                  // For updates: filter out if any dataset has a higher version
+                  if (existingVersion > version) {
+                    _loggerProxy.default.logger.info("HashTreeParser#callLocusInfoUpdateCallback --> ".concat(_this9.debugId, " Filtering out update for ").concat(type, ":").concat(id, " v").concat(version, " because dataset \"").concat(dataSetName, "\" has v").concat(existingVersion));
+                    return false;
+                  }
+                } else if (existingVersion >= version) {
+                  // For removals: filter out if the object still exists in any dataset
+                  _loggerProxy.default.logger.info("HashTreeParser#callLocusInfoUpdateCallback --> ".concat(_this9.debugId, " Filtering out removal for ").concat(type, ":").concat(id, " v").concat(version, " because dataset \"").concat(dataSetName, "\" still has v").concat(existingVersion));
+                  return false;
+                }
+              }
+            }
+          }
+          return true;
+        });
+        if (filteredUpdates.length > 0) {
+          this.locusInfoUpdateCallback(updateType, {
+            updatedObjects: filteredUpdates
+          });
+        }
+      } else if (updateType !== LocusInfoUpdateType.OBJECTS_UPDATED) {
         this.locusInfoUpdateCallback(updateType, {
           updatedObjects: updatedObjects
         });
@@ -1048,7 +1208,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "runSyncAlgorithm",
     value: function runSyncAlgorithm(receivedDataSet) {
-      var _this8 = this;
+      var _this0 = this;
       var dataSet = this.dataSets[receivedDataSet.name];
       if (!dataSet) {
         _loggerProxy.default.logger.warn("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " No data set found for ").concat(receivedDataSet.name, ", skipping sync algorithm"));
@@ -1070,7 +1230,7 @@ var HashTreeParser = /*#__PURE__*/function () {
         }
         _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " setting \"").concat(dataSet.name, "\" sync timer for ").concat(delay));
         dataSet.timer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
-          var rootHash, mismatchedLeavesData, receivedHashes, _yield$_this8$getHash, hashes, latestDataSetInfo, mismatchedLeaveIndexes, syncResponse, _t3;
+          var rootHash, mismatchedLeavesData, receivedHashes, _yield$_this0$getHash, hashes, latestDataSetInfo, mismatchedLeaveIndexes, syncResponse, _t3;
           return _regenerator.default.wrap(function (_context8) {
             while (1) switch (_context8.prev = _context8.next) {
               case 0:
@@ -1079,7 +1239,7 @@ var HashTreeParser = /*#__PURE__*/function () {
                   _context8.next = 1;
                   break;
                 }
-                _loggerProxy.default.logger.warn("HashTreeParser#runSyncAlgorithm --> ".concat(_this8.debugId, " Data set \"").concat(dataSet.name, "\" no longer has a hash tree, cannot run sync algorithm"));
+                _loggerProxy.default.logger.warn("HashTreeParser#runSyncAlgorithm --> ".concat(_this0.debugId, " Data set \"").concat(dataSet.name, "\" no longer has a hash tree, cannot run sync algorithm"));
                 return _context8.abrupt("return");
               case 1:
                 rootHash = dataSet.hashTree.getRootHash();
@@ -1087,7 +1247,7 @@ var HashTreeParser = /*#__PURE__*/function () {
                   _context8.next = 11;
                   break;
                 }
-                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this8.debugId, " Root hash mismatch: received=").concat(dataSet.root, ", ours=").concat(rootHash, ", syncing data set \"").concat(dataSet.name, "\""));
+                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this0.debugId, " Root hash mismatch: received=").concat(dataSet.root, ", ours=").concat(rootHash, ", syncing data set \"").concat(dataSet.name, "\""));
                 mismatchedLeavesData = {};
                 if (!(dataSet.leafCount !== 1)) {
                   _context8.next = 7;
@@ -1095,11 +1255,11 @@ var HashTreeParser = /*#__PURE__*/function () {
                 }
                 _context8.prev = 2;
                 _context8.next = 3;
-                return _this8.getHashesFromLocus(dataSet.name);
+                return _this0.getHashesFromLocus(dataSet.name, rootHash);
               case 3:
-                _yield$_this8$getHash = _context8.sent;
-                hashes = _yield$_this8$getHash.hashes;
-                latestDataSetInfo = _yield$_this8$getHash.dataSet;
+                _yield$_this0$getHash = _context8.sent;
+                hashes = _yield$_this0$getHash.hashes;
+                latestDataSetInfo = _yield$_this0$getHash.dataSet;
                 receivedHashes = hashes;
                 dataSet.hashTree.resize(latestDataSetInfo.leafCount);
                 _context8.next = 6;
@@ -1112,7 +1272,7 @@ var HashTreeParser = /*#__PURE__*/function () {
                   break;
                 }
                 // this is a leaf count mismatch, we should do nothing, just wait for another heartbeat message from Locus
-                _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this8.debugId, " Got 409 when fetching hashes for data set \"").concat(dataSet.name, "\": ").concat(_t3.message));
+                _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this0.debugId, " Got 409 when fetching hashes for data set \"").concat(dataSet.name, "\": ").concat(_t3.message));
                 return _context8.abrupt("return");
               case 5:
                 throw _t3;
@@ -1132,19 +1292,19 @@ var HashTreeParser = /*#__PURE__*/function () {
                   break;
                 }
                 _context8.next = 9;
-                return _this8.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
+                return _this0.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
               case 9:
                 syncResponse = _context8.sent;
                 // sync API may return nothing (in that case data will arrive via messages)
                 // or it may return a response in the same format as messages
                 if (syncResponse) {
-                  _this8.handleMessage(syncResponse, 'via sync API');
+                  _this0.handleMessage(syncResponse, 'via sync API');
                 }
               case 10:
                 _context8.next = 12;
                 break;
               case 11:
-                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this8.debugId, " \"").concat(dataSet.name, "\" root hash matching: ").concat(rootHash, ", version=").concat(dataSet.version));
+                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this0.debugId, " \"").concat(dataSet.name, "\" root hash matching: ").concat(rootHash, ", version=").concat(dataSet.version));
               case 12:
               case "end":
                 return _context8.stop();
@@ -1174,33 +1334,37 @@ var HashTreeParser = /*#__PURE__*/function () {
     /**
      * Gets the current hashes from the locus for a specific data set.
      * @param {string} dataSetName
+     * @param {string} currentRootHash
      * @returns {string[]}
      */
   }, {
     key: "getHashesFromLocus",
-    value: function getHashesFromLocus(dataSetName) {
-      var _this9 = this;
+    value: function getHashesFromLocus(dataSetName, currentRootHash) {
+      var _this1 = this;
       _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(this.debugId, " Requesting hashes for data set \"").concat(dataSetName, "\""));
       var dataSet = this.dataSets[dataSetName];
       var url = "".concat(dataSet.url, "/hashtree");
       return this.webexRequest({
         method: _constants.HTTP_VERBS.GET,
-        uri: url
+        uri: url,
+        qs: {
+          rootHash: currentRootHash
+        }
       }).then(function (response) {
         var _response$body, _response$body2;
         var hashes = (_response$body = response.body) === null || _response$body === void 0 ? void 0 : _response$body.hashes;
         var dataSetFromResponse = (_response$body2 = response.body) === null || _response$body2 === void 0 ? void 0 : _response$body2.dataSet;
         if (!hashes || !(0, _isArray.default)(hashes)) {
-          _loggerProxy.default.logger.warn("HashTreeParser#getHashesFromLocus --> ".concat(_this9.debugId, " Locus returned invalid hashes, response body="), response.body);
+          _loggerProxy.default.logger.warn("HashTreeParser#getHashesFromLocus --> ".concat(_this1.debugId, " Locus returned invalid hashes, response body="), response.body);
           throw new Error("Locus returned invalid hashes: ".concat(hashes));
         }
-        _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this9.debugId, " Received hashes for data set \"").concat(dataSetName, "\": ").concat((0, _stringify.default)(hashes)));
+        _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this1.debugId, " Received hashes for data set \"").concat(dataSetName, "\": ").concat((0, _stringify.default)(hashes)));
         return {
           hashes: hashes,
           dataSet: dataSetFromResponse
         };
       }).catch(function (error) {
-        _loggerProxy.default.logger.error("HashTreeParser#getHashesFromLocus --> ".concat(_this9.debugId, " Error ").concat(error.statusCode, " fetching hashes for data set \"").concat(dataSetName, "\":"), error);
+        _loggerProxy.default.logger.error("HashTreeParser#getHashesFromLocus --> ".concat(_this1.debugId, " Error ").concat(error.statusCode, " fetching hashes for data set \"").concat(dataSetName, "\":"), error);
         throw error;
       });
     }
@@ -1215,7 +1379,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "sendSyncRequestToLocus",
     value: function sendSyncRequestToLocus(dataSet, mismatchedLeavesData) {
-      var _this0 = this;
+      var _this10 = this;
       _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(this.debugId, " Sending sync request for data set \"").concat(dataSet.name, "\""));
       var url = "".concat(dataSet.url, "/sync");
       var body = {
@@ -1228,19 +1392,23 @@ var HashTreeParser = /*#__PURE__*/function () {
           elementIds: mismatchedLeavesData[index]
         });
       });
+      var ourCurrentRootHash = dataSet.hashTree ? dataSet.hashTree.getRootHash() : _constants2.EMPTY_HASH;
       return this.webexRequest({
         method: _constants.HTTP_VERBS.POST,
         uri: url,
+        qs: {
+          rootHash: ourCurrentRootHash
+        },
         body: body
       }).then(function (resp) {
-        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this0.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
+        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this10.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
         if (!resp.body || (0, _lodash.isEmpty)(resp.body)) {
-          _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this0.debugId, " Got ").concat(resp.statusCode, " with empty body for sync request for data set \"").concat(dataSet.name, "\", data should arrive via messages"));
+          _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this10.debugId, " Got ").concat(resp.statusCode, " with empty body for sync request for data set \"").concat(dataSet.name, "\", data should arrive via messages"));
           return null;
         }
         return resp.body;
       }).catch(function (error) {
-        _loggerProxy.default.logger.error("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this0.debugId, " Error ").concat(error.statusCode, " sending sync request for data set \"").concat(dataSet.name, "\":"), error);
+        _loggerProxy.default.logger.error("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this10.debugId, " Error ").concat(error.statusCode, " sending sync request for data set \"").concat(dataSet.name, "\":"), error);
         throw error;
       });
     }