@webex/plugin-meetings 3.12.0-next.61 → 3.12.0-next.62

package/dist/aiEnableRequest/index.js

@@ -191,7 +191,7 @@ var AIEnableRequest = _webexCore.WebexPlugin.extend({
       method: _constants.HTTP_VERBS.PUT
     });
   },
-  version: "3.12.0-next.61"
+  version: "3.12.0-next.62"
 });
 var _default = exports.default = AIEnableRequest;
 //# sourceMappingURL=index.js.map

package/dist/breakouts/breakout.js

@@ -214,7 +214,7 @@ var Breakout = _webexCore.WebexPlugin.extend({
       sessionId: this.sessionId
     });
   },
-  version: "3.12.0-next.61"
+  version: "3.12.0-next.62"
 });
 var _default = exports.default = Breakout;
 //# sourceMappingURL=breakout.js.map

package/dist/breakouts/index.js

@@ -1133,7 +1133,7 @@ var Breakouts = _webexCore.WebexPlugin.extend({
       this.trigger(_constants.BREAKOUTS.EVENTS.ASK_RETURN_TO_MAIN);
     }
   },
-  version: "3.12.0-next.61"
+  version: "3.12.0-next.62"
 });
 var _default = exports.default = Breakouts;
 //# sourceMappingURL=index.js.map

package/dist/hashTree/constants.js

@@ -4,7 +4,7 @@ var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/defi
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-exports.EMPTY_HASH = exports.DataSetNames = exports.DATA_SET_INIT_PRIORITY = void 0;
+exports.LLM_DATASET_NAMES = exports.EMPTY_HASH = exports.DataSetNames = exports.DATA_SET_INIT_PRIORITY = void 0;
 var EMPTY_HASH = exports.EMPTY_HASH = '99aa06d3014798d86001c324468d497f';
 var DataSetNames = exports.DataSetNames = {
   MAIN: 'main',
@@ -28,4 +28,7 @@ var DataSetNames = exports.DataSetNames = {
 // participant object for webinar attendees. If SELF were initialized first, locus.info
 // would not yet be populated and the attendee participant would be skipped.
 var DATA_SET_INIT_PRIORITY = exports.DATA_SET_INIT_PRIORITY = [DataSetNames.MAIN, DataSetNames.SELF];
+
+// Data sets for which we normally receive events over LLM connection
+var LLM_DATASET_NAMES = exports.LLM_DATASET_NAMES = [DataSetNames.MAIN, DataSetNames.ATD_ACTIVE, DataSetNames.ATD_UNMUTED];
 //# sourceMappingURL=constants.js.map

package/dist/hashTree/constants.js.map

@@ -1 +1 @@
-{"version":3,"names":["EMPTY_HASH","exports","DataSetNames","MAIN","ATTENDEES","ATD_ACTIVE","ATD_UNMUTED","SELF","UNJOINED","DATA_SET_INIT_PRIORITY"],"sources":["constants.ts"],"sourcesContent":["export const EMPTY_HASH = '99aa06d3014798d86001c324468d497f';\n\nexport const DataSetNames = {\n  MAIN: 'main', // sent to web client, contains also panelists, over LLM\n  ATTENDEES: 'attendees', // NOT SENT to web client, all the attendees in the locus\n  ATD_ACTIVE: 'atd-active', // only sent to panelists, over LLM; the attendees that have their hands raised or are allowed to unmute themselves\n  ATD_UNMUTED: 'atd-unmuted', // sent to web client, over LLM, not sent to panelists; the attendees that are unmuted\n  SELF: 'self', // sent to web client, over Mercury\n  UNJOINED: 'unjoined', // sent when you are not joined, but can still see some stuff from the meeting (mutually exclusive with \"main\")\n};\n\n// Priority order for initializing data sets — higher priority names come first.\n// Data sets not listed here will be initialized after all prioritized ones.\n// MAIN must come before SELF because LocusInfo.updateFromHashTree processes the\n// batch of updatedObjects in order, and the SELF handler in updateLocusFromHashTreeObject\n// checks locus.info?.isWebinar (which comes from MAIN) to decide whether to create a\n// participant object for webinar attendees. If SELF were initialized first, locus.info\n// would not yet be populated and the attendee participant would be skipped.\nexport const DATA_SET_INIT_PRIORITY: string[] = [DataSetNames.MAIN, DataSetNames.SELF];\n"],"mappings":";;;;;;;AAAO,IAAMA,UAAU,GAAAC,OAAA,CAAAD,UAAA,GAAG,kCAAkC;AAErD,IAAME,YAAY,GAAAD,OAAA,CAAAC,YAAA,GAAG;EAC1BC,IAAI,EAAE,MAAM;EAAE;EACdC,SAAS,EAAE,WAAW;EAAE;EACxBC,UAAU,EAAE,YAAY;EAAE;EAC1BC,WAAW,EAAE,aAAa;EAAE;EAC5BC,IAAI,EAAE,MAAM;EAAE;EACdC,QAAQ,EAAE,UAAU,CAAE;AACxB,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMC,sBAAgC,GAAAR,OAAA,CAAAQ,sBAAA,GAAG,CAACP,YAAY,CAACC,IAAI,EAAED,YAAY,CAACK,IAAI,CAAC","ignoreList":[]}
+{"version":3,"names":["EMPTY_HASH","exports","DataSetNames","MAIN","ATTENDEES","ATD_ACTIVE","ATD_UNMUTED","SELF","UNJOINED","DATA_SET_INIT_PRIORITY","LLM_DATASET_NAMES"],"sources":["constants.ts"],"sourcesContent":["export const EMPTY_HASH = '99aa06d3014798d86001c324468d497f';\n\nexport const DataSetNames = {\n  MAIN: 'main', // sent to web client, contains also panelists, over LLM\n  ATTENDEES: 'attendees', // NOT SENT to web client, all the attendees in the locus\n  ATD_ACTIVE: 'atd-active', // only sent to panelists, over LLM; the attendees that have their hands raised or are allowed to unmute themselves\n  ATD_UNMUTED: 'atd-unmuted', // sent to web client, over LLM, not sent to panelists; the attendees that are unmuted\n  SELF: 'self', // sent to web client, over Mercury\n  UNJOINED: 'unjoined', // sent when you are not joined, but can still see some stuff from the meeting (mutually exclusive with \"main\")\n};\n\n// Priority order for initializing data sets — higher priority names come first.\n// Data sets not listed here will be initialized after all prioritized ones.\n// MAIN must come before SELF because LocusInfo.updateFromHashTree processes the\n// batch of updatedObjects in order, and the SELF handler in updateLocusFromHashTreeObject\n// checks locus.info?.isWebinar (which comes from MAIN) to decide whether to create a\n// participant object for webinar attendees. If SELF were initialized first, locus.info\n// would not yet be populated and the attendee participant would be skipped.\nexport const DATA_SET_INIT_PRIORITY: string[] = [DataSetNames.MAIN, DataSetNames.SELF];\n\n// Data sets for which we normally receive events over LLM connection\nexport const LLM_DATASET_NAMES = [\n  DataSetNames.MAIN,\n  DataSetNames.ATD_ACTIVE,\n  DataSetNames.ATD_UNMUTED,\n];\n"],"mappings":";;;;;;;AAAO,IAAMA,UAAU,GAAAC,OAAA,CAAAD,UAAA,GAAG,kCAAkC;AAErD,IAAME,YAAY,GAAAD,OAAA,CAAAC,YAAA,GAAG;EAC1BC,IAAI,EAAE,MAAM;EAAE;EACdC,SAAS,EAAE,WAAW;EAAE;EACxBC,UAAU,EAAE,YAAY;EAAE;EAC1BC,WAAW,EAAE,aAAa;EAAE;EAC5BC,IAAI,EAAE,MAAM;EAAE;EACdC,QAAQ,EAAE,UAAU,CAAE;AACxB,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMC,sBAAgC,GAAAR,OAAA,CAAAQ,sBAAA,GAAG,CAACP,YAAY,CAACC,IAAI,EAAED,YAAY,CAACK,IAAI,CAAC;;AAEtF;AACO,IAAMG,iBAAiB,GAAAT,OAAA,CAAAS,iBAAA,GAAG,CAC/BR,YAAY,CAACC,IAAI,EACjBD,YAAY,CAACG,UAAU,EACvBH,YAAY,CAACI,WAAW,CACzB","ignoreList":[]}

package/dist/hashTree/hashTreeParser.js

@@ -15,8 +15,9 @@ var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequ
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.MeetingEndedError = exports.LocusNotFoundError = 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 _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"));
@@ -51,6 +52,12 @@ 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',
@@ -111,7 +118,10 @@ var HashTreeParser = /*#__PURE__*/function () {
     (0, _defineProperty2.default)(this, "state", void 0);
     (0, _defineProperty2.default)(this, "syncQueue", []);
     (0, _defineProperty2.default)(this, "isSyncInProgress", false);
-    (0, _defineProperty2.default)(this, "isSyncAllInProgress", 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());
     var _options$initialLocus = options.initialLocus,
       dataSets = _options$initialLocus.dataSets,
@@ -1465,8 +1475,9 @@ var HashTreeParser = /*#__PURE__*/function () {
                 // 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');
+                this.handleMessage(syncResponse, "via sync API (".concat(isInitialization ? 'init' : "".concat((0, _keys.default)(leavesData).length, " mismatched leaves"), ")"));
               }
               _context7.next = 17;
               break;
@@ -1509,21 +1520,60 @@ var HashTreeParser = /*#__PURE__*/function () {
       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(', ')));
       }
-      var _iterator9 = _createForOfIteratorHelper(dataSetNames),
-        _step9;
+      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 (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
           var _this$dataSets$name;
-          var name = _step9.value;
+          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) {
-        _iterator9.e(err);
+        _iterator0.e(err);
       } finally {
-        _iterator9.f();
+        _iterator0.f();
       }
     }
 
@@ -1616,82 +1666,178 @@ var HashTreeParser = /*#__PURE__*/function () {
       }
       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(). Does nothing if the parser is stopped or if a syncAllDatasets
-     * call is already in progress.
+     * 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 dataSetsWithHashTrees, sorted, _iterator0, _step0, ds;
+        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.isSyncAllInProgress) {
+              if (!this.tryUpgradePendingBackoff(onlyLLM)) {
                 _context9.next = 2;
                 break;
               }
               return _context9.abrupt("return");
             case 2:
-              this.isSyncAllInProgress = true;
-              _context9.prev = 3;
-              dataSetsWithHashTrees = (0, _values.default)(this.dataSets).filter(function (dataSet) {
-                return dataSet === null || dataSet === void 0 ? void 0 : dataSet.hashTree;
-              }).map(function (dataSet) {
-                return {
-                  name: dataSet.name
-                };
+              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);
               });
-              sorted = (0, _utils.sortByInitPriority)(dataSetsWithHashTrees, _constants3.DATA_SET_INIT_PRIORITY);
-              _loggerProxy.default.logger.info("HashTreeParser#syncAllDatasets --> ".concat(this.debugId, " syncing datasets: ").concat(sorted.map(function (ds) {
+              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(', ')));
-              _iterator0 = _createForOfIteratorHelper(sorted);
+              _iterator1 = _createForOfIteratorHelper(effectiveDataSetsToSync);
               try {
-                for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
-                  ds = _step0.value;
+                for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+                  ds = _step1.value;
                   this.enqueueSyncForDataset(ds.name, 'syncAllDatasets');
                 }
               } catch (err) {
-                _iterator0.e(err);
+                _iterator1.e(err);
               } finally {
-                _iterator0.f();
+                _iterator1.f();
               }
-              _context9.next = 4;
+              _context9.next = 6;
               return this.syncQueueProcessingPromise;
-            case 4:
-              _context9.prev = 4;
-              this.isSyncAllInProgress = false;
-              return _context9.finish(4);
-            case 5:
+            case 6:
             case "end":
               return _context9.stop();
           }
-        }, _callee8, this, [[3,, 4, 5]]);
+        }, _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) {
@@ -1745,11 +1891,11 @@ var HashTreeParser = /*#__PURE__*/function () {
       if (!this.heartbeatIntervalMs) {
         return;
       }
-      var _iterator1 = _createForOfIteratorHelper(receivedDataSets),
-        _step1;
+      var _iterator10 = _createForOfIteratorHelper(receivedDataSets),
+        _step10;
       try {
         var _loop2 = function _loop2() {
-          var receivedDataSet = _step1.value;
+          var receivedDataSet = _step10.value;
           var dataSet = _this11.dataSets[receivedDataSet.name];
           if (!(dataSet !== null && dataSet !== void 0 && dataSet.hashTree)) {
             // eslint-disable-next-line no-continue
@@ -1772,13 +1918,13 @@ var HashTreeParser = /*#__PURE__*/function () {
             _this11.resetHeartbeatWatchdogs([dataSet]);
           }, delay);
         };
-        for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
           if (_loop2()) continue;
         }
       } catch (err) {
-        _iterator1.e(err);
+        _iterator10.e(err);
       } finally {
-        _iterator1.f();
+        _iterator10.f();
       }
     }
 
@@ -1813,6 +1959,8 @@ var HashTreeParser = /*#__PURE__*/function () {
       _loggerProxy.default.logger.info("HashTreeParser#stop --> ".concat(this.debugId, " Stopping HashTreeParser, clearing timers and hash trees"));
       this.stopAllTimers();
       this.syncQueue = [];
+      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();
@@ -1854,11 +2002,11 @@ var HashTreeParser = /*#__PURE__*/function () {
       }
       this.setVisibleDataSets(metadataObject.data.visibleDataSets, message.dataSets);
       this.dataSets = {};
-      var _iterator10 = _createForOfIteratorHelper(message.dataSets),
-        _step10;
+      var _iterator11 = _createForOfIteratorHelper(message.dataSets),
+        _step11;
       try {
-        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
-          var dataSet = _step10.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), {}, {
@@ -1866,9 +2014,9 @@ var HashTreeParser = /*#__PURE__*/function () {
           });
         }
       } catch (err) {
-        _iterator10.e(err);
+        _iterator11.e(err);
       } finally {
-        _iterator10.f();
+        _iterator11.f();
       }
       _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;