matrix-js-sdk 37.1.0 → 37.2.0-rc.0

package/lib/matrixrtc/NewMembershipManager.js

@@ -0,0 +1,784 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*
+Copyright 2025 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { EventType } from "../@types/event.js";
+import { UpdateDelayedEventAction } from "../@types/requests.js";
+import { UnsupportedDelayedEventsEndpointError } from "../errors.js";
+import { ConnectionError, HTTPError, MatrixError } from "../http-api/errors.js";
+import { logger as rootLogger } from "../logger.js";
+import { defer } from "../utils.js";
+import { DEFAULT_EXPIRE_DURATION } from "./CallMembership.js";
+import { isLivekitFocusActive } from "./LivekitFocus.js";
+import { ActionScheduler } from "./NewMembershipManagerActionScheduler.js";
+var logger = rootLogger.getChild("MatrixRTCSession");
+
+/**
+ * This interface defines what a MembershipManager uses and exposes.
+ * This interface is what we use to write tests and allows changing the actual implementation
+ * without breaking tests because of some internal method renaming.
+ *
+ * @internal
+ */
+
+/* MembershipActionTypes:
+                           ▼
+                 ┌─────────────────────┐
+                 │SendFirstDelayedEvent│
+                 └─────────────────────┘
+                           │
+                           ▼
+                    ┌─────────────┐
+       ┌────────────│SendJoinEvent│────────────┐
+       │            └─────────────┘            │
+       │  ┌─────┐                  ┌──────┐    │    ┌──────┐
+       ▼  ▼     │                  │      ▼    ▼    ▼      │
+┌────────────┐  │                  │ ┌───────────────────┐ │
+│UpdateExpiry│  │                  │ │RestartDelayedEvent│ │
+└────────────┘  │                  │ └───────────────────┘ │
+          │     │                  │      │    │           │
+          └─────┘                  └──────┘    │           │
+                                               │           │
+                 ┌────────────────────┐        │           │
+                 │SendMainDelayedEvent│◄───────┘           │
+                 └───────────────────┬┘                    │
+                                     │                     │
+                                     └─────────────────────┘
+                     STOP ALL ABOVE
+                           ▼
+            ┌───────────────────────────────┐
+            │ SendScheduledDelayedLeaveEvent│
+            └───────────────────────────────┘
+                           │
+                           ▼
+                    ┌──────────────┐
+                    │SendLeaveEvent│
+                    └──────────────┘
+
+*/
+/**
+ * The different types of actions the MembershipManager can take.
+ * @internal
+ */
+export var MembershipActionType = /*#__PURE__*/function (MembershipActionType) {
+  MembershipActionType["SendFirstDelayedEvent"] = "SendFirstDelayedEvent";
+  MembershipActionType["SendJoinEvent"] = "SendJoinEvent";
+  MembershipActionType["RestartDelayedEvent"] = "RestartDelayedEvent";
+  MembershipActionType["UpdateExpiry"] = "UpdateExpiry";
+  MembershipActionType["SendMainDelayedEvent"] = "SendMainDelayedEvent";
+  MembershipActionType["SendScheduledDelayedLeaveEvent"] = "SendScheduledDelayedLeaveEvent";
+  MembershipActionType["SendLeaveEvent"] = "SendLeaveEvent";
+  return MembershipActionType;
+}({});
+
+/**
+ * @internal
+ */
+var Status = /*#__PURE__*/function (Status) {
+  Status["Disconnected"] = "Disconnected";
+  Status["Connecting"] = "Connecting";
+  Status["ConnectingFailed"] = "ConnectingFailed";
+  Status["Connected"] = "Connected";
+  Status["Reconnecting"] = "Reconnecting";
+  Status["Disconnecting"] = "Disconnecting";
+  Status["Stuck"] = "Stuck";
+  Status["Unknown"] = "Unknown";
+  return Status;
+}(Status || {});
+/**
+ * This class is responsible for sending all events relating to the own membership of a matrixRTC call.
+ * It has the following tasks:
+ *  - Send the users leave delayed event before sending the membership
+ *  - Send the users membership if the state machine is started
+ *  - Check if the delayed event was canceled due to sending the membership
+ *  - update the delayed event (`restart`)
+ *  - Update the state event every ~5h = `DEFAULT_EXPIRE_DURATION` (so it does not get treated as expired)
+ *  - When the state machine is stopped:
+ *   - Disconnect the member
+ *   - Stop the timer for the delay refresh
+ *   - Stop the timer for updating the state event
+ */
+export class MembershipManager {
+  isJoined() {
+    return this.activated;
+  }
+
+  /**
+   * Puts the MembershipManager in a state where it tries to be joined.
+   * It will send delayed events and membership events
+   * @param fociPreferred
+   * @param focusActive
+   * @param onError This will be called once the membership manager encounters an unrecoverable error.
+   * This should bubble up the the frontend to communicate that the call does not work in the current environment.
+   */
+  join(fociPreferred, focusActive, onError) {
+    if (this.scheduler.running) {
+      logger.error("MembershipManager is already running. Ignoring join request.");
+      return;
+    }
+    this.fociPreferred = fociPreferred;
+    this.focusActive = focusActive;
+    this.leavePromiseDefer = undefined;
+    this.activated = true;
+    this.state = MembershipManager.defaultState;
+    this.scheduler.startWithJoin().then(() => {
+      if (!this.scheduler.running) {
+        var _this$leavePromiseDef;
+        (_this$leavePromiseDef = this.leavePromiseDefer) === null || _this$leavePromiseDef === void 0 || _this$leavePromiseDef.resolve(true);
+        this.leavePromiseDefer = undefined;
+      }
+    }).catch(e => {
+      logger.error("MembershipManager stopped because: ", e);
+      onError === null || onError === void 0 || onError(e);
+    })
+    // Should already be set to false when calling `leave` in non error cases.
+    .finally(() => this.activated = false);
+  }
+
+  /**
+   * Leave from the call (Send an rtc session event with content: `{}`)
+   * @param timeout the maximum duration this promise will take to resolve
+   * @returns true if it managed to leave and false if the timeout condition happened.
+   */
+  leave(timeout) {
+    if (!this.scheduler.running) {
+      logger.warn("Called MembershipManager.leave() even though the MembershipManager is not running");
+      return Promise.resolve(true);
+    }
+
+    // We use the promise to track if we already scheduled a leave event
+    // So we do not check scheduler.actions/scheduler.insertions
+    if (!this.leavePromiseDefer) {
+      // reset scheduled actions so we will not do any new actions.
+      this.leavePromiseDefer = defer();
+      this.activated = false;
+      this.scheduler.initiateLeave();
+      if (timeout) setTimeout(() => {
+        var _this$leavePromiseDef2;
+        return (_this$leavePromiseDef2 = this.leavePromiseDefer) === null || _this$leavePromiseDef2 === void 0 ? void 0 : _this$leavePromiseDef2.resolve(false);
+      }, timeout);
+    }
+    return this.leavePromiseDefer.promise;
+  }
+  onRTCSessionMemberUpdate(memberships) {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      var isMyMembership = m => m.sender === _this.client.getUserId() && m.deviceId === _this.client.getDeviceId();
+      if (_this.isJoined() && !memberships.some(isMyMembership)) {
+        // If one of these actions are scheduled or are getting inserted in the next iteration, we should already
+        // take care of our missing membership.
+        var sendingMembershipActions = [MembershipActionType.SendFirstDelayedEvent, MembershipActionType.SendJoinEvent];
+        logger.warn("Missing own membership: force re-join");
+        if (_this.scheduler.actions.find(a => sendingMembershipActions.includes(a.type))) {
+          logger.error("NewMembershipManger tried adding another `SendFirstDelayedEvent` actions even though we already have one in the Queue\nActionQueueOnMemberUpdate:", _this.scheduler.actions);
+        } else {
+          // Only react to our own membership missing if we have not already scheduled sending a new membership DirectMembershipManagerAction.Join
+          _this.state.hasMemberStateEvent = false;
+          _this.scheduler.initiateJoin();
+        }
+      }
+      return Promise.resolve();
+    })();
+  }
+  getActiveFocus() {
+    if (this.focusActive) {
+      // A livekit active focus
+      if (isLivekitFocusActive(this.focusActive)) {
+        if (this.focusActive.focus_selection === "oldest_membership") {
+          var oldestMembership = this.getOldestMembership();
+          return oldestMembership === null || oldestMembership === void 0 ? void 0 : oldestMembership.getPreferredFoci()[0];
+        }
+      } else {
+        logger.warn("Unknown own ActiveFocus type. This makes it impossible to connect to an SFU.");
+      }
+    } else {
+      // We do not understand the membership format (could be legacy). We default to oldestMembership
+      // Once there are other methods this is a hard error!
+      var _oldestMembership = this.getOldestMembership();
+      return _oldestMembership === null || _oldestMembership === void 0 ? void 0 : _oldestMembership.getPreferredFoci()[0];
+    }
+  }
+
+  /**
+   * @throws if the client does not return user or device id.
+   * @param joinConfig
+   * @param room
+   * @param client
+   * @param getOldestMembership
+   */
+  constructor(joinConfig, room, client, getOldestMembership) {
+    this.joinConfig = joinConfig;
+    this.room = room;
+    this.client = client;
+    this.getOldestMembership = getOldestMembership;
+    _defineProperty(this, "activated", false);
+    _defineProperty(this, "leavePromiseDefer", void 0);
+    // MembershipManager mutable state.
+    _defineProperty(this, "state", void 0);
+    // Membership Event static parameters:
+    _defineProperty(this, "deviceId", void 0);
+    _defineProperty(this, "stateKey", void 0);
+    _defineProperty(this, "fociPreferred", void 0);
+    _defineProperty(this, "focusActive", void 0);
+    // Config:
+    _defineProperty(this, "membershipServerSideExpiryTimeoutOverride", void 0);
+    // Scheduler:
+    _defineProperty(this, "oldStatus", void 0);
+    _defineProperty(this, "scheduler", new ActionScheduler(type => {
+      if (this.oldStatus) {
+        //  we put this at the beginning of the actions scheduler loop handle callback since it is a loop this
+        // is equivalent to running it at the end of the loop. (just after applying the status/action list changes)
+        logger.debug("MembershipManager applied action changes. Status: ".concat(this.oldStatus, " -> ").concat(this.status));
+      }
+      this.oldStatus = this.status;
+      logger.debug("MembershipManager before processing action. status=".concat(this.oldStatus));
+      return this.membershipLoopHandler(type);
+    }));
+    var [userId, deviceId] = [this.client.getUserId(), this.client.getDeviceId()];
+    if (userId === null) throw Error("Missing userId in client");
+    if (deviceId === null) throw Error("Missing deviceId in client");
+    this.deviceId = deviceId;
+    this.stateKey = this.makeMembershipStateKey(userId, deviceId);
+    this.state = MembershipManager.defaultState;
+  }
+  static get defaultState() {
+    return {
+      hasMemberStateEvent: false,
+      delayId: undefined,
+      startTime: 0,
+      rateLimitRetries: new Map(),
+      networkErrorRetries: new Map(),
+      expireUpdateIterations: 1
+    };
+  }
+  get callMemberEventRetryDelayMinimum() {
+    var _this$joinConfig$call, _this$joinConfig;
+    return (_this$joinConfig$call = (_this$joinConfig = this.joinConfig) === null || _this$joinConfig === void 0 ? void 0 : _this$joinConfig.callMemberEventRetryDelayMinimum) !== null && _this$joinConfig$call !== void 0 ? _this$joinConfig$call : 3000;
+  }
+  get membershipEventExpiryTimeout() {
+    var _this$joinConfig$memb, _this$joinConfig2;
+    return (_this$joinConfig$memb = (_this$joinConfig2 = this.joinConfig) === null || _this$joinConfig2 === void 0 ? void 0 : _this$joinConfig2.membershipExpiryTimeout) !== null && _this$joinConfig$memb !== void 0 ? _this$joinConfig$memb : DEFAULT_EXPIRE_DURATION;
+  }
+  get membershipEventExpiryTimeoutHeadroom() {
+    var _this$joinConfig$memb2, _this$joinConfig3;
+    return (_this$joinConfig$memb2 = (_this$joinConfig3 = this.joinConfig) === null || _this$joinConfig3 === void 0 ? void 0 : _this$joinConfig3.membershipExpiryTimeoutHeadroom) !== null && _this$joinConfig$memb2 !== void 0 ? _this$joinConfig$memb2 : 5000;
+  }
+  computeNextExpiryActionTs(iteration) {
+    return this.state.startTime + this.membershipEventExpiryTimeout * iteration - this.membershipEventExpiryTimeoutHeadroom;
+  }
+  get membershipServerSideExpiryTimeout() {
+    var _ref, _this$membershipServe, _this$joinConfig4;
+    return (_ref = (_this$membershipServe = this.membershipServerSideExpiryTimeoutOverride) !== null && _this$membershipServe !== void 0 ? _this$membershipServe : (_this$joinConfig4 = this.joinConfig) === null || _this$joinConfig4 === void 0 ? void 0 : _this$joinConfig4.membershipServerSideExpiryTimeout) !== null && _ref !== void 0 ? _ref : 8000;
+  }
+  get membershipKeepAlivePeriod() {
+    var _this$joinConfig$memb3, _this$joinConfig5;
+    return (_this$joinConfig$memb3 = (_this$joinConfig5 = this.joinConfig) === null || _this$joinConfig5 === void 0 ? void 0 : _this$joinConfig5.membershipKeepAlivePeriod) !== null && _this$joinConfig$memb3 !== void 0 ? _this$joinConfig$memb3 : 5000;
+  }
+  get maximumRateLimitRetryCount() {
+    var _this$joinConfig$maxi, _this$joinConfig6;
+    return (_this$joinConfig$maxi = (_this$joinConfig6 = this.joinConfig) === null || _this$joinConfig6 === void 0 ? void 0 : _this$joinConfig6.maximumRateLimitRetryCount) !== null && _this$joinConfig$maxi !== void 0 ? _this$joinConfig$maxi : 10;
+  }
+  get maximumNetworkErrorRetryCount() {
+    var _this$joinConfig$maxi2, _this$joinConfig7;
+    return (_this$joinConfig$maxi2 = (_this$joinConfig7 = this.joinConfig) === null || _this$joinConfig7 === void 0 ? void 0 : _this$joinConfig7.maximumNetworkErrorRetryCount) !== null && _this$joinConfig$maxi2 !== void 0 ? _this$joinConfig$maxi2 : 10;
+  }
+  // LOOP HANDLER:
+  membershipLoopHandler(type) {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      _this2.oldStatus = _this2.status;
+      switch (type) {
+        case MembershipActionType.SendFirstDelayedEvent:
+          {
+            // Before we start we check if we come from a state where we have a delay id.
+            if (!_this2.state.delayId) {
+              return _this2.sendFirstDelayedLeaveEvent(); // Normal case without any previous delayed id.
+            } else {
+              // This can happen if someone else (or another client) removes our own membership event.
+              // It will trigger `onRTCSessionMemberUpdate` queue `MembershipActionType.SendFirstDelayedEvent`.
+              // We might still have our delayed event from the previous participation and dependent on the server this might not
+              // get automatically removed if the state changes. Hence It would remove our membership unexpectedly shortly after the rejoin.
+              //
+              // In this block we will try to cancel this delayed event before setting up a new one.
+
+              return _this2.cancelKnownDelayIdBeforeSendFirstDelayedEvent(_this2.state.delayId);
+            }
+          }
+        case MembershipActionType.RestartDelayedEvent:
+          {
+            if (!_this2.state.delayId) {
+              // Delay id got reset. This action was used to check if the hs canceled the delayed event when the join state got sent.
+              return createInsertActionUpdate(_this2.state.hasMemberStateEvent ? MembershipActionType.SendMainDelayedEvent : MembershipActionType.SendFirstDelayedEvent);
+            }
+            return _this2.restartDelayedEvent(_this2.state.delayId);
+          }
+        case MembershipActionType.SendMainDelayedEvent:
+          {
+            return _this2.sendMainDelayedEvent();
+          }
+        case MembershipActionType.SendScheduledDelayedLeaveEvent:
+          {
+            // We are already good
+            if (!_this2.state.hasMemberStateEvent) {
+              return {
+                replace: []
+              };
+            }
+            if (_this2.state.delayId) {
+              return _this2.sendScheduledDelayedLeaveEventOrFallbackToSendLeaveEvent(_this2.state.delayId);
+            } else {
+              return createInsertActionUpdate(MembershipActionType.SendLeaveEvent);
+            }
+          }
+        case MembershipActionType.SendJoinEvent:
+          {
+            return _this2.sendJoinEvent();
+          }
+        case MembershipActionType.UpdateExpiry:
+          {
+            return _this2.updateExpiryOnJoinedEvent();
+          }
+        case MembershipActionType.SendLeaveEvent:
+          {
+            // We are good already
+            if (!_this2.state.hasMemberStateEvent) {
+              return {
+                replace: []
+              };
+            }
+            // This is only a fallback in case we do not have working delayed events support.
+            // first we should try to just send the scheduled leave event
+            return _this2.sendFallbackLeaveEvent();
+          }
+      }
+    })();
+  }
+
+  // HANDLERS (used in the membershipLoopHandler)
+  sendFirstDelayedLeaveEvent() {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      return yield _this3.client._unstable_sendDelayedStateEvent(_this3.room.roomId, {
+        delay: _this3.membershipServerSideExpiryTimeout
+      }, EventType.GroupCallMemberPrefix, {},
+      // leave event
+      _this3.stateKey).then(response => {
+        // On success we reset retries and set delayId.
+        _this3.state.rateLimitRetries.set(MembershipActionType.SendFirstDelayedEvent, 0);
+        _this3.state.networkErrorRetries.set(MembershipActionType.SendFirstDelayedEvent, 0);
+        _this3.state.delayId = response.delay_id;
+        return createInsertActionUpdate(MembershipActionType.SendJoinEvent);
+      }).catch(e => {
+        var repeatActionType = MembershipActionType.SendFirstDelayedEvent;
+        if (_this3.manageMaxDelayExceededSituation(e)) {
+          return createInsertActionUpdate(repeatActionType);
+        }
+        var update = _this3.actionUpdateFromErrors(e, repeatActionType, "sendDelayedStateEvent");
+        if (update) return update;
+
+        // log and fall through
+        if (_this3.isUnsupportedDelayedEndpoint(e)) {
+          logger.info("Not using delayed event because the endpoint is not supported");
+        } else {
+          logger.info("Not using delayed event because: " + e);
+        }
+        // On any other error we fall back to not using delayed events and send the join state event immediately
+        return createInsertActionUpdate(MembershipActionType.SendJoinEvent);
+      });
+    })();
+  }
+  cancelKnownDelayIdBeforeSendFirstDelayedEvent(delayId) {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      // Remove all running updates and restarts
+      return yield _this4.client._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Cancel).then(() => {
+        _this4.state.delayId = undefined;
+        _this4.resetRateLimitCounter(MembershipActionType.SendFirstDelayedEvent);
+        return createReplaceActionUpdate(MembershipActionType.SendFirstDelayedEvent);
+      }).catch(e => {
+        var repeatActionType = MembershipActionType.SendFirstDelayedEvent;
+        var update = _this4.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
+        if (update) return update;
+        if (_this4.isNotFoundError(e)) {
+          // If we get a M_NOT_FOUND we know that the delayed event got already removed.
+          // This means we are good and can set it to undefined and run this again.
+          _this4.state.delayId = undefined;
+          return createReplaceActionUpdate(repeatActionType);
+        }
+        if (_this4.isUnsupportedDelayedEndpoint(e)) {
+          return createReplaceActionUpdate(MembershipActionType.SendJoinEvent);
+        }
+        // We do not just ignore and log this error since we would also need to reset the delayId.
+
+        // This becomes an unrecoverable error case since something is significantly off if we don't hit any of the above cases
+        // when state.delayId !== undefined
+        // We do not just ignore and log this error since we would also need to reset the delayId.
+        // It is cleaner if we, the frontend, rejoins instead of resetting the delayId here and behaving like in the success case.
+        throw Error("We failed to cancel a delayed event where we already had a delay id with an error we cannot automatically handle");
+      });
+    })();
+  }
+  restartDelayedEvent(delayId) {
+    var _this5 = this;
+    return _asyncToGenerator(function* () {
+      return yield _this5.client._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Restart).then(() => {
+        _this5.resetRateLimitCounter(MembershipActionType.RestartDelayedEvent);
+        return createInsertActionUpdate(MembershipActionType.RestartDelayedEvent, _this5.membershipKeepAlivePeriod);
+      }).catch(e => {
+        var repeatActionType = MembershipActionType.RestartDelayedEvent;
+        if (_this5.isNotFoundError(e)) {
+          _this5.state.delayId = undefined;
+          return createInsertActionUpdate(MembershipActionType.SendMainDelayedEvent);
+        }
+        // If the HS does not support delayed events we wont reschedule.
+        if (_this5.isUnsupportedDelayedEndpoint(e)) return {};
+
+        // TODO this also needs a test: get rate limit while checking id delayed event is scheduled
+        var update = _this5.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
+        if (update) return update;
+
+        // In other error cases we have no idea what is happening
+        throw Error("Could not restart delayed event, even though delayed events are supported. " + e);
+      });
+    })();
+  }
+  sendMainDelayedEvent() {
+    var _this6 = this;
+    return _asyncToGenerator(function* () {
+      return yield _this6.client._unstable_sendDelayedStateEvent(_this6.room.roomId, {
+        delay: _this6.membershipServerSideExpiryTimeout
+      }, EventType.GroupCallMemberPrefix, {},
+      // leave event
+      _this6.stateKey).then(response => {
+        _this6.state.delayId = response.delay_id;
+        _this6.resetRateLimitCounter(MembershipActionType.SendMainDelayedEvent);
+        return createInsertActionUpdate(MembershipActionType.RestartDelayedEvent, _this6.membershipKeepAlivePeriod);
+      }).catch(e => {
+        var repeatActionType = MembershipActionType.SendMainDelayedEvent;
+        // Don't do any other delayed event work if its not supported.
+        if (_this6.isUnsupportedDelayedEndpoint(e)) return {};
+        if (_this6.manageMaxDelayExceededSituation(e)) {
+          return createInsertActionUpdate(repeatActionType);
+        }
+        var update = _this6.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
+        if (update) return update;
+        throw Error("Could not send delayed event, even though delayed events are supported. " + e);
+      });
+    })();
+  }
+  sendScheduledDelayedLeaveEventOrFallbackToSendLeaveEvent(delayId) {
+    var _this7 = this;
+    return _asyncToGenerator(function* () {
+      return yield _this7.client._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Send).then(() => {
+        _this7.state.hasMemberStateEvent = false;
+        _this7.resetRateLimitCounter(MembershipActionType.SendScheduledDelayedLeaveEvent);
+        return {
+          replace: []
+        };
+      }).catch(e => {
+        var repeatActionType = MembershipActionType.SendLeaveEvent;
+        if (_this7.isUnsupportedDelayedEndpoint(e)) return {};
+        if (_this7.isNotFoundError(e)) {
+          _this7.state.delayId = undefined;
+          return createInsertActionUpdate(repeatActionType);
+        }
+        var update = _this7.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
+        if (update) return update;
+
+        // On any other error we fall back to SendLeaveEvent (this includes hard errors from rate limiting)
+        logger.warn("Encountered unexpected error during SendScheduledDelayedLeaveEvent. Falling back to SendLeaveEvent", e);
+        return createInsertActionUpdate(repeatActionType);
+      });
+    })();
+  }
+  sendJoinEvent() {
+    var _this8 = this;
+    return _asyncToGenerator(function* () {
+      return yield _this8.client.sendStateEvent(_this8.room.roomId, EventType.GroupCallMemberPrefix, _this8.makeMyMembership(_this8.membershipEventExpiryTimeout), _this8.stateKey).then(() => {
+        _this8.state.startTime = Date.now();
+        // The next update should already use twice the membershipEventExpiryTimeout
+        _this8.state.expireUpdateIterations = 1;
+        _this8.state.hasMemberStateEvent = true;
+        _this8.resetRateLimitCounter(MembershipActionType.SendJoinEvent);
+        return {
+          insert: [{
+            ts: Date.now(),
+            type: MembershipActionType.RestartDelayedEvent
+          }, {
+            ts: _this8.computeNextExpiryActionTs(_this8.state.expireUpdateIterations),
+            type: MembershipActionType.UpdateExpiry
+          }]
+        };
+      }).catch(e => {
+        var update = _this8.actionUpdateFromErrors(e, MembershipActionType.SendJoinEvent, "sendStateEvent");
+        if (update) return update;
+        throw e;
+      });
+    })();
+  }
+  updateExpiryOnJoinedEvent() {
+    var _this9 = this;
+    return _asyncToGenerator(function* () {
+      var nextExpireUpdateIteration = _this9.state.expireUpdateIterations + 1;
+      return yield _this9.client.sendStateEvent(_this9.room.roomId, EventType.GroupCallMemberPrefix, _this9.makeMyMembership(_this9.membershipEventExpiryTimeout * nextExpireUpdateIteration), _this9.stateKey).then(() => {
+        // Success, we reset retries and schedule update.
+        _this9.resetRateLimitCounter(MembershipActionType.UpdateExpiry);
+        _this9.state.expireUpdateIterations = nextExpireUpdateIteration;
+        return {
+          insert: [{
+            ts: _this9.computeNextExpiryActionTs(nextExpireUpdateIteration),
+            type: MembershipActionType.UpdateExpiry
+          }]
+        };
+      }).catch(e => {
+        var update = _this9.actionUpdateFromErrors(e, MembershipActionType.UpdateExpiry, "sendStateEvent");
+        if (update) return update;
+        throw e;
+      });
+    })();
+  }
+  sendFallbackLeaveEvent() {
+    var _this10 = this;
+    return _asyncToGenerator(function* () {
+      return yield _this10.client.sendStateEvent(_this10.room.roomId, EventType.GroupCallMemberPrefix, {}, _this10.stateKey).then(() => {
+        _this10.resetRateLimitCounter(MembershipActionType.SendLeaveEvent);
+        _this10.state.hasMemberStateEvent = false;
+        return {
+          replace: []
+        };
+      }).catch(e => {
+        var update = _this10.actionUpdateFromErrors(e, MembershipActionType.SendLeaveEvent, "sendStateEvent");
+        if (update) return update;
+        throw e;
+      });
+    })();
+  }
+
+  // HELPERS
+  makeMembershipStateKey(localUserId, localDeviceId) {
+    var stateKey = "".concat(localUserId, "_").concat(localDeviceId);
+    if (/^org\.matrix\.msc(3757|3779)\b/.exec(this.room.getVersion())) {
+      return stateKey;
+    } else {
+      return "_".concat(stateKey);
+    }
+  }
+
+  /**
+   * Constructs our own membership
+   */
+  makeMyMembership(expires) {
+    var _this$fociPreferred;
+    return {
+      call_id: "",
+      scope: "m.room",
+      application: "m.call",
+      device_id: this.deviceId,
+      expires,
+      focus_active: {
+        type: "livekit",
+        focus_selection: "oldest_membership"
+      },
+      foci_preferred: (_this$fociPreferred = this.fociPreferred) !== null && _this$fociPreferred !== void 0 ? _this$fociPreferred : []
+    };
+  }
+
+  // Error checks and handlers
+
+  /**
+   * Check if its a NOT_FOUND error
+   * @param error the error causing this handler check/execution
+   * @returns true if its a not found error
+   */
+  isNotFoundError(error) {
+    return error instanceof MatrixError && error.errcode === "M_NOT_FOUND";
+  }
+
+  /**
+   * Check if this is a DelayExceeded timeout and update the TimeoutOverride for the next try
+   * @param error the error causing this handler check/execution
+   * @returns true if its a delay exceeded error and we updated the local TimeoutOverride
+   */
+  manageMaxDelayExceededSituation(error) {
+    if (error instanceof MatrixError && error.errcode === "M_UNKNOWN" && error.data["org.matrix.msc4140.errcode"] === "M_MAX_DELAY_EXCEEDED") {
+      var maxDelayAllowed = error.data["org.matrix.msc4140.max_delay"];
+      if (typeof maxDelayAllowed === "number" && this.membershipServerSideExpiryTimeout > maxDelayAllowed) {
+        this.membershipServerSideExpiryTimeoutOverride = maxDelayAllowed;
+      }
+      logger.warn("Retry sending delayed disconnection event due to server timeout limitations:", error);
+      return true;
+    }
+    return false;
+  }
+  actionUpdateFromErrors(error, type, method) {
+    var updateLimit = this.actionUpdateFromRateLimitError(error, method, type);
+    if (updateLimit) return updateLimit;
+    var updateNetwork = this.actionUpdateFromNetworkErrorRetry(error, type);
+    if (updateNetwork) return updateNetwork;
+  }
+  /**
+   * Check if we have a rate limit error and schedule the same action again if we dont exceed the rate limit retry count yet.
+   * @param error the error causing this handler check/execution
+   * @param method the method used for the throw message
+   * @param type which MembershipActionType we reschedule because of a rate limit.
+   * @throws If it is a rate limit error and the retry count got exceeded
+   * @returns Returns true if we handled the error by rescheduling the correct next action.
+   * Returns false if it is not a network error.
+   */
+  actionUpdateFromRateLimitError(error, method, type) {
+    var _this$state$rateLimit;
+    // "Is rate limit"-boundary
+    if (!((error instanceof HTTPError || error instanceof MatrixError) && error.isRateLimitError())) {
+      return undefined;
+    }
+
+    // retry boundary
+    var rateLimitRetries = (_this$state$rateLimit = this.state.rateLimitRetries.get(type)) !== null && _this$state$rateLimit !== void 0 ? _this$state$rateLimit : 0;
+    if (rateLimitRetries < this.maximumRateLimitRetryCount) {
+      var resendDelay;
+      var defaultMs = 5000;
+      try {
+        var _error$getRetryAfterM;
+        resendDelay = (_error$getRetryAfterM = error.getRetryAfterMs()) !== null && _error$getRetryAfterM !== void 0 ? _error$getRetryAfterM : defaultMs;
+        logger.info("Rate limited by server, retrying in ".concat(resendDelay, "ms"));
+      } catch (e) {
+        logger.warn("Error while retrieving a rate-limit retry delay, retrying after default delay of ".concat(defaultMs), e);
+        resendDelay = defaultMs;
+      }
+      this.state.rateLimitRetries.set(type, rateLimitRetries + 1);
+      return createInsertActionUpdate(type, resendDelay);
+    }
+    throw Error("Exceeded maximum retries for " + type + " attempts (client." + method + "): " + error);
+  }
+
+  /**
+   * FIXME Don't Check the error and retry the same MembershipAction again in the configured time and for the configured retry count.
+   * @param error the error causing this handler check/execution
+   * @param type the action type that we need to repeat because of the error
+   * @throws If it is a network error and the retry count got exceeded
+   * @returns
+   * Returns true if we handled the error by rescheduling the correct next action.
+   * Returns false if it is not a network error.
+   */
+  actionUpdateFromNetworkErrorRetry(error, type) {
+    var _this$state$networkEr;
+    // "Is a network error"-boundary
+    var retries = (_this$state$networkEr = this.state.networkErrorRetries.get(type)) !== null && _this$state$networkEr !== void 0 ? _this$state$networkEr : 0;
+    var retryDurationString = this.callMemberEventRetryDelayMinimum / 1000 + "s";
+    var retryCounterString = "(" + retries + "/" + this.maximumNetworkErrorRetryCount + ")";
+    if (error instanceof Error && error.name === "AbortError") {
+      logger.warn("Network local timeout error while sending event, retrying in " + retryDurationString + " " + retryCounterString, error);
+    } else if (error instanceof Error && error.message.includes("updating delayed event")) {
+      // TODO: We do not want error message matching here but instead the error should be a typed HTTPError
+      // and be handled below automatically (the same as in the SPA case).
+      //
+      // The error originates because of https://github.com/matrix-org/matrix-widget-api/blob/5d81d4a26ff69e4bd3ddc79a884c9527999fb2f4/src/ClientWidgetApi.ts#L698-L701
+      // uses `e` instance of HttpError (and not MatrixError)
+      // The element web widget driver (only checks for MatrixError) is then failing to process (`processError`) it as a typed error: https://github.com/element-hq/element-web/blob/471712cbf06a067e5499bd5d2d7a75f693d9a12d/src/stores/widgets/StopGapWidgetDriver.ts#L711-L715
+      // So it will not call: `error.asWidgetApiErrorData()` which is also missing for `HttpError`
+      //
+      // A proper fix would be to either find a place to convert the `HttpError` into a `MatrixError` and the `processError`
+      // method to handle it as expected or to adjust `processError` to also process `HttpError`'s.
+      logger.warn("delayed event update timeout error, retrying in " + retryDurationString + " " + retryCounterString, error);
+    } else if (error instanceof ConnectionError) {
+      logger.warn("Network connection error while sending event, retrying in " + retryDurationString + " " + retryCounterString, error);
+    } else if ((error instanceof HTTPError || error instanceof MatrixError) && typeof error.httpStatus === "number" && error.httpStatus >= 500 && error.httpStatus < 600) {
+      logger.warn("Server error while sending event, retrying in " + retryDurationString + " " + retryCounterString, error);
+    } else {
+      return undefined;
+    }
+
+    // retry boundary
+    if (retries < this.maximumNetworkErrorRetryCount) {
+      this.state.networkErrorRetries.set(type, retries + 1);
+      return createInsertActionUpdate(type, this.callMemberEventRetryDelayMinimum);
+    }
+
+    // Failure
+    throw Error("Reached maximum (" + this.maximumNetworkErrorRetryCount + ") retries cause by: " + error);
+  }
+
+  /**
+   * Check if its an UnsupportedDelayedEventsEndpointError and which implies that we cannot do any delayed event logic
+   * @param error The error to check
+   * @returns true it its an UnsupportedDelayedEventsEndpointError
+   */
+  isUnsupportedDelayedEndpoint(error) {
+    return error instanceof UnsupportedDelayedEventsEndpointError;
+  }
+  resetRateLimitCounter(type) {
+    this.state.rateLimitRetries.set(type, 0);
+    this.state.networkErrorRetries.set(type, 0);
+  }
+  get status() {
+    var actions = this.scheduler.actions;
+    if (actions.length === 1) {
+      var {
+        type
+      } = actions[0];
+      switch (type) {
+        case MembershipActionType.SendFirstDelayedEvent:
+        case MembershipActionType.SendJoinEvent:
+        case MembershipActionType.SendMainDelayedEvent:
+          return Status.Connecting;
+        case MembershipActionType.UpdateExpiry:
+          // where no delayed events
+          return Status.Connected;
+        case MembershipActionType.SendScheduledDelayedLeaveEvent:
+        case MembershipActionType.SendLeaveEvent:
+          return Status.Disconnecting;
+        default:
+        // pass through as not expected
+      }
+    } else if (actions.length === 2) {
+      var types = actions.map(a => a.type);
+      // normal state for connected with delayed events
+      if ((types.includes(MembershipActionType.RestartDelayedEvent) || types.includes(MembershipActionType.SendMainDelayedEvent)) && types.includes(MembershipActionType.UpdateExpiry)) {
+        return Status.Connected;
+      }
+    } else if (actions.length === 3) {
+      var _types = actions.map(a => a.type);
+      // It is a correct connected state if we already schedule the next Restart but have not yet cleaned up
+      // the current restart.
+      if (_types.filter(t => t === MembershipActionType.RestartDelayedEvent).length === 2 && _types.includes(MembershipActionType.UpdateExpiry)) {
+        return Status.Connected;
+      }
+    }
+    if (!this.scheduler.running) {
+      return Status.Disconnected;
+    }
+    logger.error("MembershipManager has an unknown state. Actions: ", actions);
+    return Status.Unknown;
+  }
+}
+function createInsertActionUpdate(type, offset) {
+  return {
+    insert: [{
+      ts: Date.now() + (offset !== null && offset !== void 0 ? offset : 0),
+      type
+    }]
+  };
+}
+function createReplaceActionUpdate(type, offset) {
+  return {
+    replace: [{
+      ts: Date.now() + (offset !== null && offset !== void 0 ? offset : 0),
+      type
+    }]
+  };
+}
+//# sourceMappingURL=NewMembershipManager.js.map