v15.2.1

Prepare changelog for v15.2.1
Update olm to 3.2.8 (#2062 )
2021-12-13 15:17:37 +00:00 · 2021-12-13 15:17:37 +00:00 · 2021-12-13 14:59:03 +00:00 · 2021-12-06 15:10:51 +00:00 · 2021-12-06 15:10:50 +00:00 · 2021-11-30 18:16:24 +00:00
28 changed files with 810 additions and 310 deletions
@@ -1,3 +1,60 @@
+Changes in [15.2.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.1) (2021-12-13)
+==================================================================================================
+
+ * Security release with updated version of Olm to fix https://matrix.org/blog/2021/12/03/pre-disclosure-upcoming-security-release-of-libolm-and-matrix-js-sdk
+
+Changes in [15.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.0) (2021-12-06)
+==================================================================================================
+
+## ✨ Features
+ * Remove support for `ArrayBuffer` in unstable MSC3089 `createFile()` and `createNewVersion()` and instead use same content types as handled by `MatrixClient.uploadContent()`. This enables support for Node.js. ([\#2014](https://github.com/matrix-org/matrix-js-sdk/pull/2014)).
+ * Support for password-based backup on Node.js ([\#2021](https://github.com/matrix-org/matrix-js-sdk/pull/2021)).
+ * Add optional force parameter when ensuring Olm sessions ([\#2027](https://github.com/matrix-org/matrix-js-sdk/pull/2027)).
+
+## 🐛 Bug Fixes
+ * Fix call upgrades ([\#2024](https://github.com/matrix-org/matrix-js-sdk/pull/2024)). Contributed by @SimonBrandner.
+
+Changes in [15.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.0-rc.1) (2021-11-30)
+============================================================================================================
+
+## ✨ Features
+ * Remove support for `ArrayBuffer` in unstable MSC3089 `createFile()` and `createNewVersion()` and instead use same content types as handled by `MatrixClient.uploadContent()`. This enables support for Node.js. ([\#2014](https://github.com/matrix-org/matrix-js-sdk/pull/2014)).
+ * Support for password-based backup on Node.js ([\#2021](https://github.com/matrix-org/matrix-js-sdk/pull/2021)).
+ * Add optional force parameter when ensuring Olm sessions ([\#2027](https://github.com/matrix-org/matrix-js-sdk/pull/2027)).
+
+## 🐛 Bug Fixes
+ * Fix call upgrades ([\#2024](https://github.com/matrix-org/matrix-js-sdk/pull/2024)). Contributed by @SimonBrandner.
+
+Changes in [15.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.1) (2021-11-22)
+==================================================================================================
+
+## 🐛 Bug Fixes
+ * Fix edit history being broken after editing an unencrypted event with an encrypted event ([\#2013](https://github.com/matrix-org/matrix-js-sdk/pull/2013)). Fixes vector-im/element-web#19651 and vector-im/element-web#19651. Contributed by @aaronraimist.
+ * Make events pagination responses parse threads ([\#2011](https://github.com/matrix-org/matrix-js-sdk/pull/2011)). Fixes vector-im/element-web#19587 and vector-im/element-web#19587.
+
+Changes in [15.1.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.1-rc.1) (2021-11-17)
+============================================================================================================
+
+## 🐛 Bug Fixes
+ * Fix edit history being broken after editing an unencrypted event with an encrypted event ([\#2013](https://github.com/matrix-org/matrix-js-sdk/pull/2013)). Fixes vector-im/element-web#19651 and vector-im/element-web#19651. Contributed by @aaronraimist.
+ * Make events pagination responses parse threads ([\#2011](https://github.com/matrix-org/matrix-js-sdk/pull/2011)). Fixes vector-im/element-web#19587 and vector-im/element-web#19587.
+
+Changes in [15.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.0) (2021-11-08)
+==================================================================================================
+
+## 🦖 Deprecations
+ * Mark old verification methods as deprecated ([\#1994](https://github.com/matrix-org/matrix-js-sdk/pull/1994)).
+
+## ✨ Features
+ * Try to set a sender on search result events if possible ([\#2004](https://github.com/matrix-org/matrix-js-sdk/pull/2004)).
+ * Port some changes from group calls branch to develop ([\#2001](https://github.com/matrix-org/matrix-js-sdk/pull/2001)). Contributed by @SimonBrandner.
+ * Fetch room membership from server rather than relying on stored data ([\#1998](https://github.com/matrix-org/matrix-js-sdk/pull/1998)).
+ * Add method to fetch the MSC3266 Room Summary of a Room ([\#1988](https://github.com/matrix-org/matrix-js-sdk/pull/1988)).
+
+## 🐛 Bug Fixes
+ * Don't show `Unable to access microphone` when cancelling screensharing dialog ([\#2005](https://github.com/matrix-org/matrix-js-sdk/pull/2005)). Fixes vector-im/element-web#19533 and vector-im/element-web#19533. Contributed by @SimonBrandner.
+ * Strip direction override characters from display names ([\#1992](https://github.com/matrix-org/matrix-js-sdk/pull/1992)). Fixes vector-im/element-web#1712 and vector-im/element-web#1712.
+
 Changes in [15.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.0-rc.1) (2021-11-02)
 ============================================================================================================

@@ -1,6 +1,6 @@
 {
  "name": "matrix-js-sdk",
-  "version": "15.1.0-rc.1",
+  "version": "15.2.1",
  "description": "Matrix Client-Server SDK for Javascript",
  "scripts": {
    "prepublishOnly": "yarn build",
@@ -74,14 +74,14 @@
    "@babel/preset-env": "^7.12.11",
    "@babel/preset-typescript": "^7.12.7",
    "@babel/register": "^7.12.10",
-    "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.3.tgz",
+    "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.8.tgz",
    "@types/bs58": "^4.0.1",
    "@types/jest": "^26.0.20",
    "@types/node": "12",
    "@types/request": "^2.48.5",
    "@typescript-eslint/eslint-plugin": "^4.17.0",
    "@typescript-eslint/parser": "^4.17.0",
-    "allchange": "^1.0.5",
+    "allchange": "^1.0.6",
    "babel-jest": "^26.6.3",
    "babelify": "^10.0.0",
    "better-docs": "^2.4.0-beta.9",
@@ -1,27 +0,0 @@
-/*
-Copyright 2021 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.
-*/
-
-export class MockBlob {
-    private contents: number[] = [];
-
-    public constructor(private parts: ArrayLike<number>[]) {
-        parts.forEach(p => Array.from(p).forEach(e => this.contents.push(e)));
-    }
-
-    public get size(): number {
-        return this.contents.length;
-    }
-}
@@ -23,7 +23,7 @@ describe("MatrixClient retrying", function() {
        );
        httpBackend = testClient.httpBackend;
        client = testClient.client;
-        room = new Room(roomId);
+        room = new Room(roomId, client, userId);
        client.store.storeRoom(room);
    });

@@ -50,7 +50,10 @@ describe("MatrixClient retrying", function() {

    it("should mark events as EventStatus.CANCELLED when cancelled", function() {
        // send a couple of events; the second will be queued
-        const p1 = client.sendMessage(roomId, "m1").then(function(ev) {
+        const p1 = client.sendMessage(roomId, {
+            "msgtype": "m.text",
+            "body": "m1",
+        }).then(function(ev) {
            // we expect the first message to fail
            throw new Error('Message 1 unexpectedly sent successfully');
        }, (e) => {
@@ -60,7 +63,10 @@ describe("MatrixClient retrying", function() {
        // XXX: it turns out that the promise returned by this message
        // never gets resolved.
        // https://github.com/matrix-org/matrix-js-sdk/issues/496
-        client.sendMessage(roomId, "m2");
+        client.sendMessage(roomId, {
+            "msgtype": "m.text",
+            "body": "m2",
+        });

        // both events should be in the timeline at this point
        const tl = room.getLiveTimeline().getEvents();
@@ -88,7 +94,7 @@ describe("MatrixClient retrying", function() {
        }).respond(400); // fail the first message

        // wait for the localecho of ev1 to be updated
-        const p3 = new Promise((resolve, reject) => {
+        const p3 = new Promise<void>((resolve, reject) => {
            room.on("Room.localEchoUpdated", (ev0) => {
                if (ev0 === ev1) {
                    resolve();
@@ -244,8 +244,7 @@ describe("MSC3089Branch", () => {

    it('should create new versions of itself', async () => {
        const canaryName = "canary";
-        const fileContents = "contents go here";
-        const canaryContents = Uint8Array.from(Array.from(fileContents).map((_, i) => fileContents.charCodeAt(i)));
+        const canaryContents = "contents go here";
        const canaryFile = {} as IEncryptedFile;
        const canaryAddl = { canary: true };
        indexEvent.getContent = () => ({ active: true, retained: true });
@@ -24,7 +24,6 @@ import {
    TreePermissions,
 } from "../../../src/models/MSC3089TreeSpace";
 import { DEFAULT_ALPHABET } from "../../../src/utils";
-import { MockBlob } from "../../MockBlob";
 import { MatrixError } from "../../../src/http-api";

 describe("MSC3089TreeSpace", () => {
@@ -887,12 +886,8 @@ describe("MSC3089TreeSpace", () => {
        const fileName = "My File.txt";
        const fileContents = "This is a test file";

-        // Mock out Blob for the test environment
-        (<any>global).Blob = MockBlob;
-
-        const uploadFn = jest.fn().mockImplementation((contents: Blob, opts: any) => {
-            expect(contents).toBeInstanceOf(Blob);
-            expect(contents.size).toEqual(fileContents.length);
+        const uploadFn = jest.fn().mockImplementation((contents: Buffer, opts: any) => {
+            expect(contents.length).toEqual(fileContents.length);
            expect(opts).toMatchObject({
                includeFilename: false,
                onlyContentUri: true, // because the tests rely on this - we shouldn't really be testing  for this.
@@ -930,7 +925,7 @@ describe("MSC3089TreeSpace", () => {
            });
        client.sendStateEvent = sendStateFn;

-        const buf = Uint8Array.from(Array.from(fileContents).map((_, i) => fileContents.charCodeAt(i)));
+        const buf = Buffer.from(fileContents);

        // We clone the file info just to make sure it doesn't get mutated for the test.
        const result = await tree.createFile(fileName, buf, Object.assign({}, fileInfo), { metadata: true });
@@ -951,12 +946,8 @@ describe("MSC3089TreeSpace", () => {
        const fileName = "My File.txt";
        const fileContents = "This is a test file";

-        // Mock out Blob for the test environment
-        (<any>global).Blob = MockBlob;
-
-        const uploadFn = jest.fn().mockImplementation((contents: Blob, opts: any) => {
-            expect(contents).toBeInstanceOf(Blob);
-            expect(contents.size).toEqual(fileContents.length);
+        const uploadFn = jest.fn().mockImplementation((contents: Buffer, opts: any) => {
+            expect(contents.length).toEqual(fileContents.length);
            expect(opts).toMatchObject({
                includeFilename: false,
                onlyContentUri: true, // because the tests rely on this - we shouldn't really be testing  for this.
@@ -997,7 +988,7 @@ describe("MSC3089TreeSpace", () => {
            });
        client.sendStateEvent = sendStateFn;

-        const buf = Uint8Array.from(Array.from(fileContents).map((_, i) => fileContents.charCodeAt(i)));
+        const buf = Buffer.from(fileContents);

        // We clone the file info just to make sure it doesn't get mutated for the test.
        const result = await tree.createFile(fileName, buf, Object.assign({}, fileInfo), { "m.new_content": true });
@@ -147,12 +147,12 @@ export interface IPusher {
    app_display_name: string;
    app_id: string;
    data: {
-        format?: string; // TODO: Types
+        format?: string;
        url?: string; // TODO: Required if kind==http
-        brand?: string; // TODO: For email notifications only?
+        brand?: string; // TODO: For email notifications only? Unspecced field
    };
    device_display_name: string;
-    kind: string; // TODO: Types
+    kind: "http" | string;
    lang: string;
    profile_tag?: string;
    pushkey: string;
@@ -111,6 +111,7 @@ export enum MsgType {
    Audio = "m.audio",
    Location = "m.location",
    Video = "m.video",
+    KeyVerificationRequest = "m.key.verification.request",
 }

 export const RoomCreateTypeField = "type";
@@ -75,11 +75,13 @@ import {
    IKeyBackupPrepareOpts,
    IKeyBackupRestoreOpts,
    IKeyBackupRestoreResult,
+    IKeyBackupRoomSessions,
+    IKeyBackupSession,
 } from "./crypto/keybackup";
 import { IIdentityServerProvider } from "./@types/IIdentityServerProvider";
 import type Request from "request";
 import { MatrixScheduler } from "./scheduler";
-import { ICryptoCallbacks, IMinimalEvent, IRoomEvent, IStateEvent, NotificationCountType } from "./matrix";
+import { IAuthData, ICryptoCallbacks, IMinimalEvent, IRoomEvent, IStateEvent, NotificationCountType } from "./matrix";
 import {
    CrossSigningKey,
    IAddSecretStorageKeyOpts,
@@ -677,8 +679,22 @@ interface IRoomSummary extends Omit<IPublicRoomsChunkRoom, "canonical_alias" | "
    membership?: string;
    is_encrypted: boolean;
 }
+
+interface IRoomKeysResponse {
+    sessions: IKeyBackupRoomSessions;
+}
+
+interface IRoomsKeysResponse {
+    rooms: Record<string, IRoomKeysResponse>;
+}
 /* eslint-enable camelcase */

+// We're using this constant for methods overloading and inspect whether a variable
+// contains an eventId or not. This was required to ensure backwards compatibility
+// of methods for threads
+// Probably not the most graceful solution but does a good enough job for now
+const EVENT_ID_PREFIX = "$";
+
 /**
 * Represents a Matrix Client. Only directly construct this if you want to use
 * custom modules. Normally, {@link createClient} should be used
@@ -724,7 +740,7 @@ export class MatrixClient extends EventEmitter {
    protected fallbackICEServerAllowed = false;
    protected roomList: RoomList;
    protected syncApi: SyncApi;
-    public pushRules: any; // TODO: Types
+    public pushRules: IPushRules;
    protected syncLeftRoomsPromise: Promise<Room[]>;
    protected syncedLeftRooms = false;
    protected clientOpts: IStoredClientOpts;
@@ -2719,7 +2735,6 @@ export class MatrixClient extends EventEmitter {
     * @return {Promise<object>} Status of restoration with `total` and `imported`
     * key counts.
     */
-    // TODO: Types
    public async restoreKeyBackupWithPassword(
        password: string,
        targetRoomId: string,
@@ -2746,7 +2761,6 @@ export class MatrixClient extends EventEmitter {
     * @return {Promise<object>} Status of restoration with `total` and `imported`
     * key counts.
     */
-    // TODO: Types
    public async restoreKeyBackupWithSecretStorage(
        backupInfo: IKeyBackupInfo,
        targetRoomId?: string,
@@ -2783,7 +2797,6 @@ export class MatrixClient extends EventEmitter {
     * @return {Promise<object>} Status of restoration with `total` and `imported`
     * key counts.
     */
-    // TODO: Types
    public restoreKeyBackupWithRecoveryKey(
        recoveryKey: string,
        targetRoomId: string,
@@ -2795,7 +2808,6 @@ export class MatrixClient extends EventEmitter {
        return this.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
    }

-    // TODO: Types
    public async restoreKeyBackupWithCache(
        targetRoomId: string,
        targetSessionId: string,
@@ -2856,11 +2868,11 @@ export class MatrixClient extends EventEmitter {
            const res = await this.http.authedRequest(
                undefined, "GET", path.path, path.queryData, undefined,
                { prefix: PREFIX_UNSTABLE },
-            );
+            ) as IRoomsKeysResponse | IRoomKeysResponse | IKeyBackupSession;

-            if (res.rooms) {
-                // TODO: Types
-                for (const [roomId, roomData] of Object.entries<any>(res.rooms)) {
+            if ((res as IRoomsKeysResponse).rooms) {
+                const rooms = (res as IRoomsKeysResponse).rooms;
+                for (const [roomId, roomData] of Object.entries(rooms)) {
                    if (!roomData.sessions) continue;

                    totalKeyCount += Object.keys(roomData.sessions).length;
@@ -2870,9 +2882,10 @@ export class MatrixClient extends EventEmitter {
                        keys.push(k);
                    }
                }
-            } else if (res.sessions) {
-                totalKeyCount = Object.keys(res.sessions).length;
-                keys = await algorithm.decryptSessions(res.sessions);
+            } else if ((res as IRoomKeysResponse).sessions) {
+                const sessions = (res as IRoomKeysResponse).sessions;
+                totalKeyCount = Object.keys(sessions).length;
+                keys = await algorithm.decryptSessions(sessions);
                for (const k of keys) {
                    k.room_id = targetRoomId;
                }
@@ -2880,7 +2893,7 @@ export class MatrixClient extends EventEmitter {
                totalKeyCount = 1;
                try {
                    const [key] = await algorithm.decryptSessions({
-                        [targetSessionId]: res,
+                        [targetSessionId]: res as IKeyBackupSession,
                    });
                    key.room_id = targetRoomId;
                    key.session_id = targetSessionId;
@@ -3385,10 +3398,11 @@ export class MatrixClient extends EventEmitter {

    /**
     * @param {string} roomId
+     * @param {string} threadId
     * @param {string} eventType
     * @param {Object} content
     * @param {string} txnId Optional.
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to an empty object {}
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
@@ -3398,20 +3412,45 @@ export class MatrixClient extends EventEmitter {
        content: IContent,
        txnId?: string,
        callback?: Callback,
+    );
+    public sendEvent(
+        roomId: string,
+        threadId: string | null,
+        eventType: string,
+        content: IContent,
+        txnId?: string,
+        callback?: Callback,
+    )
+    public sendEvent(
+        roomId: string,
+        threadId: string | null,
+        eventType: string | IContent,
+        content: IContent | string,
+        txnId?: string | Callback,
+        callback?: Callback,
    ): Promise<ISendEventResponse> {
-        return this.sendCompleteEvent(roomId, { type: eventType, content }, txnId, callback);
+        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
+            callback = txnId as Callback;
+            txnId = content as string;
+            content = eventType as IContent;
+            eventType = threadId;
+            threadId = null;
+        }
+        return this.sendCompleteEvent(roomId, threadId, { type: eventType, content }, txnId as string, callback);
    }

    /**
     * @param {string} roomId
+     * @param {string} threadId
     * @param {object} eventObject An object with the partial structure of an event, to which event_id, user_id, room_id and origin_server_ts will be added.
     * @param {string} txnId Optional.
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to an empty object {}
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
    private sendCompleteEvent(
        roomId: string,
+        threadId: string | null,
        eventObject: any,
        txnId?: string,
        callback?: Callback,
@@ -3437,6 +3476,10 @@ export class MatrixClient extends EventEmitter {
        }));

        const room = this.getRoom(roomId);
+        const thread = room?.threads.get(threadId);
+        if (thread) {
+            localEvent.setThread(thread);
+        }

        // if this is a relation or redaction of an event
        // that hasn't been sent yet (e.g. with a local id starting with a ~)
@@ -3453,12 +3496,12 @@ export class MatrixClient extends EventEmitter {
        const type = localEvent.getType();
        logger.log(`sendEvent of type ${type} in ${roomId} with txnId ${txnId}`);

-        localEvent.setTxnId(txnId);
+        localEvent.setTxnId(txnId as string);
        localEvent.setStatus(EventStatus.SENDING);

        // add this event immediately to the local store as 'sending'.
        if (room) {
-            room.addPendingEvent(localEvent, txnId);
+            room.addPendingEvent(localEvent, txnId as string);
        }

        // addPendingEvent can change the state to NOT_SENT if it believes
@@ -3648,31 +3691,52 @@ export class MatrixClient extends EventEmitter {
     *    supplied.
     * @param {object|module:client.callback} cbOrOpts
     *    Options to pass on, may contain `reason`.
-     *    Can be callback for backwards compatibility.
+     *    Can be callback for backwards compatibility. Deprecated
     * @return {Promise} Resolves: TODO
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
    public redactEvent(
        roomId: string,
        eventId: string,
-        txnId?: string,
+        txnId?: string | undefined,
+        cbOrOpts?: Callback | IRedactOpts,
+    );
+    public redactEvent(
+        roomId: string,
+        threadId: string | null,
+        eventId: string,
+        txnId?: string | undefined,
+        cbOrOpts?: Callback | IRedactOpts,
+    );
+    public redactEvent(
+        roomId: string,
+        threadId: string | null,
+        eventId?: string,
+        txnId?: string | Callback | IRedactOpts,
        cbOrOpts?: Callback | IRedactOpts,
    ): Promise<ISendEventResponse> {
+        if (!eventId || eventId.startsWith(EVENT_ID_PREFIX)) {
+            cbOrOpts = txnId as (Callback | IRedactOpts);
+            txnId = eventId;
+            eventId = threadId;
+            threadId = null;
+        }
        const opts = typeof (cbOrOpts) === 'object' ? cbOrOpts : {};
        const reason = opts.reason;
        const callback = typeof (cbOrOpts) === 'function' ? cbOrOpts : undefined;
-        return this.sendCompleteEvent(roomId, {
+        return this.sendCompleteEvent(roomId, threadId, {
            type: EventType.RoomRedaction,
            content: { reason: reason },
            redacts: eventId,
-        }, txnId, callback);
+        }, txnId as string, callback);
    }

    /**
     * @param {string} roomId
+     * @param {string} threadId
     * @param {Object} content
     * @param {string} txnId Optional.
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to an ISendEventResponse object
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
@@ -3681,19 +3745,47 @@ export class MatrixClient extends EventEmitter {
        content: IContent,
        txnId?: string,
        callback?: Callback,
+    )
+    public sendMessage(
+        roomId: string,
+        threadId: string | null,
+        content: IContent,
+        txnId?: string,
+        callback?: Callback,
+    )
+    public sendMessage(
+        roomId: string,
+        threadId: string | null | IContent,
+        content: IContent | string,
+        txnId?: string | Callback,
+        callback?: Callback,
    ): Promise<ISendEventResponse> {
+        if (typeof threadId !== "string" && threadId !== null) {
+            callback = txnId as Callback;
+            txnId = content as string;
+            content = threadId as IContent;
+            threadId = null;
+        }
        if (utils.isFunction(txnId)) {
            callback = txnId as any as Callback; // for legacy
            txnId = undefined;
        }
-        return this.sendEvent(roomId, EventType.RoomMessage, content, txnId, callback);
+        return this.sendEvent(
+            roomId,
+            threadId as (string | null),
+            EventType.RoomMessage,
+            content as IContent,
+            txnId as string,
+            callback,
+        );
    }

    /**
     * @param {string} roomId
+     * @param {string} threadId
     * @param {string} body
     * @param {string} txnId Optional.
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to an empty object {}
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
@@ -3702,29 +3794,76 @@ export class MatrixClient extends EventEmitter {
        body: string,
        txnId?: string,
        callback?: Callback,
+    )
+    public sendTextMessage(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        txnId?: string,
+        callback?: Callback,
+    )
+    public sendTextMessage(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        txnId?: string | Callback,
+        callback?: Callback,
    ): Promise<ISendEventResponse> {
+        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
+            callback = txnId as Callback;
+            txnId = body;
+            body = threadId;
+            threadId = null;
+        }
        const content = ContentHelpers.makeTextMessage(body);
-        return this.sendMessage(roomId, content, txnId, callback);
+        return this.sendMessage(roomId, threadId, content, txnId as string, callback);
    }

    /**
     * @param {string} roomId
+     * @param {string} threadId
     * @param {string} body
     * @param {string} txnId Optional.
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to a ISendEventResponse object
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
-    public sendNotice(roomId: string, body: string, txnId?: string, callback?: Callback): Promise<ISendEventResponse> {
+    public sendNotice(
+        roomId: string,
+        body: string,
+        txnId?: string,
+        callback?: Callback,
+    )
+    public sendNotice(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        txnId?: string,
+        callback?: Callback,
+    );
+    public sendNotice(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        txnId?: string | Callback,
+        callback?: Callback,
+    ): Promise<ISendEventResponse> {
+        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
+            callback = txnId as Callback;
+            txnId = body;
+            body = threadId;
+            threadId = null;
+        }
        const content = ContentHelpers.makeNotice(body);
-        return this.sendMessage(roomId, content, txnId, callback);
+        return this.sendMessage(roomId, threadId, content, txnId as string, callback);
    }

    /**
     * @param {string} roomId
+     * @param {string} threadId
     * @param {string} body
     * @param {string} txnId Optional.
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to a ISendEventResponse object
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
@@ -3733,17 +3872,38 @@ export class MatrixClient extends EventEmitter {
        body: string,
        txnId?: string,
        callback?: Callback,
+    )
+    public sendEmoteMessage(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        txnId?: string,
+        callback?: Callback,
+    );
+    public sendEmoteMessage(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        txnId?: string | Callback,
+        callback?: Callback,
    ): Promise<ISendEventResponse> {
+        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
+            callback = txnId as Callback;
+            txnId = body;
+            body = threadId;
+            threadId = null;
+        }
        const content = ContentHelpers.makeEmoteMessage(body);
-        return this.sendMessage(roomId, content, txnId, callback);
+        return this.sendMessage(roomId, threadId, content, txnId as string, callback);
    }

    /**
     * @param {string} roomId
+     * @param {string} threadId
     * @param {string} url
     * @param {Object} info
     * @param {string} text
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to a ISendEventResponse object
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
@@ -3751,9 +3911,32 @@ export class MatrixClient extends EventEmitter {
        roomId: string,
        url: string,
        info?: IImageInfo,
-        text = "Image",
+        text?: string,
+        callback?: Callback,
+    );
+    public sendImageMessage(
+        roomId: string,
+        threadId: string | null,
+        url: string,
+        info?: IImageInfo,
+        text?: string,
+        callback?: Callback,
+    );
+    public sendImageMessage(
+        roomId: string,
+        threadId: string | null,
+        url: string | IImageInfo,
+        info?: IImageInfo | string,
+        text: Callback | string = "Image",
        callback?: Callback,
    ): Promise<ISendEventResponse> {
+        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
+            callback = text as Callback;
+            text = info as string || "Image";
+            info = url as IImageInfo;
+            url = threadId as string;
+            threadId = null;
+        }
        if (utils.isFunction(text)) {
            callback = text as any as Callback; // legacy
            text = undefined;
@@ -3764,15 +3947,16 @@ export class MatrixClient extends EventEmitter {
            info: info,
            body: text,
        };
-        return this.sendMessage(roomId, content, undefined, callback);
+        return this.sendMessage(roomId, threadId, content, undefined, callback);
    }

    /**
     * @param {string} roomId
+     * @param {string} threadId
     * @param {string} url
     * @param {Object} info
     * @param {string} text
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to a ISendEventResponse object
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
@@ -3780,9 +3964,32 @@ export class MatrixClient extends EventEmitter {
        roomId: string,
        url: string,
        info?: IImageInfo,
-        text = "Sticker",
+        text?: string,
+        callback?: Callback,
+    );
+    public sendStickerMessage(
+        roomId: string,
+        threadId: string | null,
+        url: string,
+        info?: IImageInfo,
+        text?: string,
+        callback?: Callback,
+    );
+    public sendStickerMessage(
+        roomId: string,
+        threadId: string | null,
+        url: string | IImageInfo,
+        info?: IImageInfo | string,
+        text: Callback | string = "Sticker",
        callback?: Callback,
    ): Promise<ISendEventResponse> {
+        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
+            callback = text as Callback;
+            text = info as string || "Sticker";
+            info = url as IImageInfo;
+            url = threadId as string;
+            threadId = null;
+        }
        if (utils.isFunction(text)) {
            callback = text as any as Callback; // legacy
            text = undefined;
@@ -3792,14 +3999,15 @@ export class MatrixClient extends EventEmitter {
            info: info,
            body: text,
        };
-        return this.sendEvent(roomId, EventType.Sticker, content, undefined, callback);
+        return this.sendEvent(roomId, threadId, EventType.Sticker, content, undefined, callback);
    }

    /**
     * @param {string} roomId
+     * @param {string} threadId
     * @param {string} body
     * @param {string} htmlBody
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to a ISendEventResponse object
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
@@ -3808,16 +4016,36 @@ export class MatrixClient extends EventEmitter {
        body: string,
        htmlBody: string,
        callback?: Callback,
+    );
+    public sendHtmlMessage(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        htmlBody: string,
+        callback?: Callback,
+    )
+    public sendHtmlMessage(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        htmlBody: string | Callback,
+        callback?: Callback,
    ): Promise<ISendEventResponse> {
-        const content = ContentHelpers.makeHtmlMessage(body, htmlBody);
-        return this.sendMessage(roomId, content, undefined, callback);
+        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
+            callback = htmlBody as Callback;
+            htmlBody = body as string;
+            body = threadId;
+            threadId = null;
+        }
+        const content = ContentHelpers.makeHtmlMessage(body, htmlBody as string);
+        return this.sendMessage(roomId, threadId, content, undefined, callback);
    }

    /**
     * @param {string} roomId
     * @param {string} body
     * @param {string} htmlBody
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to a ISendEventResponse object
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
@@ -3826,16 +4054,37 @@ export class MatrixClient extends EventEmitter {
        body: string,
        htmlBody: string,
        callback?: Callback,
+    );
+    public sendHtmlNotice(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        htmlBody: string,
+        callback?: Callback,
+    )
+    public sendHtmlNotice(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        htmlBody: string | Callback,
+        callback?: Callback,
    ): Promise<ISendEventResponse> {
-        const content = ContentHelpers.makeHtmlNotice(body, htmlBody);
-        return this.sendMessage(roomId, content, undefined, callback);
+        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
+            callback = htmlBody as Callback;
+            htmlBody = body as string;
+            body = threadId;
+            threadId = null;
+        }
+        const content = ContentHelpers.makeHtmlNotice(body, htmlBody as string);
+        return this.sendMessage(roomId, threadId, content, undefined, callback);
    }

    /**
     * @param {string} roomId
+     * @param {string} threadId
     * @param {string} body
     * @param {string} htmlBody
-     * @param {module:client.callback} callback Optional.
+     * @param {module:client.callback} callback Optional. Deprecated
     * @return {Promise} Resolves: to a ISendEventResponse object
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
@@ -3844,9 +4093,29 @@ export class MatrixClient extends EventEmitter {
        body: string,
        htmlBody: string,
        callback?: Callback,
+    );
+    public sendHtmlEmote(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        htmlBody: string,
+        callback?: Callback,
+    )
+    public sendHtmlEmote(
+        roomId: string,
+        threadId: string | null,
+        body: string,
+        htmlBody: string | Callback,
+        callback?: Callback,
    ): Promise<ISendEventResponse> {
-        const content = ContentHelpers.makeHtmlEmote(body, htmlBody);
-        return this.sendMessage(roomId, content, undefined, callback);
+        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
+            callback = htmlBody as Callback;
+            htmlBody = body as string;
+            body = threadId;
+            threadId = null;
+        }
+        const content = ContentHelpers.makeHtmlEmote(body, htmlBody as string);
+        return this.sendMessage(roomId, threadId, content, undefined, callback);
    }

    /**
@@ -4578,7 +4847,12 @@ export class MatrixClient extends EventEmitter {
                    const stateEvents = res.state.map(this.getEventMapper());
                    room.currentState.setUnknownStateEvents(stateEvents);
                }
-                room.addEventsToTimeline(matrixEvents, true, room.getLiveTimeline());
+
+                const [timelineEvents, threadedEvents] = this.partitionThreadedEvents(matrixEvents);
+
+                room.addEventsToTimeline(timelineEvents, true, room.getLiveTimeline());
+                this.processThreadEvents(room, threadedEvents);
+
                room.oldState.paginationToken = res.end;
                if (res.chunk.length === 0) {
                    room.oldState.paginationToken = null;
@@ -4684,7 +4958,11 @@ export class MatrixClient extends EventEmitter {
                const stateEvents = res.state.map(this.getEventMapper());
                timeline.getState(EventTimeline.BACKWARDS).setUnknownStateEvents(stateEvents);
            }
-            timelineSet.addEventsToTimeline(matrixEvents, true, timeline, res.start);
+
+            const [timelineEvents, threadedEvents] = this.partitionThreadedEvents(matrixEvents);
+
+            timelineSet.addEventsToTimeline(timelineEvents, true, timeline, res.start);
+            this.processThreadEvents(timelineSet.room, threadedEvents);

            // there is no guarantee that the event ended up in "timeline" (we
            // might have switched to a neighbouring timeline) - so check the
@@ -4817,8 +5095,11 @@ export class MatrixClient extends EventEmitter {
                    matrixEvents[i] = event;
                }

-                eventTimeline.getTimelineSet()
-                    .addEventsToTimeline(matrixEvents, backwards, eventTimeline, token);
+                const [timelineEvents, threadedEvents] = this.partitionThreadedEvents(matrixEvents);
+
+                const timelineSet = eventTimeline.getTimelineSet();
+                timelineSet.addEventsToTimeline(timelineEvents, backwards, eventTimeline, token);
+                this.processThreadEvents(timelineSet.room, threadedEvents);

                // if we've hit the end of the timeline, we need to stop trying to
                // paginate. We need to keep the 'forwards' token though, to make sure
@@ -4851,8 +5132,12 @@ export class MatrixClient extends EventEmitter {
                }
                const token = res.end;
                const matrixEvents = res.chunk.map(this.getEventMapper());
+
+                const [timelineEvents, threadedEvents] = this.partitionThreadedEvents(matrixEvents);
+
                eventTimeline.getTimelineSet()
-                    .addEventsToTimeline(matrixEvents, backwards, eventTimeline, token);
+                    .addEventsToTimeline(timelineEvents, backwards, eventTimeline, token);
+                this.processThreadEvents(room, threadedEvents);

                // if we've hit the end of the timeline, we need to stop trying to
                // paginate. We need to keep the 'forwards' token though, to make sure
@@ -5999,7 +6284,9 @@ export class MatrixClient extends EventEmitter {
        if (fetchedEventType === EventType.RoomMessageEncrypted) {
            const allEvents = originalEvent ? events.concat(originalEvent) : events;
            await Promise.all(allEvents.map(e => {
-                return new Promise(resolve => e.once("Event.decrypted", resolve));
+                if (e.isEncrypted()) {
+                    return new Promise(resolve => e.once("Event.decrypted", resolve));
+                }
            }));
            events = events.filter(e => e.getType() === eventType);
        }
@@ -6588,7 +6875,7 @@ export class MatrixClient extends EventEmitter {
        eventType: string,
        stateKey: string,
        callback?: Callback,
-    ): Promise<IStateEventWithRoomId> {
+    ): Promise<Record<string, any>> {
        const pathParams = {
            $roomId: roomId,
            $eventType: eventType,
@@ -7492,7 +7779,7 @@ export class MatrixClient extends EventEmitter {
        return this.http.authedRequest(undefined, "GET", path, qps, undefined);
    }

-    public uploadDeviceSigningKeys(auth: any, keys?: CrossSigningKeys): Promise<{}> { // TODO: types
+    public uploadDeviceSigningKeys(auth?: IAuthData, keys?: CrossSigningKeys): Promise<{}> {
        const data = Object.assign({}, keys);
        if (auth) Object.assign(data, { auth });
        return this.http.authedRequest(
@@ -8551,6 +8838,60 @@ export class MatrixClient extends EventEmitter {
            prefix: "/_matrix/client/unstable/im.nheko.summary",
        });
    }
+
+    public partitionThreadedEvents(events: MatrixEvent[]): [MatrixEvent[], MatrixEvent[]] {
+        // Indices to the events array, for readibility
+        const ROOM = 0;
+        const THREAD = 1;
+        const threadRoots = new Set<string>();
+        if (this.supportsExperimentalThreads()) {
+            return events.reduce((memo, event: MatrixEvent) => {
+                const room = this.getRoom(event.getRoomId());
+                // An event should live in the thread timeline if
+                // - It's a reply in thread event
+                // - It's related to a reply in thread event
+                let shouldLiveInThreadTimeline = event.isThreadRelation;
+                if (shouldLiveInThreadTimeline) {
+                    threadRoots.add(event.relationEventId);
+                } else {
+                    const parentEventId = event.parentEventId;
+                    const parentEvent = room?.findEventById(parentEventId) || events.find((mxEv: MatrixEvent) => {
+                        return mxEv.getId() === parentEventId;
+                    });
+                    shouldLiveInThreadTimeline = parentEvent?.isThreadRelation;
+
+                    // Copy all the reactions and annotations to the root event
+                    // to the thread timeline. They will end up living in both
+                    // timelines at the same time
+                    const targetingThreadRoot = parentEvent?.isThreadRoot || threadRoots.has(event.relationEventId);
+                    if (targetingThreadRoot && !event.isThreadRelation && event.relationEventId) {
+                        memo[THREAD].push(event);
+                    }
+                }
+                const targetTimeline = shouldLiveInThreadTimeline ? THREAD : ROOM;
+                memo[targetTimeline].push(event);
+                return memo;
+            }, [[], []]);
+        } else {
+            // When `experimentalThreadSupport` is disabled
+            // treat all events as timelineEvents
+            return [
+                events,
+                [],
+            ];
+        }
+    }
+
+    /**
+     * @experimental
+     */
+    public processThreadEvents(room: Room, threadedEvents: MatrixEvent[]): void {
+        threadedEvents
+            .sort((a, b) => a.getTs() - b.getTs())
+            .forEach(event => {
+                room.addThreadedEvent(event);
+            });
+    }
 }

 /**
@@ -304,7 +304,7 @@ export class CrossSigningInfo extends EventEmitter {
        }

        const privateKeys: Record<string, Uint8Array> = {};
-        const keys: Record<string, any> = {}; // TODO types
+        const keys: Record<string, ICrossSigningKey> = {};
        let masterSigning;
        let masterPub;

@@ -58,14 +58,7 @@ export interface IEncryptedEventInfo {
 }

 export interface IRecoveryKey {
-    keyInfo?: {
-        pubkey: string;
-        passphrase?: {
-            algorithm: string;
-            iterations: number;
-            salt: string;
-        };
-    };
+    keyInfo?: IAddSecretStorageKeyOpts;
    privateKey: Uint8Array;
    encodedPrivateKey?: string;
 }
@@ -125,12 +118,13 @@ export interface IPassphraseInfo {
    algorithm: "m.pbkdf2";
    iterations: number;
    salt: string;
-    bits: number;
+    bits?: number;
 }

 export interface IAddSecretStorageKeyOpts {
-    name: string;
-    passphrase: IPassphraseInfo;
+    pubkey: string;
+    passphrase?: IPassphraseInfo;
+    name?: string;
    key: Uint8Array;
 }

@@ -40,7 +40,7 @@ import {
    ISecretRequest,
    SecretStorageKeyObject,
 } from './SecretStorage';
-import { IAddSecretStorageKeyOpts, IImportRoomKeysOpts, ISecretStorageKeyInfo } from "./api";
+import { IAddSecretStorageKeyOpts, ICreateSecretStorageOpts, IImportRoomKeysOpts, ISecretStorageKeyInfo } from "./api";
 import { OutgoingRoomKeyRequestManager } from './OutgoingRoomKeyRequestManager';
 import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
 import { ReciprocateQRCode, SCAN_QR_CODE_METHOD, SHOW_QR_CODE_METHOD } from './verification/QRCode';
@@ -59,7 +59,7 @@ import { IStore } from "../store";
 import { Room } from "../models/room";
 import { RoomMember } from "../models/room-member";
 import { MatrixEvent, EventStatus } from "../models/event";
-import { MatrixClient, IKeysUploadResponse, SessionStore, ISignedKey } from "../client";
+import { MatrixClient, IKeysUploadResponse, SessionStore, ISignedKey, ICrossSigningKey } from "../client";
 import type { EncryptionAlgorithm, DecryptionAlgorithm } from "./algorithms/base";
 import type { IRoomEncryption, RoomList } from "./RoomList";
 import { IRecoveryKey, IEncryptedEventInfo } from "./api";
@@ -108,17 +108,6 @@ export interface IBootstrapCrossSigningOpts {
    authUploadDeviceSigningKeys?(makeRequest: (authData: any) => {}): Promise<void>;
 }

-interface IBootstrapSecretStorageOpts {
-    keyBackupInfo?: any; // TODO types
-    setupNewKeyBackup?: boolean;
-    setupNewSecretStorage?: boolean;
-    createSecretStorageKey?(): Promise<{
-        keyInfo?: any; // TODO types
-        privateKey?: Uint8Array;
-    }>;
-    getKeyBackupPassphrase?(): Promise<Uint8Array | null>;
-}
-
 /* eslint-disable camelcase */
 interface IRoomKey {
    room_id: string;
@@ -762,12 +751,12 @@ export class Crypto extends EventEmitter {
     */
    // TODO this does not resolve with what it says it does
    public async bootstrapSecretStorage({
-        createSecretStorageKey = async () => ({ }),
+        createSecretStorageKey = async () => ({} as IRecoveryKey),
        keyBackupInfo,
        setupNewKeyBackup,
        setupNewSecretStorage,
        getKeyBackupPassphrase,
-    }: IBootstrapSecretStorageOpts = {}) {
+    }: ICreateSecretStorageOpts = {}) {
        logger.log("Bootstrapping Secure Secret Storage");
        const delegateCryptoCallbacks = this.baseApis.cryptoCallbacks;
        const builder = new EncryptionSetupBuilder(
@@ -783,8 +772,7 @@ export class Crypto extends EventEmitter {
        let newKeyId = null;

        // create a new SSSS key and set it as default
-        const createSSSS = async (opts, privateKey: Uint8Array) => {
-            opts = opts || {};
+        const createSSSS = async (opts: IAddSecretStorageKeyOpts, privateKey: Uint8Array) => {
            if (privateKey) {
                opts.key = privateKey;
            }
@@ -800,7 +788,7 @@ export class Crypto extends EventEmitter {
            return keyId;
        };

-        const ensureCanCheckPassphrase = async (keyId, keyInfo) => {
+        const ensureCanCheckPassphrase = async (keyId: string, keyInfo: ISecretStorageKeyInfo) => {
            if (!keyInfo.mac) {
                const key = await this.baseApis.cryptoCallbacks.getSecretStorageKey(
                    { keys: { [keyId]: keyInfo } }, "",
@@ -880,7 +868,7 @@ export class Crypto extends EventEmitter {
            const backupKey = await this.getSessionBackupPrivateKey() || await getKeyBackupPassphrase();

            // create a new SSSS key and use the backup key as the new SSSS key
-            const opts: any = {}; // TODO types
+            const opts = {} as IAddSecretStorageKeyOpts;

            if (
                keyBackupInfo.auth_data.private_key_salt &&
@@ -898,9 +886,7 @@ export class Crypto extends EventEmitter {
            newKeyId = await createSSSS(opts, backupKey);

            // store the backup key in secret storage
-            await secretStorage.store(
-                "m.megolm_backup.v1", olmlib.encodeBase64(backupKey), [newKeyId],
-            );
+            await secretStorage.store("m.megolm_backup.v1", olmlib.encodeBase64(backupKey), [newKeyId]);

            // The backup is trusted because the user provided the private key.
            // Sign the backup with the cross-signing key so the key backup can
@@ -1274,7 +1260,7 @@ export class Crypto extends EventEmitter {
     */
    private async checkForValidDeviceSignature(
        userId: string,
-        key: any, // TODO types
+        key: ICrossSigningKey,
        devices: Record<string, IDevice>,
    ): Promise<string[]> {
        const deviceIds: string[] = [];
@@ -1609,7 +1595,7 @@ export class Crypto extends EventEmitter {
     *
     * @param {object} keys The new trusted set of keys
     */
-    private async storeTrustedSelfKeys(keys: any): Promise<void> { // TODO types
+    private async storeTrustedSelfKeys(keys: Record<string, ICrossSigningKey>): Promise<void> {
        if (keys) {
            this.crossSigningInfo.setKeys(keys);
        } else {
@@ -2592,12 +2578,16 @@ export class Crypto extends EventEmitter {
     * the given users.
     *
     * @param {string[]} users list of user ids
+     * @param {boolean} force If true, force a new Olm session to be created. Default false.
     *
     * @return {Promise} resolves once the sessions are complete, to
     *    an Object mapping from userId to deviceId to
     *    {@link module:crypto~OlmSessionResult}
     */
-    ensureOlmSessionsForUsers(users: string[]): Promise<Record<string, Record<string, olmlib.IOlmSessionResult>>> {
+    public ensureOlmSessionsForUsers(
+        users: string[],
+        force?: boolean,
+    ): Promise<Record<string, Record<string, olmlib.IOlmSessionResult>>> {
        const devicesByUser = {};

        for (let i = 0; i < users.length; ++i) {
@@ -2622,7 +2612,7 @@ export class Crypto extends EventEmitter {
            }
        }

-        return olmlib.ensureOlmSessionsForDevices(this.olmDevice, this.baseApis, devicesByUser);
+        return olmlib.ensureOlmSessionsForDevices(this.olmDevice, this.baseApis, devicesByUser, force);
    }

    /**
@@ -2658,7 +2648,7 @@ export class Crypto extends EventEmitter {
     * @param {Function} opts.progressCallback called with an object which has a stage param
     * @return {Promise} a promise which resolves once the keys have been imported
     */
-    public importRoomKeys(keys: IMegolmSessionData[], opts: IImportRoomKeysOpts = {}): Promise<any> { // TODO types
+    public importRoomKeys(keys: IMegolmSessionData[], opts: IImportRoomKeysOpts = {}): Promise<void> {
        let successes = 0;
        let failures = 0;
        const total = keys.length;
@@ -2685,7 +2675,7 @@ export class Crypto extends EventEmitter {
                successes++;
                if (opts.progressCallback) { updateProgress(); }
            });
-        }));
+        })).then();
    }

    /**
@@ -15,6 +15,10 @@ limitations under the License.
 */

 import { randomString } from '../randomstring';
+import { getCrypto } from '../utils';
+
+const subtleCrypto = (typeof window !== "undefined" && window.crypto) ?
+    (window.crypto.subtle || window.crypto.webkitSubtle) : null;

 const DEFAULT_ITERATIONS = 500000;

@@ -70,11 +74,21 @@ export async function deriveKey(
    salt: string,
    iterations: number,
    numBits = DEFAULT_BITSIZE,
+): Promise<Uint8Array> {
+    return subtleCrypto
+        ? deriveKeyBrowser(password, salt, iterations, numBits)
+        : deriveKeyNode(password, salt, iterations, numBits);
+}
+
+async function deriveKeyBrowser(
+    password: string,
+    salt: string,
+    iterations: number,
+    numBits: number,
 ): Promise<Uint8Array> {
    const subtleCrypto = global.crypto.subtle;
    const TextEncoder = global.TextEncoder;
    if (!subtleCrypto || !TextEncoder) {
-        // TODO: Implement this for node
        throw new Error("Password-based backup is not avaiable on this platform");
    }

@@ -99,3 +113,17 @@ export async function deriveKey(

    return new Uint8Array(keybits);
 }
+
+async function deriveKeyNode(
+    password: string,
+    salt: string,
+    iterations: number,
+    numBits: number,
+): Promise<Uint8Array> {
+    const crypto = getCrypto();
+    if (!crypto) {
+        throw new Error("No usable crypto implementation");
+    }
+
+    return crypto.pbkdf2Sync(password, Buffer.from(salt, 'binary'), iterations, numBits, 'sha512');
+}
@@ -31,3 +31,9 @@ try {

 export * from "./matrix";
 export default matrixcs;
+
+export * from './@types/event';
+export * from './@types/PushRules';
+export * from './@types/requests';
+export * from './@types/search';
+export * from './models/room-summary';
@@ -61,6 +61,7 @@ export enum AuthType {
    Sso = "m.login.sso",
    SsoUnstable = "org.matrix.login.sso",
    Dummy = "m.login.dummy",
+    RegistrationToken = "org.matrix.msc3231.login.registration_token",
 }

 export interface IAuthDict {
@@ -449,6 +450,7 @@ export class InteractiveAuth {
            } catch (e) {
                this.attemptAuthDeferred.reject(e);
                this.attemptAuthDeferred = null;
+                return;
            }

            if (
@@ -18,6 +18,7 @@ import { MatrixClient } from "../client";
 import { IEncryptedFile, RelationType, UNSTABLE_MSC3089_BRANCH } from "../@types/event";
 import { IContent, MatrixEvent } from "./event";
 import { MSC3089TreeSpace } from "./MSC3089TreeSpace";
+import type { ReadStream } from "fs";

 /**
 * Represents a [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089) branch - a reference
@@ -142,16 +143,16 @@ export class MSC3089Branch {
    }

    /**
-     * Creates a new version of this file.
+     * Creates a new version of this file with contents in a type that is compatible with MatrixClient.uploadContent().
     * @param {string} name The name of the file.
-     * @param {ArrayBuffer} encryptedContents The encrypted contents.
+     * @param {File | String | Buffer | ReadStream | Blob} encryptedContents The encrypted contents.
     * @param {Partial<IEncryptedFile>} info The encrypted file information.
     * @param {IContent} additionalContent Optional event content fields to include in the message.
     * @returns {Promise<void>} Resolves when uploaded.
     */
    public async createNewVersion(
        name: string,
-        encryptedContents: ArrayBuffer,
+        encryptedContents: File | String | Buffer | ReadStream | Blob,
        info: Partial<IEncryptedFile>,
        additionalContent?: IContent,
    ): Promise<void> {
@@ -31,6 +31,7 @@ import { MSC3089Branch } from "./MSC3089Branch";
 import promiseRetry from "p-retry";
 import { isRoomSharedHistory } from "../crypto/algorithms/megolm";
 import { ISendEventResponse } from "../@types/requests";
+import type { ReadStream } from "fs";

 /**
 * The recommended defaults for a tree space's power levels. Note that this
@@ -449,21 +450,23 @@ export class MSC3089TreeSpace {

    /**
     * Creates (uploads) a new file to this tree. The file must have already been encrypted for the room.
+     * The file contents are in a type that is compatible with MatrixClient.uploadContent().
     * @param {string} name The name of the file.
-     * @param {ArrayBuffer} encryptedContents The encrypted contents.
+     * @param {File | String | Buffer | ReadStream | Blob} encryptedContents The encrypted contents.
     * @param {Partial<IEncryptedFile>} info The encrypted file information.
     * @param {IContent} additionalContent Optional event content fields to include in the message.
     * @returns {Promise<ISendEventResponse>} Resolves to the file event's sent response.
     */
    public async createFile(
        name: string,
-        encryptedContents: ArrayBuffer,
+        encryptedContents: File | String | Buffer | ReadStream | Blob,
        info: Partial<IEncryptedFile>,
        additionalContent?: IContent,
    ): Promise<ISendEventResponse> {
-        const mxc = await this.client.uploadContent(new Blob([encryptedContents]), {
+        const mxc = await this.client.uploadContent(encryptedContents, {
            includeFilename: false,
            onlyContentUri: true,
+            rawResponse: false, // make this explicit otherwise behaviour is different on browser vs NodeJS
        });
        info.url = mxc;

@@ -28,6 +28,7 @@ import { Room } from "./room";
 import { Filter } from "../filter";
 import { EventType, RelationType } from "../@types/event";
 import { RoomState } from "./room-state";
+import { Thread } from "./thread";

 // var DEBUG = false;
 const DEBUG = true;
@@ -153,18 +154,18 @@ export class EventTimelineSet extends EventEmitter {
     *
     * @throws If <code>opts.pendingEventOrdering</code> was not 'detached'
     */
-    public getPendingEvents(): MatrixEvent[] {
+    public getPendingEvents(thread?: Thread): MatrixEvent[] {
        if (!this.room || !this.displayPendingEvents) {
            return [];
        }

+        const pendingEvents = this.room.getPendingEvents(thread);
        if (this.filter) {
-            return this.filter.filterRoomTimeline(this.room.getPendingEvents());
+            return this.filter.filterRoomTimeline(pendingEvents);
        } else {
-            return this.room.getPendingEvents();
+            return pendingEvents;
        }
    }
-
    /**
     * Get the live timeline for this room.
     *
@@ -438,14 +438,14 @@ export class MatrixEvent extends EventEmitter {
     * @experimental
     */
    public get isThreadRoot(): boolean {
+        // TODO, change the inner working of this getter for it to use the
+        // bundled relationship return on the event, view MSC3440
        const thread = this.getThread();
        return thread?.id === this.getId();
    }

    public get parentEventId(): string {
-        const relations = this.getWireContent()["m.relates_to"];
-        return relations?.["m.in_reply_to"]?.["event_id"]
-            || relations?.event_id;
+        return this.replyEventId || this.relationEventId;
    }

    public get replyEventId(): string {
@@ -453,6 +453,12 @@ export class MatrixEvent extends EventEmitter {
        return relations?.["m.in_reply_to"]?.["event_id"];
    }

+    public get relationEventId(): string {
+        return this.getWireContent()
+            ?.["m.relates_to"]
+            ?.event_id;
+    }
+
    /**
     * Get the previous event content JSON. This will only return something for
     * state events which exist in the timeline.
@@ -225,12 +225,6 @@ export class Room extends EventEmitter {
        this.reEmitter = new ReEmitter(this);

        opts.pendingEventOrdering = opts.pendingEventOrdering || PendingEventOrdering.Chronological;
-        if (["chronological", "detached"].indexOf(opts.pendingEventOrdering) === -1) {
-            throw new Error(
-                "opts.pendingEventOrdering MUST be either 'chronological' or " +
-                "'detached'. Got: '" + opts.pendingEventOrdering + "'",
-            );
-        }

        this.name = roomId;

@@ -241,7 +235,7 @@ export class Room extends EventEmitter {

        this.fixUpLegacyTimelineFields();

-        if (this.opts.pendingEventOrdering == "detached") {
+        if (this.opts.pendingEventOrdering === PendingEventOrdering.Detached) {
            this.pendingEventList = [];
            const serializedPendingEventList = client.sessionStore.store.getItem(pendingEventsKey(this.roomId));
            if (serializedPendingEventList) {
@@ -452,14 +446,16 @@ export class Room extends EventEmitter {
     *
     * @throws If <code>opts.pendingEventOrdering</code> was not 'detached'
     */
-    public getPendingEvents(): MatrixEvent[] {
-        if (this.opts.pendingEventOrdering !== "detached") {
+    public getPendingEvents(thread?: Thread): MatrixEvent[] {
+        if (this.opts.pendingEventOrdering !== PendingEventOrdering.Detached) {
            throw new Error(
                "Cannot call getPendingEvents with pendingEventOrdering == " +
                this.opts.pendingEventOrdering);
        }

-        return this.pendingEventList;
+        return this.pendingEventList.filter(event => {
+            return !thread || thread.id === event.threadRootId;
+        });
    }

    /**
@@ -469,7 +465,7 @@ export class Room extends EventEmitter {
     * @return {boolean} True if an element was removed.
     */
    public removePendingEvent(eventId: string): boolean {
-        if (this.opts.pendingEventOrdering !== "detached") {
+        if (this.opts.pendingEventOrdering !== PendingEventOrdering.Detached) {
            throw new Error(
                "Cannot call removePendingEvent with pendingEventOrdering == " +
                this.opts.pendingEventOrdering);
@@ -495,7 +491,7 @@ export class Room extends EventEmitter {
     * @return {boolean}
     */
    public hasPendingEvent(eventId: string): boolean {
-        if (this.opts.pendingEventOrdering !== "detached") {
+        if (this.opts.pendingEventOrdering !== PendingEventOrdering.Detached) {
            return false;
        }

@@ -509,7 +505,7 @@ export class Room extends EventEmitter {
     * @return {MatrixEvent}
     */
    public getPendingEvent(eventId: string): MatrixEvent | null {
-        if (this.opts.pendingEventOrdering !== "detached") {
+        if (this.opts.pendingEventOrdering !== PendingEventOrdering.Detached) {
            return null;
        }

@@ -856,7 +852,13 @@ export class Room extends EventEmitter {
     * the given event, or null if unknown
     */
    public getTimelineForEvent(eventId: string): EventTimeline {
-        return this.getUnfilteredTimelineSet().getTimelineForEvent(eventId);
+        const event = this.findEventById(eventId);
+        const thread = this.findThreadForEvent(event);
+        if (thread) {
+            return thread.timelineSet.getLiveTimeline();
+        } else {
+            return this.getUnfilteredTimelineSet().getTimelineForEvent(eventId);
+        }
    }

    /**
@@ -1270,8 +1272,11 @@ export class Room extends EventEmitter {
        if (!event) {
            return null;
        }
+
        if (event.isThreadRelation) {
            return this.threads.get(event.threadRootId);
+        } else if (event.isThreadRoot) {
+            return this.threads.get(event.getId());
        } else {
            const parentEvent = this.findEventById(event.parentEventId);
            return this.findThreadForEvent(parentEvent);
@@ -1301,6 +1306,16 @@ export class Room extends EventEmitter {
            this.reEmitter.reEmit(thread, [ThreadEvent.Update, ThreadEvent.Ready]);
            this.emit(ThreadEvent.New, thread);
        }
+
+        if (event.getUnsigned().transaction_id) {
+            const existingEvent = this.txnToEvent[event.getUnsigned().transaction_id];
+            if (existingEvent) {
+                // remote echo of an event we sent earlier
+                this.handleRemoteEcho(event, existingEvent);
+                return;
+            }
+        }
+
        this.emit(ThreadEvent.Update, thread);
    }

@@ -1400,13 +1415,6 @@ export class Room extends EventEmitter {
     * unique transaction id.
     */
    public addPendingEvent(event: MatrixEvent, txnId: string): void {
-        // TODO: Enable "pending events" for threads
-        // There's a fair few things to update to make them work with Threads
-        // Will get back to it when the plan is to build a more polished UI ready for production
-        if (this.client?.supportsExperimentalThreads() && event.threadRootId) {
-            return;
-        }
-
        if (event.status !== EventStatus.SENDING && event.status !== EventStatus.NOT_SENT) {
            throw new Error("addPendingEvent called on an event with status " +
                event.status);
@@ -1423,8 +1431,8 @@ export class Room extends EventEmitter {
        EventTimeline.setEventMetadata(event, this.getLiveTimeline().getState(EventTimeline.FORWARDS), false);

        this.txnToEvent[txnId] = event;
-
-        if (this.opts.pendingEventOrdering == "detached") {
+        const thread = this.threads.get(event.threadRootId);
+        if (this.opts.pendingEventOrdering === PendingEventOrdering.Detached && !thread) {
            if (this.pendingEventList.some((e) => e.status === EventStatus.NOT_SENT)) {
                logger.warn("Setting event as NOT_SENT due to messages in the same state");
                event.setStatus(EventStatus.NOT_SENT);
@@ -1443,7 +1451,7 @@ export class Room extends EventEmitter {
                let redactedEvent = this.pendingEventList &&
                    this.pendingEventList.find(e => e.getId() === redactId);
                if (!redactedEvent) {
-                    redactedEvent = this.getUnfilteredTimelineSet().findEventById(redactId);
+                    redactedEvent = this.findEventById(redactId);
                }
                if (redactedEvent) {
                    redactedEvent.markLocallyRedacted(event);
@@ -1451,16 +1459,21 @@ export class Room extends EventEmitter {
                }
            }
        } else {
-            for (let i = 0; i < this.timelineSets.length; i++) {
-                const timelineSet = this.timelineSets[i];
-                if (timelineSet.getFilter()) {
-                    if (timelineSet.getFilter().filterRoomTimeline([event]).length) {
+            if (thread) {
+                thread.timelineSet.addEventToTimeline(event,
+                    thread.timelineSet.getLiveTimeline(), false);
+            } else {
+                for (let i = 0; i < this.timelineSets.length; i++) {
+                    const timelineSet = this.timelineSets[i];
+                    if (timelineSet.getFilter()) {
+                        if (timelineSet.getFilter().filterRoomTimeline([event]).length) {
+                            timelineSet.addEventToTimeline(event,
+                                timelineSet.getLiveTimeline(), false);
+                        }
+                    } else {
                        timelineSet.addEventToTimeline(event,
                            timelineSet.getLiveTimeline(), false);
                    }
-                } else {
-                    timelineSet.addEventToTimeline(event,
-                        timelineSet.getLiveTimeline(), false);
                }
            }
        }
@@ -1518,16 +1531,21 @@ export class Room extends EventEmitter {
     * @param {module:models/event.MatrixEvent} event the relation event that needs to be aggregated.
     */
    private aggregateNonLiveRelation(event: MatrixEvent): void {
-        // TODO: We should consider whether this means it would be a better
-        // design to lift the relations handling up to the room instead.
-        for (let i = 0; i < this.timelineSets.length; i++) {
-            const timelineSet = this.timelineSets[i];
-            if (timelineSet.getFilter()) {
-                if (timelineSet.getFilter().filterRoomTimeline([event]).length) {
+        const thread = this.findThreadForEvent(event);
+        if (thread) {
+            thread.timelineSet.aggregateRelations(event);
+        } else {
+            // TODO: We should consider whether this means it would be a better
+            // design to lift the relations handling up to the room instead.
+            for (let i = 0; i < this.timelineSets.length; i++) {
+                const timelineSet = this.timelineSets[i];
+                if (timelineSet.getFilter()) {
+                    if (timelineSet.getFilter().filterRoomTimeline([event]).length) {
+                        timelineSet.aggregateRelations(event);
+                    }
+                } else {
                    timelineSet.aggregateRelations(event);
                }
-            } else {
-                timelineSet.aggregateRelations(event);
            }
        }
    }
@@ -1568,11 +1586,16 @@ export class Room extends EventEmitter {
        // any, which is good, because we don't want to try decoding it again).
        localEvent.handleRemoteEcho(remoteEvent.event);

-        for (let i = 0; i < this.timelineSets.length; i++) {
-            const timelineSet = this.timelineSets[i];
+        const thread = this.threads.get(remoteEvent.threadRootId);
+        if (thread) {
+            thread.timelineSet.handleRemoteEcho(localEvent, oldEventId, newEventId);
+        } else {
+            for (let i = 0; i < this.timelineSets.length; i++) {
+                const timelineSet = this.timelineSets[i];

-            // if it's already in the timeline, update the timeline map. If it's not, add it.
-            timelineSet.handleRemoteEcho(localEvent, oldEventId, newEventId);
+                // if it's already in the timeline, update the timeline map. If it's not, add it.
+                timelineSet.handleRemoteEcho(localEvent, oldEventId, newEventId);
+            }
        }

        this.emit("Room.localEchoUpdated", localEvent, this,
@@ -1605,7 +1628,7 @@ export class Room extends EventEmitter {

        // SENT races against /sync, so we have to special-case it.
        if (newStatus == EventStatus.SENT) {
-            const timeline = this.getUnfilteredTimelineSet().eventIdToTimeline(newEventId);
+            const timeline = this.getTimelineForEvent(newEventId);
            if (timeline) {
                // we've already received the event via the event stream.
                // nothing more to do here.
@@ -1633,11 +1656,16 @@ export class Room extends EventEmitter {
            // update the event id
            event.replaceLocalEventId(newEventId);

-            // if the event was already in the timeline (which will be the case if
-            // opts.pendingEventOrdering==chronological), we need to update the
-            // timeline map.
-            for (let i = 0; i < this.timelineSets.length; i++) {
-                this.timelineSets[i].replaceEventId(oldEventId, newEventId);
+            const thread = this.findThreadForEvent(event);
+            if (thread) {
+                thread.timelineSet.replaceEventId(oldEventId, newEventId);
+            } else {
+                // if the event was already in the timeline (which will be the case if
+                // opts.pendingEventOrdering==chronological), we need to update the
+                // timeline map.
+                for (let i = 0; i < this.timelineSets.length; i++) {
+                    this.timelineSets[i].replaceEventId(oldEventId, newEventId);
+                }
            }
        } else if (newStatus == EventStatus.CANCELLED) {
            // remove it from the pending event list, or the timeline.
@@ -1720,7 +1748,7 @@ export class Room extends EventEmitter {
            // types X Y Z to the timeline".
            this.addLiveEvent(events[i], duplicateStrategy, fromCache);
            const thread = this.threads.get(events[i].getId());
-            if (thread && !thread.ready) {
+            if (thread) {
                thread.addEvent(events[i], true);
            }
        }
@@ -14,12 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { EventEmitter } from "events";
 import { MatrixClient } from "../matrix";
 import { MatrixEvent } from "./event";
 import { EventTimeline } from "./event-timeline";
 import { EventTimelineSet } from './event-timeline-set';
 import { Room } from './room';
+import { TypedEventEmitter } from "./typed-event-emitter";

 export enum ThreadEvent {
    New = "Thread.new",
@@ -30,7 +30,7 @@ export enum ThreadEvent {
 /**
 * @experimental
 */
-export class Thread extends EventEmitter {
+export class Thread extends TypedEventEmitter<ThreadEvent> {
    /**
     * A reference to the event ID at the top of the thread
     */
@@ -40,6 +40,8 @@ export class Thread extends EventEmitter {
     */
    public readonly timelineSet;

+    private _currentUserParticipated = false;
+
    constructor(
        events: MatrixEvent[] = [],
        public readonly room: Room,
@@ -53,11 +55,20 @@ export class Thread extends EventEmitter {
        this.timelineSet = new EventTimelineSet(this.room, {
            unstableClientRelationAggregation: true,
            timelineSupport: true,
-            pendingEvents: false,
+            pendingEvents: true,
        });
        events.forEach(event => this.addEvent(event));
+
+        room.on("Room.localEchoUpdated", this.onEcho);
+        room.on("Room.timeline", this.onEcho);
    }

+    onEcho = (event: MatrixEvent) => {
+        if (this.timelineSet.eventIdToTimeline(event.getId())) {
+            this.emit(ThreadEvent.Update, this);
+        }
+    };
+
    /**
     * Add an event to the thread and updates
     * the tail/root references if needed
@@ -92,9 +103,11 @@ export class Thread extends EventEmitter {
            roomState,
        );

-        if (this.ready) {
-            this.client.decryptEventIfNeeded(event, {});
+        if (!this._currentUserParticipated && event.getSender() === this.client.getUserId()) {
+            this._currentUserParticipated = true;
        }
+
+        await this.client.decryptEventIfNeeded(event, {});
        this.emit(ThreadEvent.Update, this);
    }

@@ -106,10 +119,12 @@ export class Thread extends EventEmitter {
    }

    /**
-     * Determines thread's ready status
+     * Return last reply to the thread
     */
-    public get ready(): boolean {
-        return this.rootEvent !== undefined;
+    public get lastReply(): MatrixEvent {
+        const threadReplies = this.events
+            .filter(event => event.isThreadRelation);
+        return threadReplies[threadReplies.length - 1];
    }

    /**
@@ -141,17 +156,6 @@ export class Thread extends EventEmitter {
            .length;
    }

-    /**
-     * A set of mxid participating to the thread
-     */
-    public get participants(): Set<string> {
-        const participants = new Set<string>();
-        this.events.forEach(event => {
-            participants.add(event.getSender());
-        });
-        return participants;
-    }
-
    /**
     * A getter for the last event added to the thread
     */
@@ -175,28 +179,7 @@ export class Thread extends EventEmitter {
        return this.timelineSet.findEventById(eventId) instanceof MatrixEvent;
    }

-    public on(event: ThreadEvent, listener: (...args: any[]) => void): this {
-        super.on(event, listener);
-        return this;
-    }
-
-    public once(event: ThreadEvent, listener: (...args: any[]) => void): this {
-        super.once(event, listener);
-        return this;
-    }
-
-    public off(event: ThreadEvent, listener: (...args: any[]) => void): this {
-        super.off(event, listener);
-        return this;
-    }
-
-    public addListener(event: ThreadEvent, listener: (...args: any[]) => void): this {
-        super.addListener(event, listener);
-        return this;
-    }
-
-    public removeListener(event: ThreadEvent, listener: (...args: any[]) => void): this {
-        super.removeListener(event, listener);
-        return this;
+    public get hasCurrentUserParticipated(): boolean {
+        return this._currentUserParticipated;
    }
 }
@@ -0,0 +1,83 @@
+/*
+Copyright 2021 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 { EventEmitter } from "events";
+
+enum EventEmitterEvents {
+    NewListener = "newListener",
+    RemoveListener = "removeListener",
+}
+
+/**
+ * Typed Event Emitter class which can act as a Base Model for all our model
+ * and communication events.
+ * This makes it much easier for us to distinguish between events, as we now need
+ * to properly type this, so that our events are not stringly-based and prone
+ * to silly typos.
+ */
+export abstract class TypedEventEmitter<Events extends string> extends EventEmitter {
+    public addListener(event: Events | EventEmitterEvents, listener: (...args: any[]) => void): this {
+        return super.addListener(event, listener);
+    }
+
+    public emit(event: Events | EventEmitterEvents, ...args: any[]): boolean {
+        return super.emit(event, ...args);
+    }
+
+    public eventNames(): (Events | EventEmitterEvents)[] {
+        return super.eventNames() as Events[];
+    }
+
+    public listenerCount(event: Events | EventEmitterEvents): number {
+        return super.listenerCount(event);
+    }
+
+    public listeners(event: Events | EventEmitterEvents): Function[] {
+        return super.listeners(event);
+    }
+
+    public off(event: Events | EventEmitterEvents, listener: (...args: any[]) => void): this {
+        return super.off(event, listener);
+    }
+
+    public on(event: Events | EventEmitterEvents, listener: (...args: any[]) => void): this {
+        return super.on(event, listener);
+    }
+
+    public once(event: Events | EventEmitterEvents, listener: (...args: any[]) => void): this {
+        return super.once(event, listener);
+    }
+
+    public prependListener(event: Events | EventEmitterEvents, listener: (...args: any[]) => void): this {
+        return super.prependListener(event, listener);
+    }
+
+    public prependOnceListener(event: Events | EventEmitterEvents, listener: (...args: any[]) => void): this {
+        return super.prependOnceListener(event, listener);
+    }
+
+    public removeAllListeners(event?: Events | EventEmitterEvents): this {
+        return super.removeAllListeners(event);
+    }
+
+    public removeListener(event: Events | EventEmitterEvents, listener: (...args: any[]) => void): this {
+        return super.removeListener(event, listener);
+    }
+
+    public rawListeners(event: Events | EventEmitterEvents): Function[] {
+        return super.rawListeners(event);
+    }
+}
@@ -0,0 +1,37 @@
+/*
+Copyright 2021 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 { TypedEventEmitter } from "../models/typed-event-emitter";
+
+export enum LocalStorageErrors {
+    Global = 'Global',
+    SetItemError = 'setItem',
+    GetItemError = 'getItem',
+    RemoveItemError = 'removeItem',
+    ClearError = 'clear',
+    QuotaExceededError = 'QuotaExceededError'
+}
+
+/**
+ * Used in element-web as a temporary hack to handle all the localStorage errors on the highest level possible
+ * As of 15.11.2021 (DD/MM/YYYY) we're not properly handling local storage exceptions anywhere.
+ * This store, as an event emitter, is used to re-emit local storage exceptions so that we can handle them
+ * and show some kind of a "It's dead Jim" modal to the users, telling them that hey,
+ * maybe you should check out your disk, as it's probably dying and your session may die with it.
+ * See: https://github.com/vector-im/element-web/issues/18423
+ */
+class LocalStorageErrorsEventsEmitter extends TypedEventEmitter<LocalStorageErrors> {}
+export const localStorageErrorsEventsEmitter = new LocalStorageErrorsEventsEmitter();
@@ -285,7 +285,7 @@ export class SyncApi {
                }
                leaveObj.timeline = leaveObj.timeline || {};
                const events = this.mapSyncEventsFormat(leaveObj.timeline, room);
-                const [timelineEvents, threadedEvents] = this.partitionThreadedEvents(events);
+                const [timelineEvents, threadedEvents] = this.client.partitionThreadedEvents(events);

                const stateEvents = this.mapSyncEventsFormat(leaveObj.state, room);

@@ -307,39 +307,6 @@ export class SyncApi {
        });
    }

-    /**
-     * Split events between the ones that will end up in the main
-     * room timeline versus the one that need to be processed in a thread
-     * @experimental
-     */
-    public partitionThreadedEvents(events: MatrixEvent[]): [MatrixEvent[], MatrixEvent[]] {
-        if (this.opts.experimentalThreadSupport) {
-            return events.reduce((memo, event: MatrixEvent) => {
-                const room = this.client.getRoom(event.getRoomId());
-                // An event should live in the thread timeline if
-                // - It's a reply in thread event
-                // - It's related to a reply in thread event
-                let shouldLiveInThreadTimeline = event.isThreadRelation;
-                if (!shouldLiveInThreadTimeline) {
-                    const parentEventId = event.parentEventId;
-                    const parentEvent = room?.findEventById(parentEventId) || events.find((mxEv: MatrixEvent) => {
-                        return mxEv.getId() === parentEventId;
-                    });
-                    shouldLiveInThreadTimeline = parentEvent?.isThreadRelation;
-                }
-                memo[shouldLiveInThreadTimeline ? 1 : 0].push(event);
-                return memo;
-            }, [[], []]);
-        } else {
-            // When `experimentalThreadSupport` is disabled
-            // treat all events as timelineEvents
-            return [
-                events,
-                [],
-            ];
-        }
-    }
-
    /**
     * Peek into a room. This will result in the room in question being synced so it
     * is accessible via getRooms(). Live updates for the room will be provided.
@@ -538,6 +505,7 @@ export class SyncApi {
            // The logout already happened, we just need to stop.
            logger.warn("Token no longer valid - assuming logout");
            this.stop();
+            this.updateSyncState(SyncState.Error, { error });
            return true;
        }
        return false;
@@ -1320,7 +1288,7 @@ export class SyncApi {
                }
            }

-            const [timelineEvents, threadedEvents] = this.partitionThreadedEvents(events);
+            const [timelineEvents, threadedEvents] = this.client.partitionThreadedEvents(events);

            this.processRoomEvents(room, stateEvents, timelineEvents, syncEventData.fromCache);
            this.processThreadEvents(room, threadedEvents);
@@ -1388,7 +1356,7 @@ export class SyncApi {
            const events = this.mapSyncEventsFormat(leaveObj.timeline, room);
            const accountDataEvents = this.mapSyncEventsFormat(leaveObj.account_data);

-            const [timelineEvents, threadedEvents] = this.partitionThreadedEvents(events);
+            const [timelineEvents, threadedEvents] = this.client.partitionThreadedEvents(events);

            this.processRoomEvents(room, stateEvents, timelineEvents);
            this.processThreadEvents(room, threadedEvents);
@@ -1734,11 +1702,7 @@ export class SyncApi {
     * @experimental
     */
    private processThreadEvents(room: Room, threadedEvents: MatrixEvent[]): void {
-        threadedEvents
-            .sort((a, b) => a.getTs() - b.getTs())
-            .forEach(event => {
-                room.addThreadedEvent(event);
-            });
+        return this.client.processThreadEvents(room, threadedEvents);
    }

    // extractRelatedEvents(event: MatrixEvent, events: MatrixEvent[], relatedEvents: MatrixEvent[] = []): MatrixEvent[] {
@@ -99,7 +99,7 @@ export class TimelineWindow {
     *
     * @return {Promise}
     */
-    public load(initialEventId: string, initialWindowSize = 20): Promise<any> {
+    public load(initialEventId?: string, initialWindowSize = 20): Promise<any> {
        // given an EventTimeline, find the event we were looking for, and initialise our
        // fields so that the event in question is in the middle of the window.
        const initFields = (timeline: EventTimeline) => {
@@ -583,8 +583,8 @@ export class MatrixCall extends EventEmitter {
                new CallFeed({
                    client: this.client,
                    roomId: this.roomId,
-                    audioMuted: stream.getAudioTracks().length === 0,
-                    videoMuted: stream.getVideoTracks().length === 0,
+                    audioMuted: false,
+                    videoMuted: false,
                    userId,
                    stream,
                    purpose,
@@ -822,8 +822,8 @@ export class MatrixCall extends EventEmitter {
                    userId: this.client.getUserId(),
                    stream,
                    purpose: SDPStreamMetadataPurpose.Usermedia,
-                    audioMuted: stream.getAudioTracks().length === 0,
-                    videoMuted: stream.getVideoTracks().length === 0,
+                    audioMuted: false,
+                    videoMuted: false,
                });

                const feeds = [usermediaFeed];
@@ -2063,8 +2063,8 @@ export class MatrixCall extends EventEmitter {
                userId: this.client.getUserId(),
                stream,
                purpose: SDPStreamMetadataPurpose.Usermedia,
-                audioMuted: stream.getAudioTracks().length === 0,
-                videoMuted: stream.getVideoTracks().length === 0,
+                audioMuted: false,
+                videoMuted: false,
            });
            await this.placeCallWithCallFeeds([callFeed]);
        } catch (e) {
@@ -29,7 +29,13 @@ export interface ICallFeedOpts {
    userId: string;
    stream: MediaStream;
    purpose: SDPStreamMetadataPurpose;
+    /**
+     * Whether or not the remote SDPStreamMetadata says audio is muted
+     */
    audioMuted: boolean;
+    /**
+     * Whether or not the remote SDPStreamMetadata says video is muted
+     */
    videoMuted: boolean;
 }

@@ -1210,9 +1210,9 @@
    "@types/yargs" "^15.0.0"
    chalk "^4.0.0"

-"@matrix-org/olm@https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.3.tgz":
-  version "3.2.3"
-  resolved "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.3.tgz#cc332fdd25c08ef0e40f4d33fc3f822a0f98b6f4"
+"@matrix-org/olm@https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.8.tgz":
+  version "3.2.8"
+  resolved "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.8.tgz#8d53636d045e1776e2a2ec6613e57330dd9ce856"

 "@nicolo-ribaudo/chokidar-2@2.1.8-no-fsevents.3":
  version "2.1.8-no-fsevents.3"
@@ -1693,10 +1693,10 @@ align-text@^0.1.1, align-text@^0.1.3:
    longest "^1.0.1"
    repeat-string "^1.5.2"

-allchange@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/allchange/-/allchange-1.0.5.tgz#9496425eea8ff1a2e57b37d059333df6c3d37382"
-  integrity sha512-g3VYQfhvc42L0Mr9JTsZlVSrms4TbvqrvONj13M8NHKvp25XR9d5xS05wXqh9+mh0tYcAWDrOvAoceCzSzijBA==
+allchange@^1.0.6:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/allchange/-/allchange-1.0.6.tgz#f905918255541dc92d6a1f5cdf758db4597f569c"
+  integrity sha512-37a4J55oSxhLmlS/DeBOKjKn5dbjkyR4qMJ9is8+CKLPTe7NybcWBYvrPLr9kVLBa6aigWrdovRHrQj/4v6k4w==
  dependencies:
    "@actions/core" "^1.4.0"
    "@actions/github" "^5.0.0"
Author	SHA1	Message	Date
RiotRobot	f4839a3b4f	v15.2.1	2021-12-13 15:17:37 +00:00
RiotRobot	4b21b67a45	Prepare changelog for v15.2.1	2021-12-13 15:17:37 +00:00
David Baker	799a83a115	Update olm to 3.2.8 (#2062 )	2021-12-13 14:59:03 +00:00
RiotRobot	45b7cab203	v15.2.0	2021-12-06 15:10:51 +00:00
RiotRobot	4dfc3b9dbb	Prepare changelog for v15.2.0	2021-12-06 15:10:50 +00:00
RiotRobot	46a0645865	v15.2.0-rc.1	2021-11-30 18:16:24 +00:00
RiotRobot	2b30f45f60	Prepare changelog for v15.2.0-rc.1	2021-11-30 18:16:23 +00:00
J. Ryan Stinnett	87b920698f	Upgrade allchange to 1.0.6 (#2042 )	2021-11-30 17:55:38 +00:00
Germain	4f4811e1d9	Emit thread update after event decryption (#2040 )	2021-11-30 14:40:59 +00:00
Hugh Nimmo-Smith	db9936e07c	Standardise content type handling in MSC3089 createFile() and createNewVersion() (#2014 ) * Provide cross platform compatible versions of createFile() and createNewVersion() The exist implementations are deprecated as they only work in a browser and support a different type of contents from MatrixClient.uploadContent() * Fix MSC3089 content upload meta data in NodeJS runtime * Break unstable createFile() and createNewVersion() instead of deprecating Test using NodeJS types instead of mocked browser Blob * chore: remove incorrect comment	2021-11-30 09:02:41 +00:00
Hugh Nimmo-Smith	7dcee2eb40	Implementation of deriveKey() for NodeJS (#2021 ) Based on approach used by aes.ts	2021-11-30 09:02:26 +00:00
skyka13711	6b34ea6fe5	Exporting missing types (#2023 ) * fix types export * fix lint * index.ts fix exports * revert yarn.lock Co-authored-by: Alexey Avramenko <2822698@gmail.com> Co-authored-by: nikita <nikita@42px.ru>	2021-11-29 19:54:08 -07:00
Germain	b33b01df0f	Handle remote echo when creating a thread (#2038 )	2021-11-25 08:27:13 +00:00
Germain	1c895432ed	Fix backwards compatibility for redactEvent (#2039 )	2021-11-24 15:42:10 +00:00
Germain	ddd6a05198	Make local echo work for threads (#2026 )	2021-11-24 08:19:17 +00:00
Germain	0ccde7807f	Comprehensive events emitter typing (#2034 )	2021-11-23 15:16:35 +00:00
Will Hunt	9f97992196	getStateEvent should return any (#2032 ) * getStateEvent returns any getStateEvent returns the content of an event, not the whole state event as per https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-rooms-roomid-state-eventtype-statekey * Make the return type Record<string, any> Co-authored-by: Michael Telatynski <7t3chguy@gmail.com> Co-authored-by: Michael Telatynski <7t3chguy@gmail.com>	2021-11-23 13:54:54 +00:00
Germain	67b8da719f	Add a flag to track user participation in a thread (#2030 )	2021-11-23 08:20:27 +00:00
Šimon Brandner	04fad564f7	Fix call upgrades (#2024 ) * Init call feeds with non-muted state Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com> * Improve CallFeed docs Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-11-22 18:17:35 -07:00
Germain	aee698c285	Add KeyVerificationRequest msgType (#2033 )	2021-11-22 17:08:24 +00:00
RiotRobot	55b489b17a	Resetting package fields for development	2021-11-22 13:32:08 +00:00
RiotRobot	c5d188c30a	Merge branch 'master' into develop	2021-11-22 13:32:08 +00:00
RiotRobot	6fff3d6db5	v15.1.1	2021-11-22 13:28:39 +00:00
RiotRobot	8043d83921	Prepare changelog for v15.1.1	2021-11-22 13:28:39 +00:00
Michael Telatynski	b2d83c1f80	Iterate type definitions (#2029 )	2021-11-19 17:35:09 +00:00
Travis Ralston	1b91cd7037	Add optional force parameter when ensuring Olm sessions (#2027 ) This is useful for debugging crypto where Element's `/discardsession` doesn't reset the Olm session.	2021-11-19 07:33:45 -07:00
skyka13711	0baf926c84	TimelineWindow fix load function signature (#2028 )	2021-11-19 09:00:08 +00:00
Robert Long	763e25e031	Update sync state to error when aborting (#2025 )	2021-11-18 12:16:57 -08:00
RiotRobot	861023b3f6	v15.1.1-rc.1	2021-11-17 13:52:47 +00:00
RiotRobot	1f5a83994b	Prepare changelog for v15.1.1-rc.1	2021-11-17 13:52:47 +00:00
Dariusz Niemczyk	af523522de	Add LocalStorageErrorEventListener (#2019 ) Add a way to listen to LocalStorage error events from element-web and matrix-react-sdk in the same manner. Related: https://github.com/vector-im/element-web/issues/18423	2021-11-15 18:08:20 +00:00
Dariusz Niemczyk	c3a266b3e7	Implement TypedEventEmitter for better TS support (#2018 ) We're using stringly typed events everywhere, this is the first step for better typescript support with our event emitters before we replace it with something much better for React support.	2021-11-15 14:47:21 +00:00
Callum Brown	f41d815aa6	Add registration token UIA type (#2020 )	2021-11-15 09:16:23 +00:00
Germain	ad8a93dde8	Fix check supportExperimentalThreads (#2017 )	2021-11-10 10:54:13 +00:00
Germain	b07d44a6c0	Getter for last thread reply (#2015 )	2021-11-09 14:46:48 +00:00
RiotRobot	1dc899ba6e	Resetting package fields for development	2021-11-08 17:37:26 +00:00
RiotRobot	0b1e3edaff	Merge branch 'master' into develop	2021-11-08 17:37:25 +00:00
RiotRobot	9fb4fed044	v15.1.0	2021-11-08 17:34:08 +00:00
RiotRobot	730b0b121d	Prepare changelog for v15.1.0	2021-11-08 17:34:07 +00:00
Aaron R	9d9d9e2cfa	Fix edit history being broken after editing an unencrypted event with an encrypted event (#2013 )	2021-11-08 08:55:41 +00:00
Germain	43bc09f392	Copy relations to thread root in the thread timeline (#2012 )	2021-11-05 14:16:45 +00:00
Germain	195498e9db	Make events pagination responses parse threads (#2011 )	2021-11-04 11:29:14 +00:00
Faye Duxovni	50332c4999	End authentication attempt immediately if we couldn't find an appropriate flow (#2008 ) If `doRequest()` in `interactive-auth.ts` fails to obtain an appropriate authentication flow, it should return immediately after rejecting the promise. If it continues, it'll attempt to check `chosenFlow.stages`, which will cause an error because `chosenFlow` is `null`. This was breaking the interactive auth spec tests with Node 16.	2021-11-02 10:40:46 -04:00