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

package/node_modules/matrix-js-sdk/lib/models/thread.js

@@ -1,7 +1,5 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /*
 Copyright 2021 - 2023 The Matrix.org Foundation C.I.C.
 
@@ -30,7 +28,7 @@ import { logger } from "../logger.js";
 import { ReadReceipt } from "./read-receipt.js";
 import { ReceiptType } from "../@types/read_receipts.js";
 import { Feature, ServerSupport } from "../feature.js";
-export var ThreadEvent = /*#__PURE__*/function (ThreadEvent) {
+export let ThreadEvent = /*#__PURE__*/function (ThreadEvent) {
   ThreadEvent["New"] = "Thread.new";
   ThreadEvent["Update"] = "Thread.update";
   ThreadEvent["NewReply"] = "Thread.newReply";
@@ -38,7 +36,7 @@ export var ThreadEvent = /*#__PURE__*/function (ThreadEvent) {
   ThreadEvent["Delete"] = "Thread.delete";
   return ThreadEvent;
 }({});
-export var FeatureSupport = /*#__PURE__*/function (FeatureSupport) {
+export let FeatureSupport = /*#__PURE__*/function (FeatureSupport) {
   FeatureSupport[FeatureSupport["None"] = 0] = "None";
   FeatureSupport[FeatureSupport["Experimental"] = 1] = "Experimental";
   FeatureSupport[FeatureSupport["Stable"] = 2] = "Stable";
@@ -55,31 +53,74 @@ export function determineFeatureSupport(stable, unstable) {
 }
 export class Thread extends ReadReceipt {
   constructor(id, rootEvent, opts) {
-    var _this, _opts$pendingEventOrd;
-    // each Event in the thread adds a reemitter, so we could hit the listener limit.
     super();
-    _this = this;
+
+    // each Event in the thread adds a reemitter, so we could hit the listener limit.
+    /**
+     * A reference to all the events ID at the bottom of the threads
+     */
+    _defineProperty(this, "timelineSet", void 0);
     _defineProperty(this, "_currentUserParticipated", false);
+    _defineProperty(this, "reEmitter", void 0);
+    /**
+     * The last event in this thread, if we don't yet have this in the timeline.
+     *
+     * When we run {@link processRootEvent} (which I think happens during the
+     * setting-up of the thread), we set this to the event pointed to by the
+     * server in `latest_event` [1] that came through with the thread root.
+     *
+     * [1]: https://spec.matrix.org/v1.8/client-server-api/#server-side-aggregation-of-mthread-relationships
+     *
+     * Later, when we have populated the timeline, this is set to undefined, so
+     * that methods like {@link replyToEvent} fall through to use lastReply,
+     * which looks in the timeline for the latest event that is a "thread reply"
+     * i.e. directly refers to the thread root with an m.thread relation.
+     *
+     * So it looks like this is only really relevant when initialEventsFetched
+     * is false, because as soon as the initial events have been fetched, we
+     * should have a proper chunk of timeline from the pagination fetch.
+     *
+     * If all replies in this thread are redacted, this is set to the root
+     * event. I'm not clear what the meaning of this is, since usually after the
+     * initial events have been fetched, lastEvent should be undefined.
+     * In fact, the whole usage inside onRedaction looks suspect - it may be
+     * that we were thinking lastEvent always refers to the actual last event,
+     * but it only does so before initialEventsFetched becomes true.
+     *
+     * The usage of lastEvent inside {@link onEcho} looks suspicious, since I'd
+     * think we probably mean {@link replyToEvent} there - we are trying not to
+     * echo a duplicate event, and we probably want that behaviour even after
+     * initialEventsFetched has become true.
+     *
+     * -- andyb
+     */
+    _defineProperty(this, "lastEvent", void 0);
     _defineProperty(this, "replyCount", 0);
+    _defineProperty(this, "lastPendingEvent", void 0);
     _defineProperty(this, "pendingReplyCount", 0);
+    _defineProperty(this, "room", void 0);
+    _defineProperty(this, "client", void 0);
+    _defineProperty(this, "pendingEventOrdering", void 0);
+    _defineProperty(this, "processRootEventPromise", void 0);
     /**
      * Whether or not we need to fetch the initial set of events for the thread. We can
      * only do this if the server has support for it, so if it doesn't we just pretend
      * that we've already fetched them.
      */
     _defineProperty(this, "initialEventsFetched", !Thread.hasServerSideSupport);
+    _defineProperty(this, "initalEventFetchProm", void 0);
     /**
      * An array of events to add to the timeline once the thread has been initialised
      * with server suppport.
      */
     _defineProperty(this, "replayEvents", []);
-    _defineProperty(this, "onTimelineReset", /*#__PURE__*/_asyncToGenerator(function* () {
+    _defineProperty(this, "onTimelineReset", async () => {
       // We hit a gappy sync, ask the server for an update
-      yield _this.processRootEventPromise;
-      _this.processRootEventPromise = undefined;
-    }));
+      await this.processRootEventPromise;
+      this.processRootEventPromise = undefined;
+    });
     _defineProperty(this, "onBeforeRedaction", (event, redaction) => {
-      if (event !== null && event !== void 0 && event.isRelation(THREAD_RELATION_TYPE.name) && this.room.eventShouldLiveIn(event).threadId === this.id && event.getId() !== this.id &&
+      if (event?.isRelation(THREAD_RELATION_TYPE.name) && this.room.eventShouldLiveIn(event).threadId === this.id && event.getId() !== this.id &&
       // the root event isn't counted in the length so ignore this redaction
       !redaction.status // only respect it when it succeeds
       ) {
@@ -88,34 +129,28 @@ export class Thread extends ReadReceipt {
         this.emit(ThreadEvent.Update, this);
       }
     });
-    _defineProperty(this, "onRedaction", /*#__PURE__*/function () {
-      var _ref2 = _asyncToGenerator(function* (event, room, threadRootId) {
-        if (threadRootId !== _this.id) return; // ignore redactions for other timelines
-        if (_this.replyCount <= 0) {
-          for (var threadEvent of _this.timeline) {
-            _this.clearEventMetadata(threadEvent);
-          }
-          _this.lastEvent = _this.rootEvent;
-          _this._currentUserParticipated = false;
-          _this.emit(ThreadEvent.Delete, _this);
-        } else {
-          var _this$lastEvent;
-          if (((_this$lastEvent = _this.lastEvent) === null || _this$lastEvent === void 0 ? void 0 : _this$lastEvent.getId()) === event.getAssociatedId()) {
-            // XXX: If our last event got redacted we query the server for the last event once again
-            yield _this.processRootEventPromise;
-            _this.processRootEventPromise = undefined;
-          }
-          yield _this.updateThreadMetadata();
+    _defineProperty(this, "onRedaction", async (event, room, threadRootId) => {
+      if (threadRootId !== this.id) return; // ignore redactions for other timelines
+      if (this.replyCount <= 0) {
+        for (const threadEvent of this.timeline) {
+          this.clearEventMetadata(threadEvent);
         }
-      });
-      return function (_x, _x2, _x3) {
-        return _ref2.apply(this, arguments);
-      };
-    }());
+        this.lastEvent = this.rootEvent;
+        this._currentUserParticipated = false;
+        this.emit(ThreadEvent.Delete, this);
+      } else {
+        if (this.lastEvent?.getId() === event.getAssociatedId()) {
+          // XXX: If our last event got redacted we query the server for the last event once again
+          await this.processRootEventPromise;
+          this.processRootEventPromise = undefined;
+        }
+        await this.updateThreadMetadata();
+      }
+    });
     _defineProperty(this, "onTimelineEvent", (event, room, toStartOfTimeline) => {
       // Add a synthesized receipt when paginating forward in the timeline
       if (!toStartOfTimeline) {
-        var sender = event.getSender();
+        const sender = event.getSender();
         if (sender && room && this.shouldSendLocalEchoReceipt(sender, event)) {
           room.addLocalEchoReceipt(sender, event, ReceiptType.Read);
         }
@@ -123,37 +158,32 @@ export class Thread extends ReadReceipt {
           this.replyCount++;
         }
       }
-      this.onEcho(event, toStartOfTimeline !== null && toStartOfTimeline !== void 0 ? toStartOfTimeline : false);
+      this.onEcho(event, toStartOfTimeline ?? false);
     });
     _defineProperty(this, "onLocalEcho", event => {
       this.onEcho(event, false);
     });
-    _defineProperty(this, "onEcho", /*#__PURE__*/function () {
-      var _ref3 = _asyncToGenerator(function* (event, toStartOfTimeline) {
-        if (event.threadRootId !== _this.id) return; // ignore echoes for other timelines
-        if (_this.lastEvent === event) return; // ignore duplicate events
-        yield _this.updateThreadMetadata();
-        if (!event.isRelation(THREAD_RELATION_TYPE.name)) return; // don't send a new reply event for reactions or edits
-        if (toStartOfTimeline) return; // ignore messages added to the start of the timeline
-        // Clear the lastEvent and instead start tracking locally using lastReply
-        _this.lastEvent = undefined;
-        _this.emit(ThreadEvent.NewReply, _this, event);
-      });
-      return function (_x4, _x5) {
-        return _ref3.apply(this, arguments);
-      };
-    }());
+    _defineProperty(this, "onEcho", async (event, toStartOfTimeline) => {
+      if (event.threadRootId !== this.id) return; // ignore echoes for other timelines
+      if (this.lastEvent === event) return; // ignore duplicate events
+      await this.updateThreadMetadata();
+      if (!event.isRelation(THREAD_RELATION_TYPE.name)) return; // don't send a new reply event for reactions or edits
+      if (toStartOfTimeline) return; // ignore messages added to the start of the timeline
+      // Clear the lastEvent and instead start tracking locally using lastReply
+      this.lastEvent = undefined;
+      this.emit(ThreadEvent.NewReply, this, event);
+    });
     this.id = id;
     this.rootEvent = rootEvent;
     this.setMaxListeners(1000);
-    if (!(opts !== null && opts !== void 0 && opts.room)) {
+    if (!opts?.room) {
       // Logging/debugging for https://github.com/vector-im/element-web/issues/22141
       // Hope is that we end up with a more obvious stack trace.
       throw new Error("element-web#22141: A thread requires a room in order to function");
     }
     this.room = opts.room;
     this.client = opts.client;
-    this.pendingEventOrdering = (_opts$pendingEventOrd = opts.pendingEventOrdering) !== null && _opts$pendingEventOrd !== void 0 ? _opts$pendingEventOrd : PendingEventOrdering.Chronological;
+    this.pendingEventOrdering = opts.pendingEventOrdering ?? PendingEventOrdering.Chronological;
     this.timelineSet = new EventTimelineSet(this.room, {
       timelineSupport: true,
       pendingEvents: true
@@ -172,20 +202,17 @@ export class Thread extends ReadReceipt {
     this.updateThreadMetadata();
     this.setEventMetadata(this.rootEvent);
   }
-  fetchRootEvent() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      // Always fetch the root event, even if we already have it, so we can get the latest
-      // state (via unsigned).
-      try {
-        var eventData = yield _this2.client.fetchRoomEvent(_this2.roomId, _this2.id);
-        var mapper = _this2.client.getEventMapper();
-        _this2.rootEvent = mapper(eventData); // will merge with existing event object if such is known
-      } catch (e) {
-        logger.error("Failed to fetch thread root to construct thread with", e);
-      }
-      yield _this2.processEvent(_this2.rootEvent);
-    })();
+  async fetchRootEvent() {
+    // Always fetch the root event, even if we already have it, so we can get the latest
+    // state (via unsigned).
+    try {
+      const eventData = await this.client.fetchRoomEvent(this.roomId, this.id);
+      const mapper = this.client.getEventMapper();
+      this.rootEvent = mapper(eventData); // will merge with existing event object if such is known
+    } catch (e) {
+      logger.error("Failed to fetch thread root to construct thread with", e);
+    }
+    await this.processEvent(this.rootEvent);
   }
   static setServerSideSupport(status) {
     Thread.hasServerSideSupport = status;
@@ -203,16 +230,14 @@ export class Thread extends ReadReceipt {
     Thread.hasServerSideFwdPaginationSupport = status;
   }
   shouldSendLocalEchoReceipt(sender, event) {
-    var _this$client$canSuppo;
-    var recursionSupport = (_this$client$canSuppo = this.client.canSupport.get(Feature.RelationsRecursion)) !== null && _this$client$canSuppo !== void 0 ? _this$client$canSuppo : ServerSupport.Unsupported;
+    const recursionSupport = this.client.canSupport.get(Feature.RelationsRecursion) ?? ServerSupport.Unsupported;
     if (recursionSupport === ServerSupport.Unsupported) {
-      var _this$getReadReceiptF;
       // Normally we add a local receipt, but if we don't have
       // recursion support, then events may arrive out of order, so we
       // only create a receipt if it's after our existing receipt.
-      var oldReceiptEventId = (_this$getReadReceiptF = this.getReadReceiptForUserId(sender)) === null || _this$getReadReceiptF === void 0 ? void 0 : _this$getReadReceiptF.eventId;
+      const oldReceiptEventId = this.getReadReceiptForUserId(sender)?.eventId;
       if (oldReceiptEventId) {
-        var receiptEvent = this.findEventById(oldReceiptEventId);
+        const receiptEvent = this.findEventById(oldReceiptEventId);
         if (receiptEvent && receiptEvent.getTs() > event.getTs()) {
           return false;
         }
@@ -248,7 +273,7 @@ export class Thread extends ReadReceipt {
    * @internal
    */
   insertEventIntoTimeline(event) {
-    var eventId = event.getId();
+    const eventId = event.getId();
     if (!eventId) {
       return;
     }
@@ -272,15 +297,14 @@ export class Thread extends ReadReceipt {
    * to the start (and not the end) of the timeline.
    * @param emit - whether to emit the Update event if the thread was updated or not.
    */
-  addEvent(event, toStartOfTimeline) {
-    var emit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  addEvent(event, toStartOfTimeline, emit = true) {
     // Modify this event to point at our room's state, and mark its thread
     // as this.
     this.setEventMetadata(event);
 
     // Decide whether this event is going to be added at the end of the timeline.
-    var lastReply = this.lastReply();
-    var isNewestReply = !lastReply || event.localTimestamp >= lastReply.localTimestamp;
+    const lastReply = this.lastReply();
+    const isNewestReply = !lastReply || event.localTimestamp >= lastReply.localTimestamp;
     if (!Thread.hasServerSideSupport) {
       // When there's no server-side support, just add it to the end of the timeline.
       this.addEventToTimeline(event, toStartOfTimeline);
@@ -325,7 +349,6 @@ export class Thread extends ReadReceipt {
     // reference to something that is, then we have two cases:
 
     if (!this.initialEventsFetched) {
-      var _this$replayEvents;
       // Case 1: we haven't yet fetched events from the server. In
       // this case, when we do, the events we get back might only be
       // the first-order ones, so this event (which is second-order -
@@ -341,17 +364,15 @@ export class Thread extends ReadReceipt {
        * This fix keeps a reference to those events and replay them once the thread
        * has been initialised properly.
        */
-      (_this$replayEvents = this.replayEvents) === null || _this$replayEvents === void 0 || _this$replayEvents.push(event);
+      this.replayEvents?.push(event);
 
       // For annotations (reactions), aggregate immediately (pre-init) to keep
       // reaction counts/summary visible while the thread is still initialising.
       // Only aggregate as child: parent aggregation is unnecessary here.
       if (event.isRelation(RelationType.Annotation)) {
-        var _this$timelineSet$rel;
-        (_this$timelineSet$rel = this.timelineSet.relations) === null || _this$timelineSet$rel === void 0 || _this$timelineSet$rel.aggregateChildEvent(event, this.timelineSet);
+        this.timelineSet.relations?.aggregateChildEvent(event, this.timelineSet);
       }
     } else {
-      var _this$client$canSuppo2;
       // Case 2: this is happening later, and we have a timeline. In
       // this case, these events might be out-of order.
       //
@@ -369,7 +390,7 @@ export class Thread extends ReadReceipt {
       // (Note that both insertEventIntoTimeline and addEventToTimeline
       // do nothing if we have seen this event before.)
 
-      var recursionSupport = (_this$client$canSuppo2 = this.client.canSupport.get(Feature.RelationsRecursion)) !== null && _this$client$canSuppo2 !== void 0 ? _this$client$canSuppo2 : ServerSupport.Unsupported;
+      const recursionSupport = this.client.canSupport.get(Feature.RelationsRecursion) ?? ServerSupport.Unsupported;
       if (recursionSupport === ServerSupport.Unsupported) {
         this.insertEventIntoTimeline(event);
       } else {
@@ -378,14 +399,11 @@ export class Thread extends ReadReceipt {
       // Aggregation is handled by EventTimelineSet when inserting/adding.
     }
   }
-  processEvent(event) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      if (event) {
-        _this3.setEventMetadata(event);
-        yield _this3.fetchEditsWhereNeeded(event);
-      }
-    })();
+  async processEvent(event) {
+    if (event) {
+      this.setEventMetadata(event);
+      await this.fetchEditsWhereNeeded(event);
+    }
   }
 
   /**
@@ -394,44 +412,37 @@ export class Thread extends ReadReceipt {
    * and apply them to the current thread
    * @param receipts - A collection of the receipts cached from initial sync
    */
-  processReceipts() {
-    var receipts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    for (var _ref5 of receipts) {
-      var eventId = _ref5.eventId;
-      var receiptType = _ref5.receiptType;
-      var userId = _ref5.userId;
-      var receipt = _ref5.receipt;
-      var synthetic = _ref5.synthetic;
+  processReceipts(receipts = []) {
+    for (const {
+      eventId,
+      receiptType,
+      userId,
+      receipt,
+      synthetic
+    } of receipts) {
       this.addReceiptToStructure(eventId, receiptType, userId, receipt, synthetic);
     }
   }
-  getRootEventBundledRelationship() {
-    var rootEvent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.rootEvent;
-    return rootEvent === null || rootEvent === void 0 ? void 0 : rootEvent.getServerAggregatedRelation(THREAD_RELATION_TYPE.name);
-  }
-  processRootEvent() {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      var bundledRelationship = _this4.getRootEventBundledRelationship();
-      if (Thread.hasServerSideSupport && bundledRelationship) {
-        _this4.replyCount = bundledRelationship.count;
-        _this4._currentUserParticipated = !!bundledRelationship.current_user_participated;
-        var mapper = _this4.client.getEventMapper();
-        // re-insert roomId
-        _this4.lastEvent = mapper(_objectSpread(_objectSpread({}, bundledRelationship.latest_event), {}, {
-          room_id: _this4.roomId
-        }));
-        _this4.updatePendingReplyCount();
-        yield _this4.processEvent(_this4.lastEvent);
-      }
-    })();
+  getRootEventBundledRelationship(rootEvent = this.rootEvent) {
+    return rootEvent?.getServerAggregatedRelation(THREAD_RELATION_TYPE.name);
+  }
+  async processRootEvent() {
+    const bundledRelationship = this.getRootEventBundledRelationship();
+    if (Thread.hasServerSideSupport && bundledRelationship) {
+      this.replyCount = bundledRelationship.count;
+      this._currentUserParticipated = !!bundledRelationship.current_user_participated;
+      const mapper = this.client.getEventMapper();
+      // re-insert roomId
+      this.lastEvent = mapper(_objectSpread(_objectSpread({}, bundledRelationship.latest_event), {}, {
+        room_id: this.roomId
+      }));
+      this.updatePendingReplyCount();
+      await this.processEvent(this.lastEvent);
+    }
   }
   updatePendingReplyCount() {
-    var unfilteredPendingEvents = this.pendingEventOrdering === PendingEventOrdering.Detached ? this.room.getPendingEvents() : this.events;
-    var pendingEvents = unfilteredPendingEvents.filter(ev => {
-      var _this$lastEvent2;
-      return ev.threadRootId === this.id && ev.isRelation(THREAD_RELATION_TYPE.name) && ev.status !== null && ev.getId() !== ((_this$lastEvent2 = this.lastEvent) === null || _this$lastEvent2 === void 0 ? void 0 : _this$lastEvent2.getId());
-    });
+    const unfilteredPendingEvents = this.pendingEventOrdering === PendingEventOrdering.Detached ? this.room.getPendingEvents() : this.events;
+    const pendingEvents = unfilteredPendingEvents.filter(ev => ev.threadRootId === this.id && ev.isRelation(THREAD_RELATION_TYPE.name) && ev.status !== null && ev.getId() !== this.lastEvent?.getId());
     this.lastPendingEvent = pendingEvents.length ? pendingEvents[pendingEvents.length - 1] : undefined;
     this.pendingReplyCount = pendingEvents.length;
   }
@@ -450,147 +461,125 @@ export class Thread extends ReadReceipt {
    * timeline which would otherwise be unable to paginate forwards without this token).
    * Removing just the old live timeline whilst preserving previous ones is not supported.
    */
-  resetLiveTimeline(backPaginationToken, forwardPaginationToken) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      var oldLive = _this5.liveTimeline;
-      _this5.timelineSet.resetLiveTimeline(backPaginationToken !== null && backPaginationToken !== void 0 ? backPaginationToken : undefined, forwardPaginationToken !== null && forwardPaginationToken !== void 0 ? forwardPaginationToken : undefined);
-      var newLive = _this5.liveTimeline;
+  async resetLiveTimeline(backPaginationToken, forwardPaginationToken) {
+    const oldLive = this.liveTimeline;
+    this.timelineSet.resetLiveTimeline(backPaginationToken ?? undefined, forwardPaginationToken ?? undefined);
+    const newLive = this.liveTimeline;
 
-      // FIXME: Remove the following as soon as https://github.com/matrix-org/synapse/issues/14830 is resolved.
-      //
-      // The pagination API for thread timelines currently can't handle the type of pagination tokens returned by sync
-      //
-      // To make this work anyway, we'll have to transform them into one of the types that the API can handle.
-      // One option is passing the tokens to /messages, which can handle sync tokens, and returns the right format.
-      // /messages does not return new tokens on requests with a limit of 0.
-      // This means our timelines might overlap a slight bit, but that's not an issue, as we deduplicate messages
-      // anyway.
+    // FIXME: Remove the following as soon as https://github.com/matrix-org/synapse/issues/14830 is resolved.
+    //
+    // The pagination API for thread timelines currently can't handle the type of pagination tokens returned by sync
+    //
+    // To make this work anyway, we'll have to transform them into one of the types that the API can handle.
+    // One option is passing the tokens to /messages, which can handle sync tokens, and returns the right format.
+    // /messages does not return new tokens on requests with a limit of 0.
+    // This means our timelines might overlap a slight bit, but that's not an issue, as we deduplicate messages
+    // anyway.
 
-      var newBackward;
-      var oldForward;
-      if (backPaginationToken) {
-        var res = yield _this5.client.createMessagesRequest(_this5.roomId, backPaginationToken, 1, Direction.Forward);
-        newBackward = res.end;
-      }
-      if (forwardPaginationToken) {
-        var _res = yield _this5.client.createMessagesRequest(_this5.roomId, forwardPaginationToken, 1, Direction.Backward);
-        oldForward = _res.start;
-      }
-      // Only replace the token if we don't have paginated away from this position already. This situation doesn't
-      // occur today, but if the above issue is resolved, we'd have to go down this path.
-      if (forwardPaginationToken && oldLive.getPaginationToken(Direction.Forward) === forwardPaginationToken) {
-        oldLive.setPaginationToken(oldForward !== null && oldForward !== void 0 ? oldForward : null, Direction.Forward);
-      }
-      if (backPaginationToken && newLive.getPaginationToken(Direction.Backward) === backPaginationToken) {
-        newLive.setPaginationToken(newBackward !== null && newBackward !== void 0 ? newBackward : null, Direction.Backward);
-      }
-    })();
-  }
-  updateThreadFromRootEvent() {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      if (Thread.hasServerSideSupport) {
-        // Ensure we show *something* as soon as possible, we'll update it as soon as we get better data, but we
-        // don't want the thread preview to be empty if we can avoid it
-        if (!_this6.initialEventsFetched && !_this6.lastEvent) {
-          yield _this6.processRootEvent();
-        }
-        yield _this6.fetchRootEvent();
-      }
-      yield _this6.processRootEvent();
-    })();
-  }
-  updateThreadMetadata() {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      _this7.updatePendingReplyCount();
-      if (!_this7.processRootEventPromise) {
-        // We only want to do this once otherwise we end up rolling back to the last unsigned summary we have for the thread
-        _this7.processRootEventPromise = _this7.updateThreadFromRootEvent();
+    let newBackward;
+    let oldForward;
+    if (backPaginationToken) {
+      const res = await this.client.createMessagesRequest(this.roomId, backPaginationToken, 1, Direction.Forward);
+      newBackward = res.end;
+    }
+    if (forwardPaginationToken) {
+      const res = await this.client.createMessagesRequest(this.roomId, forwardPaginationToken, 1, Direction.Backward);
+      oldForward = res.start;
+    }
+    // Only replace the token if we don't have paginated away from this position already. This situation doesn't
+    // occur today, but if the above issue is resolved, we'd have to go down this path.
+    if (forwardPaginationToken && oldLive.getPaginationToken(Direction.Forward) === forwardPaginationToken) {
+      oldLive.setPaginationToken(oldForward ?? null, Direction.Forward);
+    }
+    if (backPaginationToken && newLive.getPaginationToken(Direction.Backward) === backPaginationToken) {
+      newLive.setPaginationToken(newBackward ?? null, Direction.Backward);
+    }
+  }
+  async updateThreadFromRootEvent() {
+    if (Thread.hasServerSideSupport) {
+      // Ensure we show *something* as soon as possible, we'll update it as soon as we get better data, but we
+      // don't want the thread preview to be empty if we can avoid it
+      if (!this.initialEventsFetched && !this.lastEvent) {
+        await this.processRootEvent();
       }
-      yield _this7.processRootEventPromise;
-      if (!_this7.initialEventsFetched) {
-        if (_this7.initalEventFetchProm) {
-          yield _this7.initalEventFetchProm;
-        } else {
-          // fetch initial events to allow proper pagination
-          try {
-            // clear out any events that were added before the pagination request
-            // completed (eg. from sync). They'll be replaced by those from the pagination.
-            // Really, we should do this after the pagination request completes, but
-            // paginateEventTimeline does the request and adds the events in one go, so
-            // this would need a refactor in order to do. It's therefore possible there's
-            // a remaining race where an event comes in while the pagination request is
-            // happening.
-            _this7.timelineSet.resetLiveTimeline();
-            // if the thread has regular events, this will just load the last reply.
-            // if the thread is newly created, this will load the root event.
-            if (_this7.replyCount === 0 && _this7.rootEvent) {
-              _this7.timelineSet.addEventsToTimeline([_this7.rootEvent], true, false, _this7.liveTimeline, null);
-              _this7.liveTimeline.setPaginationToken(null, Direction.Backward);
-            } else {
-              _this7.initalEventFetchProm = _this7.client.paginateEventTimeline(_this7.liveTimeline, {
-                backwards: true
-              });
-              yield _this7.initalEventFetchProm;
-            }
-            // We have now fetched the initial events, so set the flag. We need to do this before
-            // we actually add the events, so `this.addEvents` knows that it can now safely add
-            // them rather than buffer them in the pending event list. The main thing is that this
-            // must remain false while the async fetch happens, so we don't try to add events before
-            // the pagination has finished. The important thing is that we're not await-ing anything
-            // else between setting this and adding events, so no races.
-            _this7.initialEventsFetched = true;
-            for (var event of _this7.replayEvents) {
-              _this7.addEvent(event, false);
-            }
-            _this7.replayEvents = null;
-            // just to make sure that, if we've created a timeline window for this thread before the thread itself
-            // existed (e.g. when creating a new thread), we'll make sure the panel is force refreshed correctly.
-            _this7.emit(RoomEvent.TimelineReset, _this7.room, _this7.timelineSet, true);
-          } catch (e) {
-            logger.error("Failed to load start of newly created thread: ", e);
-            _this7.initialEventsFetched = false;
+      await this.fetchRootEvent();
+    }
+    await this.processRootEvent();
+  }
+  async updateThreadMetadata() {
+    this.updatePendingReplyCount();
+    if (!this.processRootEventPromise) {
+      // We only want to do this once otherwise we end up rolling back to the last unsigned summary we have for the thread
+      this.processRootEventPromise = this.updateThreadFromRootEvent();
+    }
+    await this.processRootEventPromise;
+    if (!this.initialEventsFetched) {
+      if (this.initalEventFetchProm) {
+        await this.initalEventFetchProm;
+      } else {
+        // fetch initial events to allow proper pagination
+        try {
+          // clear out any events that were added before the pagination request
+          // completed (eg. from sync). They'll be replaced by those from the pagination.
+          // Really, we should do this after the pagination request completes, but
+          // paginateEventTimeline does the request and adds the events in one go, so
+          // this would need a refactor in order to do. It's therefore possible there's
+          // a remaining race where an event comes in while the pagination request is
+          // happening.
+          this.timelineSet.resetLiveTimeline();
+          // if the thread has regular events, this will just load the last reply.
+          // if the thread is newly created, this will load the root event.
+          if (this.replyCount === 0 && this.rootEvent) {
+            this.timelineSet.addEventsToTimeline([this.rootEvent], true, false, this.liveTimeline, null);
+            this.liveTimeline.setPaginationToken(null, Direction.Backward);
+          } else {
+            this.initalEventFetchProm = this.client.paginateEventTimeline(this.liveTimeline, {
+              backwards: true
+            });
+            await this.initalEventFetchProm;
+          }
+          // We have now fetched the initial events, so set the flag. We need to do this before
+          // we actually add the events, so `this.addEvents` knows that it can now safely add
+          // them rather than buffer them in the pending event list. The main thing is that this
+          // must remain false while the async fetch happens, so we don't try to add events before
+          // the pagination has finished. The important thing is that we're not await-ing anything
+          // else between setting this and adding events, so no races.
+          this.initialEventsFetched = true;
+          for (const event of this.replayEvents) {
+            this.addEvent(event, false);
           }
+          this.replayEvents = null;
+          // just to make sure that, if we've created a timeline window for this thread before the thread itself
+          // existed (e.g. when creating a new thread), we'll make sure the panel is force refreshed correctly.
+          this.emit(RoomEvent.TimelineReset, this.room, this.timelineSet, true);
+        } catch (e) {
+          logger.error("Failed to load start of newly created thread: ", e);
+          this.initialEventsFetched = false;
         }
       }
-      _this7.emit(ThreadEvent.Update, _this7);
-    })();
+    }
+    this.emit(ThreadEvent.Update, this);
   }
 
   // XXX: Workaround for https://github.com/matrix-org/matrix-spec-proposals/pull/2676/files#r827240084
-  fetchEditsWhereNeeded() {
-    var _arguments = arguments,
-      _this8 = this;
-    return _asyncToGenerator(function* () {
-      var _this8$client$canSupp;
-      var recursionSupport = (_this8$client$canSupp = _this8.client.canSupport.get(Feature.RelationsRecursion)) !== null && _this8$client$canSupp !== void 0 ? _this8$client$canSupp : ServerSupport.Unsupported;
-      if (recursionSupport === ServerSupport.Unsupported) {
-        for (var _len = _arguments.length, events = new Array(_len), _key = 0; _key < _len; _key++) {
-          events[_key] = _arguments[_key];
-        }
-        return Promise.all(events.filter(isAnEncryptedThreadMessage).map(/*#__PURE__*/function () {
-          var _ref6 = _asyncToGenerator(function* (event) {
-            try {
-              var relations = yield _this8.client.relations(_this8.roomId, event.getId(), RelationType.Replace, event.getType(), {
-                limit: 1
-              });
-              if (relations.events.length) {
-                var editEvent = relations.events[0];
-                event.makeReplaced(editEvent);
-                _this8.insertEventIntoTimeline(editEvent);
-              }
-            } catch (e) {
-              logger.error("Failed to load edits for encrypted thread event", e);
-            }
+  async fetchEditsWhereNeeded(...events) {
+    const recursionSupport = this.client.canSupport.get(Feature.RelationsRecursion) ?? ServerSupport.Unsupported;
+    if (recursionSupport === ServerSupport.Unsupported) {
+      return Promise.all(events.filter(isAnEncryptedThreadMessage).map(async event => {
+        try {
+          const relations = await this.client.relations(this.roomId, event.getId(), RelationType.Replace, event.getType(), {
+            limit: 1
           });
-          return function (_x6) {
-            return _ref6.apply(this, arguments);
-          };
-        }()));
-      }
-    })();
+          if (relations.events.length) {
+            const editEvent = relations.events[0];
+            event.makeReplaced(editEvent);
+            this.insertEventIntoTimeline(editEvent);
+          }
+        } catch (e) {
+          logger.error("Failed to load edits for encrypted thread event", e);
+        }
+      }));
+    }
   }
   setEventMetadata(event) {
     if (event) {
@@ -600,9 +589,8 @@ export class Thread extends ReadReceipt {
   }
   clearEventMetadata(event) {
     if (event) {
-      var _event$event;
       event.setThread(undefined);
-      (_event$event = event.event) === null || _event$event === void 0 || (_event$event = _event$event.unsigned) === null || _event$event === void 0 || (_event$event = _event$event["m.relations"]) === null || _event$event === void 0 || delete _event$event[THREAD_RELATION_TYPE.name];
+      delete event.event?.unsigned?.["m.relations"]?.[THREAD_RELATION_TYPE.name];
     }
   }
 
@@ -616,10 +604,9 @@ export class Thread extends ReadReceipt {
   /**
    * Return last reply to the thread, if known.
    */
-  lastReply() {
-    var matches = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ev => ev.isRelation(THREAD_RELATION_TYPE.name);
-    for (var i = this.timeline.length - 1; i >= 0; i--) {
-      var event = this.timeline[i];
+  lastReply(matches = ev => ev.isRelation(THREAD_RELATION_TYPE.name)) {
+    for (let i = this.timeline.length - 1; i >= 0; i--) {
+      const event = this.timeline[i];
       if (matches(event)) {
         return event;
       }
@@ -644,8 +631,7 @@ export class Thread extends ReadReceipt {
    * This might be a synthesized event, if so, it will not emit any events to listeners.
    */
   get replyToEvent() {
-    var _ref7, _this$lastPendingEven;
-    return (_ref7 = (_this$lastPendingEven = this.lastPendingEvent) !== null && _this$lastPendingEven !== void 0 ? _this$lastPendingEven : this.lastEvent) !== null && _ref7 !== void 0 ? _ref7 : this.lastReply();
+    return this.lastPendingEvent ?? this.lastEvent ?? this.lastReply();
   }
 
   /**
@@ -707,32 +693,31 @@ export class Thread extends ReadReceipt {
     //
     // --- andyb
 
-    var isCurrentUser = userId === this.client.getUserId();
-    var lastReply = this.timeline[this.timeline.length - 1];
+    const isCurrentUser = userId === this.client.getUserId();
+    const lastReply = this.timeline[this.timeline.length - 1];
     if (isCurrentUser && lastReply) {
       // If the last activity in a thread is prior to the first threaded read receipt
       // sent in the room (suggesting that it was sent before the user started
       // using a client that supported threaded read receipts), we want to
       // consider this thread as read.
-      var beforeFirstThreadedReceipt = lastReply.getTs() < this.room.getOldestThreadedReceiptTs();
-      var lastReplyId = lastReply.getId();
+      const beforeFirstThreadedReceipt = lastReply.getTs() < this.room.getOldestThreadedReceiptTs();
+      const lastReplyId = lastReply.getId();
       // Some unsent events do not have an ID, we do not want to consider them read
       if (beforeFirstThreadedReceipt && lastReplyId) {
         return lastReplyId;
       }
     }
-    var readUpToId = super.getEventReadUpTo(userId, ignoreSynthesized);
+    const readUpToId = super.getEventReadUpTo(userId, ignoreSynthesized);
 
     // Check whether the unthreaded read receipt for that user is more recent
     // than the read receipt inside that thread.
     if (lastReply) {
-      var unthreadedReceipt = this.room.getLastUnthreadedReceiptFor(userId);
+      const unthreadedReceipt = this.room.getLastUnthreadedReceiptFor(userId);
       if (!unthreadedReceipt) {
         return readUpToId;
       }
-      for (var i = ((_this$timeline = this.timeline) === null || _this$timeline === void 0 ? void 0 : _this$timeline.length) - 1; i >= 0; --i) {
-        var _this$timeline, _ev$getId;
-        var ev = this.timeline[i];
+      for (let i = this.timeline?.length - 1; i >= 0; --i) {
+        const ev = this.timeline[i];
         // If we encounter the `readUpToId` we do not need to look further
         // there is no "more recent" unthreaded read receipt
         if (ev.getId() === readUpToId) return readUpToId;
@@ -741,7 +726,7 @@ export class Thread extends ReadReceipt {
         // whether an unthreaded read receipt is more recent that the current event.
         // We usually prefer relying on the order of the DAG but in this scenario
         // it is not possible and we have to rely on timestamp
-        if (ev.getTs() < unthreadedReceipt.ts) return (_ev$getId = ev.getId()) !== null && _ev$getId !== void 0 ? _ev$getId : readUpToId;
+        if (ev.getTs() < unthreadedReceipt.ts) return ev.getId() ?? readUpToId;
       }
     }
     return readUpToId;
@@ -760,14 +745,13 @@ export class Thread extends ReadReceipt {
    */
   hasUserReadEvent(userId, eventId) {
     if (userId === this.client.getUserId()) {
-      var _this$lastReply$getTs, _this$lastReply, _this$room$getLastUnt, _this$room$getLastUnt2, _this$lastReply$getTs2, _this$lastReply2;
       // Consider an event read if it's part of a thread that is before the
       // first threaded receipt sent in that room. It is likely that it is
       // part of a thread that was created before MSC3771 was implemented.
       // Or before the last unthreaded receipt for the logged in user
-      var beforeFirstThreadedReceipt = ((_this$lastReply$getTs = (_this$lastReply = this.lastReply()) === null || _this$lastReply === void 0 ? void 0 : _this$lastReply.getTs()) !== null && _this$lastReply$getTs !== void 0 ? _this$lastReply$getTs : 0) < this.room.getOldestThreadedReceiptTs();
-      var unthreadedReceiptTs = (_this$room$getLastUnt = (_this$room$getLastUnt2 = this.room.getLastUnthreadedReceiptFor(userId)) === null || _this$room$getLastUnt2 === void 0 ? void 0 : _this$room$getLastUnt2.ts) !== null && _this$room$getLastUnt !== void 0 ? _this$room$getLastUnt : 0;
-      var beforeLastUnthreadedReceipt = ((_this$lastReply$getTs2 = this === null || this === void 0 || (_this$lastReply2 = this.lastReply()) === null || _this$lastReply2 === void 0 ? void 0 : _this$lastReply2.getTs()) !== null && _this$lastReply$getTs2 !== void 0 ? _this$lastReply$getTs2 : 0) < unthreadedReceiptTs;
+      const beforeFirstThreadedReceipt = (this.lastReply()?.getTs() ?? 0) < this.room.getOldestThreadedReceiptTs();
+      const unthreadedReceiptTs = this.room.getLastUnthreadedReceiptFor(userId)?.ts ?? 0;
+      const beforeLastUnthreadedReceipt = (this?.lastReply()?.getTs() ?? 0) < unthreadedReceiptTs;
       if (beforeFirstThreadedReceipt || beforeLastUnthreadedReceipt) {
         return true;
       }
@@ -802,10 +786,10 @@ _defineProperty(Thread, "hasServerSideFwdPaginationSupport", FeatureSupport.None
 function isAnEncryptedThreadMessage(event) {
   return event.isEncrypted() && (event.isRelation(THREAD_RELATION_TYPE.name) || event.isThreadRoot);
 }
-export var FILTER_RELATED_BY_SENDERS = new ServerControlledNamespacedValue("related_by_senders", "io.element.relation_senders");
-export var FILTER_RELATED_BY_REL_TYPES = new ServerControlledNamespacedValue("related_by_rel_types", "io.element.relation_types");
-export var THREAD_RELATION_TYPE = new ServerControlledNamespacedValue("m.thread", "io.element.thread");
-export var ThreadFilterType = /*#__PURE__*/function (ThreadFilterType) {
+export const FILTER_RELATED_BY_SENDERS = new ServerControlledNamespacedValue("related_by_senders", "io.element.relation_senders");
+export const FILTER_RELATED_BY_REL_TYPES = new ServerControlledNamespacedValue("related_by_rel_types", "io.element.relation_types");
+export const THREAD_RELATION_TYPE = new ServerControlledNamespacedValue("m.thread", "io.element.thread");
+export let ThreadFilterType = /*#__PURE__*/function (ThreadFilterType) {
   ThreadFilterType[ThreadFilterType["My"] = 0] = "My";
   ThreadFilterType[ThreadFilterType["All"] = 1] = "All";
   return ThreadFilterType;