@openclaw/matrix 2026.7.1-beta.2 → 2026.7.1-beta.5

package/node_modules/matrix-js-sdk/lib/matrixrtc/MembershipManager.js

@@ -1,7 +1,5 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(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) { _defineProperty(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; }
 /*
 Copyright 2025-2026 The Matrix.org Foundation C.I.C.
 
@@ -75,13 +73,13 @@ On Leave: ─────────  STOP ALL ABOVE
  * Call membership should always remain sticky for this amount
  * of time.
  */
-var MEMBERSHIP_STICKY_DURATION_MS = 60 * 60 * 1000; // 60 minutes
+const MEMBERSHIP_STICKY_DURATION_MS = 60 * 60 * 1000; // 60 minutes
 
 /**
  * The different types of actions the MembershipManager can take.
  * @internal
  */
-export var MembershipActionType = /*#__PURE__*/function (MembershipActionType) {
+export let MembershipActionType = /*#__PURE__*/function (MembershipActionType) {
   MembershipActionType["SendDelayedEvent"] = "SendDelayedEvent";
   //  -> MembershipActionType.SendJoinEvent if successful
   //  -> DelayedLeaveActionType.SendDelayedEvent on error, retry sending the first delayed event.
@@ -110,7 +108,7 @@ export var MembershipActionType = /*#__PURE__*/function (MembershipActionType) {
 function createInsertActionUpdate(type, offset) {
   return {
     insert: [{
-      ts: Date.now() + (offset !== null && offset !== void 0 ? offset : 0),
+      ts: Date.now() + (offset ?? 0),
       type
     }]
   };
@@ -118,7 +116,7 @@ function createInsertActionUpdate(type, offset) {
 function createReplaceActionUpdate(type, offset) {
   return {
     replace: [{
-      ts: Date.now() + (offset !== null && offset !== void 0 ? offset : 0),
+      ts: Date.now() + (offset ?? 0),
       type
     }]
   };
@@ -155,6 +153,8 @@ export class MembershipManager extends TypedEventEmitter {
    * transport selection will be used instead.
    * @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.
+   * The original underlying error is preserved as `error.cause`, so consumers can `instanceof`-check the typed
+   * cause.
    */
   join(fociPreferred, multiSfuFocus, onError) {
     if (this.scheduler.running) {
@@ -169,7 +169,7 @@ export class MembershipManager extends TypedEventEmitter {
     this.state = MembershipManager.defaultState;
     this.scheduler.startWithJoin().catch(e => {
       this.logger.error("MembershipManager stopped because: ", e);
-      onError === null || onError === void 0 || onError(e);
+      onError?.(e);
     }).finally(() => {
       // Should already be set to false when calling `leave` in non error cases.
       this.activated = false;
@@ -178,8 +178,7 @@ export class MembershipManager extends TypedEventEmitter {
         this.emit(MembershipManagerEvent.StatusChanged, this.oldStatus, this.status);
       }
       if (!this.scheduler.running) {
-        var _this$leavePromiseRes;
-        (_this$leavePromiseRes = this.leavePromiseResolvers) === null || _this$leavePromiseRes === void 0 || _this$leavePromiseRes.resolve(true);
+        this.leavePromiseResolvers?.resolve(true);
         this.leavePromiseResolvers = undefined;
       }
     });
@@ -203,10 +202,7 @@ export class MembershipManager extends TypedEventEmitter {
       this.leavePromiseResolvers = Promise.withResolvers();
       this.activated = false;
       this.scheduler.initiateLeave();
-      if (timeout) setTimeout(() => {
-        var _this$leavePromiseRes2;
-        return (_this$leavePromiseRes2 = this.leavePromiseResolvers) === null || _this$leavePromiseRes2 === void 0 ? void 0 : _this$leavePromiseRes2.resolve(false);
-      }, timeout);
+      if (timeout) setTimeout(() => this.leavePromiseResolvers?.resolve(false), timeout);
     }
     return this.leavePromiseResolvers.promise;
   }
@@ -218,7 +214,7 @@ export class MembershipManager extends TypedEventEmitter {
     if (!this._ownMembership) {
       // 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.SendDelayedEvent, MembershipActionType.SendJoinEvent];
+      const sendingMembershipActions = [MembershipActionType.SendDelayedEvent, MembershipActionType.SendJoinEvent];
       this.logger.warn("Missing own membership: force re-join");
       this.state.hasMemberStateEvent = false;
       if (this.scheduler.actions.some(a => sendingMembershipActions.includes(a.type))) {
@@ -230,19 +226,16 @@ export class MembershipManager extends TypedEventEmitter {
     }
     return Promise.resolve();
   }
-  updateCallIntent(callIntent) {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      if (!_this.activated || !_this.ownMembership) {
-        throw Error("You cannot update your intent before joining the call");
-      }
-      if (_this.ownMembership.callIntent === callIntent) {
-        return; // No-op
-      }
-      _this.callIntent = callIntent;
-      // Kick off a new membership event as a result.
-      yield _this.sendJoinEvent();
-    })();
+  async updateCallIntent(callIntent) {
+    if (!this.activated || !this.ownMembership) {
+      throw Error("You cannot update your intent before joining the call");
+    }
+    if (this.ownMembership.callIntent === callIntent) {
+      return; // No-op
+    }
+    this.callIntent = callIntent;
+    // Kick off a new membership event as a result.
+    await this.sendJoinEvent();
   }
 
   /**
@@ -254,6 +247,24 @@ export class MembershipManager extends TypedEventEmitter {
   constructor(joinConfig, room, client, slotDescription, parentLogger) {
     super();
     _defineProperty(this, "activated", false);
+    _defineProperty(this, "logger", void 0);
+    _defineProperty(this, "callIntent", void 0);
+    _defineProperty(this, "leavePromiseResolvers", void 0);
+    _defineProperty(this, "_ownMembership", void 0);
+    // scheduler
+    _defineProperty(this, "oldStatus", void 0);
+    _defineProperty(this, "scheduler", void 0);
+    // MembershipManager mutable state.
+    _defineProperty(this, "state", void 0);
+    // Membership Event static parameters:
+    _defineProperty(this, "deviceId", void 0);
+    _defineProperty(this, "userId", void 0);
+    _defineProperty(this, "stateKey", void 0);
+    _defineProperty(this, "rtcTransport", void 0);
+    /** @deprecated This will be removed in favor or rtcTransport becoming a list of actively used transports */
+    _defineProperty(this, "fociPreferred", void 0);
+    // Config:
+    _defineProperty(this, "delayedLeaveEventDelayMsOverride", void 0);
     // an abstraction to switch between sending state or a sticky event
     _defineProperty(this, "clientSendDelayedDisconnectMembership", () => this.client._unstable_sendDelayedStateEvent(this.room.roomId, {
       delay: this.delayedLeaveEventDelayMs
@@ -265,10 +276,8 @@ export class MembershipManager extends TypedEventEmitter {
     this.room = room;
     this.client = client;
     this.slotDescription = slotDescription;
-    this.logger = (parentLogger !== null && parentLogger !== void 0 ? parentLogger : rootLogger).getChild("[MembershipManager]");
-    var _ref = [this.client.getUserId(), this.client.getDeviceId()],
-      userId = _ref[0],
-      deviceId = _ref[1];
+    this.logger = (parentLogger ?? rootLogger).getChild(`[MembershipManager]`);
+    const [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;
@@ -277,30 +286,25 @@ export class MembershipManager extends TypedEventEmitter {
     // we keep it as a string for now for backwards compatibility.
     this.stateKey = this.makeMembershipStateKey(userId, deviceId);
     this.state = MembershipManager.defaultState;
-    this.callIntent = joinConfig === null || joinConfig === void 0 ? void 0 : joinConfig.callIntent;
+    this.callIntent = joinConfig?.callIntent;
     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)
         // This order is required because this method needs to return the action updates.
-        this.logger.debug("MembershipManager applied action changes. Status: ".concat(this.oldStatus, " -> ").concat(this.status));
+        this.logger.debug(`MembershipManager applied action changes. Status: ${this.oldStatus} -> ${this.status}`);
         if (this.oldStatus !== this.status) {
           this.emit(MembershipManagerEvent.StatusChanged, this.oldStatus, this.status);
         }
       }
       this.oldStatus = this.status;
-      this.logger.debug("MembershipManager before processing action. status=".concat(this.oldStatus));
+      this.logger.debug(`MembershipManager before processing action. status=${this.oldStatus}`);
       return this.membershipLoopHandler(type);
     }, this.logger);
   }
   get ownMembership() {
     return this._ownMembership;
   }
-
-  // scheduler
-
-  // MembershipManager mutable state.
-
   static get defaultState() {
     return {
       hasMemberStateEvent: false,
@@ -312,194 +316,171 @@ export class MembershipManager extends TypedEventEmitter {
       probablyLeft: false
     };
   }
-  // Membership Event static parameters:
-
-  /** @deprecated This will be removed in favor or rtcTransport becoming a list of actively used transports */
-
-  // Config:
-
   get networkErrorRetryMs() {
-    var _this$joinConfig$netw, _this$joinConfig;
-    return (_this$joinConfig$netw = (_this$joinConfig = this.joinConfig) === null || _this$joinConfig === void 0 ? void 0 : _this$joinConfig.networkErrorRetryMs) !== null && _this$joinConfig$netw !== void 0 ? _this$joinConfig$netw : 3000;
+    return this.joinConfig?.networkErrorRetryMs ?? 3000;
   }
   get membershipEventExpiryMs() {
-    var _this$joinConfig$memb, _this$joinConfig2;
-    return (_this$joinConfig$memb = (_this$joinConfig2 = this.joinConfig) === null || _this$joinConfig2 === void 0 ? void 0 : _this$joinConfig2.membershipEventExpiryMs) !== null && _this$joinConfig$memb !== void 0 ? _this$joinConfig$memb : DEFAULT_EXPIRE_DURATION;
+    return this.joinConfig?.membershipEventExpiryMs ?? DEFAULT_EXPIRE_DURATION;
   }
   get membershipEventExpiryHeadroomMs() {
-    var _this$joinConfig$memb2, _this$joinConfig3;
-    return (_this$joinConfig$memb2 = (_this$joinConfig3 = this.joinConfig) === null || _this$joinConfig3 === void 0 ? void 0 : _this$joinConfig3.membershipEventExpiryHeadroomMs) !== null && _this$joinConfig$memb2 !== void 0 ? _this$joinConfig$memb2 : 5000;
+    return this.joinConfig?.membershipEventExpiryHeadroomMs ?? 5000;
   }
   computeNextExpiryActionTs(iteration) {
     return this.state.startTime + Math.min(this.membershipEventExpiryMs, MEMBERSHIP_STICKY_DURATION_MS) * iteration - this.membershipEventExpiryHeadroomMs;
   }
   get delayedLeaveEventDelayMs() {
-    var _ref2, _this$delayedLeaveEve, _this$joinConfig4;
-    return (_ref2 = (_this$delayedLeaveEve = this.delayedLeaveEventDelayMsOverride) !== null && _this$delayedLeaveEve !== void 0 ? _this$delayedLeaveEve : (_this$joinConfig4 = this.joinConfig) === null || _this$joinConfig4 === void 0 ? void 0 : _this$joinConfig4.delayedLeaveEventDelayMs) !== null && _ref2 !== void 0 ? _ref2 : 8000;
+    return this.delayedLeaveEventDelayMsOverride ?? this.joinConfig?.delayedLeaveEventDelayMs ?? 8000;
   }
   get delayedLeaveEventRestartMs() {
-    var _this$joinConfig$dela, _this$joinConfig5;
-    return (_this$joinConfig$dela = (_this$joinConfig5 = this.joinConfig) === null || _this$joinConfig5 === void 0 ? void 0 : _this$joinConfig5.delayedLeaveEventRestartMs) !== null && _this$joinConfig$dela !== void 0 ? _this$joinConfig$dela : 5000;
+    return this.joinConfig?.delayedLeaveEventRestartMs ?? 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;
+    return this.joinConfig?.maximumRateLimitRetryCount ?? 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;
+    return this.joinConfig?.maximumNetworkErrorRetryCount ?? 10;
   }
   get delayedLeaveEventRestartLocalTimeoutMs() {
-    var _this$joinConfig$dela2, _this$joinConfig8;
-    return (_this$joinConfig$dela2 = (_this$joinConfig8 = this.joinConfig) === null || _this$joinConfig8 === void 0 ? void 0 : _this$joinConfig8.delayedLeaveEventRestartLocalTimeoutMs) !== null && _this$joinConfig$dela2 !== void 0 ? _this$joinConfig$dela2 : 2000;
+    return this.joinConfig?.delayedLeaveEventRestartLocalTimeoutMs ?? 2000;
   }
 
   // LOOP HANDLER:
-  membershipLoopHandler(type) {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      switch (type) {
-        case MembershipActionType.SendDelayedEvent:
-          {
-            // Before we start we check if we come from a state where we have a delay id.
-            if (!_this2.state.delayId) {
-              return _this2.sendOrResendDelayedLeaveEvent(); // 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.SendDelayedEvent`.
-              // We might still have our delayed event from the previous participation and dependent on the server this might not
-              // get removed automatically 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.cancelKnownDelayIdBeforeSendDelayedEvent(_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(MembershipActionType.SendDelayedEvent);
-            }
-            return _this2.restartDelayedEvent(_this2.state.delayId);
-          }
-        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);
-            }
+  async membershipLoopHandler(type) {
+    switch (type) {
+      case MembershipActionType.SendDelayedEvent:
+        {
+          // Before we start we check if we come from a state where we have a delay id.
+          if (!this.state.delayId) {
+            return this.sendOrResendDelayedLeaveEvent(); // 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.SendDelayedEvent`.
+            // We might still have our delayed event from the previous participation and dependent on the server this might not
+            // get removed automatically 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 this.cancelKnownDelayIdBeforeSendDelayedEvent(this.state.delayId);
           }
-        case MembershipActionType.SendJoinEvent:
-          {
-            return _this2.sendJoinEvent();
+        }
+      case MembershipActionType.RestartDelayedEvent:
+        {
+          if (!this.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(MembershipActionType.SendDelayedEvent);
           }
-        case MembershipActionType.UpdateExpiry:
-          {
-            return _this2.updateExpiryOnJoinedEvent();
+          return this.restartDelayedEvent(this.state.delayId);
+        }
+      case MembershipActionType.SendScheduledDelayedLeaveEvent:
+        {
+          // We are already good
+          if (!this.state.hasMemberStateEvent) {
+            return {
+              replace: []
+            };
           }
-        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();
+          if (this.state.delayId) {
+            return this.sendScheduledDelayedLeaveEventOrFallbackToSendLeaveEvent(this.state.delayId);
+          } else {
+            return createInsertActionUpdate(MembershipActionType.SendLeaveEvent);
           }
-      }
-    })();
-  }
-  // HANDLERS (used in the membershipLoopHandler)
-  sendOrResendDelayedLeaveEvent() {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      // We can reach this at the start of a call (where we do not yet have a membership: state.hasMemberStateEvent=false)
-      // or during a call if the state event canceled our delayed event or caused by an unexpected error that removed our delayed event.
-      // (Another client could have canceled it, the homeserver might have removed/lost it due to a restart, ...)
-      // In the `then` and `catch` block we treat both cases differently. "if (this.state.hasMemberStateEvent) {} else {}"
-      return yield _this3.clientSendDelayedDisconnectMembership().then(response => {
-        _this3.state.expectedServerDelayLeaveTs = Date.now() + _this3.delayedLeaveEventDelayMs;
-        _this3.setAndEmitProbablyLeft(false);
-        // On success we reset retries and set delayId.
-        _this3.resetRateLimitCounter(MembershipActionType.SendDelayedEvent);
-        _this3.setAndEmitDelayId(response.delay_id);
-        if (_this3.state.hasMemberStateEvent) {
-          // This action was scheduled because the previous delayed event was cancelled
-          // due to lack of https://github.com/element-hq/synapse/pull/17810
-          return createInsertActionUpdate(MembershipActionType.RestartDelayedEvent, _this3.delayedLeaveEventRestartMs);
-        } else {
-          // This action was scheduled because we are in the process of joining
-          return createInsertActionUpdate(MembershipActionType.SendJoinEvent);
         }
-      }).catch(e => {
-        var repeatActionType = MembershipActionType.SendDelayedEvent;
-        if (_this3.manageMaxDelayExceededSituation(e)) {
-          return createInsertActionUpdate(repeatActionType);
+      case MembershipActionType.SendJoinEvent:
+        {
+          return this.sendJoinEvent();
         }
-        var update = _this3.actionUpdateFromErrors(e, repeatActionType, "_unstable_sendDelayedStateEvent");
-        if (update) return update;
-        if (_this3.state.hasMemberStateEvent) {
-          // This action was scheduled because the previous delayed event was cancelled
-          // due to lack of https://github.com/element-hq/synapse/pull/17810
-
-          // Don't do any other delayed event work if its not supported.
-          if (_this3.isUnsupportedDelayedEndpoint(e)) return {};
-          throw Error("Could not send delayed event, even though delayed events are supported. " + e);
-        } else {
-          // This action was scheduled because we are in the process of joining
-          // log and fall through
-          if (_this3.isUnsupportedDelayedEndpoint(e)) {
-            _this3.logger.info("Not using delayed event because the endpoint is not supported");
-          } else {
-            _this3.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);
+      case MembershipActionType.UpdateExpiry:
+        {
+          return this.updateExpiryOnJoinedEvent();
         }
-      });
-    })();
-  }
-  cancelKnownDelayIdBeforeSendDelayedEvent(delayId) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      // Remove all running updates and restarts
-      return yield _this4.client._unstable_cancelScheduledDelayedEvent(delayId).then(() => {
-        _this4.setAndEmitDelayId(undefined);
-        _this4.resetRateLimitCounter(MembershipActionType.SendDelayedEvent);
-        return createReplaceActionUpdate(MembershipActionType.SendDelayedEvent);
-      }).catch(e => {
-        var repeatActionType = MembershipActionType.SendDelayedEvent;
-        var update = _this4.actionUpdateFromErrors(e, repeatActionType, "cancelScheduledDelayedEvent");
-        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.setAndEmitDelayId(undefined);
-          return createReplaceActionUpdate(repeatActionType);
+      case MembershipActionType.SendLeaveEvent:
+        {
+          // We are good already
+          if (!this.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 this.sendFallbackLeaveEvent();
         }
-        if (_this4.isUnsupportedDelayedEndpoint(e)) {
-          return createReplaceActionUpdate(MembershipActionType.SendJoinEvent);
+    }
+  }
+  // HANDLERS (used in the membershipLoopHandler)
+  async sendOrResendDelayedLeaveEvent() {
+    // We can reach this at the start of a call (where we do not yet have a membership: state.hasMemberStateEvent=false)
+    // or during a call if the state event canceled our delayed event or caused by an unexpected error that removed our delayed event.
+    // (Another client could have canceled it, the homeserver might have removed/lost it due to a restart, ...)
+    // In the `then` and `catch` block we treat both cases differently. "if (this.state.hasMemberStateEvent) {} else {}"
+    return await this.clientSendDelayedDisconnectMembership().then(response => {
+      this.state.expectedServerDelayLeaveTs = Date.now() + this.delayedLeaveEventDelayMs;
+      this.setAndEmitProbablyLeft(false);
+      // On success we reset retries and set delayId.
+      this.resetRateLimitCounter(MembershipActionType.SendDelayedEvent);
+      this.setAndEmitDelayId(response.delay_id);
+      if (this.state.hasMemberStateEvent) {
+        // This action was scheduled because the previous delayed event was cancelled
+        // due to lack of https://github.com/element-hq/synapse/pull/17810
+        return createInsertActionUpdate(MembershipActionType.RestartDelayedEvent, this.delayedLeaveEventRestartMs);
+      } else {
+        // This action was scheduled because we are in the process of joining
+        return createInsertActionUpdate(MembershipActionType.SendJoinEvent);
+      }
+    }).catch(e => {
+      const repeatActionType = MembershipActionType.SendDelayedEvent;
+      if (this.manageMaxDelayExceededSituation(e)) {
+        return createInsertActionUpdate(repeatActionType);
+      }
+      const update = this.actionUpdateFromErrors(e, repeatActionType, "_unstable_sendDelayedStateEvent");
+      if (update) return update;
+      if (this.state.hasMemberStateEvent) {
+        // This action was scheduled because the previous delayed event was cancelled
+        // due to lack of https://github.com/element-hq/synapse/pull/17810
+
+        // Don't do any other delayed event work if its not supported.
+        if (this.isUnsupportedDelayedEndpoint(e)) return {};
+        throw Error("Could not send delayed event, even though delayed events are supported. " + e);
+      } else {
+        // This action was scheduled because we are in the process of joining
+        // log and fall through
+        if (this.isUnsupportedDelayedEndpoint(e)) {
+          this.logger.info("Not using delayed event because the endpoint is not supported");
+        } else {
+          this.logger.info("Not using delayed event because: " + e);
         }
-        // We do not just ignore and log this error since we would also need to reset the delayId.
+        // On any other error we fall back to not using delayed events and send the join state event immediately
+        return createInsertActionUpdate(MembershipActionType.SendJoinEvent);
+      }
+    });
+  }
+  async cancelKnownDelayIdBeforeSendDelayedEvent(delayId) {
+    // Remove all running updates and restarts
+    return await this.client._unstable_cancelScheduledDelayedEvent(delayId).then(() => {
+      this.setAndEmitDelayId(undefined);
+      this.resetRateLimitCounter(MembershipActionType.SendDelayedEvent);
+      return createReplaceActionUpdate(MembershipActionType.SendDelayedEvent);
+    }).catch(e => {
+      const repeatActionType = MembershipActionType.SendDelayedEvent;
+      const update = this.actionUpdateFromErrors(e, repeatActionType, "cancelScheduledDelayedEvent");
+      if (update) return update;
+      if (this.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.
+        this.setAndEmitDelayId(undefined);
+        return createReplaceActionUpdate(repeatActionType);
+      }
+      if (this.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");
-      });
-    })();
+      // 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");
+    });
   }
   setAndEmitProbablyLeft(probablyLeft) {
     if (this.state.probablyLeft === probablyLeft) {
@@ -513,155 +494,140 @@ export class MembershipManager extends TypedEventEmitter {
     this.state.delayId = delayId;
     this.emit(MembershipManagerEvent.DelayIdChanged, this.state.delayId);
   }
-  restartDelayedEvent(delayId) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      // Compute the duration until we expect the server to send the delayed leave event.
-      var durationUntilServerDelayedLeave = _this5.state.expectedServerDelayLeaveTs ? _this5.state.expectedServerDelayLeaveTs - Date.now() : undefined;
-      var abortPromise = new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new AbortError("Restart delayed event timed out before the HS responded"));
-        },
-        // We abort immediately at the time where we expect the server to send the delayed leave event.
-        // At this point we want the catch block to run and set the `probablyLeft` state.
-        //
-        // While we are already in probablyLeft state, we use the unaltered delayedLeaveEventRestartLocalTimeoutMs.
-        durationUntilServerDelayedLeave !== undefined && !_this5.state.probablyLeft ? Math.min(_this5.delayedLeaveEventRestartLocalTimeoutMs, durationUntilServerDelayedLeave) : _this5.delayedLeaveEventRestartLocalTimeoutMs);
-      });
-
-      // The obvious choice here would be to use the `IRequestOpts` to set the timeout. Since this call might be forwarded
-      // to the widget driver this information would get lost. That is why we mimic the AbortError using the race.
-      return yield Promise.race([_this5.client._unstable_restartScheduledDelayedEvent(delayId), abortPromise]).then(() => {
-        // Whenever we successfully restart the delayed event we update the `state.expectedServerDelayLeaveTs`
-        // which stores the predicted timestamp at which the server will send the delayed leave event if there wont be any further
-        // successful restart requests.
-        _this5.state.expectedServerDelayLeaveTs = Date.now() + _this5.delayedLeaveEventDelayMs;
-        _this5.resetRateLimitCounter(MembershipActionType.RestartDelayedEvent);
-        _this5.setAndEmitProbablyLeft(false);
-        return createInsertActionUpdate(MembershipActionType.RestartDelayedEvent, _this5.delayedLeaveEventRestartMs);
-      }).catch(e => {
-        if (_this5.state.expectedServerDelayLeaveTs && _this5.state.expectedServerDelayLeaveTs <= Date.now()) {
-          // Once we reach this point it's likely that the server is sending the delayed leave event so we emit `probablyLeft = true`.
-          // It will emit `probablyLeft = false` once we notice about our leave through sync and successfully setup a new state event.
-          _this5.setAndEmitProbablyLeft(true);
-        }
-        var repeatActionType = MembershipActionType.RestartDelayedEvent;
-        if (_this5.isNotFoundError(e)) {
-          _this5.setAndEmitDelayId(undefined);
-          return createInsertActionUpdate(MembershipActionType.SendDelayedEvent);
-        }
-        // 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, "restartScheduledDelayedEvent");
-        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);
-      });
-    })();
-  }
-  sendScheduledDelayedLeaveEventOrFallbackToSendLeaveEvent(delayId) {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this6.client._unstable_sendScheduledDelayedEvent(delayId).then(() => {
-        _this6.state.hasMemberStateEvent = false;
-        _this6.setAndEmitDelayId(undefined);
-        _this6.resetRateLimitCounter(MembershipActionType.SendScheduledDelayedLeaveEvent);
-        return {
-          replace: []
-        };
-      }).catch(e => {
-        var repeatActionType = MembershipActionType.SendLeaveEvent;
-        if (_this6.isUnsupportedDelayedEndpoint(e)) return {};
-        if (_this6.isNotFoundError(e)) {
-          _this6.setAndEmitDelayId(undefined);
-          return createInsertActionUpdate(repeatActionType);
-        }
-        var update = _this6.actionUpdateFromErrors(e, repeatActionType, "sendScheduledDelayedEvent");
-        if (update) return update;
+  async restartDelayedEvent(delayId) {
+    // Compute the duration until we expect the server to send the delayed leave event.
+    const durationUntilServerDelayedLeave = this.state.expectedServerDelayLeaveTs ? this.state.expectedServerDelayLeaveTs - Date.now() : undefined;
+    const abortPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new AbortError("Restart delayed event timed out before the HS responded"));
+      },
+      // We abort immediately at the time where we expect the server to send the delayed leave event.
+      // At this point we want the catch block to run and set the `probablyLeft` state.
+      //
+      // While we are already in probablyLeft state, we use the unaltered delayedLeaveEventRestartLocalTimeoutMs.
+      durationUntilServerDelayedLeave !== undefined && !this.state.probablyLeft ? Math.min(this.delayedLeaveEventRestartLocalTimeoutMs, durationUntilServerDelayedLeave) : this.delayedLeaveEventRestartLocalTimeoutMs);
+    });
 
-        // On any other error we fall back to SendLeaveEvent (this includes hard errors from rate limiting)
-        _this6.logger.warn("Encountered unexpected error during SendScheduledDelayedLeaveEvent. Falling back to SendLeaveEvent", e);
+    // The obvious choice here would be to use the `IRequestOpts` to set the timeout. Since this call might be forwarded
+    // to the widget driver this information would get lost. That is why we mimic the AbortError using the race.
+    return await Promise.race([this.client._unstable_restartScheduledDelayedEvent(delayId), abortPromise]).then(() => {
+      // Whenever we successfully restart the delayed event we update the `state.expectedServerDelayLeaveTs`
+      // which stores the predicted timestamp at which the server will send the delayed leave event if there wont be any further
+      // successful restart requests.
+      this.state.expectedServerDelayLeaveTs = Date.now() + this.delayedLeaveEventDelayMs;
+      this.resetRateLimitCounter(MembershipActionType.RestartDelayedEvent);
+      this.setAndEmitProbablyLeft(false);
+      return createInsertActionUpdate(MembershipActionType.RestartDelayedEvent, this.delayedLeaveEventRestartMs);
+    }).catch(e => {
+      if (this.state.expectedServerDelayLeaveTs && this.state.expectedServerDelayLeaveTs <= Date.now()) {
+        // Once we reach this point it's likely that the server is sending the delayed leave event so we emit `probablyLeft = true`.
+        // It will emit `probablyLeft = false` once we notice about our leave through sync and successfully setup a new state event.
+        this.setAndEmitProbablyLeft(true);
+      }
+      const repeatActionType = MembershipActionType.RestartDelayedEvent;
+      if (this.isNotFoundError(e)) {
+        this.setAndEmitDelayId(undefined);
+        return createInsertActionUpdate(MembershipActionType.SendDelayedEvent);
+      }
+      // If the HS does not support delayed events we wont reschedule.
+      if (this.isUnsupportedDelayedEndpoint(e)) return {};
+
+      // TODO this also needs a test: get rate limit while checking id delayed event is scheduled
+      const update = this.actionUpdateFromErrors(e, repeatActionType, "restartScheduledDelayedEvent");
+      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);
+    });
+  }
+  async sendScheduledDelayedLeaveEventOrFallbackToSendLeaveEvent(delayId) {
+    return await this.client._unstable_sendScheduledDelayedEvent(delayId).then(() => {
+      this.state.hasMemberStateEvent = false;
+      this.setAndEmitDelayId(undefined);
+      this.resetRateLimitCounter(MembershipActionType.SendScheduledDelayedLeaveEvent);
+      return {
+        replace: []
+      };
+    }).catch(e => {
+      const repeatActionType = MembershipActionType.SendLeaveEvent;
+      if (this.isUnsupportedDelayedEndpoint(e)) return {};
+      if (this.isNotFoundError(e)) {
+        this.setAndEmitDelayId(undefined);
         return createInsertActionUpdate(repeatActionType);
-      });
-    })();
-  }
-  sendJoinEvent() {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this7.clientSendMembership(_this7.makeMyMembership(_this7.membershipEventExpiryMs)).then(() => {
-        _this7.setAndEmitProbablyLeft(false);
-        _this7.state.startTime = Date.now();
-        // The next update should already use twice the membershipEventExpiryTimeout
-        _this7.state.expireUpdateIterations = 1;
-        _this7.state.hasMemberStateEvent = true;
-        _this7.resetRateLimitCounter(MembershipActionType.SendJoinEvent);
-        // An UpdateExpiry action might be left over from a previous join event.
-        // We can reach sendJoinEvent when the delayed leave event gets send by the HS.
-        // The branch where we might have a leftover UpdateExpiry action is:
-        // RestartDelayedEvent (cannot find it, server removed it)
-        // -> SendDelayedEvent (send new delayed event)
-        // -> SendJoinEvent (here with a still scheduled UpdateExpiry action)
-        var actionsWithoutUpdateExpiry = _this7.scheduler.actions.filter(a => a.type !== MembershipActionType.UpdateExpiry &&
-        // A new UpdateExpiry action with an updated will be scheduled,
-        a.type !== MembershipActionType.SendJoinEvent // Manually remove the SendJoinEvent action,
-        );
-        return {
-          replace: [...actionsWithoutUpdateExpiry,
-          // To check if the delayed event is still there or got removed by inserting the stateEvent, we need to restart it.
-          {
-            ts: Date.now(),
-            type: MembershipActionType.RestartDelayedEvent
-          }, {
-            ts: _this7.computeNextExpiryActionTs(_this7.state.expireUpdateIterations),
-            type: MembershipActionType.UpdateExpiry
-          }]
-        };
-      }).catch(e => {
-        var update = _this7.actionUpdateFromErrors(e, MembershipActionType.SendJoinEvent, "sendStateEvent");
-        if (update) return update;
-        throw e;
-      });
-    })();
-  }
-  updateExpiryOnJoinedEvent() {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      var nextExpireUpdateIteration = _this8.state.expireUpdateIterations + 1;
-      return yield _this8.clientSendMembership(_this8.makeMyMembership(_this8.membershipEventExpiryMs * nextExpireUpdateIteration)).then(() => {
-        // Success, we reset retries and schedule update.
-        _this8.resetRateLimitCounter(MembershipActionType.UpdateExpiry);
-        _this8.state.expireUpdateIterations = nextExpireUpdateIteration;
-        return {
-          insert: [{
-            ts: _this8.computeNextExpiryActionTs(nextExpireUpdateIteration),
-            type: MembershipActionType.UpdateExpiry
-          }]
-        };
-      }).catch(e => {
-        var update = _this8.actionUpdateFromErrors(e, MembershipActionType.UpdateExpiry, "sendStateEvent");
-        if (update) return update;
-        throw e;
-      });
-    })();
-  }
-  sendFallbackLeaveEvent() {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this9.clientSendMembership({}).then(() => {
-        _this9.resetRateLimitCounter(MembershipActionType.SendLeaveEvent);
-        _this9.state.hasMemberStateEvent = false;
-        return {
-          replace: []
-        };
-      }).catch(e => {
-        var update = _this9.actionUpdateFromErrors(e, MembershipActionType.SendLeaveEvent, "sendStateEvent");
-        if (update) return update;
-        throw e;
-      });
-    })();
+      }
+      const update = this.actionUpdateFromErrors(e, repeatActionType, "sendScheduledDelayedEvent");
+      if (update) return update;
+
+      // On any other error we fall back to SendLeaveEvent (this includes hard errors from rate limiting)
+      this.logger.warn("Encountered unexpected error during SendScheduledDelayedLeaveEvent. Falling back to SendLeaveEvent", e);
+      return createInsertActionUpdate(repeatActionType);
+    });
+  }
+  async sendJoinEvent() {
+    return await this.clientSendMembership(this.makeMyMembership(this.membershipEventExpiryMs)).then(() => {
+      this.setAndEmitProbablyLeft(false);
+      this.state.startTime = Date.now();
+      // The next update should already use twice the membershipEventExpiryTimeout
+      this.state.expireUpdateIterations = 1;
+      this.state.hasMemberStateEvent = true;
+      this.resetRateLimitCounter(MembershipActionType.SendJoinEvent);
+      // An UpdateExpiry action might be left over from a previous join event.
+      // We can reach sendJoinEvent when the delayed leave event gets send by the HS.
+      // The branch where we might have a leftover UpdateExpiry action is:
+      // RestartDelayedEvent (cannot find it, server removed it)
+      // -> SendDelayedEvent (send new delayed event)
+      // -> SendJoinEvent (here with a still scheduled UpdateExpiry action)
+      const actionsWithoutUpdateExpiry = this.scheduler.actions.filter(a => a.type !== MembershipActionType.UpdateExpiry &&
+      // A new UpdateExpiry action with an updated will be scheduled,
+      a.type !== MembershipActionType.SendJoinEvent // Manually remove the SendJoinEvent action,
+      );
+      return {
+        replace: [...actionsWithoutUpdateExpiry,
+        // To check if the delayed event is still there or got removed by inserting the stateEvent, we need to restart it.
+        {
+          ts: Date.now(),
+          type: MembershipActionType.RestartDelayedEvent
+        }, {
+          ts: this.computeNextExpiryActionTs(this.state.expireUpdateIterations),
+          type: MembershipActionType.UpdateExpiry
+        }]
+      };
+    }).catch(e => {
+      const update = this.actionUpdateFromErrors(e, MembershipActionType.SendJoinEvent, "sendStateEvent");
+      if (update) return update;
+      throw e;
+    });
+  }
+  async updateExpiryOnJoinedEvent() {
+    const nextExpireUpdateIteration = this.state.expireUpdateIterations + 1;
+    return await this.clientSendMembership(this.makeMyMembership(this.membershipEventExpiryMs * nextExpireUpdateIteration)).then(() => {
+      // Success, we reset retries and schedule update.
+      this.resetRateLimitCounter(MembershipActionType.UpdateExpiry);
+      this.state.expireUpdateIterations = nextExpireUpdateIteration;
+      return {
+        insert: [{
+          ts: this.computeNextExpiryActionTs(nextExpireUpdateIteration),
+          type: MembershipActionType.UpdateExpiry
+        }]
+      };
+    }).catch(e => {
+      const update = this.actionUpdateFromErrors(e, MembershipActionType.UpdateExpiry, "sendStateEvent");
+      if (update) return update;
+      throw e;
+    });
+  }
+  async sendFallbackLeaveEvent() {
+    return await this.clientSendMembership({}).then(() => {
+      this.resetRateLimitCounter(MembershipActionType.SendLeaveEvent);
+      this.state.hasMemberStateEvent = false;
+      return {
+        replace: []
+      };
+    }).catch(e => {
+      const update = this.actionUpdateFromErrors(e, MembershipActionType.SendLeaveEvent, "sendStateEvent");
+      if (update) return update;
+      throw e;
+    });
   }
 
   // HELPERS
@@ -672,14 +638,14 @@ export class MembershipManager extends TypedEventEmitter {
   makeMembershipStateKey(localUserId, localDeviceId) {
     // INFO_SLOT_ID_LEGACY_CASE  (search for all occurances of this INFO to get the full picture)
     // Revert back to "" just for the state key (state keys are always legacy. we use sticky events for non legacy events)
-    var application = this.slotDescription.application;
-    var needsEmptyStringRoomFix = application === "m.call" && this.slotDescription.id === "ROOM";
-    var slotId = needsEmptyStringRoomFix ? "" : this.slotDescription.id;
-    var stateKey = "".concat(localUserId, "_").concat(localDeviceId, "_").concat(application).concat(slotId);
+    const application = this.slotDescription.application;
+    const needsEmptyStringRoomFix = application === "m.call" && this.slotDescription.id === "ROOM";
+    const slotId = needsEmptyStringRoomFix ? "" : this.slotDescription.id;
+    const stateKey = `${localUserId}_${localDeviceId}_${application}${slotId}`;
     if (/^org\.matrix\.msc(3757|3779)\b/.exec(this.room.getVersion())) {
       return stateKey;
     } else {
-      return "_".concat(stateKey);
+      return `_${stateKey}`;
     }
   }
 
@@ -688,21 +654,20 @@ export class MembershipManager extends TypedEventEmitter {
    * @returns Only returns `SessionMembershipData`
    */
   makeMyMembership(expires) {
-    var _this$fociPreferred, _this$fociPreferred2;
-    var ownMembership = this.ownMembership;
-    var needsEmptyStringRoomFix = this.slotDescription.application === "m.call" && this.slotDescription.id === "ROOM";
-    var focusObjects = this.rtcTransport === undefined ? {
+    const ownMembership = this.ownMembership;
+    const needsEmptyStringRoomFix = this.slotDescription.application === "m.call" && this.slotDescription.id === "ROOM";
+    const focusObjects = this.rtcTransport === undefined ? {
       focus_active: {
         type: "livekit",
         focus_selection: "oldest_membership"
       },
-      foci_preferred: (_this$fociPreferred = this.fociPreferred) !== null && _this$fociPreferred !== void 0 ? _this$fociPreferred : []
+      foci_preferred: this.fociPreferred ?? []
     } : {
       focus_active: {
         type: "livekit",
         focus_selection: "multi_sfu"
       },
-      foci_preferred: [this.rtcTransport, ...((_this$fociPreferred2 = this.fociPreferred) !== null && _this$fociPreferred2 !== void 0 ? _this$fociPreferred2 : [])]
+      foci_preferred: [this.rtcTransport, ...(this.fociPreferred ?? [])]
     };
     return _objectSpread(_objectSpread({
       "application": this.slotDescription.application,
@@ -714,7 +679,7 @@ export class MembershipManager extends TypedEventEmitter {
       // DO NOT use this.memberId here since that is the state key (using application...)
       // But for session events we use the colon seperated userId and deviceId. The SFU will automatically
       // assign those values to the media participant for those versions.
-      "membershipID": "".concat(this.userId, ":").concat(this.deviceId),
+      "membershipID": `${this.userId}:${this.deviceId}`,
       expires,
       "m.call.intent": this.callIntent
     }, focusObjects), ownMembership !== undefined ? {
@@ -740,7 +705,7 @@ export class MembershipManager extends TypedEventEmitter {
    */
   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"];
+      const maxDelayAllowed = error.data["org.matrix.msc4140.max_delay"];
       if (typeof maxDelayAllowed === "number" && this.delayedLeaveEventDelayMs > maxDelayAllowed) {
         this.delayedLeaveEventDelayMsOverride = maxDelayAllowed;
       }
@@ -750,9 +715,9 @@ export class MembershipManager extends TypedEventEmitter {
     return false;
   }
   actionUpdateFromErrors(error, type, method) {
-    var updateLimit = this.actionUpdateFromRateLimitError(error, method, type);
+    const updateLimit = this.actionUpdateFromRateLimitError(error, method, type);
     if (updateLimit) return updateLimit;
-    var updateNetwork = this.actionUpdateFromNetworkErrorRetry(error, type);
+    const updateNetwork = this.actionUpdateFromNetworkErrorRetry(error, type);
     if (updateNetwork) return updateNetwork;
   }
   /**
@@ -765,23 +730,21 @@ export class MembershipManager extends TypedEventEmitter {
    * 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;
+    const rateLimitRetries = this.state.rateLimitRetries.get(type) ?? 0;
     if (rateLimitRetries < this.maximumRateLimitRetryCount) {
-      var resendDelay;
-      var defaultMs = 5000;
+      let resendDelay;
+      const defaultMs = 5000;
       try {
-        var _error$getRetryAfterM;
-        resendDelay = (_error$getRetryAfterM = error.getRetryAfterMs()) !== null && _error$getRetryAfterM !== void 0 ? _error$getRetryAfterM : defaultMs;
-        this.logger.info("Rate limited by server, retrying in ".concat(resendDelay, "ms"));
+        resendDelay = error.getRetryAfterMs() ?? defaultMs;
+        this.logger.info(`Rate limited by server, retrying in ${resendDelay}ms`);
       } catch (e) {
-        this.logger.warn("Error while retrieving a rate-limit retry delay, retrying after default delay of ".concat(defaultMs), e);
+        this.logger.warn(`Error while retrieving a rate-limit retry delay, retrying after default delay of ${defaultMs}`, e);
         resendDelay = defaultMs;
       }
       this.state.rateLimitRetries.set(type, rateLimitRetries + 1);
@@ -802,16 +765,15 @@ export class MembershipManager extends TypedEventEmitter {
    * 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;
+    const retries = this.state.networkErrorRetries.get(type) ?? 0;
 
     // Strings for error logging
-    var retryDurationString = this.networkErrorRetryMs / 1000 + "s";
-    var retryCounterString = "(" + retries + "/" + this.maximumNetworkErrorRetryCount + ")";
+    const retryDurationString = this.networkErrorRetryMs / 1000 + "s";
+    const retryCounterString = "(" + retries + "/" + this.maximumNetworkErrorRetryCount + ")";
 
     // Variables for scheduling the new event
-    var retryDuration = this.networkErrorRetryMs;
+    let retryDuration = this.networkErrorRetryMs;
     if (error instanceof Error && error.name === "AbortError") {
       // We do not wait for the timeout on local timeouts.
       retryDuration = 0;
@@ -859,9 +821,11 @@ export class MembershipManager extends TypedEventEmitter {
     this.state.networkErrorRetries.set(type, 0);
   }
   get status() {
-    var actions = this.scheduler.actions;
+    const actions = this.scheduler.actions;
     if (actions.length === 1) {
-      var type = actions[0].type;
+      const {
+        type
+      } = actions[0];
       switch (type) {
         case MembershipActionType.SendDelayedEvent:
         case MembershipActionType.SendJoinEvent:
@@ -876,16 +840,16 @@ export class MembershipManager extends TypedEventEmitter {
         // pass through as not expected
       }
     } else if (actions.length === 2) {
-      var types = actions.map(a => a.type);
+      const types = actions.map(a => a.type);
       // normal state for connected with delayed events
       if ((types.includes(MembershipActionType.RestartDelayedEvent) || types.includes(MembershipActionType.SendDelayedEvent) && this.state.hasMemberStateEvent) && types.includes(MembershipActionType.UpdateExpiry)) {
         return Status.Connected;
       }
     } else if (actions.length === 3) {
-      var _types = actions.map(a => a.type);
+      const 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)) {
+      if (types.filter(t => t === MembershipActionType.RestartDelayedEvent).length === 2 && types.includes(MembershipActionType.UpdateExpiry)) {
         return Status.Connected;
       }
     }
@@ -927,8 +891,7 @@ export class StickyEventMembershipManager extends MembershipManager {
     this.memberId = memberId;
   }
   actionUpdateFromErrors(e, t, m) {
-    var _StickyEventMembershi;
-    return super.actionUpdateFromErrors(e, t, (_StickyEventMembershi = StickyEventMembershipManager.nameMap.get(m)) !== null && _StickyEventMembershi !== void 0 ? _StickyEventMembershi : "unknown");
+    return super.actionUpdateFromErrors(e, t, StickyEventMembershipManager.nameMap.get(m) ?? "unknown");
   }
 
   /**
@@ -936,12 +899,12 @@ export class StickyEventMembershipManager extends MembershipManager {
    * @returns Only returns `RtcMembershipData`
    */
   makeMyMembership() {
-    var ownMembership = this.ownMembership;
-    var livekitTransport = isLivekitTransportConfig(this.rtcTransport) ? this.rtcTransport : undefined;
-    var relationObject = ownMembership !== null && ownMembership !== void 0 && ownMembership.eventId ? {
+    const ownMembership = this.ownMembership;
+    const livekitTransport = isLivekitTransportConfig(this.rtcTransport) ? this.rtcTransport : undefined;
+    const relationObject = ownMembership?.eventId ? {
       "m.relation": {
         rel_type: RelationType.Reference,
-        event_id: ownMembership === null || ownMembership === void 0 ? void 0 : ownMembership.eventId
+        event_id: ownMembership?.eventId
       }
     } : {};
     return _objectSpread({