@webex/plugin-meetings 3.12.0-next.7 → 3.12.0-next.70

package/dist/hashTree/hashTreeParser.js

@@ -15,17 +15,18 @@ var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequ
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.MeetingEndedError = exports.LocusInfoUpdateType = void 0;
+exports.default = exports.SyncAllBackoffType = exports.MeetingEndedError = exports.LocusNotFoundError = exports.LocusInfoUpdateType = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
-var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+var _set = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/set"));
 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"));
@@ -37,9 +38,12 @@ var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime-corejs2/h
 var _lodash = require("lodash");
 var _hashTree = _interopRequireDefault(require("./hashTree"));
 var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
-var _constants = require("../constants");
-var _constants2 = require("./constants");
+var _metrics = _interopRequireDefault(require("../metrics"));
+var _constants = _interopRequireDefault(require("../metrics/constants"));
+var _constants2 = require("../constants");
+var _constants3 = require("./constants");
 var _types = require("./types");
+var _types2 = require("../locus-info/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; }
@@ -48,9 +52,16 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var SyncAllBackoffType = exports.SyncAllBackoffType = /*#__PURE__*/function (SyncAllBackoffType) {
+  SyncAllBackoffType["NONE"] = "none";
+  SyncAllBackoffType["ONLY_LLM"] = "onlyLLM";
+  SyncAllBackoffType["ALL"] = "all";
+  return SyncAllBackoffType;
+}({});
 var LocusInfoUpdateType = exports.LocusInfoUpdateType = {
   OBJECTS_UPDATED: 'OBJECTS_UPDATED',
-  MEETING_ENDED: 'MEETING_ENDED'
+  MEETING_ENDED: 'MEETING_ENDED',
+  LOCUS_NOT_FOUND: 'LOCUS_NOT_FOUND'
 };
 /**
  * This error is thrown if we receive information that the meeting has ended while we're processing some hash messages.
@@ -64,11 +75,24 @@ var MeetingEndedError = exports.MeetingEndedError = /*#__PURE__*/function (_Erro
   (0, _inherits2.default)(MeetingEndedError, _Error);
   return (0, _createClass2.default)(MeetingEndedError);
 }(/*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+/**
+ * This error is thrown when a 404 is received from Locus hash tree endpoints, indicating that the locus URL
+ * is no longer valid (e.g. participant moved to a breakout room, or meeting ended).
+ * It's handled internally by HashTreeParser and results in LOCUS_NOT_FOUND being sent up.
+ */
+var LocusNotFoundError = exports.LocusNotFoundError = /*#__PURE__*/function (_Error2) {
+  function LocusNotFoundError() {
+    (0, _classCallCheck2.default)(this, LocusNotFoundError);
+    return _callSuper(this, LocusNotFoundError, arguments);
+  }
+  (0, _inherits2.default)(LocusNotFoundError, _Error2);
+  return (0, _createClass2.default)(LocusNotFoundError);
+}(/*#__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;
-var PossibleSentinelMessageDataSetNames = [_constants2.DataSetNames.MAIN, _constants2.DataSetNames.SELF, _constants2.DataSetNames.UNJOINED];
+var MetadataDataSetName = _constants3.DataSetNames.SELF;
+var PossibleSentinelMessageDataSetNames = [_constants3.DataSetNames.MAIN, _constants3.DataSetNames.SELF, _constants3.DataSetNames.UNJOINED];
 
 /**
  * Parses hash tree eventing locus data
@@ -89,9 +113,17 @@ var HashTreeParser = /*#__PURE__*/function () {
     (0, _defineProperty2.default)(this, "locusInfoUpdateCallback", void 0);
     (0, _defineProperty2.default)(this, "visibleDataSets", void 0);
     (0, _defineProperty2.default)(this, "debugId", void 0);
-    (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);
+    // tracks whether syncAllDatasets is currently in its backoff delay phase and with what scope
+    (0, _defineProperty2.default)(this, "syncAllBackoffType", SyncAllBackoffType.NONE);
+    // datasets that received messages during the syncAllDatasets backoff sleep and should be skipped
+    (0, _defineProperty2.default)(this, "dataSetsSyncedDuringBackoff", new _set.default());
+    (0, _defineProperty2.default)(this, "syncQueueProcessingPromise", _promise.default.resolve());
+    // top-level heartbeat interval from the most recent message, used as fallback when dataset-level value is missing
+    (0, _defineProperty2.default)(this, "topLevelHeartbeatIntervalMs", void 0);
     var _options$initialLocus = options.initialLocus,
       dataSets = _options$initialLocus.dataSets,
       locus = _options$initialLocus.locus; // extract dataSets from initialLocus
@@ -212,80 +244,65 @@ 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([]);
       }
       return this.webexRequest({
-        method: _constants.HTTP_VERBS.GET,
+        method: _constants2.HTTP_VERBS.GET,
         uri: this.visibleDataSetsUrl
       }).then(function (response) {
         return response.body.dataSets;
       }).catch(function (error) {
-        _this3.checkForSentinelHttpResponse(error);
+        _this2.checkForSentinelHttpResponse(error);
         throw error;
       });
     }
@@ -299,26 +316,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;
@@ -336,34 +353,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;
@@ -379,24 +396,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, _constants3.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;
@@ -408,59 +424,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;
@@ -596,9 +600,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 === _constants3.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;
         }
@@ -615,7 +619,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,
@@ -629,12 +633,40 @@ var HashTreeParser = /*#__PURE__*/function () {
           version: version
         };
       }))));
+      this.cancelPendingSyncsForDataSets(dataSets.map(function (ds) {
+        return ds.name;
+      }));
       dataSets.forEach(function (dataSet) {
-        _this5.updateDataSetInfo(dataSet);
-        _this5.runSyncAlgorithm(dataSet);
+        _this4.updateDataSetInfo(dataSet);
+        _this4.runSyncAlgorithm(dataSet);
       });
     }
 
+    /**
+     * Handles known errors that can happen during syncs
+     *
+     * @param {any} error - The error to handle
+     * @returns {boolean} true if the error was recognized and handled, false otherwise
+     */
+  }, {
+    key: "handleSyncErrors",
+    value: function handleSyncErrors(error) {
+      if (error instanceof MeetingEndedError) {
+        this.callLocusInfoUpdateCallback({
+          updateType: LocusInfoUpdateType.MEETING_ENDED
+        });
+        return true;
+      }
+      if (error instanceof LocusNotFoundError) {
+        this.callLocusInfoUpdateCallback({
+          updateType: LocusInfoUpdateType.LOCUS_NOT_FOUND
+        });
+        this.stop();
+        return true;
+      }
+      return false;
+    }
+
     /**
      * Asynchronously initializes new visible data sets
      *
@@ -644,18 +676,14 @@ 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) {
-          if (error instanceof MeetingEndedError) {
-            _this6.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) {
+        _this5.initializeNewVisibleDataSets(dataSetsRequiringInitialization).catch(function (error) {
+          if (!_this5.handleSyncErrors(error)) {
+            _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);
           }
@@ -715,14 +743,18 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "handleLocusUpdate",
     value: function handleLocusUpdate(update) {
-      var _this7 = this;
+      var _this6 = this;
       if (this.state === 'stopped') {
         return;
       }
       var dataSets = update.dataSets,
         locus = update.locus,
         metadata = update.metadata;
+      _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received update with dataSets=").concat(dataSets === null || dataSets === void 0 ? void 0 : dataSets.map(function (ds) {
+        return ds.name;
+      }).join(','), " metadata=").concat(metadata ? 'yes' : 'no'));
       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),
@@ -752,9 +784,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,
@@ -781,10 +813,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) {
@@ -820,10 +852,26 @@ var HashTreeParser = /*#__PURE__*/function () {
           maxMs: receivedDataSet.backoff.maxMs,
           exponent: receivedDataSet.backoff.exponent
         };
+        this.dataSets[receivedDataSet.name].heartbeatIntervalMs = receivedDataSet.heartbeatIntervalMs;
         _loggerProxy.default.logger.info("HashTreeParser#updateDataSetInfo --> ".concat(this.debugId, " updated \"").concat(receivedDataSet.name, "\" dataset to version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
       }
     }
 
+    /**
+     * Updates the leaf count for a data set, resizing its hash tree accordingly.
+     *
+     * @param {InternalDataSet} dataSet - The data set to update
+     * @param {number} newLeafCount - The new leaf count
+     * @returns {void}
+     */
+  }, {
+    key: "updateDataSetLeafCount",
+    value: function updateDataSetLeafCount(dataSet, newLeafCount) {
+      var _dataSet$hashTree;
+      (_dataSet$hashTree = dataSet.hashTree) === null || _dataSet$hashTree === void 0 ? void 0 : _dataSet$hashTree.resize(newLeafCount);
+      dataSet.leafCount = newLeafCount;
+    }
+
     /**
      * Checks for changes in the visible data sets based on the updated objects.
      * @param {HashTreeObject[]} updatedObjects - The list of updated hash tree objects.
@@ -832,7 +880,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "checkForVisibleDataSetChanges",
     value: function checkForVisibleDataSetChanges(updatedObjects) {
-      var _this8 = this;
+      var _this7 = this;
       var removedDataSets = [];
       var addedDataSets = [];
 
@@ -841,20 +889,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;
@@ -878,7 +926,10 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "deleteHashTree",
     value: function deleteHashTree(dataSetName) {
+      var _this$dataSets$dataSe;
       this.dataSets[dataSetName].hashTree = undefined;
+      (_this$dataSets$dataSe = this.dataSets[dataSetName].syncAbortController) === null || _this$dataSets$dataSe === void 0 ? void 0 : _this$dataSets$dataSe.abort();
+      this.dataSets[dataSetName].syncAbortController = undefined;
 
       // we also need to stop the timers as there is no hash tree anymore to sync
       if (this.dataSets[dataSetName].timer) {
@@ -908,16 +959,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,
@@ -927,7 +978,7 @@ var HashTreeParser = /*#__PURE__*/function () {
               };
             })));
           }
-          _this9.deleteHashTree(ds.name);
+          _this8.deleteHashTree(ds.name);
         }
       });
       this.visibleDataSets = this.visibleDataSets.filter(function (vds) {
@@ -988,81 +1039,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, _constants3.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;
@@ -1078,25 +1126,37 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "parseMessage",
     value: function parseMessage(message, debugText) {
-      var _message$locusStateEl,
-        _this1 = this,
-        _message$locusStateEl2;
+      var _message$dataSets,
+        _message$locusStateEl,
+        _message$locusStateEl2,
+        _this0 = this;
       if (this.state === 'stopped') {
         return [];
       }
       var dataSets = message.dataSets,
         visibleDataSetsUrl = message.visibleDataSetsUrl;
-      _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " received message ").concat(debugText || '', ":"), message);
-      if (((_message$locusStateEl = message.locusStateElements) === null || _message$locusStateEl === void 0 ? void 0 : _message$locusStateEl.length) === 0) {
+      _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " ").concat(debugText || '', " dataSets: ").concat((_message$dataSets = message.dataSets) === null || _message$dataSets === void 0 ? void 0 : _message$dataSets.map(function (_ref5) {
+        var name = _ref5.name,
+          version = _ref5.version;
+        return "".concat(name, ":").concat(version);
+      }).join(','), ", elements: ").concat((_message$locusStateEl = message.locusStateElements) === null || _message$locusStateEl === void 0 ? void 0 : _message$locusStateEl.map(function (el) {
+        return "".concat(el.htMeta.elementId.type, ":").concat(el.htMeta.elementId.id, ":").concat(el.htMeta.elementId.version).concat(el.data ? '+' : '-');
+      }).join(',')));
+      if (((_message$locusStateEl2 = message.locusStateElements) === null || _message$locusStateEl2 === void 0 ? void 0 : _message$locusStateEl2.length) === 0) {
         _loggerProxy.default.logger.warn("HashTreeParser#parseMessage --> ".concat(this.debugId, " got empty locusStateElements!!!"));
-        // todo: send a metric
+        _metrics.default.sendBehavioralMetric(_constants.default.HASH_TREE_EMPTY_LOCUS_STATE_ELEMENTS, {
+          debugId: this.debugId
+        });
       }
 
       // 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);
       });
+      this.cancelPendingSyncsForDataSets(dataSets.map(function (ds) {
+        return ds.name;
+      }));
       var updatedObjects = [];
 
       // when we detect new visible datasets, it may be that the metadata about them is not
@@ -1115,9 +1175,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);
@@ -1139,13 +1199,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);
@@ -1159,20 +1219,20 @@ var HashTreeParser = /*#__PURE__*/function () {
                   item: object.htMeta.elementId
                 };
               }));
-              (0, _lodash.zip)(appliedChangesList, locusStateElementsForThisSet).forEach(function (_ref5) {
-                var _ref6 = (0, _slicedToArray2.default)(_ref5, 2),
-                  changeApplied = _ref6[0],
-                  object = _ref6[1];
+              (0, _lodash.zip)(appliedChangesList, locusStateElementsForThisSet).forEach(function (_ref6) {
+                var _ref7 = (0, _slicedToArray2.default)(_ref6, 2),
+                  changeApplied = _ref7[0],
+                  object = _ref7[1];
                 if (changeApplied) {
                   // add to updatedObjects so that our locus DTO will get updated with the new object
                   updatedObjects.push(object);
                 }
               });
             } 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) {
@@ -1198,8 +1258,8 @@ var HashTreeParser = /*#__PURE__*/function () {
       if (this.state === 'stopped') {
         return;
       }
-      if (message.heartbeatIntervalMs) {
-        this.heartbeatIntervalMs = message.heartbeatIntervalMs;
+      if (message.heartbeatIntervalMs !== undefined) {
+        this.topLevelHeartbeatIntervalMs = message.heartbeatIntervalMs;
       }
       if (this.isEndMessage(message)) {
         _loggerProxy.default.logger.info("HashTreeParser#handleMessage --> ".concat(this.debugId, " received sentinel END MEETING message"));
@@ -1229,25 +1289,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) {
@@ -1256,12 +1316,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;
                 }
               }
@@ -1270,13 +1330,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
         });
       }
     }
@@ -1300,164 +1361,517 @@ 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 _dataSet$syncAbortCon;
+        var abortController, 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;
+              abortController = (_dataSet$syncAbortCon = dataSet.syncAbortController) !== null && _dataSet$syncAbortCon !== void 0 ? _dataSet$syncAbortCon : new AbortController();
+              dataSet.syncAbortController = abortController;
+              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;
+              this.updateDataSetLeafCount(dataSet, 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:
+              if (!abortController.signal.aborted) {
+                _context7.next = 11;
                 break;
               }
-              _context6.next = 9;
-              return this.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
-            case 9:
-              syncResponse = _context6.sent;
+              _loggerProxy.default.logger.info("HashTreeParser#performSync --> ".concat(this.debugId, " abandoning sync for \"").concat(dataSet.name, "\" before /sync - message received during sync"));
+              return _context7.abrupt("return");
+            case 11:
+              // request sync for mismatched leaves
+              syncResponse = null;
+              if (!isInitialization) {
+                _context7.next = 13;
+                break;
+              }
+              _context7.next = 12;
+              return this.sendSyncRequestToLocus(dataSet, {
+                isInitialization: true
+              });
+            case 12:
+              syncResponse = _context7.sent;
+              _context7.next = 15;
+              break;
+            case 13:
+              if (!((0, _keys.default)(leavesData).length > 0)) {
+                _context7.next = 15;
+                break;
+              }
+              _context7.next = 14;
+              return this.sendSyncRequestToLocus(dataSet, {
+                mismatchedLeavesData: leavesData
+              });
+            case 14:
+              syncResponse = _context7.sent;
+            case 15:
               // 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
+              // We still need to restart the sync timer as a safety net in case the messages don't arrive.
+              this.runSyncAlgorithm(dataSet);
               if (syncResponse) {
-                this.handleMessage(syncResponse, 'via sync API');
+                // clear the abort controller before processing the response so that
+                // parseMessage() -> cancelPendingSyncsForDataSets() doesn't log a
+                // misleading "aborting sync" message for this already-completed sync
+                dataSet.syncAbortController = undefined;
+
+                // the format of sync response is the same as messages, so we can reuse the same handler
+                this.handleMessage(syncResponse, "via sync API (".concat(isInitialization ? 'init' : "".concat((0, _keys.default)(leavesData).length, " mismatched leaves"), ")"));
               }
-            case 10:
-              _context6.next = 12;
+              _context7.next = 17;
               break;
-            case 11:
-              _context6.prev = 11;
-              _t4 = _context6["catch"](1);
-              if (_t4 instanceof MeetingEndedError) {
-                this.callLocusInfoUpdateCallback({
-                  updateType: LocusInfoUpdateType.MEETING_ENDED
-                });
-              } else {
+            case 16:
+              _context7.prev = 16;
+              _t4 = _context7["catch"](2);
+              if (!this.handleSyncErrors(_t4)) {
                 _loggerProxy.default.logger.warn("HashTreeParser#performSync --> ".concat(this.debugId, " error during sync for data set \"").concat(dataSet.name, "\":"), _t4);
               }
-            case 12:
+            case 17:
+              _context7.prev = 17;
+              dataSet.syncAbortController = undefined;
+              return _context7.finish(17);
+            case 18:
             case "end":
-              return _context6.stop();
+              return _context7.stop();
           }
-        }, _callee5, this, [[1, 11], [2, 4]]);
+        }, _callee6, this, [[2, 16, 17, 18], [3, 6]]);
       }));
-      function performSync(_x6, _x7, _x8) {
+      function performSync(_x8, _x9, _x0) {
         return _performSync.apply(this, arguments);
       }
       return performSync;
     }()
+    /**
+     * Cancels any pending or in-flight syncs for the specified data sets.
+     * This removes matching entries from the sync queue and aborts any in-flight sync HTTP requests.
+     *
+     * @param {string[]} dataSetNames - The names of the data sets to cancel syncs for
+     * @returns {void}
+     */
+    )
+  }, {
+    key: "cancelPendingSyncsForDataSets",
+    value: function cancelPendingSyncsForDataSets(dataSetNames) {
+      var previousLength = this.syncQueue.length;
+      this.syncQueue = this.syncQueue.filter(function (entry) {
+        return !dataSetNames.includes(entry.dataSetName);
+      });
+      if (previousLength !== this.syncQueue.length) {
+        _loggerProxy.default.logger.info("HashTreeParser#cancelPendingSyncsForDataSets --> ".concat(this.debugId, " removed ").concat(previousLength - this.syncQueue.length, " entries from sync queue for data sets: ").concat(dataSetNames.join(', ')));
+      }
+      this.markDataSetsForSyncAllBackoffSkip(dataSetNames);
+      this.abortInFlightSyncs(dataSetNames);
+    }
+
+    /**
+     * If a syncAllDatasets backoff sleep is in progress, marks the given data sets to be skipped
+     * after the sleep completes.
+     *
+     * @param {string[]} dataSetNames - The names of the data sets to mark
+     * @returns {void}
+     */
+  }, {
+    key: "markDataSetsForSyncAllBackoffSkip",
+    value: function markDataSetsForSyncAllBackoffSkip(dataSetNames) {
+      if (this.syncAllBackoffType !== SyncAllBackoffType.NONE) {
+        var _iterator9 = _createForOfIteratorHelper(dataSetNames),
+          _step9;
+        try {
+          for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+            var name = _step9.value;
+            this.dataSetsSyncedDuringBackoff.add(name);
+          }
+        } catch (err) {
+          _iterator9.e(err);
+        } finally {
+          _iterator9.f();
+        }
+      }
+    }
+
+    /**
+     * Aborts any in-flight sync HTTP requests for the specified data sets.
+     *
+     * @param {string[]} dataSetNames - The names of the data sets whose syncs should be aborted
+     * @returns {void}
+     */
+  }, {
+    key: "abortInFlightSyncs",
+    value: function abortInFlightSyncs(dataSetNames) {
+      var _iterator0 = _createForOfIteratorHelper(dataSetNames),
+        _step0;
+      try {
+        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+          var _this$dataSets$name;
+          var name = _step0.value;
+          if ((_this$dataSets$name = this.dataSets[name]) !== null && _this$dataSets$name !== void 0 && _this$dataSets$name.syncAbortController) {
+            _loggerProxy.default.logger.info("HashTreeParser#cancelPendingSyncsForDataSets --> ".concat(this.debugId, " aborting in-flight sync for data set \"").concat(name, "\""));
+            this.dataSets[name].syncAbortController.abort();
+          }
+        }
+      } catch (err) {
+        _iterator0.e(err);
+      } finally {
+        _iterator0.f();
+      }
+    }
+
+    /**
+     * 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 _ref8, 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
+              _ref8 = this.syncQueue.shift(), dataSetName = _ref8.dataSetName, reason = _ref8.reason, isInitialization = _ref8.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;
+    }()
+    /**
+     * sets the backoff type for syncAllDatasets calls, which determines the scope of datasets that will be synced after the backoff delay.
+     *
+     * @param {boolean} onlyLLM - Whether the backoff is for a syncAllDatasets call that is syncing only LLM datasets
+     * @returns {void}
+     */
+    )
+  }, {
+    key: "setSyncAllBackoffType",
+    value: function setSyncAllBackoffType(onlyLLM) {
+      this.syncAllBackoffType = onlyLLM ? SyncAllBackoffType.ONLY_LLM : SyncAllBackoffType.ALL;
+    }
+
+    /**
+     * Checks if a syncAll backoff is already in progress. If so, upgrades the scope from
+     * onlyLLM to all datasets when the new call has a broader scope.
+     *
+     * @param {boolean} onlyLLM - Whether the current call is for LLM datasets only
+     * @returns {boolean} true if a backoff is already pending (caller should return early)
+     */
+  }, {
+    key: "tryUpgradePendingBackoff",
+    value: function tryUpgradePendingBackoff(onlyLLM) {
+      if (this.syncAllBackoffType !== SyncAllBackoffType.NONE) {
+        if (!onlyLLM && this.syncAllBackoffType === SyncAllBackoffType.ONLY_LLM) {
+          this.setSyncAllBackoffType(false);
+          _loggerProxy.default.logger.info("HashTreeParser#syncAllDatasets --> ".concat(this.debugId, " upgraded pending syncAll from onlyLLM to all datasets"));
+        }
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Syncs all data sets that have hash trees, one by one in sequence, using the priority order
+     * provided by sortByInitPriority().
+     *
+     * If a call is already waiting in the backoff delay phase, a new call with a broader scope
+     * (onlyLLM=false) will upgrade the pending scope, and the dataset list will be computed after
+     * the backoff using the upgraded scope. After the backoff, the sync queue handles deduplication
+     * so no guard is needed.
+     *
+     * @param {Object} [options={}] - Options for syncing
+     * @param {boolean} [options.onlyLLM=false] - Whether to sync only LLM based data sets
+     * @returns {Promise<void>}
+     */
+  }, {
+    key: "syncAllDatasets",
+    value: (function () {
+      var _syncAllDatasets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
+        var options,
+          _options$onlyLLM,
+          onlyLLM,
+          dataSetsToSync,
+          delay,
+          effectiveBackoffType,
+          skippedDataSets,
+          effectiveDataSetsToSync,
+          _iterator1,
+          _step1,
+          ds,
+          _args9 = arguments;
+        return _regenerator.default.wrap(function (_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              options = _args9.length > 0 && _args9[0] !== undefined ? _args9[0] : {};
+              _options$onlyLLM = options.onlyLLM, onlyLLM = _options$onlyLLM === void 0 ? false : _options$onlyLLM;
+              if (!(this.state === 'stopped')) {
+                _context9.next = 1;
+                break;
+              }
+              return _context9.abrupt("return");
+            case 1:
+              if (!this.tryUpgradePendingBackoff(onlyLLM)) {
+                _context9.next = 2;
+                break;
+              }
+              return _context9.abrupt("return");
+            case 2:
+              dataSetsToSync = this.getSortedDataSetsWithHashTrees(onlyLLM);
+              if (!(dataSetsToSync.length === 0)) {
+                _context9.next = 3;
+                break;
+              }
+              return _context9.abrupt("return");
+            case 3:
+              this.setSyncAllBackoffType(onlyLLM);
+              delay = this.getWeightedBackoffTime(dataSetsToSync[0].backoff);
+              _loggerProxy.default.logger.info("HashTreeParser#syncAllDatasets --> ".concat(this.debugId, " starting backoff delay of ").concat(delay, "ms (onlyLLM=").concat(onlyLLM, ")"));
+
+              // delay the start of the syncs - this is a Locus requirement to avoid thundering herd issues
+              _context9.next = 4;
+              return (0, _utils.sleep)(delay);
+            case 4:
+              // read the (possibly upgraded) scope and clear the backoff flag
+              effectiveBackoffType = this.syncAllBackoffType;
+              skippedDataSets = this.dataSetsSyncedDuringBackoff;
+              this.syncAllBackoffType = SyncAllBackoffType.NONE;
+              this.dataSetsSyncedDuringBackoff = new _set.default();
+              if (!(this.state === 'stopped')) {
+                _context9.next = 5;
+                break;
+              }
+              return _context9.abrupt("return");
+            case 5:
+              // re-evaluate the dataset list after the sleep, since the scope may have been upgraded
+              // and exclude datasets that received messages during the backoff sleep
+              effectiveDataSetsToSync = this.getSortedDataSetsWithHashTrees(effectiveBackoffType === SyncAllBackoffType.ONLY_LLM).filter(function (ds) {
+                return !skippedDataSets.has(ds.name);
+              });
+              if (skippedDataSets.size > 0) {
+                _loggerProxy.default.logger.info("HashTreeParser#syncAllDatasets --> ".concat(this.debugId, " skipping datasets that received messages during backoff: ").concat((0, _toConsumableArray2.default)(skippedDataSets).join(', ')));
+              }
+              _loggerProxy.default.logger.info("HashTreeParser#syncAllDatasets --> ".concat(this.debugId, " syncing ").concat(effectiveBackoffType === SyncAllBackoffType.ONLY_LLM ? 'only LLM' : 'all', " datasets: ").concat(effectiveDataSetsToSync.map(function (ds) {
+                return ds.name;
+              }).join(', ')));
+              _iterator1 = _createForOfIteratorHelper(effectiveDataSetsToSync);
+              try {
+                for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+                  ds = _step1.value;
+                  this.enqueueSyncForDataset(ds.name, 'syncAllDatasets');
+                }
+              } catch (err) {
+                _iterator1.e(err);
+              } finally {
+                _iterator1.f();
+              }
+              _context9.next = 6;
+              return this.syncQueueProcessingPromise;
+            case 6:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee8, this);
+      }));
+      function syncAllDatasets() {
+        return _syncAllDatasets.apply(this, arguments);
+      }
+      return syncAllDatasets;
+    }()
+    /**
+     * Returns the list of data sets that have hash trees, sorted by the priority order provided by sortByInitPriority().
+     *
+     * @param {boolean} onlyLLM - Whether to include only LLM based data sets
+     * @returns {Array<{name: string, backoff: {maxMs: number, exponent: number}}>} The sorted list of data sets with their backoff configurations
+     */
+    )
+  }, {
+    key: "getSortedDataSetsWithHashTrees",
+    value: function getSortedDataSetsWithHashTrees(onlyLLM) {
+      var dataSets = (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,
+          backoff: dataSet.backoff
+        };
+      });
+      if (onlyLLM) {
+        dataSets = dataSets.filter(function (ds) {
+          return _constants3.LLM_DATASET_NAMES.includes(ds.name);
+        });
+      }
+      return (0, _utils.sortByInitPriority)(dataSets, _constants3.DATA_SET_INIT_PRIORITY);
+    }
+
     /**
      * Runs the sync algorithm for the given data set.
      *
      * @param {DataSet} receivedDataSet - The data set to run the sync algorithm for.
      * @returns {void}
      */
-    )
   }, {
     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"));
         return;
       }
       if (!dataSet.hashTree) {
-        _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " Data set \"").concat(dataSet.name, "\" has no hash tree, skipping sync algorithm"));
+        // no hash tree, so no need to do any syncing
+        // we fall into this branch often, because Locus sends dataSets in messages that are not visible to us
+
         return;
       }
       dataSet.hashTree.resize(receivedDataSet.leafCount);
-
-      // temporary log for the workshop // todo: remove
-      var ourCurrentRootHash = dataSet.hashTree.getRootHash();
-      _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " dataSet=\"").concat(dataSet.name, "\" version=").concat(dataSet.version, " hashes before starting timer: ours=").concat(ourCurrentRootHash, " Locus=").concat(dataSet.root));
       var delay = dataSet.idleMs + this.getWeightedBackoffTime(dataSet.backoff);
       if (delay > 0) {
         if (dataSet.timer) {
           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));
+          }
+        }, delay);
       } else {
         _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " No delay for \"").concat(dataSet.name, "\" data set, skipping sync timer reset/setup"));
       }
@@ -1475,48 +1889,45 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "resetHeartbeatWatchdogs",
     value: function resetHeartbeatWatchdogs(receivedDataSets) {
-      var _this12 = this;
-      if (!this.heartbeatIntervalMs) {
-        return;
-      }
-      var _iterator9 = _createForOfIteratorHelper(receivedDataSets),
-        _step9;
+      var _this11 = this;
+      var _iterator10 = _createForOfIteratorHelper(receivedDataSets),
+        _step10;
       try {
         var _loop2 = function _loop2() {
-          var receivedDataSet = _step9.value;
-          var dataSet = _this12.dataSets[receivedDataSet.name];
-          if (!(dataSet !== null && dataSet !== void 0 && dataSet.hashTree)) {
-            // eslint-disable-next-line no-continue
-            return 1; // continue
-          }
+          var _dataSet$heartbeatInt;
+          var receivedDataSet = _step10.value;
+          var dataSet = _this11.dataSets[receivedDataSet.name];
           if (dataSet.heartbeatWatchdogTimer) {
             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);
+
+          // dataset-level heartbeatIntervalMs takes priority; fall back to top-level common value
+          var heartbeatIntervalMs = (_dataSet$heartbeatInt = dataSet === null || dataSet === void 0 ? void 0 : dataSet.heartbeatIntervalMs) !== null && _dataSet$heartbeatInt !== void 0 ? _dataSet$heartbeatInt : _this11.topLevelHeartbeatIntervalMs;
+          if (!(dataSet !== null && dataSet !== void 0 && dataSet.hashTree) || !heartbeatIntervalMs) {
+            // eslint-disable-next-line no-continue
+            return 1; // continue
+          }
+          var backoffTime = _this11.getWeightedBackoffTime(dataSet.backoff);
+          var delay = 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"));
+            _metrics.default.sendBehavioralMetric(_constants.default.HASH_TREE_HEARTBEAT_WATCHDOG_EXPIRED, {
+              debugId: _this11.debugId,
+              dataSetName: dataSet.name
+            });
+            _this11.enqueueSyncForDataset(dataSet.name, "heartbeat watchdog expired");
+            _this11.resetHeartbeatWatchdogs([dataSet]);
+          }, delay);
         };
-        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
           if (_loop2()) continue;
         }
       } catch (err) {
-        _iterator9.e(err);
+        _iterator10.e(err);
       } finally {
-        _iterator9.f();
+        _iterator10.f();
       }
     }
 
@@ -1550,7 +1961,14 @@ 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 = [];
+      this.topLevelHeartbeatIntervalMs = undefined;
+      this.syncAllBackoffType = SyncAllBackoffType.NONE;
+      this.dataSetsSyncedDuringBackoff = new _set.default();
       (0, _values.default)(this.dataSets).forEach(function (dataSet) {
+        var _dataSet$syncAbortCon2;
+        (_dataSet$syncAbortCon2 = dataSet.syncAbortController) === null || _dataSet$syncAbortCon2 === void 0 ? void 0 : _dataSet$syncAbortCon2.abort();
+        dataSet.syncAbortController = undefined;
         dataSet.hashTree = undefined;
       });
       this.visibleDataSets = [];
@@ -1558,29 +1976,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) {
+    key: "resumeFromMessage",
+    value: function resumeFromMessage(message) {
       var _message$locusStateEl3, _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) {
         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 _iterator11 = _createForOfIteratorHelper(message.dataSets),
+        _step11;
       try {
-        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
-          var dataSet = _step0.value;
+        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+          var dataSet = _step11.value;
           var name = dataSet.name,
             leafCount = dataSet.leafCount;
           this.dataSets[name] = _objectSpread(_objectSpread({}, dataSet), {}, {
@@ -1588,23 +2018,62 @@ var HashTreeParser = /*#__PURE__*/function () {
           });
         }
       } catch (err) {
-        _iterator0.e(err);
+        _iterator11.e(err);
       } finally {
-        _iterator0.f();
+        _iterator11.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) {
       var _error$body;
+      // 404 for any dataset means the locus is no longer available at this URL - could be replaced or ended
+      // if a dataset is just not visible, we would get a 400
+      if (error.statusCode === 404) {
+        _loggerProxy.default.logger.info("HashTreeParser#checkForSentinelHttpResponse --> ".concat(this.debugId, " Received 404 for data set \"").concat(dataSetName, "\", locus not found"));
+        this.stopAllTimers();
+        throw new LocusNotFoundError();
+      }
       var isValidDataSetForSentinel = dataSetName === undefined || PossibleSentinelMessageDataSetNames.includes(dataSetName.toLowerCase());
-      if ((error.statusCode === 409 && ((_error$body = error.body) === null || _error$body === void 0 ? void 0 : _error$body.errorCode) === 2403004 || error.statusCode === 404) && isValidDataSetForSentinel) {
-        _loggerProxy.default.logger.info("HashTreeParser#checkForSentinelHttpResponse --> ".concat(this.debugId, " Received ").concat(error.statusCode, " for data set \"").concat(dataSetName, "\", indicating that the meeting has ended"));
+      if (error.statusCode === 409 && ((_error$body = error.body) === null || _error$body === void 0 ? void 0 : _error$body.errorCode) === _types2.LocusErrorCodes.LOCUS_INACTIVE && isValidDataSetForSentinel) {
+        var _error$body2;
+        _loggerProxy.default.logger.info("HashTreeParser#checkForSentinelHttpResponse --> ".concat(this.debugId, " Received ").concat(error.statusCode, "/").concat((_error$body2 = error.body) === null || _error$body2 === void 0 ? void 0 : _error$body2.errorCode, " for data set \"").concat(dataSetName, "\", indicating that the meeting has ended"));
         this.stopAllTimers();
         throw new MeetingEndedError();
       }
@@ -1614,37 +2083,49 @@ 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");
       return this.webexRequest({
-        method: _constants.HTTP_VERBS.GET,
+        method: _constants2.HTTP_VERBS.GET,
         uri: url,
         qs: {
           rootHash: currentRootHash
         }
       }).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);
+        _metrics.default.sendBehavioralMetric(_constants.default.HASH_TREE_SYNC_FAILURE, {
+          debugId: _this12.debugId,
+          dataSetName: dataSetName,
+          request: 'GET /hashtree',
+          statusCode: error.statusCode,
+          reason: error.message
+        });
         throw error;
       });
     }
@@ -1653,43 +2134,60 @@ 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: []
         });
-      });
-      var ourCurrentRootHash = dataSet.hashTree ? dataSet.hashTree.getRootHash() : _constants2.EMPTY_HASH;
+      } 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() : _constants3.EMPTY_HASH;
       return this.webexRequest({
-        method: _constants.HTTP_VERBS.POST,
+        method: _constants2.HTTP_VERBS.POST,
         uri: url,
         qs: {
           rootHash: ourCurrentRootHash
         },
         body: body
       }).then(function (resp) {
-        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this14.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);
+        _metrics.default.sendBehavioralMetric(_constants.default.HASH_TREE_SYNC_FAILURE, {
+          debugId: _this13.debugId,
+          dataSetName: dataSet.name,
+          request: 'POST /sync',
+          statusCode: error.statusCode,
+          reason: error.message
+        });
         throw error;
       });
     }