v39.3.0

v39.3.0-rc.0
Re-add truthy check on room name/avatar/alias events (#5081 )
2025-12-02 14:44:30 +00:00 · 2025-11-25 14:10:43 +00:00 · 2025-11-25 09:09:11 +00:00 · 2025-11-24 09:07:13 +00:00 · 2025-11-18 14:27:42 +00:00 · 2025-11-18 14:26:56 +00:00
31 changed files with 2156 additions and 1602 deletions
@@ -15,7 +15,7 @@ jobs:
            deployments: write
        steps:
            - name: 📥 Download artifact
-              uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5
+              uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6
              with:
                  github-token: ${{ secrets.GITHUB_TOKEN }}
                  run-id: ${{ github.event.workflow_run.id }}
@@ -4,8 +4,6 @@ on:
        secrets:
            ELEMENT_BOT_TOKEN:
                required: true
-            NPM_TOKEN:
-                required: false
            GPG_PASSPHRASE:
                required: false
            GPG_PRIVATE_KEY:
@@ -282,8 +280,6 @@ jobs:
        permissions:
            contents: read
            id-token: write
-        secrets:
-            NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

    post-release:
        name: Post release steps
@@ -1,9 +1,6 @@
 name: Publish to npm
 on:
    workflow_call:
-        secrets:
-            NPM_TOKEN:
-                required: true
        outputs:
            id:
                description: "The npm package@version string we published"
@@ -31,21 +28,18 @@ jobs:
                  registry-url: "https://registry.npmjs.org"
                  node-version-file: package.json

+            # Ensure npm 11.5.1 or later is installed
+            - name: Update npm
+              run: npm install -g npm@latest
+
            - name: 🔨 Install dependencies
              run: "yarn install --frozen-lockfile"

            - name: 🚀 Publish to npm
              id: npm-publish
              run: |
-                  npm publish --provenance --access public --tag next
+                  npm publish --provenance --access public --tag "$TAG"
                  release=$(jq -r '"\(.name)@\(.version)"' package.json)
                  echo "id=$release" >> $GITHUB_OUTPUT
              env:
-                  NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-            - name: 🎖️ Add `latest` dist-tag to final releases
-              if: steps.npm-publish.outputs.id && !contains(steps.npm-publish.outputs.id, '-rc.')
-              run: npm dist-tag add "$release" latest
-              env:
-                  NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-                  release: ${{ steps.npm-publish.outputs.id }}
+                  TAG: ${{ contains(steps.npm-publish.outputs.id, '-rc.') && 'next' || 'latest' }}
@@ -43,7 +43,7 @@ jobs:
                  fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis

            - name: 📥 Download artifact
-              uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5
+              uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6
              if: ${{ !inputs.sharded }}
              with:
                  github-token: ${{ secrets.GITHUB_TOKEN }}
@@ -51,7 +51,7 @@ jobs:
                  name: coverage
                  path: coverage
            - name: 📥 Download sharded artifacts
-              uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5
+              uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6
              if: inputs.sharded
              with:
                  github-token: ${{ secrets.GITHUB_TOKEN }}
@@ -114,7 +114,7 @@ jobs:
              run: "yarn run gendoc --treatWarningsAsErrors --suppressCommentWarningsInDeclarationFiles"

            - name: Upload Artifact
-              uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+              uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5
              with:
                  name: docs
                  path: _docs
@@ -57,7 +57,7 @@ jobs:

            - name: Upload Artifact
              if: env.ENABLE_COVERAGE == 'true'
-              uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+              uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5
              with:
                  name: coverage-${{ matrix.specs }}-${{ matrix.node == 'lts/*' && 'lts' || matrix.node }}
                  path: |
@@ -1,3 +1,33 @@
+Changes in [39.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v39.3.0) (2025-12-02)
+==================================================================================================
+## 🐛 Bug Fixes
+
+* Re-add truthy check on room name/avatar/alias events ([#5081](https://github.com/matrix-org/matrix-js-sdk/pull/5081)). Contributed by @t3chguy.
+* Fix invalid state events corrupting room objects ([#5078](https://github.com/matrix-org/matrix-js-sdk/pull/5078)). Contributed by @t3chguy.
+
+
+Changes in [39.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v39.2.0) (2025-11-18)
+==================================================================================================
+## ✨ Features
+
+* Delayed event management: split endpoints, no auth ([#5066](https://github.com/matrix-org/matrix-js-sdk/pull/5066)). Contributed by @AndrewFerr.
+* do not set cache in authenticated fetch ([#5020](https://github.com/matrix-org/matrix-js-sdk/pull/5020)). Contributed by @pkuzco.
+
+## 🐛 Bug Fixes
+
+* Fix media switching during legacy calls ([#5069](https://github.com/matrix-org/matrix-js-sdk/pull/5069)). Contributed by @langleyd.
+
+
+Changes in [39.1.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v39.1.2) (2025-11-04)
+==================================================================================================
+Re-release of v39.1.0 to fix npm publishing workflow
+
+
+
+Changes in [39.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v39.1.1) (2025-11-04)
+==================================================================================================
+Re-release of v39.1.0 to fix npm publishing workflow
+
 Changes in [39.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v39.1.0) (2025-11-04)
 ==================================================================================================
 ## ✨ Features
@@ -1,6 +1,6 @@
 {
    "name": "matrix-js-sdk",
-    "version": "39.1.0",
+    "version": "39.3.0",
    "description": "Matrix Client-Server SDK for Javascript",
    "engines": {
        "node": ">=22.0.0"
@@ -56,10 +56,10 @@
        "jwt-decode": "^4.0.0",
        "loglevel": "^1.9.2",
        "matrix-events-sdk": "0.0.1",
-        "matrix-widget-api": "^1.10.0",
+        "matrix-widget-api": "^1.14.0",
        "oidc-client-ts": "^3.0.1",
        "p-retry": "7",
-        "sdp-transform": "^2.14.1",
+        "sdp-transform": "^3.0.0",
        "unhomoglyph": "^1.0.6",
        "uuid": "13"
    },
@@ -84,12 +84,12 @@
        "@stylistic/eslint-plugin": "^5.0.0",
        "@types/content-type": "^1.1.5",
        "@types/debug": "^4.1.7",
-        "@types/jest": "^29.0.0",
+        "@types/jest": "^30.0.0",
        "@types/node": "18",
        "@types/sdp-transform": "^2.4.5",
        "@typescript-eslint/eslint-plugin": "^8.0.0",
        "@typescript-eslint/parser": "^8.0.0",
-        "babel-jest": "^29.0.0",
+        "babel-jest": "^30.0.0",
        "babel-plugin-search-and-replace": "^1.1.1",
        "debug": "^4.3.4",
        "eslint": "8.57.1",
@@ -107,10 +107,10 @@
        "fetch-mock": "11.1.5",
        "fetch-mock-jest": "^1.5.1",
        "husky": "^9.0.0",
-        "jest": "^29.0.0",
-        "jest-environment-jsdom": "^29.0.0",
+        "jest": "^30.0.0",
+        "jest-environment-jsdom": "^30.0.0",
        "jest-localstorage-mock": "^2.4.6",
-        "jest-mock": "^29.0.0",
+        "jest-mock": "^30.0.0",
        "knip": "^5.0.0",
        "lint-staged": "^16.0.0",
        "matrix-mock-request": "^2.5.0",
@@ -86,7 +86,9 @@ class MockWidgetApi extends EventEmitter {
                ? { event_id: `$${Math.random()}` }
                : { delay_id: `id-${Math.random()}` },
    );
-    public updateDelayedEvent = jest.fn().mockResolvedValue(undefined);
+    public cancelScheduledDelayedEvent = jest.fn().mockResolvedValue(undefined);
+    public restartScheduledDelayedEvent = jest.fn().mockResolvedValue(undefined);
+    public sendScheduledDelayedEvent = jest.fn().mockResolvedValue(undefined);
    public sendToDevice = jest.fn().mockResolvedValue(undefined);
    public requestOpenIDConnectToken = jest.fn(async () => {
        return testOIDCToken;
@@ -531,17 +533,49 @@ describe("RoomWidgetClient", () => {
                ).rejects.toThrow();
            });

-            it("updates delayed events", async () => {
+            it.each([UpdateDelayedEventAction.Cancel, UpdateDelayedEventAction.Restart, UpdateDelayedEventAction.Send])(
+                "can %s scheduled delayed events (action in parameter)",
+                async (action: UpdateDelayedEventAction) => {
+                    await makeClient({ updateDelayedEvents: true, sendEvent: ["org.matrix.rageshake_request"] });
+                    expect(widgetApi.requestCapability).toHaveBeenCalledWith(
+                        MatrixCapabilities.MSC4157UpdateDelayedEvent,
+                    );
+                    await client._unstable_updateDelayedEvent("id", action);
+                    let updateDelayedEvent: (delayId: string) => Promise<unknown>;
+                    switch (action) {
+                        case UpdateDelayedEventAction.Cancel:
+                            updateDelayedEvent = widgetApi.cancelScheduledDelayedEvent;
+                            break;
+                        case UpdateDelayedEventAction.Restart:
+                            updateDelayedEvent = widgetApi.cancelScheduledDelayedEvent;
+                            break;
+                        case UpdateDelayedEventAction.Send:
+                            updateDelayedEvent = widgetApi.sendScheduledDelayedEvent;
+                            break;
+                    }
+                    expect(updateDelayedEvent).toHaveBeenCalledWith("id");
+                },
+            );
+
+            it("can cancel scheduled delayed events (action in method)", async () => {
                await makeClient({ updateDelayedEvents: true, sendEvent: ["org.matrix.rageshake_request"] });
                expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157UpdateDelayedEvent);
-                for (const action of [
-                    UpdateDelayedEventAction.Cancel,
-                    UpdateDelayedEventAction.Restart,
-                    UpdateDelayedEventAction.Send,
-                ]) {
-                    await client._unstable_updateDelayedEvent("id", action);
-                    expect(widgetApi.updateDelayedEvent).toHaveBeenCalledWith("id", action);
-                }
+                await client._unstable_cancelScheduledDelayedEvent("id");
+                expect(widgetApi.cancelScheduledDelayedEvent).toHaveBeenCalledWith("id");
+            });
+
+            it("can restart scheduled delayed events (action in method)", async () => {
+                await makeClient({ updateDelayedEvents: true, sendEvent: ["org.matrix.rageshake_request"] });
+                expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157UpdateDelayedEvent);
+                await client._unstable_restartScheduledDelayedEvent("id");
+                expect(widgetApi.restartScheduledDelayedEvent).toHaveBeenCalledWith("id");
+            });
+
+            it("can send scheduled delayed events (action in method)", async () => {
+                await makeClient({ updateDelayedEvents: true, sendEvent: ["org.matrix.rageshake_request"] });
+                expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157UpdateDelayedEvent);
+                await client._unstable_sendScheduledDelayedEvent("id");
+                expect(widgetApi.sendScheduledDelayedEvent).toHaveBeenCalledWith("id");
            });
        });

@@ -583,6 +617,13 @@ describe("RoomWidgetClient", () => {
                        "Server does not support",
                    );
                }
+                for (const updateDelayedEvent of [
+                    client._unstable_cancelScheduledDelayedEvent,
+                    client._unstable_restartScheduledDelayedEvent,
+                    client._unstable_sendScheduledDelayedEvent,
+                ]) {
+                    await expect(updateDelayedEvent.call(client, "id")).rejects.toThrow("Server does not support");
+                }
            });
        });
    });
@@ -1,4 +1,4 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing

 exports[`MatrixHttpApi should return expected object from \`getContentUri\` 1`] = `
 {
@@ -375,7 +375,7 @@ describe("FetchHttpApi", () => {
                            refreshToken,
                            onlyData: true,
                        });
-                        await expect(api.authedRequest(Method.Post, "/account/password")).rejects.toThrow(
+                        await expect(api.authedRequest(Method.Post, "/account/password")).rejects.toEqual(
                            unknownTokenErr,
                        );
                        expect(tokenRefreshFunction).toHaveBeenCalledWith(refreshToken);
@@ -397,7 +397,7 @@ describe("FetchHttpApi", () => {
                            refreshToken,
                            onlyData: true,
                        });
-                        await expect(api.authedRequest(Method.Post, "/account/password")).rejects.toThrow(
+                        await expect(api.authedRequest(Method.Post, "/account/password")).rejects.toEqual(
                            unknownTokenErr,
                        );
                        expect(tokenRefreshFunction).toHaveBeenCalledWith(refreshToken);
@@ -801,6 +801,10 @@ describe("MatrixClient", function () {
            await expect(
                client._unstable_updateDelayedEvent("anyDelayId", UpdateDelayedEventAction.Send),
            ).rejects.toThrow(errorMessage);
+
+            await expect(client._unstable_cancelScheduledDelayedEvent("anyDelayId")).rejects.toThrow(errorMessage);
+            await expect(client._unstable_restartScheduledDelayedEvent("anyDelayId")).rejects.toThrow(errorMessage);
+            await expect(client._unstable_sendScheduledDelayedEvent("anyDelayId")).rejects.toThrow(errorMessage);
        });

        it("works with null threadId", async () => {
@@ -1077,21 +1081,169 @@ describe("MatrixClient", function () {
            });
        });

-        it("can update delayed events", async () => {
+        it.each([UpdateDelayedEventAction.Cancel, UpdateDelayedEventAction.Restart, UpdateDelayedEventAction.Send])(
+            "can %s scheduled delayed events (action in request body)",
+            async (action: UpdateDelayedEventAction) => {
+                const delayId = "id";
+                httpLookups = [
+                    {
+                        method: "POST",
+                        prefix: unstableMSC4140Prefix,
+                        path: `/delayed_events/${encodeURIComponent(delayId)}`,
+                        data: {
+                            action,
+                        },
+                    },
+                ];
+
+                await client._unstable_updateDelayedEvent(delayId, action);
+            },
+        );
+
+        it.each([UpdateDelayedEventAction.Cancel, UpdateDelayedEventAction.Restart, UpdateDelayedEventAction.Send])(
+            "can %s scheduled delayed events (action in request body fallback when auth required)",
+            async (action: UpdateDelayedEventAction) => {
+                const delayId = "id";
+                const baseLookup = {
+                    method: "POST",
+                    prefix: unstableMSC4140Prefix,
+                    path: `/delayed_events/${encodeURIComponent(delayId)}`,
+                };
+                httpLookups = [
+                    {
+                        ...baseLookup,
+                        error: {
+                            httpStatus: 401,
+                            errcode: "M_MISSING_TOKEN",
+                        },
+                    },
+                    {
+                        ...baseLookup,
+                        data: {
+                            action,
+                        },
+                    },
+                ];
+
+                await client._unstable_updateDelayedEvent(delayId, action);
+            },
+        );
+
+        it("can cancel scheduled delayed events (action in request path)", async () => {
            const delayId = "id";
-            const action = UpdateDelayedEventAction.Restart;
            httpLookups = [
+                {
+                    method: "POST",
+                    prefix: unstableMSC4140Prefix,
+                    path: `/delayed_events/${encodeURIComponent(delayId)}/cancel`,
+                },
+            ];
+
+            await client._unstable_cancelScheduledDelayedEvent(delayId);
+        });
+
+        it("can restart scheduled delayed events (action in request path)", async () => {
+            const delayId = "id";
+            httpLookups = [
+                {
+                    method: "POST",
+                    prefix: unstableMSC4140Prefix,
+                    path: `/delayed_events/${encodeURIComponent(delayId)}/restart`,
+                },
+            ];
+
+            await client._unstable_restartScheduledDelayedEvent(delayId);
+        });
+
+        it("can send scheduled delayed events (action in request path)", async () => {
+            const delayId = "id";
+            httpLookups = [
+                {
+                    method: "POST",
+                    prefix: unstableMSC4140Prefix,
+                    path: `/delayed_events/${encodeURIComponent(delayId)}/send`,
+                },
+            ];
+
+            await client._unstable_sendScheduledDelayedEvent(delayId);
+        });
+
+        it("can cancel scheduled delayed events (action in request path fallback when unsupported)", async () => {
+            const delayId = "id";
+            httpLookups = [
+                {
+                    method: "POST",
+                    prefix: unstableMSC4140Prefix,
+                    path: `/delayed_events/${encodeURIComponent(delayId)}/cancel`,
+                    error: {
+                        httpStatus: 400,
+                        errcode: "M_UNRECOGNIZED",
+                    },
+                },
                {
                    method: "POST",
                    prefix: unstableMSC4140Prefix,
                    path: `/delayed_events/${encodeURIComponent(delayId)}`,
                    data: {
-                        action,
+                        action: UpdateDelayedEventAction.Cancel,
                    },
                },
            ];

-            await client._unstable_updateDelayedEvent(delayId, action);
+            await client._unstable_cancelScheduledDelayedEvent(delayId);
+            expect(httpLookups).toHaveLength(0);
+        });
+
+        it("can restart scheduled delayed events (action in request path fallback when unsupported)", async () => {
+            const delayId = "id";
+            httpLookups = [
+                {
+                    method: "POST",
+                    prefix: unstableMSC4140Prefix,
+                    path: `/delayed_events/${encodeURIComponent(delayId)}/restart`,
+                    error: {
+                        httpStatus: 400,
+                        errcode: "M_UNRECOGNIZED",
+                    },
+                },
+                {
+                    method: "POST",
+                    prefix: unstableMSC4140Prefix,
+                    path: `/delayed_events/${encodeURIComponent(delayId)}`,
+                    data: {
+                        action: UpdateDelayedEventAction.Restart,
+                    },
+                },
+            ];
+
+            await client._unstable_restartScheduledDelayedEvent(delayId);
+            expect(httpLookups).toHaveLength(0);
+        });
+
+        it("can send scheduled delayed events (action in request path fallback when unsupported)", async () => {
+            const delayId = "id";
+            httpLookups = [
+                {
+                    method: "POST",
+                    prefix: unstableMSC4140Prefix,
+                    path: `/delayed_events/${encodeURIComponent(delayId)}/send`,
+                    error: {
+                        httpStatus: 400,
+                        errcode: "M_UNRECOGNIZED",
+                    },
+                },
+                {
+                    method: "POST",
+                    prefix: unstableMSC4140Prefix,
+                    path: `/delayed_events/${encodeURIComponent(delayId)}`,
+                    data: {
+                        action: UpdateDelayedEventAction.Send,
+                    },
+                },
+            ];
+
+            await client._unstable_sendScheduledDelayedEvent(delayId);
+            expect(httpLookups).toHaveLength(0);
        });
    });

@@ -523,6 +523,9 @@ describe("MatrixRTCSession", () => {
            client.sendEvent = sendEventMock;

            client._unstable_updateDelayedEvent = jest.fn();
+            client._unstable_cancelScheduledDelayedEvent = jest.fn();
+            client._unstable_restartScheduledDelayedEvent = jest.fn();
+            client._unstable_sendScheduledDelayedEvent = jest.fn();

            mockRoom = makeMockRoom([]);
            sess = MatrixRTCSession.sessionForRoom(client, mockRoom, callSession);
@@ -94,6 +94,9 @@ describe("MembershipManager", () => {
        // Provide a default mock that is like the default "non error" server behaviour.
        (client._unstable_sendDelayedStateEvent as Mock<any>).mockResolvedValue({ delay_id: "id" });
        (client._unstable_updateDelayedEvent as Mock<any>).mockResolvedValue(undefined);
+        (client._unstable_cancelScheduledDelayedEvent as Mock<any>).mockResolvedValue(undefined);
+        (client._unstable_restartScheduledDelayedEvent as Mock<any>).mockResolvedValue(undefined);
+        (client._unstable_sendScheduledDelayedEvent as Mock<any>).mockResolvedValue(undefined);
        (client._unstable_sendStickyEvent as Mock<any>).mockResolvedValue({ event_id: "id" });
        (client._unstable_sendStickyDelayedEvent as Mock<any>).mockResolvedValue({ delay_id: "id" });
        (client.sendStateEvent as Mock<any>).mockResolvedValue({ event_id: "id" });
@@ -122,7 +125,9 @@ describe("MembershipManager", () => {
            it("sends a membership event and schedules delayed leave when joining a call", async () => {
                // Spys/Mocks

-                const updateDelayedEventHandle = createAsyncHandle<void>(client._unstable_updateDelayedEvent as Mock);
+                const restartScheduledDelayedEventHandle = createAsyncHandle<void>(
+                    client._unstable_restartScheduledDelayedEvent as Mock,
+                );

                // Test
                const memberManager = new MembershipManager(undefined, room, client, callSession);
@@ -143,7 +148,7 @@ describe("MembershipManager", () => {
                    },
                    "_@alice:example.org_AAAAAAA_m.call",
                );
-                updateDelayedEventHandle.resolve?.();
+                restartScheduledDelayedEventHandle.resolve?.();
                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledWith(
                    room.roomId,
                    { delay: 8000 },
@@ -157,13 +162,13 @@ describe("MembershipManager", () => {
            it("reschedules delayed leave event if sending state cancels it", async () => {
                const memberManager = new MembershipManager(undefined, room, client, callSession);
                const waitForSendState = waitForMockCall(client.sendStateEvent);
-                const waitForUpdateDelaye = waitForMockCallOnce(
-                    client._unstable_updateDelayedEvent,
+                const waitForRestartScheduledDelayedEvent = waitForMockCallOnce(
+                    client._unstable_restartScheduledDelayedEvent,
                    Promise.reject(new MatrixError({ errcode: "M_NOT_FOUND" })),
                );
                memberManager.join([focus], focusActive);
                await waitForSendState;
-                await waitForUpdateDelaye;
+                await waitForRestartScheduledDelayedEvent;
                await jest.advanceTimersByTimeAsync(1);
                // Once for the initial event and once because of the errcode: "M_NOT_FOUND"
                // Different to "sends a membership event and schedules delayed leave when joining a call" where its only called once (1)
@@ -179,7 +184,7 @@ describe("MembershipManager", () => {
                    if (useOwnedStateEvents) {
                        room.getVersion = jest.fn().mockReturnValue("org.matrix.msc3757.default");
                    }
-                    const updatedDelayedEvent = waitForMockCall(client._unstable_updateDelayedEvent);
+                    const restartScheduledDelayedEvent = waitForMockCall(client._unstable_restartScheduledDelayedEvent);
                    const sentDelayedState = waitForMockCall(
                        client._unstable_sendDelayedStateEvent,
                        Promise.resolve({
@@ -265,13 +270,13 @@ describe("MembershipManager", () => {
                    await sentDelayedState;

                    // should have prepared the heartbeat to keep delaying the leave event while still connected
-                    await updatedDelayedEvent;
-                    expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(1);
+                    await restartScheduledDelayedEvent;
+                    expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalledTimes(1);

                    // ensures that we reach the code that schedules the timeout for the next delay update before we advance the timers.
                    await jest.advanceTimersByTimeAsync(5000);
                    // should update delayed disconnect
-                    expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(2);
+                    expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalledTimes(2);
                }

                it("sends a membership event after rate limits during delayed event setup when joining a call", async () => {
@@ -343,7 +348,7 @@ describe("MembershipManager", () => {
            //   (onRTCSessionMemberUpdate)
            // - Only then do we resolve the sending of the delayed event.
            // - We test that the manager acknowledges the leave and sends a new membership state event.
-            (client._unstable_updateDelayedEvent as Mock<any>).mockRejectedValueOnce(
+            (client._unstable_restartScheduledDelayedEvent as Mock<any>).mockRejectedValueOnce(
                new MatrixError({ errcode: "M_NOT_FOUND" }),
            );

@@ -404,17 +409,17 @@ describe("MembershipManager", () => {
            manager.join([focus]);
            await jest.advanceTimersByTimeAsync(1);
            await manager.leave();
-            expect(client._unstable_updateDelayedEvent).toHaveBeenLastCalledWith("id", "send");
+            expect(client._unstable_sendScheduledDelayedEvent).toHaveBeenLastCalledWith("id");
            expect(client.sendStateEvent).toHaveBeenCalled();
        });
        it("send leave event when leave is called and resolving delayed leave fails", async () => {
            const manager = new MembershipManager({}, room, client, callSession);
            manager.join([focus]);
            await jest.advanceTimersByTimeAsync(1);
-            (client._unstable_updateDelayedEvent as Mock<any>).mockRejectedValue("unknown");
+            (client._unstable_sendScheduledDelayedEvent as Mock<any>).mockRejectedValue("unknown");
            await manager.leave();

-            // We send a normal leave event since we failed using updateDelayedEvent with the "send" action.
+            // We send a normal leave event since we failed using sendScheduledDelayedEvent.
            expect(client.sendStateEvent).toHaveBeenLastCalledWith(
                room.roomId,
                "org.matrix.msc3401.call.member",
@@ -438,6 +443,9 @@ describe("MembershipManager", () => {
            expect(client.sendStateEvent).not.toHaveBeenCalled();
            expect(client._unstable_sendDelayedStateEvent).not.toHaveBeenCalled();
            expect(client._unstable_updateDelayedEvent).not.toHaveBeenCalled();
+            expect(client._unstable_cancelScheduledDelayedEvent).not.toHaveBeenCalled();
+            expect(client._unstable_restartScheduledDelayedEvent).not.toHaveBeenCalled();
+            expect(client._unstable_sendScheduledDelayedEvent).not.toHaveBeenCalled();
        });
        it("does nothing if own membership still present", async () => {
            const manager = new MembershipManager({}, room, client, callSession);
@@ -447,6 +455,9 @@ describe("MembershipManager", () => {
            // reset all mocks before checking what happens when calling: `onRTCSessionMemberUpdate`
            (client.sendStateEvent as Mock).mockClear();
            (client._unstable_updateDelayedEvent as Mock).mockClear();
+            (client._unstable_cancelScheduledDelayedEvent as Mock).mockClear();
+            (client._unstable_restartScheduledDelayedEvent as Mock).mockClear();
+            (client._unstable_sendScheduledDelayedEvent as Mock).mockClear();
            (client._unstable_sendDelayedStateEvent as Mock).mockClear();

            await manager.onRTCSessionMemberUpdate([
@@ -462,6 +473,9 @@ describe("MembershipManager", () => {
            expect(client.sendStateEvent).not.toHaveBeenCalled();
            expect(client._unstable_sendDelayedStateEvent).not.toHaveBeenCalled();
            expect(client._unstable_updateDelayedEvent).not.toHaveBeenCalled();
+            expect(client._unstable_cancelScheduledDelayedEvent).not.toHaveBeenCalled();
+            expect(client._unstable_restartScheduledDelayedEvent).not.toHaveBeenCalled();
+            expect(client._unstable_sendScheduledDelayedEvent).not.toHaveBeenCalled();
        });
        it("recreates membership if it is missing", async () => {
            const manager = new MembershipManager({}, room, client, callSession);
@@ -469,7 +483,7 @@ describe("MembershipManager", () => {
            await jest.advanceTimersByTimeAsync(1);
            // clearing all mocks before checking what happens when calling: `onRTCSessionMemberUpdate`
            (client.sendStateEvent as Mock).mockClear();
-            (client._unstable_updateDelayedEvent as Mock).mockClear();
+            (client._unstable_restartScheduledDelayedEvent as Mock).mockClear();
            (client._unstable_sendDelayedStateEvent as Mock).mockClear();

            // Our own membership is removed:
@@ -478,7 +492,7 @@ describe("MembershipManager", () => {
            expect(client.sendStateEvent).toHaveBeenCalled();
            expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalled();

-            expect(client._unstable_updateDelayedEvent).toHaveBeenCalled();
+            expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalled();
        });

        it("updates the UpdateExpiry entry in the action scheduler", async () => {
@@ -487,10 +501,10 @@ describe("MembershipManager", () => {
            await jest.advanceTimersByTimeAsync(1);
            // clearing all mocks before checking what happens when calling: `onRTCSessionMemberUpdate`
            (client.sendStateEvent as Mock).mockClear();
-            (client._unstable_updateDelayedEvent as Mock).mockClear();
+            (client._unstable_restartScheduledDelayedEvent as Mock).mockClear();
            (client._unstable_sendDelayedStateEvent as Mock).mockClear();

-            (client._unstable_updateDelayedEvent as Mock<any>).mockRejectedValueOnce(
+            (client._unstable_restartScheduledDelayedEvent as Mock<any>).mockRejectedValueOnce(
                new MatrixError({ errcode: "M_NOT_FOUND" }),
            );

@@ -503,7 +517,7 @@ describe("MembershipManager", () => {
            expect(client.sendStateEvent).toHaveBeenCalled();
            expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalled();

-            expect(client._unstable_updateDelayedEvent).toHaveBeenCalled();
+            expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalled();
            expect(manager.status).toBe(Status.Connected);
        });
    });
@@ -523,17 +537,17 @@ describe("MembershipManager", () => {

            // The first call is from checking id the server deleted the delayed event
            // so it does not need a `advanceTimersByTime`
-            expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(1);
+            expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalledTimes(1);
            // TODO: Check that update delayed event is called with the correct HTTP request timeout
-            // expect(client._unstable_updateDelayedEvent).toHaveBeenLastCalledWith("id", 10_000, { localTimeoutMs: 20_000 });
+            // expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenLastCalledWith("id", 10_000, { localTimeoutMs: 20_000 });

            for (let i = 2; i <= 12; i++) {
                // flush promises before advancing the timers to make sure schedulers are setup
                await jest.advanceTimersByTimeAsync(10_000);

-                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(i);
+                expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalledTimes(i);
                // TODO: Check that update delayed event is called with the correct HTTP request timeout
-                // expect(client._unstable_updateDelayedEvent).toHaveBeenLastCalledWith("id", 10_000, { localTimeoutMs: 20_000 });
+                // expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenLastCalledWith("id", 10_000, { localTimeoutMs: 20_000 });
            }
        });

@@ -681,7 +695,7 @@ describe("MembershipManager", () => {
        });
        describe("retries sending update delayed leave event restart", () => {
            it("resends the initial check delayed update event", async () => {
-                (client._unstable_updateDelayedEvent as Mock<any>).mockRejectedValue(
+                (client._unstable_restartScheduledDelayedEvent as Mock<any>).mockRejectedValue(
                    new MatrixError(
                        { errcode: "M_LIMIT_EXCEEDED" },
                        429,
@@ -695,17 +709,17 @@ describe("MembershipManager", () => {

                // Hit rate limit
                await jest.advanceTimersByTimeAsync(1);
-                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(1);
+                expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalledTimes(1);

                // Hit second rate limit.
                await jest.advanceTimersByTimeAsync(1000);
-                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(2);
+                expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalledTimes(2);

                // Setup resolve
-                (client._unstable_updateDelayedEvent as Mock<any>).mockResolvedValue(undefined);
+                (client._unstable_restartScheduledDelayedEvent as Mock<any>).mockResolvedValue(undefined);
                await jest.advanceTimersByTimeAsync(1000);

-                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(3);
+                expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalledTimes(3);
                expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
            });
        });
@@ -734,7 +748,7 @@ describe("MembershipManager", () => {
        // because legacy does not have a retry limit and no mechanism to communicate unrecoverable errors.
        it("throws, when reaching maximum number of retries", async () => {
            const delayEventRestartError = jest.fn();
-            (client._unstable_updateDelayedEvent as Mock<any>).mockRejectedValue(
+            (client._unstable_restartScheduledDelayedEvent as Mock<any>).mockRejectedValue(
                new MatrixError(
                    { errcode: "M_LIMIT_EXCEEDED" },
                    429,
@@ -808,11 +822,11 @@ describe("MembershipManager", () => {
            manager.join([focus], focusActive);
            try {
                // Let the scheduler run one iteration so that we can send the join state event
-                await waitForMockCall(client._unstable_updateDelayedEvent);
+                await waitForMockCall(client._unstable_restartScheduledDelayedEvent);

                // We never resolve the delayed event so that we can test the probablyLeft event.
                // This simulates the case where the server does not respond to the delayed event.
-                client._unstable_updateDelayedEvent = jest.fn(() => stuckPromise);
+                client._unstable_restartScheduledDelayedEvent = jest.fn(() => stuckPromise);
                expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
                expect(manager.status).toBe(Status.Connected);
                expect(probablyLeftEmit).not.toHaveBeenCalledWith(true);
@@ -822,18 +836,18 @@ describe("MembershipManager", () => {
                await jest.advanceTimersByTimeAsync(5000);
                // No emission after 5s
                expect(probablyLeftEmit).not.toHaveBeenCalledWith(true);
-                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(1);
+                expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalledTimes(1);

                await jest.advanceTimersByTimeAsync(4999);
-                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(3);
+                expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalledTimes(3);
                expect(probablyLeftEmit).not.toHaveBeenCalledWith(true);

                // Reset mocks before we setup the next delayed event restart by advancing the timers 1 more ms.
-                (client._unstable_updateDelayedEvent as Mock<any>).mockResolvedValue({});
+                (client._unstable_restartScheduledDelayedEvent as Mock<any>).mockResolvedValue({});

                // Emit after 10s
                await jest.advanceTimersByTimeAsync(1);
-                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(4);
+                expect(client._unstable_restartScheduledDelayedEvent).toHaveBeenCalledTimes(4);
                expect(probablyLeftEmit).toHaveBeenCalledWith(true);

                // Mock a sync which does not include our own membership
@@ -898,8 +912,8 @@ describe("MembershipManager", () => {
        describe("join()", () => {
            describe("sends an rtc membership event", () => {
                it("sends a membership event and schedules delayed leave when joining a call", async () => {
-                    const updateDelayedEventHandle = createAsyncHandle<void>(
-                        client._unstable_updateDelayedEvent as Mock,
+                    const restartScheduledDelayedEventHandle = createAsyncHandle<void>(
+                        client._unstable_restartScheduledDelayedEvent as Mock,
                    );
                    const memberManager = new StickyEventMembershipManager(undefined, room, client, callSession);

@@ -925,7 +939,7 @@ describe("MembershipManager", () => {
                            msc4354_sticky_key: "_@alice:example.org_AAAAAAA_m.call",
                        },
                    );
-                    updateDelayedEventHandle.resolve?.();
+                    restartScheduledDelayedEventHandle.resolve?.();

                    // Ensure we have sent the delayed disconnect event.
                    expect(client._unstable_sendStickyDelayedEvent).toHaveBeenCalledWith(
@@ -52,6 +52,9 @@ export type MockClient = Pick<
    | "sendStateEvent"
    | "_unstable_sendDelayedStateEvent"
    | "_unstable_updateDelayedEvent"
+    | "_unstable_cancelScheduledDelayedEvent"
+    | "_unstable_restartScheduledDelayedEvent"
+    | "_unstable_sendScheduledDelayedEvent"
    | "_unstable_sendStickyEvent"
    | "_unstable_sendStickyDelayedEvent"
    | "cancelPendingEvent"
@@ -67,6 +70,9 @@ export function makeMockClient(userId: string, deviceId: string): MockClient {
        sendStateEvent: jest.fn(),
        cancelPendingEvent: jest.fn(),
        _unstable_updateDelayedEvent: jest.fn(),
+        _unstable_cancelScheduledDelayedEvent: jest.fn(),
+        _unstable_restartScheduledDelayedEvent: jest.fn(),
+        _unstable_sendScheduledDelayedEvent: jest.fn(),
        _unstable_sendDelayedStateEvent: jest.fn(),
        _unstable_sendStickyEvent: jest.fn(),
        _unstable_sendStickyDelayedEvent: jest.fn(),
@@ -127,15 +127,17 @@ describe("Poll", () => {

        it("waits for existing relations request to finish when getting responses", async () => {
            const poll = new Poll(basePollStartEvent, mockClient, room);
+            // @ts-expect-error TS2769
+            const spy = jest.spyOn(poll, "fetchResponses");
            const firstResponsePromise = poll.getResponses();
            const secondResponsePromise = poll.getResponses();
            await firstResponsePromise;
-            expect(firstResponsePromise).toEqual(secondResponsePromise);
            await secondResponsePromise;
+            expect(spy).toHaveBeenCalledTimes(1);
            expect(mockClient.relations).toHaveBeenCalledTimes(1);
        });

-        it("filters relations for relevent response events", async () => {
+        it("filters relations for relevant response events", async () => {
            const replyEvent = makeRelatedEvent({ type: "m.room.message" });
            const stableResponseEvent = makeRelatedEvent({ type: M_POLL_RESPONSE.stable! });
            const unstableResponseEvent = makeRelatedEvent({ type: M_POLL_RESPONSE.unstable });
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { Direction, type MatrixClient, MatrixEvent, Room } from "../../../src";
+import { Direction, EventType, type MatrixClient, MatrixEvent, Room } from "../../../src";
 import type { MockedObject } from "jest-mock";

 const CREATOR_USER_ID = "@creator:example.org";
@@ -185,4 +185,71 @@ describe("Room", () => {
            expectRedacted(messageEvents, room, false);
        });
    });
+
+    it("should ignore invalid m.room.name events", async () => {
+        const mockClient = createMockClient();
+        const room = new Room("!room:example.org", mockClient, CREATOR_USER_ID);
+        const invalidNameEvent = new MatrixEvent({
+            type: EventType.RoomName,
+            content: {
+                name: { invalid: 123 },
+            },
+            state_key: "",
+            event_id: "$123",
+            room_id: room.roomId,
+            sender: CREATOR_USER_ID,
+        });
+
+        // Set up the room
+        room.currentState.setStateEvents([invalidNameEvent]);
+        room.recalculate();
+
+        expect(room.name).toEqual("Empty room");
+    });
+
+    describe("getAltAliases()", () => {
+        it("should ignore invalid events", async () => {
+            const mockClient = createMockClient();
+            const room = new Room("!room:example.org", mockClient, CREATOR_USER_ID);
+            const invalidAliasEvent = new MatrixEvent({
+                type: EventType.RoomCanonicalAlias,
+                content: {
+                    alt_aliases: [123, "#foo:bar"],
+                },
+                state_key: "",
+                event_id: "$123",
+                room_id: room.roomId,
+                sender: CREATOR_USER_ID,
+            });
+
+            // Set up the room
+            room.currentState.setStateEvents([invalidAliasEvent]);
+            room.recalculate();
+
+            expect(room.getAltAliases()).toEqual(["#foo:bar"]);
+        });
+    });
+
+    describe("calculateRoomName()", () => {
+        it("should ignore empty m.room.name 'name' field", async () => {
+            const mockClient = createMockClient();
+            const room = new Room("!room:example.org", mockClient, CREATOR_USER_ID);
+            const event = new MatrixEvent({
+                type: EventType.RoomName,
+                content: {
+                    name: "",
+                },
+                state_key: "",
+                event_id: "$123",
+                room_id: room.roomId,
+                sender: CREATOR_USER_ID,
+            });
+
+            // Set up the room
+            room.currentState.setStateEvents([event]);
+            room.recalculate();
+
+            expect(room.name).not.toEqual("");
+        });
+    });
 });
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { type Mocked, type SpyInstance } from "jest-mock";
+import { type Mocked } from "jest-mock";
 import * as RustSdkCryptoJs from "@matrix-org/matrix-sdk-crypto-wasm";
 import { type OlmMachine } from "@matrix-org/matrix-sdk-crypto-wasm";
 import fetchMock from "fetch-mock-jest";
@@ -211,14 +211,14 @@ describe("PerSessionKeyBackupDownloader", () => {
            fetchMock.get(`path:/_matrix/client/v3/room_keys/keys/!roomA/sessionA1`, mockCipherKey);

            // @ts-ignore access to private function
-            const spy: SpyInstance = jest.spyOn(downloader, "queryKeyBackup");
+            const spy: jest.SpyInstance = jest.spyOn(downloader, "queryKeyBackup");

            const expectImported = expectSessionImported("!roomA", "sessionA1");

            downloader.onDecryptionKeyMissingError("!roomA", "sessionA0");
            await jest.runAllTimersAsync();
            expect(spy).toHaveBeenCalledTimes(1);
-            expect(spy).toHaveLastReturnedWith(Promise.resolve({ ok: false, error: "MISSING_DECRYPTION_KEY" }));
+            await expect(spy.mock.results[0].value).rejects.toThrow("MISSING_DECRYPTION_KEY");

            downloader.onDecryptionKeyMissingError("!roomA", "sessionA1");
            await jest.runAllTimersAsync();
@@ -237,7 +237,7 @@ describe("PerSessionKeyBackupDownloader", () => {
            });

            // @ts-ignore access to private function
-            const spy: SpyInstance = jest.spyOn(downloader, "queryKeyBackup");
+            const spy: jest.SpyInstance = jest.spyOn(downloader, "queryKeyBackup");

            downloader.onDecryptionKeyMissingError("!roomA", "sessionA0");
            await jest.runAllTimersAsync();
@@ -297,7 +297,7 @@ describe("PerSessionKeyBackupDownloader", () => {
    });

    describe("Given no usable backup available", () => {
-        let getConfigSpy: SpyInstance;
+        let getConfigSpy: jest.SpyInstance;

        beforeEach(async () => {
            mockRustBackupManager.getActiveBackupVersion.mockResolvedValue(null);
@@ -318,7 +318,7 @@ describe("PerSessionKeyBackupDownloader", () => {
            await jest.runAllTimersAsync();

            expect(getConfigSpy).toHaveBeenCalledTimes(1);
-            expect(getConfigSpy).toHaveReturnedWith(Promise.resolve(null));
+            await expect(getConfigSpy.mock.results[0].value).resolves.toEqual(null);

            // isKeyBackupDownloadConfigured remains false
            expect(downloader.isKeyBackupDownloadConfigured()).toBe(false);
@@ -336,7 +336,7 @@ describe("PerSessionKeyBackupDownloader", () => {
            await jest.runAllTimersAsync();

            expect(getConfigSpy).toHaveBeenCalledTimes(1);
-            expect(getConfigSpy).toHaveReturnedWith(Promise.resolve(null));
+            await expect(getConfigSpy.mock.results[0].value).resolves.toEqual(null);

            // isKeyBackupDownloadConfigured remains false
            expect(downloader.isKeyBackupDownloadConfigured()).toBe(false);
@@ -355,7 +355,7 @@ describe("PerSessionKeyBackupDownloader", () => {
            await jest.runAllTimersAsync();

            expect(getConfigSpy).toHaveBeenCalledTimes(1);
-            expect(getConfigSpy).toHaveReturnedWith(Promise.resolve(null));
+            await expect(getConfigSpy.mock.results[0].value).resolves.toEqual(null);

            // isKeyBackupDownloadConfigured remains false
            expect(downloader.isKeyBackupDownloadConfigured()).toBe(false);
@@ -377,7 +377,7 @@ describe("PerSessionKeyBackupDownloader", () => {
            await jest.runAllTimersAsync();

            expect(getConfigSpy).toHaveBeenCalledTimes(1);
-            expect(getConfigSpy).toHaveReturnedWith(Promise.resolve(null));
+            await expect(getConfigSpy.mock.results[0].value).resolves.toEqual(null);

            // isKeyBackupDownloadConfigured remains false
            expect(downloader.isKeyBackupDownloadConfigured()).toBe(false);
@@ -399,7 +399,7 @@ describe("PerSessionKeyBackupDownloader", () => {
            await jest.runAllTimersAsync();

            expect(getConfigSpy).toHaveBeenCalledTimes(1);
-            expect(getConfigSpy).toHaveReturnedWith(Promise.resolve(null));
+            await expect(getConfigSpy.mock.results[0].value).resolves.toEqual(null);

            // isKeyBackupDownloadConfigured remains false
            expect(downloader.isKeyBackupDownloadConfigured()).toBe(false);
@@ -488,7 +488,7 @@ describe("PerSessionKeyBackupDownloader", () => {
            const originalImplementation = downloader.queryKeyBackup.bind(downloader);

            // @ts-ignore access to private function
-            const keyQuerySpy: SpyInstance = jest.spyOn(downloader, "queryKeyBackup");
+            const keyQuerySpy: jest.SpyInstance = jest.spyOn(downloader, "queryKeyBackup");
            const rateDeferred = Promise.withResolvers<void>();

            keyQuerySpy.mockImplementation(
@@ -542,7 +542,7 @@ describe("PerSessionKeyBackupDownloader", () => {
            const originalImplementation = downloader.queryKeyBackup.bind(downloader);

            // @ts-ignore
-            const keyQuerySpy: SpyInstance = jest.spyOn(downloader, "queryKeyBackup");
+            const keyQuerySpy: jest.SpyInstance = jest.spyOn(downloader, "queryKeyBackup");
            const errorDeferred = Promise.withResolvers<void>();

            keyQuerySpy.mockImplementation(
@@ -606,7 +606,7 @@ describe("PerSessionKeyBackupDownloader", () => {
            });

            // @ts-ignore access to private function
-            const keyQuerySpy: SpyInstance = jest.spyOn(downloader, "queryKeyBackup");
+            const keyQuerySpy: jest.SpyInstance = jest.spyOn(downloader, "queryKeyBackup");

            downloader.onDecryptionKeyMissingError("!roomA", "sessionA0");
            downloader.onDecryptionKeyMissingError("!roomA", "sessionA1");
@@ -1,4 +1,4 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing

 exports[`RustCrypto importing and exporting room keys should import and export keys 1`] = `
 {
@@ -187,12 +187,14 @@ describe("Group Call", function () {
        });

        it("does not start initializing local call feed twice", () => {
-            const promise1 = groupCall.initLocalCallFeed();
+            // @ts-expect-error TS2769
+            const spy = jest.spyOn(groupCall, "initLocalCallFeedInternal");
+            groupCall.initLocalCallFeed();
            // @ts-ignore Mock
            groupCall.state = GroupCallState.LocalCallFeedUninitialized;
-            const promise2 = groupCall.initLocalCallFeed();
+            groupCall.initLocalCallFeed();

-            expect(promise1).toEqual(promise2);
+            expect(spy).toHaveBeenCalledTimes(1);
        });

        it("sets state to local call feed uninitialized when getUserMedia() fails", async () => {
@@ -61,10 +61,10 @@ describe("Media Handler", function () {
        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(
            expect.objectContaining({
                audio: expect.objectContaining({
-                    deviceId: { ideal: FAKE_AUDIO_INPUT_ID },
+                    deviceId: { exact: FAKE_AUDIO_INPUT_ID },
                }),
                video: expect.objectContaining({
-                    deviceId: { ideal: FAKE_VIDEO_INPUT_ID },
+                    deviceId: { exact: FAKE_VIDEO_INPUT_ID },
                }),
            }),
        );
@@ -77,7 +77,7 @@ describe("Media Handler", function () {
        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(
            expect.objectContaining({
                audio: expect.objectContaining({
-                    deviceId: { ideal: FAKE_AUDIO_INPUT_ID },
+                    deviceId: { exact: FAKE_AUDIO_INPUT_ID },
                }),
            }),
        );
@@ -109,7 +109,7 @@ describe("Media Handler", function () {
        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(
            expect.objectContaining({
                video: expect.objectContaining({
-                    deviceId: { ideal: FAKE_VIDEO_INPUT_ID },
+                    deviceId: { exact: FAKE_VIDEO_INPUT_ID },
                }),
            }),
        );
@@ -122,10 +122,10 @@ describe("Media Handler", function () {
        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(
            expect.objectContaining({
                audio: expect.objectContaining({
-                    deviceId: { ideal: FAKE_AUDIO_INPUT_ID },
+                    deviceId: { exact: FAKE_AUDIO_INPUT_ID },
                }),
                video: expect.objectContaining({
-                    deviceId: { ideal: FAKE_VIDEO_INPUT_ID },
+                    deviceId: { exact: FAKE_VIDEO_INPUT_ID },
                }),
            }),
        );
@@ -331,6 +331,80 @@ describe("Media Handler", function () {

            expect(stream.getVideoTracks().length).toEqual(0);
        });
+
+        it("falls back to ideal deviceId when exact deviceId fails", async () => {
+            // First call with exact should fail
+            mockMediaDevices.getUserMedia
+                .mockRejectedValueOnce(new Error("OverconstrainedError"))
+                .mockImplementation((constraints: MediaStreamConstraints) => {
+                    const stream = new MockMediaStream("local_stream");
+                    if (constraints.audio) {
+                        const track = new MockMediaStreamTrack("audio_track", "audio");
+                        track.settings = { deviceId: FAKE_AUDIO_INPUT_ID };
+                        stream.addTrack(track);
+                    }
+                    return Promise.resolve(stream.typed());
+                });
+
+            const stream = await mediaHandler.getUserMediaStream(true, false);
+
+            // Should have been called twice: once with exact, once with ideal
+            expect(mockMediaDevices.getUserMedia).toHaveBeenCalledTimes(2);
+            expect(mockMediaDevices.getUserMedia).toHaveBeenNthCalledWith(
+                1,
+                expect.objectContaining({
+                    audio: expect.objectContaining({
+                        deviceId: { exact: FAKE_AUDIO_INPUT_ID },
+                    }),
+                }),
+            );
+            expect(mockMediaDevices.getUserMedia).toHaveBeenNthCalledWith(
+                2,
+                expect.objectContaining({
+                    audio: expect.objectContaining({
+                        deviceId: { ideal: FAKE_AUDIO_INPUT_ID },
+                    }),
+                }),
+            );
+            expect(stream).toBeTruthy();
+        });
+
+        it("falls back to ideal deviceId for video when exact fails", async () => {
+            // First call with exact should fail
+            mockMediaDevices.getUserMedia
+                .mockRejectedValueOnce(new Error("OverconstrainedError"))
+                .mockImplementation((constraints: MediaStreamConstraints) => {
+                    const stream = new MockMediaStream("local_stream");
+                    if (constraints.video) {
+                        const track = new MockMediaStreamTrack("video_track", "video");
+                        track.settings = { deviceId: FAKE_VIDEO_INPUT_ID };
+                        stream.addTrack(track);
+                    }
+                    return Promise.resolve(stream.typed());
+                });
+
+            const stream = await mediaHandler.getUserMediaStream(false, true);
+
+            // Should have been called twice: once with exact, once with ideal
+            expect(mockMediaDevices.getUserMedia).toHaveBeenCalledTimes(2);
+            expect(mockMediaDevices.getUserMedia).toHaveBeenNthCalledWith(
+                1,
+                expect.objectContaining({
+                    video: expect.objectContaining({
+                        deviceId: { exact: FAKE_VIDEO_INPUT_ID },
+                    }),
+                }),
+            );
+            expect(mockMediaDevices.getUserMedia).toHaveBeenNthCalledWith(
+                2,
+                expect.objectContaining({
+                    video: expect.objectContaining({
+                        deviceId: { ideal: FAKE_VIDEO_INPUT_ID },
+                    }),
+                }),
+            );
+            expect(stream).toBeTruthy();
+        });
    });

    describe("getScreensharingStream", () => {
@@ -1,4 +1,4 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing

 exports[`CallFeedStatsReporter should builds CallFeedReport 1`] = `
 {
@@ -106,6 +106,7 @@ import { RoomMemberEvent, type RoomMemberEventHandlerMap } from "./models/room-m
 import { type IPowerLevelsContent, type RoomStateEvent, type RoomStateEventHandlerMap } from "./models/room-state.ts";
 import {
    isSendDelayedEventRequestOpts,
+    UpdateDelayedEventAction,
    type DelayedEventInfo,
    type IAddThreePidOnlyBody,
    type IBindThreePidBody,
@@ -130,7 +131,6 @@ import {
    type KnockRoomOpts,
    type SendDelayedEventRequestOpts,
    type SendDelayedEventResponse,
-    type UpdateDelayedEventAction,
 } from "./@types/requests.ts";
 import {
    type AccountDataEvents,
@@ -3570,8 +3570,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     *
     * Note: This endpoint is unstable, and can throw an `Error`.
     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.
+     *
+     * @deprecated Instead use one of:
+     * - {@link _unstable_cancelScheduledDelayedEvent}
+     * - {@link _unstable_restartScheduledDelayedEvent}
+     * - {@link _unstable_sendScheduledDelayedEvent}
     */
-    // eslint-disable-next-line
+    // eslint-disable-next-line @typescript-eslint/naming-convention
    public async _unstable_updateDelayedEvent(
        delayId: string,
        action: UpdateDelayedEventAction,
@@ -3583,17 +3588,123 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                "updateDelayedEvent",
            );
        }
+        return await this.updateScheduledDelayedEventWithActionInBody(delayId, action, requestOptions);
+    }

+    /**
+     * Cancel the scheduled delivery of the delayed event matching the provided delayId.
+     *
+     * Note: This endpoint is unstable, and can throw an `Error`.
+     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.
+     *
+     * @throws A M_NOT_FOUND error if no matching delayed event could be found.
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public async _unstable_cancelScheduledDelayedEvent(
+        delayId: string,
+        requestOptions: IRequestOpts = {},
+    ): Promise<EmptyObject> {
+        return await this.updateScheduledDelayedEvent(delayId, UpdateDelayedEventAction.Cancel, requestOptions);
+    }
+
+    /**
+     * Restart the scheduled delivery of the delayed event matching the given delayId.
+     *
+     * Note: This endpoint is unstable, and can throw an `Error`.
+     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.
+     *
+     * @throws A M_NOT_FOUND error if no matching delayed event could be found.
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public async _unstable_restartScheduledDelayedEvent(
+        delayId: string,
+        requestOptions: IRequestOpts = {},
+    ): Promise<EmptyObject> {
+        return await this.updateScheduledDelayedEvent(delayId, UpdateDelayedEventAction.Restart, requestOptions);
+    }
+
+    /**
+     * Immediately send the delayed event matching the given delayId,
+     * instead of waiting for its scheduled delivery.
+     *
+     * Note: This endpoint is unstable, and can throw an `Error`.
+     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.
+     *
+     * @throws A M_NOT_FOUND error if no matching delayed event could be found.
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public async _unstable_sendScheduledDelayedEvent(
+        delayId: string,
+        requestOptions: IRequestOpts = {},
+    ): Promise<EmptyObject> {
+        return await this.updateScheduledDelayedEvent(delayId, UpdateDelayedEventAction.Send, requestOptions);
+    }
+
+    private async updateScheduledDelayedEvent(
+        delayId: string,
+        action: UpdateDelayedEventAction,
+        requestOptions: IRequestOpts = {},
+    ): Promise<EmptyObject> {
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+            throw new UnsupportedDelayedEventsEndpointError(
+                "Server does not support the delayed events API",
+                `${action}ScheduledDelayedEvent`,
+            );
+        }
+
+        try {
+            const path = utils.encodeUri("/delayed_events/$delayId/$action", {
+                $delayId: delayId,
+                $action: action,
+            });
+            return await this.http.request(Method.Post, path, undefined, undefined, {
+                ...requestOptions,
+                prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_DELAYED_EVENTS}`,
+            });
+        } catch (e) {
+            if (e instanceof MatrixError && e.errcode === "M_UNRECOGNIZED") {
+                // For backwards compatibility with an older version of this endpoint
+                // which put the update action in the request body instead of the path
+                return await this.updateScheduledDelayedEventWithActionInBody(delayId, action, requestOptions);
+            } else {
+                throw e;
+            }
+        }
+    }
+
+    /**
+     * @deprecated Present for backwards compatibility with an older version of MSC4140
+     * which had a single, authenticated endpoint for updating a delayed event, instead
+     * of one unauthenticated endpoint per update action.
+     */
+    private async updateScheduledDelayedEventWithActionInBody(
+        delayId: string,
+        action: UpdateDelayedEventAction,
+        requestOptions: IRequestOpts = {},
+    ): Promise<EmptyObject> {
        const path = utils.encodeUri("/delayed_events/$delayId", {
            $delayId: delayId,
        });
        const data = {
            action,
        };
-        return await this.http.authedRequest(Method.Post, path, undefined, data, {
-            ...requestOptions,
-            prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_DELAYED_EVENTS}`,
-        });
+        try {
+            return await this.http.request(Method.Post, path, undefined, data, {
+                ...requestOptions,
+                prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_DELAYED_EVENTS}`,
+            });
+        } catch (e) {
+            if (e instanceof MatrixError && e.errcode === "M_MISSING_TOKEN") {
+                // For backwards compatibility with an older version of this endpoint
+                // which required authentication
+                return await this.http.authedRequest(Method.Post, path, undefined, data, {
+                    ...requestOptions,
+                    prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_DELAYED_EVENTS}`,
+                });
+            } else {
+                throw e;
+            }
+        }
    }

    /**
@@ -37,7 +37,7 @@ import {
    type ISendEventResponse,
    type SendDelayedEventRequestOpts,
    type SendDelayedEventResponse,
-    type UpdateDelayedEventAction,
+    UpdateDelayedEventAction,
 } from "./@types/requests.ts";
 import { EventType, type StateEvents } from "./@types/event.ts";
 import { logger } from "./logger.ts";
@@ -459,8 +459,12 @@ export class RoomWidgetClient extends MatrixClient {

    /**
     * @experimental This currently relies on an unstable MSC (MSC4140).
+     * @deprecated Instead use one of:
+     * - {@link _unstable_cancelScheduledDelayedEvent}
+     * - {@link _unstable_restartScheduledDelayedEvent}
+     * - {@link _unstable_sendScheduledDelayedEvent}
     */
-    // eslint-disable-next-line
+    // eslint-disable-next-line @typescript-eslint/naming-convention
    public async _unstable_updateDelayedEvent(delayId: string, action: UpdateDelayedEventAction): Promise<EmptyObject> {
        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
            throw new UnsupportedDelayedEventsEndpointError(
@@ -469,7 +473,67 @@ export class RoomWidgetClient extends MatrixClient {
            );
        }

-        await this.widgetApi.updateDelayedEvent(delayId, action).catch(timeoutToConnectionError);
+        let updateDelayedEvent: (delayId: string) => Promise<unknown>;
+        switch (action) {
+            case UpdateDelayedEventAction.Cancel:
+                updateDelayedEvent = this.widgetApi.cancelScheduledDelayedEvent;
+                break;
+            case UpdateDelayedEventAction.Restart:
+                updateDelayedEvent = this.widgetApi.cancelScheduledDelayedEvent;
+                break;
+            case UpdateDelayedEventAction.Send:
+                updateDelayedEvent = this.widgetApi.sendScheduledDelayedEvent;
+                break;
+        }
+        await updateDelayedEvent.call(this.widgetApi, delayId).catch(timeoutToConnectionError);
+        return {};
+    }
+
+    /**
+     * @experimental This currently relies on an unstable MSC (MSC4140).
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public async _unstable_cancelScheduledDelayedEvent(delayId: string): Promise<EmptyObject> {
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+            throw new UnsupportedDelayedEventsEndpointError(
+                "Server does not support the delayed events API",
+                "cancelScheduledDelayedEvent",
+            );
+        }
+
+        await this.widgetApi.cancelScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
+        return {};
+    }
+
+    /**
+     * @experimental This currently relies on an unstable MSC (MSC4140).
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public async _unstable_restartScheduledDelayedEvent(delayId: string): Promise<EmptyObject> {
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+            throw new UnsupportedDelayedEventsEndpointError(
+                "Server does not support the delayed events API",
+                "restartScheduledDelayedEvent",
+            );
+        }
+
+        await this.widgetApi.restartScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
+        return {};
+    }
+
+    /**
+     * @experimental This currently relies on an unstable MSC (MSC4140).
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public async _unstable_sendScheduledDelayedEvent(delayId: string): Promise<EmptyObject> {
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+            throw new UnsupportedDelayedEventsEndpointError(
+                "Server does not support the delayed events API",
+                "sendScheduledDelayedEvent",
+            );
+        }
+
+        await this.widgetApi.sendScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
        return {};
    }

@@ -59,7 +59,14 @@ export class ClientStoppedError extends Error {
 export class UnsupportedDelayedEventsEndpointError extends Error {
    public constructor(
        message: string,
-        public clientEndpoint: "sendDelayedEvent" | "updateDelayedEvent" | "sendDelayedStateEvent" | "getDelayedEvents",
+        public clientEndpoint:
+            | "sendDelayedEvent"
+            | "updateDelayedEvent"
+            | "cancelScheduledDelayedEvent"
+            | "restartScheduledDelayedEvent"
+            | "sendScheduledDelayedEvent"
+            | "sendDelayedStateEvent"
+            | "getDelayedEvents",
    ) {
        super(message);
        this.name = "UnsupportedDelayedEventsEndpointError";
@@ -279,6 +279,13 @@ export class FetchHttpApi<O extends IHttpOpts> {

        const { signal, cleanup } = anySignal(signals);

+        // Set cache mode based on presence of Authorization header.
+        // Browsers/proxies do not cache responses to requests with Authorization headers.
+        // So specifying "no-cache" is redundant, and actually prevents caching
+        // of preflight requests in CORS scenarios. As such, we only set "no-cache"
+        // when there is no Authorization header.
+        const cacheMode = "Authorization" in headers ? undefined : "no-cache";
+
        let res: Response;
        const start = Date.now();
        try {
@@ -291,7 +298,7 @@ export class FetchHttpApi<O extends IHttpOpts> {
                redirect: "follow",
                referrer: "",
                referrerPolicy: "no-referrer",
-                cache: "no-cache",
+                cache: cacheMode,
                credentials: "omit", // we send credentials via headers
                keepalive: keepAlive,
                priority: opts.priority,
@@ -178,7 +178,8 @@ export interface MembershipConfig {
     * In the presence of network packet loss (hurting TCP connections), the custom delayedEventRestartLocalTimeoutMs
     * helps by keeping more delayed event reset candidates in flight,
     * improving the chances of a successful reset. (its is equivalent to the js-sdk `localTimeout` configuration,
-     * but only applies to calls to the `_unstable_updateDelayedEvent` endpoint with a body of `{action:"restart"}`.)
+     * but only applies to calls to the `_unstable_restartScheduledDelayedEvent` endpoint
+     * or the `_unstable_updateDelayedEvent` endpoint with a body of `{action:"restart"}`.)
     */
    delayedLeaveEventRestartLocalTimeoutMs?: number;

@@ -514,6 +515,9 @@ export class MatrixRTCSession extends TypedEventEmitter<
            | "sendStateEvent"
            | "_unstable_sendDelayedStateEvent"
            | "_unstable_updateDelayedEvent"
+            | "_unstable_cancelScheduledDelayedEvent"
+            | "_unstable_restartScheduledDelayedEvent"
+            | "_unstable_sendScheduledDelayedEvent"
            | "_unstable_sendStickyEvent"
            | "_unstable_sendStickyDelayedEvent"
            | "cancelPendingEvent"
@@ -16,11 +16,7 @@ limitations under the License.
 import { AbortError } from "p-retry";

 import { EventType, RelationType } from "../@types/event.ts";
-import {
-    type ISendEventResponse,
-    type SendDelayedEventResponse,
-    UpdateDelayedEventAction,
-} from "../@types/requests.ts";
+import { type ISendEventResponse, type SendDelayedEventResponse } from "../@types/requests.ts";
 import { type EmptyObject } from "../@types/common.ts";
 import type { MatrixClient } from "../client.ts";
 import { ConnectionError, HTTPError, MatrixError } from "../http-api/errors.ts";
@@ -169,7 +165,14 @@ function createReplaceActionUpdate(type: MembershipActionType, offset?: number):

 type MembershipManagerClient = Pick<
    MatrixClient,
-    "getUserId" | "getDeviceId" | "sendStateEvent" | "_unstable_sendDelayedStateEvent" | "_unstable_updateDelayedEvent"
+    | "getUserId"
+    | "getDeviceId"
+    | "sendStateEvent"
+    | "_unstable_sendDelayedStateEvent"
+    | "_unstable_updateDelayedEvent"
+    | "_unstable_cancelScheduledDelayedEvent"
+    | "_unstable_restartScheduledDelayedEvent"
+    | "_unstable_sendScheduledDelayedEvent"
 >;

 /**
@@ -544,7 +547,7 @@ export class MembershipManager
    private async cancelKnownDelayIdBeforeSendDelayedEvent(delayId: string): Promise<ActionUpdate> {
        // Remove all running updates and restarts
        return await this.client
-            ._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Cancel)
+            ._unstable_cancelScheduledDelayedEvent(delayId)
            .then(() => {
                this.state.delayId = undefined;
                this.resetRateLimitCounter(MembershipActionType.SendDelayedEvent);
@@ -552,7 +555,7 @@ export class MembershipManager
            })
            .catch((e) => {
                const repeatActionType = MembershipActionType.SendDelayedEvent;
-                const update = this.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
+                const update = this.actionUpdateFromErrors(e, repeatActionType, "cancelScheduledDelayedEvent");
                if (update) return update;

                if (this.isNotFoundError(e)) {
@@ -606,10 +609,7 @@ export class MembershipManager

        // The obvious choice here would be to use the `IRequestOpts` to set the timeout. Since this call might be forwarded
        // to the widget driver this information would get lost. That is why we mimic the AbortError using the race.
-        return await Promise.race([
-            this.client._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Restart),
-            abortPromise,
-        ])
+        return await Promise.race([this.client._unstable_restartScheduledDelayedEvent(delayId), abortPromise])
            .then(() => {
                // Whenever we successfully restart the delayed event we update the `state.expectedServerDelayLeaveTs`
                // which stores the predicted timestamp at which the server will send the delayed leave event if there wont be any further
@@ -637,7 +637,7 @@ export class MembershipManager
                if (this.isUnsupportedDelayedEndpoint(e)) return {};

                // TODO this also needs a test: get rate limit while checking id delayed event is scheduled
-                const update = this.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
+                const update = this.actionUpdateFromErrors(e, repeatActionType, "restartScheduledDelayedEvent");
                if (update) return update;

                // In other error cases we have no idea what is happening
@@ -647,7 +647,7 @@ export class MembershipManager

    private async sendScheduledDelayedLeaveEventOrFallbackToSendLeaveEvent(delayId: string): Promise<ActionUpdate> {
        return await this.client
-            ._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Send)
+            ._unstable_sendScheduledDelayedEvent(delayId)
            .then(() => {
                this.state.hasMemberStateEvent = false;
                this.resetRateLimitCounter(MembershipActionType.SendScheduledDelayedLeaveEvent);
@@ -661,7 +661,7 @@ export class MembershipManager
                    this.state.delayId = undefined;
                    return createInsertActionUpdate(repeatActionType);
                }
-                const update = this.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
+                const update = this.actionUpdateFromErrors(e, repeatActionType, "sendScheduledDelayedEvent");
                if (update) return update;

                // On any other error we fall back to SendLeaveEvent (this includes hard errors from rate limiting)
@@ -1783,12 +1783,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
        allowDefault = true,
        useAuthentication: boolean = false,
    ): string | null {
-        const roomAvatarEvent = this.currentState.getStateEvents(EventType.RoomAvatar, "");
-        if (!roomAvatarEvent && !allowDefault) {
+        const mainUrl = this.getMxcAvatarUrl();
+        if (!mainUrl && !allowDefault) {
            return null;
        }

-        const mainUrl = roomAvatarEvent ? roomAvatarEvent.getContent().url : null;
        if (mainUrl) {
            return getHttpUriForMxc(
                baseUrl,
@@ -1810,7 +1809,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     * @returns the mxc avatar url or falsy
     */
    public getMxcAvatarUrl(): string | null {
-        return this.currentState.getStateEvents(EventType.RoomAvatar, "")?.getContent()?.url || null;
+        const url = this.currentState.getStateEvents(EventType.RoomAvatar, "")?.getContent().url;
+        return url && typeof url === "string" ? url : null;
    }

    /**
@@ -1820,11 +1820,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     * @returns The room's canonical alias, or null if there is none
     */
    public getCanonicalAlias(): string | null {
-        const canonicalAlias = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, "");
-        if (canonicalAlias) {
-            return canonicalAlias.getContent().alias || null;
-        }
-        return null;
+        const canonicalAlias = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, "")?.getContent().alias;
+        return canonicalAlias && typeof canonicalAlias === "string" ? canonicalAlias : null;
    }

    /**
@@ -1832,9 +1829,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     * @returns The room's alternative aliases, or an empty array
     */
    public getAltAliases(): string[] {
-        const canonicalAlias = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, "");
-        if (canonicalAlias) {
-            return canonicalAlias.getContent().alt_aliases || [];
+        const altAliases = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, "")?.getContent().alt_aliases;
+        if (Array.isArray(altAliases)) {
+            return altAliases.filter((alias) => typeof alias === "string");
        }
        return [];
    }
@@ -3640,13 +3637,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     */
    private calculateRoomName(userId: string, ignoreRoomNameEvent = false): string {
        if (!ignoreRoomNameEvent) {
-            // check for an alias, if any. for now, assume first alias is the
-            // official one.
-            const mRoomName = this.currentState.getStateEvents(EventType.RoomName, "");
-            if (mRoomName?.getContent().name) {
+            const name = this.currentState.getStateEvents(EventType.RoomName, "")?.getContent().name;
+            if (name && typeof name === "string") {
                return this.roomNameGenerator({
                    type: RoomNameType.Actual,
-                    name: mRoomName.getContent().name,
+                    name,
                });
            }
        }
@@ -264,8 +264,19 @@ export class MediaHandler extends TypedEventEmitter<
        }

        if (!canReuseStream) {
-            const constraints = this.getUserMediaContraints(shouldRequestAudio, shouldRequestVideo);
-            stream = await navigator.mediaDevices.getUserMedia(constraints);
+            let constraints: MediaStreamConstraints;
+            try {
+                // Not specifying exact for deviceId means switching devices does not always work,
+                // try with exact and fallback to ideal if it fails
+                constraints = this.getUserMediaContraints(shouldRequestAudio, shouldRequestVideo, true);
+                stream = await navigator.mediaDevices.getUserMedia(constraints);
+            } catch (e) {
+                logger.warn(
+                    `MediaHandler getUserMediaStreamInternal() error (e=${e}), retrying without exact deviceId`,
+                );
+                constraints = this.getUserMediaContraints(shouldRequestAudio, shouldRequestVideo, false);
+                stream = await navigator.mediaDevices.getUserMedia(constraints);
+            }
            logger.log(
                `MediaHandler getUserMediaStreamInternal() calling getUserMediaStream (streamId=${
                    stream.id
@@ -435,30 +446,36 @@ export class MediaHandler extends TypedEventEmitter<
        this.emit(MediaHandlerEvent.LocalStreamsChanged);
    }

-    private getUserMediaContraints(audio: boolean, video: boolean): MediaStreamConstraints {
+    private getUserMediaContraints(audio: boolean, video: boolean, exactDeviceId?: boolean): MediaStreamConstraints {
        const isWebkit = !!navigator.webkitGetUserMedia;
+        const deviceIdKey = exactDeviceId ? "exact" : "ideal";
+
+        const audioConstraints: MediaTrackConstraints = {};
+        if (this.audioInput) {
+            audioConstraints.deviceId = { [deviceIdKey]: this.audioInput };
+        }
+        if (this.audioSettings) {
+            audioConstraints.autoGainControl = { ideal: this.audioSettings.autoGainControl };
+            audioConstraints.echoCancellation = { ideal: this.audioSettings.echoCancellation };
+            audioConstraints.noiseSuppression = { ideal: this.audioSettings.noiseSuppression };
+        }
+
+        const videoConstraints: MediaTrackConstraints = {
+            /* We want 640x360.  Chrome will give it only if we ask exactly,
+               FF refuses entirely if we ask exactly, so have to ask for ideal
+               instead
+               XXX: Is this still true?
+             */
+            width: isWebkit ? { exact: 640 } : { ideal: 640 },
+            height: isWebkit ? { exact: 360 } : { ideal: 360 },
+        };
+        if (this.videoInput) {
+            videoConstraints.deviceId = { [deviceIdKey]: this.videoInput };
+        }

        return {
-            audio: audio
-                ? {
-                      deviceId: this.audioInput ? { ideal: this.audioInput } : undefined,
-                      autoGainControl: this.audioSettings ? { ideal: this.audioSettings.autoGainControl } : undefined,
-                      echoCancellation: this.audioSettings ? { ideal: this.audioSettings.echoCancellation } : undefined,
-                      noiseSuppression: this.audioSettings ? { ideal: this.audioSettings.noiseSuppression } : undefined,
-                  }
-                : false,
-            video: video
-                ? {
-                      deviceId: this.videoInput ? { ideal: this.videoInput } : undefined,
-                      /* We want 640x360.  Chrome will give it only if we ask exactly,
-                   FF refuses entirely if we ask exactly, so have to ask for ideal
-                   instead
-                   XXX: Is this still true?
-                 */
-                      width: isWebkit ? { exact: 640 } : { ideal: 640 },
-                      height: isWebkit ? { exact: 360 } : { ideal: 360 },
-                  }
-                : false,
+            audio: audio ? audioConstraints : false,
+            video: video ? videoConstraints : false,
        };
    }
Author	SHA1	Message	Date
RiotRobot	dd2635dbe6	v39.3.0	2025-12-02 14:44:30 +00:00
RiotRobot	23241f18e2	v39.3.0-rc.0	2025-11-25 14:10:43 +00:00
Michael Telatynski	90da67aa95	Re-add truthy check on room name/avatar/alias events (#5081 ) * Re-add truthy check on room name/avatar/alias events Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> * Add regression test Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> --------- Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>	2025-11-25 09:09:11 +00:00
renovate[bot]	0bf2702149	Update jest to v30 (major) (#4875 ) * Update jest to v30 * Update snapshots & imports Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> * Make jest happier Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> * Fix tests Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> --------- Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> Co-authored-by: Michael Telatynski <7t3chguy@gmail.com>	2025-11-24 09:07:13 +00:00
RiotRobot	c7a75c8824	Merge branch 'master' into develop	2025-11-18 14:27:42 +00:00
RiotRobot	98b2b9745d	v39.2.0	2025-11-18 14:26:56 +00:00
Michael Telatynski	65d5b3172c	Fix invalid state events corrupting room objects (#5078 ) * Fix invalid room name/canonical alias corrupting room objects Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> * Iterate Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> * Add test Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> --------- Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>	2025-11-18 10:46:24 +00:00
renovate[bot]	2f72f9e889	Update dependency eslint-plugin-jsdoc to v61.1.12 (#5074 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-11-11 14:30:01 +00:00
renovate[bot]	18f500a1f8	Update all non-major dependencies (#5076 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-11-11 14:01:33 +00:00
renovate[bot]	b1df58796a	Update typescript-eslint monorepo to v8.46.3 (#5075 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-11-11 14:01:12 +00:00
RiotRobot	761b3771d6	v39.2.0-rc.0	2025-11-11 12:44:05 +00:00
Andrew Ferrazzutti	df88edfda0	Delayed event management: split endpoints, no auth (#5066 ) * Delayed event management: split endpoints, no auth Add dedicated endpoints for each of the cancel/restart/send actions for updating a delayed event, and make them unauthenticated. Also keep support for the original endpoint where the update action is in the request body, and make the split-endpoint versions fall back to it if they are unsupported by the homeserver. * Don't @link parameters in method docstrings as TypeDoc doesn't support that * Reduce code duplication * Reduce code duplication again * Add a little more test coverage * Use split delayed event management for widgets * Specify which eslint rule to ignore Co-authored-by: Will Hunt <2072976+Half-Shot@users.noreply.github.com> * Restore embedded non-split delay evt update method Keep supporting it to not break widgets that currently use it. Also add back the test for it. * Deprecate the non-split delay evt update methods * Comment to explain fallback to non-split endpoint * Add backwards compatibility with authed endpoints * Comment backwards compatibility helper method * Await returned promises because `return await promise` is at least as fast as `return promise` --------- Co-authored-by: Will Hunt <2072976+Half-Shot@users.noreply.github.com>	2025-11-11 05:54:33 +00:00
David Langley	1dee1ba581	Fix media switching during legacy calls (#5069 ) * Specify exact for deviceId * Update mediaHandler.spec.ts * fallback to ideal if exact fails * Reduce cognitive complexity for sonar * Add tests	2025-11-10 09:36:32 +00:00
pkuzco	b274c74a30	do not set cache in authenticated fetch (#5020 ) * do not set cache in authenticated fetch * issue 5019 - updated comment * do not set cache in authenticated fetch Signed-off-by: Bahaa Naamneh <b.naamneh@gmail.com> * issue 5019 - updated comment Signed-off-by: Bahaa Naamneh <b.naamneh@gmail.com> --------- Signed-off-by: Bahaa Naamneh <b.naamneh@gmail.com> Co-authored-by: Bahaa Naamneh <glimm.no@gmail.com>	2025-11-06 14:36:27 +00:00
RiotRobot	b489bb15cf	Merge branch 'master' into develop	2025-11-04 14:02:00 +00:00
RiotRobot	dff4922a42	v39.1.2	2025-11-04 14:01:14 +00:00
Michael Telatynski	dc6ad0b54c	Fix npm publish script (#5068 ) The `id` is also an output from this workflow so needs re-adding, not sure how the token stuck around, I thought I removed that	2025-11-04 13:33:55 +00:00
RiotRobot	9769c05dc5	Merge branch 'master' into develop	2025-11-04 13:23:41 +00:00
RiotRobot	dd379d3d4c	v39.1.1	2025-11-04 13:22:58 +00:00
Michael Telatynski	1b884a3e52	Fix npm release missing template braces (#5067 )	2025-11-04 13:00:29 +00:00
RiotRobot	ddb164490e	Merge branch 'master' into develop	2025-11-04 12:54:27 +00:00
Michael Telatynski	4cc4c01dd8	Remove call to npm dist-tag (#5065 ) As it does not work for NPM Trusted Publishing https://github.com/npm/cli/issues/8547 Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>	2025-10-30 09:34:14 +00:00
Michael Telatynski	0ae483ce27	Use NPM Trusted Publishers over token (#5064 ) * Use NPM Trusted Publishers over token due to security changes being enacted next month by npm Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> * Update npm as ubuntu-latest only has 10.x and 11.5.1 or later is necessary Signed-off-by: Michael Telatynski <7t3chguy@gmail.com> --------- Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>	2025-10-29 16:07:11 +00:00
renovate[bot]	dbc1fa87ed	Update dependency eslint-plugin-jsdoc to v61.1.8 (#5058 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-10-28 23:03:02 +00:00
renovate[bot]	0a3675b971	Update typescript-eslint monorepo to v8.46.2 (#5059 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-10-28 16:11:40 +00:00
renovate[bot]	ab3f529d29	Update babel monorepo to v7.28.5 (#5057 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-10-28 14:57:44 +00:00
renovate[bot]	607b712a07	Update dependency sdp-transform to v3 (#5062 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-10-28 14:54:32 +00:00
renovate[bot]	b6d9e49277	Update dependency @stylistic/eslint-plugin to v5.5.0 (#5061 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-10-28 14:54:17 +00:00
renovate[bot]	731d5943e2	Update GitHub Artifact Actions (#5063 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-10-28 14:54:08 +00:00
renovate[bot]	01e7a43593	Update all non-major dependencies (#5060 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-10-28 14:53:35 +00:00