@webex/plugin-meetings 3.12.0-next.3 → 3.12.0-next.31

package/dist/hashTree/hashTreeParser.js

@@ -17,15 +17,15 @@ _Object$defineProperty(exports, "__esModule", {
 });
 exports.default = exports.MeetingEndedError = exports.LocusInfoUpdateType = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
-var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
 var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
 var _isArray = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/array/is-array"));
 var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
 var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
 var _parseInt2 = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/parse-int"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
 var _typeof2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/typeof"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
@@ -39,6 +39,7 @@ var _hashTree = _interopRequireDefault(require("./hashTree"));
 var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
 var _constants = require("../constants");
 var _constants2 = require("./constants");
+var _types = require("./types");
 var _utils = require("./utils");
 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; }
@@ -91,6 +92,10 @@ var HashTreeParser = /*#__PURE__*/function () {
     (0, _defineProperty2.default)(this, "heartbeatIntervalMs", void 0);
     (0, _defineProperty2.default)(this, "excludedDataSets", void 0);
     (0, _defineProperty2.default)(this, "state", void 0);
+    (0, _defineProperty2.default)(this, "syncQueue", []);
+    (0, _defineProperty2.default)(this, "isSyncInProgress", false);
+    (0, _defineProperty2.default)(this, "isSyncAllInProgress", false);
+    (0, _defineProperty2.default)(this, "syncQueueProcessingPromise", _promise.default.resolve());
     var _options$initialLocus = options.initialLocus,
       dataSets = _options$initialLocus.dataSets,
       locus = _options$initialLocus.locus; // extract dataSets from initialLocus
@@ -211,69 +216,54 @@ var HashTreeParser = /*#__PURE__*/function () {
      */
   }, {
     key: "initializeNewVisibleDataSet",
-    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(dataSetInfo.name, "\""));
-      if (!this.addToVisibleDataSetsList(visibleDataSetInfo)) {
-        return _promise.default.resolve({
-          updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-          updatedObjects: []
-        });
-      }
-      var hashTree = new _hashTree.default([], dataSetInfo.leafCount);
-      this.dataSets[dataSetInfo.name] = _objectSpread(_objectSpread({}, dataSetInfo), {}, {
-        hashTree: hashTree
-      });
-      return this.sendInitializationSyncRequestToLocus(dataSetInfo.name, 'new visible data set');
-    }
-
-    /**
-     * Sends a special sync request to Locus with all leaves empty - this is a way to get all the data for a given dataset.
-     *
-     * @param {string} datasetName - name of the dataset for which to send the request
-     * @param {string} debugText - text to include in logs
-     * @returns {Promise}
-     */
-  }, {
-    key: "sendInitializationSyncRequestToLocus",
-    value: function sendInitializationSyncRequestToLocus(datasetName, debugText) {
-      var _this2 = this;
-      var dataset = this.dataSets[datasetName];
-      if (!dataset) {
-        _loggerProxy.default.logger.warn("HashTreeParser#sendInitializationSyncRequestToLocus --> ".concat(this.debugId, " No data set found for ").concat(datasetName, ", cannot send the request for leaf data"));
-        return _promise.default.resolve(null);
+    value: (function () {
+      var _initializeNewVisibleDataSet = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(visibleDataSetInfo, dataSetInfo) {
+        var hashTree;
+        return _regenerator.default.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!this.isVisibleDataSet(dataSetInfo.name)) {
+                _context.next = 1;
+                break;
+              }
+              _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Data set \"").concat(dataSetInfo.name, "\" already exists, skipping init"));
+              return _context.abrupt("return");
+            case 1:
+              _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Adding visible data set \"").concat(dataSetInfo.name, "\""));
+              if (this.addToVisibleDataSetsList(visibleDataSetInfo)) {
+                _context.next = 2;
+                break;
+              }
+              return _context.abrupt("return");
+            case 2:
+              hashTree = new _hashTree.default([], dataSetInfo.leafCount);
+              this.dataSets[dataSetInfo.name] = _objectSpread(_objectSpread({}, dataSetInfo), {}, {
+                hashTree: hashTree
+              });
+              this.enqueueSyncForDataset(dataSetInfo.name, 'new visible data set initialization', true);
+              _context.next = 3;
+              return this.syncQueueProcessingPromise;
+            case 3:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function initializeNewVisibleDataSet(_x, _x2) {
+        return _initializeNewVisibleDataSet.apply(this, arguments);
       }
-      var emptyLeavesData = new Array(dataset.leafCount).fill([]);
-      _loggerProxy.default.logger.info("HashTreeParser#sendInitializationSyncRequestToLocus --> ".concat(this.debugId, " Sending initial sync request to Locus for data set \"").concat(datasetName, "\" with empty leaf data"));
-      return this.sendSyncRequestToLocus(this.dataSets[datasetName], emptyLeavesData).then(function (syncResponse) {
-        if (syncResponse) {
-          return {
-            updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-            updatedObjects: _this2.parseMessage(syncResponse, "via empty leaves /sync API call for ".concat(debugText))
-          };
-        }
-        return {
-          updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-          updatedObjects: []
-        };
-      });
-    }
-
+      return initializeNewVisibleDataSet;
+    }()
     /**
      * Queries Locus for all up-to-date information about all visible data sets
      *
      * @returns {Promise}
      */
+    )
   }, {
     key: "getAllVisibleDataSetsFromLocus",
     value: function getAllVisibleDataSetsFromLocus() {
-      var _this3 = this;
+      var _this2 = this;
       if (!this.visibleDataSetsUrl) {
         _loggerProxy.default.logger.warn("HashTreeParser#getAllVisibleDataSetsFromLocus --> ".concat(this.debugId, " No visibleDataSetsUrl, cannot get data sets information"));
         return _promise.default.resolve([]);
@@ -284,7 +274,7 @@ var HashTreeParser = /*#__PURE__*/function () {
       }).then(function (response) {
         return response.body.dataSets;
       }).catch(function (error) {
-        _this3.checkForSentinelHttpResponse(error);
+        _this2.checkForSentinelHttpResponse(error);
         throw error;
       });
     }
@@ -298,26 +288,26 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "initializeFromMessage",
     value: (function () {
-      var _initializeFromMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(message) {
+      var _initializeFromMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2(message) {
         var visibleDataSets;
-        return _regenerator.default.wrap(function (_context) {
-          while (1) switch (_context.prev = _context.next) {
+        return _regenerator.default.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
             case 0:
               this.visibleDataSetsUrl = message.visibleDataSetsUrl;
               _loggerProxy.default.logger.info("HashTreeParser#initializeFromMessage --> ".concat(this.debugId, " visibleDataSetsUrl=").concat(this.visibleDataSetsUrl));
-              _context.next = 1;
+              _context2.next = 1;
               return this.getAllVisibleDataSetsFromLocus();
             case 1:
-              visibleDataSets = _context.sent;
-              _context.next = 2;
+              visibleDataSets = _context2.sent;
+              _context2.next = 2;
               return this.initializeDataSets(visibleDataSets, 'initialization from message');
             case 2:
             case "end":
-              return _context.stop();
+              return _context2.stop();
           }
-        }, _callee, this);
+        }, _callee2, this);
       }));
-      function initializeFromMessage(_x) {
+      function initializeFromMessage(_x3) {
         return _initializeFromMessage.apply(this, arguments);
       }
       return initializeFromMessage;
@@ -335,34 +325,34 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "initializeFromGetLociResponse",
     value: (function () {
-      var _initializeFromGetLociResponse = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2(locus) {
+      var _initializeFromGetLociResponse = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3(locus) {
         var _locus$links2, _locus$links2$resourc, _locus$links2$resourc2;
         var visibleDataSets;
-        return _regenerator.default.wrap(function (_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
+        return _regenerator.default.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
             case 0:
               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;
+                _context3.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");
+              return _context3.abrupt("return");
             case 1:
               this.visibleDataSetsUrl = locus.links.resources.visibleDataSets.url;
               _loggerProxy.default.logger.info("HashTreeParser#initializeFromGetLociResponse --> ".concat(this.debugId, " visibleDataSets url: ").concat(this.visibleDataSetsUrl));
-              _context2.next = 2;
+              _context3.next = 2;
               return this.getAllVisibleDataSetsFromLocus();
             case 2:
-              visibleDataSets = _context2.sent;
-              _context2.next = 3;
+              visibleDataSets = _context3.sent;
+              _context3.next = 3;
               return this.initializeDataSets(visibleDataSets, 'initialization from GET /loci response');
             case 3:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
-        }, _callee2, this);
+        }, _callee3, this);
       }));
-      function initializeFromGetLociResponse(_x2) {
+      function initializeFromGetLociResponse(_x4) {
         return _initializeFromGetLociResponse.apply(this, arguments);
       }
       return initializeFromGetLociResponse;
@@ -378,24 +368,23 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "initializeDataSets",
     value: (function () {
-      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) {
+      var _initializeDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4(visibleDataSets, debugText) {
+        var _iterator2, _step2, dataSet, name, leafCount, url, _t;
+        return _regenerator.default.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
             case 0:
               if (!(this.state === 'stopped')) {
-                _context3.next = 1;
+                _context4.next = 1;
                 break;
               }
-              return _context3.abrupt("return");
+              return _context4.abrupt("return");
             case 1:
-              updatedObjects = [];
-              _iterator2 = _createForOfIteratorHelper(visibleDataSets);
-              _context3.prev = 2;
+              _iterator2 = _createForOfIteratorHelper((0, _utils.sortByInitPriority)(visibleDataSets, _constants2.DATA_SET_INIT_PRIORITY));
+              _context4.prev = 2;
               _iterator2.s();
             case 3:
               if ((_step2 = _iterator2.n()).done) {
-                _context3.next = 7;
+                _context4.next = 6;
                 break;
               }
               dataSet = _step2.value;
@@ -407,59 +396,47 @@ var HashTreeParser = /*#__PURE__*/function () {
                 _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " dataset \"").concat(name, "\" already exists (").concat(debugText, ")"));
               }
               if (this.isVisibleDataSet(name)) {
-                _context3.next = 4;
+                _context4.next = 4;
                 break;
               }
               if (this.addToVisibleDataSetsList({
                 name: name,
                 url: url
               })) {
-                _context3.next = 4;
+                _context4.next = 4;
                 break;
               }
-              return _context3.abrupt("continue", 6);
+              return _context4.abrupt("continue", 5);
             case 4:
-              if (this.dataSets[name].hashTree) {
-                _context3.next = 6;
-                break;
+              if (!this.dataSets[name].hashTree) {
+                _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " creating hash tree for visible dataset \"").concat(name, "\" (").concat(debugText, ")"));
+                this.dataSets[name].hashTree = new _hashTree.default([], leafCount);
+                this.enqueueSyncForDataset(name, "initialization sync for ".concat(debugText), true);
               }
-              _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " creating hash tree for visible dataset \"").concat(name, "\" (").concat(debugText, ")"));
-              this.dataSets[name].hashTree = new _hashTree.default([], leafCount);
-
-              // eslint-disable-next-line no-await-in-loop
-              _context3.next = 5;
-              return this.sendInitializationSyncRequestToLocus(name, debugText);
             case 5:
-              _data = _context3.sent;
-              if (_data.updateType === LocusInfoUpdateType.OBJECTS_UPDATED) {
-                updatedObjects.push.apply(updatedObjects, (0, _toConsumableArray2.default)(_data.updatedObjects || []));
-              }
+              _context4.next = 3;
+              break;
             case 6:
-              _context3.next = 3;
+              _context4.next = 8;
               break;
             case 7:
-              _context3.next = 9;
-              break;
-            case 8:
-              _context3.prev = 8;
-              _t = _context3["catch"](2);
+              _context4.prev = 7;
+              _t = _context4["catch"](2);
               _iterator2.e(_t);
-            case 9:
-              _context3.prev = 9;
+            case 8:
+              _context4.prev = 8;
               _iterator2.f();
-              return _context3.finish(9);
+              return _context4.finish(8);
+            case 9:
+              _context4.next = 10;
+              return this.syncQueueProcessingPromise;
             case 10:
-              this.callLocusInfoUpdateCallback({
-                updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-                updatedObjects: updatedObjects
-              });
-            case 11:
             case "end":
-              return _context3.stop();
+              return _context4.stop();
           }
-        }, _callee3, this, [[2, 8, 9, 10]]);
+        }, _callee4, this, [[2, 7, 8, 9]]);
       }));
-      function initializeDataSets(_x3, _x4) {
+      function initializeDataSets(_x5, _x6) {
         return _initializeDataSets.apply(this, arguments);
       }
       return initializeDataSets;
@@ -483,7 +460,7 @@ var HashTreeParser = /*#__PURE__*/function () {
         copyData = _ref$copyData === void 0 ? false : _ref$copyData;
       // object mapping dataset names to arrays of leaf data
       var leafInfo = {};
-      var _findAndStoreMetaData = function findAndStoreMetaData(currentLocusPart) {
+      var _findAndStoreMetaData = function findAndStoreMetaData(currentLocusPart, currentLocusPartName) {
         if ((0, _typeof2.default)(currentLocusPart) !== 'object' || currentLocusPart === null) {
           return;
         }
@@ -499,10 +476,16 @@ var HashTreeParser = /*#__PURE__*/function () {
             version: version
           };
           if (copyData) {
-            newLeafInfo.data = (0, _lodash.cloneDeep)(currentLocusPart);
+            if (type.toLowerCase() === _types.ObjectType.control) {
+              // control entries require special handling, because they are signalled by Locus
+              // differently when coming in messages vs API responses
+              newLeafInfo.data = (0, _defineProperty2.default)({}, currentLocusPartName, (0, _lodash.cloneDeep)(currentLocusPart));
+            } else {
+              newLeafInfo.data = (0, _lodash.cloneDeep)(currentLocusPart);
 
-            // remove any nested other objects that have their own htMeta
-            (0, _utils.deleteNestedObjectsWithHtMeta)(newLeafInfo.data);
+              // remove any nested other objects that have their own htMeta
+              (0, _utils.deleteNestedObjectsWithHtMeta)(newLeafInfo.data);
+            }
           }
           var _iterator3 = _createForOfIteratorHelper(dataSetNames),
             _step3;
@@ -521,12 +504,14 @@ var HashTreeParser = /*#__PURE__*/function () {
           }
         }
         if ((0, _isArray.default)(currentLocusPart)) {
-          var _iterator4 = _createForOfIteratorHelper(currentLocusPart),
+          var _iterator4 = _createForOfIteratorHelper(currentLocusPart.entries()),
             _step4;
           try {
             for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-              var item = _step4.value;
-              _findAndStoreMetaData(item);
+              var _step4$value = (0, _slicedToArray2.default)(_step4.value, 2),
+                index = _step4$value[0],
+                item = _step4$value[1];
+              _findAndStoreMetaData(item, index.toString());
             }
           } catch (err) {
             _iterator4.e(err);
@@ -537,12 +522,12 @@ var HashTreeParser = /*#__PURE__*/function () {
           for (var _i = 0, _Object$keys = (0, _keys.default)(currentLocusPart); _i < _Object$keys.length; _i++) {
             var key = _Object$keys[_i];
             if (Object.prototype.hasOwnProperty.call(currentLocusPart, key)) {
-              _findAndStoreMetaData(currentLocusPart[key]);
+              _findAndStoreMetaData(currentLocusPart[key], key);
             }
           }
         }
       };
-      _findAndStoreMetaData(locus);
+      _findAndStoreMetaData(locus, 'locus');
       return leafInfo;
     }
 
@@ -587,9 +572,9 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "isEndMessage",
     value: function isEndMessage(message) {
-      var _this4 = this;
+      var _this3 = this;
       return message.dataSets.some(function (dataSet) {
-        if (dataSet.leafCount === 1 && dataSet.root === _constants2.EMPTY_HASH && (!_this4.dataSets[dataSet.name] || _this4.dataSets[dataSet.name].version < dataSet.version) && PossibleSentinelMessageDataSetNames.includes(dataSet.name.toLowerCase())) {
+        if (dataSet.leafCount === 1 && dataSet.root === _constants2.EMPTY_HASH && (!_this3.dataSets[dataSet.name] || _this3.dataSets[dataSet.name].version < dataSet.version) && PossibleSentinelMessageDataSetNames.includes(dataSet.name.toLowerCase())) {
           // this is a special way for Locus to indicate that this meeting has ended
           return true;
         }
@@ -606,7 +591,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "handleRootHashHeartBeatMessage",
     value: function handleRootHashHeartBeatMessage(message) {
-      var _this5 = this;
+      var _this4 = this;
       var dataSets = message.dataSets;
       _loggerProxy.default.logger.info("HashTreeParser#handleRootHashMessage --> ".concat(this.debugId, " Received heartbeat root hash message with data sets: ").concat((0, _stringify.default)(dataSets.map(function (_ref2) {
         var name = _ref2.name,
@@ -621,8 +606,8 @@ var HashTreeParser = /*#__PURE__*/function () {
         };
       }))));
       dataSets.forEach(function (dataSet) {
-        _this5.updateDataSetInfo(dataSet);
-        _this5.runSyncAlgorithm(dataSet);
+        _this4.updateDataSetInfo(dataSet);
+        _this4.runSyncAlgorithm(dataSet);
       });
     }
 
@@ -635,18 +620,18 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "queueInitForNewVisibleDataSets",
     value: function queueInitForNewVisibleDataSets(dataSetsRequiringInitialization) {
-      var _this6 = this;
+      var _this5 = this;
       _loggerProxy.default.logger.info("HashTreeParser#queueInitForNewVisibleDataSets --> ".concat(this.debugId, " queuing initialization of new visible datasets: ").concat(dataSetsRequiringInitialization.map(function (ds) {
         return ds.name;
       }).join(', ')));
       queueMicrotask(function () {
-        _this6.initializeNewVisibleDataSets(dataSetsRequiringInitialization).catch(function (error) {
+        _this5.initializeNewVisibleDataSets(dataSetsRequiringInitialization).catch(function (error) {
           if (error instanceof MeetingEndedError) {
-            _this6.callLocusInfoUpdateCallback({
+            _this5.callLocusInfoUpdateCallback({
               updateType: LocusInfoUpdateType.MEETING_ENDED
             });
           } else {
-            _loggerProxy.default.logger.warn("HashTreeParser#queueInitForNewVisibleDataSets --> ".concat(_this6.debugId, " error while initializing new visible datasets: ").concat(dataSetsRequiringInitialization.map(function (ds) {
+            _loggerProxy.default.logger.warn("HashTreeParser#queueInitForNewVisibleDataSets --> ".concat(_this5.debugId, " error while initializing new visible datasets: ").concat(dataSetsRequiringInitialization.map(function (ds) {
               return ds.name;
             }).join(', '), ": "), error);
           }
@@ -706,7 +691,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "handleLocusUpdate",
     value: function handleLocusUpdate(update) {
-      var _this7 = this;
+      var _this6 = this;
       if (this.state === 'stopped') {
         return;
       }
@@ -714,6 +699,7 @@ var HashTreeParser = /*#__PURE__*/function () {
         locus = update.locus,
         metadata = update.metadata;
       if (!dataSets) {
+        // this happens for example when we handle GET /loci response
         _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received hash tree update without dataSets"));
       } else {
         var _iterator5 = _createForOfIteratorHelper(dataSets),
@@ -743,9 +729,9 @@ var HashTreeParser = /*#__PURE__*/function () {
 
       // 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 (_this7.dataSets[dataSetName]) {
-          if (_this7.dataSets[dataSetName].hashTree) {
-            var appliedChangesList = _this7.dataSets[dataSetName].hashTree.putItems(leafInfo[dataSetName].map(function (leaf) {
+        if (_this6.dataSets[dataSetName]) {
+          if (_this6.dataSets[dataSetName].hashTree) {
+            var appliedChangesList = _this6.dataSets[dataSetName].hashTree.putItems(leafInfo[dataSetName].map(function (leaf) {
               return {
                 id: leaf.id,
                 type: leaf.type,
@@ -772,10 +758,10 @@ var HashTreeParser = /*#__PURE__*/function () {
             });
           } else {
             // no hash tree means that the data set is not visible
-            _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this7.debugId, " received leaf data for data set \"").concat(dataSetName, "\" that has no hash tree created, ignoring"));
+            _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this6.debugId, " received leaf data for data set \"").concat(dataSetName, "\" that has no hash tree created, ignoring"));
           }
         } else {
-          _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(_this7.debugId, " received leaf data for unknown data set \"").concat(dataSetName, "\", ignoring"));
+          _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(_this6.debugId, " received leaf data for unknown data set \"").concat(dataSetName, "\", ignoring"));
         }
       });
       if (updatedObjects.length === 0) {
@@ -823,7 +809,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "checkForVisibleDataSetChanges",
     value: function checkForVisibleDataSetChanges(updatedObjects) {
-      var _this8 = this;
+      var _this7 = this;
       var removedDataSets = [];
       var addedDataSets = [];
 
@@ -832,20 +818,20 @@ var HashTreeParser = /*#__PURE__*/function () {
         var _object$data;
         if ((0, _utils.isMetadata)(object) && (_object$data = object.data) !== null && _object$data !== void 0 && _object$data.visibleDataSets) {
           var newVisibleDataSets = object.data.visibleDataSets.filter(function (vds) {
-            return !_this8.isExcludedDataSet(vds.name);
+            return !_this7.isExcludedDataSet(vds.name);
           });
-          removedDataSets = _this8.visibleDataSets.filter(function (ds) {
+          removedDataSets = _this7.visibleDataSets.filter(function (ds) {
             return !newVisibleDataSets.some(function (nvs) {
               return nvs.name === ds.name;
             });
           });
           addedDataSets = newVisibleDataSets.filter(function (nvs) {
-            return _this8.visibleDataSets.every(function (ds) {
+            return _this7.visibleDataSets.every(function (ds) {
               return ds.name !== nvs.name;
             });
           });
           if (removedDataSets.length > 0 || addedDataSets.length > 0) {
-            _loggerProxy.default.logger.info("HashTreeParser#checkForVisibleDataSetChanges --> ".concat(_this8.debugId, " visible data sets change: removed: ").concat(removedDataSets.map(function (ds) {
+            _loggerProxy.default.logger.info("HashTreeParser#checkForVisibleDataSetChanges --> ".concat(_this7.debugId, " visible data sets change: removed: ").concat(removedDataSets.map(function (ds) {
               return ds.name;
             }).join(', '), ", added: ").concat(addedDataSets.map(function (ds) {
               return ds.name;
@@ -899,16 +885,16 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "processVisibleDataSetChanges",
     value: function processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects) {
-      var _this9 = this;
+      var _this8 = 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 _this9$dataSets$ds$na;
-        if ((_this9$dataSets$ds$na = _this9.dataSets[ds.name]) !== null && _this9$dataSets$ds$na !== void 0 && _this9$dataSets$ds$na.hashTree) {
-          for (var i = 0; i < _this9.dataSets[ds.name].hashTree.numLeaves; i += 1) {
-            removedObjects.push.apply(removedObjects, (0, _toConsumableArray2.default)(_this9.dataSets[ds.name].hashTree.getLeafData(i).map(function (elementId) {
+        var _this8$dataSets$ds$na;
+        if ((_this8$dataSets$ds$na = _this8.dataSets[ds.name]) !== null && _this8$dataSets$ds$na !== void 0 && _this8$dataSets$ds$na.hashTree) {
+          for (var i = 0; i < _this8.dataSets[ds.name].hashTree.numLeaves; i += 1) {
+            removedObjects.push.apply(removedObjects, (0, _toConsumableArray2.default)(_this8.dataSets[ds.name].hashTree.getLeafData(i).map(function (elementId) {
               return {
                 htMeta: {
                   elementId: elementId,
@@ -918,7 +904,7 @@ var HashTreeParser = /*#__PURE__*/function () {
               };
             })));
           }
-          _this9.deleteHashTree(ds.name);
+          _this8.deleteHashTree(ds.name);
         }
       });
       this.visibleDataSets = this.visibleDataSets.filter(function (vds) {
@@ -979,81 +965,78 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "initializeNewVisibleDataSets",
     value: (function () {
-      var _initializeNewVisibleDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4(addedDataSets) {
-        var _this0 = this;
+      var _initializeNewVisibleDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(addedDataSets) {
+        var _this9 = this;
         var allDataSets, _iterator7, _step7, _loop, _t2;
-        return _regenerator.default.wrap(function (_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
+        return _regenerator.default.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
             case 0:
               if (!(this.state === 'stopped')) {
-                _context5.next = 1;
+                _context6.next = 1;
                 break;
               }
-              return _context5.abrupt("return");
+              return _context6.abrupt("return");
             case 1:
-              _context5.next = 2;
+              _context6.next = 2;
               return this.getAllVisibleDataSetsFromLocus();
             case 2:
-              allDataSets = _context5.sent;
-              _iterator7 = _createForOfIteratorHelper(addedDataSets);
-              _context5.prev = 3;
+              allDataSets = _context6.sent;
+              _iterator7 = _createForOfIteratorHelper((0, _utils.sortByInitPriority)(addedDataSets, _constants2.DATA_SET_INIT_PRIORITY));
+              _context6.prev = 3;
               _loop = /*#__PURE__*/_regenerator.default.mark(function _loop() {
-                var ds, dataSetInfo, updates;
-                return _regenerator.default.wrap(function (_context4) {
-                  while (1) switch (_context4.prev = _context4.next) {
+                var ds, dataSetInfo;
+                return _regenerator.default.wrap(function (_context5) {
+                  while (1) switch (_context5.prev = _context5.next) {
                     case 0:
                       ds = _step7.value;
                       dataSetInfo = allDataSets.find(function (d) {
                         return d.name === ds.name;
                       });
-                      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this0.debugId, " initializing data set \"").concat(ds.name, "\""));
+                      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this9.debugId, " initializing data set \"").concat(ds.name, "\""));
                       if (dataSetInfo) {
-                        _context4.next = 1;
+                        _context5.next = 1;
                         break;
                       }
-                      _loggerProxy.default.logger.warn("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this0.debugId, " missing info about data set \"").concat(ds.name, "\" in Locus response from visibleDataSetsUrl"));
-                      _context4.next = 3;
+                      _loggerProxy.default.logger.warn("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this9.debugId, " missing info about data set \"").concat(ds.name, "\" in Locus response from visibleDataSetsUrl"));
+                      _context5.next = 2;
                       break;
                     case 1:
-                      _context4.next = 2;
-                      return _this0.initializeNewVisibleDataSet(ds, dataSetInfo);
+                      _context5.next = 2;
+                      return _this9.initializeNewVisibleDataSet(ds, dataSetInfo);
                     case 2:
-                      updates = _context4.sent;
-                      _this0.callLocusInfoUpdateCallback(updates);
-                    case 3:
                     case "end":
-                      return _context4.stop();
+                      return _context5.stop();
                   }
                 }, _loop);
               });
               _iterator7.s();
             case 4:
               if ((_step7 = _iterator7.n()).done) {
-                _context5.next = 6;
+                _context6.next = 6;
                 break;
               }
-              return _context5.delegateYield(_loop(), "t0", 5);
+              return _context6.delegateYield(_loop(), "t0", 5);
             case 5:
-              _context5.next = 4;
+              _context6.next = 4;
               break;
             case 6:
-              _context5.next = 8;
+              _context6.next = 8;
               break;
             case 7:
-              _context5.prev = 7;
-              _t2 = _context5["catch"](3);
+              _context6.prev = 7;
+              _t2 = _context6["catch"](3);
               _iterator7.e(_t2);
             case 8:
-              _context5.prev = 8;
+              _context6.prev = 8;
               _iterator7.f();
-              return _context5.finish(8);
+              return _context6.finish(8);
             case 9:
             case "end":
-              return _context5.stop();
+              return _context6.stop();
           }
-        }, _callee4, this, [[3, 7, 8, 9]]);
+        }, _callee5, this, [[3, 7, 8, 9]]);
       }));
-      function initializeNewVisibleDataSets(_x5) {
+      function initializeNewVisibleDataSets(_x7) {
         return _initializeNewVisibleDataSets.apply(this, arguments);
       }
       return initializeNewVisibleDataSets;
@@ -1070,8 +1053,7 @@ var HashTreeParser = /*#__PURE__*/function () {
     key: "parseMessage",
     value: function parseMessage(message, debugText) {
       var _message$locusStateEl,
-        _this1 = this,
-        _message$locusStateEl2;
+        _this0 = this;
       if (this.state === 'stopped') {
         return [];
       }
@@ -1086,7 +1068,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 _this1.updateDataSetInfo(dataSet);
+        return _this0.updateDataSetInfo(dataSet);
       });
       var updatedObjects = [];
 
@@ -1106,9 +1088,9 @@ var HashTreeParser = /*#__PURE__*/function () {
             _step8;
           try {
             for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-              var _this1$dataSets$dataS;
+              var _this0$dataSets$dataS;
               var dataSetName = _step8.value;
-              var hashTree = (_this1$dataSets$dataS = _this1.dataSets[dataSetName]) === null || _this1$dataSets$dataS === void 0 ? void 0 : _this1$dataSets$dataS.hashTree;
+              var hashTree = (_this0$dataSets$dataS = _this0.dataSets[dataSetName]) === null || _this0$dataSets$dataS === void 0 ? void 0 : _this0$dataSets$dataS.hashTree;
               if (hashTree && object.data) {
                 if (hashTree.putItem(object.htMeta.elementId)) {
                   updatedMetadataObjects.push(object);
@@ -1130,13 +1112,13 @@ var HashTreeParser = /*#__PURE__*/function () {
           dataSetsRequiringInitialization = this.processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects);
         }
       }
-      if (((_message$locusStateEl2 = message.locusStateElements) === null || _message$locusStateEl2 === void 0 ? void 0 : _message$locusStateEl2.length) > 0) {
+      if (message.locusStateElements && message.locusStateElements.length > 0) {
         // by this point we now have this.dataSets setup for data sets from this message
         // 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 (_this1.dataSets[dataSet.name]) {
-            var hashTree = _this1.dataSets[dataSet.name].hashTree;
+          if (_this0.dataSets[dataSet.name]) {
+            var hashTree = _this0.dataSets[dataSet.name].hashTree;
             if (hashTree) {
               var locusStateElementsForThisSet = message.locusStateElements.filter(function (object) {
                 return object.htMeta.dataSetNames.includes(dataSet.name);
@@ -1160,10 +1142,10 @@ var HashTreeParser = /*#__PURE__*/function () {
                 }
               });
             } else {
-              _loggerProxy.default.logger.info("Locus-info:index#parseMessage --> ".concat(_this1.debugId, " unexpected (not visible) dataSet ").concat(dataSet.name, " received in hash tree message"));
+              _loggerProxy.default.logger.info("Locus-info:index#parseMessage --> ".concat(_this0.debugId, " unexpected (not visible) dataSet ").concat(dataSet.name, " received in hash tree message"));
             }
           }
-          _this1.runSyncAlgorithm(dataSet);
+          _this0.runSyncAlgorithm(dataSet);
         });
       }
       if (dataSetsRequiringInitialization.length > 0) {
@@ -1220,25 +1202,25 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "callLocusInfoUpdateCallback",
     value: function callLocusInfoUpdateCallback(updates) {
-      var _this10 = this;
+      var _updates$updatedObjec,
+        _this1 = this;
       if (this.state === 'stopped') {
         return;
       }
-      var updateType = updates.updateType,
-        updatedObjects = updates.updatedObjects;
-      if (updateType === LocusInfoUpdateType.OBJECTS_UPDATED && (updatedObjects === null || updatedObjects === void 0 ? void 0 : updatedObjects.length) > 0) {
+      var updateType = updates.updateType;
+      if (updateType === LocusInfoUpdateType.OBJECTS_UPDATED && ((_updates$updatedObjec = updates.updatedObjects) === null || _updates$updatedObjec === void 0 ? void 0 : _updates$updatedObjec.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 filteredUpdates = updates.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)(_this10.dataSets); _i2 < _Object$keys3.length; _i2++) {
+          for (var _i2 = 0, _Object$keys3 = (0, _keys.default)(_this1.dataSets); _i2 < _Object$keys3.length; _i2++) {
             var dataSetName = _Object$keys3[_i2];
-            var dataSet = _this10.dataSets[dataSetName];
+            var dataSet = _this1.dataSets[dataSetName];
 
             // only visible datasets have hash trees set
             if (dataSet !== null && dataSet !== void 0 && dataSet.hashTree) {
@@ -1247,12 +1229,12 @@ var HashTreeParser = /*#__PURE__*/function () {
                 if (object.data) {
                   // For updates: filter out if any dataset has a higher version
                   if (existingVersion > version) {
-                    _loggerProxy.default.logger.info("HashTreeParser#callLocusInfoUpdateCallback --> ".concat(_this10.debugId, " Filtering out update for ").concat(type, ":").concat(id, " v").concat(version, " because dataset \"").concat(dataSetName, "\" has v").concat(existingVersion));
+                    _loggerProxy.default.logger.info("HashTreeParser#callLocusInfoUpdateCallback --> ".concat(_this1.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(_this10.debugId, " Filtering out removal for ").concat(type, ":").concat(id, " v").concat(version, " because dataset \"").concat(dataSetName, "\" still has v").concat(existingVersion));
+                  _loggerProxy.default.logger.info("HashTreeParser#callLocusInfoUpdateCallback --> ".concat(_this1.debugId, " Filtering out removal for ").concat(type, ":").concat(id, " v").concat(version, " because dataset \"").concat(dataSetName, "\" still has v").concat(existingVersion));
                   return false;
                 }
               }
@@ -1261,13 +1243,14 @@ var HashTreeParser = /*#__PURE__*/function () {
           return true;
         });
         if (filteredUpdates.length > 0) {
-          this.locusInfoUpdateCallback(updateType, {
+          this.locusInfoUpdateCallback({
+            updateType: updateType,
             updatedObjects: filteredUpdates
           });
         }
       } else if (updateType !== LocusInfoUpdateType.OBJECTS_UPDATED) {
-        this.locusInfoUpdateCallback(updateType, {
-          updatedObjects: updatedObjects
+        this.locusInfoUpdateCallback({
+          updateType: updateType
         });
       }
     }
@@ -1291,84 +1274,113 @@ var HashTreeParser = /*#__PURE__*/function () {
      * Performs a sync for the given data set.
      *
      * @param {InternalDataSet} dataSet - The data set to sync
-     * @param {string} rootHash - Our current root hash for this data set
      * @param {string} reason - The reason for the sync (used for logging)
+     * @param {boolean} [isInitialization] - Whether this is an initialization sync (sends empty leaves data instead of comparing hashes)
      * @returns {Promise<void>}
      */
   }, {
     key: "performSync",
     value: (function () {
-      var _performSync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(dataSet, rootHash, reason) {
-        var mismatchedLeavesData, receivedHashes, _yield$this$getHashes, hashes, latestDataSetInfo, mismatchedLeaveIndexes, syncResponse, _t3, _t4;
-        return _regenerator.default.wrap(function (_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
+      var _performSync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6(dataSet, reason, isInitialization) {
+        var hashTree, rootHash, leavesData, receivedHashes, hashesResult, mismatchedLeaveIndexes, syncResponse, _t3, _t4;
+        return _regenerator.default.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
             case 0:
               if (dataSet.hashTree) {
-                _context6.next = 1;
+                _context7.next = 1;
                 break;
               }
-              return _context6.abrupt("return");
+              return _context7.abrupt("return");
             case 1:
-              _context6.prev = 1;
+              hashTree = dataSet.hashTree;
+              rootHash = hashTree.getRootHash();
+              _context7.prev = 2;
               _loggerProxy.default.logger.info("HashTreeParser#performSync --> ".concat(this.debugId, " ").concat(reason, ", syncing data set \"").concat(dataSet.name, "\""));
-              mismatchedLeavesData = {};
+              leavesData = {};
+              if (isInitialization) {
+                _context7.next = 10;
+                break;
+              }
               if (!(dataSet.leafCount !== 1)) {
-                _context6.next = 7;
+                _context7.next = 9;
                 break;
               }
-              _context6.prev = 2;
-              _context6.next = 3;
+              _context7.prev = 3;
+              _context7.next = 4;
               return this.getHashesFromLocus(dataSet.name, rootHash);
-            case 3:
-              _yield$this$getHashes = _context6.sent;
-              hashes = _yield$this$getHashes.hashes;
-              latestDataSetInfo = _yield$this$getHashes.dataSet;
-              receivedHashes = hashes;
-              dataSet.hashTree.resize(latestDataSetInfo.leafCount);
-              _context6.next = 6;
-              break;
             case 4:
-              _context6.prev = 4;
-              _t3 = _context6["catch"](2);
-              if (!(_t3.statusCode === 409)) {
-                _context6.next = 5;
+              hashesResult = _context7.sent;
+              if (hashesResult) {
+                _context7.next = 5;
+                break;
+              }
+              return _context7.abrupt("return");
+            case 5:
+              receivedHashes = hashesResult.hashes;
+              hashTree.resize(hashesResult.dataSet.leafCount);
+              _context7.next = 8;
+              break;
+            case 6:
+              _context7.prev = 6;
+              _t3 = _context7["catch"](3);
+              if (!((_t3 === null || _t3 === void 0 ? void 0 : _t3.statusCode) === 409)) {
+                _context7.next = 7;
                 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(this.debugId, " Got 409 when fetching hashes for data set \"").concat(dataSet.name, "\": ").concat(_t3.message));
-              return _context6.abrupt("return");
-            case 5:
+              return _context7.abrupt("return");
+            case 7:
               throw _t3;
-            case 6:
+            case 8:
               // identify mismatched leaves
-              mismatchedLeaveIndexes = dataSet.hashTree.diffHashes(receivedHashes);
+              mismatchedLeaveIndexes = hashTree.diffHashes(receivedHashes);
               mismatchedLeaveIndexes.forEach(function (index) {
-                mismatchedLeavesData[index] = dataSet.hashTree.getLeafData(index);
+                leavesData[index] = hashTree.getLeafData(index);
               });
-              _context6.next = 8;
+              _context7.next = 10;
               break;
-            case 7:
-              mismatchedLeavesData[0] = dataSet.hashTree.getLeafData(0);
-            case 8:
-              if (!((0, _keys.default)(mismatchedLeavesData).length > 0)) {
-                _context6.next = 10;
+            case 9:
+              leavesData = {
+                0: hashTree.getLeafData(0)
+              };
+            case 10:
+              // request sync for mismatched leaves
+              syncResponse = null;
+              if (!isInitialization) {
+                _context7.next = 12;
                 break;
               }
-              _context6.next = 9;
-              return this.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
-            case 9:
-              syncResponse = _context6.sent;
+              _context7.next = 11;
+              return this.sendSyncRequestToLocus(dataSet, {
+                isInitialization: true
+              });
+            case 11:
+              syncResponse = _context7.sent;
+              _context7.next = 14;
+              break;
+            case 12:
+              if (!((0, _keys.default)(leavesData).length > 0)) {
+                _context7.next = 14;
+                break;
+              }
+              _context7.next = 13;
+              return this.sendSyncRequestToLocus(dataSet, {
+                mismatchedLeavesData: leavesData
+              });
+            case 13:
+              syncResponse = _context7.sent;
+            case 14:
               // 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) {
                 this.handleMessage(syncResponse, 'via sync API');
               }
-            case 10:
-              _context6.next = 12;
+              _context7.next = 16;
               break;
-            case 11:
-              _context6.prev = 11;
-              _t4 = _context6["catch"](1);
+            case 15:
+              _context7.prev = 15;
+              _t4 = _context7["catch"](2);
               if (_t4 instanceof MeetingEndedError) {
                 this.callLocusInfoUpdateCallback({
                   updateType: LocusInfoUpdateType.MEETING_ENDED
@@ -1376,17 +1388,176 @@ var HashTreeParser = /*#__PURE__*/function () {
               } else {
                 _loggerProxy.default.logger.warn("HashTreeParser#performSync --> ".concat(this.debugId, " error during sync for data set \"").concat(dataSet.name, "\":"), _t4);
               }
-            case 12:
+            case 16:
             case "end":
-              return _context6.stop();
+              return _context7.stop();
           }
-        }, _callee5, this, [[1, 11], [2, 4]]);
+        }, _callee6, this, [[2, 15], [3, 6]]);
       }));
-      function performSync(_x6, _x7, _x8) {
+      function performSync(_x8, _x9, _x0) {
         return _performSync.apply(this, arguments);
       }
       return performSync;
     }()
+    /**
+     * Enqueues a sync for the given data set. If the data set is already in the queue, the request is ignored.
+     * This ensures that all syncs are executed sequentially and no more than 1 sync runs at a time.
+     *
+     * @param {string} dataSetName - The name of the data set to sync
+     * @param {string} reason - The reason for the sync (used for logging)
+     * @param {boolean} [isInitialization=false] - Whether this is an initialization sync (uses empty leaves data instead of hash comparison)
+     * @returns {void}
+     */
+    )
+  }, {
+    key: "enqueueSyncForDataset",
+    value: function enqueueSyncForDataset(dataSetName, reason) {
+      var isInitialization = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      if (this.state === 'stopped') return;
+      var existingEntry = this.syncQueue.find(function (entry) {
+        return entry.dataSetName === dataSetName;
+      });
+      if (existingEntry) {
+        if (isInitialization) {
+          existingEntry.isInitialization = true;
+        }
+        _loggerProxy.default.logger.info("HashTreeParser#enqueueSyncForDataset --> ".concat(this.debugId, " data set \"").concat(dataSetName, "\" already in sync queue, skipping"));
+        return;
+      }
+      this.syncQueue.push({
+        dataSetName: dataSetName,
+        reason: reason,
+        isInitialization: isInitialization
+      });
+      if (!this.isSyncInProgress) {
+        this.syncQueueProcessingPromise = this.processSyncQueue();
+      }
+    }
+
+    /**
+     * Processes the sync queue sequentially. Only one instance of this method runs at a time.
+     *
+     * @returns {Promise<void>}
+     */
+  }, {
+    key: "processSyncQueue",
+    value: (function () {
+      var _processSyncQueue = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
+        var _ref7, dataSetName, reason, isInitialization, dataSet;
+        return _regenerator.default.wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              if (!this.isSyncInProgress) {
+                _context8.next = 1;
+                break;
+              }
+              return _context8.abrupt("return");
+            case 1:
+              this.isSyncInProgress = true;
+              _context8.prev = 2;
+            case 3:
+              if (!(this.syncQueue.length > 0 && this.state !== 'stopped')) {
+                _context8.next = 6;
+                break;
+              }
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+              _ref7 = this.syncQueue.shift(), dataSetName = _ref7.dataSetName, reason = _ref7.reason, isInitialization = _ref7.isInitialization;
+              dataSet = this.dataSets[dataSetName];
+              if (dataSet !== null && dataSet !== void 0 && dataSet.hashTree) {
+                _context8.next = 4;
+                break;
+              }
+              return _context8.abrupt("continue", 3);
+            case 4:
+              _context8.next = 5;
+              return this.performSync(dataSet, reason, isInitialization);
+            case 5:
+              _context8.next = 3;
+              break;
+            case 6:
+              _context8.prev = 6;
+              this.isSyncInProgress = false;
+              return _context8.finish(6);
+            case 7:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee7, this, [[2,, 6, 7]]);
+      }));
+      function processSyncQueue() {
+        return _processSyncQueue.apply(this, arguments);
+      }
+      return processSyncQueue;
+    }()
+    /**
+     * Syncs all data sets that have hash trees, one by one in sequence, using the priority order
+     * provided by sortByInitPriority(). Does nothing if the parser is stopped or if a syncAllDatasets
+     * call is already in progress.
+     *
+     * @returns {Promise<void>}
+     */
+    )
+  }, {
+    key: "syncAllDatasets",
+    value: (function () {
+      var _syncAllDatasets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
+        var dataSetsWithHashTrees, sorted, _iterator9, _step9, ds;
+        return _regenerator.default.wrap(function (_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              if (!(this.state === 'stopped')) {
+                _context9.next = 1;
+                break;
+              }
+              return _context9.abrupt("return");
+            case 1:
+              if (!this.isSyncAllInProgress) {
+                _context9.next = 2;
+                break;
+              }
+              return _context9.abrupt("return");
+            case 2:
+              this.isSyncAllInProgress = true;
+              _context9.prev = 3;
+              dataSetsWithHashTrees = (0, _values.default)(this.dataSets).filter(function (dataSet) {
+                return dataSet === null || dataSet === void 0 ? void 0 : dataSet.hashTree;
+              }).map(function (dataSet) {
+                return {
+                  name: dataSet.name
+                };
+              });
+              sorted = (0, _utils.sortByInitPriority)(dataSetsWithHashTrees, _constants2.DATA_SET_INIT_PRIORITY);
+              _loggerProxy.default.logger.info("HashTreeParser#syncAllDatasets --> ".concat(this.debugId, " syncing datasets: ").concat(sorted.map(function (ds) {
+                return ds.name;
+              }).join(', ')));
+              _iterator9 = _createForOfIteratorHelper(sorted);
+              try {
+                for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+                  ds = _step9.value;
+                  this.enqueueSyncForDataset(ds.name, 'syncAllDatasets');
+                }
+              } catch (err) {
+                _iterator9.e(err);
+              } finally {
+                _iterator9.f();
+              }
+              _context9.next = 4;
+              return this.syncQueueProcessingPromise;
+            case 4:
+              _context9.prev = 4;
+              this.isSyncAllInProgress = false;
+              return _context9.finish(4);
+            case 5:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee8, this, [[3,, 4, 5]]);
+      }));
+      function syncAllDatasets() {
+        return _syncAllDatasets.apply(this, arguments);
+      }
+      return syncAllDatasets;
+    }()
     /**
      * Runs the sync algorithm for the given data set.
      *
@@ -1397,7 +1568,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "runSyncAlgorithm",
     value: function runSyncAlgorithm(receivedDataSet) {
-      var _this11 = this;
+      var _this10 = 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"));
@@ -1418,37 +1589,19 @@ var HashTreeParser = /*#__PURE__*/function () {
           clearTimeout(dataSet.timer);
         }
         _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 _callee6() {
-          var rootHash;
-          return _regenerator.default.wrap(function (_context7) {
-            while (1) switch (_context7.prev = _context7.next) {
-              case 0:
-                dataSet.timer = undefined;
-                if (dataSet.hashTree) {
-                  _context7.next = 1;
-                  break;
-                }
-                _loggerProxy.default.logger.warn("HashTreeParser#runSyncAlgorithm --> ".concat(_this11.debugId, " Data set \"").concat(dataSet.name, "\" no longer has a hash tree, cannot run sync algorithm"));
-                return _context7.abrupt("return");
-              case 1:
-                rootHash = dataSet.hashTree.getRootHash();
-                if (!(dataSet.root !== rootHash)) {
-                  _context7.next = 3;
-                  break;
-                }
-                _context7.next = 2;
-                return _this11.performSync(dataSet, rootHash, "Root hash mismatch: received=".concat(dataSet.root, ", ours=").concat(rootHash));
-              case 2:
-                _context7.next = 4;
-                break;
-              case 3:
-                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this11.debugId, " \"").concat(dataSet.name, "\" root hash matching: ").concat(rootHash, ", version=").concat(dataSet.version));
-              case 4:
-              case "end":
-                return _context7.stop();
-            }
-          }, _callee6);
-        })), delay);
+        dataSet.timer = setTimeout(function () {
+          dataSet.timer = undefined;
+          if (!dataSet.hashTree) {
+            _loggerProxy.default.logger.warn("HashTreeParser#runSyncAlgorithm --> ".concat(_this10.debugId, " Data set \"").concat(dataSet.name, "\" no longer has a hash tree, cannot run sync algorithm"));
+            return;
+          }
+          var rootHash = dataSet.hashTree.getRootHash();
+          if (dataSet.root !== rootHash) {
+            _this10.enqueueSyncForDataset(dataSet.name, "Root hash mismatch: received=".concat(dataSet.root, ", ours=").concat(rootHash));
+          } else {
+            _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this10.debugId, " \"").concat(dataSet.name, "\" root hash matching: ").concat(rootHash, ", version=").concat(dataSet.version));
+          }
+        }, delay);
       } else {
         _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " No delay for \"").concat(dataSet.name, "\" data set, skipping sync timer reset/setup"));
       }
@@ -1466,16 +1619,16 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "resetHeartbeatWatchdogs",
     value: function resetHeartbeatWatchdogs(receivedDataSets) {
-      var _this12 = this;
+      var _this11 = this;
       if (!this.heartbeatIntervalMs) {
         return;
       }
-      var _iterator9 = _createForOfIteratorHelper(receivedDataSets),
-        _step9;
+      var _iterator0 = _createForOfIteratorHelper(receivedDataSets),
+        _step0;
       try {
         var _loop2 = function _loop2() {
-          var receivedDataSet = _step9.value;
-          var dataSet = _this12.dataSets[receivedDataSet.name];
+          var receivedDataSet = _step0.value;
+          var dataSet = _this11.dataSets[receivedDataSet.name];
           if (!(dataSet !== null && dataSet !== void 0 && dataSet.hashTree)) {
             // eslint-disable-next-line no-continue
             return 1; // continue
@@ -1484,30 +1637,21 @@ var HashTreeParser = /*#__PURE__*/function () {
             clearTimeout(dataSet.heartbeatWatchdogTimer);
             dataSet.heartbeatWatchdogTimer = undefined;
           }
-          var backoffTime = _this12.getWeightedBackoffTime(dataSet.backoff);
-          var delay = _this12.heartbeatIntervalMs + backoffTime;
-          dataSet.heartbeatWatchdogTimer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
-            return _regenerator.default.wrap(function (_context8) {
-              while (1) switch (_context8.prev = _context8.next) {
-                case 0:
-                  dataSet.heartbeatWatchdogTimer = undefined;
-                  _loggerProxy.default.logger.warn("HashTreeParser#resetHeartbeatWatchdogs --> ".concat(_this12.debugId, " Heartbeat watchdog fired for data set \"").concat(dataSet.name, "\" - no heartbeat received within expected interval, initiating sync"));
-                  _context8.next = 1;
-                  return _this12.performSync(dataSet, dataSet.hashTree.getRootHash(), "heartbeat watchdog expired");
-                case 1:
-                case "end":
-                  return _context8.stop();
-              }
-            }, _callee7);
-          })), delay);
+          var backoffTime = _this11.getWeightedBackoffTime(dataSet.backoff);
+          var delay = _this11.heartbeatIntervalMs + backoffTime;
+          dataSet.heartbeatWatchdogTimer = setTimeout(function () {
+            dataSet.heartbeatWatchdogTimer = undefined;
+            _loggerProxy.default.logger.warn("HashTreeParser#resetHeartbeatWatchdogs --> ".concat(_this11.debugId, " Heartbeat watchdog fired for data set \"").concat(dataSet.name, "\" - no heartbeat received within expected interval, initiating sync"));
+            _this11.enqueueSyncForDataset(dataSet.name, "heartbeat watchdog expired");
+          }, delay);
         };
-        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
           if (_loop2()) continue;
         }
       } catch (err) {
-        _iterator9.e(err);
+        _iterator0.e(err);
       } finally {
-        _iterator9.f();
+        _iterator0.f();
       }
     }
 
@@ -1541,6 +1685,7 @@ var HashTreeParser = /*#__PURE__*/function () {
     value: function stop() {
       _loggerProxy.default.logger.info("HashTreeParser#stop --> ".concat(this.debugId, " Stopping HashTreeParser, clearing timers and hash trees"));
       this.stopAllTimers();
+      this.syncQueue = [];
       (0, _values.default)(this.dataSets).forEach(function (dataSet) {
         dataSet.hashTree = undefined;
       });
@@ -1549,29 +1694,41 @@ var HashTreeParser = /*#__PURE__*/function () {
     }
 
     /**
-     * Resumes the HashTreeParser that was previously stopped.
+     * Cleans up the HashTreeParser, stopping all timers and clearing all internal state.
+     * After calling this, the parser should not be used anymore.
+     * @returns {void}
+     */
+  }, {
+    key: "cleanUp",
+    value: function cleanUp() {
+      this.stop();
+      this.dataSets = {};
+    }
+
+    /**
+     * Resumes the HashTreeParser that was previously stopped, using a hash tree message.
      * @param {HashTreeMessage} message - The message to resume with, it must contain metadata with visible data sets info
      * @returns {void}
      */
   }, {
-    key: "resume",
-    value: function resume(message) {
-      var _message$locusStateEl3, _metadataObject$data;
+    key: "resumeFromMessage",
+    value: function resumeFromMessage(message) {
+      var _message$locusStateEl2, _metadataObject$data;
       // check that message contains metadata with visible data sets - this is essential to be able to resume
-      var metadataObject = (_message$locusStateEl3 = message.locusStateElements) === null || _message$locusStateEl3 === void 0 ? void 0 : _message$locusStateEl3.find(function (el) {
+      var metadataObject = (_message$locusStateEl2 = message.locusStateElements) === null || _message$locusStateEl2 === void 0 ? void 0 : _message$locusStateEl2.find(function (el) {
         return (0, _utils.isMetadata)(el);
       });
       if (!(metadataObject !== null && metadataObject !== void 0 && (_metadataObject$data = metadataObject.data) !== null && _metadataObject$data !== void 0 && _metadataObject$data.visibleDataSets)) {
-        _loggerProxy.default.logger.warn("HashTreeParser#resume --> ".concat(this.debugId, " Cannot resume HashTreeParser because the message is missing metadata with visible data sets info"));
+        _loggerProxy.default.logger.warn("HashTreeParser#resumeFromMessage --> ".concat(this.debugId, " Cannot resume HashTreeParser because the message is missing metadata with visible data sets info"));
         return;
       }
       this.setVisibleDataSets(metadataObject.data.visibleDataSets, message.dataSets);
       this.dataSets = {};
-      var _iterator0 = _createForOfIteratorHelper(message.dataSets),
-        _step0;
+      var _iterator1 = _createForOfIteratorHelper(message.dataSets),
+        _step1;
       try {
-        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
-          var dataSet = _step0.value;
+        for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+          var dataSet = _step1.value;
           var name = dataSet.name,
             leafCount = dataSet.leafCount;
           this.dataSets[name] = _objectSpread(_objectSpread({}, dataSet), {}, {
@@ -1579,16 +1736,47 @@ var HashTreeParser = /*#__PURE__*/function () {
           });
         }
       } catch (err) {
-        _iterator0.e(err);
+        _iterator1.e(err);
       } finally {
-        _iterator0.f();
+        _iterator1.f();
       }
-      _loggerProxy.default.logger.info("HashTreeParser#resume --> ".concat(this.debugId, " Resuming HashTreeParser with data sets: ").concat((0, _keys.default)(this.dataSets).join(', '), ", visible data sets: ").concat(this.visibleDataSets.map(function (ds) {
+      _loggerProxy.default.logger.info("HashTreeParser#resumeFromMessage --> ".concat(this.debugId, " Resuming HashTreeParser with data sets: ").concat((0, _keys.default)(this.dataSets).join(', '), ", visible data sets: ").concat(this.visibleDataSets.map(function (ds) {
         return ds.name;
       }).join(', ')));
       this.state = 'active';
       this.handleMessage(message, 'on resume');
     }
+
+    /**
+     * Resumes the HashTreeParser that was previously stopped, using a Locus API response.
+     * Unlike resumeFromMessage(), this does not require metadata/dataSets in the input,
+     * as it fetches all necessary information from Locus via initializeFromGetLociResponse.
+     * @param {LocusDTO} locus - locus object from an API response
+     * @returns {Promise}
+     */
+  }, {
+    key: "resumeFromApiResponse",
+    value: (function () {
+      var _resumeFromApiResponse = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9(locus) {
+        return _regenerator.default.wrap(function (_context0) {
+          while (1) switch (_context0.prev = _context0.next) {
+            case 0:
+              this.state = 'active';
+              this.dataSets = {};
+              _loggerProxy.default.logger.info("HashTreeParser#resumeFromApiResponse --> ".concat(this.debugId, " Resuming HashTreeParser from API response"));
+              _context0.next = 1;
+              return this.initializeFromGetLociResponse(locus);
+            case 1:
+            case "end":
+              return _context0.stop();
+          }
+        }, _callee9, this);
+      }));
+      function resumeFromApiResponse(_x1) {
+        return _resumeFromApiResponse.apply(this, arguments);
+      }
+      return resumeFromApiResponse;
+    }())
   }, {
     key: "checkForSentinelHttpResponse",
     value: function checkForSentinelHttpResponse(error, dataSetName) {
@@ -1605,12 +1793,12 @@ var HashTreeParser = /*#__PURE__*/function () {
      * Gets the current hashes from the locus for a specific data set.
      * @param {string} dataSetName
      * @param {string} currentRootHash
-     * @returns {string[]}
+     * @returns {Object|null} An object containing the hashes and leaf count, or null if the hashes match and no sync is needed
      */
   }, {
     key: "getHashesFromLocus",
     value: function getHashesFromLocus(dataSetName, currentRootHash) {
-      var _this13 = this;
+      var _this12 = 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");
@@ -1622,20 +1810,25 @@ var HashTreeParser = /*#__PURE__*/function () {
         }
       }).then(function (response) {
         var _response$body, _response$body2;
+        if (!response.body || (0, _lodash.isEmpty)(response.body)) {
+          // 204 with empty body means our hashes match Locus, no sync needed
+          _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this12.debugId, " Got ").concat(response.statusCode, " with empty body for data set \"").concat(dataSetName, "\", hashes match - no sync needed"));
+          return null;
+        }
         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(_this13.debugId, " Locus returned invalid hashes, response body="), response.body);
+          _loggerProxy.default.logger.warn("HashTreeParser#getHashesFromLocus --> ".concat(_this12.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(_this13.debugId, " Received hashes for data set \"").concat(dataSetName, "\": ").concat((0, _stringify.default)(hashes)));
+        _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this12.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(_this13.debugId, " Error ").concat(error.statusCode, " fetching hashes for data set \"").concat(dataSetName, "\":"), error);
-        _this13.checkForSentinelHttpResponse(error, dataSet.name);
+        _loggerProxy.default.logger.error("HashTreeParser#getHashesFromLocus --> ".concat(_this12.debugId, " Error ").concat(error.statusCode, " fetching hashes for data set \"").concat(dataSetName, "\":"), error);
+        _this12.checkForSentinelHttpResponse(error, dataSet.name);
         throw error;
       });
     }
@@ -1644,25 +1837,36 @@ var HashTreeParser = /*#__PURE__*/function () {
      * Sends a sync request to Locus for the specified data set.
      *
      * @param {InternalDataSet} dataSet The data set to sync.
-     * @param {Record<number, LeafDataItem[]>} mismatchedLeavesData The mismatched leaves data to include in the sync request.
+     * @param {Object} options Either `{ isInitialization: true }` for init syncs (uses leafCount=1 with empty leaf data) or `{ mismatchedLeavesData }` for normal syncs.
      * @returns {Promise<HashTreeMessage|null>}
      */
   }, {
     key: "sendSyncRequestToLocus",
-    value: function sendSyncRequestToLocus(dataSet, mismatchedLeavesData) {
-      var _this14 = this;
+    value: function sendSyncRequestToLocus(dataSet, options) {
+      var _this13 = this;
       _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(this.debugId, " Sending sync request for data set \"").concat(dataSet.name, "\""));
+      var isInitialization = 'isInitialization' in options;
       var url = "".concat(dataSet.url, "/sync");
       var body = {
-        leafCount: dataSet.leafCount,
+        leafCount: isInitialization ? 1 : dataSet.leafCount,
         leafDataEntries: []
       };
-      (0, _keys.default)(mismatchedLeavesData).forEach(function (index) {
+      if (isInitialization) {
+        // initialization sync: Locus requires leafCount=1 with a single empty leaf
         body.leafDataEntries.push({
-          leafIndex: (0, _parseInt2.default)(index, 10),
-          elementIds: mismatchedLeavesData[index]
+          leafIndex: 0,
+          elementIds: []
         });
-      });
+      } else {
+        var mismatchedLeavesData = options.mismatchedLeavesData;
+        (0, _keys.default)(mismatchedLeavesData).forEach(function (index) {
+          var leafIndex = (0, _parseInt2.default)(index, 10);
+          body.leafDataEntries.push({
+            leafIndex: leafIndex,
+            elementIds: mismatchedLeavesData[leafIndex]
+          });
+        });
+      }
       var ourCurrentRootHash = dataSet.hashTree ? dataSet.hashTree.getRootHash() : _constants2.EMPTY_HASH;
       return this.webexRequest({
         method: _constants.HTTP_VERBS.POST,
@@ -1672,15 +1876,15 @@ var HashTreeParser = /*#__PURE__*/function () {
         },
         body: body
       }).then(function (resp) {
-        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this14.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
+        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this13.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
         if (!resp.body || (0, _lodash.isEmpty)(resp.body)) {
-          _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this14.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(_this13.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(_this14.debugId, " Error ").concat(error.statusCode, " sending sync request for data set \"").concat(dataSet.name, "\":"), error);
-        _this14.checkForSentinelHttpResponse(error, dataSet.name);
+        _loggerProxy.default.logger.error("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this13.debugId, " Error ").concat(error.statusCode, " sending sync request for data set \"").concat(dataSet.name, "\":"), error);
+        _this13.checkForSentinelHttpResponse(error, dataSet.name);
         throw error;
       });
     }