diff --git a/src/client.ts b/src/client.ts
index efd6f536ec3..54f75358141 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -5243,6 +5243,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             throw new Error("could not get thread timeline: no client support");
         }
 
+        if (!timelineSet.room) {
+            throw new Error("could not get thread timeline: not a room timeline");
+        }
+
         if (!timelineSet.thread) {
             throw new Error("could not get thread timeline: not a thread timeline");
         }
@@ -5277,14 +5281,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 }
 
                 const thread = timelineSet.thread;
-                const resOlder = await this.fetchRelations(
+                const resOlder: IRelationsResponse = await this.fetchRelations(
                     timelineSet.room.roomId,
                     thread.id,
                     THREAD_RELATION_TYPE.name,
                     null,
                     { dir: Direction.Backward, from: res.start },
                 );
-                const resNewer = await this.fetchRelations(
+                const resNewer: IRelationsResponse = await this.fetchRelations(
                     timelineSet.room.roomId,
                     thread.id,
                     THREAD_RELATION_TYPE.name,
@@ -5339,10 +5343,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                     null,
                     { dir: Direction.Backward, from: res.start },
                 );
-                const eventsNewer = [];
+                const eventsNewer: IEvent[] = [];
                 let nextBatch: Optional<string> = res.end;
                 while (nextBatch) {
-                    const resNewer = await this.fetchRelations(
+                    const resNewer: IRelationsResponse = await this.fetchRelations(
                         timelineSet.room.roomId,
                         thread.id,
                         THREAD_RELATION_TYPE.name,
@@ -5532,7 +5536,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             // create a shallow copy of LAZY_LOADING_MESSAGES_FILTER,
             // so the timelineFilter doesn't get written into it below
             filter = {
-                ...filter,
                 ...Filter.LAZY_LOADING_MESSAGES_FILTER,
             };
         }
@@ -5579,7 +5582,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         const isNotifTimeline = (eventTimeline.getTimelineSet() === this.notifTimelineSet);
         const room = this.getRoom(eventTimeline.getRoomId());
         const isThreadListTimeline = eventTimeline.getTimelineSet().isThreadTimeline;
-        const isThreadTimeline = (eventTimeline.getTimelineSet().thread);
+        const thread = eventTimeline.getTimelineSet().thread;
 
         // TODO: we should implement a backoff (as per scrollback()) to deal more
         // nicely with HTTP errors.
@@ -5690,7 +5693,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 eventTimeline.paginationRequests[dir] = null;
             });
             eventTimeline.paginationRequests[dir] = promise;
-        } else if (isThreadTimeline) {
+        } else if (thread) {
             const room = this.getRoom(eventTimeline.getRoomId());
             if (!room) {
                 throw new Error("Unknown room " + eventTimeline.getRoomId());
@@ -5698,10 +5701,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
             promise = this.fetchRelations(
                 eventTimeline.getRoomId(),
-                eventTimeline.getTimelineSet().thread?.id,
+                thread.id,
                 THREAD_RELATION_TYPE.name,
                 null,
-                { dir, limit: opts.limit, from: token },
+                { dir, limit: opts.limit, from: token ?? undefined },
             ).then(async (res) => {
                 const mapper = this.getEventMapper();
                 const matrixEvents = res.chunk.map(mapper);
@@ -6933,12 +6936,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         eventType?: EventType | string | null,
         opts: IRelationsRequestOpts = { dir: Direction.Backward },
     ): Promise<{
-        originalEvent: MatrixEvent;
+        originalEvent: MatrixEvent | null;
         events: MatrixEvent[];
         nextBatch?: string;
         prevBatch?: string;
     }> {
-        const fetchedEventType = this.getEncryptedIfNeededEventType(roomId, eventType);
+        const fetchedEventType = eventType ? this.getEncryptedIfNeededEventType(roomId, eventType) : null;
         const result = await this.fetchRelations(
             roomId,
             eventId,
@@ -6962,7 +6965,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             events = events.filter(e => e.getSender() === originalEvent.getSender());
         }
         return {
-            originalEvent,
+            originalEvent: originalEvent ?? null,
             events,
             nextBatch: result.next_batch,
             prevBatch: result.prev_batch,
diff --git a/src/models/event-timeline-set.ts b/src/models/event-timeline-set.ts
index 83a96b5b449..5ef710c37f0 100644
--- a/src/models/event-timeline-set.ts
+++ b/src/models/event-timeline-set.ts
@@ -297,8 +297,8 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      * @return {?module:models/event-timeline~EventTimeline} timeline containing
      * the given event, or null if unknown
      */
-    public getTimelineForEvent(eventId: string | null): EventTimeline | null {
-        if (eventId === null) { return null; }
+    public getTimelineForEvent(eventId?: string): EventTimeline | null {
+        if (eventId === null || eventId === undefined) { return null; }
         const res = this._eventIdToTimeline.get(eventId);
         return (res === undefined) ? null : res;
     }
diff --git a/src/models/event.ts b/src/models/event.ts
index cb1d4655839..540049e6e35 100644
--- a/src/models/event.ts
+++ b/src/models/event.ts
@@ -1543,7 +1543,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * @experimental
      */
-    public setThread(thread: Thread | null): void {
+    public setThread(thread?: Thread): void {
         if (this.thread) {
             this.reEmitter.stopReEmitting(this.thread, [ThreadEvent.Update]);
         }
@@ -1561,7 +1561,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         return this.thread;
     }
 
-    public setThreadId(threadId: string): void {
+    public setThreadId(threadId?: string): void {
         this.threadId = threadId;
     }
 }
diff --git a/src/models/room.ts b/src/models/room.ts
index b565a035842..86343c722b9 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -1828,9 +1828,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     }
 
     private onThreadNewReply(thread: Thread): void {
-        if (thread.length && thread.rootEvent) {
-            this.updateThreadRootEvents(thread, false);
-        }
+        this.updateThreadRootEvents(thread, false);
     }
 
     private onThreadDelete(thread: Thread): void {
@@ -1957,9 +1955,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     }
 
     private updateThreadRootEvents = (thread: Thread, toStartOfTimeline: boolean) => {
-        this.updateThreadRootEvent(this.threadsTimelineSets?.[0], thread, toStartOfTimeline);
-        if (thread.hasCurrentUserParticipated) {
-            this.updateThreadRootEvent(this.threadsTimelineSets?.[1], thread, toStartOfTimeline);
+        if (thread.length) {
+            this.updateThreadRootEvent(this.threadsTimelineSets?.[0], thread, toStartOfTimeline);
+            if (thread.hasCurrentUserParticipated) {
+                this.updateThreadRootEvent(this.threadsTimelineSets?.[1], thread, toStartOfTimeline);
+            }
         }
     };
 
@@ -1968,18 +1968,20 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         thread: Thread,
         toStartOfTimeline: boolean,
     ) => {
-        if (Thread.hasServerSideSupport) {
-            timelineSet.addLiveEvent(thread.rootEvent, {
-                duplicateStrategy: DuplicateStrategy.Replace,
-                fromCache: false,
-                roomState: this.currentState,
-            });
-        } else {
-            timelineSet.addEventToTimeline(
-                thread.rootEvent,
-                timelineSet.getLiveTimeline(),
-                { toStartOfTimeline },
-            );
+        if (timelineSet && thread.rootEvent) {
+            if (Thread.hasServerSideSupport) {
+                timelineSet.addLiveEvent(thread.rootEvent, {
+                    duplicateStrategy: DuplicateStrategy.Replace,
+                    fromCache: false,
+                    roomState: this.currentState,
+                });
+            } else {
+                timelineSet.addEventToTimeline(
+                    thread.rootEvent,
+                    timelineSet.getLiveTimeline(),
+                    { toStartOfTimeline },
+                );
+            }
         }
     };
 
@@ -2020,15 +2022,16 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             RoomEvent.Timeline,
             RoomEvent.TimelineReset,
         ]);
+        const isNewer = this.lastThread?.rootEvent
+            && rootEvent?.localTimestamp
+            && this.lastThread.rootEvent?.localTimestamp < rootEvent?.localTimestamp;
 
-        if (!this.lastThread || this.lastThread.rootEvent?.localTimestamp < rootEvent?.localTimestamp) {
+        if (!this.lastThread || isNewer) {
             this.lastThread = thread;
         }
 
         if (this.threadsReady) {
-            if (thread.length && thread.rootEvent) {
-                this.updateThreadRootEvents(thread, toStartOfTimeline);
-            }
+            this.updateThreadRootEvents(thread, toStartOfTimeline);
         }
 
         this.emit(ThreadEvent.New, thread, toStartOfTimeline);
diff --git a/src/models/thread.ts b/src/models/thread.ts
index 38c26d83239..19bf7415a07 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -234,6 +234,9 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
     public async addEvent(event: MatrixEvent, toStartOfTimeline: boolean, emit = true): Promise<void> {
         this.setEventMetadata(event);
 
+        const lastReply = this.lastReply();
+        const isNewestReply = !lastReply || event.localTimestamp > lastReply?.localTimestamp;
+
         // Add all incoming events to the thread's timeline set when there's  no server support
         if (!Thread.hasServerSideSupport) {
             // all the relevant membership info to hydrate events with a sender
@@ -243,16 +246,13 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
             this.addEventToTimeline(event, toStartOfTimeline);
 
             this.client.decryptEventIfNeeded(event, {});
-        } else if (!toStartOfTimeline &&
-            this.initialEventsFetched &&
-            event.localTimestamp > this.lastReply()?.localTimestamp
-        ) {
+        } else if (!toStartOfTimeline && this.initialEventsFetched && isNewestReply) {
             await this.fetchEditsWhereNeeded(event);
             this.addEventToTimeline(event, false);
         } else if (event.isRelation(RelationType.Annotation) || event.isRelation(RelationType.Replace)) {
             // Apply annotations and replace relations to the relations of the timeline only
-            this.timelineSet.relations.aggregateParentEvent(event);
-            this.timelineSet.relations.aggregateChildEvent(event, this.timelineSet);
+            this.timelineSet.relations?.aggregateParentEvent(event);
+            this.timelineSet.relations?.aggregateChildEvent(event, this.timelineSet);
             return;
         }
 
@@ -268,12 +268,14 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         }
     }
 
-    public async processEvent(event: MatrixEvent): Promise<void> {
-        this.setEventMetadata(event);
-        await this.fetchEditsWhereNeeded(event);
+    public async processEvent(event: Optional<MatrixEvent>): Promise<void> {
+        if (event) {
+            this.setEventMetadata(event);
+            await this.fetchEditsWhereNeeded(event);
+        }
     }
 
-    private getRootEventBundledRelationship(rootEvent = this.rootEvent): IThreadBundledRelationship {
+    private getRootEventBundledRelationship(rootEvent = this.rootEvent): IThreadBundledRelationship | undefined {
         return rootEvent?.getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);
     }
 
@@ -286,7 +288,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
         if (Thread.hasServerSideSupport && bundledRelationship) {
             this.replyCount = bundledRelationship.count;
-            this._currentUserParticipated = bundledRelationship.current_user_participated;
+            this._currentUserParticipated = bundledRelationship.current_user_participated ?? false;
 
             const mapper = this.client.getEventMapper();
             this.lastEvent = mapper(bundledRelationship.latest_event);
diff --git a/src/utils.ts b/src/utils.ts
index dc109128f7e..6f3a47dbd45 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -22,6 +22,7 @@ limitations under the License.
 
 import unhomoglyph from "unhomoglyph";
 import promiseRetry from "p-retry";
+import { Optional } from "matrix-events-sdk";
 
 import type * as NodeCrypto from "crypto";
 import { MatrixEvent } from "./models/event";
@@ -123,13 +124,17 @@ export function decodeParams(query: string): Record<string, string | string[]> {
  * variables with. E.g. { "$bar": "baz" }.
  * @return {string} The result of replacing all template variables e.g. '/foo/baz'.
  */
-export function encodeUri(pathTemplate: string, variables: Record<string, string>): string {
+export function encodeUri(pathTemplate: string, variables: Record<string, Optional<string>>): string {
     for (const key in variables) {
         if (!variables.hasOwnProperty(key)) {
             continue;
         }
+        const value = variables[key];
+        if (value === undefined || value === null) {
+            continue;
+        }
         pathTemplate = pathTemplate.replace(
-            key, encodeURIComponent(variables[key]),
+            key, encodeURIComponent(value),
         );
     }
     return pathTemplate;