@openclaw/matrix 2026.8.1-beta.3 → 2026.8.2

package/node_modules/matrix-js-sdk/src/matrixrtc/MatrixRTCSession.ts

@@ -35,6 +35,7 @@ import type {
     RTCCallIntent,
     Transport,
     SlotDescription,
+    RtcSlotEventContent,
 } from "./types.ts";
 import {
     MembershipManagerEvent,
@@ -309,6 +310,25 @@ export class MatrixRTCSession extends TypedEventEmitter<
         return computeSlotId(this.slotDescription);
     }
 
+    /**
+     * Reads the current slot state event's content for this session.
+     *
+     * @returns The slot event's content, or `undefined` if no slot event exists for this session.
+     */
+    public getRtcSlot(): RtcSlotEventContent | undefined {
+        return getSlotEventContent(this.roomSubset, this.slotDescription);
+    }
+
+    /**
+     * Whether this session's slot is closed.
+     *
+     * @returns `true` if the slot is closed, `false` if the slot is open or `undefined`
+     * if no slot exists.
+     */
+    public isSlotClosed(): boolean | undefined {
+        return isSlotClosed(this.roomSubset, this.slotDescription);
+    }
+
     /**
      * Returns all the call memberships for a room that match the provided `sessionDescription`,
      * oldest first.
@@ -325,7 +345,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
         const logger = rootLogger.getChild(
             `[MatrixRTCSession ${room.roomId} ${slotDescription.application}#${slotDescription.id}]`,
         );
-        const callMemberEvents = collectMembersEvents(room, options, logger);
+        const callMemberEvents = collectMembersEvents(room, slotDescription, options, logger);
 
         const callMemberships = await computeBackendIdentityAndVerifyMemberEvents(
             room,
@@ -424,6 +444,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
         );
 
         this.roomSubset.on(RoomStateEvent.Members, this.onRoomMemberUpdate);
+        this.roomSubset.on(RoomStateEvent.Events, this.onRoomStateEvent);
         this.roomSubset.on(RoomStickyEventsEvent.Update, this.onStickyEventUpdate);
 
         this.initialMembershipCalculated = this.ensureRecalculateSessionMembers();
@@ -448,6 +469,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
         }
 
         this.roomSubset.off(RoomStateEvent.Members, this.onRoomMemberUpdate);
+        this.roomSubset.off(RoomStateEvent.Events, this.onRoomStateEvent);
         this.roomSubset.off(RoomStickyEventsEvent.Update, this.onStickyEventUpdate);
     }
 
@@ -494,7 +516,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
                   )
                 : new MembershipManager(joinConfig, this.roomSubset, this.client, this.slotDescription, this.logger);
 
-            this.reEmitter.reEmit(this.membershipManager!, [
+            this.reEmitter.reEmit(this.membershipManager, [
                 MembershipManagerEvent.ProbablyLeft,
                 MembershipManagerEvent.StatusChanged,
                 MembershipManagerEvent.DelayIdChanged,
@@ -528,12 +550,12 @@ export class MatrixRTCSession extends TypedEventEmitter<
         this.pendingNotificationToSend = this.joinConfig?.notificationType;
 
         // Join!
-        this.membershipManager!.join(fociPreferred, multiSfuFocus, (e) => {
+        this.membershipManager.join(fociPreferred, multiSfuFocus, (e) => {
             this.logger.error("MembershipManager encountered an unrecoverable error: ", e);
             this.emit(MatrixRTCSessionEvent.MembershipManagerError, e);
             this.emit(MatrixRTCSessionEvent.JoinStateChanged, this.isJoined());
         });
-        this.encryptionManager!.join(joinConfig);
+        this.encryptionManager.join(joinConfig);
 
         this.emit(MatrixRTCSessionEvent.JoinStateChanged, true);
     }
@@ -714,6 +736,15 @@ export class MatrixRTCSession extends TypedEventEmitter<
         void this.ensureRecalculateSessionMembers();
     };
 
+    /**
+     * Call this when a room state event has been updated.
+     */
+    private readonly onRoomStateEvent = (event: MatrixEvent): void => {
+        if (event.getType() !== EventType.RTCSlot) return;
+        if (event.getStateKey() !== computeSlotId(this.slotDescription)) return;
+        void this.ensureRecalculateSessionMembers();
+    };
+
     /**
      * Call this when a sticky event update has occured.
      */
@@ -735,7 +766,6 @@ export class MatrixRTCSession extends TypedEventEmitter<
      * Call this when something changed that may impacts the current MatrixRTC members in this session.
      */
     // We allow this name schema since this function should only be used for testing purposes.
-    // eslint-disable-next-line @typescript-eslint/naming-convention
     public _onRTCSessionMemberUpdate = async (): Promise<void> => {
         await this.recalculateSessionMembers();
     };
@@ -899,17 +929,54 @@ function isValidMembership(
     return true;
 }
 
+/**
+ * Reads the slot state event's content for the given slot description.
+ *
+ * @returns The slot event's content, or `undefined` if no slot event exists for the given description.
+ */
+function getSlotEventContent(
+    room: Pick<Room, "getLiveTimeline">,
+    slotDescription: SlotDescription,
+): RtcSlotEventContent | undefined {
+    const slotId = computeSlotId(slotDescription);
+    const slotEvent = room
+        .getLiveTimeline()
+        .getState(EventTimeline.FORWARDS)
+        ?.getStateEvents(EventType.RTCSlot, slotId);
+    if (!slotEvent) return undefined;
+
+    return slotEvent.getContent<RtcSlotEventContent>();
+}
+
+/**
+ * Whether the given slot is closed.
+ *
+ * @returns `true` if the slot is closed, `false` if the slot is open or `undefined`
+ * if no slot exists.
+ */
+function isSlotClosed(room: Pick<Room, "getLiveTimeline">, slotDescription: SlotDescription): boolean | undefined {
+    const content = getSlotEventContent(room, slotDescription) as Partial<RtcSlotEventContent> | undefined;
+    if (content === undefined) return undefined;
+
+    return (
+        content.status !== "open" ||
+        typeof content.application !== "object" ||
+        content.application?.type !== slotDescription.application
+    );
+}
+
 /**
  * Collects the raw member events from room state and sticky store.
  */
 function collectMembersEvents(
     room: Pick<Room, "getLiveTimeline" | "roomId" | "_unstable_getStickyEvents">,
+    slotDescription: SlotDescription,
     options: SessionMembershipsForSlotOpts,
     logger: Logger,
 ): MatrixEvent[] {
     const { listenForStickyEvents, listenForMemberStateEvents } = options;
     let callMemberEvents: MatrixEvent[] = [];
-    if (listenForStickyEvents) {
+    if (listenForStickyEvents && !isSlotClosed(room, slotDescription)) {
         // prefill with sticky events
         callMemberEvents = [...room._unstable_getStickyEvents()].filter((e) => e.getType() === EventType.RTCMembership);
     }

package/node_modules/matrix-js-sdk/src/matrixrtc/MatrixRTCSessionManager.ts

@@ -22,7 +22,7 @@ import { RoomStateEvent } from "../models/room-state.ts";
 import { type MatrixEvent } from "../models/event.ts";
 import { MatrixRTCSession } from "./MatrixRTCSession.ts";
 import { EventType } from "../@types/event.ts";
-import { type SlotDescription } from "./types.ts";
+import { type RtcSlotEventContent, type SlotDescription } from "./types.ts";
 import { computeSlotId } from "./utils.ts";
 
 export enum MatrixRTCSessionManagerEvents {
@@ -98,6 +98,25 @@ export class MatrixRTCSessionManager extends TypedEventEmitter<MatrixRTCSessionM
         return this.roomSessions.get(room.roomId)!;
     }
 
+    /**
+     * Reads the current slot state event's content for the given room's session.
+     *
+     * @returns The slot event's content, or `undefined` if no slot event exists for the session.
+     */
+    public getRtcSlot(room: Room): RtcSlotEventContent | undefined {
+        return this.getRoomSession(room).getRtcSlot();
+    }
+
+    /**
+     * Whether the given room's slot is closed.
+     *
+     * @returns `true` if the slot is closed, `false` if the slot is open or `undefined`
+     * if no slot exists.
+     */
+    public isSlotClosed(room: Room): boolean | undefined {
+        return this.getRoomSession(room).isSlotClosed();
+    }
+
     /**
      * Gets the main MatrixRTC session for a room, returning an empty session
      * if no members are currently participating
@@ -129,7 +148,7 @@ export class MatrixRTCSessionManager extends TypedEventEmitter<MatrixRTCSessionM
     };
 
     private readonly onRoomState = (event: MatrixEvent): void => {
-        if (event.getType() !== EventType.GroupCallMemberPrefix) {
+        if (event.getType() !== EventType.GroupCallMemberPrefix && event.getType() !== EventType.RTCSlot) {
             return;
         }
         const room = this.client.getRoom(event.getRoomId());

package/node_modules/matrix-js-sdk/src/matrixrtc/MembershipManager.ts

@@ -284,7 +284,7 @@ export class MembershipManager
             this.logger.warn("Missing own membership: force re-join");
             this.state.hasMemberStateEvent = false;
 
-            if (this.scheduler.actions.some((a) => sendingMembershipActions.includes(a.type as MembershipActionType))) {
+            if (this.scheduler.actions.some((a) => sendingMembershipActions.includes(a.type))) {
                 this.logger.error(
                     "tried adding another `SendDelayedEvent` actions even though we already have one in the Queue\nActionQueueOnMemberUpdate:",
                     this.scheduler.actions,
@@ -1111,11 +1111,14 @@ export class StickyEventMembershipManager extends MembershipManager {
                 ...(this.callIntent ? { "m.call.intent": this.callIntent } : {}),
             },
             slot_id: computeSlotId(this.slotDescription),
-            // Make sure we do not add the alias to the transport.
-            // It is not needed in matrix2.0. The additional session information will be used to find the right alias on the sfu.
-            rtc_transports: livekitTransport
-                ? [{ type: livekitTransport.type, livekit_service_url: livekitTransport.livekit_service_url }]
-                : [],
+            transports: {
+                // Make sure we do not add the alias to the transport.
+                // It is not needed in matrix2.0. The additional session information will be used to find the right alias on the sfu.
+                published: livekitTransport
+                    ? [{ type: livekitTransport.type, livekit_service_url: livekitTransport.livekit_service_url }]
+                    : [],
+                can_subscribe: ["livekit"],
+            },
             member: { device_id: this.deviceId, user_id: this.userId, id: this.memberId },
             versions: [],
             ...relationObject,

package/node_modules/matrix-js-sdk/src/matrixrtc/MembershipManagerActionScheduler.ts

@@ -101,7 +101,7 @@ export class ActionScheduler {
                     );
                     try {
                         // `this.wakeup` can also be called and sets the `wakeupUpdate` object while we are in the handler.
-                        handlerResult = await this.membershipLoopHandler(nextAction.type as MembershipActionType);
+                        handlerResult = await this.membershipLoopHandler(nextAction.type);
                     } catch (e) {
                         // Preserve the original error as `cause`.
                         throw new Error(`The MembershipManager shut down because of the end condition: ${e}`, {

package/node_modules/matrix-js-sdk/src/matrixrtc/RTCEncryptionManager.ts

@@ -342,7 +342,7 @@ export class RTCEncryptionManager implements IEncryptionManager {
             })
             .map((membership) => {
                 return {
-                    userId: membership.sender!,
+                    userId: membership.sender,
                     deviceId: membership.deviceId,
                     membershipTs: membership.createdTs(),
                 };
@@ -446,7 +446,7 @@ export class RTCEncryptionManager implements IEncryptionManager {
 
     private nextKeyIndex(): number {
         if (this.outboundSession) {
-            return (this.outboundSession!.keyId + 1) % 256;
+            return (this.outboundSession.keyId + 1) % 256;
         }
         return 0;
     }

package/node_modules/matrix-js-sdk/src/matrixrtc/ToDeviceKeyTransport.ts

@@ -88,8 +88,8 @@ export class ToDeviceKeyTransport
         const targets = members
             .map((member) => {
                 return {
-                    userId: member.userId!,
-                    deviceId: member.deviceId!,
+                    userId: member.userId,
+                    deviceId: member.deviceId,
                 };
             })
             // filter out me
@@ -137,7 +137,7 @@ export class ToDeviceKeyTransport
             // TODO userId this is claimed information, deviceId is claimed information
             {
                 userId: fromUser,
-                deviceId: content.member.claimed_device_id!,
+                deviceId: content.member.claimed_device_id,
                 memberId: content.member.id ?? hardcodedMemberIdAlternative,
             },
             content.keys.key,

package/node_modules/matrix-js-sdk/src/matrixrtc/index.ts

@@ -20,5 +20,5 @@ export * from "./MatrixRTCSession.ts";
 export * from "./MatrixRTCSessionManager.ts";
 export type * from "./types.ts";
 export { type SessionMembershipData, type RtcMembershipData } from "./membershipData/index.ts";
-export { Status, parseCallNotificationContent, isMyMembership } from "./types.ts";
+export { Status, parseCallNotificationContent, isMyMembership, RTC_SLOT_ENCRYPTION_PER_MEMBER } from "./types.ts";
 export { MembershipManagerEvent } from "./IMembershipManager.ts";

package/node_modules/matrix-js-sdk/src/matrixrtc/membershipData/rtc.ts

@@ -17,7 +17,7 @@ limitations under the License.
 import { MXID_PATTERN } from "../../models/room-member.ts";
 import type { IContent } from "../../models/event.ts";
 import type { RelationType } from "../../types.ts";
-import { type RtcSlotEventContent, type Transport } from "../types.ts";
+import { type RtcSlotApplicationContent, type Transport } from "../types.ts";
 import { MatrixRTCMembershipParseError } from "./common.ts";
 import { sha256 } from "../../digest.ts";
 import { encodeUnpaddedBase64 } from "../../base64.ts";
@@ -37,8 +37,11 @@ export interface RtcMembershipData {
         event_id: string;
         rel_type: RelationType.Reference;
     };
-    "application": RtcSlotEventContent["application"];
-    "rtc_transports": Transport[];
+    "application": RtcSlotApplicationContent;
+    "transports": {
+        published: Transport[];
+        can_subscribe: string[];
+    };
     "versions": string[];
     "msc4354_sticky_key"?: string;
     "sticky_key"?: string;
@@ -97,17 +100,25 @@ export const checkRtcMembershipData = (data: IContent, sender: string): data is
             if (data.application.type.includes("#")) errors.push(prefix + 'application.type must not include "#"');
         }
     }
-    if (data.rtc_transports === undefined || !Array.isArray(data.rtc_transports)) {
-        errors.push(prefix + "rtc_transports must be an array");
+    if (typeof data.transports !== "object" || data.transports === null || !Array.isArray(data.transports.published)) {
+        errors.push(prefix + "transports.published must be an array");
     } else {
         // validate that each transport has at least a string 'type'
-        for (const t of data.rtc_transports) {
-            if (typeof t !== "object" || t === null || typeof (t as any).type !== "string") {
-                errors.push(prefix + "rtc_transports entries must be objects with a string type");
+        for (const t of data.transports.published) {
+            if (typeof t !== "object" || t === null || typeof t.type !== "string") {
+                errors.push(prefix + "transports.published entries must be objects with a string type");
                 break;
             }
         }
     }
+    if (
+        typeof data.transports !== "object" ||
+        data.transports === null ||
+        !Array.isArray(data.transports.can_subscribe) ||
+        !data.transports.can_subscribe.every((t: unknown) => typeof t === "string")
+    ) {
+        errors.push(prefix + "transports.can_subscribe must be an array of strings");
+    }
     if (data.versions === undefined || !Array.isArray(data.versions)) {
         errors.push(prefix + "versions must be an array");
     } else if (!data.versions.every((v) => typeof v === "string")) {

package/node_modules/matrix-js-sdk/src/matrixrtc/types.ts

@@ -201,15 +201,32 @@ export interface Transport {
 }
 
 /**
- * Event content for a `m.rtc.slot` state event.
+ * Event content for `org.matrix.msc4143.rtc.slot` state events.
  */
 export interface RtcSlotEventContent<T extends string = string> {
-    application: {
-        type: T;
-        // other application specific keys
-        [key: string]: unknown;
-    };
-    slot_id: string;
+    status: "open" | "closed";
+    application?: RtcSlotApplicationContent<T>;
+    encryption?: RtcSlotEncryptionContent;
+}
+
+/**
+ * Content of the `application` object within `org.matrix.msc4143.rtc.slot` events.
+ */
+export interface RtcSlotApplicationContent<T extends string = string> {
+    type: T;
+    // Other application specific keys.
+    [key: string]: unknown;
+}
+
+export const RTC_SLOT_ENCRYPTION_PER_MEMBER = "org.matrix.msc4143.per_member";
+
+/**
+ * Content of the `encryption` object within `org.matrix.msc4143.rtc.slot` events.
+ */
+export interface RtcSlotEncryptionContent {
+    type: typeof RTC_SLOT_ENCRYPTION_PER_MEMBER;
+    // Other encryption-mechanism specific keys.
+    [key: string]: unknown;
 }
 
 /**

package/node_modules/matrix-js-sdk/src/matrixrtc/utils.ts

@@ -24,8 +24,6 @@ export class OutdatedKeyFilter {
     // Map of participantId -> keyIndex -> timestamp
     private tsBuffer: Map<EncryptionKeyMapKey, Map<number, number>> = new Map();
 
-    public constructor() {}
-
     /**
      * Check if there is a recent key with the same keyId (index) and then use the creationTS to decide what to
      * do with the key. If the key received is older than the one already in the buffer, it is ignored.

package/node_modules/matrix-js-sdk/src/models/event-timeline-set.ts

@@ -526,9 +526,9 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
                 // that would happen, so I'm going to ignore it for now.
                 //
                 if (existingTimeline == neighbour) {
-                    debuglog("Event " + eventId + " in neighbouring timeline - " + "switching to " + existingTimeline);
+                    debuglog("Event " + eventId + " in neighbouring timeline - switching to " + existingTimeline);
                 } else {
-                    debuglog("Event " + eventId + " already in a different " + "timeline " + existingTimeline);
+                    debuglog("Event " + eventId + " already in a different timeline " + existingTimeline);
                 }
                 timeline = existingTimeline;
                 continue;
@@ -582,7 +582,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
             if (direction === EventTimeline.FORWARDS && timeline === this.liveTimeline) {
                 logger.warn({ lastEventWasNew, didUpdate }); // for debugging
                 logger.warn(
-                    `Refusing to set forwards pagination token of live timeline ` + `${timeline} to ${paginationToken}`,
+                    `Refusing to set forwards pagination token of live timeline ${timeline} to ${paginationToken}`,
                 );
                 return;
             }

package/node_modules/matrix-js-sdk/src/models/event.ts

@@ -50,7 +50,6 @@ import { type EmptyObject } from "../@types/common.ts";
 
 export { EventStatus } from "./event-status.ts";
 
-/* eslint-disable camelcase */
 export interface IContent {
     [key: string]: any;
     "msgtype"?: MsgType | string;
@@ -165,7 +164,6 @@ export interface IClearEvent {
     content: Omit<IContent, "membership" | "avatar_url" | "displayname" | "m.relates_to">;
     unsigned?: IUnsigned;
 }
-/* eslint-enable camelcase */
 
 interface IKeyRequestRecipient {
     userId: string;
@@ -438,17 +436,17 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         // of space if we don't intern it.
         (["state_key", "type", "sender", "room_id", "membership"] as const).forEach((prop) => {
             if (typeof event[prop] !== "string") return;
-            event[prop] = internaliseString(event[prop]!);
+            event[prop] = internaliseString(event[prop]);
         });
 
         (["membership", "avatar_url", "displayname"] as const).forEach((prop) => {
             if (typeof event.content?.[prop] !== "string") return;
-            event.content[prop] = internaliseString(event.content[prop]!);
+            event.content[prop] = internaliseString(event.content[prop]);
         });
 
         (["rel_type"] as const).forEach((prop) => {
             if (typeof event.content?.["m.relates_to"]?.[prop] !== "string") return;
-            event.content["m.relates_to"][prop] = internaliseString(event.content["m.relates_to"][prop]!);
+            event.content["m.relates_to"][prop] = internaliseString(event.content["m.relates_to"][prop]);
         });
 
         this.txnId = event.txn_id;
@@ -829,7 +827,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
         // if this is a state event, pack cleartext type and statekey
         if (this.isState()) {
-            this.event.state_key = `${this.clearEvent!.type}:${this.clearEvent!.state_key}`;
+            this.event.state_key = `${this.clearEvent.type}:${this.clearEvent.state_key}`;
         }
     }
 
@@ -938,7 +936,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         // `decryptionPromise`).
         await Promise.resolve();
 
-        // eslint-disable-next-line no-constant-condition
         while (true) {
             this.retryDecryption = false;
 
@@ -951,7 +948,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
                 this.setClearData(res);
                 this._decryptionFailureReason = null;
             } catch (e) {
-                const detailedError = e instanceof DecryptionError ? (<DecryptionError>e).detailedString : String(e);
+                const detailedError = e instanceof DecryptionError ? e.detailedString : String(e);
 
                 err = e as Error;
 
@@ -984,7 +981,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
                 this.setClearDataForDecryptionFailure(String(e));
                 this._decryptionFailureReason =
-                    e instanceof DecryptionError ? (<DecryptionError>e).code : DecryptionFailureCode.UNKNOWN_ERROR;
+                    e instanceof DecryptionError ? e.code : DecryptionFailureCode.UNKNOWN_ERROR;
             }
 
             // Make sure we clear 'decryptionPromise' before sending the 'Event.decrypted' event,
@@ -1257,10 +1254,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
             this.clearEvent = undefined;
         }
 
-        const keeps =
-            this.getType() in REDACT_KEEP_CONTENT_MAP
-                ? REDACT_KEEP_CONTENT_MAP[this.getType() as keyof typeof REDACT_KEEP_CONTENT_MAP]
-                : {};
+        const keeps = this.getType() in REDACT_KEEP_CONTENT_MAP ? REDACT_KEEP_CONTENT_MAP[this.getType()] : {};
         const content = this.getContent();
         for (const key in content) {
             if (content.hasOwnProperty(key) && !keeps[key]) {

package/node_modules/matrix-js-sdk/src/models/invites-ignorer.ts

@@ -252,7 +252,7 @@ export class IgnoredInvites {
             // `sources` could contain non-string / invalid room ids
             .filter((roomId) => typeof roomId === "string")
             .map((roomId) => this.client.getRoom(roomId))
-            .filter((room) => !!room) as Room[];
+            .filter((room) => !!room);
         if (sourceRooms.length != sources.length) {
             hasChanges = true;
         }

package/node_modules/matrix-js-sdk/src/models/poll.ts

@@ -176,7 +176,7 @@ export class Poll extends TypedEventEmitter<Exclude<PollEvent, PollEvent.New>, P
 
         const responses =
             this.responses ||
-            new Relations("m.reference", M_POLL_RESPONSE.name, this.matrixClient, [M_POLL_RESPONSE.altName!]);
+            new Relations("m.reference", M_POLL_RESPONSE.name, this.matrixClient, [M_POLL_RESPONSE.altName]);
 
         const pollEndEvent = allRelations.events.find((event) => M_POLL_END.matches(event.getType()));
 

package/node_modules/matrix-js-sdk/src/models/read-receipt.ts

@@ -325,7 +325,7 @@ export abstract class ReadReceipt<
         }
         this.receiptCacheByEventId.get(eventId)!.push({
             userId: userId,
-            type: receiptType as ReceiptType,
+            type: receiptType,
             data: receipt,
         });
     }

package/node_modules/matrix-js-sdk/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/node_modules/matrix-js-sdk/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;