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

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

@@ -1,8 +1,5 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 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; }
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 /*
 Copyright 2015 - 2023 The Matrix.org Foundation C.I.C.
 
@@ -49,13 +46,13 @@ import { KnownMembership } from "./@types/membership.js";
 // beyond that and wedge forever, so we need to track how long we are willing
 // to keep open the connection. This constant is *ADDED* to the timeout= value
 // to determine the max time we're willing to wait.
-var BUFFER_PERIOD_MS = 80 * 1000;
+const BUFFER_PERIOD_MS = 80 * 1000;
 
 // 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;
-export var SyncState = /*#__PURE__*/function (SyncState) {
+const FAILED_SYNC_ERROR_THRESHOLD = 3;
+export let SyncState = /*#__PURE__*/function (SyncState) {
   /** Emitted after we try to sync more than `FAILED_SYNC_ERROR_THRESHOLD`
    * times and are still failing. Or when we enounter a hard error like the
    * token being invalid. */
@@ -79,18 +76,18 @@ export var SyncState = /*#__PURE__*/function (SyncState) {
 // Room versions where "insertion", "batch", and "marker" events are controlled
 // by power-levels. MSC2716 is supported in existing room versions but they
 // should only have special meaning when the room creator sends them.
-var MSC2716_ROOM_VERSIONS = ["org.matrix.msc2716v3"];
+const MSC2716_ROOM_VERSIONS = ["org.matrix.msc2716v3"];
 function getFilterName(userId, suffix) {
   // scope this on the user ID because people may login on many accounts
   // and they all need to be stored!
-  return "FILTER_SYNC_".concat(userId) + (suffix ? "_" + suffix : "");
+  return `FILTER_SYNC_${userId}` + (suffix ? "_" + suffix : "");
 }
 
 /**
  * Options passed into the constructor of SyncApi by MatrixClient
  */
 
-export var SetPresence = /*#__PURE__*/function (SetPresence) {
+export let SetPresence = /*#__PURE__*/function (SetPresence) {
   SetPresence["Offline"] = "offline";
   SetPresence["Online"] = "online";
   SetPresence["Unavailable"] = "unavailable";
@@ -112,8 +109,6 @@ export function defaultSyncApiOpts(syncOpts) {
   }, syncOpts);
 }
 export class SyncApi {
-  // flag set if the store needs to be cleared before we can start
-
   /**
    * Construct an entity which is able to sync with a homeserver.
    * @param client - The matrix client instance to use.
@@ -122,35 +117,43 @@ export class SyncApi {
    * @internal
    */
   constructor(client, opts, syncOpts) {
-    var _this = this;
+    _defineProperty(this, "opts", void 0);
+    _defineProperty(this, "syncOpts", void 0);
     _defineProperty(this, "_peekRoom", null);
+    _defineProperty(this, "currentSyncRequest", void 0);
+    _defineProperty(this, "abortController", void 0);
     _defineProperty(this, "syncState", null);
+    _defineProperty(this, "syncStateData", void 0);
     // additional data (eg. error object for failed sync)
     _defineProperty(this, "catchingUp", false);
     _defineProperty(this, "running", false);
+    _defineProperty(this, "keepAliveTimer", void 0);
+    _defineProperty(this, "connectionReturnedResolvers", void 0);
     _defineProperty(this, "notifEvents", []);
     // accumulator of sync events in the current sync response
     _defineProperty(this, "failedSyncCount", 0);
     // Number of consecutive failed /sync requests
     _defineProperty(this, "storeIsInvalid", false);
-    _defineProperty(this, "getPushRules", /*#__PURE__*/_asyncToGenerator(function* () {
+    // flag set if the store needs to be cleared before we can start
+    _defineProperty(this, "presence", void 0);
+    _defineProperty(this, "getPushRules", async () => {
       try {
-        _this.syncOpts.logger.debug("Getting push rules...");
-        var result = yield _this.client.getPushRules();
-        _this.syncOpts.logger.debug("Got push rules");
-        _this.client.pushRules = result;
+        this.syncOpts.logger.debug("Getting push rules...");
+        const result = await this.client.getPushRules();
+        this.syncOpts.logger.debug("Got push rules");
+        this.client.pushRules = result;
       } catch (err) {
-        _this.syncOpts.logger.error("Getting push rules failed", err);
-        if (_this.shouldAbortSync(err)) return;
+        this.syncOpts.logger.error("Getting push rules failed", err);
+        if (this.shouldAbortSync(err)) return;
         // wait for saved sync to complete before doing anything else,
         // otherwise the sync state will end up being incorrect
-        _this.syncOpts.logger.debug("Waiting for saved sync before retrying push rules...");
-        yield _this.recoverFromSyncStartupError(_this.savedSyncPromise, err);
-        return _this.getPushRules(); // try again
+        this.syncOpts.logger.debug("Waiting for saved sync before retrying push rules...");
+        await this.recoverFromSyncStartupError(this.savedSyncPromise, err);
+        return this.getPushRules(); // try again
       }
-    }));
+    });
     _defineProperty(this, "buildDefaultFilter", () => {
-      var filter = new Filter(this.client.credentials.userId);
+      const filter = new Filter(this.client.credentials.userId);
       if (this.client.canSupport.get(Feature.ThreadUnreadNotifications) !== ServerSupport.Unsupported) {
         filter.setUnreadThreadNotifications(true);
       }
@@ -176,51 +179,51 @@ export class SyncApi {
     /**
      * Preare sync filter options for the unstable MSC4429 user profile fields if enabled.
      */
-    _defineProperty(this, "prepareSyncFilterUserProfiles", /*#__PURE__*/_asyncToGenerator(function* () {
-      var _this$opts$unstableMS;
-      if ((_this$opts$unstableMS = _this.opts.unstableMSC4429SyncUserProfileFields) !== null && _this$opts$unstableMS !== void 0 && _this$opts$unstableMS.length) {
-        _this.syncOpts.logger.debug("Enabling EXPERIMENTAL user profiles on sync filter...");
-        if (!_this.opts.filter) {
-          _this.opts.filter = _this.buildDefaultFilter();
+    _defineProperty(this, "prepareSyncFilterUserProfiles", async () => {
+      if (this.opts.unstableMSC4429SyncUserProfileFields?.length) {
+        this.syncOpts.logger.debug("Enabling EXPERIMENTAL user profiles on sync filter...");
+        if (!this.opts.filter) {
+          this.opts.filter = this.buildDefaultFilter();
         }
-        _this.opts.filter.setUnstableMSC4429SyncUserProfiles(_this.opts.unstableMSC4429SyncUserProfileFields, yield _this.client.doesServerSupportUnstableFeature("org.matrix.msc4429.stable"));
+        this.opts.filter.setUnstableMSC4429SyncUserProfiles(this.opts.unstableMSC4429SyncUserProfileFields, await this.client.doesServerSupportUnstableFeature("org.matrix.msc4429.stable"));
       }
-    }));
-    _defineProperty(this, "storeClientOptions", /*#__PURE__*/_asyncToGenerator(function* () {
+    });
+    _defineProperty(this, "storeClientOptions", async () => {
       try {
-        _this.syncOpts.logger.debug("Storing client options...");
-        yield _this.client.storeClientOptions();
-        _this.syncOpts.logger.debug("Stored client options");
+        this.syncOpts.logger.debug("Storing client options...");
+        await this.client.storeClientOptions();
+        this.syncOpts.logger.debug("Stored client options");
       } catch (err) {
-        _this.syncOpts.logger.error("Storing client options failed", err);
+        this.syncOpts.logger.error("Storing client options failed", err);
         throw err;
       }
-    }));
-    _defineProperty(this, "getFilter", /*#__PURE__*/_asyncToGenerator(function* () {
-      _this.syncOpts.logger.debug("Getting filter...");
-      var filter;
-      if (_this.opts.filter) {
-        filter = _this.opts.filter;
+    });
+    _defineProperty(this, "getFilter", async () => {
+      this.syncOpts.logger.debug("Getting filter...");
+      let filter;
+      if (this.opts.filter) {
+        filter = this.opts.filter;
       } else {
-        filter = _this.buildDefaultFilter();
+        filter = this.buildDefaultFilter();
       }
-      var filterId;
+      let filterId;
       try {
-        filterId = yield _this.client.getOrCreateFilter(getFilterName(_this.client.credentials.userId), filter);
+        filterId = await this.client.getOrCreateFilter(getFilterName(this.client.credentials.userId), filter);
       } catch (err) {
-        _this.syncOpts.logger.error("Getting filter failed", err);
-        if (_this.shouldAbortSync(err)) return {};
+        this.syncOpts.logger.error("Getting filter failed", err);
+        if (this.shouldAbortSync(err)) return {};
         // wait for saved sync to complete before doing anything else,
         // otherwise the sync state will end up being incorrect
-        _this.syncOpts.logger.debug("Waiting for saved sync before retrying filter...");
-        yield _this.recoverFromSyncStartupError(_this.savedSyncPromise, err);
-        return _this.getFilter(); // try again
+        this.syncOpts.logger.debug("Waiting for saved sync before retrying filter...");
+        await this.recoverFromSyncStartupError(this.savedSyncPromise, err);
+        return this.getFilter(); // try again
       }
       return {
         filter,
         filterId
       };
-    }));
+    });
+    _defineProperty(this, "savedSyncPromise", void 0);
     /**
      * Event handler for the 'online' event
      * This event is generally unreliable and precise behaviour
@@ -239,7 +242,7 @@ export class SyncApi {
     }
   }
   createRoom(roomId) {
-    var room = _createAndReEmitRoom(this.client, roomId, this.opts);
+    const room = _createAndReEmitRoom(this.client, roomId, this.opts);
     room.on(RoomStateEvent.Marker, (markerEvent, markerFoundOptions) => {
       this.onMarkerStateEvent(room, markerEvent, markerFoundOptions);
     });
@@ -255,19 +258,19 @@ export class SyncApi {
    * @param setStateOptions - When `timelineWasEmpty` is set
    * as `true`, the given marker event will be ignored
    */
-  onMarkerStateEvent(room, markerEvent) {
-    var _ref5 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-      timelineWasEmpty = _ref5.timelineWasEmpty;
+  onMarkerStateEvent(room, markerEvent, {
+    timelineWasEmpty
+  } = {}) {
     // We don't need to refresh the timeline if it was empty before the
     // marker arrived. This could be happen in a variety of cases:
     //  1. From the initial sync
     //  2. If it's from the first state we're seeing after joining the room
     //  3. Or whether it's coming from `syncFromCache`
     if (timelineWasEmpty) {
-      this.syncOpts.logger.debug("MarkerState: Ignoring markerEventId=".concat(markerEvent.getId(), " in roomId=").concat(room.roomId, " ") + "because the timeline was empty before the marker arrived which means there is nothing to refresh.");
+      this.syncOpts.logger.debug(`MarkerState: Ignoring markerEventId=${markerEvent.getId()} in roomId=${room.roomId} ` + `because the timeline was empty before the marker arrived which means there is nothing to refresh.`);
       return;
     }
-    var isValidMsc2716Event =
+    const isValidMsc2716Event =
     // Check whether the room version directly supports MSC2716, in
     // which case, "marker" events are already auth'ed by
     // power_levels
@@ -292,11 +295,11 @@ export class SyncApi {
     if (isValidMsc2716Event) {
       // Saw new marker event, let's let the clients know they should
       // refresh the timeline.
-      this.syncOpts.logger.debug("MarkerState: Timeline needs to be refreshed because " + "a new markerEventId=".concat(markerEvent.getId(), " was sent in roomId=").concat(room.roomId));
+      this.syncOpts.logger.debug(`MarkerState: Timeline needs to be refreshed because ` + `a new markerEventId=${markerEvent.getId()} was sent in roomId=${room.roomId}`);
       room.setTimelineNeedsRefresh(true);
       room.emit(RoomEvent.HistoryImportedWithinTimeline, markerEvent, room);
     } else {
-      this.syncOpts.logger.debug("MarkerState: Ignoring markerEventId=".concat(markerEvent.getId(), " in roomId=").concat(room.roomId, " because ") + "MSC2716 is not supported in the room version or for any room version, the marker wasn't sent " + "by the room creator.");
+      this.syncOpts.logger.debug(`MarkerState: Ignoring markerEventId=${markerEvent.getId()} in roomId=${room.roomId} because ` + `MSC2716 is not supported in the room version or for any room version, the marker wasn't sent ` + `by the room creator.`);
     }
   }
 
@@ -304,67 +307,59 @@ export class SyncApi {
    * Sync rooms the user has left.
    * @returns Resolved when they've been added to the store.
    */
-  syncLeftRooms() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      var _data$rooms;
-      var client = _this2.client;
-
-      // grab a filter with limit=1 and include_leave=true
-      var filter = new Filter(_this2.client.credentials.userId);
-      filter.setTimelineLimit(1);
-      filter.setIncludeLeaveRooms(true);
-      var localTimeoutMs = _this2.opts.pollTimeout + BUFFER_PERIOD_MS;
-      var filterId = yield client.getOrCreateFilter(getFilterName(client.credentials.userId, "LEFT_ROOMS"), filter);
-      var qps = {
-        "timeout": 0,
-        // don't want to block since this is a single isolated req
-        "filter": filterId,
-        "org.matrix.msc4222.use_state_after": true
-      };
-      var data = yield client.http.authedRequest(Method.Get, "/sync", qps, undefined, {
-        localTimeoutMs
-      });
-      var leaveRooms = [];
-      if ((_data$rooms = data.rooms) !== null && _data$rooms !== void 0 && _data$rooms.leave) {
-        leaveRooms = _this2.mapSyncResponseToRoomArray(data.rooms.leave);
+  async syncLeftRooms() {
+    const client = this.client;
+
+    // grab a filter with limit=1 and include_leave=true
+    const filter = new Filter(this.client.credentials.userId);
+    filter.setTimelineLimit(1);
+    filter.setIncludeLeaveRooms(true);
+    const localTimeoutMs = this.opts.pollTimeout + BUFFER_PERIOD_MS;
+    const filterId = await client.getOrCreateFilter(getFilterName(client.credentials.userId, "LEFT_ROOMS"), filter);
+    const qps = {
+      "timeout": 0,
+      // don't want to block since this is a single isolated req
+      "filter": filterId,
+      "org.matrix.msc4222.use_state_after": true
+    };
+    const data = await client.http.authedRequest(Method.Get, "/sync", qps, undefined, {
+      localTimeoutMs
+    });
+    let leaveRooms = [];
+    if (data.rooms?.leave) {
+      leaveRooms = this.mapSyncResponseToRoomArray(data.rooms.leave);
+    }
+    const rooms = await Promise.all(leaveRooms.map(async leaveObj => {
+      const room = leaveObj.room;
+      if (!leaveObj.isBrandNewRoom) {
+        // the intention behind syncLeftRooms is to add in rooms which were
+        // *omitted* from the initial /sync. Rooms the user were joined to
+        // but then left whilst the app is running will appear in this list
+        // and we do not want to bother with them since they will have the
+        // current state already (and may get dupe messages if we add
+        // yet more timeline events!), so skip them.
+        // NB: When we persist rooms to localStorage this will be more
+        //     complicated...
+        return;
       }
-      var rooms = yield Promise.all(leaveRooms.map(/*#__PURE__*/function () {
-        var _ref6 = _asyncToGenerator(function* (leaveObj) {
-          var room = leaveObj.room;
-          if (!leaveObj.isBrandNewRoom) {
-            // the intention behind syncLeftRooms is to add in rooms which were
-            // *omitted* from the initial /sync. Rooms the user were joined to
-            // but then left whilst the app is running will appear in this list
-            // and we do not want to bother with them since they will have the
-            // current state already (and may get dupe messages if we add
-            // yet more timeline events!), so skip them.
-            // NB: When we persist rooms to localStorage this will be more
-            //     complicated...
-            return;
-          }
-          leaveObj.timeline = leaveObj.timeline || {
-            prev_batch: null,
-            events: []
-          };
-
-          // set the back-pagination token. Do this *before* adding any
-          // events so that clients can start back-paginating.
-          room.getLiveTimeline().setPaginationToken(leaveObj.timeline.prev_batch, EventTimeline.BACKWARDS);
-          var _yield$_this2$mapAndI = yield _this2.mapAndInjectRoomEvents(leaveObj),
-            timelineEvents = _yield$_this2$mapAndI.timelineEvents;
-          room.recalculate();
-          client.store.storeRoom(room);
-          client.emit(ClientEvent.Room, room);
-          _this2.processEventsForNotifs(room, timelineEvents);
-          return room;
-        });
-        return function (_x) {
-          return _ref6.apply(this, arguments);
-        };
-      }()));
-      return rooms.filter(Boolean);
-    })();
+      leaveObj.timeline = leaveObj.timeline || {
+        prev_batch: null,
+        events: []
+      };
+
+      // set the back-pagination token. Do this *before* adding any
+      // events so that clients can start back-paginating.
+      room.getLiveTimeline().setPaginationToken(leaveObj.timeline.prev_batch, EventTimeline.BACKWARDS);
+      const {
+        timelineEvents
+      } = await this.mapAndInjectRoomEvents(leaveObj);
+      room.recalculate();
+      client.store.storeRoom(room);
+      client.emit(ClientEvent.Room, room);
+      this.processEventsForNotifs(room, timelineEvents);
+      return room;
+    }));
+    return rooms.filter(Boolean);
   }
 
   /**
@@ -375,17 +370,14 @@ export class SyncApi {
    * @returns A promise which resolves once the room has been added to the
    * store.
    */
-  peek(roomId) {
-    var _this$_peekRoom;
-    var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 20;
-    if (((_this$_peekRoom = this._peekRoom) === null || _this$_peekRoom === void 0 ? void 0 : _this$_peekRoom.roomId) === roomId) {
+  peek(roomId, limit = 20) {
+    if (this._peekRoom?.roomId === roomId) {
       return Promise.resolve(this._peekRoom);
     }
-    var client = this.client;
+    const client = this.client;
     this._peekRoom = this.createRoom(roomId);
     return this.client.roomInitialSync(roomId, limit).then(response => {
-      var _this$_peekRoom2;
-      if (((_this$_peekRoom2 = this._peekRoom) === null || _this$_peekRoom2 === void 0 ? void 0 : _this$_peekRoom2.roomId) !== roomId) {
+      if (this._peekRoom?.roomId !== roomId) {
         throw new Error("Peeking aborted");
       }
 
@@ -398,15 +390,15 @@ export class SyncApi {
 
       // FIXME: Mostly duplicated from injectRoomEvents but not entirely
       // because "state" in this API is at the BEGINNING of the chunk
-      var oldStateEvents = deepCopy(response.state).map(client.getEventMapper());
-      var stateEvents = response.state.map(client.getEventMapper());
-      var messages = response.messages.chunk.map(client.getEventMapper());
+      const oldStateEvents = deepCopy(response.state).map(client.getEventMapper());
+      const stateEvents = response.state.map(client.getEventMapper());
+      const messages = response.messages.chunk.map(client.getEventMapper());
 
       // XXX: copypasted from /sync until we kill off this minging v1 API stuff)
       // handle presence events (User objects)
       if (Array.isArray(response.presence)) {
         response.presence.map(client.getEventMapper()).forEach(function (presenceEvent) {
-          var user = client.store.getUser(presenceEvent.getContent().user_id);
+          let user = client.store.getUser(presenceEvent.getContent().user_id);
           if (user) {
             user.setPresenceEvent(presenceEvent);
           } else {
@@ -455,8 +447,6 @@ export class SyncApi {
    * @param token - from= token
    */
   peekPoll(peekRoom, token) {
-    var _this$abortController,
-      _this3 = this;
     if (this._peekRoom !== peekRoom) {
       this.syncOpts.logger.debug("Stopped peeking in room %s", peekRoom.roomId);
       return;
@@ -469,51 +459,46 @@ export class SyncApi {
       from: token
     }, undefined, {
       localTimeoutMs: 50 * 1000,
-      abortSignal: (_this$abortController = this.abortController) === null || _this$abortController === void 0 ? void 0 : _this$abortController.signal
-    }).then(/*#__PURE__*/function () {
-      var _ref7 = _asyncToGenerator(function* (res) {
-        if (_this3._peekRoom !== peekRoom) {
-          _this3.syncOpts.logger.debug("Stopped peeking in room %s", peekRoom.roomId);
-          return;
+      abortSignal: this.abortController?.signal
+    }).then(async res => {
+      if (this._peekRoom !== peekRoom) {
+        this.syncOpts.logger.debug("Stopped peeking in room %s", peekRoom.roomId);
+        return;
+      }
+      // We have a problem that we get presence both from /events and /sync
+      // however, /sync only returns presence for users in rooms
+      // you're actually joined to.
+      // in order to be sure to get presence for all of the users in the
+      // peeked room, we handle presence explicitly here. This may result
+      // in duplicate presence events firing for some users, which is a
+      // performance drain, but such is life.
+      // XXX: copypasted from /sync until we can kill this minging v1 stuff.
+
+      res.chunk.filter(function (e) {
+        return e.type === "m.presence";
+      }).map(this.client.getEventMapper()).forEach(presenceEvent => {
+        let user = this.client.store.getUser(presenceEvent.getContent().user_id);
+        if (user) {
+          user.setPresenceEvent(presenceEvent);
+        } else {
+          user = User.createUser(presenceEvent.getContent().user_id, this.client);
+          user.setPresenceEvent(presenceEvent);
+          this.client.store.storeUser(user);
         }
-        // We have a problem that we get presence both from /events and /sync
-        // however, /sync only returns presence for users in rooms
-        // you're actually joined to.
-        // in order to be sure to get presence for all of the users in the
-        // peeked room, we handle presence explicitly here. This may result
-        // in duplicate presence events firing for some users, which is a
-        // performance drain, but such is life.
-        // XXX: copypasted from /sync until we can kill this minging v1 stuff.
-
-        res.chunk.filter(function (e) {
-          return e.type === "m.presence";
-        }).map(_this3.client.getEventMapper()).forEach(presenceEvent => {
-          var user = _this3.client.store.getUser(presenceEvent.getContent().user_id);
-          if (user) {
-            user.setPresenceEvent(presenceEvent);
-          } else {
-            user = User.createUser(presenceEvent.getContent().user_id, _this3.client);
-            user.setPresenceEvent(presenceEvent);
-            _this3.client.store.storeUser(user);
-          }
-          _this3.client.emit(ClientEvent.Event, presenceEvent);
-        });
+        this.client.emit(ClientEvent.Event, presenceEvent);
+      });
 
-        // strip out events which aren't for the given room_id (e.g presence)
-        // and also ephemeral events (which we're assuming is anything without
-        // and event ID because the /events API doesn't separate them).
-        var events = res.chunk.filter(function (e) {
-          return e.room_id === peekRoom.roomId && e.event_id;
-        }).map(_this3.client.getEventMapper());
-        yield peekRoom.addLiveEvents(events, {
-          addToState: true
-        });
-        _this3.peekPoll(peekRoom, res.end);
+      // strip out events which aren't for the given room_id (e.g presence)
+      // and also ephemeral events (which we're assuming is anything without
+      // and event ID because the /events API doesn't separate them).
+      const events = res.chunk.filter(function (e) {
+        return e.room_id === peekRoom.roomId && e.event_id;
+      }).map(this.client.getEventMapper());
+      await peekRoom.addLiveEvents(events, {
+        addToState: true
       });
-      return function (_x2) {
-        return _ref7.apply(this, arguments);
-      };
-    }(), err => {
+      this.peekPoll(peekRoom, res.end);
+    }, err => {
       this.syncOpts.logger.error("[%s] Peek poll failed: %s", peekRoom.roomId, err);
       setTimeout(() => {
         this.peekPoll(peekRoom, token);
@@ -537,23 +522,19 @@ export class SyncApi {
    * this object.
    */
   getSyncStateData() {
-    var _this$syncStateData;
-    return (_this$syncStateData = this.syncStateData) !== null && _this$syncStateData !== void 0 ? _this$syncStateData : null;
+    return this.syncStateData ?? null;
   }
-  recoverFromSyncStartupError(savedSyncPromise, error) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      // Wait for the saved sync to complete - we send the pushrules and filter requests
-      // before the saved sync has finished so they can run in parallel, but only process
-      // the results after the saved sync is done. Equivalently, we wait for it to finish
-      // before reporting failures from these functions.
-      yield savedSyncPromise;
-      var keepaliveProm = _this4.startKeepAlives();
-      _this4.updateSyncState(SyncState.Error, {
-        error
-      });
-      yield keepaliveProm;
-    })();
+  async recoverFromSyncStartupError(savedSyncPromise, error) {
+    // Wait for the saved sync to complete - we send the pushrules and filter requests
+    // before the saved sync has finished so they can run in parallel, but only process
+    // the results after the saved sync is done. Equivalently, we wait for it to finish
+    // before reporting failures from these functions.
+    await savedSyncPromise;
+    const keepaliveProm = this.startKeepAlives();
+    this.updateSyncState(SyncState.Error, {
+      error
+    });
+    await keepaliveProm;
   }
   shouldAbortSync(error) {
     if (error.errcode === "M_UNKNOWN_TOKEN") {
@@ -570,104 +551,100 @@ export class SyncApi {
   /**
    * Main entry point
    */
-  sync() {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      var _globalThis$window, _globalThis$window$ad;
-      _this5.running = true;
-      _this5.abortController = new AbortController();
-      (_globalThis$window = globalThis.window) === null || _globalThis$window === void 0 || (_globalThis$window$ad = _globalThis$window.addEventListener) === null || _globalThis$window$ad === void 0 || _globalThis$window$ad.call(_globalThis$window, "online", _this5.onOnline, false);
-      if (_this5.client.isGuest()) {
-        // no push rules for guests, no access to POST filter for guests.
-        return _this5.doSync({});
-      }
-
-      // Pull the saved sync token out first, before the worker starts sending
-      // all the sync data which could take a while. This will let us send our
-      // first incremental sync request before we've processed our saved data.
-      _this5.syncOpts.logger.debug("Getting saved sync token...");
-      var savedSyncTokenPromise = _this5.client.store.getSavedSyncToken().then(tok => {
-        _this5.syncOpts.logger.debug("Got saved sync token");
-        return tok;
-      });
-      _this5.savedSyncPromise = _this5.client.store.getSavedSync().then(savedSync => {
-        _this5.syncOpts.logger.debug("Got reply from saved sync, exists? ".concat(!!savedSync));
-        if (savedSync) {
-          return _this5.syncFromCache(savedSync);
-        }
-      }).catch(err => {
-        _this5.syncOpts.logger.error("Getting saved sync failed", err);
-      });
+  async sync() {
+    this.running = true;
+    this.abortController = new AbortController();
+    globalThis.window?.addEventListener?.("online", this.onOnline, false);
+    if (this.client.isGuest()) {
+      // no push rules for guests, no access to POST filter for guests.
+      return this.doSync({});
+    }
 
-      // We need to do one-off checks before we can begin the /sync loop.
-      // These are:
-      //   1) We need to get push rules so we can check if events should bing as we get
-      //      them from /sync.
-      //   2) We need to get/create a filter which we can use for /sync.
-      //   3) We need to prepare lazy loading for sync
-      //   4) We need to store the client options
-
-      // Now start the first incremental sync request: this can also
-      // take a while so if we set it going now, we can wait for it
-      // to finish while we process our saved sync data.
-      yield _this5.getPushRules();
-      _this5.prepareSyncFilterLazyLoading();
-      yield _this5.prepareSyncFilterUserProfiles();
-      yield _this5.storeClientOptions();
-      var _yield$_this5$getFilt = yield _this5.getFilter(),
-        filterId = _yield$_this5$getFilt.filterId,
-        filter = _yield$_this5$getFilt.filter;
-      if (!filter) return; // bail, getFilter failed
-
-      // reset the notifications timeline to prepare it to paginate from
-      // the current point in time.
-      // The right solution would be to tie /sync pagination tokens into
-      // /notifications API somehow.
-      _this5.client.resetNotifTimelineSet();
-      if (!_this5.currentSyncRequest) {
-        var firstSyncFilter = filterId;
-        var savedSyncToken = yield savedSyncTokenPromise;
-        if (savedSyncToken) {
-          _this5.syncOpts.logger.debug("Sending first sync request...");
-        } else {
-          _this5.syncOpts.logger.debug("Sending initial sync request...");
-          var initialFilter = _this5.buildDefaultFilter();
-          initialFilter.setDefinition(filter.getDefinition());
-          initialFilter.setTimelineLimit(_this5.opts.initialSyncLimit);
-          // Use an inline filter, no point uploading it for a single usage
-          firstSyncFilter = JSON.stringify(initialFilter.getDefinition());
-        }
+    // Pull the saved sync token out first, before the worker starts sending
+    // all the sync data which could take a while. This will let us send our
+    // first incremental sync request before we've processed our saved data.
+    this.syncOpts.logger.debug("Getting saved sync token...");
+    const savedSyncTokenPromise = this.client.store.getSavedSyncToken().then(tok => {
+      this.syncOpts.logger.debug("Got saved sync token");
+      return tok;
+    });
+    this.savedSyncPromise = this.client.store.getSavedSync().then(savedSync => {
+      this.syncOpts.logger.debug(`Got reply from saved sync, exists? ${!!savedSync}`);
+      if (savedSync) {
+        return this.syncFromCache(savedSync);
+      }
+    }).catch(err => {
+      this.syncOpts.logger.error("Getting saved sync failed", err);
+    });
 
-        // Send this first sync request here so we can then wait for the saved
-        // sync data to finish processing before we process the results of this one.
-        _this5.currentSyncRequest = _this5.doSyncRequest({
-          filter: firstSyncFilter
-        }, savedSyncToken);
+    // We need to do one-off checks before we can begin the /sync loop.
+    // These are:
+    //   1) We need to get push rules so we can check if events should bing as we get
+    //      them from /sync.
+    //   2) We need to get/create a filter which we can use for /sync.
+    //   3) We need to prepare lazy loading for sync
+    //   4) We need to store the client options
+
+    // Now start the first incremental sync request: this can also
+    // take a while so if we set it going now, we can wait for it
+    // to finish while we process our saved sync data.
+    await this.getPushRules();
+    this.prepareSyncFilterLazyLoading();
+    await this.prepareSyncFilterUserProfiles();
+    await this.storeClientOptions();
+    const {
+      filterId,
+      filter
+    } = await this.getFilter();
+    if (!filter) return; // bail, getFilter failed
+
+    // reset the notifications timeline to prepare it to paginate from
+    // the current point in time.
+    // The right solution would be to tie /sync pagination tokens into
+    // /notifications API somehow.
+    this.client.resetNotifTimelineSet();
+    if (!this.currentSyncRequest) {
+      let firstSyncFilter = filterId;
+      const savedSyncToken = await savedSyncTokenPromise;
+      if (savedSyncToken) {
+        this.syncOpts.logger.debug("Sending first sync request...");
+      } else {
+        this.syncOpts.logger.debug("Sending initial sync request...");
+        const initialFilter = this.buildDefaultFilter();
+        initialFilter.setDefinition(filter.getDefinition());
+        initialFilter.setTimelineLimit(this.opts.initialSyncLimit);
+        // Use an inline filter, no point uploading it for a single usage
+        firstSyncFilter = JSON.stringify(initialFilter.getDefinition());
       }
 
-      // Now wait for the saved sync to finish...
-      _this5.syncOpts.logger.debug("Waiting for saved sync before starting sync processing...");
-      yield _this5.savedSyncPromise;
-      // process the first sync request and continue syncing with the normal filterId
-      return _this5.doSync({
-        filter: filterId
-      });
-    })();
+      // Send this first sync request here so we can then wait for the saved
+      // sync data to finish processing before we process the results of this one.
+      this.currentSyncRequest = this.doSyncRequest({
+        filter: firstSyncFilter
+      }, savedSyncToken);
+    }
+
+    // Now wait for the saved sync to finish...
+    this.syncOpts.logger.debug("Waiting for saved sync before starting sync processing...");
+    await this.savedSyncPromise;
+    // process the first sync request and continue syncing with the normal filterId
+    return this.doSync({
+      filter: filterId
+    });
   }
 
   /**
    * Stops the sync object from syncing.
    */
   stop() {
-    var _globalThis$window2, _globalThis$window2$r, _this$abortController2;
     this.syncOpts.logger.debug("SyncApi.stop");
     // It is necessary to check for the existance of
     // globalThis.window AND globalThis.window.removeEventListener.
     // Some platforms (e.g. React Native) register globalThis.window,
     // but do not have globalThis.window.removeEventListener.
-    (_globalThis$window2 = globalThis.window) === null || _globalThis$window2 === void 0 || (_globalThis$window2$r = _globalThis$window2.removeEventListener) === null || _globalThis$window2$r === void 0 || _globalThis$window2$r.call(_globalThis$window2, "online", this.onOnline, false);
+    globalThis.window?.removeEventListener?.("online", this.onOnline, false);
     this.running = false;
-    (_this$abortController2 = this.abortController) === null || _this$abortController2 === void 0 || _this$abortController2.abort();
+    this.abortController?.abort();
     if (this.keepAliveTimer) {
       clearTimeout(this.keepAliveTimer);
       this.keepAliveTimer = undefined;
@@ -691,134 +668,127 @@ export class SyncApi {
    * @param savedSync - a saved sync that was persisted by a store. This
    * should have been acquired via client.store.getSavedSync().
    */
-  syncFromCache(savedSync) {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      _this6.syncOpts.logger.debug("sync(): not doing HTTP hit, instead returning stored /sync data");
-      var nextSyncToken = savedSync.nextBatch;
-
-      // Set sync token for future incremental syncing
-      _this6.client.store.setSyncToken(nextSyncToken);
-
-      // No previous sync, set old token to null
-      var syncEventData = {
-        nextSyncToken,
-        catchingUp: false,
-        fromCache: true
-      };
-      var data = {
-        next_batch: nextSyncToken,
-        rooms: savedSync.roomsData,
-        account_data: {
-          events: savedSync.accountData
-        }
-      };
-      try {
-        yield _this6.processSyncResponse(syncEventData, data);
-      } catch (e) {
-        _this6.syncOpts.logger.error("Error processing cached sync", e);
+  async syncFromCache(savedSync) {
+    this.syncOpts.logger.debug("sync(): not doing HTTP hit, instead returning stored /sync data");
+    const nextSyncToken = savedSync.nextBatch;
+
+    // Set sync token for future incremental syncing
+    this.client.store.setSyncToken(nextSyncToken);
+
+    // No previous sync, set old token to null
+    const syncEventData = {
+      nextSyncToken,
+      catchingUp: false,
+      fromCache: true
+    };
+    const data = {
+      next_batch: nextSyncToken,
+      rooms: savedSync.roomsData,
+      account_data: {
+        events: savedSync.accountData
       }
+    };
+    try {
+      await this.processSyncResponse(syncEventData, data);
+    } catch (e) {
+      this.syncOpts.logger.error("Error processing cached sync", e);
+    }
 
-      // Don't emit a prepared if we've bailed because the store is invalid:
-      // in this case the client will not be usable until stopped & restarted
-      // so this would be useless and misleading.
-      if (!_this6.storeIsInvalid) {
-        _this6.updateSyncState(SyncState.Prepared, syncEventData);
-      }
-    })();
+    // Don't emit a prepared if we've bailed because the store is invalid:
+    // in this case the client will not be usable until stopped & restarted
+    // so this would be useless and misleading.
+    if (!this.storeIsInvalid) {
+      this.updateSyncState(SyncState.Prepared, syncEventData);
+    }
   }
 
   /**
    * Invoke me to do /sync calls
    */
-  doSync(syncOptions) {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      while (_this7.running) {
-        var syncToken = _this7.client.store.getSyncToken();
-        var data = void 0;
-        try {
-          if (!_this7.currentSyncRequest) {
-            _this7.currentSyncRequest = _this7.doSyncRequest(syncOptions, syncToken);
-          }
-          data = yield _this7.currentSyncRequest;
-        } catch (e) {
-          var abort = yield _this7.onSyncError(e);
-          if (abort) return;
-          continue;
-        } finally {
-          _this7.currentSyncRequest = undefined;
+  async doSync(syncOptions) {
+    while (this.running) {
+      const syncToken = this.client.store.getSyncToken();
+      let data;
+      try {
+        if (!this.currentSyncRequest) {
+          this.currentSyncRequest = this.doSyncRequest(syncOptions, syncToken);
         }
+        data = await this.currentSyncRequest;
+      } catch (e) {
+        const abort = await this.onSyncError(e);
+        if (abort) return;
+        continue;
+      } finally {
+        this.currentSyncRequest = undefined;
+      }
 
-        // set the sync token NOW *before* processing the events. We do this so
-        // if something barfs on an event we can skip it rather than constantly
-        // polling with the same token.
-        _this7.client.store.setSyncToken(data.next_batch);
-
-        // Reset after a successful sync
-        _this7.failedSyncCount = 0;
-        var syncEventData = {
-          oldSyncToken: syncToken !== null && syncToken !== void 0 ? syncToken : undefined,
-          nextSyncToken: data.next_batch,
-          catchingUp: _this7.catchingUp
-        };
-        try {
-          yield _this7.processSyncResponse(syncEventData, data);
-        } catch (e) {
-          // log the exception with stack if we have it, else fall back
-          // to the plain description
-          _this7.syncOpts.logger.error("Caught /sync error", e);
-
-          // Emit the exception for client handling
-          _this7.client.emit(ClientEvent.SyncUnexpectedError, e);
-        }
+      // set the sync token NOW *before* processing the events. We do this so
+      // if something barfs on an event we can skip it rather than constantly
+      // polling with the same token.
+      this.client.store.setSyncToken(data.next_batch);
+
+      // Reset after a successful sync
+      this.failedSyncCount = 0;
+      const syncEventData = {
+        oldSyncToken: syncToken ?? undefined,
+        nextSyncToken: data.next_batch,
+        catchingUp: this.catchingUp
+      };
+      try {
+        await this.processSyncResponse(syncEventData, data);
+      } catch (e) {
+        // log the exception with stack if we have it, else fall back
+        // to the plain description
+        this.syncOpts.logger.error("Caught /sync error", e);
 
-        // Persist after processing as `unsigned` may get mutated
-        // with an `org.matrix.msc4023.thread_id`
-        yield _this7.client.store.setSyncData(data);
+        // Emit the exception for client handling
+        this.client.emit(ClientEvent.SyncUnexpectedError, e);
+      }
 
-        // update this as it may have changed
-        syncEventData.catchingUp = _this7.catchingUp;
+      // Persist after processing as `unsigned` may get mutated
+      // with an `org.matrix.msc4023.thread_id`
+      await this.client.store.setSyncData(data);
 
-        // emit synced events
-        if (!syncOptions.hasSyncedBefore) {
-          _this7.updateSyncState(SyncState.Prepared, syncEventData);
-          syncOptions.hasSyncedBefore = true;
-        }
+      // update this as it may have changed
+      syncEventData.catchingUp = this.catchingUp;
 
-        // tell the crypto module to do its processing. It may block (to do a
-        // /keys/changes request).
-        if (_this7.syncOpts.cryptoCallbacks) {
-          yield _this7.syncOpts.cryptoCallbacks.onSyncCompleted(syncEventData);
-        }
+      // emit synced events
+      if (!syncOptions.hasSyncedBefore) {
+        this.updateSyncState(SyncState.Prepared, syncEventData);
+        syncOptions.hasSyncedBefore = true;
+      }
 
-        // keep emitting SYNCING -> SYNCING for clients who want to do bulk updates
-        _this7.updateSyncState(SyncState.Syncing, syncEventData);
-        if (_this7.client.store.wantsSave()) {
-          // tell databases that everything is now in a consistent state and can be saved.
-          yield _this7.client.store.save();
-        }
+      // tell the crypto module to do its processing. It may block (to do a
+      // /keys/changes request).
+      if (this.syncOpts.cryptoCallbacks) {
+        this.syncOpts.cryptoCallbacks.onSyncCompleted(syncEventData);
       }
-      if (!_this7.running) {
-        _this7.syncOpts.logger.debug("Sync no longer running: exiting.");
-        if (_this7.connectionReturnedResolvers) {
-          _this7.connectionReturnedResolvers.reject();
-          _this7.connectionReturnedResolvers = undefined;
-        }
-        _this7.updateSyncState(SyncState.Stopped);
+
+      // keep emitting SYNCING -> SYNCING for clients who want to do bulk updates
+      this.updateSyncState(SyncState.Syncing, syncEventData);
+      if (this.client.store.wantsSave()) {
+        // tell databases that everything is now in a consistent state and can be saved.
+        await this.client.store.save();
       }
-    })();
+    }
+    if (!this.running) {
+      this.syncOpts.logger.debug("Sync no longer running: exiting.");
+      if (this.connectionReturnedResolvers) {
+        this.connectionReturnedResolvers.reject();
+        this.connectionReturnedResolvers = undefined;
+      }
+      this.updateSyncState(SyncState.Stopped);
+    }
   }
   doSyncRequest(syncOptions, syncToken) {
-    var _this$abortController3;
-    var qps = this.getSyncParams(syncOptions, syncToken);
+    const qps = this.getSyncParams(syncOptions, syncToken);
     return this.client.http.authedRequest(Method.Get, "/sync", qps, undefined, {
       localTimeoutMs: qps.timeout + BUFFER_PERIOD_MS,
-      abortSignal: (_this$abortController3 = this.abortController) === null || _this$abortController3 === void 0 ? void 0 : _this$abortController3.signal
+      abortSignal: this.abortController?.signal
     });
   }
   getSyncParams(syncOptions, syncToken) {
-    var timeout = this.opts.pollTimeout;
+    let timeout = this.opts.pollTimeout;
     if (this.getSyncState() !== SyncState.Syncing || this.catchingUp) {
       // unless we are happily syncing already, we want the server to return
       // as quickly as possible, even if there are no events queued. This
@@ -834,11 +804,11 @@ export class SyncApi {
       this.catchingUp = true;
       timeout = 0;
     }
-    var filter = syncOptions.filter;
+    let filter = syncOptions.filter;
     if (this.client.isGuest() && !filter) {
       filter = this.getGuestFilter();
     }
-    var qps = {
+    const qps = {
       filter,
       timeout,
       "org.matrix.msc4222.use_state_after": true
@@ -873,51 +843,48 @@ export class SyncApi {
   setPresence(presence) {
     this.presence = presence;
   }
-  onSyncError(err) {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this8.running) {
-        _this8.syncOpts.logger.debug("Sync no longer running: exiting");
-        if (_this8.connectionReturnedResolvers) {
-          _this8.connectionReturnedResolvers.reject();
-          _this8.connectionReturnedResolvers = undefined;
-        }
-        _this8.updateSyncState(SyncState.Stopped);
-        return true; // abort
-      }
-      _this8.syncOpts.logger.error("/sync error %s", err);
-      if (_this8.shouldAbortSync(err)) {
-        return true; // abort
+  async onSyncError(err) {
+    if (!this.running) {
+      this.syncOpts.logger.debug("Sync no longer running: exiting");
+      if (this.connectionReturnedResolvers) {
+        this.connectionReturnedResolvers.reject();
+        this.connectionReturnedResolvers = undefined;
       }
-      _this8.failedSyncCount++;
-      _this8.syncOpts.logger.debug("Number of consecutive failed sync requests:", _this8.failedSyncCount);
-      _this8.syncOpts.logger.debug("Starting keep-alive");
-      // Note that we do *not* mark the sync connection as
-      // lost yet: we only do this if a keepalive poke
-      // fails, since long lived HTTP connections will
-      // go away sometimes and we shouldn't treat this as
-      // erroneous. We set the state to 'reconnecting'
-      // instead, so that clients can observe this state
-      // if they wish.
-      var keepAlivePromise = _this8.startKeepAlives();
-      _this8.currentSyncRequest = undefined;
-      // Transition from RECONNECTING to ERROR after a given number of failed syncs
-      _this8.updateSyncState(_this8.failedSyncCount >= FAILED_SYNC_ERROR_THRESHOLD ? SyncState.Error : SyncState.Reconnecting, {
-        error: err
+      this.updateSyncState(SyncState.Stopped);
+      return true; // abort
+    }
+    this.syncOpts.logger.error("/sync error %s", err);
+    if (this.shouldAbortSync(err)) {
+      return true; // abort
+    }
+    this.failedSyncCount++;
+    this.syncOpts.logger.debug("Number of consecutive failed sync requests:", this.failedSyncCount);
+    this.syncOpts.logger.debug("Starting keep-alive");
+    // Note that we do *not* mark the sync connection as
+    // lost yet: we only do this if a keepalive poke
+    // fails, since long lived HTTP connections will
+    // go away sometimes and we shouldn't treat this as
+    // erroneous. We set the state to 'reconnecting'
+    // instead, so that clients can observe this state
+    // if they wish.
+    const keepAlivePromise = this.startKeepAlives();
+    this.currentSyncRequest = undefined;
+    // Transition from RECONNECTING to ERROR after a given number of failed syncs
+    this.updateSyncState(this.failedSyncCount >= FAILED_SYNC_ERROR_THRESHOLD ? SyncState.Error : SyncState.Reconnecting, {
+      error: err
+    });
+    const connDidFail = await keepAlivePromise;
+
+    // Only emit CATCHUP if we detected a connectivity error: if we didn't,
+    // it's quite likely the sync will fail again for the same reason and we
+    // want to stay in ERROR rather than keep flip-flopping between ERROR
+    // and CATCHUP.
+    if (connDidFail && this.getSyncState() === SyncState.Error) {
+      this.updateSyncState(SyncState.Catchup, {
+        catchingUp: true
       });
-      var connDidFail = yield keepAlivePromise;
-
-      // Only emit CATCHUP if we detected a connectivity error: if we didn't,
-      // it's quite likely the sync will fail again for the same reason and we
-      // want to stay in ERROR rather than keep flip-flopping between ERROR
-      // and CATCHUP.
-      if (connDidFail && _this8.getSyncState() === SyncState.Error) {
-        _this8.updateSyncState(SyncState.Catchup, {
-          catchingUp: true
-        });
-      }
-      return false;
-    })();
+    }
+    return false;
   }
 
   /**
@@ -927,483 +894,450 @@ export class SyncApi {
    * @param syncEventData - Object containing sync tokens associated with this sync
    * @param data - The response from /sync
    */
-  processSyncResponse(syncEventData, data) {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      var _data$presence, _data$account_data, _data$users, _this9$syncOpts$crypt, _data$device_unused_f;
-      var client = _this9.client;
-
-      // data looks like:
-      // {
-      //    next_batch: $token,
-      //    presence: { events: [] },
-      //    account_data: { events: [] },
-      //    device_lists: { changed: ["@user:server", ... ]},
-      //    to_device: { events: [] },
-      //    device_one_time_keys_count: { signed_curve25519: 42 },
-      //    rooms: {
-      //      invite: {
-      //        $roomid: {
-      //          invite_state: { events: [] }
-      //        }
-      //      },
-      //      join: {
-      //        $roomid: {
-      //          state: { events: [] },
-      //          timeline: { events: [], prev_batch: $token, limited: true },
-      //          ephemeral: { events: [] },
-      //          summary: {
-      //             m.heroes: [ $user_id ],
-      //             m.joined_member_count: $count,
-      //             m.invited_member_count: $count
-      //          },
-      //          account_data: { events: [] },
-      //          unread_notifications: {
-      //              highlight_count: 0,
-      //              notification_count: 0,
-      //          }
-      //          "org.matrix.msc4222.state_after": { events: [] },  // only if "org.matrix.msc4222.use_state_after" is true
-      //          msc4354_sticky: { events: [] }, // only if "org.matrix.msc4354.sticky" is true
-      //        }
-      //      },
-      //      leave: {
-      //        $roomid: {
-      //          state: { events: [] },
-      //          timeline: { events: [], prev_batch: $token }
-      //        }
-      //      }
-      //    }
-      // }
-
-      // TODO-arch:
-      // - Each event we pass through needs to be emitted via 'event', can we
-      //   do this in one place?
-      // - The isBrandNewRoom boilerplate is boilerplatey.
+  async processSyncResponse(syncEventData, data) {
+    const client = this.client;
+
+    // data looks like:
+    // {
+    //    next_batch: $token,
+    //    presence: { events: [] },
+    //    account_data: { events: [] },
+    //    device_lists: { changed: ["@user:server", ... ]},
+    //    to_device: { events: [] },
+    //    device_one_time_keys_count: { signed_curve25519: 42 },
+    //    rooms: {
+    //      invite: {
+    //        $roomid: {
+    //          invite_state: { events: [] }
+    //        }
+    //      },
+    //      join: {
+    //        $roomid: {
+    //          state: { events: [] },
+    //          timeline: { events: [], prev_batch: $token, limited: true },
+    //          ephemeral: { events: [] },
+    //          summary: {
+    //             m.heroes: [ $user_id ],
+    //             m.joined_member_count: $count,
+    //             m.invited_member_count: $count
+    //          },
+    //          account_data: { events: [] },
+    //          unread_notifications: {
+    //              highlight_count: 0,
+    //              notification_count: 0,
+    //          }
+    //          "org.matrix.msc4222.state_after": { events: [] },  // only if "org.matrix.msc4222.use_state_after" is true
+    //          msc4354_sticky: { events: [] }, // only if "org.matrix.msc4354.sticky" is true
+    //        }
+    //      },
+    //      leave: {
+    //        $roomid: {
+    //          state: { events: [] },
+    //          timeline: { events: [], prev_batch: $token }
+    //        }
+    //      }
+    //    }
+    // }
+
+    // TODO-arch:
+    // - Each event we pass through needs to be emitted via 'event', can we
+    //   do this in one place?
+    // - The isBrandNewRoom boilerplate is boilerplatey.
+
+    // handle presence events (User objects)
+    if (Array.isArray(data.presence?.events)) {
+      data.presence.events.filter(noUnsafeEventProps).map(client.getEventMapper()).forEach(function (presenceEvent) {
+        let user = client.store.getUser(presenceEvent.getSender());
+        if (user) {
+          user.setPresenceEvent(presenceEvent);
+        } else {
+          user = User.createUser(presenceEvent.getSender(), client);
+          user.setPresenceEvent(presenceEvent);
+          client.store.storeUser(user);
+        }
+        client.emit(ClientEvent.Event, presenceEvent);
+      });
+    }
 
-      // handle presence events (User objects)
-      if (Array.isArray((_data$presence = data.presence) === null || _data$presence === void 0 ? void 0 : _data$presence.events)) {
-        data.presence.events.filter(noUnsafeEventProps).map(client.getEventMapper()).forEach(function (presenceEvent) {
-          var user = client.store.getUser(presenceEvent.getSender());
-          if (user) {
-            user.setPresenceEvent(presenceEvent);
-          } else {
-            user = User.createUser(presenceEvent.getSender(), client);
-            user.setPresenceEvent(presenceEvent);
-            client.store.storeUser(user);
-          }
-          client.emit(ClientEvent.Event, presenceEvent);
-        });
+    // handle non-room account_data
+    if (Array.isArray(data.account_data?.events)) {
+      const events = data.account_data.events.filter(noUnsafeEventProps).map(client.getEventMapper());
+      const prevEventsMap = events.reduce((m, c) => {
+        m[c.getType()] = client.store.getAccountData(c.getType());
+        return m;
+      }, {});
+      client.store.storeAccountDataEvents(events);
+      events.forEach(function (accountDataEvent) {
+        // Honour push rules that come down the sync stream but also
+        // honour push rules that were previously cached. Base rules
+        // will be updated when we receive push rules via getPushRules
+        // (see sync) before syncing over the network.
+        if (accountDataEvent.getType() === EventType.PushRules) {
+          const rules = accountDataEvent.getContent();
+          client.setPushRules(rules);
+        }
+        const prevEvent = prevEventsMap[accountDataEvent.getType()];
+        client.emit(ClientEvent.AccountData, accountDataEvent, prevEvent);
+        return accountDataEvent;
+      });
+    }
+
+    // handle user profile updates (MSC4429)
+    const userUpdate = data["users"] ?? data["org.matrix.msc4429.users"];
+    if (typeof userUpdate === "object" && userUpdate !== null) {
+      const usersToRemove = [];
+      const profilesToAmend = new Map();
+      for (const [userId, userData] of Object.entries(userUpdate)) {
+        logger.info(`Storing user profile ${userId}`, userData);
+        if (userData.profile_updates) {
+          const existingProfile = await client.store.getUserProfile(userId);
+          profilesToAmend.set(userId, _objectSpread(_objectSpread({}, existingProfile), userData.profile_updates));
+        } else if (userData.profile_updates === null) {
+          usersToRemove.push(userId);
+        }
+      }
+      if (usersToRemove.length) {
+        await client.store.removeUserProfiles(usersToRemove);
+      }
+      if (profilesToAmend.size) {
+        await client.store.storeUserProfiles(profilesToAmend);
       }
 
-      // handle non-room account_data
-      if (Array.isArray((_data$account_data = data.account_data) === null || _data$account_data === void 0 ? void 0 : _data$account_data.events)) {
-        var events = data.account_data.events.filter(noUnsafeEventProps).map(client.getEventMapper());
-        var prevEventsMap = events.reduce((m, c) => {
-          m[c.getType()] = client.store.getAccountData(c.getType());
-          return m;
-        }, {});
-        client.store.storeAccountDataEvents(events);
-        events.forEach(function (accountDataEvent) {
-          // Honour push rules that come down the sync stream but also
-          // honour push rules that were previously cached. Base rules
-          // 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();
-            client.setPushRules(rules);
-          }
-          var prevEvent = prevEventsMap[accountDataEvent.getType()];
-          client.emit(ClientEvent.AccountData, accountDataEvent, prevEvent);
-          return accountDataEvent;
-        });
+      // emit after we've update the store so that clients can get the updated profile if they want to
+      for (const [userId, userData] of Object.entries(userUpdate)) {
+        client.emit(ClientEvent.UserProfileUpdate, userId, userData.profile_updates ?? null);
       }
+    }
 
-      // handle user profile updates (MSC4429)
-      var userUpdate = (_data$users = data["users"]) !== null && _data$users !== void 0 ? _data$users : data["org.matrix.msc4429.users"];
-      if (typeof userUpdate === "object" && userUpdate !== null) {
-        var usersToRemove = [];
-        var profilesToAmend = new Map();
-        for (var _ref0 of Object.entries(userUpdate)) {
-          var _ref9 = _slicedToArray(_ref0, 2);
-          var userId = _ref9[0];
-          var userData = _ref9[1];
-          logger.info("Storing user profile ".concat(userId), userData);
-          if (userData.profile_updates) {
-            client.emit(ClientEvent.UserProfileUpdate, userId, userData.profile_updates);
-            var existingProfile = yield client.store.getUserProfile(userId);
-            profilesToAmend.set(userId, _objectSpread(_objectSpread({}, existingProfile), userData.profile_updates));
-          } else if (userData.profile_updates === null) {
-            usersToRemove.push(userId);
-          }
-        }
-        if (usersToRemove.length) {
-          yield client.store.removeUserProfiles(usersToRemove);
-        }
-        if (profilesToAmend.size) {
-          yield client.store.storeUserProfiles(profilesToAmend);
-        }
+    // handle to-device events
+    if (data.to_device && Array.isArray(data.to_device.events) && data.to_device.events.length > 0) {
+      const toDeviceMessages = data.to_device.events.filter(noUnsafeEventProps);
+      let receivedToDeviceMessages;
+      if (this.syncOpts.cryptoCallbacks) {
+        receivedToDeviceMessages = await this.syncOpts.cryptoCallbacks.preprocessToDeviceMessages(toDeviceMessages);
+      } else {
+        // Crypto is not enabled, so we just return the events.
+        receivedToDeviceMessages = toDeviceMessages.map(rawEvent => ({
+          message: rawEvent,
+          encryptionInfo: null
+        }));
       }
+      processToDeviceMessages(receivedToDeviceMessages, client);
+    } else {
+      // no more to-device events: we can stop polling with a short timeout.
+      this.catchingUp = false;
+    }
 
-      // handle to-device events
-      if (data.to_device && Array.isArray(data.to_device.events) && data.to_device.events.length > 0) {
-        var toDeviceMessages = data.to_device.events.filter(noUnsafeEventProps);
-        var receivedToDeviceMessages;
-        if (_this9.syncOpts.cryptoCallbacks) {
-          receivedToDeviceMessages = yield _this9.syncOpts.cryptoCallbacks.preprocessToDeviceMessages(toDeviceMessages);
-        } else {
-          receivedToDeviceMessages = toDeviceMessages.map(rawEvent => (
-          // Crypto is not enabled, so we just return the events.
-          {
-            message: rawEvent,
-            encryptionInfo: null
-          }));
-        }
-        processToDeviceMessages(receivedToDeviceMessages, client);
+    // the returned json structure is a bit crap, so make it into a
+    // nicer form (array) after applying sanity to make sure we don't fail
+    // on missing keys (on the off chance)
+    let inviteRooms = [];
+    let joinRooms = [];
+    let leaveRooms = [];
+    let knockRooms = [];
+    if (data.rooms) {
+      if (data.rooms.invite) {
+        inviteRooms = this.mapSyncResponseToRoomArray(data.rooms.invite);
+      }
+      if (data.rooms.join) {
+        joinRooms = this.mapSyncResponseToRoomArray(data.rooms.join);
+      }
+      if (data.rooms.leave) {
+        leaveRooms = this.mapSyncResponseToRoomArray(data.rooms.leave);
+      }
+      if (data.rooms.knock) {
+        knockRooms = this.mapSyncResponseToRoomArray(data.rooms.knock);
+      }
+    }
+    this.notifEvents = [];
+
+    // Handle invites
+    await Promise.all(inviteRooms.map(async inviteObj => {
+      const room = inviteObj.room;
+      const stateEvents = this.mapSyncEventsFormat(inviteObj.invite_state, room);
+      await this.injectRoomEvents(room, stateEvents, undefined);
+      if (inviteObj.isBrandNewRoom) {
+        room.recalculate();
+        client.store.storeRoom(room);
+        client.emit(ClientEvent.Room, room);
       } else {
-        // no more to-device events: we can stop polling with a short timeout.
-        _this9.catchingUp = false;
+        // Update room state for invite->reject->invite cycles
+        room.recalculate();
       }
+      stateEvents.forEach(function (e) {
+        client.emit(ClientEvent.Event, e);
+      });
+    }));
 
-      // the returned json structure is a bit crap, so make it into a
-      // nicer form (array) after applying sanity to make sure we don't fail
-      // on missing keys (on the off chance)
-      var inviteRooms = [];
-      var joinRooms = [];
-      var leaveRooms = [];
-      var knockRooms = [];
-      if (data.rooms) {
-        if (data.rooms.invite) {
-          inviteRooms = _this9.mapSyncResponseToRoomArray(data.rooms.invite);
+    // Handle joins
+    await Promise.all(joinRooms.map(async joinObj => {
+      const room = joinObj.room;
+      const stateEvents = this.mapSyncEventsFormat(joinObj.state, room);
+      const stateAfterEvents = this.mapSyncEventsFormat(joinObj["org.matrix.msc4222.state_after"], room);
+      // 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
+      const timelineEvents = this.mapSyncEventsFormat(joinObj.timeline, room, false);
+      const ephemeralEvents = this.mapSyncEventsFormat(joinObj.ephemeral);
+      const accountDataEvents = this.mapSyncEventsFormat(joinObj.account_data);
+      const stickyEvents = this.mapSyncEventsFormat(joinObj.msc4354_sticky);
+
+      // If state_after is present, this is the events that form the state at the end of the timeline block and
+      // regular timeline events do *not* count towards state. If it's not present, then the state is formed by
+      // the state events plus the timeline events. Note mapSyncEventsFormat returns an empty array if the field
+      // is absent so we explicitly check the field on the original object.
+      const eventsFormingFinalState = joinObj["org.matrix.msc4222.state_after"] ? stateAfterEvents : stateEvents.concat(timelineEvents);
+      const encrypted = this.isRoomEncrypted(room, eventsFormingFinalState);
+      // We store the server-provided value first so it's correct when any of the events fire.
+      if (joinObj.unread_notifications) {
+        /**
+         * 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.
+         * XXX: this is known faulty as the push rule for `.m.room.encrypted` may be disabled so server
+         * may issue notification counts of 0 which we wrongly trust.
+         * https://github.com/matrix-org/matrix-spec-proposals/pull/2654 would fix this
+         *
+         * @see import("./client").fixNotificationCountOnDecryption
+         */
+        if (!encrypted || joinObj.unread_notifications.notification_count === 0) {
+          // In an encrypted room, if the room has notifications enabled then it's typical for
+          // the server to flag all new messages as notifying. However, some push rules calculate
+          // events as ignored based on their event contents (e.g. ignoring msgtype=m.notice messages)
+          // so we want to calculate this figure on the client in all cases.
+          room.setUnreadNotificationCount(NotificationCountType.Total, joinObj.unread_notifications.notification_count ?? 0);
         }
-        if (data.rooms.join) {
-          joinRooms = _this9.mapSyncResponseToRoomArray(data.rooms.join);
-        }
-        if (data.rooms.leave) {
-          leaveRooms = _this9.mapSyncResponseToRoomArray(data.rooms.leave);
-        }
-        if (data.rooms.knock) {
-          knockRooms = _this9.mapSyncResponseToRoomArray(data.rooms.knock);
+        if (!encrypted || room.getUnreadNotificationCount(NotificationCountType.Highlight) <= 0) {
+          // If the locally stored highlight count is zero, use the server provided value.
+          room.setUnreadNotificationCount(NotificationCountType.Highlight, joinObj.unread_notifications.highlight_count ?? 0);
         }
       }
-      _this9.notifEvents = [];
-
-      // Handle invites
-      yield Promise.all(inviteRooms.map(/*#__PURE__*/function () {
-        var _ref1 = _asyncToGenerator(function* (inviteObj) {
-          var room = inviteObj.room;
-          var stateEvents = _this9.mapSyncEventsFormat(inviteObj.invite_state, room);
-          yield _this9.injectRoomEvents(room, stateEvents, undefined);
-          if (inviteObj.isBrandNewRoom) {
-            room.recalculate();
-            client.store.storeRoom(room);
-            client.emit(ClientEvent.Room, room);
-          } else {
-            // Update room state for invite->reject->invite cycles
-            room.recalculate();
-          }
-          stateEvents.forEach(function (e) {
-            client.emit(ClientEvent.Event, e);
-          });
-        });
-        return function (_x3) {
-          return _ref1.apply(this, arguments);
-        };
-      }()));
-
-      // Handle joins
-      yield Promise.all(joinRooms.map(/*#__PURE__*/function () {
-        var _ref10 = _asyncToGenerator(function* (joinObj) {
-          var _joinObj$UNREAD_THREA;
-          var room = joinObj.room;
-          var stateEvents = _this9.mapSyncEventsFormat(joinObj.state, room);
-          var stateAfterEvents = _this9.mapSyncEventsFormat(joinObj["org.matrix.msc4222.state_after"], room);
-          // 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 = _this9.mapSyncEventsFormat(joinObj.timeline, room, false);
-          var ephemeralEvents = _this9.mapSyncEventsFormat(joinObj.ephemeral);
-          var accountDataEvents = _this9.mapSyncEventsFormat(joinObj.account_data);
-          var stickyEvents = _this9.mapSyncEventsFormat(joinObj.msc4354_sticky);
-
-          // If state_after is present, this is the events that form the state at the end of the timeline block and
-          // regular timeline events do *not* count towards state. If it's not present, then the state is formed by
-          // the state events plus the timeline events. Note mapSyncEventsFormat returns an empty array if the field
-          // is absent so we explicitly check the field on the original object.
-          var eventsFormingFinalState = joinObj["org.matrix.msc4222.state_after"] ? stateAfterEvents : stateEvents.concat(timelineEvents);
-          var encrypted = _this9.isRoomEncrypted(room, eventsFormingFinalState);
-          // We store the server-provided value first so it's correct when any of the events fire.
-          if (joinObj.unread_notifications) {
-            /**
-             * 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.
-             * XXX: this is known faulty as the push rule for `.m.room.encrypted` may be disabled so server
-             * may issue notification counts of 0 which we wrongly trust.
-             * https://github.com/matrix-org/matrix-spec-proposals/pull/2654 would fix this
-             *
-             * @see import("./client").fixNotificationCountOnDecryption
-             */
-            if (!encrypted || joinObj.unread_notifications.notification_count === 0) {
-              var _joinObj$unread_notif;
-              // In an encrypted room, if the room has notifications enabled then it's typical for
-              // the server to flag all new messages as notifying. However, some push rules calculate
-              // events as ignored based on their event contents (e.g. ignoring msgtype=m.notice messages)
-              // so we want to calculate this figure on the client in all cases.
-              room.setUnreadNotificationCount(NotificationCountType.Total, (_joinObj$unread_notif = joinObj.unread_notifications.notification_count) !== null && _joinObj$unread_notif !== void 0 ? _joinObj$unread_notif : 0);
-            }
-            if (!encrypted || room.getUnreadNotificationCount(NotificationCountType.Highlight) <= 0) {
-              var _joinObj$unread_notif2;
-              // If the locally stored highlight count is zero, use the server provided value.
-              room.setUnreadNotificationCount(NotificationCountType.Highlight, (_joinObj$unread_notif2 = joinObj.unread_notifications.highlight_count) !== null && _joinObj$unread_notif2 !== void 0 ? _joinObj$unread_notif2 : 0);
-            }
-          }
-          var unreadThreadNotifications = (_joinObj$UNREAD_THREA = joinObj[UNREAD_THREAD_NOTIFICATIONS.name]) !== null && _joinObj$UNREAD_THREA !== void 0 ? _joinObj$UNREAD_THREA : joinObj[UNREAD_THREAD_NOTIFICATIONS.altName];
-          if (unreadThreadNotifications) {
-            // This mirrors the logic above for rooms: take the *total* notification count from
-            // the server for unencrypted rooms or is it's zero. Any threads not present in this
-            // object implicitly have zero notifications, so start by clearing the total counts
-            // for all such threads.
-            room.resetThreadUnreadNotificationCountFromSync(Object.keys(unreadThreadNotifications));
-            for (var _ref13 of Object.entries(unreadThreadNotifications)) {
-              var _ref12 = _slicedToArray(_ref13, 2);
-              var threadId = _ref12[0];
-              var unreadNotification = _ref12[1];
-              if (!encrypted || unreadNotification.notification_count === 0) {
-                var _unreadNotification$n;
-                room.setThreadUnreadNotificationCount(threadId, NotificationCountType.Total, (_unreadNotification$n = unreadNotification.notification_count) !== null && _unreadNotification$n !== void 0 ? _unreadNotification$n : 0);
-              }
-              var hasNoNotifications = room.getThreadUnreadNotificationCount(threadId, NotificationCountType.Highlight) <= 0;
-              if (!encrypted || encrypted && hasNoNotifications) {
-                var _unreadNotification$h;
-                room.setThreadUnreadNotificationCount(threadId, NotificationCountType.Highlight, (_unreadNotification$h = unreadNotification.highlight_count) !== null && _unreadNotification$h !== void 0 ? _unreadNotification$h : 0);
-              }
-            }
-          } else {
-            room.resetThreadUnreadNotificationCountFromSync();
+      const unreadThreadNotifications = joinObj[UNREAD_THREAD_NOTIFICATIONS.name] ?? joinObj[UNREAD_THREAD_NOTIFICATIONS.altName];
+      if (unreadThreadNotifications) {
+        // This mirrors the logic above for rooms: take the *total* notification count from
+        // the server for unencrypted rooms or is it's zero. Any threads not present in this
+        // object implicitly have zero notifications, so start by clearing the total counts
+        // for all such threads.
+        room.resetThreadUnreadNotificationCountFromSync(Object.keys(unreadThreadNotifications));
+        for (const [threadId, unreadNotification] of Object.entries(unreadThreadNotifications)) {
+          if (!encrypted || unreadNotification.notification_count === 0) {
+            room.setThreadUnreadNotificationCount(threadId, NotificationCountType.Total, unreadNotification.notification_count ?? 0);
           }
-          joinObj.timeline = joinObj.timeline || {};
-          if (joinObj.isBrandNewRoom) {
-            // set the back-pagination token. Do this *before* adding any
-            // events so that clients can start back-paginating.
-            if (joinObj.timeline.prev_batch !== null) {
-              room.getLiveTimeline().setPaginationToken(joinObj.timeline.prev_batch, EventTimeline.BACKWARDS);
-            }
-          } else if (joinObj.timeline.limited) {
-            var 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 (var i = timelineEvents.length - 1; i >= 0; i--) {
-              var eventId = timelineEvents[i].getId();
-              if (room.getTimelineForEvent(eventId)) {
-                _this9.syncOpts.logger.debug("Already have event ".concat(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) {
-              var _syncEventData$oldSyn;
-              room.resetLiveTimeline(joinObj.timeline.prev_batch, _this9.syncOpts.canResetEntireTimeline(room.roomId) ? null : (_syncEventData$oldSyn = syncEventData.oldSyncToken) !== null && _syncEventData$oldSyn !== void 0 ? _syncEventData$oldSyn : null);
-
-              // We have to assume any gap in any timeline is
-              // reason to stop incrementally tracking notifications and
-              // reset the timeline.
-              client.resetNotifTimelineSet();
-            }
+          const hasNoNotifications = room.getThreadUnreadNotificationCount(threadId, NotificationCountType.Highlight) <= 0;
+          if (!encrypted || encrypted && hasNoNotifications) {
+            room.setThreadUnreadNotificationCount(threadId, NotificationCountType.Highlight, unreadNotification.highlight_count ?? 0);
           }
-
-          // process any crypto events *before* emitting the RoomStateEvent events. This
-          // avoids a race condition if the application tries to send a message after the
-          // state event is processed, but before crypto is enabled, which then causes the
-          // crypto layer to complain.
-
-          if (_this9.syncOpts.cryptoCallbacks) {
-            for (var e of eventsFormingFinalState) {
-              if (e.isState() && e.getType() === EventType.RoomEncryption && e.getStateKey() === "") {
-                yield _this9.syncOpts.cryptoCallbacks.onCryptoEvent(room, e);
-              }
-            }
+        }
+      } else {
+        room.resetThreadUnreadNotificationCountFromSync();
+      }
+      joinObj.timeline = joinObj.timeline || {};
+      if (joinObj.isBrandNewRoom) {
+        // set the back-pagination token. Do this *before* adding any
+        // events so that clients can start back-paginating.
+        if (joinObj.timeline.prev_batch !== null) {
+          room.getLiveTimeline().setPaginationToken(joinObj.timeline.prev_batch, EventTimeline.BACKWARDS);
+        }
+      } else if (joinObj.timeline.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(joinObj.timeline.prev_batch, this.syncOpts.canResetEntireTimeline(room.roomId) ? null : syncEventData.oldSyncToken ?? null);
 
-          // Proactively decrypt state events: normally we decrypt on demand, but for state
-          // events we need them immediately, so we handle them here. Specifically, consumers
-          // (e.g. Element Web) expect state events to be unencrypted upon receipt.
-          for (var ev of timelineEvents.filter(ev => ev.isState())) {
-            yield _this9.client.decryptEventIfNeeded(ev);
-          }
-          try {
-            if ("org.matrix.msc4222.state_after" in joinObj) {
-              yield _this9.injectRoomEvents(room, undefined, stateAfterEvents, timelineEvents, syncEventData.fromCache);
-            } else {
-              yield _this9.injectRoomEvents(room, stateEvents, undefined, timelineEvents, syncEventData.fromCache);
-            }
-          } catch (e) {
-            _this9.syncOpts.logger.error("Failed to process events on room ".concat(room.roomId, ":"), e);
-          }
+          // We have to assume any gap in any timeline is
+          // reason to stop incrementally tracking notifications and
+          // reset the timeline.
+          client.resetNotifTimelineSet();
+        }
+      }
 
-          // set summary after processing events,
-          // because it will trigger a name calculation
-          // which needs the room state to be up to date
-          if (joinObj.summary) {
-            room.setSummary(joinObj.summary);
-          }
+      // process any crypto events *before* emitting the RoomStateEvent events. This
+      // avoids a race condition if the application tries to send a message after the
+      // state event is processed, but before crypto is enabled, which then causes the
+      // crypto layer to complain.
 
-          // we deliberately don't add ephemeral events to the timeline
-          room.addEphemeralEvents(ephemeralEvents);
-
-          // we deliberately don't add accountData to the timeline
-          room.addAccountData(accountDataEvents);
-
-          // Sticky events primarily come via the `timeline` field, with the
-          // sticky info field marking them as sticky.
-          // If the sync is "gappy" (meaning it is skipping events to catch up) then
-          // sticky events will instead come down the sticky section.
-          // This ensures we collect sticky events from both places.
-          var stickyEventsAndStickyEventsFromTheTimeline = stickyEvents.concat(timelineEvents.filter(e => e.unstableStickyInfo !== undefined));
-          // Note: We calculate sticky events before emitting `.Room` as it's nice to have
-          // sticky events calculated and ready to go.
-          room._unstable_addStickyEvents(stickyEventsAndStickyEventsFromTheTimeline);
-          room.recalculate();
-          if (joinObj.isBrandNewRoom) {
-            client.store.storeRoom(room);
-            client.emit(ClientEvent.Room, room);
-          }
-          _this9.processEventsForNotifs(room, timelineEvents);
-          var emitEvent = e => client.emit(ClientEvent.Event, e);
-          // this fires a couple of times for some events. (eg state events are in the timeline and the state)
-          // should this get a sync section as an additional event emission param (e, syncSection))?
-          stateEvents.forEach(emitEvent);
-          timelineEvents.forEach(emitEvent);
-          ephemeralEvents.forEach(emitEvent);
-          accountDataEvents.forEach(emitEvent);
-          stickyEvents.filter(stickyEvent =>
-          // This is highly unlikey, but in the case where a sticky event
-          // has appeared in the timeline AND the sticky section, we only
-          // want to emit the event once.
-          !timelineEvents.some(timelineEvent => timelineEvent.getId() === stickyEvent.getId())).forEach(emitEvent);
-          // 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();
-        });
-        return function (_x4) {
-          return _ref10.apply(this, arguments);
-        };
-      }()));
-
-      // Handle leaves (e.g. kicked rooms)
-      yield Promise.all(leaveRooms.map(/*#__PURE__*/function () {
-        var _ref14 = _asyncToGenerator(function* (leaveObj) {
-          var room = leaveObj.room;
-          var _yield$_this9$mapAndI = yield _this9.mapAndInjectRoomEvents(leaveObj),
-            timelineEvents = _yield$_this9$mapAndI.timelineEvents,
-            stateEvents = _yield$_this9$mapAndI.stateEvents,
-            stateAfterEvents = _yield$_this9$mapAndI.stateAfterEvents;
-          var accountDataEvents = _this9.mapSyncEventsFormat(leaveObj.account_data);
-          room.addAccountData(accountDataEvents);
-          room.recalculate();
-          if (leaveObj.isBrandNewRoom) {
-            client.store.storeRoom(room);
-            client.emit(ClientEvent.Room, room);
-          }
-          _this9.processEventsForNotifs(room, timelineEvents);
-          stateEvents === null || stateEvents === void 0 || stateEvents.forEach(function (e) {
-            client.emit(ClientEvent.Event, e);
-          });
-          stateAfterEvents === null || stateAfterEvents === void 0 || stateAfterEvents.forEach(function (e) {
-            client.emit(ClientEvent.Event, e);
-          });
-          timelineEvents.forEach(function (e) {
-            client.emit(ClientEvent.Event, e);
-          });
-          accountDataEvents.forEach(function (e) {
-            client.emit(ClientEvent.Event, e);
-          });
-        });
-        return function (_x5) {
-          return _ref14.apply(this, arguments);
-        };
-      }()));
-
-      // Handle knocks
-      yield Promise.all(knockRooms.map(/*#__PURE__*/function () {
-        var _ref15 = _asyncToGenerator(function* (knockObj) {
-          var room = knockObj.room;
-          var stateEvents = _this9.mapSyncEventsFormat(knockObj.knock_state, room);
-          yield _this9.injectRoomEvents(room, stateEvents, undefined);
-          if (knockObj.isBrandNewRoom) {
-            room.recalculate();
-            client.store.storeRoom(room);
-            client.emit(ClientEvent.Room, room);
-          } else {
-            // Update room state for knock->leave->knock cycles
-            room.recalculate();
+      if (this.syncOpts.cryptoCallbacks) {
+        for (const e of eventsFormingFinalState) {
+          if (e.isState() && e.getType() === EventType.RoomEncryption && e.getStateKey() === "") {
+            await this.syncOpts.cryptoCallbacks.onCryptoEvent(room, e);
           }
-          stateEvents.forEach(function (e) {
-            client.emit(ClientEvent.Event, e);
-          });
-        });
-        return function (_x6) {
-          return _ref15.apply(this, arguments);
-        };
-      }()));
-
-      // update the notification timeline, if appropriate.
-      // we only do this for live events, as otherwise we can't order them sanely
-      // in the timeline relative to ones paginated in by /notifications.
-      // XXX: we could fix this by making EventTimeline support chronological
-      // ordering... but it doesn't, right now.
-      if (syncEventData.oldSyncToken && _this9.notifEvents.length) {
-        _this9.notifEvents.sort(function (a, b) {
-          return a.getTs() - b.getTs();
-        });
-        _this9.notifEvents.forEach(function (event) {
-          var _client$getNotifTimel;
-          (_client$getNotifTimel = client.getNotifTimelineSet()) === null || _client$getNotifTimel === void 0 || _client$getNotifTimel.addLiveEvent(event, {
-            addToState: true
-          });
-        });
+        }
       }
 
-      // Handle device list updates
-      if (data.device_lists) {
-        if (_this9.syncOpts.cryptoCallbacks) {
-          yield _this9.syncOpts.cryptoCallbacks.processDeviceLists(data.device_lists);
+      // Proactively decrypt state events: normally we decrypt on demand, but for state
+      // events we need them immediately, so we handle them here. Specifically, consumers
+      // (e.g. Element Web) expect state events to be unencrypted upon receipt.
+      for (const ev of timelineEvents.filter(ev => ev.isState())) {
+        await this.client.decryptEventIfNeeded(ev);
+      }
+      try {
+        if ("org.matrix.msc4222.state_after" in joinObj) {
+          await this.injectRoomEvents(room, undefined, stateAfterEvents, timelineEvents, syncEventData.fromCache);
         } else {
-          // FIXME if we *don't* have a crypto module, we still need to
-          // invalidate the device lists. But that would require a
-          // substantial bit of rework :/.
+          await this.injectRoomEvents(room, stateEvents, undefined, timelineEvents, syncEventData.fromCache);
         }
+      } catch (e) {
+        this.syncOpts.logger.error(`Failed to process events on room ${room.roomId}:`, e);
+      }
+
+      // set summary after processing events,
+      // because it will trigger a name calculation
+      // which needs the room state to be up to date
+      if (joinObj.summary) {
+        room.setSummary(joinObj.summary);
+      }
+
+      // we deliberately don't add ephemeral events to the timeline
+      room.addEphemeralEvents(ephemeralEvents);
+
+      // we deliberately don't add accountData to the timeline
+      room.addAccountData(accountDataEvents);
+
+      // Sticky events primarily come via the `timeline` field, with the
+      // sticky info field marking them as sticky.
+      // If the sync is "gappy" (meaning it is skipping events to catch up) then
+      // sticky events will instead come down the sticky section.
+      // This ensures we collect sticky events from both places.
+      const stickyEventsAndStickyEventsFromTheTimeline = stickyEvents.concat(timelineEvents.filter(e => e.unstableStickyInfo !== undefined));
+      // Note: We calculate sticky events before emitting `.Room` as it's nice to have
+      // sticky events calculated and ready to go.
+      room._unstable_addStickyEvents(stickyEventsAndStickyEventsFromTheTimeline);
+      room.recalculate();
+      if (joinObj.isBrandNewRoom) {
+        client.store.storeRoom(room);
+        client.emit(ClientEvent.Room, room);
+      }
+      this.processEventsForNotifs(room, timelineEvents);
+      const emitEvent = e => client.emit(ClientEvent.Event, e);
+      // this fires a couple of times for some events. (eg state events are in the timeline and the state)
+      // should this get a sync section as an additional event emission param (e, syncSection))?
+      stateEvents.forEach(emitEvent);
+      timelineEvents.forEach(emitEvent);
+      ephemeralEvents.forEach(emitEvent);
+      accountDataEvents.forEach(emitEvent);
+      stickyEvents.filter(stickyEvent =>
+      // This is highly unlikey, but in the case where a sticky event
+      // has appeared in the timeline AND the sticky section, we only
+      // want to emit the event once.
+      !timelineEvents.some(timelineEvent => timelineEvent.getId() === stickyEvent.getId())).forEach(emitEvent);
+      // 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();
+    }));
+
+    // Handle leaves (e.g. kicked rooms)
+    await Promise.all(leaveRooms.map(async leaveObj => {
+      const room = leaveObj.room;
+      const {
+        timelineEvents,
+        stateEvents,
+        stateAfterEvents
+      } = await this.mapAndInjectRoomEvents(leaveObj);
+      const accountDataEvents = this.mapSyncEventsFormat(leaveObj.account_data);
+      room.addAccountData(accountDataEvents);
+      room.recalculate();
+      if (leaveObj.isBrandNewRoom) {
+        client.store.storeRoom(room);
+        client.emit(ClientEvent.Room, room);
       }
+      this.processEventsForNotifs(room, timelineEvents);
+      stateEvents?.forEach(function (e) {
+        client.emit(ClientEvent.Event, e);
+      });
+      stateAfterEvents?.forEach(function (e) {
+        client.emit(ClientEvent.Event, e);
+      });
+      timelineEvents.forEach(function (e) {
+        client.emit(ClientEvent.Event, e);
+      });
+      accountDataEvents.forEach(function (e) {
+        client.emit(ClientEvent.Event, e);
+      });
+    }));
+
+    // Handle knocks
+    await Promise.all(knockRooms.map(async knockObj => {
+      const room = knockObj.room;
+      const stateEvents = this.mapSyncEventsFormat(knockObj.knock_state, room);
+      await this.injectRoomEvents(room, stateEvents, undefined);
+      if (knockObj.isBrandNewRoom) {
+        room.recalculate();
+        client.store.storeRoom(room);
+        client.emit(ClientEvent.Room, room);
+      } else {
+        // Update room state for knock->leave->knock cycles
+        room.recalculate();
+      }
+      stateEvents.forEach(function (e) {
+        client.emit(ClientEvent.Event, e);
+      });
+    }));
 
-      // Handle one_time_keys_count and unused fallback keys
-      yield (_this9$syncOpts$crypt = _this9.syncOpts.cryptoCallbacks) === null || _this9$syncOpts$crypt === void 0 ? void 0 : _this9$syncOpts$crypt.processKeyCounts(data.device_one_time_keys_count, (_data$device_unused_f = data.device_unused_fallback_key_types) !== null && _data$device_unused_f !== void 0 ? _data$device_unused_f : data["org.matrix.msc2732.device_unused_fallback_key_types"]);
-    })();
+    // update the notification timeline, if appropriate.
+    // we only do this for live events, as otherwise we can't order them sanely
+    // in the timeline relative to ones paginated in by /notifications.
+    // XXX: we could fix this by making EventTimeline support chronological
+    // ordering... but it doesn't, right now.
+    if (syncEventData.oldSyncToken && this.notifEvents.length) {
+      this.notifEvents.sort(function (a, b) {
+        return a.getTs() - b.getTs();
+      });
+      this.notifEvents.forEach(function (event) {
+        client.getNotifTimelineSet()?.addLiveEvent(event, {
+          addToState: true
+        });
+      });
+    }
+
+    // Handle device list updates
+    if (data.device_lists) {
+      if (this.syncOpts.cryptoCallbacks) {
+        await this.syncOpts.cryptoCallbacks.processDeviceLists(data.device_lists);
+      } else {
+        // FIXME if we *don't* have a crypto module, we still need to
+        // invalidate the device lists. But that would require a
+        // substantial bit of rework :/.
+      }
+    }
+
+    // Handle one_time_keys_count and unused fallback keys
+    await this.syncOpts.cryptoCallbacks?.processKeyCounts(data.device_one_time_keys_count, data.device_unused_fallback_key_types ?? data["org.matrix.msc2732.device_unused_fallback_key_types"]);
   }
 
   /**
@@ -1440,9 +1374,7 @@ export class SyncApi {
    *
    * @param connDidFail - True if a connectivity failure has been detected. Optional.
    */
-  pokeKeepAlive() {
-    var _this$abortController4;
-    var connDidFail = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  pokeKeepAlive(connDidFail = false) {
     if (!this.running) {
       // we are in a keepAlive, retrying to connect, but the syncronization
       // was stopped, so we are stopping the retry.
@@ -1453,7 +1385,7 @@ export class SyncApi {
       }
       return;
     }
-    var success = () => {
+    const success = () => {
       clearTimeout(this.keepAliveTimer);
       if (this.connectionReturnedResolvers) {
         this.connectionReturnedResolvers.resolve(connDidFail);
@@ -1467,7 +1399,7 @@ export class SyncApi {
     {
       prefix: "",
       localTimeoutMs: 15 * 1000,
-      abortSignal: (_this$abortController4 = this.abortController) === null || _this$abortController4 === void 0 ? void 0 : _this$abortController4.signal
+      abortSignal: this.abortController?.signal
     }).then(() => {
       success();
     }, err => {
@@ -1497,10 +1429,10 @@ export class SyncApi {
     // Maps { roomid: {stuff}, roomid: {stuff} }
     // to
     // [{stuff+Room+isBrandNewRoom}, {stuff+Room+isBrandNewRoom}]
-    var client = this.client;
+    const client = this.client;
     return Object.keys(obj).filter(k => !unsafeProp(k)).map(roomId => {
-      var room = client.store.getRoom(roomId);
-      var isBrandNewRoom = false;
+      let room = client.store.getRoom(roomId);
+      let isBrandNewRoom = false;
       if (!room) {
         room = this.createRoom(roomId);
         isBrandNewRoom = true;
@@ -1511,12 +1443,11 @@ export class SyncApi {
       });
     });
   }
-  mapSyncEventsFormat(obj, room) {
-    var decrypt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  mapSyncEventsFormat(obj, room, decrypt = true) {
     if (!obj || !Array.isArray(obj.events)) {
       return [];
     }
-    var mapper = this.client.getEventMapper({
+    const mapper = this.client.getEventMapper({
       decrypt
     });
     return obj.events.filter(noUnsafeEventProps).map(function (e) {
@@ -1533,15 +1464,15 @@ export class SyncApi {
     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,
@@ -1554,8 +1485,8 @@ export class SyncApi {
         // 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;
-        if ((inviteEvent === null || inviteEvent === void 0 ? void 0 : inviteEvent.getContent().membership) !== KnownMembership.Invite) {
+        const inviteEvent = member.events.member;
+        if (inviteEvent?.getContent().membership !== KnownMembership.Invite) {
           // between resolving and now they have since joined, so don't clobber
           return;
         }
@@ -1569,7 +1500,7 @@ export class SyncApi {
     });
   }
   findEncryptionEvent(events) {
-    return events === null || events === void 0 ? void 0 : events.find(e => e.getType() === EventType.RoomEncryption && e.getStateKey() === "");
+    return events?.find(e => e.getType() === EventType.RoomEncryption && e.getStateKey() === "");
   }
 
   // When processing the sync response we cannot rely on Room.hasEncryptionStateEvent we actually
@@ -1577,23 +1508,20 @@ export class SyncApi {
   isRoomEncrypted(room, eventsFormingFinalState) {
     return room.hasEncryptionStateEvent() || !!this.findEncryptionEvent(eventsFormingFinalState);
   }
-  mapAndInjectRoomEvents(wrappedRoom) {
-    var _this0 = this;
-    return _asyncToGenerator(function* () {
-      var stateEvents = _this0.mapSyncEventsFormat(wrappedRoom.state, wrappedRoom.room);
-      var stateAfterEvents = _this0.mapSyncEventsFormat(wrappedRoom["org.matrix.msc4222.state_after"], wrappedRoom.room);
-      var timelineEvents = _this0.mapSyncEventsFormat(wrappedRoom.timeline, wrappedRoom.room);
-      if ("org.matrix.msc4222.state_after" in wrappedRoom) {
-        yield _this0.injectRoomEvents(wrappedRoom.room, undefined, stateAfterEvents, timelineEvents);
-      } else {
-        yield _this0.injectRoomEvents(wrappedRoom.room, stateEvents, undefined, timelineEvents);
-      }
-      return {
-        timelineEvents,
-        stateEvents,
-        stateAfterEvents
-      };
-    })();
+  async mapAndInjectRoomEvents(wrappedRoom) {
+    const stateEvents = this.mapSyncEventsFormat(wrappedRoom.state, wrappedRoom.room);
+    const stateAfterEvents = this.mapSyncEventsFormat(wrappedRoom["org.matrix.msc4222.state_after"], wrappedRoom.room);
+    const timelineEvents = this.mapSyncEventsFormat(wrappedRoom.timeline, wrappedRoom.room);
+    if ("org.matrix.msc4222.state_after" in wrappedRoom) {
+      await this.injectRoomEvents(wrappedRoom.room, undefined, stateAfterEvents, timelineEvents);
+    } else {
+      await this.injectRoomEvents(wrappedRoom.room, stateEvents, undefined, timelineEvents);
+    }
+    return {
+      timelineEvents,
+      stateEvents,
+      stateAfterEvents
+    };
   }
 
   /**
@@ -1612,76 +1540,71 @@ export class SyncApi {
    * are not added to the state.
    */
 
-  injectRoomEvents(room, stateEventList, stateAfterEventList, timelineEventList) {
-    var _arguments = arguments,
-      _this1 = this;
-    return _asyncToGenerator(function* () {
-      var fromCache = _arguments.length > 4 && _arguments[4] !== undefined ? _arguments[4] : false;
-      var eitherStateEventList = stateAfterEventList !== null && stateAfterEventList !== void 0 ? stateAfterEventList : stateEventList;
-
-      // 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 eitherStateEventList) {
-          _this1.client.getPushActionsForEvent(ev);
-        }
-        liveTimeline.initialiseState(eitherStateEventList, {
-          timelineWasEmpty
-        });
-      }
-      _this1.resolveInvites(room);
-
-      // recalculate the room name at this point as adding events to the timeline
-      // may make notifications appear which should have the right name.
-      // XXX: This looks suspect: we'll end up recalculating the room once here
-      // and then again after adding events (processSyncResponse calls it after
-      // calling us) even if no state events were added. It also means that if
-      // one of the room events in timelineEventList is something that needs
-      // a recalculation (like m.room.name) we won't recalculate until we've
-      // finished adding all the events, which will cause the notification to have
-      // the old room name rather than the new one.
-      room.recalculate();
+  async injectRoomEvents(room, stateEventList, stateAfterEventList, timelineEventList, fromCache = false) {
+    const eitherStateEventList = stateAfterEventList ?? 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(eitherStateEventList);
-        room.currentState.setStateEvents(eitherStateEventList);
+    // 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 eitherStateEventList) {
+        this.client.getPushActionsForEvent(ev);
       }
-
-      // Execute the timeline events. If addToState is true the timeline has any state
-      // events in it, this will continue to diverge the current state.
-      // 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,
-        timelineWasEmpty,
-        addToState: stateAfterEventList === undefined
+      liveTimeline.initialiseState(eitherStateEventList, {
+        timelineWasEmpty
       });
-      _this1.client.processBeaconEvents(room, timelineEventList);
-    })();
+    }
+    this.resolveInvites(room);
+
+    // recalculate the room name at this point as adding events to the timeline
+    // may make notifications appear which should have the right name.
+    // XXX: This looks suspect: we'll end up recalculating the room once here
+    // and then again after adding events (processSyncResponse calls it after
+    // calling us) even if no state events were added. It also means that if
+    // one of the room events in timelineEventList is something that needs
+    // a recalculation (like m.room.name) we won't recalculate until we've
+    // finished adding all the events, which will cause the notification to have
+    // the old room name rather than the new one.
+    room.recalculate();
+
+    // 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(eitherStateEventList);
+      room.currentState.setStateEvents(eitherStateEventList);
+    }
+
+    // Execute the timeline events. If addToState is true the timeline has any state
+    // events in it, this will continue to diverge the current state.
+    // 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,
+      timelineWasEmpty,
+      addToState: stateAfterEventList === undefined
+    });
+    this.client.processBeaconEvents(room, timelineEventList);
   }
 
   /**
@@ -1695,10 +1618,9 @@ export class SyncApi {
   processEventsForNotifs(room, timelineEventList) {
     // gather our notifications into this.notifEvents
     if (this.client.getNotifTimelineSet()) {
-      for (var event of timelineEventList) {
-        var _pushActions$tweaks;
-        var pushActions = this.client.getPushActionsForEvent(event);
-        if (pushActions !== null && pushActions !== void 0 && pushActions.notify && (_pushActions$tweaks = pushActions.tweaks) !== null && _pushActions$tweaks !== void 0 && _pushActions$tweaks.highlight) {
+      for (const event of timelineEventList) {
+        const pushActions = this.client.getPushActionsForEvent(event);
+        if (pushActions?.notify && pushActions.tweaks?.highlight) {
           this.notifEvents.push(event);
         }
       }
@@ -1716,7 +1638,7 @@ export class SyncApi {
    * @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);
@@ -1726,8 +1648,10 @@ export class SyncApi {
 // /!\ This function is not intended for public use! It's only exported from
 // here in order to share some common logic with sliding-sync-sdk.ts.
 export function _createAndReEmitRoom(client, roomId, opts) {
-  var timelineSupport = client.timelineSupport;
-  var room = new Room(roomId, client, client.getUserId(), {
+  const {
+    timelineSupport
+  } = client;
+  const room = new Room(roomId, client, client.getUserId(), {
     lazyLoadMembers: opts.lazyLoadMembers,
     pendingEventOrdering: opts.pendingEventOrdering,
     timelineSupport
@@ -1737,8 +1661,7 @@ export function _createAndReEmitRoom(client, roomId, opts) {
   // We need to add a listener for RoomState.members in order to hook them
   // correctly.
   room.on(RoomStateEvent.NewMember, (event, state, member) => {
-    var _client$getUser;
-    member.user = (_client$getUser = client.getUser(member.userId)) !== null && _client$getUser !== void 0 ? _client$getUser : undefined;
+    member.user = client.getUser(member.userId) ?? undefined;
     client.reEmitter.reEmit(member, [RoomMemberEvent.Name, RoomMemberEvent.Typing, RoomMemberEvent.PowerLevel, RoomMemberEvent.Membership]);
   });
   return room;
@@ -1751,7 +1674,7 @@ export function _createAndReEmitRoom(client, roomId, opts) {
  * Also converts the events into `MatrixEvent`s, and emits the now deprecated {@link ClientEvent.ToDeviceEvent} events for compatibility.
  * */
 export function processToDeviceMessages(toDeviceMessages, client) {
-  var cancelledKeyVerificationTxns = [];
+  const cancelledKeyVerificationTxns = [];
   toDeviceMessages.map(processedMessage => {
     // map is a cheap inline forEach
     // We want to flag m.key.verification.start events as cancelled
@@ -1760,7 +1683,7 @@ export function processToDeviceMessages(toDeviceMessages, client) {
     // so we can flag the verification events as cancelled in the loop
     // below.
     if (processedMessage.message.type === "m.key.verification.cancel") {
-      var txnId = processedMessage.message.content["transaction_id"];
+      const txnId = processedMessage.message.content["transaction_id"];
       if (txnId) {
         cancelledKeyVerificationTxns.push(txnId);
       }
@@ -1772,14 +1695,14 @@ export function processToDeviceMessages(toDeviceMessages, client) {
   }).forEach(function (processedEvent) {
     // For backwards compatibility, we also emit the event as a `MatrixEvent` using `ClientEvent.ToDeviceEvent`.
     {
-      var toDeviceEvent = processedEvent.message;
-      var content = toDeviceEvent.content;
+      const toDeviceEvent = processedEvent.message;
+      const content = toDeviceEvent.content;
       // The message is cloned before being passed to the MatrixEvent constructor, because
       // the `makeEncrypted` method will mutate the type and content properties of the original message and will interfere
       // with the emitted event for `ReceivedToDeviceMessage`.
-      var deprecatedCompatibilityEvent = new MatrixEvent(Object.assign({}, toDeviceEvent));
+      const deprecatedCompatibilityEvent = new MatrixEvent(Object.assign({}, toDeviceEvent));
       if (toDeviceEvent.type === "m.key.verification.start" || toDeviceEvent.type === "m.key.verification.request") {
-        var txnId = content["transaction_id"];
+        const txnId = content["transaction_id"];
         if (cancelledKeyVerificationTxns.includes(txnId)) {
           deprecatedCompatibilityEvent.flagCancelled();
         }