@openclaw/matrix 2026.7.1-beta.1 → 2026.7.1-beta.4

package/node_modules/matrix-js-sdk/lib/embedded.js

@@ -1,9 +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; }
-function _asyncIterator(r) { var n, t, o, e = 2; for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) { if (t && null != (n = r[t])) return n.call(r); if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r)); t = "@@asyncIterator", o = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
-function AsyncFromSyncIterator(r) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var n = r.done; return Promise.resolve(r.value).then(function (r) { return { value: r, done: n }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(r) { this.s = r, this.n = r.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function _return(r) { var n = this.s.return; return void 0 === n ? Promise.resolve({ value: r, done: !0 }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); }, throw: function _throw(r) { var n = this.s.return; return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(r); }
 /*
 Copyright 2022 The Matrix.org Foundation C.I.C.
 
@@ -32,7 +28,7 @@ import { ConnectionError, MatrixError } from "./http-api/errors.js";
 import { User } from "./models/user.js";
 import { MapWithDefault, recursiveMapToObject } from "./utils.js";
 import { TypedEventEmitter, UnsupportedDelayedEventsEndpointError } from "./matrix.js";
-export var RoomWidgetClientEvent = /*#__PURE__*/function (RoomWidgetClientEvent) {
+export let RoomWidgetClientEvent = /*#__PURE__*/function (RoomWidgetClientEvent) {
   RoomWidgetClientEvent["PendingEventsChanged"] = "PendingEvent.pendingEventsChanged";
   return RoomWidgetClientEvent;
 }({});
@@ -53,190 +49,162 @@ export class RoomWidgetClient extends MatrixClient {
    *   or if the the widget wants to send the `ContentLoaded` action at a later point in time after the initial setup.
    */
   constructor(widgetApi, capabilities, _roomId, opts, sendContentLoaded) {
-    var _this, _capabilities$receive;
     super(opts);
-    _this = this;
+    _defineProperty(this, "room", void 0);
+    _defineProperty(this, "widgetApiReady", void 0);
+    _defineProperty(this, "roomStateSynced", void 0);
+    _defineProperty(this, "lifecycle", void 0);
     _defineProperty(this, "syncState", null);
     _defineProperty(this, "pendingSendingEventsTxId", []);
     _defineProperty(this, "eventEmitter", new TypedEventEmitter());
     _defineProperty(this, "syncApiResolver", Promise.withResolvers());
-    _defineProperty(this, "updateTxId", /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator(function* (event) {
-        // We update the txId for remote echos that originate from this client.
-        // This happens with the help of `pendingSendingEventsTxId` where we store all events that are currently sending
-        // with their widget txId and once ready the final evId.
-        if (
-        // This could theoretically be an event send by this device
-        // In that case we need to update the txId of the event because the embedded client/widget
-        // knows this event with a different transaction Id than what was used by the host client.
-        event.getSender() === _this.getUserId() &&
-        // We optimize by not blocking events from types that we have not send
-        // with this client.
-        _this.pendingSendingEventsTxId.some(p => event.getType() === p.type)) {
-          var _this$pendingSendingE;
-          // Compare by event Id if we have a matching pending event where we know the txId.
-          var matchingTxId = (_this$pendingSendingE = _this.pendingSendingEventsTxId.find(p => p.id === event.getId())) === null || _this$pendingSendingE === void 0 ? void 0 : _this$pendingSendingE.txId;
-          // Block any further processing of this event until we have received the sending response.
-          // -> until we know the event id.
-          // -> until we have not pending events anymore.
-          while (!matchingTxId && _this.pendingSendingEventsTxId.length > 0) {
-            var _this$pendingSendingE2;
-            // Recheck whenever the PendingEventsChanged
-            yield new Promise(resolve => _this.eventEmitter.once(RoomWidgetClientEvent.PendingEventsChanged, () => resolve()));
-            matchingTxId = (_this$pendingSendingE2 = _this.pendingSendingEventsTxId.find(p => p.id === event.getId())) === null || _this$pendingSendingE2 === void 0 ? void 0 : _this$pendingSendingE2.txId;
-          }
+    _defineProperty(this, "updateTxId", async event => {
+      // We update the txId for remote echos that originate from this client.
+      // This happens with the help of `pendingSendingEventsTxId` where we store all events that are currently sending
+      // with their widget txId and once ready the final evId.
+      if (
+      // This could theoretically be an event send by this device
+      // In that case we need to update the txId of the event because the embedded client/widget
+      // knows this event with a different transaction Id than what was used by the host client.
+      event.getSender() === this.getUserId() &&
+      // We optimize by not blocking events from types that we have not send
+      // with this client.
+      this.pendingSendingEventsTxId.some(p => event.getType() === p.type)) {
+        // Compare by event Id if we have a matching pending event where we know the txId.
+        let matchingTxId = this.pendingSendingEventsTxId.find(p => p.id === event.getId())?.txId;
+        // Block any further processing of this event until we have received the sending response.
+        // -> until we know the event id.
+        // -> until we have not pending events anymore.
+        while (!matchingTxId && this.pendingSendingEventsTxId.length > 0) {
+          // Recheck whenever the PendingEventsChanged
+          await new Promise(resolve => this.eventEmitter.once(RoomWidgetClientEvent.PendingEventsChanged, () => resolve()));
+          matchingTxId = this.pendingSendingEventsTxId.find(p => p.id === event.getId())?.txId;
+        }
 
-          // We found the correct txId: we update the event and delete the entry of the pending events.
-          if (matchingTxId) {
-            event.setTxnId(matchingTxId);
-            event.setUnsigned(_objectSpread(_objectSpread({}, event.getUnsigned()), {}, {
-              transaction_id: matchingTxId
-            }));
-          }
-          _this.pendingSendingEventsTxId = _this.pendingSendingEventsTxId.filter(p => p.id !== event.getId());
+        // We found the correct txId: we update the event and delete the entry of the pending events.
+        if (matchingTxId) {
+          event.setTxnId(matchingTxId);
+          event.setUnsigned(_objectSpread(_objectSpread({}, event.getUnsigned()), {}, {
+            transaction_id: matchingTxId
+          }));
+        }
+        this.pendingSendingEventsTxId = this.pendingSendingEventsTxId.filter(p => p.id !== event.getId());
 
-          // Emit once there are no pending events anymore to release all other events that got
-          // awaited in the `while (!matchingTxId && this.pendingSendingEventsTxId.length > 0)` loop
-          // but are not send by this client.
-          if (_this.pendingSendingEventsTxId.length === 0) {
-            _this.eventEmitter.emit(RoomWidgetClientEvent.PendingEventsChanged);
-          }
+        // Emit once there are no pending events anymore to release all other events that got
+        // awaited in the `while (!matchingTxId && this.pendingSendingEventsTxId.length > 0)` loop
+        // but are not send by this client.
+        if (this.pendingSendingEventsTxId.length === 0) {
+          this.eventEmitter.emit(RoomWidgetClientEvent.PendingEventsChanged);
         }
-      });
-      return function (_x) {
-        return _ref.apply(this, arguments);
-      };
-    }());
-    _defineProperty(this, "onEvent", /*#__PURE__*/function () {
-      var _ref2 = _asyncToGenerator(function* (ev) {
-        ev.preventDefault();
+      }
+    });
+    _defineProperty(this, "onEvent", async ev => {
+      ev.preventDefault();
 
-        // Verify the room ID matches, since it's possible for the client to
-        // send us events from other rooms if this widget is always on screen
-        if (ev.detail.data.room_id === _this.roomId) {
-          var _event = new MatrixEvent(ev.detail.data);
+      // Verify the room ID matches, since it's possible for the client to
+      // send us events from other rooms if this widget is always on screen
+      if (ev.detail.data.room_id === this.roomId) {
+        const event = new MatrixEvent(ev.detail.data);
 
-          // Only inject once we have update the txId
-          yield _this.updateTxId(_event);
-          yield _this.syncApiResolver.promise;
-          if (_this.syncApi instanceof SyncApi) {
-            if (yield _this.supportUpdateState()) {
-              yield _this.syncApi.injectRoomEvents(_this.room, undefined, [], [_event]);
-            } else {
-              // Passing undefined for `stateAfterEventList` will make `injectRoomEvents` run in legacy mode
-              // -> state events in `timelineEventList` will update the state.
-              yield _this.syncApi.injectRoomEvents(_this.room, [], undefined, [_event]);
-            }
+        // Only inject once we have update the txId
+        await this.updateTxId(event);
+        await this.syncApiResolver.promise;
+        if (this.syncApi instanceof SyncApi) {
+          if (await this.supportUpdateState()) {
+            await this.syncApi.injectRoomEvents(this.room, undefined, [], [event]);
           } else {
-            // Sliding Sync
-            if (yield _this.supportUpdateState()) {
-              yield _this.syncApi.injectRoomEvents(_this.room, [], [_event]);
-            } else {
-              logger.error("slididng sync cannot be used in widget mode if the client widget driver does not support the version: 'org.matrix.msc2762_update_state'");
-            }
+            // Passing undefined for `stateAfterEventList` will make `injectRoomEvents` run in legacy mode
+            // -> state events in `timelineEventList` will update the state.
+            await this.syncApi.injectRoomEvents(this.room, [], undefined, [event]);
           }
-          _this.emit(ClientEvent.Event, _event);
-          if (_event.unstableStickyInfo !== undefined) _this.room._unstable_addStickyEvents([_event]);
-          _this.setSyncState(SyncState.Syncing);
-          logger.info("Received event ".concat(_event.getId(), " ").concat(_event.getType()));
         } else {
-          var _ev$detail$data = ev.detail.data,
-            eventId = _ev$detail$data.event_id,
-            _roomId2 = _ev$detail$data.room_id;
-          logger.info("Received event ".concat(eventId, " for a different room ").concat(_roomId2, "; discarding"));
+          // Sliding Sync
+          if (await this.supportUpdateState()) {
+            await this.syncApi.injectRoomEvents(this.room, [], [event]);
+          } else {
+            logger.error("slididng sync cannot be used in widget mode if the client widget driver does not support the version: 'org.matrix.msc2762_update_state'");
+          }
         }
-        yield _this.ack(ev);
-      });
-      return function (_x2) {
-        return _ref2.apply(this, arguments);
-      };
-    }());
-    _defineProperty(this, "onToDevice", /*#__PURE__*/function () {
-      var _ref3 = _asyncToGenerator(function* (ev) {
-        ev.preventDefault();
-        var event = new MatrixEvent({
-          type: ev.detail.data.type,
-          sender: ev.detail.data.sender,
-          content: ev.detail.data.content
-        });
-        // Mark the event as encrypted if it was, using fake contents and keys since those are unknown to us
-        if (ev.detail.data.encrypted) event.makeEncrypted(EventType.RoomMessageEncrypted, {}, "", "");
-        _this.emit(ClientEvent.ToDeviceEvent, event);
-        _this.setSyncState(SyncState.Syncing);
-        yield _this.ack(ev);
+        this.emit(ClientEvent.Event, event);
+        if (event.unstableStickyInfo !== undefined) this.room._unstable_addStickyEvents([event]);
+        this.setSyncState(SyncState.Syncing);
+        logger.info(`Received event ${event.getId()} ${event.getType()}`);
+      } else {
+        const {
+          event_id: eventId,
+          room_id: roomId
+        } = ev.detail.data;
+        logger.info(`Received event ${eventId} for a different room ${roomId}; discarding`);
+      }
+      await this.ack(ev);
+    });
+    _defineProperty(this, "onToDevice", async ev => {
+      ev.preventDefault();
+      const event = new MatrixEvent({
+        type: ev.detail.data.type,
+        sender: ev.detail.data.sender,
+        content: ev.detail.data.content
       });
-      return function (_x3) {
-        return _ref3.apply(this, arguments);
-      };
-    }());
-    _defineProperty(this, "onStateUpdate", /*#__PURE__*/function () {
-      var _ref4 = _asyncToGenerator(function* (ev) {
-        ev.preventDefault();
-        if (!(yield _this.supportUpdateState())) {
-          logger.warn("received update_state widget action but the widget driver did not claim to support 'org.matrix.msc2762_update_state'");
-        }
-        yield _this.syncApiResolver.promise;
-        for (var rawEvent of ev.detail.data.state) {
-          // Verify the room ID matches, since it's possible for the client to
-          // send us state updates from other rooms if this widget is always
-          // on screen
-          if (rawEvent.room_id === _this.roomId) {
-            var _event2 = new MatrixEvent(rawEvent);
-            if (_this.syncApi instanceof SyncApi) {
-              yield _this.syncApi.injectRoomEvents(_this.room, undefined, [_event2]);
-            } else {
-              // Sliding Sync
-              yield _this.syncApi.injectRoomEvents(_this.room, [_event2]);
-            }
-            logger.debug("Updated state entry ".concat(_event2.getType(), " ").concat(_event2.getStateKey(), " to ").concat(_event2.getId()));
+      // Mark the event as encrypted if it was, using fake contents and keys since those are unknown to us
+      if (ev.detail.data.encrypted) event.makeEncrypted(EventType.RoomMessageEncrypted, {}, "", "");
+      this.emit(ClientEvent.ToDeviceEvent, event);
+      this.setSyncState(SyncState.Syncing);
+      await this.ack(ev);
+    });
+    _defineProperty(this, "onStateUpdate", async ev => {
+      ev.preventDefault();
+      if (!(await this.supportUpdateState())) {
+        logger.warn("received update_state widget action but the widget driver did not claim to support 'org.matrix.msc2762_update_state'");
+      }
+      await this.syncApiResolver.promise;
+      for (const rawEvent of ev.detail.data.state) {
+        // Verify the room ID matches, since it's possible for the client to
+        // send us state updates from other rooms if this widget is always
+        // on screen
+        if (rawEvent.room_id === this.roomId) {
+          const event = new MatrixEvent(rawEvent);
+          if (this.syncApi instanceof SyncApi) {
+            await this.syncApi.injectRoomEvents(this.room, undefined, [event]);
           } else {
-            var _ev$detail$data2 = ev.detail.data,
-              eventId = _ev$detail$data2.event_id,
-              _roomId3 = _ev$detail$data2.room_id;
-            logger.info("Received state entry ".concat(eventId, " for a different room ").concat(_roomId3, "; discarding"));
+            // Sliding Sync
+            await this.syncApi.injectRoomEvents(this.room, [event]);
           }
+          logger.debug(`Updated state entry ${event.getType()} ${event.getStateKey()} to ${event.getId()}`);
+        } else {
+          const {
+            event_id: eventId,
+            room_id: roomId
+          } = ev.detail.data;
+          logger.info(`Received state entry ${eventId} for a different room ${roomId}; discarding`);
         }
-        yield _this.ack(ev);
-      });
-      return function (_x4) {
-        return _ref4.apply(this, arguments);
-      };
-    }());
+      }
+      await this.ack(ev);
+    });
     this.widgetApi = widgetApi;
     this.capabilities = capabilities;
     this.roomId = _roomId;
-    var transportSend = this.widgetApi.transport.send.bind(this.widgetApi.transport);
-    this.widgetApi.transport.send = /*#__PURE__*/function () {
-      var _ref5 = _asyncToGenerator(function* (action, data) {
-        try {
-          return yield transportSend(action, data);
-        } catch (error) {
-          processAndThrow(error);
-        }
-      });
-      return function (_x5, _x6) {
-        return _ref5.apply(this, arguments);
-      };
-    }();
-    var transportSendComplete = this.widgetApi.transport.sendComplete.bind(this.widgetApi.transport);
-    this.widgetApi.transport.sendComplete = /*#__PURE__*/function () {
-      var _ref6 = _asyncToGenerator(function* (action, data) {
-        try {
-          return yield transportSendComplete(action, data);
-        } catch (error) {
-          processAndThrow(error);
-        }
-      });
-      return function (_x7, _x8) {
-        return _ref6.apply(this, arguments);
-      };
-    }();
+    const transportSend = this.widgetApi.transport.send.bind(this.widgetApi.transport);
+    this.widgetApi.transport.send = async (action, data) => {
+      try {
+        return await transportSend(action, data);
+      } catch (error) {
+        processAndThrow(error);
+      }
+    };
+    const transportSendComplete = this.widgetApi.transport.sendComplete.bind(this.widgetApi.transport);
+    this.widgetApi.transport.sendComplete = async (action, data) => {
+      try {
+        return await transportSendComplete(action, data);
+      } catch (error) {
+        processAndThrow(error);
+      }
+    };
     this.widgetApiReady = new Promise(resolve => this.widgetApi.once("ready", resolve));
-    this.roomStateSynced = (_capabilities$receive = capabilities.receiveState) !== null && _capabilities$receive !== void 0 && _capabilities$receive.length ? new Promise(resolve => this.widgetApi.once("action:".concat(WidgetApiToWidgetAction.UpdateState), resolve)) : Promise.resolve();
+    this.roomStateSynced = capabilities.receiveState?.length ? new Promise(resolve => this.widgetApi.once(`action:${WidgetApiToWidgetAction.UpdateState}`, resolve)) : Promise.resolve();
     this.requestInitialCapabilities(capabilities, _roomId);
-    widgetApi.on("action:".concat(WidgetApiToWidgetAction.SendEvent), this.onEvent);
-    widgetApi.on("action:".concat(WidgetApiToWidgetAction.SendToDevice), this.onToDevice);
-    widgetApi.on("action:".concat(WidgetApiToWidgetAction.UpdateState), this.onStateUpdate);
+    widgetApi.on(`action:${WidgetApiToWidgetAction.SendEvent}`, this.onEvent);
+    widgetApi.on(`action:${WidgetApiToWidgetAction.SendToDevice}`, this.onToDevice);
+    widgetApi.on(`action:${WidgetApiToWidgetAction.UpdateState}`, this.onStateUpdate);
 
     // Open communication with the host
     widgetApi.start();
@@ -248,13 +216,12 @@ export class RoomWidgetClient extends MatrixClient {
     if (sendContentLoaded) widgetApi.sendContentLoaded();
   }
   requestInitialCapabilities(capabilities, roomId) {
-    var _capabilities$sendEve, _capabilities$receive2, _capabilities$sendSta, _capabilities$receive3, _capabilities$sendEve2, _capabilities$receive4, _capabilities$sendSta2, _capabilities$receive5, _capabilities$sendToD, _capabilities$receive6, _capabilities$sendEve3, _capabilities$sendSta3;
     // Request capabilities for the functionality this client needs to support
-    if ((_capabilities$sendEve = capabilities.sendEvent) !== null && _capabilities$sendEve !== void 0 && _capabilities$sendEve.length || (_capabilities$receive2 = capabilities.receiveEvent) !== null && _capabilities$receive2 !== void 0 && _capabilities$receive2.length || capabilities.sendMessage === true || Array.isArray(capabilities.sendMessage) && capabilities.sendMessage.length || capabilities.receiveMessage === true || Array.isArray(capabilities.receiveMessage) && capabilities.receiveMessage.length || (_capabilities$sendSta = capabilities.sendState) !== null && _capabilities$sendSta !== void 0 && _capabilities$sendSta.length || (_capabilities$receive3 = capabilities.receiveState) !== null && _capabilities$receive3 !== void 0 && _capabilities$receive3.length) {
+    if (capabilities.sendEvent?.length || capabilities.receiveEvent?.length || capabilities.sendMessage === true || Array.isArray(capabilities.sendMessage) && capabilities.sendMessage.length || capabilities.receiveMessage === true || Array.isArray(capabilities.receiveMessage) && capabilities.receiveMessage.length || capabilities.sendState?.length || capabilities.receiveState?.length) {
       this.widgetApi.requestCapabilityForRoomTimeline(roomId);
     }
-    (_capabilities$sendEve2 = capabilities.sendEvent) === null || _capabilities$sendEve2 === void 0 || _capabilities$sendEve2.forEach(eventType => this.widgetApi.requestCapabilityToSendEvent(eventType));
-    (_capabilities$receive4 = capabilities.receiveEvent) === null || _capabilities$receive4 === void 0 || _capabilities$receive4.forEach(eventType => this.widgetApi.requestCapabilityToReceiveEvent(eventType));
+    capabilities.sendEvent?.forEach(eventType => this.widgetApi.requestCapabilityToSendEvent(eventType));
+    capabilities.receiveEvent?.forEach(eventType => this.widgetApi.requestCapabilityToReceiveEvent(eventType));
     if (capabilities.sendMessage === true) {
       this.widgetApi.requestCapabilityToSendMessage();
     } else if (Array.isArray(capabilities.sendMessage)) {
@@ -265,19 +232,17 @@ export class RoomWidgetClient extends MatrixClient {
     } else if (Array.isArray(capabilities.receiveMessage)) {
       capabilities.receiveMessage.forEach(msgType => this.widgetApi.requestCapabilityToReceiveMessage(msgType));
     }
-    (_capabilities$sendSta2 = capabilities.sendState) === null || _capabilities$sendSta2 === void 0 || _capabilities$sendSta2.forEach(_ref7 => {
-      var eventType = _ref7.eventType,
-        stateKey = _ref7.stateKey;
-      return this.widgetApi.requestCapabilityToSendState(eventType, stateKey);
-    });
-    (_capabilities$receive5 = capabilities.receiveState) === null || _capabilities$receive5 === void 0 || _capabilities$receive5.forEach(_ref8 => {
-      var eventType = _ref8.eventType,
-        stateKey = _ref8.stateKey;
-      return this.widgetApi.requestCapabilityToReceiveState(eventType, stateKey);
-    });
-    (_capabilities$sendToD = capabilities.sendToDevice) === null || _capabilities$sendToD === void 0 || _capabilities$sendToD.forEach(eventType => this.widgetApi.requestCapabilityToSendToDevice(eventType));
-    (_capabilities$receive6 = capabilities.receiveToDevice) === null || _capabilities$receive6 === void 0 || _capabilities$receive6.forEach(eventType => this.widgetApi.requestCapabilityToReceiveToDevice(eventType));
-    if (capabilities.sendDelayedEvents && ((_capabilities$sendEve3 = capabilities.sendEvent) !== null && _capabilities$sendEve3 !== void 0 && _capabilities$sendEve3.length || capabilities.sendMessage === true || Array.isArray(capabilities.sendMessage) && capabilities.sendMessage.length || (_capabilities$sendSta3 = capabilities.sendState) !== null && _capabilities$sendSta3 !== void 0 && _capabilities$sendSta3.length)) {
+    capabilities.sendState?.forEach(({
+      eventType,
+      stateKey
+    }) => this.widgetApi.requestCapabilityToSendState(eventType, stateKey));
+    capabilities.receiveState?.forEach(({
+      eventType,
+      stateKey
+    }) => this.widgetApi.requestCapabilityToReceiveState(eventType, stateKey));
+    capabilities.sendToDevice?.forEach(eventType => this.widgetApi.requestCapabilityToSendToDevice(eventType));
+    capabilities.receiveToDevice?.forEach(eventType => this.widgetApi.requestCapabilityToReceiveToDevice(eventType));
+    if (capabilities.sendDelayedEvents && (capabilities.sendEvent?.length || capabilities.sendMessage === true || Array.isArray(capabilities.sendMessage) && capabilities.sendMessage.length || capabilities.sendState?.length)) {
       this.widgetApi.requestCapability(MatrixCapabilities.MSC4157SendDelayedEvent);
     }
     if (capabilities.updateDelayedEvents) {
@@ -293,189 +258,159 @@ export class RoomWidgetClient extends MatrixClient {
       this.widgetApi.requestCapability(MatrixCapabilities.MSC3846TurnServers);
     }
   }
-  supportUpdateState() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      return (yield _this2.widgetApi.getClientVersions()).includes(UnstableApiVersion.MSC2762_UPDATE_STATE);
-    })();
+  async supportUpdateState() {
+    return (await this.widgetApi.getClientVersions()).includes(UnstableApiVersion.MSC2762_UPDATE_STATE);
   }
-  startClient() {
-    var _arguments = arguments,
-      _this3 = this;
-    return _asyncToGenerator(function* () {
-      var opts = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : {};
-      _this3.lifecycle = new AbortController();
+  async startClient(opts = {}) {
+    this.lifecycle = new AbortController();
 
-      // Create our own user object artificially (instead of waiting for sync)
-      // so it's always available, even if the user is not in any rooms etc.
-      var userId = _this3.getUserId();
-      if (userId) {
-        _this3.store.storeUser(new User(userId));
-      }
+    // Create our own user object artificially (instead of waiting for sync)
+    // so it's always available, even if the user is not in any rooms etc.
+    const userId = this.getUserId();
+    if (userId) {
+      this.store.storeUser(new User(userId));
+    }
 
-      // Even though we have no access token and cannot sync, the sync class
-      // still has some valuable helper methods that we make use of, so we
-      // instantiate it anyways
-      if (opts.slidingSync) {
-        _this3.syncApi = new SlidingSyncSdk(opts.slidingSync, _this3, opts, _this3.buildSyncApiOptions());
-      } else {
-        _this3.syncApi = new SyncApi(_this3, opts, _this3.buildSyncApiOptions());
-      }
-      _this3.syncApiResolver.resolve();
-      _this3.room = _this3.syncApi.createRoom(_this3.roomId);
-      _this3.store.storeRoom(_this3.room);
-      yield _this3.widgetApiReady;
+    // Even though we have no access token and cannot sync, the sync class
+    // still has some valuable helper methods that we make use of, so we
+    // instantiate it anyways
+    if (opts.slidingSync) {
+      this.syncApi = new SlidingSyncSdk(opts.slidingSync, this, opts, this.buildSyncApiOptions());
+    } else {
+      this.syncApi = new SyncApi(this, opts, this.buildSyncApiOptions());
+    }
+    this.syncApiResolver.resolve();
+    this.room = this.syncApi.createRoom(this.roomId);
+    this.store.storeRoom(this.room);
+    await this.widgetApiReady;
 
-      // sync room state:
-      if (yield _this3.supportUpdateState()) {
-        // This will resolve once the client driver has sent us all the allowed room state.
-        yield _this3.roomStateSynced;
-      } else {
-        var _this3$capabilities$r, _this3$capabilities$r2;
-        // Backfill the requested events
-        // We only get the most recent event for every type + state key combo,
-        // so it doesn't really matter what order we inject them in
-        yield Promise.all((_this3$capabilities$r = (_this3$capabilities$r2 = _this3.capabilities.receiveState) === null || _this3$capabilities$r2 === void 0 ? void 0 : _this3$capabilities$r2.map(/*#__PURE__*/function () {
-          var _ref0 = _asyncToGenerator(function* (_ref9) {
-            var eventType = _ref9.eventType,
-              stateKey = _ref9.stateKey;
-            var rawEvents = yield _this3.widgetApi.readStateEvents(eventType, undefined, stateKey, [_this3.roomId]);
-            var events = rawEvents.map(rawEvent => new MatrixEvent(rawEvent));
-            if (_this3.syncApi instanceof SyncApi) {
-              // Passing events as `stateAfterEventList` will update the state.
-              yield _this3.syncApi.injectRoomEvents(_this3.room, undefined, events);
-            } else {
-              yield _this3.syncApi.injectRoomEvents(_this3.room, events); // Sliding Sync
-            }
-            events.forEach(event => {
-              _this3.emit(ClientEvent.Event, event);
-              logger.info("Backfilled event ".concat(event.getId(), " ").concat(event.getType(), " ").concat(event.getStateKey()));
-            });
-          });
-          return function (_x9) {
-            return _ref0.apply(this, arguments);
-          };
-        }())) !== null && _this3$capabilities$r !== void 0 ? _this3$capabilities$r : []);
-      }
-      if (opts.clientWellKnownPollPeriod !== undefined) {
-        _this3.clientWellKnownIntervalID = setInterval(() => {
-          _this3.fetchClientWellKnown();
-        }, 1000 * opts.clientWellKnownPollPeriod);
-        _this3.fetchClientWellKnown();
-      }
-      _this3.setSyncState(SyncState.Syncing);
-      logger.info("Finished initial sync");
-      _this3.matrixRTC.start();
+    // sync room state:
+    if (await this.supportUpdateState()) {
+      // This will resolve once the client driver has sent us all the allowed room state.
+      await this.roomStateSynced;
+    } else {
+      // Backfill the requested events
+      // We only get the most recent event for every type + state key combo,
+      // so it doesn't really matter what order we inject them in
+      await Promise.all(this.capabilities.receiveState?.map(async ({
+        eventType,
+        stateKey
+      }) => {
+        const rawEvents = await this.widgetApi.readStateEvents(eventType, undefined, stateKey, [this.roomId]);
+        const events = rawEvents.map(rawEvent => new MatrixEvent(rawEvent));
+        if (this.syncApi instanceof SyncApi) {
+          // Passing events as `stateAfterEventList` will update the state.
+          await this.syncApi.injectRoomEvents(this.room, undefined, events);
+        } else {
+          await this.syncApi.injectRoomEvents(this.room, events); // Sliding Sync
+        }
+        events.forEach(event => {
+          this.emit(ClientEvent.Event, event);
+          logger.info(`Backfilled event ${event.getId()} ${event.getType()} ${event.getStateKey()}`);
+        });
+      }) ?? []);
+    }
+    if (opts.clientWellKnownPollPeriod !== undefined) {
+      this.clientWellKnownIntervalID = setInterval(() => {
+        this.fetchClientWellKnown();
+      }, 1000 * opts.clientWellKnownPollPeriod);
+      this.fetchClientWellKnown();
+    }
+    this.setSyncState(SyncState.Syncing);
+    logger.info("Finished initial sync");
+    this.matrixRTC.start();
 
-      // Watch for TURN servers, if requested
-      if (_this3.capabilities.turnServers) _this3.watchTurnServers();
-    })();
+    // Watch for TURN servers, if requested
+    if (this.capabilities.turnServers) this.watchTurnServers();
   }
   stopClient() {
-    this.widgetApi.off("action:".concat(WidgetApiToWidgetAction.SendEvent), this.onEvent);
-    this.widgetApi.off("action:".concat(WidgetApiToWidgetAction.SendToDevice), this.onToDevice);
-    this.widgetApi.off("action:".concat(WidgetApiToWidgetAction.UpdateState), this.onStateUpdate);
+    this.widgetApi.off(`action:${WidgetApiToWidgetAction.SendEvent}`, this.onEvent);
+    this.widgetApi.off(`action:${WidgetApiToWidgetAction.SendToDevice}`, this.onToDevice);
+    this.widgetApi.off(`action:${WidgetApiToWidgetAction.UpdateState}`, this.onStateUpdate);
     super.stopClient();
     this.lifecycle.abort(); // Signal to other async tasks that the client has stopped
   }
-  joinRoom(roomIdOrAlias) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      if (roomIdOrAlias === _this4.roomId) return _this4.room;
-      throw new Error("Unknown room: ".concat(roomIdOrAlias));
-    })();
+  async joinRoom(roomIdOrAlias) {
+    if (roomIdOrAlias === this.roomId) return this.room;
+    throw new Error(`Unknown room: ${roomIdOrAlias}`);
   }
-  encryptAndSendEvent(room, event, delayOptsOrQuery, queryDict) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      var _queryOpts;
-      var queryOpts = queryDict;
-      var delayOpts;
-      if (delayOptsOrQuery && isSendDelayedEventRequestOpts(delayOptsOrQuery)) {
-        delayOpts = delayOptsOrQuery;
-      } else if (!queryOpts) {
-        queryOpts = delayOptsOrQuery;
-      }
-      var stickyDurationMs = (_queryOpts = queryOpts) === null || _queryOpts === void 0 ? void 0 : _queryOpts["org.matrix.msc4354.sticky_duration_ms"];
-      if (stickyDurationMs !== undefined && typeof stickyDurationMs !== "number") {
-        throw new Error("Sticky duration must be a number when defined");
-      }
-      // This is save since we just checked that above
-      // We need the additional as assertion for the EW linter to be happy.
-      // It is not capable of implying the type based on the throw if `stickyDurationMs !== undefined && typeof stickyDurationMs !== "number"`
-      // above
-      var stickyDurationMsAsNumber = stickyDurationMs;
+  async encryptAndSendEvent(room, event, delayOptsOrQuery, queryDict) {
+    let queryOpts = queryDict;
+    let delayOpts;
+    if (delayOptsOrQuery && isSendDelayedEventRequestOpts(delayOptsOrQuery)) {
+      delayOpts = delayOptsOrQuery;
+    } else if (!queryOpts) {
+      queryOpts = delayOptsOrQuery;
+    }
+    const stickyDurationMs = queryOpts?.["org.matrix.msc4354.sticky_duration_ms"];
+    if (stickyDurationMs !== undefined && typeof stickyDurationMs !== "number") {
+      throw new Error("Sticky duration must be a number when defined");
+    }
+    // This is save since we just checked that above
+    // We need the additional as assertion for the EW linter to be happy.
+    // It is not capable of implying the type based on the throw if `stickyDurationMs !== undefined && typeof stickyDurationMs !== "number"`
+    // above
+    const stickyDurationMsAsNumber = stickyDurationMs;
 
-      // We need to extend the content with the redacts parameter
-      // The js sdk uses event.redacts but the widget api uses event.content.redacts
-      // This will be converted back to event.redacts in the widget driver.
-      var content = event.event.redacts ? _objectSpread(_objectSpread({}, event.getContent()), {}, {
-        redacts: event.event.redacts
-      }) : event.getContent();
+    // We need to extend the content with the redacts parameter
+    // The js sdk uses event.redacts but the widget api uses event.content.redacts
+    // This will be converted back to event.redacts in the widget driver.
+    const content = event.event.redacts ? _objectSpread(_objectSpread({}, event.getContent()), {}, {
+      redacts: event.event.redacts
+    }) : event.getContent();
 
-      // Delayed event special case.
-      if (delayOpts) {
-        // TODO: updatePendingEvent for delayed events?
-        var _response = yield _this5.widgetApi.sendRoomEvent(event.getType(), content, room.roomId, "delay" in delayOpts ? delayOpts.delay : undefined, "parent_delay_id" in delayOpts ? delayOpts.parent_delay_id : undefined, stickyDurationMsAsNumber).catch(timeoutToConnectionError);
-        return _this5.validateSendDelayedEventResponse(_response);
-      }
-      var txId = event.getTxnId();
-      // Add the txnId to the pending list (still with unknown evID)
-      if (txId) _this5.pendingSendingEventsTxId.push({
-        type: event.getType(),
-        id: undefined,
-        txId
-      });
-      var response;
-      try {
-        response = yield _this5.widgetApi.sendRoomEvent(event.getType(), content, room.roomId, undefined, undefined, stickyDurationMsAsNumber).catch(timeoutToConnectionError);
-      } catch (e) {
-        _this5.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);
-        throw e;
-      }
-      // This also checks for an event id on the response
-      room.updatePendingEvent(event, EventStatus.SENT, response.event_id);
+    // Delayed event special case.
+    if (delayOpts) {
+      // TODO: updatePendingEvent for delayed events?
+      const response = await this.widgetApi.sendRoomEvent(event.getType(), content, room.roomId, "delay" in delayOpts ? delayOpts.delay : undefined, "parent_delay_id" in delayOpts ? delayOpts.parent_delay_id : undefined, stickyDurationMsAsNumber).catch(timeoutToConnectionError);
+      return this.validateSendDelayedEventResponse(response);
+    }
+    const txId = event.getTxnId();
+    // Add the txnId to the pending list (still with unknown evID)
+    if (txId) this.pendingSendingEventsTxId.push({
+      type: event.getType(),
+      id: undefined,
+      txId
+    });
+    let response;
+    try {
+      response = await this.widgetApi.sendRoomEvent(event.getType(), content, room.roomId, undefined, undefined, stickyDurationMsAsNumber).catch(timeoutToConnectionError);
+    } catch (e) {
+      this.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);
+      throw e;
+    }
+    // This also checks for an event id on the response
+    room.updatePendingEvent(event, EventStatus.SENT, response.event_id);
 
-      // Update the pending events list with the eventId
-      _this5.pendingSendingEventsTxId.forEach(p => {
-        if (p.txId === txId) p.id = response.event_id;
-      });
-      _this5.eventEmitter.emit(RoomWidgetClientEvent.PendingEventsChanged);
-      return {
-        event_id: response.event_id
-      };
-    })();
+    // Update the pending events list with the eventId
+    this.pendingSendingEventsTxId.forEach(p => {
+      if (p.txId === txId) p.id = response.event_id;
+    });
+    this.eventEmitter.emit(RoomWidgetClientEvent.PendingEventsChanged);
+    return {
+      event_id: response.event_id
+    };
   }
-  sendStateEvent(roomId, eventType, content) {
-    var _arguments2 = arguments,
-      _this6 = this;
-    return _asyncToGenerator(function* () {
-      var stateKey = _arguments2.length > 3 && _arguments2[3] !== undefined ? _arguments2[3] : "";
-      var response = yield _this6.widgetApi.sendStateEvent(eventType, stateKey, content, roomId).catch(timeoutToConnectionError);
-      if (response.event_id === undefined) {
-        throw new Error("'event_id' absent from response to an event request");
-      }
-      return {
-        event_id: response.event_id
-      };
-    })();
+  async sendStateEvent(roomId, eventType, content, stateKey = "") {
+    const response = await this.widgetApi.sendStateEvent(eventType, stateKey, content, roomId).catch(timeoutToConnectionError);
+    if (response.event_id === undefined) {
+      throw new Error("'event_id' absent from response to an event request");
+    }
+    return {
+      event_id: response.event_id
+    };
   }
 
   /**
    * @experimental This currently relies on an unstable MSC (MSC4140).
    */
   // eslint-disable-next-line
-  _unstable_sendDelayedStateEvent(roomId, delayOpts, eventType, content) {
-    var _arguments3 = arguments,
-      _this7 = this;
-    return _asyncToGenerator(function* () {
-      var stateKey = _arguments3.length > 4 && _arguments3[4] !== undefined ? _arguments3[4] : "";
-      if (!(yield _this7.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
-        throw new UnsupportedDelayedEventsEndpointError("Server does not support the delayed events API", "sendDelayedStateEvent");
-      }
-      var response = yield _this7.widgetApi.sendStateEvent(eventType, stateKey, content, roomId, "delay" in delayOpts ? delayOpts.delay : undefined, "parent_delay_id" in delayOpts ? delayOpts.parent_delay_id : undefined).catch(timeoutToConnectionError);
-      return _this7.validateSendDelayedEventResponse(response);
-    })();
+  async _unstable_sendDelayedStateEvent(roomId, delayOpts, eventType, content, stateKey = "") {
+    if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      throw new UnsupportedDelayedEventsEndpointError("Server does not support the delayed events API", "sendDelayedStateEvent");
+    }
+    const response = await this.widgetApi.sendStateEvent(eventType, stateKey, content, roomId, "delay" in delayOpts ? delayOpts.delay : undefined, "parent_delay_id" in delayOpts ? delayOpts.parent_delay_id : undefined).catch(timeoutToConnectionError);
+    return this.validateSendDelayedEventResponse(response);
   }
   validateSendDelayedEventResponse(response) {
     if (response.delay_id === undefined) {
@@ -494,126 +429,103 @@ export class RoomWidgetClient extends MatrixClient {
    * - {@link _unstable_sendScheduledDelayedEvent}
    */
   // eslint-disable-next-line @typescript-eslint/naming-convention
-  _unstable_updateDelayedEvent(delayId, action) {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      if (!(yield _this8.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
-        throw new UnsupportedDelayedEventsEndpointError("Server does not support the delayed events API", "updateDelayedEvent");
-      }
-      var updateDelayedEvent;
-      switch (action) {
-        case UpdateDelayedEventAction.Cancel:
-          updateDelayedEvent = _this8.widgetApi.cancelScheduledDelayedEvent;
-          break;
-        case UpdateDelayedEventAction.Restart:
-          updateDelayedEvent = _this8.widgetApi.cancelScheduledDelayedEvent;
-          break;
-        case UpdateDelayedEventAction.Send:
-          updateDelayedEvent = _this8.widgetApi.sendScheduledDelayedEvent;
-          break;
-      }
-      yield updateDelayedEvent.call(_this8.widgetApi, delayId).catch(timeoutToConnectionError);
-      return {};
-    })();
+  async _unstable_updateDelayedEvent(delayId, action) {
+    if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      throw new UnsupportedDelayedEventsEndpointError("Server does not support the delayed events API", "updateDelayedEvent");
+    }
+    switch (action) {
+      case UpdateDelayedEventAction.Cancel:
+        await this.widgetApi.cancelScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
+        break;
+      case UpdateDelayedEventAction.Restart:
+        await this.widgetApi.restartScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
+        break;
+      case UpdateDelayedEventAction.Send:
+        await this.widgetApi.sendScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
+        break;
+    }
+    return {};
   }
 
   /**
    * @experimental This currently relies on an unstable MSC (MSC4140).
    */
   // eslint-disable-next-line @typescript-eslint/naming-convention
-  _unstable_cancelScheduledDelayedEvent(delayId) {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      if (!(yield _this9.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
-        throw new UnsupportedDelayedEventsEndpointError("Server does not support the delayed events API", "cancelScheduledDelayedEvent");
-      }
-      yield _this9.widgetApi.cancelScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
-      return {};
-    })();
+  async _unstable_cancelScheduledDelayedEvent(delayId) {
+    if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      throw new UnsupportedDelayedEventsEndpointError("Server does not support the delayed events API", "cancelScheduledDelayedEvent");
+    }
+    await this.widgetApi.cancelScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
+    return {};
   }
 
   /**
    * @experimental This currently relies on an unstable MSC (MSC4140).
    */
   // eslint-disable-next-line @typescript-eslint/naming-convention
-  _unstable_restartScheduledDelayedEvent(delayId) {
-    var _this0 = this;
-    return _asyncToGenerator(function* () {
-      if (!(yield _this0.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
-        throw new UnsupportedDelayedEventsEndpointError("Server does not support the delayed events API", "restartScheduledDelayedEvent");
-      }
-      yield _this0.widgetApi.restartScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
-      return {};
-    })();
+  async _unstable_restartScheduledDelayedEvent(delayId) {
+    if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      throw new UnsupportedDelayedEventsEndpointError("Server does not support the delayed events API", "restartScheduledDelayedEvent");
+    }
+    await this.widgetApi.restartScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
+    return {};
   }
 
   /**
    * @experimental This currently relies on an unstable MSC (MSC4140).
    */
   // eslint-disable-next-line @typescript-eslint/naming-convention
-  _unstable_sendScheduledDelayedEvent(delayId) {
-    var _this1 = this;
-    return _asyncToGenerator(function* () {
-      if (!(yield _this1.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
-        throw new UnsupportedDelayedEventsEndpointError("Server does not support the delayed events API", "sendScheduledDelayedEvent");
-      }
-      yield _this1.widgetApi.sendScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
-      return {};
-    })();
+  async _unstable_sendScheduledDelayedEvent(delayId) {
+    if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      throw new UnsupportedDelayedEventsEndpointError("Server does not support the delayed events API", "sendScheduledDelayedEvent");
+    }
+    await this.widgetApi.sendScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
+    return {};
   }
 
   /**
    * by {@link MatrixClient.encryptAndSendToDevice}.
    */
-  encryptAndSendToDevice(eventType, devices, payload) {
-    var _this10 = this;
-    return _asyncToGenerator(function* () {
-      // map: user Id → device Id → payload
-      var contentMap = new MapWithDefault(() => new Map());
-      for (var _ref10 of devices) {
-        var userId = _ref10.userId;
-        var deviceId = _ref10.deviceId;
-        contentMap.getOrCreate(userId).set(deviceId, payload);
-      }
-      yield _this10.widgetApi.sendToDevice(eventType, true, recursiveMapToObject(contentMap)).catch(timeoutToConnectionError);
-    })();
+  async encryptAndSendToDevice(eventType, devices, payload) {
+    // map: user Id → device Id → payload
+    const contentMap = new MapWithDefault(() => new Map());
+    for (const {
+      userId,
+      deviceId
+    } of devices) {
+      contentMap.getOrCreate(userId).set(deviceId, payload);
+    }
+    await this.widgetApi.sendToDevice(eventType, true, recursiveMapToObject(contentMap)).catch(timeoutToConnectionError);
   }
-  sendToDevice(eventType, contentMap) {
-    var _this11 = this;
-    return _asyncToGenerator(function* () {
-      yield _this11.widgetApi.sendToDevice(eventType, false, recursiveMapToObject(contentMap)).catch(timeoutToConnectionError);
-      return {};
-    })();
+  async sendToDevice(eventType, contentMap) {
+    await this.widgetApi.sendToDevice(eventType, false, recursiveMapToObject(contentMap)).catch(timeoutToConnectionError);
+    return {};
   }
-  getOpenIdToken() {
-    var _this12 = this;
-    return _asyncToGenerator(function* () {
-      var token = yield _this12.widgetApi.requestOpenIDConnectToken().catch(timeoutToConnectionError);
-      // the IOpenIDCredentials from the widget-api and IOpenIDToken form the matrix-js-sdk are compatible.
-      // we still recreate the token to make this transparent and catch'able by the linter in case the types change in the future.
-      return {
-        access_token: token.access_token,
-        expires_in: token.expires_in,
-        matrix_server_name: token.matrix_server_name,
-        token_type: token.token_type
-      };
-    })();
+  async getOpenIdToken() {
+    const token = await this.widgetApi.requestOpenIDConnectToken().catch(timeoutToConnectionError);
+    // the IOpenIDCredentials from the widget-api and IOpenIDToken form the matrix-js-sdk are compatible.
+    // we still recreate the token to make this transparent and catch'able by the linter in case the types change in the future.
+    return {
+      access_token: token.access_token,
+      expires_in: token.expires_in,
+      matrix_server_name: token.matrix_server_name,
+      token_type: token.token_type
+    };
   }
-  queueToDevice(_ref11) {
-    var _this13 = this;
-    return _asyncToGenerator(function* () {
-      var eventType = _ref11.eventType,
-        batch = _ref11.batch;
-      // map: user Id → device Id → payload
-      var contentMap = new MapWithDefault(() => new Map());
-      for (var _ref13 of batch) {
-        var userId = _ref13.userId;
-        var deviceId = _ref13.deviceId;
-        var payload = _ref13.payload;
-        contentMap.getOrCreate(userId).set(deviceId, payload);
-      }
-      yield _this13.widgetApi.sendToDevice(eventType, false, recursiveMapToObject(contentMap)).catch(timeoutToConnectionError);
-    })();
+  async queueToDevice({
+    eventType,
+    batch
+  }) {
+    // map: user Id → device Id → payload
+    const contentMap = new MapWithDefault(() => new Map());
+    for (const {
+      userId,
+      deviceId,
+      payload
+    } of batch) {
+      contentMap.getOrCreate(userId).set(deviceId, payload);
+    }
+    await this.widgetApi.sendToDevice(eventType, false, recursiveMapToObject(contentMap)).catch(timeoutToConnectionError);
   }
 
   /**
@@ -629,20 +541,14 @@ export class RoomWidgetClient extends MatrixClient {
    * @param encrypted - Whether the event should be encrypted.
    * @param contentMap - The content to send. Map from user_id to device_id to content object.
    */
-  sendToDeviceViaWidgetApi(eventType, encrypted, contentMap) {
-    var _this14 = this;
-    return _asyncToGenerator(function* () {
-      yield _this14.widgetApi.sendToDevice(eventType, encrypted, recursiveMapToObject(contentMap)).catch(timeoutToConnectionError);
-    })();
+  async sendToDeviceViaWidgetApi(eventType, encrypted, contentMap) {
+    await this.widgetApi.sendToDevice(eventType, encrypted, recursiveMapToObject(contentMap)).catch(timeoutToConnectionError);
   }
 
   // Overridden since we get TURN servers automatically over the widget API,
   // and this method would otherwise complain about missing an access token
-  checkTurnServers() {
-    var _this15 = this;
-    return _asyncToGenerator(function* () {
-      return _this15.turnServers.length > 0;
-    })();
+  async checkTurnServers() {
+    return this.turnServers.length > 0;
   }
 
   // Overridden since we 'sync' manually without the sync API
@@ -650,61 +556,34 @@ export class RoomWidgetClient extends MatrixClient {
     return this.syncState;
   }
   setSyncState(state) {
-    var oldState = this.syncState;
+    const oldState = this.syncState;
     this.syncState = state;
     this.emit(ClientEvent.Sync, state, oldState);
   }
-  ack(ev) {
-    var _this16 = this;
-    return _asyncToGenerator(function* () {
-      yield _this16.widgetApi.transport.reply(ev.detail, {});
-    })();
+  async ack(ev) {
+    this.widgetApi.transport.reply(ev.detail, {});
   }
-  watchTurnServers() {
-    var _this17 = this;
-    return _asyncToGenerator(function* () {
-      var servers = _this17.widgetApi.getTurnServers();
-      var onClientStopped = () => {
-        servers.return(undefined);
-      };
-      _this17.lifecycle.signal.addEventListener("abort", onClientStopped);
-      try {
-        var _iteratorAbruptCompletion = false;
-        var _didIteratorError = false;
-        var _iteratorError;
-        try {
-          for (var _iterator = _asyncIterator(servers), _step; _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done; _iteratorAbruptCompletion = false) {
-            var server = _step.value;
-            {
-              _this17.turnServers = [{
-                urls: server.uris,
-                username: server.username,
-                credential: server.password
-              }];
-              _this17.emit(ClientEvent.TurnServers, _this17.turnServers);
-              logger.log("Received TURN server: ".concat(server.uris));
-            }
-          }
-        } catch (err) {
-          _didIteratorError = true;
-          _iteratorError = err;
-        } finally {
-          try {
-            if (_iteratorAbruptCompletion && _iterator.return != null) {
-              yield _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
-        }
-      } catch (e) {
-        logger.warn("Error watching TURN servers", e);
-      } finally {
-        _this17.lifecycle.signal.removeEventListener("abort", onClientStopped);
+  async watchTurnServers() {
+    const servers = this.widgetApi.getTurnServers();
+    const onClientStopped = () => {
+      servers.return(undefined);
+    };
+    this.lifecycle.signal.addEventListener("abort", onClientStopped);
+    try {
+      for await (const server of servers) {
+        this.turnServers = [{
+          urls: server.uris,
+          username: server.username,
+          credential: server.password
+        }];
+        this.emit(ClientEvent.TurnServers, this.turnServers);
+        logger.log(`Received TURN server: ${server.uris}`);
       }
-    })();
+    } catch (e) {
+      logger.warn("Error watching TURN servers", e);
+    } finally {
+      this.lifecycle.signal.removeEventListener("abort", onClientStopped);
+    }
   }
 }
 function processAndThrow(error) {