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

package/dist/hashTree/hashTreeParser.js

@@ -5,7 +5,7 @@ var _Array$from = require("@babel/runtime-corejs2/core-js/array/from");
 var _Symbol = require("@babel/runtime-corejs2/core-js/symbol");
 var _Symbol$iterator = require("@babel/runtime-corejs2/core-js/symbol/iterator");
 var _Array$isArray2 = require("@babel/runtime-corejs2/core-js/array/is-array");
-var _Object$keys3 = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$keys4 = require("@babel/runtime-corejs2/core-js/object/keys");
 var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
 var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
 var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
@@ -15,7 +15,7 @@ var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequ
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.LocusInfoUpdateType = void 0;
+exports.default = exports.MeetingEndedError = exports.LocusInfoUpdateType = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
 var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
 var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
@@ -40,7 +40,7 @@ var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy")
 var _constants = require("../constants");
 var _constants2 = require("./constants");
 var _utils = require("./utils");
-function ownKeys(e, r) { var t = _Object$keys3(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function ownKeys(e, r) { var t = _Object$keys4(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof _Symbol && r[_Symbol$iterator] || r["@@iterator"]; if (!t) { if (_Array$isArray2(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? _Array$from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
@@ -55,7 +55,7 @@ var LocusInfoUpdateType = exports.LocusInfoUpdateType = {
  * This error is thrown if we receive information that the meeting has ended while we're processing some hash messages.
  * It's handled internally by HashTreeParser and results in MEETING_ENDED being sent up.
  */
-var MeetingEndedError = /*#__PURE__*/function (_Error) {
+var MeetingEndedError = exports.MeetingEndedError = /*#__PURE__*/function (_Error) {
   function MeetingEndedError() {
     (0, _classCallCheck2.default)(this, MeetingEndedError);
     return _callSuper(this, MeetingEndedError, arguments);
@@ -63,6 +63,12 @@ var MeetingEndedError = /*#__PURE__*/function (_Error) {
   (0, _inherits2.default)(MeetingEndedError, _Error);
   return (0, _createClass2.default)(MeetingEndedError);
 }(/*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+/* Currently Locus always sends Metadata objects only in the "self" dataset.
+ * If this ever changes, update all the code that relies on this constant.
+ */
+var MetadataDataSetName = _constants2.DataSetNames.SELF;
+var PossibleSentinelMessageDataSetNames = [_constants2.DataSetNames.MAIN, _constants2.DataSetNames.SELF, _constants2.DataSetNames.UNJOINED];
+
 /**
  * Parses hash tree eventing locus data
  */
@@ -73,7 +79,7 @@ var HashTreeParser = /*#__PURE__*/function () {
    * @param {Object} options.initialLocus The initial locus data containing the hash tree information
    */
   function HashTreeParser(options) {
-    var _locus$self;
+    var _locus$links, _locus$links$resource, _locus$links$resource2, _options$metadata, _options$metadata2, _options$metadata2$vi;
     (0, _classCallCheck2.default)(this, HashTreeParser);
     (0, _defineProperty2.default)(this, "dataSets", {});
     (0, _defineProperty2.default)(this, "visibleDataSetsUrl", void 0);
@@ -82,6 +88,9 @@ 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);
     var _options$initialLocus = options.initialLocus,
       dataSets = _options$initialLocus.dataSets,
       locus = _options$initialLocus.locus; // extract dataSets from initialLocus
@@ -89,14 +98,23 @@ var HashTreeParser = /*#__PURE__*/function () {
     this.debugId = options.debugId;
     this.webexRequest = options.webexRequest;
     this.locusInfoUpdateCallback = options.locusInfoUpdateCallback;
-    this.visibleDataSets = (locus === null || locus === void 0 ? void 0 : (_locus$self = locus.self) === null || _locus$self === void 0 ? void 0 : _locus$self.visibleDataSets) || [];
-    if (this.visibleDataSets.length === 0) {
-      _loggerProxy.default.logger.warn("HashTreeParser#constructor --> ".concat(this.debugId, " No visibleDataSets found in locus.self"));
+    this.excludedDataSets = options.excludedDataSets || [];
+    this.visibleDataSetsUrl = locus === null || locus === void 0 ? void 0 : (_locus$links = locus.links) === null || _locus$links === void 0 ? void 0 : (_locus$links$resource = _locus$links.resources) === null || _locus$links$resource === void 0 ? void 0 : (_locus$links$resource2 = _locus$links$resource.visibleDataSets) === null || _locus$links$resource2 === void 0 ? void 0 : _locus$links$resource2.url;
+    this.setVisibleDataSets(((_options$metadata = options.metadata) === null || _options$metadata === void 0 ? void 0 : _options$metadata.visibleDataSets) || [], dataSets);
+    this.state = 'active';
+    if (((_options$metadata2 = options.metadata) === null || _options$metadata2 === void 0 ? void 0 : (_options$metadata2$vi = _options$metadata2.visibleDataSets) === null || _options$metadata2$vi === void 0 ? void 0 : _options$metadata2$vi.length) === 0) {
+      _loggerProxy.default.logger.warn("HashTreeParser#constructor --> ".concat(this.debugId, " No visibleDataSets found in Metadata"));
     }
     // object mapping dataset names to arrays of leaf data
     var leafData = this.analyzeLocusHtMeta(locus);
-    _loggerProxy.default.logger.info("HashTreeParser#constructor --> creating HashTreeParser for datasets: ".concat((0, _stringify.default)(dataSets.map(function (ds) {
+    if (options.metadata) {
+      // add also the metadata that's outside of locus object itself
+      this.analyzeMetadata(leafData, options.metadata);
+    }
+    _loggerProxy.default.logger.info("HashTreeParser#constructor --> ".concat(this.debugId, " creating HashTreeParser for datasets: ").concat((0, _stringify.default)(dataSets.map(function (ds) {
       return ds.name;
+    })), " with visible datasets: ").concat((0, _stringify.default)(this.visibleDataSets.map(function (vds) {
+      return vds.name;
     }))));
     var _iterator = _createForOfIteratorHelper(dataSets),
       _step;
@@ -106,7 +124,7 @@ var HashTreeParser = /*#__PURE__*/function () {
         var name = dataSet.name,
           leafCount = dataSet.leafCount;
         this.dataSets[name] = _objectSpread(_objectSpread({}, dataSet), {}, {
-          hashTree: this.visibleDataSets.includes(name) ? new _hashTree.default(leafData[name] || [], leafCount) : undefined
+          hashTree: this.isVisibleDataSet(name) ? new _hashTree.default(leafData[name] || [], leafCount) : undefined
         });
       }
     } catch (err) {
@@ -117,30 +135,102 @@ var HashTreeParser = /*#__PURE__*/function () {
   }
 
   /**
-   * Initializes a new visible data set by creating a hash tree for it, adding it to all the internal structures,
-   * and sending an initial sync request to Locus with empty leaf data - that will trigger Locus to gives us all the data
-   * from that dataset (in the response or via messages).
+   * Sets the visible data sets list for the HashTreeParser. This method should be called only at the start, to initialize
+   * the visible data sets, before any message processsing, so for example from the constructor or when resuming the parser.
    *
-   * @param {DataSet} dataSet The new data set to be added
-   * @returns {Promise}
+   * @param {Array<VisibleDataSetInfo>} visibleDataSets - The visible data sets to set
+   * @param {Array<DataSet>} dataSets - The "dataSets" list from Locus (yes, Locus sends visibleDataSets and dataSets as separate lists and they can differ)
+   * @returns {void}
    */
   return (0, _createClass2.default)(HashTreeParser, [{
+    key: "setVisibleDataSets",
+    value: function setVisibleDataSets(visibleDataSets, dataSets) {
+      var _this = this;
+      this.visibleDataSets = (0, _lodash.cloneDeep)(visibleDataSets).filter(function (vds) {
+        return (
+          // exclude data sets we will never care about
+          !_this.isExcludedDataSet(vds.name) &&
+          // and make sure that visibleDataSets list is consistent with dataSets list
+          dataSets.some(function (ds) {
+            return ds.name === vds.name;
+          })
+        );
+      });
+    }
+
+    /**
+     * Checks if the given data set name is in the list of visible data sets
+     * @param {string} dataSetName data set name to check
+     * @returns {Boolean} True if the data set is visible, false otherwise
+     */
+  }, {
+    key: "isVisibleDataSet",
+    value: function isVisibleDataSet(dataSetName) {
+      return this.visibleDataSets.some(function (vds) {
+        return vds.name === dataSetName;
+      });
+    }
+
+    /**
+     * Checks if the given data set name is in the excluded list
+     * @param {string} dataSetName data set name to check
+     * @returns {boolean} True if the data set is excluded, false otherwise
+     */
+  }, {
+    key: "isExcludedDataSet",
+    value: function isExcludedDataSet(dataSetName) {
+      return this.excludedDataSets.some(function (name) {
+        return name === dataSetName;
+      });
+    }
+
+    /**
+     * Adds a data set to the visible data sets list, unless it is in the excluded list.
+     * @param {VisibleDataSetInfo} dataSetInfo data set info to add
+     * @returns {boolean} True if the data set was added, false if it was excluded
+     */
+  }, {
+    key: "addToVisibleDataSetsList",
+    value: function addToVisibleDataSetsList(dataSetInfo) {
+      if (this.isExcludedDataSet(dataSetInfo.name)) {
+        _loggerProxy.default.logger.info("HashTreeParser#addToVisibleDataSetsList --> ".concat(this.debugId, " Data set \"").concat(dataSetInfo.name, "\" is in the excluded list, ignoring"));
+        return false;
+      }
+      this.visibleDataSets.push(dataSetInfo);
+      return true;
+    }
+
+    /**
+     * Initializes a new visible data set by creating a hash tree for it, adding it to all the internal structures,
+     * and sending an initial sync request to Locus with empty leaf data - that will trigger Locus to gives us all the data
+     * from that dataset (in the response or via messages).
+     *
+     * @param {VisibleDataSetInfo} visibleDataSetInfo Information about the new visible data set
+     * @param {DataSet} dataSetInfo The new data set to be added
+     * @returns {Promise}
+     */
+  }, {
     key: "initializeNewVisibleDataSet",
-    value: function initializeNewVisibleDataSet(dataSet) {
-      if (this.visibleDataSets.includes(dataSet.name)) {
-        _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Data set \"").concat(dataSet.name, "\" already exists, skipping init"));
+    value: function initializeNewVisibleDataSet(visibleDataSetInfo, dataSetInfo) {
+      if (this.isVisibleDataSet(dataSetInfo.name)) {
+        _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Data set \"").concat(dataSetInfo.name, "\" already exists, skipping init"));
+        return _promise.default.resolve({
+          updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
+          updatedObjects: []
+        });
+      }
+      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Adding visible data set \"").concat(dataSetInfo.name, "\""));
+      if (!this.addToVisibleDataSetsList(visibleDataSetInfo)) {
         return _promise.default.resolve({
           updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
           updatedObjects: []
         });
       }
-      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSet --> ".concat(this.debugId, " Adding visible data set \"").concat(dataSet.name, "\""));
-      this.visibleDataSets.push(dataSet.name);
-      var hashTree = new _hashTree.default([], dataSet.leafCount);
-      this.dataSets[dataSet.name] = _objectSpread(_objectSpread({}, dataSet), {}, {
+      var hashTree = new _hashTree.default([], dataSetInfo.leafCount);
+      this.dataSets[dataSetInfo.name] = _objectSpread(_objectSpread({}, dataSetInfo), {}, {
         hashTree: hashTree
       });
-      return this.sendInitializationSyncRequestToLocus(dataSet.name, 'new visible data set');
+      return this.sendInitializationSyncRequestToLocus(dataSetInfo.name, 'new visible data set');
     }
 
     /**
@@ -153,7 +243,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "sendInitializationSyncRequestToLocus",
     value: function sendInitializationSyncRequestToLocus(datasetName, debugText) {
-      var _this = this;
+      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"));
@@ -163,7 +253,10 @@ var HashTreeParser = /*#__PURE__*/function () {
       _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 _this.parseMessage(syncResponse, "via empty leaves /sync API call for ".concat(debugText));
+          return {
+            updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
+            updatedObjects: _this2.parseMessage(syncResponse, "via empty leaves /sync API call for ".concat(debugText))
+          };
         }
         return {
           updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
@@ -173,19 +266,26 @@ var HashTreeParser = /*#__PURE__*/function () {
     }
 
     /**
-     * Queries Locus for information about all the data sets
+     * Queries Locus for all up-to-date information about all visible data sets
      *
-     * @param {string} url - url from which we can get info about all data sets
      * @returns {Promise}
      */
   }, {
-    key: "getAllDataSetsMetadata",
-    value: function getAllDataSetsMetadata(url) {
+    key: "getAllVisibleDataSetsFromLocus",
+    value: function getAllVisibleDataSetsFromLocus() {
+      var _this3 = 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,
-        uri: url
+        uri: this.visibleDataSetsUrl
       }).then(function (response) {
         return response.body.dataSets;
+      }).catch(function (error) {
+        _this3.checkForSentinelHttpResponse(error);
+        throw error;
       });
     }
 
@@ -199,17 +299,18 @@ var HashTreeParser = /*#__PURE__*/function () {
     key: "initializeFromMessage",
     value: (function () {
       var _initializeFromMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(message) {
-        var dataSets;
+        var visibleDataSets;
         return _regenerator.default.wrap(function (_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              _loggerProxy.default.logger.info("HashTreeParser#initializeFromMessage --> ".concat(this.debugId, " visibleDataSetsUrl=").concat(message.visibleDataSetsUrl));
+              this.visibleDataSetsUrl = message.visibleDataSetsUrl;
+              _loggerProxy.default.logger.info("HashTreeParser#initializeFromMessage --> ".concat(this.debugId, " visibleDataSetsUrl=").concat(this.visibleDataSetsUrl));
               _context.next = 1;
-              return this.getAllDataSetsMetadata(message.visibleDataSetsUrl);
+              return this.getAllVisibleDataSetsFromLocus();
             case 1:
-              dataSets = _context.sent;
+              visibleDataSets = _context.sent;
               _context.next = 2;
-              return this.initializeDataSets(dataSets, 'initialization from message');
+              return this.initializeDataSets(visibleDataSets, 'initialization from message');
             case 2:
             case "end":
               return _context.stop();
@@ -235,25 +336,26 @@ var HashTreeParser = /*#__PURE__*/function () {
     key: "initializeFromGetLociResponse",
     value: (function () {
       var _initializeFromGetLociResponse = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2(locus) {
-        var _locus$links, _locus$links$resource, _locus$links$resource2;
-        var dataSets;
+        var _locus$links2, _locus$links2$resourc, _locus$links2$resourc2;
+        var visibleDataSets;
         return _regenerator.default.wrap(function (_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
-              if (locus !== null && locus !== void 0 && (_locus$links = locus.links) !== null && _locus$links !== void 0 && (_locus$links$resource = _locus$links.resources) !== null && _locus$links$resource !== void 0 && (_locus$links$resource2 = _locus$links$resource.visibleDataSets) !== null && _locus$links$resource2 !== void 0 && _locus$links$resource2.url) {
+              if (locus !== null && locus !== void 0 && (_locus$links2 = locus.links) !== null && _locus$links2 !== void 0 && (_locus$links2$resourc = _locus$links2.resources) !== null && _locus$links2$resourc !== void 0 && (_locus$links2$resourc2 = _locus$links2$resourc.visibleDataSets) !== null && _locus$links2$resourc2 !== void 0 && _locus$links2$resourc2.url) {
                 _context2.next = 1;
                 break;
               }
               _loggerProxy.default.logger.warn("HashTreeParser#initializeFromGetLociResponse --> ".concat(this.debugId, " missing visibleDataSets url in GET Loci response, cannot initialize hash trees"));
               return _context2.abrupt("return");
             case 1:
-              _loggerProxy.default.logger.info("HashTreeParser#initializeFromGetLociResponse --> ".concat(this.debugId, " visibleDataSets url: ").concat(locus.links.resources.visibleDataSets.url));
+              this.visibleDataSetsUrl = locus.links.resources.visibleDataSets.url;
+              _loggerProxy.default.logger.info("HashTreeParser#initializeFromGetLociResponse --> ".concat(this.debugId, " visibleDataSets url: ").concat(this.visibleDataSetsUrl));
               _context2.next = 2;
-              return this.getAllDataSetsMetadata(locus.links.resources.visibleDataSets.url);
+              return this.getAllVisibleDataSetsFromLocus();
             case 2:
-              dataSets = _context2.sent;
+              visibleDataSets = _context2.sent;
               _context2.next = 3;
-              return this.initializeDataSets(dataSets, 'initialization from GET /loci response');
+              return this.initializeDataSets(visibleDataSets, 'initialization from GET /loci response');
             case 3:
             case "end":
               return _context2.stop();
@@ -268,7 +370,7 @@ var HashTreeParser = /*#__PURE__*/function () {
     /**
      * Initializes data sets by doing an initialization sync on each visible data set that doesn't have a hash tree yet.
      *
-     * @param {DataSet[]} dataSets Array of DataSet objects to initialize
+     * @param {DataSet[]} visibleDataSets Array of visible DataSet objects to initialize
      * @param {string} debugText Text to include in logs for debugging purposes
      * @returns {Promise}
      */
@@ -276,76 +378,86 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "initializeDataSets",
     value: (function () {
-      var _initializeDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3(dataSets, debugText) {
-        var updatedObjects, _iterator2, _step2, dataSet, name, leafCount, _data, _t;
+      var _initializeDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3(visibleDataSets, debugText) {
+        var updatedObjects, _iterator2, _step2, dataSet, name, leafCount, url, _data, _t;
         return _regenerator.default.wrap(function (_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
+              if (!(this.state === 'stopped')) {
+                _context3.next = 1;
+                break;
+              }
+              return _context3.abrupt("return");
+            case 1:
               updatedObjects = [];
-              _iterator2 = _createForOfIteratorHelper(dataSets);
-              _context3.prev = 1;
+              _iterator2 = _createForOfIteratorHelper(visibleDataSets);
+              _context3.prev = 2;
               _iterator2.s();
-            case 2:
+            case 3:
               if ((_step2 = _iterator2.n()).done) {
-                _context3.next = 6;
+                _context3.next = 7;
                 break;
               }
               dataSet = _step2.value;
-              name = dataSet.name, leafCount = dataSet.leafCount;
+              name = dataSet.name, leafCount = dataSet.leafCount, url = dataSet.url;
               if (!this.dataSets[name]) {
                 _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " initializing dataset \"").concat(name, "\" (").concat(debugText, ")"));
                 this.dataSets[name] = _objectSpread({}, dataSet);
               } else {
                 _loggerProxy.default.logger.info("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " dataset \"").concat(name, "\" already exists (").concat(debugText, ")"));
               }
-              if (!(this.visibleDataSets.includes(name) && !this.dataSets[name].hashTree)) {
-                _context3.next = 5;
+              if (this.isVisibleDataSet(name)) {
+                _context3.next = 4;
+                break;
+              }
+              if (this.addToVisibleDataSetsList({
+                name: name,
+                url: url
+              })) {
+                _context3.next = 4;
+                break;
+              }
+              return _context3.abrupt("continue", 6);
+            case 4:
+              if (this.dataSets[name].hashTree) {
+                _context3.next = 6;
                 break;
               }
               _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 = 3;
+              _context3.next = 5;
               return this.sendInitializationSyncRequestToLocus(name, debugText);
-            case 3:
+            case 5:
               _data = _context3.sent;
-              if (!(_data.updateType === LocusInfoUpdateType.MEETING_ENDED)) {
-                _context3.next = 4;
-                break;
-              }
-              _loggerProxy.default.logger.warn("HashTreeParser#initializeDataSets --> ".concat(this.debugId, " meeting ended while initializing new visible data set \"").concat(name, "\""));
-
-              // throw an error, it will be caught higher up and the meeting will be destroyed
-              throw new MeetingEndedError();
-            case 4:
               if (_data.updateType === LocusInfoUpdateType.OBJECTS_UPDATED) {
                 updatedObjects.push.apply(updatedObjects, (0, _toConsumableArray2.default)(_data.updatedObjects || []));
               }
-            case 5:
-              _context3.next = 2;
-              break;
             case 6:
-              _context3.next = 8;
+              _context3.next = 3;
               break;
             case 7:
-              _context3.prev = 7;
-              _t = _context3["catch"](1);
-              _iterator2.e(_t);
+              _context3.next = 9;
+              break;
             case 8:
               _context3.prev = 8;
-              _iterator2.f();
-              return _context3.finish(8);
+              _t = _context3["catch"](2);
+              _iterator2.e(_t);
             case 9:
+              _context3.prev = 9;
+              _iterator2.f();
+              return _context3.finish(9);
+            case 10:
               this.callLocusInfoUpdateCallback({
                 updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
                 updatedObjects: updatedObjects
               });
-            case 10:
+            case 11:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this, [[1, 7, 8, 9]]);
+        }, _callee3, this, [[2, 8, 9, 10]]);
       }));
       function initializeDataSets(_x3, _x4) {
         return _initializeDataSets.apply(this, arguments);
@@ -434,6 +546,38 @@ var HashTreeParser = /*#__PURE__*/function () {
       return leafInfo;
     }
 
+    /**
+     * Analyzes the Metadata object that is sent outside of Locus object, and appends its data to passed in leafInfo
+     * structure.
+     *
+     * @param {Record<string, LeafInfo[]>} leafInfo the structure to which the Metadata info will be appended
+     * @param {Metadata} metadata Metadata object
+     * @returns {void}
+     */
+  }, {
+    key: "analyzeMetadata",
+    value: function analyzeMetadata(leafInfo, metadata) {
+      var _htMeta$dataSetNames;
+      var htMeta = metadata.htMeta;
+      if ((htMeta === null || htMeta === void 0 ? void 0 : (_htMeta$dataSetNames = htMeta.dataSetNames) === null || _htMeta$dataSetNames === void 0 ? void 0 : _htMeta$dataSetNames.length) === 1 && htMeta.dataSetNames[0].toLowerCase() === MetadataDataSetName) {
+        var _metadata$htMeta$elem = metadata.htMeta.elementId,
+          type = _metadata$htMeta$elem.type,
+          id = _metadata$htMeta$elem.id,
+          version = _metadata$htMeta$elem.version;
+        var dataSetName = htMeta.dataSetNames[0];
+        if (!leafInfo[dataSetName]) {
+          leafInfo[dataSetName] = [];
+        }
+        leafInfo[dataSetName].push({
+          type: type,
+          id: id,
+          version: version
+        });
+      } else {
+        throw new Error("".concat(this.debugId, " Metadata htMeta has unexpected dataSetNames: ").concat(htMeta && htMeta.dataSetNames.join(',')));
+      }
+    }
+
     /**
      * Checks if the provided hash tree message indicates the end of the meeting and that there won't be any more updates.
      *
@@ -443,14 +587,14 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "isEndMessage",
     value: function isEndMessage(message) {
-      var mainDataSet = message.dataSets.find(function (dataSet) {
-        return dataSet.name.toLowerCase() === _constants2.DataSetNames.MAIN;
+      var _this4 = 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())) {
+          // this is a special way for Locus to indicate that this meeting has ended
+          return true;
+        }
+        return false;
       });
-      if (mainDataSet && mainDataSet.leafCount === 1 && mainDataSet.root === _constants2.EMPTY_HASH && this.dataSets[_constants2.DataSetNames.MAIN].version < mainDataSet.version) {
-        // this is a special way for Locus to indicate that this meeting has ended
-        return true;
-      }
-      return false;
     }
 
     /**
@@ -462,7 +606,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "handleRootHashHeartBeatMessage",
     value: function handleRootHashHeartBeatMessage(message) {
-      var _this2 = this;
+      var _this5 = 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,
@@ -477,11 +621,81 @@ var HashTreeParser = /*#__PURE__*/function () {
         };
       }))));
       dataSets.forEach(function (dataSet) {
-        _this2.updateDataSetInfo(dataSet);
-        _this2.runSyncAlgorithm(dataSet);
+        _this5.updateDataSetInfo(dataSet);
+        _this5.runSyncAlgorithm(dataSet);
       });
     }
 
+    /**
+     * Asynchronously initializes new visible data sets
+     *
+     * @param {VisibleDataSetInfo[]} dataSetsRequiringInitialization list of datasets to initialize
+     * @returns {void}
+     */
+  }, {
+    key: "queueInitForNewVisibleDataSets",
+    value: function queueInitForNewVisibleDataSets(dataSetsRequiringInitialization) {
+      var _this6 = 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) {
+              return ds.name;
+            }).join(', '), ": "), error);
+          }
+        });
+      });
+    }
+
+    /**
+     * Handles updates to Metadata object that we receive from Locus via other means than messages. Right now
+     * that means only in the API response alongside locus object.
+     *
+     * @param {Metadata} metadata received in Locus update other than a message (for example in an API response)
+     * @param {HashTreeObject[]} updatedObjects a list of updated hash tree objects to which any updates resulting from new Metadata will be added
+     * @returns {void}
+     */
+  }, {
+    key: "handleMetadataUpdate",
+    value: function handleMetadataUpdate(metadata, updatedObjects) {
+      var _this$dataSets$Metada;
+      var dataSetsRequiringInitialization = [];
+
+      // current assumption based on Locus docs is that Metadata object lives always in "self" data set
+      var hashTree = (_this$dataSets$Metada = this.dataSets[MetadataDataSetName]) === null || _this$dataSets$Metada === void 0 ? void 0 : _this$dataSets$Metada.hashTree;
+      if (!hashTree) {
+        _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received Metadata object but no hash tree for \"").concat(MetadataDataSetName, "\" data set exists"));
+      } else {
+        var metadataUpdated = hashTree.putItem(metadata.htMeta.elementId);
+        if (metadataUpdated) {
+          // metadata in Locus API response is in a slightly different format than the objects in messages, so need to adapt it
+          var metadataObject = {
+            htMeta: metadata.htMeta,
+            data: metadata
+          };
+          updatedObjects.push(metadataObject);
+          var _this$checkForVisible = this.checkForVisibleDataSetChanges([metadataObject]),
+            changeDetected = _this$checkForVisible.changeDetected,
+            removedDataSets = _this$checkForVisible.removedDataSets,
+            addedDataSets = _this$checkForVisible.addedDataSets;
+          if (changeDetected) {
+            dataSetsRequiringInitialization = this.processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects);
+          }
+          if (dataSetsRequiringInitialization.length > 0) {
+            // there are some data sets that we need to initialize asynchronously
+            this.queueInitForNewVisibleDataSets(dataSetsRequiringInitialization);
+          }
+        }
+      }
+    }
+
     /**
      * This method should be called when we receive a partial locus DTO that contains dataSets and htMeta information
      * It updates the hash trees with the new leaf data based on the received Locus
@@ -492,23 +706,28 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "handleLocusUpdate",
     value: function handleLocusUpdate(update) {
-      var _this3 = this;
+      var _this7 = this;
+      if (this.state === 'stopped') {
+        return;
+      }
       var dataSets = update.dataSets,
-        locus = update.locus;
+        locus = update.locus,
+        metadata = update.metadata;
       if (!dataSets) {
-        _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received hash tree update without dataSets"));
-      }
-      var _iterator5 = _createForOfIteratorHelper(dataSets),
-        _step5;
-      try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var dataSet = _step5.value;
-          this.updateDataSetInfo(dataSet);
+        _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received hash tree update without dataSets"));
+      } else {
+        var _iterator5 = _createForOfIteratorHelper(dataSets),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var dataSet = _step5.value;
+            this.updateDataSetInfo(dataSet);
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
         }
-      } catch (err) {
-        _iterator5.e(err);
-      } finally {
-        _iterator5.f();
       }
       var updatedObjects = [];
 
@@ -517,11 +736,16 @@ var HashTreeParser = /*#__PURE__*/function () {
         copyData: true
       });
 
+      // if we got metadata, process it (currently that means only potential visible data set list changes)
+      if (metadata) {
+        this.handleMetadataUpdate(metadata, updatedObjects);
+      }
+
       // then process the data in hash trees, if it is a new version, then add it to updatedObjects
       (0, _keys.default)(leafInfo).forEach(function (dataSetName) {
-        if (_this3.dataSets[dataSetName]) {
-          if (_this3.dataSets[dataSetName].hashTree) {
-            var appliedChangesList = _this3.dataSets[dataSetName].hashTree.putItems(leafInfo[dataSetName].map(function (leaf) {
+        if (_this7.dataSets[dataSetName]) {
+          if (_this7.dataSets[dataSetName].hashTree) {
+            var appliedChangesList = _this7.dataSets[dataSetName].hashTree.putItems(leafInfo[dataSetName].map(function (leaf) {
               return {
                 id: leaf.id,
                 type: leaf.type,
@@ -548,10 +772,10 @@ var HashTreeParser = /*#__PURE__*/function () {
             });
           } else {
             // no hash tree means that the data set is not visible
-            _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this3.debugId, " received leaf data for data set \"").concat(dataSetName, "\" that has no hash tree created, ignoring"));
+            _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this7.debugId, " received leaf data for data set \"").concat(dataSetName, "\" that has no hash tree created, ignoring"));
           }
         } else {
-          _loggerProxy.default.logger.warn("HashTreeParser#handleLocusUpdate --> ".concat(_this3.debugId, " received leaf data for unknown data set \"").concat(dataSetName, "\", ignoring"));
+          _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(_this7.debugId, " received leaf data for unknown data set \"").concat(dataSetName, "\", ignoring"));
         }
       });
       if (updatedObjects.length === 0) {
@@ -562,9 +786,6 @@ var HashTreeParser = /*#__PURE__*/function () {
           updatedObjects: updatedObjects
         });
       }
-
-      // todo: once Locus design on how visible data sets will be communicated in subsequent API responses is confirmed,
-      // we'll need to check here if visible data sets have changed and update this.visibleDataSets, remove/create hash trees etc
     }
 
     /**
@@ -578,7 +799,7 @@ var HashTreeParser = /*#__PURE__*/function () {
     value: function updateDataSetInfo(receivedDataSet) {
       if (!this.dataSets[receivedDataSet.name]) {
         this.dataSets[receivedDataSet.name] = _objectSpread({}, receivedDataSet);
-        _loggerProxy.default.logger.info("HashTreeParser#handleMessage --> ".concat(this.debugId, " created entry for \"").concat(receivedDataSet.name, "\" dataset: version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
+        _loggerProxy.default.logger.info("HashTreeParser#updateDataSetInfo --> ".concat(this.debugId, " created entry for \"").concat(receivedDataSet.name, "\" dataset: version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
         return;
       }
       // update our version of the dataSet
@@ -590,7 +811,7 @@ var HashTreeParser = /*#__PURE__*/function () {
           maxMs: receivedDataSet.backoff.maxMs,
           exponent: receivedDataSet.backoff.exponent
         };
-        _loggerProxy.default.logger.info("HashTreeParser#handleMessage --> ".concat(this.debugId, " updated \"").concat(receivedDataSet.name, "\" to version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
+        _loggerProxy.default.logger.info("HashTreeParser#updateDataSetInfo --> ".concat(this.debugId, " updated \"").concat(receivedDataSet.name, "\" dataset to version=").concat(receivedDataSet.version, ", root=").concat(receivedDataSet.root));
       }
     }
 
@@ -602,24 +823,33 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "checkForVisibleDataSetChanges",
     value: function checkForVisibleDataSetChanges(updatedObjects) {
-      var _this4 = this;
+      var _this8 = this;
       var removedDataSets = [];
       var addedDataSets = [];
 
-      // visibleDataSets can only be changed by self object updates
+      // visibleDataSets can only be changed by Metadata object updates
       updatedObjects.forEach(function (object) {
         var _object$data;
-        // todo: in the future visibleDataSets will be in "Metadata" object, not in "self"
-        if ((0, _utils.isSelf)(object) && (_object$data = object.data) !== null && _object$data !== void 0 && _object$data.visibleDataSets) {
-          var newVisibleDataSets = object.data.visibleDataSets;
-          removedDataSets = _this4.visibleDataSets.filter(function (ds) {
-            return !newVisibleDataSets.includes(ds);
+        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);
           });
-          addedDataSets = newVisibleDataSets.filter(function (ds) {
-            return !_this4.visibleDataSets.includes(ds);
+          removedDataSets = _this8.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 ds.name !== nvs.name;
+            });
           });
           if (removedDataSets.length > 0 || addedDataSets.length > 0) {
-            _loggerProxy.default.logger.info("HashTreeParser#checkForVisibleDataSetChanges --> ".concat(_this4.debugId, " visible data sets change: removed: ").concat(removedDataSets.join(', '), ", added: ").concat(addedDataSets.join(', ')));
+            _loggerProxy.default.logger.info("HashTreeParser#checkForVisibleDataSetChanges --> ".concat(_this8.debugId, " visible data sets change: removed: ").concat(removedDataSets.map(function (ds) {
+              return ds.name;
+            }).join(', '), ", added: ").concat(addedDataSets.map(function (ds) {
+              return ds.name;
+            }).join(', ')));
           }
         }
       });
@@ -641,11 +871,15 @@ var HashTreeParser = /*#__PURE__*/function () {
     value: function deleteHashTree(dataSetName) {
       this.dataSets[dataSetName].hashTree = undefined;
 
-      // we also need to stop the timer as there is no hash tree anymore to sync
+      // we also need to stop the timers as there is no hash tree anymore to sync
       if (this.dataSets[dataSetName].timer) {
         clearTimeout(this.dataSets[dataSetName].timer);
         this.dataSets[dataSetName].timer = undefined;
       }
+      if (this.dataSets[dataSetName].heartbeatWatchdogTimer) {
+        clearTimeout(this.dataSets[dataSetName].heartbeatWatchdogTimer);
+        this.dataSets[dataSetName].heartbeatWatchdogTimer = undefined;
+      }
     }
 
     /**
@@ -657,38 +891,40 @@ var HashTreeParser = /*#__PURE__*/function () {
      * visible data sets and they require async initialization, the names of these data sets
      * are returned in an array.
      *
-     * @param {string[]} removedDataSets - The list of removed data sets.
-     * @param {string[]} addedDataSets - The list of added data sets.
+     * @param {VisibleDataSetInfo[]} removedDataSets - The list of removed data sets.
+     * @param {VisibleDataSetInfo[]} addedDataSets - The list of added data sets.
      * @param {HashTreeObject[]} updatedObjects - The list of updated hash tree objects to which changes will be added.
-     * @returns {string[]} names of data sets that couldn't be initialized synchronously
+     * @returns {VisibleDataSetInfo[]} list of data sets that couldn't be initialized synchronously
      */
   }, {
     key: "processVisibleDataSetChanges",
     value: function processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects) {
-      var _this5 = this;
+      var _this9 = this;
       var dataSetsRequiringInitialization = [];
 
       // if a visible data set was removed, we need to tell our client that all objects from it are removed
       var removedObjects = [];
       removedDataSets.forEach(function (ds) {
-        var _this5$dataSets$ds;
-        if ((_this5$dataSets$ds = _this5.dataSets[ds]) !== null && _this5$dataSets$ds !== void 0 && _this5$dataSets$ds.hashTree) {
-          for (var i = 0; i < _this5.dataSets[ds].hashTree.numLeaves; i += 1) {
-            removedObjects.push.apply(removedObjects, (0, _toConsumableArray2.default)(_this5.dataSets[ds].hashTree.getLeafData(i).map(function (elementId) {
+        var _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) {
               return {
                 htMeta: {
                   elementId: elementId,
-                  dataSetNames: [ds]
+                  dataSetNames: [ds.name]
                 },
                 data: null
               };
             })));
           }
-          _this5.deleteHashTree(ds);
+          _this9.deleteHashTree(ds.name);
         }
       });
       this.visibleDataSets = this.visibleDataSets.filter(function (vds) {
-        return !removedDataSets.includes(vds);
+        return !removedDataSets.some(function (rds) {
+          return rds.name === vds.name;
+        });
       });
       updatedObjects.push.apply(updatedObjects, removedObjects);
 
@@ -698,22 +934,29 @@ var HashTreeParser = /*#__PURE__*/function () {
       try {
         for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
           var ds = _step6.value;
-          var dataSetInfo = this.dataSets[ds];
+          var dataSetInfo = this.dataSets[ds.name];
           if (dataSetInfo) {
-            if (this.visibleDataSets.includes(dataSetInfo.name)) {
-              _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Data set \"").concat(ds, "\" is already visible, skipping"));
+            if (this.isVisibleDataSet(dataSetInfo.name)) {
+              _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Data set \"").concat(ds.name, "\" is already visible, skipping"));
 
               // eslint-disable-next-line no-continue
               continue;
             }
-            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Adding visible data set \"").concat(ds, "\""));
-            this.visibleDataSets.push(ds);
+            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " Adding visible data set \"").concat(ds.name, "\""));
+            if (!this.addToVisibleDataSetsList(ds)) {
+              // eslint-disable-next-line no-continue
+              continue;
+            }
             var hashTree = new _hashTree.default([], dataSetInfo.leafCount);
             this.dataSets[dataSetInfo.name] = _objectSpread(_objectSpread({}, dataSetInfo), {}, {
               hashTree: hashTree
             });
+
+            // this call is needed here for the edge case where we receive a message with new visible data sets
+            // and there are no objects belonging to these data sets in the message but we already have the info about them in this.dataSets
+            this.runSyncAlgorithm(this.dataSets[dataSetInfo.name]);
           } else {
-            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " visible data set \"").concat(ds, "\" added but no info about it in our dataSets structures"));
+            _loggerProxy.default.logger.info("HashTreeParser#processVisibleDataSetChanges --> ".concat(this.debugId, " visible data set \"").concat(ds.name, "\" added but no info about it in our dataSets structures"));
             // todo: add a metric here
             dataSetsRequiringInitialization.push(ds);
           }
@@ -730,25 +973,30 @@ var HashTreeParser = /*#__PURE__*/function () {
      * Adds entries to the passed in updateObjects array
      * for the changes that result from adding and removing visible data sets.
      *
-     * @param {HashTreeMessage} message - The hash tree message that triggered the visible data set changes.
-     * @param {string[]} addedDataSets - The list of added data sets.
+     * @param {VisibleDataSetInfo[]} addedDataSets - The list of added data sets.
      * @returns {Promise<void>}
      */
   }, {
     key: "initializeNewVisibleDataSets",
     value: (function () {
-      var _initializeNewVisibleDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4(message, addedDataSets) {
-        var _this6 = this;
+      var _initializeNewVisibleDataSets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4(addedDataSets) {
+        var _this0 = this;
         var allDataSets, _iterator7, _step7, _loop, _t2;
         return _regenerator.default.wrap(function (_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
-              _context5.next = 1;
-              return this.getAllDataSetsMetadata(message.visibleDataSetsUrl);
+              if (!(this.state === 'stopped')) {
+                _context5.next = 1;
+                break;
+              }
+              return _context5.abrupt("return");
             case 1:
+              _context5.next = 2;
+              return this.getAllVisibleDataSetsFromLocus();
+            case 2:
               allDataSets = _context5.sent;
               _iterator7 = _createForOfIteratorHelper(addedDataSets);
-              _context5.prev = 2;
+              _context5.prev = 3;
               _loop = /*#__PURE__*/_regenerator.default.mark(function _loop() {
                 var ds, dataSetInfo, updates;
                 return _regenerator.default.wrap(function (_context4) {
@@ -756,22 +1004,22 @@ var HashTreeParser = /*#__PURE__*/function () {
                     case 0:
                       ds = _step7.value;
                       dataSetInfo = allDataSets.find(function (d) {
-                        return d.name === ds;
+                        return d.name === ds.name;
                       });
-                      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this6.debugId, " initializing data set \"").concat(ds, "\""));
+                      _loggerProxy.default.logger.info("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this0.debugId, " initializing data set \"").concat(ds.name, "\""));
                       if (dataSetInfo) {
                         _context4.next = 1;
                         break;
                       }
-                      _loggerProxy.default.logger.warn("HashTreeParser#handleHashTreeMessage --> ".concat(_this6.debugId, " missing info about data set \"").concat(ds, "\" in Locus response from visibleDataSetsUrl"));
+                      _loggerProxy.default.logger.warn("HashTreeParser#initializeNewVisibleDataSets --> ".concat(_this0.debugId, " missing info about data set \"").concat(ds.name, "\" in Locus response from visibleDataSetsUrl"));
                       _context4.next = 3;
                       break;
                     case 1:
                       _context4.next = 2;
-                      return _this6.initializeNewVisibleDataSet(dataSetInfo);
+                      return _this0.initializeNewVisibleDataSet(ds, dataSetInfo);
                     case 2:
                       updates = _context4.sent;
-                      _this6.callLocusInfoUpdateCallback(updates);
+                      _this0.callLocusInfoUpdateCallback(updates);
                     case 3:
                     case "end":
                       return _context4.stop();
@@ -779,33 +1027,33 @@ var HashTreeParser = /*#__PURE__*/function () {
                 }, _loop);
               });
               _iterator7.s();
-            case 3:
+            case 4:
               if ((_step7 = _iterator7.n()).done) {
-                _context5.next = 5;
+                _context5.next = 6;
                 break;
               }
-              return _context5.delegateYield(_loop(), "t0", 4);
-            case 4:
-              _context5.next = 3;
-              break;
+              return _context5.delegateYield(_loop(), "t0", 5);
             case 5:
-              _context5.next = 7;
+              _context5.next = 4;
               break;
             case 6:
-              _context5.prev = 6;
-              _t2 = _context5["catch"](2);
-              _iterator7.e(_t2);
+              _context5.next = 8;
+              break;
             case 7:
               _context5.prev = 7;
-              _iterator7.f();
-              return _context5.finish(7);
+              _t2 = _context5["catch"](3);
+              _iterator7.e(_t2);
             case 8:
+              _context5.prev = 8;
+              _iterator7.f();
+              return _context5.finish(8);
+            case 9:
             case "end":
               return _context5.stop();
           }
-        }, _callee4, this, [[2, 6, 7, 8]]);
+        }, _callee4, this, [[3, 7, 8, 9]]);
       }));
-      function initializeNewVisibleDataSets(_x5, _x6) {
+      function initializeNewVisibleDataSets(_x5) {
         return _initializeNewVisibleDataSets.apply(this, arguments);
       }
       return initializeNewVisibleDataSets;
@@ -815,156 +1063,119 @@ var HashTreeParser = /*#__PURE__*/function () {
      *
      * @param {HashTreeMessage} message - The hash tree message containing data sets and objects to be processed
      * @param {string} [debugText] - Optional debug text to include in logs
-     * @returns {Promise}
+     * @returns {HashTreeObject[]} list of hash tree objects that were updated as a result of processing the message
      */
     )
   }, {
     key: "parseMessage",
-    value: (function () {
-      var _parseMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(message, debugText) {
-        var _message$locusStateEl,
-          _this7 = this;
-        var dataSets, visibleDataSetsUrl, isRosterDropped, updatedObjects, dataSetsRequiringInitialization, selfUpdates, updatedSelfObjects, _this$checkForVisible, changeDetected, removedDataSets, addedDataSets;
-        return _regenerator.default.wrap(function (_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
-            case 0:
-              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.warn("HashTreeParser#parseMessage --> ".concat(this.debugId, " got empty locusStateElements!!!"));
-                // todo: send a metric
-              }
+    value: function parseMessage(message, debugText) {
+      var _message$locusStateEl,
+        _this1 = this,
+        _message$locusStateEl2;
+      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.warn("HashTreeParser#parseMessage --> ".concat(this.debugId, " got empty locusStateElements!!!"));
+        // todo: send a metric
+      }
 
-              // first, update our metadata about the datasets with info from the message
-              this.visibleDataSetsUrl = visibleDataSetsUrl;
-              dataSets.forEach(function (dataSet) {
-                return _this7.updateDataSetInfo(dataSet);
-              });
-              if (!this.isEndMessage(message)) {
-                _context6.next = 1;
-                break;
-              }
-              _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " received END message"));
-              this.stopAllTimers();
-              return _context6.abrupt("return", {
-                updateType: LocusInfoUpdateType.MEETING_ENDED
-              });
-            case 1:
-              isRosterDropped = false;
-              updatedObjects = []; // when we detect new visible datasets, it may be that the metadata about them is not
-              // available in the message, they will require separate async initialization
-              dataSetsRequiringInitialization = []; // first find out if there are any visible data set changes - they're signalled in SELF object updates
-              selfUpdates = (message.locusStateElements || []).filter(function (object) {
-                return (
-                  // todo: SPARK-744859 once Locus supports it, we will filter for "Metadata" type here instead of "self"
-                  (0, _utils.isSelf)(object)
-                );
-              });
-              if (selfUpdates.length > 0) {
-                updatedSelfObjects = [];
-                selfUpdates.forEach(function (object) {
-                  // todo: once Locus supports it, we will use the "view" field here instead of dataSetNames
-                  var _iterator8 = _createForOfIteratorHelper(object.htMeta.dataSetNames),
-                    _step8;
-                  try {
-                    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-                      var _this7$dataSets$dataS;
-                      var dataSetName = _step8.value;
-                      var hashTree = (_this7$dataSets$dataS = _this7.dataSets[dataSetName]) === null || _this7$dataSets$dataS === void 0 ? void 0 : _this7$dataSets$dataS.hashTree;
-                      if (hashTree && object.data) {
-                        if (hashTree.putItem(object.htMeta.elementId)) {
-                          updatedSelfObjects.push(object);
-                        }
-                      }
-                    }
-                  } catch (err) {
-                    _iterator8.e(err);
-                  } finally {
-                    _iterator8.f();
-                  }
-                });
-                updatedObjects.push.apply(updatedObjects, updatedSelfObjects);
-                _this$checkForVisible = this.checkForVisibleDataSetChanges(updatedSelfObjects), changeDetected = _this$checkForVisible.changeDetected, removedDataSets = _this$checkForVisible.removedDataSets, addedDataSets = _this$checkForVisible.addedDataSets;
-                if (changeDetected) {
-                  dataSetsRequiringInitialization = this.processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects);
-                }
-              }
+      // first, update our metadata about the datasets with info from the message
+      this.visibleDataSetsUrl = visibleDataSetsUrl;
+      dataSets.forEach(function (dataSet) {
+        return _this1.updateDataSetInfo(dataSet);
+      });
+      var updatedObjects = [];
 
-              // 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 (_this7.dataSets[dataSet.name]) {
-                  var hashTree = _this7.dataSets[dataSet.name].hashTree;
-                  if (hashTree) {
-                    var locusStateElementsForThisSet = message.locusStateElements.filter(function (object) {
-                      return object.htMeta.dataSetNames.includes(dataSet.name);
-                    });
-                    var appliedChangesList = hashTree.updateItems(locusStateElementsForThisSet.map(function (object) {
-                      return object.data ? {
-                        operation: 'update',
-                        item: object.htMeta.elementId
-                      } : {
-                        operation: 'remove',
-                        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];
-                      if (changeApplied) {
-                        if ((0, _utils.isSelf)(object) && !object.data) {
-                          isRosterDropped = true;
-                        }
-                        // 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(_this7.debugId, " unexpected (not visible) dataSet ").concat(dataSet.name, " received in hash tree message"));
-                  }
-                }
-                if (!isRosterDropped) {
-                  _this7.runSyncAlgorithm(dataSet);
+      // when we detect new visible datasets, it may be that the metadata about them is not
+      // available in the message, they will require separate async initialization
+      var dataSetsRequiringInitialization = [];
+
+      // first find out if there are any visible data set changes - they're signalled in Metadata object updates
+      var metadataUpdates = (message.locusStateElements || []).filter(function (object) {
+        return (0, _utils.isMetadata)(object);
+      });
+      if (metadataUpdates.length > 0) {
+        var updatedMetadataObjects = [];
+        metadataUpdates.forEach(function (object) {
+          // todo: once Locus supports it, we will use the "view" field here instead of dataSetNames
+          var _iterator8 = _createForOfIteratorHelper(object.htMeta.dataSetNames),
+            _step8;
+          try {
+            for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+              var _this1$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;
+              if (hashTree && object.data) {
+                if (hashTree.putItem(object.htMeta.elementId)) {
+                  updatedMetadataObjects.push(object);
                 }
-              });
-              if (!isRosterDropped) {
-                _context6.next = 2;
-                break;
               }
-              _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " detected roster drop"));
-              this.stopAllTimers();
-
-              // in case of roster drop we don't care about other updates
-              return _context6.abrupt("return", {
-                updateType: LocusInfoUpdateType.MEETING_ENDED
+            }
+          } catch (err) {
+            _iterator8.e(err);
+          } finally {
+            _iterator8.f();
+          }
+        });
+        updatedObjects.push.apply(updatedObjects, updatedMetadataObjects);
+        var _this$checkForVisible2 = this.checkForVisibleDataSetChanges(updatedMetadataObjects),
+          changeDetected = _this$checkForVisible2.changeDetected,
+          removedDataSets = _this$checkForVisible2.removedDataSets,
+          addedDataSets = _this$checkForVisible2.addedDataSets;
+        if (changeDetected) {
+          dataSetsRequiringInitialization = this.processVisibleDataSetChanges(removedDataSets, addedDataSets, updatedObjects);
+        }
+      }
+      if (((_message$locusStateEl2 = message.locusStateElements) === null || _message$locusStateEl2 === void 0 ? void 0 : _message$locusStateEl2.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 (hashTree) {
+              var locusStateElementsForThisSet = message.locusStateElements.filter(function (object) {
+                return object.htMeta.dataSetNames.includes(dataSet.name);
               });
-            case 2:
-              if (dataSetsRequiringInitialization.length > 0) {
-                // there are some data sets that we need to initialize asynchronously
-                queueMicrotask(function () {
-                  _this7.initializeNewVisibleDataSets(message, dataSetsRequiringInitialization);
-                });
-              }
-              if (updatedObjects.length === 0) {
-                _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " No objects updated as a result of received message"));
-              }
-              return _context6.abrupt("return", {
-                updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
-                updatedObjects: updatedObjects
+              var appliedChangesList = hashTree.updateItems(locusStateElementsForThisSet.map(function (object) {
+                return object.data ? {
+                  operation: 'update',
+                  item: object.htMeta.elementId
+                } : {
+                  operation: 'remove',
+                  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];
+                if (changeApplied) {
+                  // add to updatedObjects so that our locus DTO will get updated with the new object
+                  updatedObjects.push(object);
+                }
               });
-            case 3:
-            case "end":
-              return _context6.stop();
+            } else {
+              _loggerProxy.default.logger.info("Locus-info:index#parseMessage --> ".concat(_this1.debugId, " unexpected (not visible) dataSet ").concat(dataSet.name, " received in hash tree message"));
+            }
           }
-        }, _callee5, this);
-      }));
-      function parseMessage(_x7, _x8) {
-        return _parseMessage.apply(this, arguments);
+          _this1.runSyncAlgorithm(dataSet);
+        });
       }
-      return parseMessage;
-    }()
+      if (dataSetsRequiringInitialization.length > 0) {
+        // there are some data sets that we need to initialize asynchronously
+        this.queueInitForNewVisibleDataSets(dataSetsRequiringInitialization);
+      }
+      if (updatedObjects.length === 0) {
+        _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " No objects updated as a result of received message"));
+      }
+      return updatedObjects;
+    }
+
     /**
      * Handles incoming hash tree messages, updates the hash trees and calls locusInfoUpdateCallback
      *
@@ -972,52 +1183,89 @@ var HashTreeParser = /*#__PURE__*/function () {
      * @param {string} [debugText] - Optional debug text to include in logs
      * @returns {void}
      */
-    )
   }, {
     key: "handleMessage",
-    value: (function () {
-      var _handleMessage = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6(message, debugText) {
-        var updates;
-        return _regenerator.default.wrap(function (_context7) {
-          while (1) switch (_context7.prev = _context7.next) {
-            case 0:
-              if (!(message.locusStateElements === undefined)) {
-                _context7.next = 1;
-                break;
-              }
-              this.handleRootHashHeartBeatMessage(message);
-              _context7.next = 3;
-              break;
-            case 1:
-              _context7.next = 2;
-              return this.parseMessage(message, debugText);
-            case 2:
-              updates = _context7.sent;
-              this.callLocusInfoUpdateCallback(updates);
-            case 3:
-            case "end":
-              return _context7.stop();
-          }
-        }, _callee6, this);
-      }));
-      function handleMessage(_x9, _x0) {
-        return _handleMessage.apply(this, arguments);
+    value: function handleMessage(message, debugText) {
+      if (this.state === 'stopped') {
+        return;
       }
-      return handleMessage;
-    }()
+      if (message.heartbeatIntervalMs) {
+        this.heartbeatIntervalMs = message.heartbeatIntervalMs;
+      }
+      if (this.isEndMessage(message)) {
+        _loggerProxy.default.logger.info("HashTreeParser#handleMessage --> ".concat(this.debugId, " received sentinel END MEETING message"));
+        this.stopAllTimers();
+        this.callLocusInfoUpdateCallback({
+          updateType: LocusInfoUpdateType.MEETING_ENDED
+        });
+      } else if (message.locusStateElements === undefined) {
+        this.handleRootHashHeartBeatMessage(message);
+        this.resetHeartbeatWatchdogs(message.dataSets);
+      } else {
+        var updatedObjects = this.parseMessage(message, debugText);
+        this.resetHeartbeatWatchdogs(message.dataSets);
+        this.callLocusInfoUpdateCallback({
+          updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
+          updatedObjects: updatedObjects
+        });
+      }
+    }
+
     /**
      * Calls the updateInfo callback if there are any updates to report
      *
      * @param {Object} updates parsed from a Locus message
      * @returns {void}
      */
-    )
   }, {
     key: "callLocusInfoUpdateCallback",
     value: function callLocusInfoUpdateCallback(updates) {
+      var _this10 = 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) {
+      if (updateType === LocusInfoUpdateType.OBJECTS_UPDATED && (updatedObjects === null || updatedObjects === void 0 ? void 0 : updatedObjects.length) > 0) {
+        // Filter out updates for objects that already have a higher version in their datasets,
+        // or removals for objects that still exist in any of their datasets
+        var filteredUpdates = updatedObjects.filter(function (object) {
+          var elementId = object.htMeta.elementId;
+          var type = elementId.type,
+            id = elementId.id,
+            version = elementId.version;
+
+          // Check all datasets
+          for (var _i2 = 0, _Object$keys3 = (0, _keys.default)(_this10.dataSets); _i2 < _Object$keys3.length; _i2++) {
+            var dataSetName = _Object$keys3[_i2];
+            var dataSet = _this10.dataSets[dataSetName];
+
+            // only visible datasets have hash trees set
+            if (dataSet !== null && dataSet !== void 0 && dataSet.hashTree) {
+              var existingVersion = dataSet.hashTree.getItemVersion(id, type);
+              if (existingVersion !== undefined) {
+                if (object.data) {
+                  // For updates: filter out if any dataset has a higher version
+                  if (existingVersion > version) {
+                    _loggerProxy.default.logger.info("HashTreeParser#callLocusInfoUpdateCallback --> ".concat(_this10.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));
+                  return false;
+                }
+              }
+            }
+          }
+          return true;
+        });
+        if (filteredUpdates.length > 0) {
+          this.locusInfoUpdateCallback(updateType, {
+            updatedObjects: filteredUpdates
+          });
+        }
+      } else if (updateType !== LocusInfoUpdateType.OBJECTS_UPDATED) {
         this.locusInfoUpdateCallback(updateType, {
           updatedObjects: updatedObjects
         });
@@ -1039,16 +1287,117 @@ var HashTreeParser = /*#__PURE__*/function () {
       return Math.round(Math.pow(randomValue, exponent) * maxMs);
     }
 
+    /**
+     * 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)
+     * @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) {
+            case 0:
+              if (dataSet.hashTree) {
+                _context6.next = 1;
+                break;
+              }
+              return _context6.abrupt("return");
+            case 1:
+              _context6.prev = 1;
+              _loggerProxy.default.logger.info("HashTreeParser#performSync --> ".concat(this.debugId, " ").concat(reason, ", syncing data set \"").concat(dataSet.name, "\""));
+              mismatchedLeavesData = {};
+              if (!(dataSet.leafCount !== 1)) {
+                _context6.next = 7;
+                break;
+              }
+              _context6.prev = 2;
+              _context6.next = 3;
+              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;
+                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:
+              throw _t3;
+            case 6:
+              // identify mismatched leaves
+              mismatchedLeaveIndexes = dataSet.hashTree.diffHashes(receivedHashes);
+              mismatchedLeaveIndexes.forEach(function (index) {
+                mismatchedLeavesData[index] = dataSet.hashTree.getLeafData(index);
+              });
+              _context6.next = 8;
+              break;
+            case 7:
+              mismatchedLeavesData[0] = dataSet.hashTree.getLeafData(0);
+            case 8:
+              if (!((0, _keys.default)(mismatchedLeavesData).length > 0)) {
+                _context6.next = 10;
+                break;
+              }
+              _context6.next = 9;
+              return this.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
+            case 9:
+              syncResponse = _context6.sent;
+              // sync API may return nothing (in that case data will arrive via messages)
+              // or it may return a response in the same format as messages
+              if (syncResponse) {
+                this.handleMessage(syncResponse, 'via sync API');
+              }
+            case 10:
+              _context6.next = 12;
+              break;
+            case 11:
+              _context6.prev = 11;
+              _t4 = _context6["catch"](1);
+              if (_t4 instanceof MeetingEndedError) {
+                this.callLocusInfoUpdateCallback({
+                  updateType: LocusInfoUpdateType.MEETING_ENDED
+                });
+              } else {
+                _loggerProxy.default.logger.warn("HashTreeParser#performSync --> ".concat(this.debugId, " error during sync for data set \"").concat(dataSet.name, "\":"), _t4);
+              }
+            case 12:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee5, this, [[1, 11], [2, 4]]);
+      }));
+      function performSync(_x6, _x7, _x8) {
+        return _performSync.apply(this, arguments);
+      }
+      return performSync;
+    }()
     /**
      * 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 _this8 = this;
+      var _this11 = 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"));
@@ -1069,93 +1418,99 @@ var HashTreeParser = /*#__PURE__*/function () {
           clearTimeout(dataSet.timer);
         }
         _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " setting \"").concat(dataSet.name, "\" sync timer for ").concat(delay));
-        dataSet.timer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
-          var rootHash, mismatchedLeavesData, receivedHashes, _yield$_this8$getHash, hashes, latestDataSetInfo, mismatchedLeaveIndexes, syncResponse, _t3;
-          return _regenerator.default.wrap(function (_context8) {
-            while (1) switch (_context8.prev = _context8.next) {
+        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) {
-                  _context8.next = 1;
+                  _context7.next = 1;
                   break;
                 }
-                _loggerProxy.default.logger.warn("HashTreeParser#runSyncAlgorithm --> ".concat(_this8.debugId, " Data set \"").concat(dataSet.name, "\" no longer has a hash tree, cannot run sync algorithm"));
-                return _context8.abrupt("return");
+                _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)) {
-                  _context8.next = 11;
+                  _context7.next = 3;
                   break;
                 }
-                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this8.debugId, " Root hash mismatch: received=").concat(dataSet.root, ", ours=").concat(rootHash, ", syncing data set \"").concat(dataSet.name, "\""));
-                mismatchedLeavesData = {};
-                if (!(dataSet.leafCount !== 1)) {
-                  _context8.next = 7;
-                  break;
-                }
-                _context8.prev = 2;
-                _context8.next = 3;
-                return _this8.getHashesFromLocus(dataSet.name);
-              case 3:
-                _yield$_this8$getHash = _context8.sent;
-                hashes = _yield$_this8$getHash.hashes;
-                latestDataSetInfo = _yield$_this8$getHash.dataSet;
-                receivedHashes = hashes;
-                dataSet.hashTree.resize(latestDataSetInfo.leafCount);
-                _context8.next = 6;
+                _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:
-                _context8.prev = 4;
-                _t3 = _context8["catch"](2);
-                if (!(_t3.statusCode === 409)) {
-                  _context8.next = 5;
-                  break;
-                }
-                // this is a leaf count mismatch, we should do nothing, just wait for another heartbeat message from Locus
-                _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this8.debugId, " Got 409 when fetching hashes for data set \"").concat(dataSet.name, "\": ").concat(_t3.message));
-                return _context8.abrupt("return");
-              case 5:
-                throw _t3;
-              case 6:
-                // identify mismatched leaves
-                mismatchedLeaveIndexes = dataSet.hashTree.diffHashes(receivedHashes);
-                mismatchedLeaveIndexes.forEach(function (index) {
-                  mismatchedLeavesData[index] = dataSet.hashTree.getLeafData(index);
-                });
-                _context8.next = 8;
-                break;
-              case 7:
-                mismatchedLeavesData[0] = dataSet.hashTree.getLeafData(0);
-              case 8:
-                if (!((0, _keys.default)(mismatchedLeavesData).length > 0)) {
-                  _context8.next = 10;
-                  break;
-                }
-                _context8.next = 9;
-                return _this8.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
-              case 9:
-                syncResponse = _context8.sent;
-                // sync API may return nothing (in that case data will arrive via messages)
-                // or it may return a response in the same format as messages
-                if (syncResponse) {
-                  _this8.handleMessage(syncResponse, 'via sync API');
-                }
-              case 10:
-                _context8.next = 12;
-                break;
-              case 11:
-                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this8.debugId, " \"").concat(dataSet.name, "\" root hash matching: ").concat(rootHash, ", version=").concat(dataSet.version));
-              case 12:
               case "end":
-                return _context8.stop();
+                return _context7.stop();
             }
-          }, _callee7, null, [[2, 4]]);
+          }, _callee6);
         })), delay);
       } else {
         _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " No delay for \"").concat(dataSet.name, "\" data set, skipping sync timer reset/setup"));
       }
     }
 
+    /**
+     * Resets the heartbeat watchdog timers for the specified data sets. Each data set has its own
+     * watchdog timer that monitors whether heartbeats are being received within the expected interval.
+     * If a heartbeat is not received for a specific data set within heartbeatIntervalMs plus
+     * a backoff-calculated time, the sync algorithm is initiated for that data set
+     *
+     * @param {Array<DataSet>} receivedDataSets - The data sets from the received message for which watchdog timers should be reset
+     * @returns {void}
+     */
+  }, {
+    key: "resetHeartbeatWatchdogs",
+    value: function resetHeartbeatWatchdogs(receivedDataSets) {
+      var _this12 = this;
+      if (!this.heartbeatIntervalMs) {
+        return;
+      }
+      var _iterator9 = _createForOfIteratorHelper(receivedDataSets),
+        _step9;
+      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
+          }
+          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);
+        };
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          if (_loop2()) continue;
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+    }
+
     /**
      * Stops all timers for the data sets to prevent any further sync attempts.
      * @returns {void}
@@ -1168,39 +1523,119 @@ var HashTreeParser = /*#__PURE__*/function () {
           clearTimeout(dataSet.timer);
           dataSet.timer = undefined;
         }
+        if (dataSet.heartbeatWatchdogTimer) {
+          clearTimeout(dataSet.heartbeatWatchdogTimer);
+          dataSet.heartbeatWatchdogTimer = undefined;
+        }
+      });
+    }
+
+    /**
+     * Stops the HashTreeParser, preventing it from processing any further messages and clearing all timers.
+     * It also clears all the hash trees, so if the parser is resumed later, it will need to do a sync
+     * to be up-to-date.
+     * @returns {void}
+     */
+  }, {
+    key: "stop",
+    value: function stop() {
+      _loggerProxy.default.logger.info("HashTreeParser#stop --> ".concat(this.debugId, " Stopping HashTreeParser, clearing timers and hash trees"));
+      this.stopAllTimers();
+      (0, _values.default)(this.dataSets).forEach(function (dataSet) {
+        dataSet.hashTree = undefined;
       });
+      this.visibleDataSets = [];
+      this.state = 'stopped';
+    }
+
+    /**
+     * Resumes the HashTreeParser that was previously stopped.
+     * @param {HashTreeMessage} message - The message to resume with, it must contain metadata with visible data sets info
+     * @returns {void}
+     */
+  }, {
+    key: "resume",
+    value: function resume(message) {
+      var _message$locusStateEl3, _metadataObject$data;
+      // 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"));
+        return;
+      }
+      this.setVisibleDataSets(metadataObject.data.visibleDataSets, message.dataSets);
+      this.dataSets = {};
+      var _iterator0 = _createForOfIteratorHelper(message.dataSets),
+        _step0;
+      try {
+        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+          var dataSet = _step0.value;
+          var name = dataSet.name,
+            leafCount = dataSet.leafCount;
+          this.dataSets[name] = _objectSpread(_objectSpread({}, dataSet), {}, {
+            hashTree: this.isVisibleDataSet(name) ? new _hashTree.default([], leafCount) : undefined
+          });
+        }
+      } catch (err) {
+        _iterator0.e(err);
+      } finally {
+        _iterator0.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) {
+        return ds.name;
+      }).join(', ')));
+      this.state = 'active';
+      this.handleMessage(message, 'on resume');
+    }
+  }, {
+    key: "checkForSentinelHttpResponse",
+    value: function checkForSentinelHttpResponse(error, dataSetName) {
+      var _error$body;
+      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"));
+        this.stopAllTimers();
+        throw new MeetingEndedError();
+      }
     }
 
     /**
      * Gets the current hashes from the locus for a specific data set.
      * @param {string} dataSetName
+     * @param {string} currentRootHash
      * @returns {string[]}
      */
   }, {
     key: "getHashesFromLocus",
-    value: function getHashesFromLocus(dataSetName) {
-      var _this9 = this;
+    value: function getHashesFromLocus(dataSetName, currentRootHash) {
+      var _this13 = this;
       _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(this.debugId, " Requesting hashes for data set \"").concat(dataSetName, "\""));
       var dataSet = this.dataSets[dataSetName];
       var url = "".concat(dataSet.url, "/hashtree");
       return this.webexRequest({
         method: _constants.HTTP_VERBS.GET,
-        uri: url
+        uri: url,
+        qs: {
+          rootHash: currentRootHash
+        }
       }).then(function (response) {
         var _response$body, _response$body2;
         var hashes = (_response$body = response.body) === null || _response$body === void 0 ? void 0 : _response$body.hashes;
         var dataSetFromResponse = (_response$body2 = response.body) === null || _response$body2 === void 0 ? void 0 : _response$body2.dataSet;
         if (!hashes || !(0, _isArray.default)(hashes)) {
-          _loggerProxy.default.logger.warn("HashTreeParser#getHashesFromLocus --> ".concat(_this9.debugId, " Locus returned invalid hashes, response body="), response.body);
+          _loggerProxy.default.logger.warn("HashTreeParser#getHashesFromLocus --> ".concat(_this13.debugId, " Locus returned invalid hashes, response body="), response.body);
           throw new Error("Locus returned invalid hashes: ".concat(hashes));
         }
-        _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this9.debugId, " Received hashes for data set \"").concat(dataSetName, "\": ").concat((0, _stringify.default)(hashes)));
+        _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this13.debugId, " Received hashes for data set \"").concat(dataSetName, "\": ").concat((0, _stringify.default)(hashes)));
         return {
           hashes: hashes,
           dataSet: dataSetFromResponse
         };
       }).catch(function (error) {
-        _loggerProxy.default.logger.error("HashTreeParser#getHashesFromLocus --> ".concat(_this9.debugId, " Error ").concat(error.statusCode, " fetching hashes for data set \"").concat(dataSetName, "\":"), error);
+        _loggerProxy.default.logger.error("HashTreeParser#getHashesFromLocus --> ".concat(_this13.debugId, " Error ").concat(error.statusCode, " fetching hashes for data set \"").concat(dataSetName, "\":"), error);
+        _this13.checkForSentinelHttpResponse(error, dataSet.name);
         throw error;
       });
     }
@@ -1215,7 +1650,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "sendSyncRequestToLocus",
     value: function sendSyncRequestToLocus(dataSet, mismatchedLeavesData) {
-      var _this0 = this;
+      var _this14 = this;
       _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(this.debugId, " Sending sync request for data set \"").concat(dataSet.name, "\""));
       var url = "".concat(dataSet.url, "/sync");
       var body = {
@@ -1228,19 +1663,24 @@ var HashTreeParser = /*#__PURE__*/function () {
           elementIds: mismatchedLeavesData[index]
         });
       });
+      var ourCurrentRootHash = dataSet.hashTree ? dataSet.hashTree.getRootHash() : _constants2.EMPTY_HASH;
       return this.webexRequest({
         method: _constants.HTTP_VERBS.POST,
         uri: url,
+        qs: {
+          rootHash: ourCurrentRootHash
+        },
         body: body
       }).then(function (resp) {
-        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this0.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
+        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this14.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
         if (!resp.body || (0, _lodash.isEmpty)(resp.body)) {
-          _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this0.debugId, " Got ").concat(resp.statusCode, " with empty body for sync request for data set \"").concat(dataSet.name, "\", data should arrive via messages"));
+          _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this14.debugId, " Got ").concat(resp.statusCode, " with empty body for sync request for data set \"").concat(dataSet.name, "\", data should arrive via messages"));
           return null;
         }
         return resp.body;
       }).catch(function (error) {
-        _loggerProxy.default.logger.error("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this0.debugId, " Error ").concat(error.statusCode, " sending sync request for data set \"").concat(dataSet.name, "\":"), error);
+        _loggerProxy.default.logger.error("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this14.debugId, " Error ").concat(error.statusCode, " sending sync request for data set \"").concat(dataSet.name, "\":"), error);
+        _this14.checkForSentinelHttpResponse(error, dataSet.name);
         throw error;
       });
     }