matrix-js-sdk 42.1.0 → 42.2.0

package/src/models/relations-container.ts

@@ -20,6 +20,7 @@ import { EventStatus, type MatrixEvent, MatrixEventEvent } from "./event.ts";
 import { type EventTimelineSet } from "./event-timeline-set.ts";
 import { type MatrixClient } from "../client.ts";
 import { type Room } from "./room.ts";
+import { logger } from "../logger.ts";
 
 export class RelationsContainer {
     // A tree of objects to access a set of related children for an event, as in:
@@ -89,29 +90,58 @@ export class RelationsContainer {
      * @param event - The new child event to be aggregated.
      * @param timelineSet - The event timeline set within which to search for the related event if any.
      */
-    public aggregateChildEvent(event: MatrixEvent, timelineSet?: EventTimelineSet): void {
+    public aggregateChildEvent(event: MatrixEvent, timelineSet?: EventTimelineSet): void;
+    /**
+     * Add a relation event using a known target that is not in the timeline yet.
+     *
+     * @param event - The new child event to be aggregated.
+     * @param timelineSet - The event timeline set within which to search for the related event.
+     * @param targetEvent - The known relation target.
+     * @returns A promise which resolves after aggregation.
+     */
+    public aggregateChildEvent(
+        event: MatrixEvent,
+        timelineSet: EventTimelineSet,
+        targetEvent: MatrixEvent,
+    ): Promise<void>;
+    public aggregateChildEvent(
+        event: MatrixEvent,
+        timelineSet?: EventTimelineSet,
+        targetEvent?: MatrixEvent,
+    ): void | Promise<void> {
+        const aggregation = this.aggregateChildEventInternal(event, timelineSet, targetEvent);
+        if (targetEvent) return aggregation;
+
+        void aggregation.catch((error) => logger.error("Failed to aggregate child event: ", error));
+    }
+
+    private aggregateChildEventInternal(
+        event: MatrixEvent,
+        timelineSet?: EventTimelineSet,
+        targetEvent?: MatrixEvent,
+    ): Promise<void> {
         if (event.isRedacted() || event.status === EventStatus.CANCELLED) {
-            return;
+            return Promise.resolve();
         }
 
         const relation = event.getRelation();
-        if (!relation) return;
-
-        const onEventDecrypted = (): void => {
-            if (event.isDecryptionFailure()) {
-                // This could for example happen if the encryption keys are not yet available.
-                // The event may still be decrypted later. Register the listener again.
-                event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
-                return;
-            }
-
-            this.aggregateChildEvent(event, timelineSet);
-        };
+        if (!relation) return Promise.resolve();
 
         // If the event is currently encrypted, wait until it has been decrypted.
         if (event.isBeingDecrypted() || event.shouldAttemptDecryption()) {
-            event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
-            return;
+            return new Promise<void>((resolve, reject) => {
+                const onEventDecrypted = (): void => {
+                    if (event.isDecryptionFailure()) {
+                        // This could for example happen if the encryption keys are not yet available.
+                        // The event may still be decrypted later. Register the listener again.
+                        event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
+                        return;
+                    }
+
+                    void this.aggregateChildEventInternal(event, timelineSet, targetEvent).then(resolve, reject);
+                };
+                event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
+            });
         }
 
         const { event_id: relatesToEventId, rel_type: relationType } = relation;
@@ -130,20 +160,26 @@ export class RelationsContainer {
         }
 
         let relationsWithEventType = relationsWithRelType.get(eventType);
+        const isNewRelationCollection = !relationsWithEventType;
+        let targetEventUpdate = Promise.resolve();
         if (!relationsWithEventType) {
             relationsWithEventType = new Relations(relationType!, eventType, this.client);
             relationsWithRelType.set(eventType, relationsWithEventType);
+        }
 
+        if (isNewRelationCollection || targetEvent) {
             const room = this.room ?? timelineSet?.room;
             const relatesToEvent =
                 timelineSet?.findEventById(relatesToEventId!) ??
                 room?.findEventById(relatesToEventId!) ??
-                room?.getPendingEvent(relatesToEventId!);
+                room?.getPendingEvent(relatesToEventId!) ??
+                targetEvent;
             if (relatesToEvent) {
-                relationsWithEventType.setTargetEvent(relatesToEvent);
+                targetEventUpdate = relationsWithEventType.setTargetEvent(relatesToEvent);
             }
         }
 
-        relationsWithEventType.addEvent(event);
+        const addEventUpdate = relationsWithEventType.addEvent(event);
+        return Promise.all([targetEventUpdate, addEventUpdate]).then(() => undefined);
     }
 }

package/src/models/relations.ts

@@ -336,7 +336,7 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
      * @param targetEvent - the event the relations are related to.
      */
     public async setTargetEvent(event: MatrixEvent): Promise<void> {
-        if (this.targetEvent) {
+        if (this.targetEvent === event) {
             return;
         }
         this.targetEvent = event;

package/src/models/room.ts

@@ -939,7 +939,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     private getFunctionalMembers(): string[] {
         const mFunctionalMembers = this.currentState.getStateEvents(UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, "");
         if (Array.isArray(mFunctionalMembers?.getContent().service_members)) {
-            return mFunctionalMembers!.getContent().service_members;
+            return mFunctionalMembers.getContent().service_members;
         }
         return [];
     }
@@ -949,7 +949,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
         // Only generate a fallback avatar if the conversation is with a single specific other user (a "DM").
         let nonFunctionalMemberCount = 0;
-        this.getMembers()!.forEach((m) => {
+        this.getMembers().forEach((m) => {
             if (m.membership !== "join" && m.membership !== "invite") return;
             if (functionalMembers.includes(m.userId)) return;
             nonFunctionalMemberCount++;
@@ -1070,7 +1070,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         if (rawMembersEvents === null || this.hasEncryptionStateEvent()) {
             fromServer = true;
             rawMembersEvents = await this.loadMembersFromServer();
-            logger.log(`LL: got ${rawMembersEvents.length} ` + `members from server for room ${this.roomId}`);
+            logger.log(`LL: got ${rawMembersEvents.length} members from server for room ${this.roomId}`);
         }
         const memberEvents = rawMembersEvents.filter(noUnsafeEventProps).map(this.client.getEventMapper());
         return { memberEvents, fromServer };
@@ -1129,7 +1129,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                         .getMembers()
                         .filter((m) => m.isOutOfBand())
                         .map((m) => m.events.member?.event as IStateEventWithRoomId);
-                    logger.log(`LL: telling store to write ${oobMembers.length}` + ` members for room ${this.roomId}`);
+                    logger.log(`LL: telling store to write ${oobMembers.length} members for room ${this.roomId}`);
                     const store = this.client.store;
                     return (
                         store
@@ -1171,7 +1171,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      */
     private cleanupAfterLeaving(): void {
         this.clearLoadedMembersIfNeeded().catch((err) => {
-            logger.error(`error after clearing loaded members from ` + `room ${this.roomId} after leaving`);
+            logger.error(`error after clearing loaded members from room ${this.roomId} after leaving`);
             logger.log(err);
         });
     }
@@ -2078,7 +2078,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         };
 
         if (filterType === ThreadFilterType.My) {
-            definition!.room!.timeline![FILTER_RELATED_BY_SENDERS.name] = [myUserId];
+            definition.room!.timeline![FILTER_RELATED_BY_SENDERS.name] = [myUserId];
         }
 
         filter.setDefinition(definition);
@@ -2410,7 +2410,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         const threadRootId = event.threadRootId;
 
         // Where the parent is the thread root and this is a non-thread relation this should live only in the main timeline
-        if (!!parentEventId && !isThreadRelation && (threadRootId === parentEventId || roots?.has(parentEventId!))) {
+        if (!!parentEventId && !isThreadRelation && (threadRootId === parentEventId || roots?.has(parentEventId))) {
             return {
                 shouldLiveInRoom: true,
                 shouldLiveInThread: false,
@@ -3208,7 +3208,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             );
         } else {
             // When `threadSupport` is disabled treat all events as timelineEvents
-            return [events as MatrixEvent[], [] as MatrixEvent[], [] as MatrixEvent[]];
+            return [events, [] as MatrixEvent[], [] as MatrixEvent[]];
         }
     }
 
@@ -3240,7 +3240,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         Object.keys(content).forEach((eventId: string) => {
             Object.keys(content[eventId]).forEach((receiptType: ReceiptType | string) => {
                 Object.keys(content[eventId][receiptType]).forEach((userId: string) => {
-                    const receipt = content[eventId][receiptType][userId] as Receipt;
+                    const receipt = content[eventId][receiptType][userId];
                     const receiptForMainTimeline = !receipt.thread_id || receipt.thread_id === MAIN_ROOM_TIMELINE;
                     const receiptDestination: Thread | this | undefined = receiptForMainTimeline
                         ? this

package/src/models/thread.ts

@@ -132,6 +132,8 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
      */
     public initialEventsFetched = !Thread.hasServerSideSupport;
     private initalEventFetchProm: Promise<boolean> | undefined;
+    private preInitEventTargets = new Map<string, MatrixEvent>();
+    private preInitObserverState = { active: true };
 
     /**
      * An array of events to add to the timeline once the thread has been initialised
@@ -170,6 +172,9 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
         this.reEmitter = new TypedReEmitter(this);
 
         this.reEmitter.reEmit(this.timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
+        this.once(ThreadEvent.Delete, () => {
+            this.preInitObserverState.active = false;
+        });
 
         this.room.on(MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);
         this.room.on(RoomEvent.Redaction, this.onRedaction);
@@ -364,10 +369,19 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
         // Modify this event to point at our room's state, and mark its thread
         // as this.
         this.setEventMetadata(event);
+        const eventId = event.getId();
+        if (
+            !this.initialEventsFetched &&
+            eventId &&
+            !event.isRelation(RelationType.Annotation) &&
+            !event.isRelation(RelationType.Replace)
+        ) {
+            this.preInitEventTargets.set(eventId, event);
+        }
 
         // Decide whether this event is going to be added at the end of the timeline.
         const lastReply = this.lastReply();
-        const isNewestReply = !lastReply || event.localTimestamp >= lastReply!.localTimestamp;
+        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.
@@ -438,12 +452,33 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
              */
             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.
+            // Aggregate annotations immediately to keep reaction counts visible.
             if (event.isRelation(RelationType.Annotation)) {
                 this.timelineSet.relations?.aggregateChildEvent(event, this.timelineSet);
             }
+
+            // Edits can also be aggregated immediately when their target is already
+            // known. If it is not known yet, replay still handles them after pagination.
+            if (event.isRelation(RelationType.Replace)) {
+                const targetEventId = event.getRelation()?.event_id;
+                const targetEvent = targetEventId ? this.findPreInitTargetEvent(targetEventId) : undefined;
+                if (targetEvent && targetEventId) {
+                    const weakThread = new WeakRef(this);
+                    const observerState = this.preInitObserverState;
+                    const eventId = event.getId();
+                    void this.timelineSet.relations
+                        .aggregateChildEvent(event, this.timelineSet, targetEvent)
+                        .then(() => {
+                            const thread = weakThread.deref();
+                            if (!thread || !observerState.active) return;
+                            const effectiveTarget = thread.findPreInitTargetEvent(targetEventId);
+                            if (effectiveTarget?.replacingEvent()?.getId() === eventId) {
+                                thread.emit(ThreadEvent.Update, thread);
+                            }
+                        })
+                        .catch((error) => logger.error("Failed to aggregate pre-initialization thread edit: ", error));
+                }
+            }
         } else {
             // Case 2: this is happening later, and we have a timeline. In
             // this case, these events might be out-of order.
@@ -474,6 +509,15 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
         }
     }
 
+    private findPreInitTargetEvent(eventId: string): MatrixEvent | undefined {
+        return (
+            this.timelineSet.findEventById(eventId) ??
+            this.room.findEventById(eventId) ??
+            this.preInitEventTargets.get(eventId) ??
+            (this.lastEvent?.getId() === eventId ? this.lastEvent : undefined)
+        );
+    }
+
     public async processEvent(event: MatrixEvent | null | undefined): Promise<void> {
         if (event) {
             this.setEventMetadata(event);
@@ -642,6 +686,7 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
                         this.addEvent(event, false);
                     }
                     this.replayEvents = null;
+                    this.preInitEventTargets.clear();
                     // 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);

package/src/oauth/authorize.ts

@@ -24,7 +24,7 @@ import {
     hasRequiredStringProperty,
     isRecord,
 } from "../@types/type-guards.ts";
-import { Method } from "../http-api";
+import { Method } from "../http-api/index.ts";
 import { OAuthGrantType } from "./register.ts";
 import { sleep } from "../utils.ts";
 

package/src/oauth/index.ts

@@ -34,7 +34,7 @@ import {
 } from "./register.ts";
 import { encodeUnpaddedBase64Url } from "../base64.ts";
 import { sha256 } from "../digest.ts";
-import { HTTPError, Method } from "../http-api";
+import { HTTPError, Method } from "../http-api/index.ts";
 import { logger } from "../logger.ts";
 import { OAuth2Error } from "./error.ts";
 import { secureRandomString } from "../randomstring.ts";
@@ -126,7 +126,7 @@ export class OAuth2 {
                 throw error;
             } else {
                 logger.error("Dynamic registration request failed", error);
-                throw new Error(OAuth2Error.DynamicRegistrationFailed);
+                throw new Error(OAuth2Error.DynamicRegistrationFailed, { cause: error });
             }
         }
     }

package/src/pollingCachedValue.ts

@@ -0,0 +1,184 @@
+/*
+Copyright 2026 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { calculateRetryBackoff } from "./http-api/index.ts";
+import { type Logger } from "./logger.ts";
+import { sleep } from "./utils.ts";
+
+/**
+ * How to fetch and cache a given value, as passed to {@link PollingCachedValue}.
+ */
+export interface PollingCachedValueOptions<ValueType> {
+    /** The name of the cached value (for tracing/logs). */
+    name: string;
+    /** The logger to derive this value's child logger from. */
+    logger: Logger;
+    /** Fetches a fresh value. Rejections are retried according to the retry policy. */
+    fetch: () => Promise<ValueType>;
+    /**
+     * The default time-to-live before the value gets refreshed, overridable per run
+     * via {@link PollingCachedValue.start}.
+     * If undefined the value never expires; use {@link PollingCachedValue.refresh} to clear the cache.
+     */
+    ttlMillis?: number;
+    /** Called when a new value is cached. Use to emit changes if needed. */
+    onValueCached?: (value: ValueType) => void;
+    /**
+     * Determines whether a non-transient error should be cached.
+     * By default errors are not cached, i.e. the next attempt retries the fetch.
+     */
+    shouldCacheError?: (error: unknown) => boolean;
+}
+
+/**
+ * Defines a generic mechanism to fetch and cache a value, refreshing it periodically.
+ */
+export class PollingCachedValue<ValueType> {
+    private cached?: ValueType;
+    private fetchPromise?: Promise<ValueType>;
+    private ttlTimeoutHandle?: ReturnType<typeof setTimeout>;
+
+    private isStopped = false;
+    private ttlMillis?: number;
+
+    private readonly logger: Logger;
+
+    /**
+     * Build a generic mechanism allowing to fetch and cache a given value.
+     * @param opts - Describes what to fetch and how to cache it, see {@link PollingCachedValueOptions}.
+     */
+    public constructor(private readonly opts: PollingCachedValueOptions<ValueType>) {
+        this.ttlMillis = opts.ttlMillis;
+        this.logger = opts.logger.getChild(`PollingCachedValue<${opts.name}>`);
+    }
+
+    /**
+     * Gets the cached value if any.
+     */
+    public get(): ValueType | undefined {
+        return this.cached;
+    }
+
+    /**
+     * Ensures that the value was fetched once before getting the actual cached value.
+     */
+    public async wait(): Promise<ValueType | undefined> {
+        await this.doFetch();
+        return this.cached;
+    }
+
+    /**
+     * Call this as early as possible and when the value can already be fetched.
+     * @param ttlMillis - The time-to-live before the value gets refreshed, overriding the one
+     *     given at construction. If omitted the configured default is kept.
+     */
+    public start(ttlMillis?: number): void {
+        if (ttlMillis !== undefined) {
+            this.ttlMillis = ttlMillis;
+        }
+        this.isStopped = false;
+        // Request a fetch as soon as possible
+        this.doFetch().catch((err) => {
+            this.logger.debug("Cached value fetch on start did fail", err);
+        });
+    }
+    /**
+     * Call when the client is stopped, or when the cached value is no longer needed.
+     */
+    public stop(): void {
+        if (this.ttlTimeoutHandle) {
+            clearTimeout(this.ttlTimeoutHandle);
+        }
+        this.isStopped = true;
+    }
+
+    /**
+     * Force to refresh.
+     * @throws
+     */
+    public async refresh(): Promise<ValueType | undefined> {
+        await this.doFetch(true);
+        return this.cached;
+    }
+
+    /**
+     * Internal fetch method
+     * @param force - if set to true will force a fetch of the value even if a fetch is already in progress.
+     * @private
+     */
+    private async doFetch(force: boolean = false): Promise<void> {
+        if (this.fetchPromise && !force) {
+            await this.fetchPromise;
+            return;
+        }
+
+        this.fetchPromise = this.fetchWithRetryPolicy();
+
+        try {
+            this.cached = await this.fetchPromise;
+            if (this.isStopped) {
+                this.fetchPromise = undefined;
+                return;
+            }
+            this.logger.trace(`New cachedValue: ${this.cached}`);
+            this.opts.onValueCached?.(this.cached);
+            // The value is cached only for a given time.
+            if (this.ttlMillis) {
+                this.ttlTimeoutHandle = setTimeout(() => {
+                    this.fetchPromise = undefined;
+                    void this.doFetch();
+                }, this.ttlMillis);
+            }
+        } catch (error) {
+            this.logger.debug(`Error fetching server value for ${error}`);
+            if (this.isStopped) {
+                this.fetchPromise = undefined;
+                return;
+            }
+            if (!this.opts.shouldCacheError?.(error)) {
+                // clear the promise, i.e next tentative will retry to fetch
+                this.fetchPromise = undefined;
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Gracefully handle transient error retries, respect retry_after_millis for rate limits.
+     * @private
+     */
+    private async fetchWithRetryPolicy(): Promise<ValueType> {
+        let currentRetryCount = 0;
+        while (true) {
+            try {
+                return await this.opts.fetch();
+            } catch (e) {
+                this.logger.trace(`Failed to fetch retry: ${e}`);
+                if (this.isStopped) {
+                    throw e;
+                }
+                currentRetryCount++;
+                const backoff = calculateRetryBackoff(e, currentRetryCount, true);
+                if (backoff < 0) {
+                    // Max number of retries reached, or error is not retryable. rethrow the error
+                    throw e;
+                }
+                // wait for the specified time and then retry the request
+                await sleep(backoff);
+            }
+        }
+    }
+}

package/src/pushprocessor.ts

@@ -294,7 +294,7 @@ export class PushProcessor {
         // These lines are mostly to make the tests happy. We shouldn't run into these
         // properties missing in practice.
         if (!newRules) newRules = {} as IPushRules;
-        if (!newRules.global) newRules.global = {} as PushRuleSet;
+        if (!newRules.global) newRules.global = {};
         if (!newRules.global.override) newRules.global.override = [];
         if (!newRules.global.underride) newRules.global.underride = [];
 
@@ -349,7 +349,7 @@ export class PushProcessor {
         // These lines are mostly to make the tests happy. We shouldn't run into these
         // properties missing in practice.
         if (!newRules) newRules = {} as IPushRules;
-        if (!newRules.global) newRules.global = {} as PushRuleSet;
+        if (!newRules.global) newRules.global = {};
         if (!newRules.global.override) newRules.global.override = [];
         if (!newRules.global.room) newRules.global.room = [];
         if (!newRules.global.sender) newRules.global.sender = [];
@@ -846,7 +846,7 @@ export class PushProcessor {
             for (const kind of RULEKINDS_IN_ORDER) {
                 if (this.client.pushRules[scope][kind] === undefined) continue;
 
-                for (const rule of this.client.pushRules[scope][kind]!) {
+                for (const rule of this.client.pushRules[scope][kind]) {
                     if (rule.rule_id === ruleId) return { rule, kind };
                 }
             }

package/src/receipt-accumulator.ts

@@ -17,7 +17,6 @@ limitations under the License.
 import { type IMinimalEvent } from "./sync-accumulator.ts";
 import { EventType } from "./@types/event.ts";
 import { isSupportedReceiptType, MapWithDefault, recursiveMapToObject } from "./utils.ts";
-import { type IContent } from "./models/event.ts";
 import { type ReceiptContent, type ReceiptType } from "./@types/read_receipts.ts";
 
 interface AccumulatedReceipt {
@@ -162,7 +161,7 @@ export class ReceiptAccumulator {
             room_id: roomId,
             content: {
                 // $event_id: { "m.read": { $user_id: $json } }
-            } as IContent,
+            },
         };
 
         const receiptEventContent: MapWithDefault<

package/src/rendezvous/MSC4108SignInWithQR.ts

@@ -385,7 +385,7 @@ export class MSC4108SignInWithQR {
             );
         }
         if (payload.type === PayloadType.Failure) {
-            throw new RendezvousError("Failed", (payload as FailurePayload).reason);
+            throw new RendezvousError("Failed", payload.reason);
         }
         if (payload.type !== PayloadType.ProtocolAccepted) {
             throw new RendezvousError("Unexpected message received", MSC4108FailureReason.UnexpectedMessageReceived);
@@ -412,11 +412,10 @@ export class MSC4108SignInWithQR {
             } else if (res.error === "access_denied") {
                 reason = MSC4108FailureReason.UserCancelled;
             }
-            const payload: FailurePayload = {
+            await this.send({
                 type: PayloadType.Failure,
                 reason,
-            };
-            await this.send(payload);
+            } satisfies FailurePayload);
 
             throw new RendezvousError("Rejection from device authorization endpoint", reason);
         }

package/src/rtcTransportsCachedValue.ts

@@ -0,0 +1,40 @@
+/*
+Copyright 2026 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { PollingCachedValue } from "./pollingCachedValue.ts";
+import { type Transport } from "./matrixrtc/index.ts";
+import { ClientEvent, type MatrixClient } from "./client.ts";
+import { type Logger } from "./logger.ts";
+import { MatrixError } from "./http-api/index.ts";
+
+const TRANSPORT_CACHE_TTL_MILLISECONDS = 1000 * 60 * 60 * 24; // 1 day
+
+/**
+ * Builds a cache for the rtc/transport discovery end-point of the given client.
+ */
+export function createRtcTransportsCachedValue(client: MatrixClient, logger: Logger): PollingCachedValue<Transport[]> {
+    return new PollingCachedValue({
+        name: "RTCTransports",
+        logger,
+        ttlMillis: TRANSPORT_CACHE_TTL_MILLISECONDS,
+        fetch: () => client._unstable_getRTCTransports(),
+        onValueCached: (transports) => client.emit(ClientEvent.RtcTransportsUpdated, transports),
+        // If the end point is not supported by the homeserver it will be a 404 error.
+        // This is a final error, it can be cached, no need to retry everytime.
+        // It will retry when ttl has expired.
+        shouldCacheError: (error) => error instanceof MatrixError && error.httpStatus === 404,
+    });
+}

package/src/rust-crypto/PerSessionKeyBackupDownloader.ts

@@ -394,7 +394,7 @@ export class PerSessionKeyBackupDownloader {
     ): Promise<void> {
         const sessionsToImport: Record<string, KeyBackupSession> = { [sessionInfo.megolmSessionId]: data };
 
-        const keys = await configuration!.decryptor.decryptSessions(sessionsToImport);
+        const keys = await configuration.decryptor.decryptSessions(sessionsToImport);
         for (const k of keys) {
             k.room_id = sessionInfo.roomId;
         }

package/src/rust-crypto/backup.ts

@@ -23,7 +23,6 @@ import {
     type KeyBackupCheck,
     type KeyBackupInfo,
     type KeyBackupSession,
-    type Curve25519SessionData,
     type KeyBackupRestoreOpts,
     type KeyBackupRestoreResult,
     type KeyBackupRoomSessions,
@@ -42,7 +41,6 @@ import {
     CryptoEvent,
     ImportRoomKeyStage,
 } from "../crypto-api/index.ts";
-import { type AESEncryptedSecretStoragePayload } from "../@types/AESEncryptedSecretStoragePayload.ts";
 import { type IMegolmSessionData } from "../@types/crypto.ts";
 
 /** Authentification of the backup info, depends on algorithm */
@@ -901,9 +899,7 @@ export class RustBackupDecryptor implements BackupDecryptor {
     /**
      * Implements {@link BackupDecryptor#decryptSessions}
      */
-    public async decryptSessions(
-        ciphertexts: Record<string, KeyBackupSession<Curve25519SessionData | AESEncryptedSecretStoragePayload>>,
-    ): Promise<IMegolmSessionData[]> {
+    public async decryptSessions(ciphertexts: Record<string, KeyBackupSession>): Promise<IMegolmSessionData[]> {
         const keys: IMegolmSessionData[] = [];
         for (const [sessionId, sessionData] of Object.entries(ciphertexts)) {
             try {