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

package/dist/locus-info/index.js

@@ -1,37 +1,40 @@
 "use strict";
 
 var _typeof = require("@babel/runtime-corejs2/helpers/typeof");
-var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+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$keys2 = 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");
 var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
 var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
-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 _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
 var _WeakMap = require("@babel/runtime-corejs2/core-js/weak-map");
 var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
+exports.createLocusFromHashTreeMessage = createLocusFromHashTreeMessage;
 exports.default = void 0;
+exports.findMeetingForHashTreeMessage = findMeetingForHashTreeMessage;
 var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
-var _map = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/map"));
-var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
-var _assign = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/assign"));
-var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
-var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
-var _isArray = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/array/is-array"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
 var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/assign"));
+var _map = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/map"));
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+var _isArray = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/array/is-array"));
 var _lodash = require("lodash");
 var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
 var _eventsScope = _interopRequireDefault(require("../common/events/events-scope"));
@@ -46,26 +49,190 @@ var _mediaSharesUtils = _interopRequireDefault(require("./mediaSharesUtils"));
 var _parser = _interopRequireDefault(require("./parser"));
 var _metrics = _interopRequireDefault(require("../metrics"));
 var _constants2 = _interopRequireDefault(require("../metrics/constants"));
-var _hashTreeParser = _interopRequireWildcard(require("../hashTree/hashTreeParser"));
+var _hashTreeParser2 = _interopRequireWildcard(require("../hashTree/hashTreeParser"));
 var _types = require("../hashTree/types");
 var _utils = require("../hashTree/utils");
+var _util = _interopRequireDefault(require("../meetings/util"));
 function _interopRequireWildcard(e, t) { if ("function" == typeof _WeakMap) var r = new _WeakMap(), n = new _WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = _Object$defineProperty) && _Object$getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function ownKeys(e, r) { var t = _Object$keys2(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; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function ownKeys(e, r) { var t = _Object$keys2(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 _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 // list of top level keys in Locus DTO relevant for Hash Tree DTOs processing
 // it does not contain fields specific to classic Locus DTOs like sequence or baseSequence
-var LocusDtoTopLevelKeys = ['controls', 'fullState', 'host', 'info', 'links', 'mediaShares', 'meetings', 'participants', 'replaces', 'self', 'sequence', 'syncUrl', 'url', 'htMeta' // only exists when hash trees are used
+var LocusDtoTopLevelKeys = ['controls', 'fullState', 'embeddedApps', 'host', 'info', 'links', 'mediaShares', 'meetings', 'participants', 'replaces', 'self', 'sequence', 'syncUrl', 'url', 'htMeta' // only exists when hash trees are used
 ];
+// when we invoke APIs on the whole Locus like "mute all" backend returns the whole Locus in the response like this
+
 var LocusObjectStateAfterUpdates = {
   unchanged: 'unchanged',
   removed: 'removed',
   updated: 'updated'
 };
+/**
+ * Gets the replacement information
+ *
+ * @param {any} self - "self" object from Locus DTO
+ * @param {string} deviceUrl - The URL of the user's device
+ * @returns {any} The replace information if available, otherwise undefined
+ */
+function getReplaceInfoFromSelf(self, deviceUrl) {
+  if (self) {
+    var _device$replaces;
+    var device = _util.default.getThisDevice({
+      self: self
+    }, deviceUrl);
+    if ((device === null || device === void 0 ? void 0 : (_device$replaces = device.replaces) === null || _device$replaces === void 0 ? void 0 : _device$replaces.length) > 0) {
+      return device.replaces[0];
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Finds a meeting by its locus URL in meeting collection. It checks all HashTreeParsers of all meetings in the collection.
+ *
+ * @param {MeetingCollection} meetingCollection - The collection of meetings to search
+ * @param {string} locusUrl - The locus URL to search for
+ * @returns {any} The meeting if found, otherwise undefined
+ */
+function findLocusUrlInAnyHashTreeParser(meetingCollection, locusUrl) {
+  for (var _i = 0, _arr = (0, _values.default)(meetingCollection.getAll()); _i < _arr.length; _i++) {
+    var _meeting$locusInfo, _meeting$locusInfo$ha;
+    var meeting = _arr[_i];
+    if (meeting !== null && meeting !== void 0 && (_meeting$locusInfo = meeting.locusInfo) !== null && _meeting$locusInfo !== void 0 && (_meeting$locusInfo$ha = _meeting$locusInfo.hashTreeParsers) !== null && _meeting$locusInfo$ha !== void 0 && _meeting$locusInfo$ha.has(locusUrl)) {
+      return meeting;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Finds a meeting for a given hash tree message.
+ *
+ * @param {HashTreeMessage} message - The hash tree message to find the meeting for
+ * @param {MeetingCollection} meetingCollection - The collection of meetings to search
+ * @param {string} deviceUrl - The URL of the user's device
+ * @returns {any} The meeting if found, otherwise undefined
+ */
+function findMeetingForHashTreeMessage(message, meetingCollection, deviceUrl) {
+  var _message$locusStateEl, _message$locusStateEl2;
+  var foundMeeting = findLocusUrlInAnyHashTreeParser(meetingCollection, message.locusUrl);
+  if (foundMeeting) {
+    return foundMeeting;
+  }
+
+  // if we haven't found anything, it may mean that message has a new locusUrl
+  // check if it indicates that it replaces some existing current locusUrl (this is indicated in "self")
+  var self = (_message$locusStateEl = message.locusStateElements) === null || _message$locusStateEl === void 0 ? void 0 : (_message$locusStateEl2 = _message$locusStateEl.find(function (el) {
+    return (0, _utils.isSelf)(el);
+  })) === null || _message$locusStateEl2 === void 0 ? void 0 : _message$locusStateEl2.data;
+  var replaces = getReplaceInfoFromSelf(self, deviceUrl);
+  if (replaces !== null && replaces !== void 0 && replaces.locusUrl) {
+    foundMeeting = findLocusUrlInAnyHashTreeParser(meetingCollection, replaces.locusUrl);
+    return foundMeeting;
+  }
+  return undefined;
+}
+
+/**
+ * Creates a locus object from the objects received in a hash tree message. It usually will be
+ * incomplete, because hash tree messages only contain the parts of locus that have changed,
+ * and some updates come separately over Mercury or LLM in separate messages.
+ *
+ * @param {HashTreeMessage} message hash tree message to created the locus from
+ * @returns {Object} the created locus object and metadata if present
+ */
+function createLocusFromHashTreeMessage(message) {
+  var locus = {
+    participants: [],
+    url: message.locusUrl
+  };
+  var metadata;
+  if (!message.locusStateElements) {
+    return {
+      locus: locus,
+      metadata: metadata
+    };
+  }
+  var _iterator = _createForOfIteratorHelper(message.locusStateElements),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var element = _step.value;
+      if (!element.data) {
+        // eslint-disable-next-line no-continue
+        return 1; // continue
+      }
+      var type = element.htMeta.elementId.type.toLowerCase();
+      switch (type) {
+        case _types.ObjectType.locus:
+          {
+            // spread locus object data onto the top level, but remove keys managed by other ObjectTypes
+            var locusObjectData = _objectSpread({}, element.data);
+            (0, _values.default)(_types.ObjectTypeToLocusKeyMap).forEach(function (locusDtoKey) {
+              delete locusObjectData[locusDtoKey];
+            });
+            (0, _assign.default)(locus, locusObjectData);
+            break;
+          }
+        case _types.ObjectType.participant:
+          locus.participants.push(element.data);
+          break;
+        case _types.ObjectType.mediaShare:
+          if (!locus.mediaShares) {
+            locus.mediaShares = [];
+          }
+          locus.mediaShares.push(element.data);
+          break;
+        case _types.ObjectType.embeddedApp:
+          if (!locus.embeddedApps) {
+            locus.embeddedApps = [];
+          }
+          locus.embeddedApps.push(element.data);
+          break;
+        case _types.ObjectType.control:
+          if (!locus.controls) {
+            locus.controls = {};
+          }
+          (0, _assign.default)(locus.controls, element.data);
+          break;
+        case _types.ObjectType.links:
+        case _types.ObjectType.info:
+        case _types.ObjectType.fullState:
+        case _types.ObjectType.self:
+          {
+            var locusDtoKey = _types.ObjectTypeToLocusKeyMap[type];
+            locus[locusDtoKey] = element.data;
+            break;
+          }
+        case _types.ObjectType.metadata:
+          // metadata is not part of Locus DTO
+          metadata = _objectSpread(_objectSpread({}, element.data), {}, {
+            htMeta: element.htMeta
+          });
+          break;
+        default:
+          break;
+      }
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      if (_loop()) continue;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    locus: locus,
+    metadata: metadata
+  };
+}
+
 /**
  * @description LocusInfo extends ChildEmitter to convert locusInfo info a private emitter to parent object
  * @export
@@ -110,7 +277,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     (0, _defineProperty2.default)(_this, "links", void 0);
     (0, _defineProperty2.default)(_this, "mainSessionLocusCache", void 0);
     (0, _defineProperty2.default)(_this, "self", void 0);
-    (0, _defineProperty2.default)(_this, "hashTreeParser", void 0);
+    (0, _defineProperty2.default)(_this, "hashTreeParsers", void 0);
     (0, _defineProperty2.default)(_this, "hashTreeObjectId2ParticipantId", void 0);
     // mapping of hash tree object ids to participant ids
     (0, _defineProperty2.default)(_this, "classicVsHashTreeMismatchMetricCounter", 0);
@@ -123,6 +290,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     _this.meetingId = meetingId;
     _this.updateMeeting = updateMeeting;
     _this.locusParser = new _parser.default();
+    _this.hashTreeParsers = new _map.default();
     _this.hashTreeObjectId2ParticipantId = new _map.default();
     return _this;
   }
@@ -210,7 +378,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
           // in some cases Locus might return us full DTO even when we asked for a delta
           _loggerProxy.default.logger.info('Locus-info:index#doLocusSync --> got full DTO when we asked for delta');
         }
-        meeting.locusInfo.onFullLocus(res.body);
+        meeting.locusInfo.onFullLocus('classic Locus sync', res.body);
       }).catch(function (e) {
         _loggerProxy.default.logger.info("Locus-info:index#doLocusSync --> getLocusDTO succeeded but failed to handle result, locus parser will resume but not all data may be synced (".concat(e.toString(), ")"));
         _metrics.default.sendBehavioralMetric(_constants2.default.LOCUS_SYNC_HANDLING_FAILED, {
@@ -332,20 +500,60 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     }
 
     /**
-     * Creates the HashTreeParser instance.
-     * @param {Object} initial locus data
-     * @returns {void}
+     * Creates a HashTreeParser instance for a given locusUrl and stores it in the map.
+     * @param {Object} params
+     * @param {string} params.locusUrl - the locus URL used as the map key
+     * @param {Object} params.initialLocus - initial locus data
+     * @param {Object} params.metadata - hash tree metadata
+     * @param {string} params.replacedAt - timestamp from Locus indicating when the replacement happened
+     * @returns {HashTreeParser} the newly created parser
      */
   }, {
     key: "createHashTreeParser",
     value: function createHashTreeParser(_ref) {
-      var initialLocus = _ref.initialLocus;
-      return new _hashTreeParser.default({
+      var _this$webex$config$me;
+      var locusUrl = _ref.locusUrl,
+        initialLocus = _ref.initialLocus,
+        metadata = _ref.metadata,
+        replacedAt = _ref.replacedAt;
+      var parser = new _hashTreeParser2.default({
         initialLocus: initialLocus,
+        metadata: metadata,
         webexRequest: this.webex.request.bind(this.webex),
-        locusInfoUpdateCallback: this.updateFromHashTree.bind(this),
-        debugId: "HT-".concat(this.meetingId.substring(0, 4))
+        locusInfoUpdateCallback: this.updateFromHashTree.bind(this, locusUrl),
+        debugId: "HT-".concat(locusUrl.split('/').pop().substring(0, 4)),
+        excludedDataSets: (_this$webex$config$me = this.webex.config.meetings.locus) === null || _this$webex$config$me === void 0 ? void 0 : _this$webex$config$me.excludedDataSets
       });
+
+      // When a new HashTreeParser is created, previous one should be stopped.
+      // Locus will only be sending us updates for the current one.
+      var _iterator2 = _createForOfIteratorHelper(this.hashTreeParsers),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = (0, _slicedToArray2.default)(_step2.value, 2),
+            existingLocusUrl = _step2$value[0],
+            existingEntry = _step2$value[1];
+          if (existingEntry.parser.state !== 'stopped') {
+            existingEntry.parser.stop();
+            if (replacedAt) {
+              existingEntry.replacedAt = replacedAt;
+            } else {
+              _loggerProxy.default.logger.warn("Locus-info:index#createHashTreeParser --> no replacedAt timestamp provided for new HashTreeParser with locusUrl ".concat(locusUrl, ", replacing ").concat(existingLocusUrl));
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      this.hashTreeParsers.set(locusUrl, {
+        parser: parser,
+        initializedFromHashTree: false
+      });
+      this.hashTreeObjectId2ParticipantId.clear();
+      return parser;
     }
 
     /**
@@ -358,7 +566,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     value: (function () {
       var _initialSetup = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(data) {
         var _data$locus, _data$locus$links, _data$locus$links$res, _data$locus$links$res2;
-        var _data$hashTreeMessage, _selfObject$data, selfObject, _data$locus2, _data$locus2$self, _t;
+        var _data$hashTreeMessage, _metadataObject$data, metadataObject, hashTreeParser, _hashTreeParser, _t;
         return _regenerator.default.wrap(function (_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
@@ -370,47 +578,49 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
                 _context.next = 4;
                 break;
               }
-              // we need the SELF object to be in the received message, because it contains visibleDataSets
+              // we need the Metadata object to be in the received message, because it contains visibleDataSets
               // and these are needed to initialize all the hash trees
-              selfObject = (_data$hashTreeMessage = data.hashTreeMessage.locusStateElements) === null || _data$hashTreeMessage === void 0 ? void 0 : _data$hashTreeMessage.find(function (el) {
-                return (0, _utils.isSelf)(el);
+              metadataObject = (_data$hashTreeMessage = data.hashTreeMessage.locusStateElements) === null || _data$hashTreeMessage === void 0 ? void 0 : _data$hashTreeMessage.find(function (el) {
+                return (0, _utils.isMetadata)(el);
               });
-              if (selfObject !== null && selfObject !== void 0 && (_selfObject$data = selfObject.data) !== null && _selfObject$data !== void 0 && _selfObject$data.visibleDataSets) {
+              if (metadataObject !== null && metadataObject !== void 0 && (_metadataObject$data = metadataObject.data) !== null && _metadataObject$data !== void 0 && _metadataObject$data.visibleDataSets) {
                 _context.next = 2;
                 break;
               }
-              _loggerProxy.default.logger.warn("Locus-info:index#initialSetup --> cannot initialize HashTreeParser, SELF object with visibleDataSets is missing in the message");
-              throw new Error('SELF object with visibleDataSets is missing in the message');
+              // this is a common case (not an error)
+              // it happens for example after we leave the meeting and still get some heartbeats or delayed messages
+              _loggerProxy.default.logger.info("Locus-info:index#initialSetup --> cannot initialize HashTreeParser, Metadata object with visibleDataSets is missing in the message");
+
+              // throw so that handleLocusEvent() catches it and destroys the partially created meeting object
+              throw new Error('Metadata object with visibleDataSets is missing in the message');
             case 2:
               _loggerProxy.default.logger.info('Locus-info:index#initialSetup --> creating HashTreeParser from message');
               // first create the HashTreeParser, but don't initialize it with any data yet
-              // pass just a fake locus that contains only the visibleDataSets
-              this.hashTreeParser = this.createHashTreeParser({
+              hashTreeParser = this.createHashTreeParser({
+                locusUrl: data.hashTreeMessage.locusUrl,
                 initialLocus: {
-                  locus: {
-                    self: {
-                      visibleDataSets: selfObject.data.visibleDataSets
-                    }
-                  },
-                  dataSets: [] // empty, because they will be populated in initializeFromMessage() call  // dataSets: data.hashTreeMessage.dataSets,
+                  locus: null,
+                  dataSets: data.hashTreeMessage.dataSets
+                },
+                metadata: {
+                  htMeta: metadataObject.htMeta,
+                  visibleDataSets: metadataObject.data.visibleDataSets
                 }
-              });
-
-              // now handle the message - that should populate all the visible datasets
+              }); // now handle the message - that should populate all the visible datasets
               _context.next = 3;
-              return this.hashTreeParser.initializeFromMessage(data.hashTreeMessage);
+              return hashTreeParser.initializeFromMessage(data.hashTreeMessage);
             case 3:
               _context.next = 5;
               break;
             case 4:
               // "classic" Locus case, no hash trees involved
               this.updateLocusCache(data.locus);
-              this.onFullLocus(data.locus, undefined);
+              this.onFullLocus('classic locus message', data.locus, undefined);
             case 5:
               return _context.abrupt("continue", 10);
             case 6:
               this.updateLocusCache(data.locus);
-              this.onFullLocus(data.locus, undefined, data.dataSets);
+              this.onFullLocus('join response', data.locus, undefined, data.dataSets, data.metadata);
               return _context.abrupt("continue", 10);
             case 7:
               if (!((_data$locus = data.locus) !== null && _data$locus !== void 0 && (_data$locus$links = _data$locus.links) !== null && _data$locus$links !== void 0 && (_data$locus$links$res = _data$locus$links.resources) !== null && _data$locus$links$res !== void 0 && (_data$locus$links$res2 = _data$locus$links$res.visibleDataSets) !== null && _data$locus$links$res2 !== void 0 && _data$locus$links$res2.url)) {
@@ -419,28 +629,23 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
               }
               _loggerProxy.default.logger.info('Locus-info:index#initialSetup --> creating HashTreeParser from get-loci-response');
               // first create the HashTreeParser, but don't initialize it with any data yet
-              // pass just a fake locus that contains only the visibleDataSets
-              this.hashTreeParser = this.createHashTreeParser({
+              _hashTreeParser = this.createHashTreeParser({
+                locusUrl: data.locus.url,
                 initialLocus: {
-                  locus: {
-                    self: {
-                      visibleDataSets: (_data$locus2 = data.locus) === null || _data$locus2 === void 0 ? void 0 : (_data$locus2$self = _data$locus2.self) === null || _data$locus2$self === void 0 ? void 0 : _data$locus2$self.visibleDataSets
-                    }
-                  },
+                  locus: null,
                   dataSets: [] // empty, because we don't have them yet
-                }
-              });
-
-              // now initialize all the data
+                },
+                metadata: null // get-loci-response doesn't contain Metadata object
+              }); // now initialize all the data
               _context.next = 8;
-              return this.hashTreeParser.initializeFromGetLociResponse(data.locus);
+              return _hashTreeParser.initializeFromGetLociResponse(data.locus);
             case 8:
               _context.next = 10;
               break;
             case 9:
               // "classic" Locus case, no hash trees involved
               this.updateLocusCache(data.locus);
-              this.onFullLocus(data.locus, undefined);
+              this.onFullLocus('classic get-loci-response', data.locus, undefined);
             case 10:
               // Change it to true after it receives it first locus object
               this.emitChange = true;
@@ -465,25 +670,36 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "handleLocusAPIResponse",
     value: function handleLocusAPIResponse(meeting, responseBody) {
-      if (this.hashTreeParser) {
-        if (!responseBody.dataSets) {
-          this.sendClassicVsHashTreeMismatchMetric(meeting, "expected hash tree dataSets in API response but they are missing");
-          // continuing as we can still manage without responseBody.dataSets, but this is very suspicious
-        }
-        _loggerProxy.default.logger.info('Locus-info:index#handleLocusAPIResponse --> passing Locus API response to HashTreeParser: ', responseBody);
-        // update the data in our hash trees
-        this.hashTreeParser.handleLocusUpdate(responseBody);
+      var _responseBody$locus;
+      var isWrapped = 'locus' in responseBody;
+      var locusUrl = isWrapped ? (_responseBody$locus = responseBody.locus) === null || _responseBody$locus === void 0 ? void 0 : _responseBody$locus.url : responseBody.url;
+      var hashTreeParserEntry = locusUrl && this.hashTreeParsers.get(locusUrl);
+      if (hashTreeParserEntry) {
+        if (isWrapped) {
+          if (!responseBody.dataSets) {
+            this.sendClassicVsHashTreeMismatchMetric(meeting, "expected hash tree dataSets in API response but they are missing");
+            // continuing as we can still manage without responseBody.dataSets, but this is very suspicious
+          }
+          _loggerProxy.default.logger.info('Locus-info:index#handleLocusAPIResponse --> passing Locus API response to HashTreeParser: ', responseBody);
+          // update the data in our hash trees
+          hashTreeParserEntry.parser.handleLocusUpdate(responseBody);
+        } else {
+          // LocusDTO without wrapper - pass it through as if it had no dataSets
+          hashTreeParserEntry.parser.handleLocusUpdate({
+            locus: responseBody
+          });
+        }
       } else {
-        if (responseBody.dataSets) {
+        if (isWrapped && responseBody.dataSets) {
           this.sendClassicVsHashTreeMismatchMetric(meeting, "unexpected hash tree dataSets in API response");
         }
         // classic Locus delta
-        this.handleLocusDelta(responseBody.locus, meeting);
+        var locus = isWrapped ? responseBody.locus : responseBody;
+        this.handleLocusDelta(locus, meeting);
       }
     }
 
     /**
-     *
      * @param {HashTreeObject} object data set object
      * @param {any} locus
      * @returns {void}
@@ -491,7 +707,8 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "updateLocusFromHashTreeObject",
     value: function updateLocusFromHashTreeObject(object, locus) {
-      var _this4 = this;
+      var _this4 = this,
+        _locus$self;
       var type = object.htMeta.elementId.type.toLowerCase();
       var addParticipantObject = function addParticipantObject(obj) {
         if (!locus.participants) {
@@ -543,6 +760,27 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
             });
           }
           break;
+        case _types.ObjectType.embeddedApp:
+          if (object.data) {
+            var _locus$embeddedApps;
+            _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> embeddedApp id=".concat(object.htMeta.elementId.id, " url='").concat(object.data.url, "' updated version=").concat(object.htMeta.elementId.version, ":"), object.data);
+            var existingEmbeddedApp = (_locus$embeddedApps = locus.embeddedApps) === null || _locus$embeddedApps === void 0 ? void 0 : _locus$embeddedApps.find(function (ms) {
+              return ms.htMeta.elementId.id === object.htMeta.elementId.id;
+            });
+            if (existingEmbeddedApp) {
+              (0, _assign.default)(existingEmbeddedApp, object.data);
+            } else {
+              locus.embeddedApps = locus.embeddedApps || [];
+              locus.embeddedApps.push(object.data);
+            }
+          } else {
+            var _locus$embeddedApps2;
+            _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> embeddedApp id=".concat(object.htMeta.elementId.id, " removed, version=").concat(object.htMeta.elementId.version));
+            locus.embeddedApps = (_locus$embeddedApps2 = locus.embeddedApps) === null || _locus$embeddedApps2 === void 0 ? void 0 : _locus$embeddedApps2.filter(function (ms) {
+              return ms.htMeta.elementId.id !== object.htMeta.elementId.id;
+            });
+          }
+          break;
         case _types.ObjectType.participant:
           _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> participant id=".concat(object.htMeta.elementId.id, " ").concat(object.data ? 'updated' : 'removed', " version=").concat(object.htMeta.elementId.version));
           if (object.data) {
@@ -557,6 +795,16 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
             locus.jsSdkMeta.removedParticipantIds.push(participantId);
             this.hashTreeObjectId2ParticipantId.delete(object.htMeta.elementId.id);
           }
+          // Create self from the participant if it matches self identity and is being moved.
+          // We need this, because participant update comes in LLM message often before the self update from Mercury.
+          // Other parts of the code detect move only by looking at self, while some other parts of the SDK/webapp code
+          // look at participant for roles etc, so if participant is updated but not self, then it looks like we our lost roles temporarily
+          // (until self is updated)
+          // This will be fixed properly in SPARK-790239
+          if (object.data && object.data.identity === ((_locus$self = locus.self) === null || _locus$self === void 0 ? void 0 : _locus$self.identity) && object.data.state === 'LEFT' && object.data.reason === 'MOVED') {
+            _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> FOUND a match for MOVED self in participant object ".concat(object.htMeta.elementId.id));
+            (0, _assign.default)(locus[_types.ObjectTypeToLocusKeyMap[_types.ObjectType.self]], object.data);
+          }
           break;
         case _types.ObjectType.control:
           if (object.data) {
@@ -598,6 +846,10 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
             }
           }
           break;
+        case _types.ObjectType.metadata:
+          _loggerProxy.default.logger.info("Locus-info:index#updateLocusFromHashTreeObject --> metadata object updated to version ".concat(object.htMeta.elementId.version));
+          // we don't use hash tree metadata right now for anything, it's mainly used internally by HashTreeParser
+          break;
         default:
           _loggerProxy.default.logger.warn("Locus-info:index#updateLocusFromHashTreeObject --> received unsupported object type ".concat(type));
           break;
@@ -627,6 +879,77 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       }
     }
 
+    /**
+     * Checks if the hash tree message should trigger a switch to a different HashTreeParser
+     *
+     * @param {HashTreeMessage} message incoming hash tree message
+     * @returns {boolean} true if the message was handled as a parser switch, false otherwise
+     */
+  }, {
+    key: "handleHashTreeParserSwitch",
+    value: function handleHashTreeParserSwitch(message) {
+      var _message$locusStateEl3, _message$locusStateEl4;
+      var entry = this.hashTreeParsers.get(message.locusUrl);
+      var self = (_message$locusStateEl3 = message.locusStateElements) === null || _message$locusStateEl3 === void 0 ? void 0 : (_message$locusStateEl4 = _message$locusStateEl3.find(function (el) {
+        return (0, _utils.isSelf)(el);
+      })) === null || _message$locusStateEl4 === void 0 ? void 0 : _message$locusStateEl4.data;
+      var replaces = getReplaceInfoFromSelf(self,
+      // @ts-ignore
+      this.webex.internal.device.url);
+      if (!entry) {
+        var _message$locusStateEl5, _metadata$data, _metadata$data$visibl;
+        // Metadata object that contains information about visible datasets is needed to initialize the HashTreeParser,
+        // but it's buried inside the message, we need to find it and pass it to HashTreeParser constructor
+        var metadata = (_message$locusStateEl5 = message.locusStateElements) === null || _message$locusStateEl5 === void 0 ? void 0 : _message$locusStateEl5.find(function (el) {
+          return (0, _utils.isMetadata)(el);
+        });
+        if ((metadata === null || metadata === void 0 ? void 0 : (_metadata$data = metadata.data) === null || _metadata$data === void 0 ? void 0 : (_metadata$data$visibl = _metadata$data.visibleDataSets) === null || _metadata$data$visibl === void 0 ? void 0 : _metadata$data$visibl.length) > 0) {
+          _loggerProxy.default.logger.info("Locus-info:index#handleHashTreeParserSwitch --> no hash tree parser found for locusUrl ".concat(message.locusUrl, ", creating a new one"));
+          var parser = this.createHashTreeParser({
+            locusUrl: message.locusUrl,
+            initialLocus: {
+              locus: null,
+              dataSets: message.dataSets
+            },
+            metadata: {
+              htMeta: metadata.htMeta,
+              visibleDataSets: metadata.data.visibleDataSets
+            },
+            replacedAt: replaces === null || replaces === void 0 ? void 0 : replaces.replacedAt
+          });
+
+          // handle the message with the new parser
+          parser.handleMessage(message);
+        }
+        return true;
+      }
+      if (entry.parser.state === 'stopped') {
+        // the message matches a stopped parser, we need to check if maybe this is a new "replacement" and we need to re-activate the parser
+        // this happens when you move from breakout A -> breakout B -> back to breakout A
+        if (replaces) {
+          if (replaces.replacedAt > (entry.replacedAt || '')) {
+            _loggerProxy.default.logger.info("Locus-info:index#handleHashTreeParserSwitch --> resuming a HashTreeParser for locusUrl=".concat(message.locusUrl, ", which replaces ").concat(replaces.locusUrl));
+            var replacedEntry = this.hashTreeParsers.get(replaces.locusUrl);
+            if (replacedEntry) {
+              replacedEntry.replacedAt = replaces.replacedAt;
+              entry.initializedFromHashTree = false;
+              this.hashTreeObjectId2ParticipantId.clear();
+              replacedEntry.parser.stop();
+              entry.parser.resume(message);
+            } else {
+              _loggerProxy.default.logger.warn("Locus-info:index#handleHashTreeParserSwitch --> the parser that is supposed to be replaced with the currently resumed parser is not found, locusUrl=".concat(replaces.locusUrl));
+            }
+          } else {
+            _loggerProxy.default.logger.info("Locus-info:index#handleHashTreeParserSwitch --> received message for stopped HashTreeParser with locusUrl ".concat(message.locusUrl, ", but replaces info provided is not newer, so not re-activating the parser"));
+          }
+          return true;
+        }
+        _loggerProxy.default.logger.info("Locus-info:index#handleHashTreeParserSwitch --> received message for stopped HashTreeParser with locusUrl ".concat(message.locusUrl, ", but no replaces info provided, so not re-activating the parser"));
+        return true;
+      }
+      return false;
+    }
+
     /**
      * Handles a hash tree message received from Locus.
      *
@@ -642,29 +965,36 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
         this.sendClassicVsHashTreeMismatchMetric(meeting, "got ".concat(eventType, ", expected ").concat(_constants.LOCUSEVENT.HASH_TREE_DATA_UPDATED));
         return;
       }
-      this.hashTreeParser.handleMessage(message);
+      var parserSwitched = this.handleHashTreeParserSwitch(message);
+      if (parserSwitched) {
+        return;
+      }
+      var entry = this.hashTreeParsers.get(message.locusUrl);
+      entry.parser.handleMessage(message);
     }
 
     /**
      * Callback registered with HashTreeParser to receive locus info updates.
      * Updates our locus info based on the data parsed by the hash tree parser.
      *
+     * @param {string} locusUrl - the locus URL for which the update is received
      * @param {LocusInfoUpdateType} updateType - The type of update received.
      * @param {Object} [data] - Additional data for the update, if applicable.
      * @returns {void}
      */
   }, {
     key: "updateFromHashTree",
-    value: function updateFromHashTree(updateType, data) {
+    value: function updateFromHashTree(locusUrl, updateType, data) {
       var _this5 = this;
       switch (updateType) {
-        case _hashTreeParser.LocusInfoUpdateType.OBJECTS_UPDATED:
+        case _hashTreeParser2.LocusInfoUpdateType.OBJECTS_UPDATED:
           {
             // initialize our new locus
             var locus = {
               participants: [],
               jsSdkMeta: {
-                removedParticipantIds: []
+                removedParticipantIds: [],
+                forceReplaceMembers: false
               }
             };
 
@@ -690,13 +1020,21 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
                 }
               }
             });
-
+            var hashTreeParserEntry = this.hashTreeParsers.get(locusUrl);
+            if (!hashTreeParserEntry.initializedFromHashTree) {
+              // this is the first time we're getting an update for this locusUrl,
+              // so it's probably a move to/from breakout. We need to start from a clean state,
+              // so empty locus and we rely on Locus giving us sufficient data in the updates to populate it.
+              _loggerProxy.default.logger.info("Locus-info:index#updateFromHashTree --> first INITIAL update for locusUrl ".concat(locusUrl, ", starting from empty state"));
+              hashTreeParserEntry.initializedFromHashTree = true;
+              locus.jsSdkMeta.forceReplaceMembers = true;
+            } else if (
             // if Locus object is unchanged or removed, we need to keep using the existing locus
             // because the rest of the locusInfo code expects locus to always be present (with at least some of the fields)
             // if it gets updated, we only need to have the fields that are not part of "locus" object (like "info" or "mediaShares")
             // so that when Locus object gets updated, if the new one is missing some field, that field will
             // be removed from our locusInfo
-            if (locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.unchanged || locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.removed) {
+            locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.unchanged || locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.removed) {
               // copy over all of existing locus except participants
               LocusDtoTopLevelKeys.forEach(function (key) {
                 if (key !== 'participants') {
@@ -728,11 +1066,13 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
             this.onDeltaLocus(locus);
             break;
           }
-        case _hashTreeParser.LocusInfoUpdateType.MEETING_ENDED:
+        case _hashTreeParser2.LocusInfoUpdateType.MEETING_ENDED:
           {
-            _loggerProxy.default.logger.info("Locus-info:index#updateFromHashTree --> received signal that meeting ended, destroying meeting ".concat(this.meetingId));
             var meeting = this.webex.meetings.meetingCollection.get(this.meetingId);
-            this.webex.meetings.destroy(meeting, _constants.MEETING_REMOVED_REASON.SELF_REMOVED);
+            if (meeting) {
+              _loggerProxy.default.logger.info("Locus-info:index#updateFromHashTree --> received signal that meeting ended, destroying meeting ".concat(this.meetingId));
+              this.webex.meetings.destroy(meeting, _constants.MEETING_REMOVED_REASON.SELF_REMOVED);
+            }
           }
       }
     }
@@ -746,11 +1086,16 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "parse",
     value: function parse(meeting, data) {
-      if (this.hashTreeParser) {
+      if (this.hashTreeParsers.size > 0) {
         this.handleHashTreeMessage(meeting, data.eventType, data.stateElementsMessage);
       } else {
-        // eslint-disable-next-line @typescript-eslint/no-shadow
         var eventType = data.eventType;
+        if (eventType === _constants.LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
+          // this can happen when we get an event before join http response
+          // it's OK to just ignore it
+          _loggerProxy.default.logger.info("Locus-info:index#parse --> received locus hash tree event before hashTreeParser is created");
+          return;
+        }
         var locus = this.getTheLocusToUpdate(data.locus);
         _loggerProxy.default.logger.info("Locus-info:index#parse --> received locus data: ".concat(eventType));
         locus.jsSdkMeta = {
@@ -771,14 +1116,11 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
           case _constants.LOCUSEVENT.PARTICIPANT_DECLINED:
           case _constants.LOCUSEVENT.FLOOR_GRANTED:
           case _constants.LOCUSEVENT.FLOOR_RELEASED:
-            this.onFullLocus(locus, eventType);
+            this.onFullLocus("classic locus event ".concat(eventType), locus, eventType);
             break;
           case _constants.LOCUSEVENT.DIFFERENCE:
             this.handleLocusDelta(locus, meeting);
             break;
-          case _constants.LOCUSEVENT.HASH_TREE_DATA_UPDATED:
-            this.sendClassicVsHashTreeMismatchMetric(meeting, "got ".concat(eventType, ", expected classic events"));
-            break;
           default:
             // Why will there be a event with no eventType ????
             // we may not need this, we can get full locus
@@ -803,32 +1145,39 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     /**
      * Function for handling full locus when it's using hash trees (so not the "classic" one).
      *
+     * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
      * @param {object} locus locus object
+     * @param {object} metadata locus hash trees metadata
      * @param {string} eventType locus event
      * @param {DataSet[]} dataSets
      * @returns {void}
      */
   }, {
     key: "onFullLocusWithHashTrees",
-    value: function onFullLocusWithHashTrees(locus, eventType, dataSets) {
-      if (!this.hashTreeParser) {
-        _loggerProxy.default.logger.info("Locus-info:index#onFullLocus --> creating hash tree parser");
-        _loggerProxy.default.logger.info('Locus-info:index#onFullLocus --> dataSets:', dataSets, ' and locus:', locus);
-        this.hashTreeParser = this.createHashTreeParser({
+    value: function onFullLocusWithHashTrees(debugText, locus, metadata, eventType, dataSets) {
+      if (!this.hashTreeParsers.has(locus.url)) {
+        _loggerProxy.default.logger.info("Locus-info:index#onFullLocus (".concat(debugText, ") --> creating hash tree parser for locusUrl=").concat(locus.url));
+        _loggerProxy.default.logger.info("Locus-info:index#onFullLocus (".concat(debugText, ") --> dataSets:"), dataSets, ' and locus:', locus, ' and metadata:', metadata);
+        this.createHashTreeParser({
+          locusUrl: locus.url,
           initialLocus: {
             locus: locus,
             dataSets: dataSets
-          }
+          },
+          metadata: metadata
         });
+        // we have a full locus to start with, so we consider Locus info to be "initialized"
+        this.hashTreeParsers.get(locus.url).initializedFromHashTree = true;
         this.onFullLocusCommon(locus, eventType);
       } else {
         // in this case the Locus we're getting is not necessarily the full one
         // so treat it like if we just got it in any api response
 
-        _loggerProxy.default.logger.info('Locus-info:index#onFullLocus --> hash tree parser already exists, handling it like a normal API response');
+        _loggerProxy.default.logger.info("Locus-info:index#onFullLocus (".concat(debugText, ") --> hash tree parser already exists, handling it like a normal API response"));
         this.handleLocusAPIResponse(undefined, {
           dataSets: dataSets,
-          locus: locus
+          locus: locus,
+          metadata: metadata
         });
       }
     }
@@ -836,15 +1185,16 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     /**
      * Function for handling full locus when it's the "classic" one (not hash trees)
      *
+     * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
      * @param {object} locus locus object
      * @param {string} eventType locus event
      * @returns {void}
      */
   }, {
     key: "onFullLocusClassic",
-    value: function onFullLocusClassic(locus, eventType) {
+    value: function onFullLocusClassic(debugText, locus, eventType) {
       if (!this.locusParser.isNewFullLocus(locus)) {
-        _loggerProxy.default.logger.info("Locus-info:index#onFullLocus --> ignoring old full locus DTO, eventType=".concat(eventType));
+        _loggerProxy.default.logger.info("Locus-info:index#onFullLocus (".concat(debugText, ") --> ignoring old full locus DTO, eventType=").concat(eventType));
         return;
       }
       this.onFullLocusCommon(locus, eventType);
@@ -852,23 +1202,28 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
 
     /**
      * updates the locus with full locus object
+     * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
      * @param {object} locus locus object
      * @param {string} eventType locus event
      * @param {DataSet[]} dataSets
+     * @param {object} metadata locus hash trees metadata
      * @returns {object} null
      * @memberof LocusInfo
      */
   }, {
     key: "onFullLocus",
-    value: function onFullLocus(locus, eventType, dataSets) {
+    value: function onFullLocus(debugText, locus, eventType, dataSets, metadata) {
       if (!locus) {
-        _loggerProxy.default.logger.error('Locus-info:index#onFullLocus --> object passed as argument was invalid, continuing.');
+        _loggerProxy.default.logger.error("Locus-info:index#onFullLocus (".concat(debugText, ") --> object passed as argument was invalid, continuing."));
       }
       if (dataSets) {
+        if (!metadata) {
+          throw new Error("Locus-info:index#onFullLocus (".concat(debugText, ") --> hash tree metadata is missing with full Locus"));
+        }
         // this is the new hashmap Locus DTO format (only applicable to webinars for now)
-        this.onFullLocusWithHashTrees(locus, eventType, dataSets);
+        this.onFullLocusWithHashTrees(debugText, locus, metadata, eventType, dataSets);
       } else {
-        this.onFullLocusClassic(locus, eventType);
+        this.onFullLocusClassic(debugText, locus, eventType);
       }
     }
 
@@ -889,7 +1244,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       (_this$participants = this.participants) === null || _this$participants === void 0 ? void 0 : _this$participants.forEach(function (participant) {
         var _participant$htMeta;
         // participant.htMeta is set only for hash tree based locus
-        if ((_participant$htMeta = participant.htMeta) !== null && _participant$htMeta !== void 0 && _participant$htMeta.elementId.id) {
+        if (typeof ((_participant$htMeta = participant.htMeta) === null || _participant$htMeta === void 0 ? void 0 : _participant$htMeta.elementId.id) === 'number') {
           _this6.hashTreeObjectId2ParticipantId.set(participant.htMeta.elementId.id, participant.id);
         }
       });
@@ -940,6 +1295,30 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       }
     }
 
+    /**
+     * Makes sure that passed in locus object has a participant object for self.
+     *
+     * @param {LocusDTO} locus The locus object to check and modify if needed
+     * @returns {void}
+     */
+  }, {
+    key: "ensureSelfParticipantExists",
+    value: function ensureSelfParticipantExists(locus) {
+      var self = locus.self;
+
+      // sanity check, this should never fail
+      if (!(self !== null && self !== void 0 && self.identity) || !(0, _isArray.default)(locus.participants)) {
+        _loggerProxy.default.logger.warn("Locus-info:index#ensureSelfParticipantExists --> locus object is missing required fields, cannot ensure self participant exists. self?.identity=\"".concat(self === null || self === void 0 ? void 0 : self.identity, "\""));
+        return;
+      }
+      var selfExists = locus.participants.some(function (participant) {
+        return participant.identity === self.identity;
+      });
+      if (!selfExists) {
+        locus.participants.push(_objectSpread({}, self));
+      }
+    }
+
     /**
      * @param {Object} locus
      * @returns {undefined}
@@ -949,10 +1328,20 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
     key: "onDeltaLocus",
     value: function onDeltaLocus(locus) {
       var _locus$jsSdkMeta2;
-      var isReplaceMembers = _controlsUtils.default.isNeedReplaceMembers(this.controls, locus.controls);
+      var isReplaceMembers = ((_locus$jsSdkMeta2 = locus.jsSdkMeta) === null || _locus$jsSdkMeta2 === void 0 ? void 0 : _locus$jsSdkMeta2.forceReplaceMembers) !== undefined ? locus.jsSdkMeta.forceReplaceMembers : _controlsUtils.default.isNeedReplaceMembers(this.controls, locus.controls);
+      if (isReplaceMembers) {
+        // when we're moving between breakouts, Locus sometimes doesn't send us
+        // any participants at all for a few seconds
+        // Web app relies on having at least the self participant always there
+        // so we copy self into participants if it's not there.
+        this.ensureSelfParticipantExists(locus);
+      }
       this.mergeParticipants(this.participants, locus.participants);
-      this.updateLocusInfo(locus);
-      this.updateParticipants(locus.participants, (_locus$jsSdkMeta2 = locus.jsSdkMeta) === null || _locus$jsSdkMeta2 === void 0 ? void 0 : _locus$jsSdkMeta2.removedParticipantIds, isReplaceMembers);
+      var updatesApplied = this.updateLocusInfo(locus);
+      if (updatesApplied) {
+        var _locus$jsSdkMeta3;
+        this.updateParticipants(locus.participants, (_locus$jsSdkMeta3 = locus.jsSdkMeta) === null || _locus$jsSdkMeta3 === void 0 ? void 0 : _locus$jsSdkMeta3.removedParticipantIds, isReplaceMembers);
+      }
       this.isMeetingActive();
     }
 
@@ -964,12 +1353,12 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "updateLocusInfo",
     value: function updateLocusInfo(locus) {
-      var _locus$self, _locus$self2;
-      if (((_locus$self = locus.self) === null || _locus$self === void 0 ? void 0 : _locus$self.reason) === 'MOVED' && ((_locus$self2 = locus.self) === null || _locus$self2 === void 0 ? void 0 : _locus$self2.state) === 'LEFT') {
+      var _locus$self2, _locus$self3;
+      if (((_locus$self2 = locus.self) === null || _locus$self2 === void 0 ? void 0 : _locus$self2.reason) === 'MOVED' && ((_locus$self3 = locus.self) === null || _locus$self3 === void 0 ? void 0 : _locus$self3.state) === 'LEFT') {
         // When moved to a breakout session locus sends a message for the previous locus
         // indicating that we have been moved. It isn't helpful to continue parsing this
         // as it gets interpreted as if we have left the call
-        return;
+        return false;
       }
       this.updateControls(locus.controls, locus.self);
       this.updateConversationUrl(locus.conversationUrl, locus.info);
@@ -988,6 +1377,8 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
       this.updateLinks(locus.links);
       this.compareAndUpdate();
       // update which required to compare different objects from locus
+
+      return true;
     }
 
     /**
@@ -1102,23 +1493,6 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
             reason: _constants.MEETING_REMOVED_REASON.MEETING_INACTIVE_TERMINATING,
             shouldLeave: false
           });
-        } else if (this.fullState && this.fullState.removed) {
-          // user has been dropped from a meeting
-
-          // @ts-ignore
-          this.webex.internal.newMetrics.submitClientEvent({
-            name: 'client.call.remote-ended',
-            options: {
-              meetingId: this.meetingId
-            }
-          });
-          this.emitScoped({
-            file: 'locus-info',
-            function: 'isMeetingActive'
-          }, _constants.EVENTS.DESTROY_MEETING, {
-            reason: _constants.MEETING_REMOVED_REASON.FULLSTATE_REMOVED,
-            shouldLeave: false
-          });
         }
         // If you are  guest and you are removed from the meeting
         // You wont get any further events
@@ -1205,11 +1579,11 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
         isReplace: isReplace
       });
       if (participants && (0, _isArray.default)(participants) && participants.length > 0) {
-        var _iterator = _createForOfIteratorHelper(participants),
-          _step;
+        var _iterator3 = _createForOfIteratorHelper(participants),
+          _step3;
         try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var participant = _step.value;
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var participant = _step3.value;
             if (participant && (participant === null || participant === void 0 ? void 0 : participant.reason) === 'FAILURE') {
               var _participant$person;
               this.emitScoped({
@@ -1221,9 +1595,9 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
             }
           }
         } catch (err) {
-          _iterator.e(err);
+          _iterator3.e(err);
         } finally {
-          _iterator.f();
+          _iterator3.f();
         }
       }
     }
@@ -1246,6 +1620,7 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
           hasMeetingContainerChanged = _ControlsUtils$getCon2.hasMeetingContainerChanged,
           hasTranscribeChanged = _ControlsUtils$getCon2.hasTranscribeChanged,
           hasHesiodLLMIdChanged = _ControlsUtils$getCon2.hasHesiodLLMIdChanged,
+          hasAiSummaryNotificationChanged = _ControlsUtils$getCon2.hasAiSummaryNotificationChanged,
           hasTranscribeSpokenLanguageChanged = _ControlsUtils$getCon2.hasTranscribeSpokenLanguageChanged,
           hasManualCaptionChanged = _ControlsUtils$getCon2.hasManualCaptionChanged,
           hasEntryExitToneChanged = _ControlsUtils$getCon2.hasEntryExitToneChanged,
@@ -1376,6 +1751,14 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
             hesiodLlmId: hesiodLlmId
           });
         }
+        if (hasAiSummaryNotificationChanged) {
+          this.emitScoped({
+            file: 'locus-info',
+            function: 'updateControls'
+          }, _constants.LOCUSINFO.EVENTS.CONTROLS_AI_SUMMARY_NOTIFICATION_UPDATED, {
+            aiSummaryNotification: current.transcribe.aiSummaryNotification
+          });
+        }
         if (hasTranscribeSpokenLanguageChanged) {
           var spokenLanguage = current.transcribe.spokenLanguage;
           this.emitScoped({
@@ -1800,6 +2183,14 @@ var LocusInfo = exports.default = /*#__PURE__*/function (_EventsScope) {
             brb: parsedSelves.current.brb
           });
         }
+        if (parsedSelves.updates.selfIdChanged) {
+          this.emitScoped({
+            file: 'locus-info',
+            function: 'updateSelf'
+          }, _constants.LOCUSINFO.EVENTS.SELF_ID_CHANGED, {
+            selfId: parsedSelves.current.selfId
+          });
+        }
         if (parsedSelves.updates.interpretationChanged) {
           this.emitScoped({
             file: 'locus-info',