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

package/node_modules/matrix-js-sdk/lib/sliding-sync-sdk.js

@@ -1,5 +1,4 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 /*
 Copyright 2022 The Matrix.org Foundation C.I.C.
 
@@ -32,7 +31,7 @@ import { KnownMembership } from "./@types/membership.js";
 // Number of consecutive failed syncs that will lead to a syncState of ERROR as opposed
 // to RECONNECTING. This is needed to inform the client of server issues when the
 // keepAlive is successful but the server /sync fails.
-var FAILED_SYNC_ERROR_THRESHOLD = 3;
+const FAILED_SYNC_ERROR_THRESHOLD = 3;
 class ExtensionE2EE {
   constructor(crypto) {
     this.crypto = crypto;
@@ -43,36 +42,30 @@ class ExtensionE2EE {
   when() {
     return ExtensionState.PreProcess;
   }
-  onRequest(isInitial) {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      if (isInitial) {
-        // In SSS, the `?pos=` contains the stream position for device list updates.
-        // If we do not have a `?pos=` (e.g because we forgot it, or because the server
-        // invalidated our connection) then we MUST invlaidate all device lists because
-        // the server will not tell us the delta. This will then cause UTDs as we will fail
-        // to encrypt for new devices. This is an expensive call, so we should
-        // really really remember `?pos=` wherever possible.
-        logger.log("ExtensionE2EE: invalidating all device lists due to missing 'pos'");
-        yield _this.crypto.markAllTrackedUsersAsDirty();
-      }
-      return {
-        enabled: true // this is sticky so only send it on the initial request
-      };
-    })();
-  }
-  onResponse(data) {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      // Handle device list updates
-      if (data.device_lists) {
-        yield _this2.crypto.processDeviceLists(data.device_lists);
-      }
+  async onRequest(isInitial) {
+    if (isInitial) {
+      // In SSS, the `?pos=` contains the stream position for device list updates.
+      // If we do not have a `?pos=` (e.g because we forgot it, or because the server
+      // invalidated our connection) then we MUST invlaidate all device lists because
+      // the server will not tell us the delta. This will then cause UTDs as we will fail
+      // to encrypt for new devices. This is an expensive call, so we should
+      // really really remember `?pos=` wherever possible.
+      logger.log("ExtensionE2EE: invalidating all device lists due to missing 'pos'");
+      await this.crypto.markAllTrackedUsersAsDirty();
+    }
+    return {
+      enabled: true // this is sticky so only send it on the initial request
+    };
+  }
+  async onResponse(data) {
+    // Handle device list updates
+    if (data.device_lists) {
+      await this.crypto.processDeviceLists(data.device_lists);
+    }
 
-      // Handle one_time_keys_count and unused_fallback_key_types
-      yield _this2.crypto.processKeyCounts(data.device_one_time_keys_count, data["device_unused_fallback_key_types"] || data["org.matrix.msc2732.device_unused_fallback_key_types"]);
-      _this2.crypto.onSyncCompleted({});
-    })();
+    // Handle one_time_keys_count and unused_fallback_key_types
+    await this.crypto.processKeyCounts(data.device_one_time_keys_count, data["device_unused_fallback_key_types"] || data["org.matrix.msc2732.device_unused_fallback_key_types"]);
+    this.crypto.onSyncCompleted({});
   }
 }
 class ExtensionToDevice {
@@ -87,34 +80,27 @@ class ExtensionToDevice {
   when() {
     return ExtensionState.PreProcess;
   }
-  onRequest(isInitial) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      return {
-        since: _this3.nextBatch !== null ? _this3.nextBatch : undefined,
-        limit: 100,
-        enabled: true
-      };
-    })();
-  }
-  onResponse(data) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      var events = data["events"] || [];
-      var receivedToDeviceMessages;
-      if (_this4.cryptoCallbacks) {
-        receivedToDeviceMessages = yield _this4.cryptoCallbacks.preprocessToDeviceMessages(events);
-      } else {
-        receivedToDeviceMessages = events.map(rawEvent => (
-        // Crypto is not enabled, so we just return the events.
-        {
-          message: rawEvent,
-          encryptionInfo: null
-        }));
-      }
-      processToDeviceMessages(receivedToDeviceMessages, _this4.client);
-      _this4.nextBatch = data.next_batch;
-    })();
+  async onRequest(isInitial) {
+    return {
+      since: this.nextBatch !== null ? this.nextBatch : undefined,
+      limit: 100,
+      enabled: true
+    };
+  }
+  async onResponse(data) {
+    const events = data["events"] || [];
+    let receivedToDeviceMessages;
+    if (this.cryptoCallbacks) {
+      receivedToDeviceMessages = await this.cryptoCallbacks.preprocessToDeviceMessages(events);
+    } else {
+      // Crypto is not enabled, so we just return the events.
+      receivedToDeviceMessages = events.map(rawEvent => ({
+        message: rawEvent,
+        encryptionInfo: null
+      }));
+    }
+    processToDeviceMessages(receivedToDeviceMessages, this.client);
+    this.nextBatch = data.next_batch;
   }
 }
 class ExtensionAccountData {
@@ -127,36 +113,31 @@ class ExtensionAccountData {
   when() {
     return ExtensionState.PostProcess;
   }
-  onRequest(isInitial) {
-    return _asyncToGenerator(function* () {
-      return {
-        enabled: true
-      };
-    })();
+  async onRequest(isInitial) {
+    return {
+      enabled: true
+    };
   }
-  onResponse(data) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      if (data.global && data.global.length > 0) {
-        _this5.processGlobalAccountData(data.global);
-      }
-      for (var roomId in data.rooms) {
-        var accountDataEvents = mapEvents(_this5.client, roomId, data.rooms[roomId]);
-        var room = _this5.client.getRoom(roomId);
-        if (!room) {
-          logger.warn("got account data for room but room doesn't exist on client:", roomId);
-          continue;
-        }
-        room.addAccountData(accountDataEvents);
-        accountDataEvents.forEach(e => {
-          _this5.client.emit(ClientEvent.Event, e);
-        });
+  async onResponse(data) {
+    if (data.global && data.global.length > 0) {
+      this.processGlobalAccountData(data.global);
+    }
+    for (const roomId in data.rooms) {
+      const accountDataEvents = mapEvents(this.client, roomId, data.rooms[roomId]);
+      const room = this.client.getRoom(roomId);
+      if (!room) {
+        logger.warn("got account data for room but room doesn't exist on client:", roomId);
+        continue;
       }
-    })();
+      room.addAccountData(accountDataEvents);
+      accountDataEvents.forEach(e => {
+        this.client.emit(ClientEvent.Event, e);
+      });
+    }
   }
   processGlobalAccountData(globalAccountData) {
-    var events = mapEvents(this.client, undefined, globalAccountData);
-    var prevEventsMap = events.reduce((m, c) => {
+    const events = mapEvents(this.client, undefined, globalAccountData);
+    const prevEventsMap = events.reduce((m, c) => {
       m[c.getType()] = this.client.store.getAccountData(c.getType());
       return m;
     }, {});
@@ -167,10 +148,10 @@ class ExtensionAccountData {
       // will be updated when we receive push rules via getPushRules
       // (see sync) before syncing over the network.
       if (accountDataEvent.getType() === EventType.PushRules) {
-        var rules = accountDataEvent.getContent();
+        const rules = accountDataEvent.getContent();
         this.client.setPushRules(rules);
       }
-      var prevEvent = prevEventsMap[accountDataEvent.getType()];
+      const prevEvent = prevEventsMap[accountDataEvent.getType()];
       this.client.emit(ClientEvent.AccountData, accountDataEvent, prevEvent);
       return accountDataEvent;
     });
@@ -186,23 +167,18 @@ class ExtensionTyping {
   when() {
     return ExtensionState.PostProcess;
   }
-  onRequest(isInitial) {
-    return _asyncToGenerator(function* () {
-      return {
-        enabled: true
-      };
-    })();
+  async onRequest(isInitial) {
+    return {
+      enabled: true
+    };
   }
-  onResponse(data) {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      if (!(data !== null && data !== void 0 && data.rooms)) {
-        return;
-      }
-      for (var roomId in data.rooms) {
-        processEphemeralEvents(_this6.client, roomId, [data.rooms[roomId]]);
-      }
-    })();
+  async onResponse(data) {
+    if (!data?.rooms) {
+      return;
+    }
+    for (const roomId in data.rooms) {
+      processEphemeralEvents(this.client, roomId, [data.rooms[roomId]]);
+    }
   }
 }
 class ExtensionReceipts {
@@ -215,23 +191,18 @@ class ExtensionReceipts {
   when() {
     return ExtensionState.PostProcess;
   }
-  onRequest(isInitial) {
-    return _asyncToGenerator(function* () {
-      return {
-        enabled: true
-      };
-    })();
+  async onRequest(isInitial) {
+    return {
+      enabled: true
+    };
   }
-  onResponse(data) {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      if (!(data !== null && data !== void 0 && data.rooms)) {
-        return;
-      }
-      for (var roomId in data.rooms) {
-        processEphemeralEvents(_this7.client, roomId, [data.rooms[roomId]]);
-      }
-    })();
+  async onResponse(data) {
+    if (!data?.rooms) {
+      return;
+    }
+    for (const roomId in data.rooms) {
+      processEphemeralEvents(this.client, roomId, [data.rooms[roomId]]);
+    }
   }
 }
 
@@ -243,7 +214,10 @@ export class SlidingSyncSdk {
   // accumulator of sync events in the current sync response
 
   constructor(slidingSync, client, opts, syncOpts) {
+    _defineProperty(this, "opts", void 0);
+    _defineProperty(this, "syncOpts", void 0);
     _defineProperty(this, "syncState", null);
+    _defineProperty(this, "syncStateData", void 0);
     _defineProperty(this, "lastPos", null);
     _defineProperty(this, "failCount", 0);
     _defineProperty(this, "notifEvents", []);
@@ -256,7 +230,7 @@ export class SlidingSyncSdk {
     }
     this.slidingSync.on(SlidingSyncEvent.Lifecycle, this.onLifecycle.bind(this));
     this.slidingSync.on(SlidingSyncEvent.RoomData, this.onRoomData.bind(this));
-    var extensions = [new ExtensionToDevice(this.client, this.syncOpts.cryptoCallbacks), new ExtensionAccountData(this.client), new ExtensionTyping(this.client), new ExtensionReceipts(this.client)];
+    const extensions = [new ExtensionToDevice(this.client, this.syncOpts.cryptoCallbacks), new ExtensionAccountData(this.client), new ExtensionTyping(this.client), new ExtensionReceipts(this.client)];
     if (this.syncOpts.cryptoCallbacks) {
       extensions.push(new ExtensionE2EE(this.syncOpts.cryptoCallbacks));
     }
@@ -264,19 +238,16 @@ export class SlidingSyncSdk {
       this.slidingSync.registerExtension(ext);
     });
   }
-  onRoomData(roomId, roomData) {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      var room = _this8.client.store.getRoom(roomId);
-      if (!room) {
-        if (!roomData.initial) {
-          _this8.syncOpts.logger.debug("initial flag not set but no stored room exists for room ", roomId, roomData);
-          return;
-        }
-        room = _createAndReEmitRoom(_this8.client, roomId, _this8.opts);
+  async onRoomData(roomId, roomData) {
+    let room = this.client.store.getRoom(roomId);
+    if (!room) {
+      if (!roomData.initial) {
+        this.syncOpts.logger.debug("initial flag not set but no stored room exists for room ", roomId, roomData);
+        return;
       }
-      yield _this8.processRoomData(_this8.client, room, roomData);
-    })();
+      room = _createAndReEmitRoom(this.client, roomId, this.opts);
+    }
+    await this.processRoomData(this.client, room, roomData);
   }
   onLifecycle(state, resp, err) {
     if (err) {
@@ -318,7 +289,7 @@ export class SlidingSyncSdk {
           }
         } else {
           this.failCount = 0;
-          this.syncOpts.logger.debug("SlidingSyncState.RequestFinished with ".concat(Object.keys((resp === null || resp === void 0 ? void 0 : resp.rooms) || []).length, " rooms"));
+          this.syncOpts.logger.debug(`SlidingSyncState.RequestFinished with ${Object.keys(resp?.rooms || []).length} rooms`);
         }
         break;
     }
@@ -328,10 +299,8 @@ export class SlidingSyncSdk {
    * Sync rooms the user has left.
    * @returns Resolved when they've been added to the store.
    */
-  syncLeftRooms() {
-    return _asyncToGenerator(function* () {
-      return []; // TODO
-    })();
+  async syncLeftRooms() {
+    return []; // TODO
   }
 
   /**
@@ -341,10 +310,8 @@ export class SlidingSyncSdk {
    * @returns A promise which resolves once the room has been added to the
    * store.
    */
-  peek(roomId) {
-    return _asyncToGenerator(function* () {
-      return null; // TODO
-    })();
+  async peek(roomId) {
+    return null; // TODO
   }
 
   /**
@@ -379,16 +346,17 @@ export class SlidingSyncSdk {
    * this object.
    */
   getSyncStateData() {
-    var _this$syncStateData;
-    return (_this$syncStateData = this.syncStateData) !== null && _this$syncStateData !== void 0 ? _this$syncStateData : null;
+    return this.syncStateData ?? null;
   }
 
   // Helper functions which set up JS SDK structs are below and are identical to the sync v2 counterparts
 
   createRoom(roomId) {
     // XXX cargoculted from sync.ts
-    var timelineSupport = this.client.timelineSupport;
-    var room = new Room(roomId, this.client, this.client.getUserId(), {
+    const {
+      timelineSupport
+    } = this.client;
+    const room = new Room(roomId, this.client, this.client.getUserId(), {
       lazyLoadMembers: this.opts.lazyLoadMembers,
       pendingEventOrdering: this.opts.pendingEventOrdering,
       timelineSupport
@@ -404,8 +372,7 @@ export class SlidingSyncSdk {
     // order to hook them correctly.
     this.client.reEmitter.reEmit(room.currentState, [RoomStateEvent.Events, RoomStateEvent.Members, RoomStateEvent.NewMember, RoomStateEvent.Update]);
     room.currentState.on(RoomStateEvent.NewMember, (event, state, member) => {
-      var _this$client$getUser;
-      member.user = (_this$client$getUser = this.client.getUser(member.userId)) !== null && _this$client$getUser !== void 0 ? _this$client$getUser : undefined;
+      member.user = this.client.getUser(member.userId) ?? undefined;
       this.client.reEmitter.reEmit(member, [RoomMemberEvent.Name, RoomMemberEvent.Typing, RoomMemberEvent.PowerLevel, RoomMemberEvent.Membership]);
     });
   }
@@ -430,189 +397,180 @@ export class SlidingSyncSdk {
     }
     return false;
   }
-  processRoomData(client, room, roomData) {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      roomData = ensureNameEvent(client, room.roomId, roomData);
-      var stateEvents = mapEvents(_this9.client, room.roomId, roomData.required_state);
-      // Prevent events from being decrypted ahead of time
-      // this helps large account to speed up faster
-      // room::decryptCriticalEvent is in charge of decrypting all the events
-      // required for a client to function properly
-      var timelineEvents = mapEvents(_this9.client, room.roomId, roomData.timeline, false);
-      var ephemeralEvents = []; // TODO this.mapSyncEventsFormat(joinObj.ephemeral);
-
-      // TODO: handle threaded / beacon events
-
-      if (roomData.limited || roomData.initial) {
-        // we should not know about any of these timeline entries if this is a genuinely new room.
-        // If we do, then we've effectively done scrollback (e.g requesting timeline_limit: 1 for
-        // this room, then timeline_limit: 50).
-        var knownEvents = new Set();
-        room.getLiveTimeline().getEvents().forEach(e => {
-          knownEvents.add(e.getId());
-        });
-        // all unknown events BEFORE a known event must be scrollback e.g:
-        //       D E   <-- what we know
-        // A B C D E F <-- what we just received
-        // means:
-        // A B C       <-- scrollback
-        //       D E   <-- dupes
-        //           F <-- new event
-        // We bucket events based on if we have seen a known event yet.
-        var oldEvents = [];
-        var newEvents = [];
-        var seenKnownEvent = false;
-        for (var i = timelineEvents.length - 1; i >= 0; i--) {
-          var recvEvent = timelineEvents[i];
-          if (knownEvents.has(recvEvent.getId())) {
-            seenKnownEvent = true;
-            continue; // don't include this event, it's a dupe
-          }
-          if (seenKnownEvent) {
-            // old -> new
-            oldEvents.push(recvEvent);
-          } else {
-            // old -> new
-            newEvents.unshift(recvEvent);
-          }
-        }
-        timelineEvents = newEvents;
-        if (oldEvents.length > 0) {
-          // old events are scrollback, insert them now
-          room.addEventsToTimeline(oldEvents, true, false, room.getLiveTimeline(), roomData.prev_batch);
+  async processRoomData(client, room, roomData) {
+    roomData = ensureNameEvent(client, room.roomId, roomData);
+    const stateEvents = mapEvents(this.client, room.roomId, roomData.required_state);
+    // Prevent events from being decrypted ahead of time
+    // this helps large account to speed up faster
+    // room::decryptCriticalEvent is in charge of decrypting all the events
+    // required for a client to function properly
+    let timelineEvents = mapEvents(this.client, room.roomId, roomData.timeline, false);
+    const ephemeralEvents = []; // TODO this.mapSyncEventsFormat(joinObj.ephemeral);
+
+    // TODO: handle threaded / beacon events
+
+    if (roomData.limited || roomData.initial) {
+      // we should not know about any of these timeline entries if this is a genuinely new room.
+      // If we do, then we've effectively done scrollback (e.g requesting timeline_limit: 1 for
+      // this room, then timeline_limit: 50).
+      const knownEvents = new Set();
+      room.getLiveTimeline().getEvents().forEach(e => {
+        knownEvents.add(e.getId());
+      });
+      // all unknown events BEFORE a known event must be scrollback e.g:
+      //       D E   <-- what we know
+      // A B C D E F <-- what we just received
+      // means:
+      // A B C       <-- scrollback
+      //       D E   <-- dupes
+      //           F <-- new event
+      // We bucket events based on if we have seen a known event yet.
+      const oldEvents = [];
+      const newEvents = [];
+      let seenKnownEvent = false;
+      for (let i = timelineEvents.length - 1; i >= 0; i--) {
+        const recvEvent = timelineEvents[i];
+        if (knownEvents.has(recvEvent.getId())) {
+          seenKnownEvent = true;
+          continue; // don't include this event, it's a dupe
         }
-      }
-      var encrypted = room.hasEncryptionStateEvent();
-      // we do this first so it's correct when any of the events fire
-      if (roomData.notification_count != null) {
-        room.setUnreadNotificationCount(NotificationCountType.Total, roomData.notification_count);
-      }
-      if (roomData.highlight_count != null) {
-        // We track unread notifications ourselves in encrypted rooms, so don't
-        // bother setting it here. We trust our calculations better than the
-        // server's for this case, and therefore will assume that our non-zero
-        // count is accurate.
-        if (!encrypted || encrypted && room.getUnreadNotificationCount(NotificationCountType.Highlight) <= 0) {
-          room.setUnreadNotificationCount(NotificationCountType.Highlight, roomData.highlight_count);
+        if (seenKnownEvent) {
+          // old -> new
+          oldEvents.push(recvEvent);
+        } else {
+          // old -> new
+          newEvents.unshift(recvEvent);
         }
       }
-      if (roomData.bump_stamp) {
-        room.setBumpStamp(roomData.bump_stamp);
+      timelineEvents = newEvents;
+      if (oldEvents.length > 0) {
+        // old events are scrollback, insert them now
+        room.addEventsToTimeline(oldEvents, true, false, room.getLiveTimeline(), roomData.prev_batch);
       }
-      if (Number.isInteger(roomData.invited_count)) {
-        room.currentState.setInvitedMemberCount(roomData.invited_count);
+    }
+    const encrypted = room.hasEncryptionStateEvent();
+    // we do this first so it's correct when any of the events fire
+    if (roomData.notification_count != null) {
+      room.setUnreadNotificationCount(NotificationCountType.Total, roomData.notification_count);
+    }
+    if (roomData.highlight_count != null) {
+      // We track unread notifications ourselves in encrypted rooms, so don't
+      // bother setting it here. We trust our calculations better than the
+      // server's for this case, and therefore will assume that our non-zero
+      // count is accurate.
+      if (!encrypted || encrypted && room.getUnreadNotificationCount(NotificationCountType.Highlight) <= 0) {
+        room.setUnreadNotificationCount(NotificationCountType.Highlight, roomData.highlight_count);
       }
-      if (Number.isInteger(roomData.joined_count)) {
-        room.currentState.setJoinedMemberCount(roomData.joined_count);
+    }
+    if (roomData.bump_stamp) {
+      room.setBumpStamp(roomData.bump_stamp);
+    }
+    if (Number.isInteger(roomData.invited_count)) {
+      room.currentState.setInvitedMemberCount(roomData.invited_count);
+    }
+    if (Number.isInteger(roomData.joined_count)) {
+      room.currentState.setJoinedMemberCount(roomData.joined_count);
+    }
+    if (roomData.invite_state) {
+      const inviteStateEvents = mapEvents(this.client, room.roomId, roomData.invite_state);
+      await this.injectRoomEvents(room, inviteStateEvents);
+      if (roomData.initial) {
+        room.recalculate();
+        this.client.store.storeRoom(room);
+        this.client.emit(ClientEvent.Room, room);
       }
-      if (roomData.invite_state) {
-        var inviteStateEvents = mapEvents(_this9.client, room.roomId, roomData.invite_state);
-        yield _this9.injectRoomEvents(room, inviteStateEvents);
-        if (roomData.initial) {
-          room.recalculate();
-          _this9.client.store.storeRoom(room);
-          _this9.client.emit(ClientEvent.Room, room);
+      inviteStateEvents.forEach(e => {
+        this.client.emit(ClientEvent.Event, e);
+      });
+      return;
+    }
+    if (roomData.limited) {
+      // set the back-pagination token. Do this *before* adding any
+      // events so that clients can start back-paginating.
+      room.getLiveTimeline().setPaginationToken(roomData.prev_batch ?? null, EventTimeline.BACKWARDS);
+    }
+
+    /* TODO
+    else if (roomData.limited) {
+         let limited = true;
+         // we've got a limited sync, so we *probably* have a gap in the
+        // timeline, so should reset. But we might have been peeking or
+        // paginating and already have some of the events, in which
+        // case we just want to append any subsequent events to the end
+        // of the existing timeline.
+        //
+        // This is particularly important in the case that we already have
+        // *all* of the events in the timeline - in that case, if we reset
+        // the timeline, we'll end up with an entirely empty timeline,
+        // which we'll try to paginate but not get any new events (which
+        // will stop us linking the empty timeline into the chain).
+        //
+        for (let i = timelineEvents.length - 1; i >= 0; i--) {
+            const eventId = timelineEvents[i].getId();
+            if (room.getTimelineForEvent(eventId)) {
+                this.syncOpts.logger.debug("Already have event " + eventId + " in limited " +
+                    "sync - not resetting");
+                limited = false;
+                 // we might still be missing some of the events before i;
+                // we don't want to be adding them to the end of the
+                // timeline because that would put them out of order.
+                timelineEvents.splice(0, i);
+                 // XXX: there's a problem here if the skipped part of the
+                // timeline modifies the state set in stateEvents, because
+                // we'll end up using the state from stateEvents rather
+                // than the later state from timelineEvents. We probably
+                // need to wind stateEvents forward over the events we're
+                // skipping.
+                break;
+            }
         }
-        inviteStateEvents.forEach(e => {
-          _this9.client.emit(ClientEvent.Event, e);
-        });
-        return;
-      }
-      if (roomData.limited) {
-        var _roomData$prev_batch;
-        // set the back-pagination token. Do this *before* adding any
-        // events so that clients can start back-paginating.
-        room.getLiveTimeline().setPaginationToken((_roomData$prev_batch = roomData.prev_batch) !== null && _roomData$prev_batch !== void 0 ? _roomData$prev_batch : null, EventTimeline.BACKWARDS);
-      }
+         if (limited) {
+            room.resetLiveTimeline(
+                roomData.prev_batch,
+                null, // TODO this.syncOpts.canResetEntireTimeline(room.roomId) ? null : syncEventData.oldSyncToken,
+            );
+             // We have to assume any gap in any timeline is
+            // reason to stop incrementally tracking notifications and
+            // reset the timeline.
+            this.client.resetNotifTimelineSet();
+            this.registerStateListeners(room);
+        }
+    } */
 
-      /* TODO
-      else if (roomData.limited) {
-           let limited = true;
-           // we've got a limited sync, so we *probably* have a gap in the
-          // timeline, so should reset. But we might have been peeking or
-          // paginating and already have some of the events, in which
-          // case we just want to append any subsequent events to the end
-          // of the existing timeline.
-          //
-          // This is particularly important in the case that we already have
-          // *all* of the events in the timeline - in that case, if we reset
-          // the timeline, we'll end up with an entirely empty timeline,
-          // which we'll try to paginate but not get any new events (which
-          // will stop us linking the empty timeline into the chain).
-          //
-          for (let i = timelineEvents.length - 1; i >= 0; i--) {
-              const eventId = timelineEvents[i].getId();
-              if (room.getTimelineForEvent(eventId)) {
-                  this.syncOpts.logger.debug("Already have event " + eventId + " in limited " +
-                      "sync - not resetting");
-                  limited = false;
-                   // we might still be missing some of the events before i;
-                  // we don't want to be adding them to the end of the
-                  // timeline because that would put them out of order.
-                  timelineEvents.splice(0, i);
-                   // XXX: there's a problem here if the skipped part of the
-                  // timeline modifies the state set in stateEvents, because
-                  // we'll end up using the state from stateEvents rather
-                  // than the later state from timelineEvents. We probably
-                  // need to wind stateEvents forward over the events we're
-                  // skipping.
-                  break;
-              }
-          }
-           if (limited) {
-              room.resetLiveTimeline(
-                  roomData.prev_batch,
-                  null, // TODO this.syncOpts.canResetEntireTimeline(room.roomId) ? null : syncEventData.oldSyncToken,
-              );
-               // We have to assume any gap in any timeline is
-              // reason to stop incrementally tracking notifications and
-              // reset the timeline.
-              this.client.resetNotifTimelineSet();
-              this.registerStateListeners(room);
-          }
-      } */
+    await this.injectRoomEvents(room, stateEvents, timelineEvents, roomData.num_live);
 
-      yield _this9.injectRoomEvents(room, stateEvents, timelineEvents, roomData.num_live);
+    // we deliberately don't add ephemeral events to the timeline
+    room.addEphemeralEvents(ephemeralEvents);
 
-      // we deliberately don't add ephemeral events to the timeline
-      room.addEphemeralEvents(ephemeralEvents);
+    // local fields must be set before any async calls because call site assumes
+    // synchronous execution prior to emitting SlidingSyncState.Complete
+    room.updateMyMembership(KnownMembership.Join);
+    room.setMSC4186SummaryData(roomData.heroes, roomData.joined_count, roomData.invited_count);
+    room.recalculate();
+    if (roomData.initial) {
+      client.store.storeRoom(room);
+      client.emit(ClientEvent.Room, room);
+    }
 
-      // local fields must be set before any async calls because call site assumes
-      // synchronous execution prior to emitting SlidingSyncState.Complete
-      room.updateMyMembership(KnownMembership.Join);
-      room.setMSC4186SummaryData(roomData.heroes, roomData.joined_count, roomData.invited_count);
-      room.recalculate();
-      if (roomData.initial) {
-        client.store.storeRoom(room);
-        client.emit(ClientEvent.Room, room);
+    // check if any timeline events should bing and add them to the notifEvents array:
+    // we'll purge this once we've fully processed the sync response
+    this.addNotifications(timelineEvents);
+    const processRoomEvent = async e => {
+      client.emit(ClientEvent.Event, e);
+      if (e.isState() && e.getType() == EventType.RoomEncryption && this.syncOpts.cryptoCallbacks) {
+        await this.syncOpts.cryptoCallbacks.onCryptoEvent(room, e);
       }
+    };
+    await promiseMapSeries(stateEvents, processRoomEvent);
+    await promiseMapSeries(timelineEvents, processRoomEvent);
+    ephemeralEvents.forEach(function (e) {
+      client.emit(ClientEvent.Event, e);
+    });
 
-      // check if any timeline events should bing and add them to the notifEvents array:
-      // we'll purge this once we've fully processed the sync response
-      _this9.addNotifications(timelineEvents);
-      var processRoomEvent = /*#__PURE__*/function () {
-        var _ref = _asyncToGenerator(function* (e) {
-          client.emit(ClientEvent.Event, e);
-          if (e.isState() && e.getType() == EventType.RoomEncryption && _this9.syncOpts.cryptoCallbacks) {
-            yield _this9.syncOpts.cryptoCallbacks.onCryptoEvent(room, e);
-          }
-        });
-        return function processRoomEvent(_x) {
-          return _ref.apply(this, arguments);
-        };
-      }();
-      yield promiseMapSeries(stateEvents, processRoomEvent);
-      yield promiseMapSeries(timelineEvents, processRoomEvent);
-      ephemeralEvents.forEach(function (e) {
-        client.emit(ClientEvent.Event, e);
-      });
-
-      // Decrypt only the last message in all rooms to make sure we can generate a preview
-      // And decrypt all events after the recorded read receipt to ensure an accurate
-      // notification count
-      room.decryptCriticalEvents();
-    })();
+    // Decrypt only the last message in all rooms to make sure we can generate a preview
+    // And decrypt all events after the recorded read receipt to ensure an accurate
+    // notification count
+    room.decryptCriticalEvents();
   }
 
   /**
@@ -624,94 +582,88 @@ export class SlidingSyncSdk {
    * @param numLive - the number of events in timelineEventList which just happened,
    * supplied from the server.
    */
-  injectRoomEvents(room, stateEventList) {
-    var _arguments = arguments,
-      _this0 = this;
-    return _asyncToGenerator(function* () {
-      var timelineEventList = _arguments.length > 2 && _arguments[2] !== undefined ? _arguments[2] : [];
-      var numLive = _arguments.length > 3 && _arguments[3] !== undefined ? _arguments[3] : 0;
-      // If there are no events in the timeline yet, initialise it with
-      // the given state events
-      var liveTimeline = room.getLiveTimeline();
-      var timelineWasEmpty = liveTimeline.getEvents().length == 0;
-      if (timelineWasEmpty) {
-        // Passing these events into initialiseState will freeze them, so we need
-        // to compute and cache the push actions for them now, otherwise sync dies
-        // with an attempt to assign to read only property.
-        // XXX: This is pretty horrible and is assuming all sorts of behaviour from
-        // these functions that it shouldn't be. We should probably either store the
-        // push actions cache elsewhere so we can freeze MatrixEvents, or otherwise
-        // find some solution where MatrixEvents are immutable but allow for a cache
-        // field.
-        for (var ev of stateEventList) {
-          _this0.client.getPushActionsForEvent(ev);
-        }
-        liveTimeline.initialiseState(stateEventList);
+  async injectRoomEvents(room, stateEventList, timelineEventList = [], numLive = 0) {
+    // If there are no events in the timeline yet, initialise it with
+    // the given state events
+    const liveTimeline = room.getLiveTimeline();
+    const timelineWasEmpty = liveTimeline.getEvents().length == 0;
+    if (timelineWasEmpty) {
+      // Passing these events into initialiseState will freeze them, so we need
+      // to compute and cache the push actions for them now, otherwise sync dies
+      // with an attempt to assign to read only property.
+      // XXX: This is pretty horrible and is assuming all sorts of behaviour from
+      // these functions that it shouldn't be. We should probably either store the
+      // push actions cache elsewhere so we can freeze MatrixEvents, or otherwise
+      // find some solution where MatrixEvents are immutable but allow for a cache
+      // field.
+      for (const ev of stateEventList) {
+        this.client.getPushActionsForEvent(ev);
       }
+      liveTimeline.initialiseState(stateEventList);
+    }
 
-      // If the timeline wasn't empty, we process the state events here: they're
-      // defined as updates to the state before the start of the timeline, so this
-      // starts to roll the state forward.
-      // XXX: That's what we *should* do, but this can happen if we were previously
-      // peeking in a room, in which case we obviously do *not* want to add the
-      // state events here onto the end of the timeline. Historically, the js-sdk
-      // has just set these new state events on the old and new state. This seems
-      // very wrong because there could be events in the timeline that diverge the
-      // state, in which case this is going to leave things out of sync. However,
-      // for now I think it;s best to behave the same as the code has done previously.
-      if (!timelineWasEmpty) {
-        // XXX: As above, don't do this...
-        //room.addLiveEvents(stateEventList || []);
-        // Do this instead...
-        room.oldState.setStateEvents(stateEventList);
-        room.currentState.setStateEvents(stateEventList);
-      }
+    // If the timeline wasn't empty, we process the state events here: they're
+    // defined as updates to the state before the start of the timeline, so this
+    // starts to roll the state forward.
+    // XXX: That's what we *should* do, but this can happen if we were previously
+    // peeking in a room, in which case we obviously do *not* want to add the
+    // state events here onto the end of the timeline. Historically, the js-sdk
+    // has just set these new state events on the old and new state. This seems
+    // very wrong because there could be events in the timeline that diverge the
+    // state, in which case this is going to leave things out of sync. However,
+    // for now I think it;s best to behave the same as the code has done previously.
+    if (!timelineWasEmpty) {
+      // XXX: As above, don't do this...
+      //room.addLiveEvents(stateEventList || []);
+      // Do this instead...
+      room.oldState.setStateEvents(stateEventList);
+      room.currentState.setStateEvents(stateEventList);
+    }
 
-      // the timeline is broken into 'live' events which just happened and normal timeline events
-      // which are still to be appended to the end of the live timeline but happened a while ago.
-      // The live events are marked as fromCache=false to ensure that downstream components know
-      // this is a live event, not historical (from a remote server cache).
-
-      var liveTimelineEvents = [];
-      if (numLive > 0) {
-        // last numLive events are live
-        liveTimelineEvents = timelineEventList.slice(-1 * numLive);
-        // everything else is not live
-        timelineEventList = timelineEventList.slice(0, -1 * liveTimelineEvents.length);
-      }
+    // the timeline is broken into 'live' events which just happened and normal timeline events
+    // which are still to be appended to the end of the live timeline but happened a while ago.
+    // The live events are marked as fromCache=false to ensure that downstream components know
+    // this is a live event, not historical (from a remote server cache).
+
+    let liveTimelineEvents = [];
+    if (numLive > 0) {
+      // last numLive events are live
+      liveTimelineEvents = timelineEventList.slice(-1 * numLive);
+      // everything else is not live
+      timelineEventList = timelineEventList.slice(0, -1 * liveTimelineEvents.length);
+    }
 
-      // Execute the timeline events.
-      // This also needs to be done before running push rules on the events as they need
-      // to be decorated with sender etc.
-      yield room.addLiveEvents(timelineEventList, {
-        fromCache: true,
+    // Execute the timeline events.
+    // This also needs to be done before running push rules on the events as they need
+    // to be decorated with sender etc.
+    await room.addLiveEvents(timelineEventList, {
+      fromCache: true,
+      addToState: false
+    });
+    if (liveTimelineEvents.length > 0) {
+      await room.addLiveEvents(liveTimelineEvents, {
+        fromCache: false,
         addToState: false
       });
-      if (liveTimelineEvents.length > 0) {
-        yield room.addLiveEvents(liveTimelineEvents, {
-          fromCache: false,
-          addToState: false
-        });
-      }
-      room.recalculate();
+    }
+    room.recalculate();
 
-      // resolve invites now we have set the latest state
-      _this0.resolveInvites(room);
-    })();
+    // resolve invites now we have set the latest state
+    this.resolveInvites(room);
   }
   resolveInvites(room) {
     if (!room || !this.opts.resolveInvitesToProfiles) {
       return;
     }
-    var client = this.client;
+    const client = this.client;
     // For each invited room member we want to give them a displayname/avatar url
     // if they have one (the m.room.member invites don't contain this).
     room.getMembersWithMembership(KnownMembership.Invite).forEach(function (member) {
       if (member.requestedProfileInfo) return;
       member.requestedProfileInfo = true;
       // try to get a cached copy first.
-      var user = client.getUser(member.userId);
-      var promise;
+      const user = client.getUser(member.userId);
+      let promise;
       if (user) {
         promise = Promise.resolve({
           avatar_url: user.avatarUrl,
@@ -724,7 +676,7 @@ export class SlidingSyncSdk {
         // slightly naughty by doctoring the invite event but this means all
         // the code paths remain the same between invite/join display name stuff
         // which is a worthy trade-off for some minor pollution.
-        var inviteEvent = member.events.member;
+        const inviteEvent = member.events.member;
         if (inviteEvent.getContent().membership !== KnownMembership.Invite) {
           // between resolving and now they have since joined, so don't clobber
           return;
@@ -745,31 +697,28 @@ export class SlidingSyncSdk {
   /**
    * Main entry point. Blocks until stop() is called.
    */
-  sync() {
-    var _this1 = this;
-    return _asyncToGenerator(function* () {
-      _this1.syncOpts.logger.debug("Sliding sync init loop");
-
-      //   1) We need to get push rules so we can check if events should bing as we get
-      //      them from /sync.
-      while (!_this1.client.isGuest()) {
-        try {
-          _this1.syncOpts.logger.debug("Getting push rules...");
-          var result = yield _this1.client.getPushRules();
-          _this1.syncOpts.logger.debug("Got push rules");
-          _this1.client.pushRules = result;
-          break;
-        } catch (err) {
-          _this1.syncOpts.logger.error("Getting push rules failed", err);
-          if (_this1.shouldAbortSync(err)) {
-            return;
-          }
+  async sync() {
+    this.syncOpts.logger.debug("Sliding sync init loop");
+
+    //   1) We need to get push rules so we can check if events should bing as we get
+    //      them from /sync.
+    while (!this.client.isGuest()) {
+      try {
+        this.syncOpts.logger.debug("Getting push rules...");
+        const result = await this.client.getPushRules();
+        this.syncOpts.logger.debug("Got push rules");
+        this.client.pushRules = result;
+        break;
+      } catch (err) {
+        this.syncOpts.logger.error("Getting push rules failed", err);
+        if (this.shouldAbortSync(err)) {
+          return;
         }
       }
+    }
 
-      // start syncing
-      yield _this1.slidingSync.start();
-    })();
+    // start syncing
+    await this.slidingSync.start();
   }
 
   /**
@@ -786,7 +735,7 @@ export class SlidingSyncSdk {
    * @param data - Object of additional data to emit in the event
    */
   updateSyncState(newState, data) {
-    var old = this.syncState;
+    const old = this.syncState;
     this.syncState = newState;
     this.syncStateData = data;
     this.client.emit(ClientEvent.Sync, this.syncState, old, data);
@@ -805,8 +754,8 @@ export class SlidingSyncSdk {
     if (!this.client.getNotifTimelineSet()) {
       return;
     }
-    for (var timelineEvent of timelineEventList) {
-      var pushActions = this.client.getPushActionsForEvent(timelineEvent);
+    for (const timelineEvent of timelineEventList) {
+      const pushActions = this.client.getPushActionsForEvent(timelineEvent);
       if (pushActions && pushActions.notify && pushActions.tweaks && pushActions.tweaks.highlight) {
         this.notifEvents.push(timelineEvent);
       }
@@ -825,8 +774,7 @@ export class SlidingSyncSdk {
       return a.getTs() - b.getTs();
     });
     this.notifEvents.forEach(event => {
-      var _this$client$getNotif;
-      (_this$client$getNotif = this.client.getNotifTimelineSet()) === null || _this$client$getNotif === void 0 || _this$client$getNotif.addLiveEvent(event, {
+      this.client.getNotifTimelineSet()?.addLiveEvent(event, {
         addToState: false
       });
     });
@@ -840,7 +788,7 @@ function ensureNameEvent(client, roomId, roomData) {
   if (!roomData.name) {
     return roomData;
   }
-  for (var stateEvent of roomData.required_state) {
+  for (const stateEvent of roomData.required_state) {
     if (stateEvent.type === EventType.RoomName && stateEvent.state_key === "") {
       stateEvent.content = {
         name: roomData.name
@@ -862,9 +810,8 @@ function ensureNameEvent(client, roomId, roomData) {
 }
 // Helper functions which set up JS SDK structs are below and are identical to the sync v2 counterparts,
 // just outside the class.
-function mapEvents(client, roomId, events) {
-  var decrypt = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
-  var mapper = client.getEventMapper({
+function mapEvents(client, roomId, events, decrypt = true) {
+  const mapper = client.getEventMapper({
     decrypt
   });
   return events.map(function (e) {
@@ -873,8 +820,8 @@ function mapEvents(client, roomId, events) {
   });
 }
 function processEphemeralEvents(client, roomId, ephEvents) {
-  var ephemeralEvents = mapEvents(client, roomId, ephEvents);
-  var room = client.getRoom(roomId);
+  const ephemeralEvents = mapEvents(client, roomId, ephEvents);
+  const room = client.getRoom(roomId);
   if (!room) {
     logger.warn("got ephemeral events for room but room doesn't exist on client:", roomId);
     return;