Cover the standalone client's initialisation and session restore

Neither had a test before the move, so the moved lines showed up as
uncovered. The client initialisation is tested through a fake client
and mocked stores: which store it syncs into with and without
IndexedDB, with and without the worker, the fallback to memory when
the IndexedDB store cannot start, clearing the stores only when not
restoring, carrying on without crypto, and counting as ready only
after a sync from the network rather than the one restored from the
store. The session restore is tested for no stored session, a
restored one, one the homeserver no longer knows, and any other
failure.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

docker-compose-playwright.yml

@@ -19,7 +19,7 @@ services:
       - ./backend/playwright_homeserver-othersite.yaml:/data/cfg/homeserver.yaml:Z
   element-web:
     # Pin to a SHA so that upstream cannot break our tests. Renovate handles regular updates.
-    image: ghcr.io/element-hq/element-web:develop@sha256:e063472b6bdf6d0bfa1d43dfa4ef7effee1efd2c9684daee665d1bedfe746a47
+    image: ghcr.io/element-hq/element-web:develop@sha256:a79801206c628a912d57fa6f355d5c5ab9c6c40c2d1b6208d4192678fb6e80c7
   element-web-1:
     # Pin to a SHA so that upstream cannot break our tests. Renovate handles regular updates.
-    image: ghcr.io/element-hq/element-web:develop@sha256:e063472b6bdf6d0bfa1d43dfa4ef7effee1efd2c9684daee665d1bedfe746a47
+    image: ghcr.io/element-hq/element-web:develop@sha256:a79801206c628a912d57fa6f355d5c5ab9c6c40c2d1b6208d4192678fb6e80c7

locales/en/app.json

@@ -3,7 +3,6 @@
     "user_menu": "User menu"
   },
   "action": {
-    "add_background_image": "Add image",
     "close": "Close",
     "copy_link": "Copy link",
     "edit": "Edit",
@@ -99,10 +98,6 @@
   },
   "disconnected_banner": "Connectivity to the server has been lost.",
   "error": {
-    "background_animated": "Animated images cannot be used as a background",
-    "background_not_an_image": "That file is not a supported image",
-    "background_not_kept": "That background could not be saved",
-    "background_undecodable": "That image could not be opened",
     "call_is_not_supported": "Call is not supported",
     "call_not_found": "Call not found",
     "call_not_found_description": "<0>That link doesn't appear to belong to any existing call. Check that you have the right link, or <2>create a new one</2>.</0>",

package.json

@@ -97,7 +97,6 @@
     "copy-to-clipboard": "^3.3.3",
     "eslint-plugin-element-call": "link:eslint",
     "eslint-plugin-storybook": "^10.3.6",
-    "fake-indexeddb": "^6.2.5",
     "fetch-mock": "11.1.5",
     "i18next": "^26.0.0",
     "i18next-browser-languagedetector": "^8.0.0",

playwright/background-effects.spec.ts

@@ -5,15 +5,9 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { expect, test, type Browser, type Page } from "@playwright/test";
+import { expect, test, type Locator, type Page } from "@playwright/test";
 
 import { SpaHelpers } from "./spa-helpers.ts";
-import {
-  averageColour,
-  cameraColour,
-  type Colour,
-  distance,
-} from "./utils/colour.ts";
 
 // Background effects need WebGL2, and headless Firefox on a CI runner has none,
 // so it rightly offers none of them.
@@ -22,13 +16,15 @@ test.skip(
   "Background effects need WebGL2, which headless Firefox on CI does not have",
 );
 
+type Colour = [number, number, number];
+
 test.describe("background effects", () => {
   test("pre-join preview shows the chosen effect", async ({ page }) => {
     test.slow();
     await page.goto("/");
     await SpaHelpers.createCall(page, "Effect user", "Background effects");
     const preview = page.locator("video").first();
-    const camera = await cameraColour(preview);
+    const camera = await averageColour(preview);
 
     await page.getByRole("button", { name: "Camera", exact: true }).click();
     const tile = page
@@ -106,807 +102,25 @@ async function drawsPerSecond(page: Page): Promise<number> {
   });
 }
 
-test.describe("the camera menu's preview", () => {
-  test("shows the camera with the effect in force", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Preview user", "Preview in the menu");
-    const camera = await cameraColour(page.locator("video").first());
-
-    await page.getByRole("button", { name: "Camera", exact: true }).click();
-    const preview = page.getByRole("menu").locator("video");
-    await expect(preview).toBeVisible();
-    await expect
-      .poll(async () => distance(await averageColour(preview), camera), {
-        timeout: 20_000,
-      })
-      .toBeLessThan(30);
-
-    const tile = page.getByRole("menuitemradio", { name: "Background 1" });
-    await tile.click();
-    const picture = await averageColour(tile.locator("img"));
-    await expect
-      .poll(async () => distance(await averageColour(preview), picture), {
-        timeout: 60_000,
-      })
-      .toBeLessThan(distance(camera, picture) / 2);
-  });
-
-  test("shows the call's own camera once joined", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(
-      page,
-      "Call preview user",
-      "Preview in the call's menu",
-      true,
-    );
-    await expect(page.getByTestId("incall_videomute")).toBeEnabled({
-      timeout: 10_000,
-    });
-    const camera = await cameraColour(page.locator("video").first());
-
-    await page.getByRole("button", { name: "Camera", exact: true }).click();
-    const preview = page.getByRole("menu").locator("video");
-    await expect(preview).toBeVisible();
-    await expect
-      .poll(async () => distance(await averageColour(preview), camera), {
-        timeout: 20_000,
-      })
-      .toBeLessThan(30);
-
-    const tile = page.getByRole("menuitemradio", { name: "Background 1" });
-    await tile.click();
-    const picture = await averageColour(tile.locator("img"));
-    await expect
-      .poll(async () => distance(await averageColour(preview), picture), {
-        timeout: 60_000,
-      })
-      .toBeLessThan(distance(camera, picture) / 2);
-  });
-});
-
-test.describe("background effects section", () => {
-  test("section stays within the call area at every size", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Sizes user", "Background effect sizes");
-
-    for (const size of [
-      { width: 1280, height: 800 },
-      { width: 800, height: 600 },
-      { width: 600, height: 420 },
-      { width: 480, height: 360 },
-      { width: 360, height: 640 },
-    ]) {
-      await page.setViewportSize(size);
-      await page.getByRole("button", { name: "Camera", exact: true }).click();
-      const menu = page.getByRole("menu");
-      await expect(menu).toBeVisible();
-
-      const box = (await menu.boundingBox())!;
-      const where = `at ${size.width}x${size.height}`;
-      expect(box.x, where).toBeGreaterThanOrEqual(0);
-      expect(box.y, where).toBeGreaterThanOrEqual(0);
-      expect(box.x + box.width, where).toBeLessThanOrEqual(size.width);
-      expect(box.y + box.height, where).toBeLessThanOrEqual(size.height);
-
-      const last = page
-        .getByRole("group", { name: "Background effects" })
-        .getByRole("menuitemradio")
-        .last();
-      await last.scrollIntoViewIfNeeded();
-      await expect(last, where).toBeInViewport({ ratio: 1 });
-      await last.click();
-      await expect(last, where).toHaveAttribute("aria-checked", "true");
-
-      // Back to no effect for the next size, and close.
-      await page
-        .getByRole("group", { name: "Background effects" })
-        .getByRole("menuitemradio", { name: "None" })
-        .click();
-      await page.keyboard.press("Escape");
-      await expect(menu).toBeHidden();
-    }
-  });
-});
-
-test.describe("the chosen effect", () => {
-  test("chosen effect survives leaving and rejoining", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Returning user", "Effect remembered");
-    const { camera, picture } = await chooseAndWear(page, "Background 1");
-    await page.getByTestId("lobby_joinCall").click();
-    await page.getByTestId("incall_leave").click();
-    await expect(page.getByRole("heading")).toContainText(
-      "your call has ended",
-    );
-
-    await page.goto("/");
-    await page.getByTestId("home_callName").fill("Effect remembered again");
-    await page.getByTestId("home_go").click();
-    await expect(page.getByTestId("lobby_joinCall")).toBeVisible();
-    await page.getByRole("button", { name: "Camera", exact: true }).click();
-    const tile = page
-      .getByRole("group", { name: "Background effects" })
-      .getByRole("menuitemradio", { name: "Background 1" });
-    await expect(tile).toHaveAttribute("aria-checked", "true");
-    const preview = page.locator("video").first();
-    await expect
-      .poll(async () => distance(await averageColour(preview), picture), {
-        timeout: 60_000,
-      })
-      .toBeLessThan(distance(camera, picture) / 2);
-  });
-
-  test("second session still shows the existing error", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Two tabs", "Effect in two tabs");
-    await chooseAndWear(page, "Background 1");
-
-    const second = await page.context().newPage();
-    await second.goto("/");
-    await expect(
-      page.getByRole("heading", { name: "Opened in another tab" }),
-    ).toBeVisible();
-  });
-});
-
-/** Chooses an effect in the lobby, and waits until the preview wears it. */
-async function chooseAndWear(
-  page: Page,
-  name: string,
-): Promise<{ camera: Colour; picture: Colour }> {
-  const preview = page.locator("video").first();
-  const camera = await cameraColour(preview);
-  await page.getByRole("button", { name: "Camera", exact: true }).click();
-  const tile = page.getByRole("menuitemradio", { name });
-  await tile.click();
-  const picture = await averageColour(tile.locator("img"));
-  await expect
-    .poll(async () => distance(await averageColour(preview), picture), {
-      timeout: 60_000,
-    })
-    .toBeLessThan(distance(camera, picture) / 2);
-  await page.keyboard.press("Escape");
-  return { camera, picture };
-}
-
-test.describe("a background of one's own", () => {
-  test("adds an image from the device", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Adding user", "Own background");
-    const preview = page.locator("video").first();
-    const camera = await cameraColour(preview);
-    const red = await redImage(page);
-
-    await addImage(page, red);
-    const mine = page
-      .getByRole("group", { name: "Background effects" })
-      .getByRole("menuitemradio", { name: "Background 3" });
-    await expect(mine).toBeVisible();
-    await expect(mine).toHaveAttribute("aria-checked", "false");
-
-    await mine.click();
-    await expect
-      .poll(async () => distance(await averageColour(preview), RED), {
-        timeout: 60_000,
-      })
-      .toBeLessThan(distance(camera, RED) / 2);
-  });
-
-  test("adding an image makes no upload", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Private user", "Own background kept");
-    const preview = page.locator("video").first();
-    const camera = await cameraColour(preview);
-    const red = await redImage(page);
-    const sent: { request: string; body: Buffer | null }[] = [];
-    page.on("request", (request) =>
-      sent.push({
-        request: `${request.method()} ${request.url()}`,
-        body: request.postDataBuffer(),
-      }),
-    );
-
-    await addImage(page, red);
-    await page
-      .getByRole("group", { name: "Background effects" })
-      .getByRole("menuitemradio", { name: "Background 3" })
-      .click();
-    // Kept, chosen and in force: anything that would send it has had its turn.
-    await expect
-      .poll(async () => distance(await averageColour(preview), RED), {
-        timeout: 60_000,
-      })
-      .toBeLessThan(distance(camera, RED) / 2);
-    // The file as given, and the copy kept, which is encoded anew.
-    const samples = [red, await keptBytes(page)].map((bytes) =>
-      bytes.subarray(bytes.length - 64),
-    );
-    const carriesIt = sent.filter(
-      ({ request, body }) =>
-        request.includes("/_matrix/media/") ||
-        samples.some((sample) => body?.includes(sample)),
-    );
-    expect(carriesIt.map(({ request }) => request)).toEqual([]);
-  });
-
-  test("added image survives rejoining and is gone after storage is cleared", async ({
-    page,
-  }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Keeping user", "Own background again");
-    const preview = page.locator("video").first();
-    const camera = await cameraColour(preview);
-    const red = await redImage(page);
-    await addImage(page, red);
-    const mine = page
-      .getByRole("group", { name: "Background effects" })
-      .getByRole("menuitemradio", { name: "Background 3" });
-    await mine.click();
-    await page.keyboard.press("Escape");
-
-    await page.reload();
-    await expect(page.getByTestId("lobby_joinCall")).toBeVisible();
-    await page.getByRole("button", { name: "Camera", exact: true }).click();
-    await expect(mine).toHaveAttribute("aria-checked", "true");
-    await page.keyboard.press("Escape");
-    await expect
-      .poll(async () => distance(await averageColour(preview), RED), {
-        timeout: 60_000,
-      })
-      .toBeLessThan(distance(camera, RED) / 2);
-
-    await page.evaluate(
-      async () =>
-        new Promise<void>((resolve, reject) => {
-          const request = indexedDB.deleteDatabase(
-            "element-call-background-images",
-          );
-          request.onsuccess = (): void => resolve();
-          request.onerror = (): void => reject(request.error);
-          request.onblocked = (): void => resolve();
-        }),
-    );
-    await page.reload();
-    await expect(page.getByTestId("lobby_joinCall")).toBeVisible();
-    await page.getByRole("button", { name: "Camera", exact: true }).click();
-    await expect(
-      page.getByRole("group", { name: "Background effects" }),
-    ).toBeVisible();
-    await expect(mine).toHaveCount(0);
-    await page.keyboard.press("Escape");
-
-    await addImage(page, red);
-    await expect(mine).toBeVisible();
-  });
-
-  test("a removed image stays removed", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(
-      page,
-      "Removing user",
-      "Own background removed",
-    );
-    await addImage(page, await redImage(page));
-    const mine = page
-      .getByRole("group", { name: "Background effects" })
-      .getByRole("menuitemradio", { name: "Background 3" });
-    await expect(mine).toHaveAttribute("aria-keyshortcuts", "Delete");
-    await mine.focus();
-    await page.keyboard.press("Delete");
-    await expect(mine).toHaveCount(0);
-
-    await page.reload();
-    await expect(page.getByTestId("lobby_joinCall")).toBeVisible();
-    await page.getByRole("button", { name: "Camera", exact: true }).click();
-    await expect(
-      page.getByRole("group", { name: "Background effects" }),
-    ).toBeVisible();
-    await expect(mine).toHaveCount(0);
-    expect(await keptImages(page)).toEqual([]);
-  });
-});
-
-test.describe("what can be added", () => {
-  test("refuses an animated image", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Refused user", "Animated refused");
-    await addImage(page, ANIMATED_GIF, {
-      name: "moving.gif",
-      type: "image/gif",
-    });
-
-    await expect(
-      page.getByText("Animated images cannot be used as a background"),
-    ).toBeVisible();
-    const section = page.getByRole("group", { name: "Background effects" });
-    await expect(
-      section.getByRole("menuitemradio", { name: "Background 3" }),
-    ).toHaveCount(0);
-    await expect(
-      section.getByRole("menuitemradio", { name: "None" }),
-    ).toHaveAttribute("aria-checked", "true");
-    expect(await keptImages(page)).toEqual([]);
-  });
-
-  test("reduces an oversized image", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Large user", "Oversized reduced");
-    await addImage(page, await pngImage(page, { width: 4000, height: 3000 }));
-
-    await expect(
-      page
-        .getByRole("group", { name: "Background effects" })
-        .getByRole("menuitemradio", { name: "Background 3" }),
-    ).toBeVisible();
-    await expect(page.getByRole("alert")).toHaveCount(0);
-    const [kept] = await keptImages(page);
-    expect(kept).toMatchObject({ width: 1920, height: 1440 });
-  });
-
-  test("lays every image on an opaque ground", async ({ page }) => {
-    test.setTimeout(120_000);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Logo user", "Transparent made opaque");
-    await addImage(
-      page,
-      await pngImage(page, { width: 320, height: 180, transparent: true }),
-    );
-
-    await expect(
-      page
-        .getByRole("group", { name: "Background effects" })
-        .getByRole("menuitemradio", { name: "Background 3" }),
-    ).toBeVisible();
-    const [kept] = await keptImages(page);
-    expect(kept.minAlpha).toBe(255);
-  });
-});
-
-/** Two frames of one pixel, red then blue. */
-const ANIMATED_GIF = Buffer.from(
-  "R0lGODlhAQABAPEAAP8AAAAA/wAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQACgAAACwAAAAAAQABAAACAkQBACH5BAAKAAAALAAAAAABAAEAAAICTAEAOw==",
-  "base64",
-);
-
-/** A red PNG of the given size; transparent leaves its right half empty. */
-async function pngImage(
-  page: Page,
-  size: { width: number; height: number; transparent?: boolean },
-): Promise<Buffer> {
-  const dataUrl = await page.evaluate(({ width, height, transparent }) => {
-    const canvas = document.createElement("canvas");
-    canvas.width = width;
-    canvas.height = height;
-    const context = canvas.getContext("2d")!;
-    context.fillStyle = "rgb(255, 0, 0)";
-    context.fillRect(0, 0, transparent ? width / 2 : width, height);
-    return canvas.toDataURL("image/png");
-  }, size);
-  return Buffer.from(dataUrl.split(",")[1], "base64");
-}
-
-/** The images the device keeps, as it keeps them. */
-async function keptImages(
-  page: Page,
-): Promise<{ width: number; height: number; minAlpha: number }[]> {
-  return page.evaluate(async () => {
-    const db = await new Promise<IDBDatabase>((resolve, reject) => {
-      const request = indexedDB.open("element-call-background-images");
-      request.onsuccess = (): void => resolve(request.result);
-      request.onerror = (): void => reject(request.error);
-    });
-    if (!db.objectStoreNames.contains("backgrounds")) return [];
-    const kept = await new Promise<{ image: Blob }[]>((resolve, reject) => {
-      const request = db
-        .transaction("backgrounds")
-        .objectStore("backgrounds")
-        .getAll();
-      request.onsuccess = (): void => resolve(request.result);
-      request.onerror = (): void => reject(request.error);
-    });
-    db.close();
-    return Promise.all(
-      kept.map(async ({ image }) => {
-        const bitmap = await createImageBitmap(image);
-        const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
-        const context = canvas.getContext("2d")!;
-        context.drawImage(bitmap, 0, 0);
-        const { data } = context.getImageData(
-          0,
-          0,
-          bitmap.width,
-          bitmap.height,
-        );
-        let minAlpha = 255;
-        for (let i = 3; i < data.length; i += 4)
-          minAlpha = Math.min(minAlpha, data[i]);
-        return { width: bitmap.width, height: bitmap.height, minAlpha };
-      }),
-    );
-  });
-}
-
-/** The bytes of the one image the device keeps. */
-async function keptBytes(page: Page): Promise<Buffer> {
-  const base64 = await page.evaluate(
-    async () =>
-      new Promise<string>((resolve, reject) => {
-        const open = indexedDB.open("element-call-background-images");
-        open.onerror = (): void => reject(open.error);
-        open.onsuccess = (): void => {
-          const all = open.result
-            .transaction("backgrounds")
-            .objectStore("backgrounds")
-            .getAll();
-          all.onerror = (): void => reject(all.error);
-          all.onsuccess = (): void => {
-            const reader = new FileReader();
-            reader.onload = (): void =>
-              resolve((reader.result as string).split(",")[1]);
-            reader.readAsDataURL((all.result[0] as { image: Blob }).image);
-          };
-        };
-      }),
-  );
-  return Buffer.from(base64, "base64");
-}
-
-const RED: Colour = [255, 0, 0];
-
-/** A solid red PNG, unlike the camera and the shipped pictures. */
-async function redImage(page: Page): Promise<Buffer> {
-  const dataUrl = await page.evaluate(() => {
-    const canvas = document.createElement("canvas");
-    canvas.width = 320;
-    canvas.height = 180;
-    const context = canvas.getContext("2d")!;
-    context.fillStyle = "rgb(255, 0, 0)";
-    context.fillRect(0, 0, canvas.width, canvas.height);
-    return canvas.toDataURL("image/png");
-  });
-  return Buffer.from(dataUrl.split(",")[1], "base64");
-}
-
-/** Adds an image from the camera menu's add tile, leaving the menu open. */
-async function addImage(
-  page: Page,
-  image: Buffer,
-  { name, type } = { name: "mine.png", type: "image/png" },
-): Promise<void> {
-  if (!(await page.getByRole("menu").isVisible()))
-    await page.getByRole("button", { name: "Camera", exact: true }).click();
-  const chooser = page.waitForEvent("filechooser");
-  await page.getByRole("menuitem", { name: "Add image" }).click();
-  await (await chooser).setFiles({ name, mimeType: type, buffer: image });
-}
-
-test.describe("joining with a background chosen", () => {
-  test("publishes no frame of the room", async ({ browser }) => {
-    // Two first builds of the pipeline, one of them held back.
-    test.setTimeout(180_000);
-    const hostContext = await browser.newContext();
-    const host = await hostContext.newPage();
-    await recordIncomingFrames(host);
-    await host.goto("/");
-    await SpaHelpers.createCall(host, "Host", "Join with a background", true);
-    await expect(host.getByTestId("incall_videomute")).toBeEnabled({
-      timeout: 10_000,
-    });
-    const inviteLink = await SpaHelpers.getCallInviteLink(host);
-    await host.keyboard.press("Escape");
-
-    const guestContext = await browser.newContext();
-    const guest = await guestContext.newPage();
-    await guest.goto(inviteLink);
-    await guest.getByTestId("joincall_displayName").fill("Guest");
-    await guest.getByTestId("joincall_joincall").click();
-    const preview = guest.locator("video").first();
-    await expect(preview).toBeVisible();
-    const camera = await cameraColour(preview);
-    await guest.getByRole("button", { name: "Camera", exact: true }).click();
-    const tile = guest.getByRole("menuitemradio", { name: "Background 1" });
-    await tile.click();
-    const picture = await averageColour(tile.locator("img"));
-    await expect
-      .poll(async () => distance(await averageColour(preview), picture), {
-        timeout: 60_000,
-      })
-      .toBeLessThan(distance(camera, picture) / 2);
-    // Were the pipeline built again for the call's track, it would take as
-    // long as on the slower route. Routing bypasses the cache, so it waits.
-    let heldBack = 0;
-    await guest.route("**/*.tflite*", async (route) => {
-      heldBack += 1;
-      await new Promise((resolve) => setTimeout(resolve, 15_000));
-      await route.continue();
-    });
-    await guest.keyboard.press("Escape");
-    await guest.getByTestId("lobby_joinCall").click();
-
-    const guestTile = host
-      .getByTestId("videoTile")
-      .filter({ has: host.getByTestId("name_tag").getByText("Guest") });
-    await expect(guestTile.locator("video")).toBeVisible({ timeout: 60_000 });
-    // Visible can come before the stream is attached.
-    let trackId: string | undefined;
-    await expect
-      .poll(async () => {
-        trackId = await guestTile
-          .locator("video")
-          .evaluate(
-            (video: HTMLVideoElement) =>
-              (video.srcObject as MediaStream | null)?.getVideoTracks()[0]?.id,
-          );
-        return trackId;
-      })
-      .toBeDefined();
-    await expectNoFrameOfTheRoom(host, trackId!, 0, camera, picture);
-    // The join adopts the lobby's pipeline, so the model is never fetched again.
-    expect(heldBack).toBe(0);
-
-    await hostContext.close();
-    await guestContext.close();
-  });
-});
-
-test.describe("the first build", () => {
-  test("survives the camera turned off and on while it runs", async ({
-    page,
-  }) => {
-    test.setTimeout(120_000);
-    const failures: string[] = [];
-    page.on("console", (m) => {
-      if (m.text().includes("Failed to attach video processor"))
-        failures.push(m.text());
-    });
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Toggling user", "Toggle while building");
-    const preview = page.locator("video").first();
-    const camera = await cameraColour(preview);
-
-    const held = await holdBackTheModel(page);
-    await page.getByRole("button", { name: "Camera", exact: true }).click();
-    const tile = page.getByRole("menuitemradio", { name: "Background 1" });
-    await tile.click();
-    const picture = await averageColour(tile.locator("img"));
-    await page.keyboard.press("Escape");
-    // New preview tracks, each attached while the first is still building.
-    for (let i = 0; i < 2; i++) {
-      await page.getByTestId("incall_videomute").click();
-      await page.getByTestId("incall_videomute").click();
-    }
-
-    await expect
-      .poll(async () => distance(await averageColour(preview), picture), {
-        timeout: 60_000,
-      })
-      .toBeLessThan(distance(camera, picture) / 2);
-    expect(failures).toEqual([]);
-    expect(held()).toBeGreaterThan(0);
-  });
-});
-
-test.describe("turning the camera on with a background chosen", () => {
-  test("publishes no frame of the room when the camera started off", async ({
-    browser,
-  }) => {
-    test.setTimeout(120_000);
-    const { host, guest, close } = await hostAndGuest(browser);
-    const camera = await cameraColour(guest.locator("video").first());
-    await guest.getByTestId("incall_videomute").click();
-    await guest.getByTestId("lobby_joinCall").click();
-
-    const picture = await chooseBackground(guest);
-    const held = await holdBackTheModel(guest);
-    await guest.getByTestId("incall_videomute").click();
-
-    const trackId = await incomingTrackId(host);
-    await expectNoFrameOfTheRoom(host, trackId, 0, camera, picture);
-    expect(held()).toBeGreaterThan(0);
-    await close();
-  });
-
-  test("publishes no frame of the room when the camera was turned off", async ({
-    browser,
-  }) => {
-    test.setTimeout(120_000);
-    const { host, guest, close } = await hostAndGuest(browser);
-    const camera = await cameraColour(guest.locator("video").first());
-    await guest.getByTestId("lobby_joinCall").click();
-    const trackId = await incomingTrackId(host);
-    await expect
-      .poll(async () => (await framesOf(host, trackId)).length, {
-        timeout: 20_000,
-      })
-      .toBeGreaterThan(0);
-    await guest.getByTestId("incall_videomute").click();
-
-    const picture = await chooseBackground(guest);
-    const held = await holdBackTheModel(guest);
-    const before = (await framesOf(host, trackId)).length;
-    await guest.getByTestId("incall_videomute").click();
-
-    await expectNoFrameOfTheRoom(host, trackId, before, camera, picture);
-    expect(held()).toBeGreaterThan(0);
-    await close();
-  });
-});
-
-/** A host in a call, recording what it receives, and a guest in its lobby. */
-async function hostAndGuest(browser: Browser): Promise<{
-  host: Page;
-  guest: Page;
-  close: () => Promise<void>;
-}> {
-  const hostContext = await browser.newContext();
-  const host = await hostContext.newPage();
-  await recordIncomingFrames(host);
-  await host.goto("/");
-  await SpaHelpers.createCall(host, "Host", "Camera with a background", true);
-  await expect(host.getByTestId("incall_videomute")).toBeEnabled({
-    timeout: 10_000,
-  });
-  const inviteLink = await SpaHelpers.getCallInviteLink(host);
-  await host.keyboard.press("Escape");
-
-  const guestContext = await browser.newContext();
-  const guest = await guestContext.newPage();
-  await guest.goto(inviteLink);
-  await guest.getByTestId("joincall_displayName").fill("Guest");
-  await guest.getByTestId("joincall_joincall").click();
-  await expect(guest.locator("video").first()).toBeVisible();
-  return {
-    host,
-    guest,
-    close: async (): Promise<void> => {
-      await hostContext.close();
-      await guestContext.close();
-    },
-  };
-}
-
-/** Chooses the first shipped picture in the call, and answers its colour. */
-async function chooseBackground(guest: Page): Promise<Colour> {
-  // The lobby has a camera button of its own, so wait for the call's.
-  await expect(guest.getByTestId("incall_leave")).toBeVisible({
-    timeout: 30_000,
-  });
-  await expect(guest.getByTestId("incall_videomute")).toBeEnabled({
-    timeout: 10_000,
-  });
-  await guest.getByRole("button", { name: "Camera", exact: true }).click();
-  const tile = guest.getByRole("menuitemradio", { name: "Background 1" });
-  await tile.click();
-  await expect(tile).toHaveAttribute("aria-checked", "true");
-  const picture = await averageColour(tile.locator("img"));
-  await guest.keyboard.press("Escape");
-  return picture;
-}
-
-/** Makes the pipeline's first build as slow as on the slower route. */
-/** Answers how often it held the model back, which a check should see. */
-async function holdBackTheModel(page: Page): Promise<() => number> {
-  let held = 0;
-  // Routing bypasses the cache, so it waits.
-  await page.route("**/*.tflite*", async (route) => {
-    held += 1;
-    await new Promise((resolve) => setTimeout(resolve, 5_000));
-    await route.continue();
-  });
-  return () => held;
-}
-
-/** The id of the guest's camera track, as the host receives it. */
-async function incomingTrackId(host: Page): Promise<string> {
-  const guestTile = host
-    .getByTestId("videoTile")
-    .filter({ has: host.getByTestId("name_tag").getByText("Guest") });
-  await expect(guestTile.locator("video")).toBeVisible({ timeout: 60_000 });
-  // Visible can come before the stream is attached.
-  let trackId: string | undefined;
-  await expect
-    .poll(async () => {
-      trackId = await guestTile
-        .locator("video")
-        .evaluate(
-          (video: HTMLVideoElement) =>
-            (video.srcObject as MediaStream | null)?.getVideoTracks()[0]?.id,
-        );
-      return trackId;
-    })
-    .toBeDefined();
-  return trackId!;
-}
-
-/** Waits for the picture to arrive, then finds no frame of the room since. */
-async function expectNoFrameOfTheRoom(
-  host: Page,
-  trackId: string,
-  since: number,
-  camera: Colour,
-  picture: Colour,
-): Promise<void> {
-  await expect
-    .poll(
-      async () => {
-        const frames = (await framesOf(host, trackId)).slice(since);
-        // A black frame, as a track starts, is nearer the picture than the
-        // camera, but shows neither.
-        return frames.some(
-          (f) =>
-            distance(f, picture) <
-            Math.min(distance(f, camera), distance(f, [0, 0, 0])),
-        );
-      },
-      { timeout: 60_000 },
-    )
-    .toBe(true);
-  const frames = (await framesOf(host, trackId)).slice(since);
-  expect(
-    frames.filter((f) => distance(f, camera) < distance(f, picture)),
-  ).toEqual([]);
-}
-
-/**
- * Records the mean colour of every frame of every video track the page
- * receives, from the moment it arrives: a tile may attach it later than its
- * first frame.
- */
-async function recordIncomingFrames(page: Page): Promise<void> {
-  await page.addInitScript(() => {
-    const frames: Record<string, [number, number, number][]> = {};
-    (window as unknown as { receivedFrames: typeof frames }).receivedFrames =
-      frames;
-    const record = (track: MediaStreamTrack): void => {
-      if (track.kind !== "video" || frames[track.id]) return;
-      const seen: [number, number, number][] = (frames[track.id] = []);
-      const video = document.createElement("video");
-      video.muted = true;
-      video.srcObject = new MediaStream([track]);
+/** The mean colour of a video's current frame or an image, drawn small. */
+async function averageColour(element: Locator): Promise<Colour> {
+  return element.evaluate(
+    async (source: HTMLVideoElement | HTMLImageElement) => {
+      if (source instanceof HTMLImageElement) await source.decode();
       const canvas = document.createElement("canvas");
-      canvas.width = canvas.height = 16;
-      const context = canvas.getContext("2d", { willReadFrequently: true })!;
-      const step = (): void => {
-        context.drawImage(video, 0, 0, 16, 16);
-        const { data } = context.getImageData(0, 0, 16, 16);
-        const sum = [0, 0, 0];
-        for (let i = 0; i < data.length; i += 4)
-          for (let c = 0; c < 3; c++) sum[c] += data[i + c];
-        seen.push(sum.map((v) => v / (data.length / 4)) as Colour);
-        video.requestVideoFrameCallback(step);
-      };
-      video.requestVideoFrameCallback(step);
-      void video.play();
-    };
-    const Connection = window.RTCPeerConnection;
-    window.RTCPeerConnection = class extends Connection {
-      public constructor(...args: ConstructorParameters<typeof Connection>) {
-        super(...args);
-        this.addEventListener("track", (e) => record(e.track));
-      }
-    };
-  });
-}
-
-async function framesOf(page: Page, trackId: string): Promise<Colour[]> {
-  return page.evaluate(
-    (id) =>
-      (
-        window as unknown as {
-          receivedFrames: Record<string, [number, number, number][]>;
-        }
-      ).receivedFrames[id] ?? [],
-    trackId,
+      canvas.width = canvas.height = 32;
+      const context = canvas.getContext("2d")!;
+      context.drawImage(source, 0, 0, 32, 32);
+      const { data } = context.getImageData(0, 0, 32, 32);
+      const sum = [0, 0, 0];
+      for (let i = 0; i < data.length; i += 4)
+        for (let c = 0; c < 3; c++) sum[c] += data[i + c];
+      const pixels = data.length / 4;
+      return sum.map((s) => s / pixels) as Colour;
+    },
   );
 }
+
+function distance(a: Colour, b: Colour): number {
+  return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+}

playwright/component/background-effects.spec.ts

@@ -1,85 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { expect, type Locator, type Page, test } from "@playwright/test";
-
-import { createUserAndRoom, resizeContainer, startHarness } from "./harness.ts";
-import { averageColour, cameraColour, expectWearing } from "../utils/colour.ts";
-
-// Background effects need WebGL2, and headless Firefox on a CI runner has none,
-// so it rightly offers none of them.
-test.skip(
-  ({ browserName }) => browserName === "firefox",
-  "Background effects need WebGL2, which headless Firefox on CI does not have",
-);
-
-/**
- * Background effects with Element Call as a component in a host page: the
- * pipeline's model and WebAssembly have to load from the component's bundle,
- * and the portalled menu has to be sized against the call, not the window.
- * Driven from the lobby, which builds the same menu and pipeline.
- */
-
-// Sign-in, crypto setup and sync happen twice before anything shows.
-test.describe.configure({ timeout: 180_000 });
-
-test("puts a picture on the call's preview", async ({ page }) => {
-  const { username, roomId } = await createUserAndRoom("effects");
-  const panes = await startHarness(page, username, roomId);
-  const pane = panes.first();
-  await resizeContainer(pane.getByTestId("call-container"), {
-    width: 900,
-    height: 480,
-  });
-  await expect(pane.getByTestId("lobby_joinCall")).toBeVisible({
-    timeout: 60_000,
-  });
-  const preview = pane.locator("video").first();
-  const camera = await cameraColour(preview);
-
-  const tile = await openEffect(page, pane, "Background 1");
-  const picture = await averageColour(tile.locator("img"));
-  await tile.click();
-  await expect(tile).toHaveAttribute("aria-checked", "true");
-  await expectWearing(preview, picture, camera);
-});
-
-test("keeps every effect reachable in a small container", async ({ page }) => {
-  const { username, roomId } = await createUserAndRoom("effectsreach");
-  const panes = await startHarness(page, username, roomId);
-  const pane = panes.first();
-  const container = pane.getByTestId("call-container");
-  await resizeContainer(container, { width: 400, height: 360 });
-  await expect(pane.getByTestId("lobby_joinCall")).toBeVisible({
-    timeout: 60_000,
-  });
-
-  const last = await openEffect(page, pane, "Background 2");
-  const list = page.locator("[role='menu'] div[role='none']").first();
-  expect((await list.boundingBox())!.height).toBeLessThanOrEqual(
-    (await container.boundingBox())!.height,
-  );
-  await last.scrollIntoViewIfNeeded();
-  await expect(last).toBeInViewport({ ratio: 1 });
-  await last.click();
-  await expect(last).toHaveAttribute("aria-checked", "true");
-});
-
-/** Opens a component's camera menu and returns one of its effects. */
-async function openEffect(
-  page: Page,
-  pane: Locator,
-  name: string,
-): Promise<Locator> {
-  await pane
-    .getByRole("button", { name: "Camera", exact: true })
-    .click({ timeout: 60_000 });
-  // Portalled out of the pane, so found on the page.
-  return page
-    .getByRole("group", { name: "Background effects" })
-    .getByRole("menuitemradio", { name });
-}

playwright/fixtures/widget-user.ts

@@ -109,7 +109,15 @@ export const widgetTest = test.extend<MyFixtures>({
       await TestHelpers.dismissInviteUnknownUserModal(ewPage1);
 
       // Accept the invite
-      await TestHelpers.openRoomInvite(ewPage2, "Welcome Room");
+      await TestHelpers.closeReleaseAnnouncement(
+        ewPage2,
+        "Introducing Sections",
+      );
+      await TestHelpers.expandAllSections(ewPage2);
+      await expect(
+        TestHelpers.roomListItem(ewPage2, "Welcome Room"),
+      ).toBeVisible();
+      await TestHelpers.roomListItem(ewPage2, "Welcome Room").click();
       await ewPage2.getByRole("button", { name: "Accept" }).click();
       await expect(
         ewPage2
@@ -117,7 +125,17 @@ export const widgetTest = test.extend<MyFixtures>({
           .getByRole("heading", { name: "Welcome Room" }),
       ).toBeVisible();
     } else if (callType === "dm") {
-      await TestHelpers.chooseFromRoomListNewMenu(ewPage1, "Start chat");
+      await TestHelpers.closeReleaseAnnouncement(
+        ewPage1,
+        "Introducing Sections",
+      );
+
+      await ewPage1
+        .getByRole("navigation", { name: "Room list" })
+        .getByRole("button", { name: "New", exact: true })
+        .click();
+
+      await ewPage1.getByRole("menuitem", { name: "Start chat" }).click();
       await ewPage1.getByRole("textbox", { name: "Search" }).click();
       await ewPage1.getByRole("textbox", { name: "Search" }).fill(whistlerMxId);
       await ewPage1.getByRole("button", { name: "Go" }).click();
@@ -139,7 +157,12 @@ export const widgetTest = test.extend<MyFixtures>({
       ).toBeVisible();
 
       // Accept the DM invite from brooks
-      await TestHelpers.openRoomInvite(ewPage2, brooksDisplayName);
+      await TestHelpers.closeReleaseAnnouncement(
+        ewPage2,
+        "Introducing Sections",
+      );
+      await TestHelpers.expandAllSections(ewPage2);
+      await TestHelpers.roomListItem(ewPage2, brooksDisplayName).click();
       await ewPage2.getByRole("button", { name: "Start chatting" }).click();
     }
 

playwright/utils/colour.ts

@@ -1,55 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { expect, type Locator } from "@playwright/test";
-
-export type Colour = [number, number, number];
-
-/** The camera's colour, once the preview is showing it rather than nothing. */
-export async function cameraColour(preview: Locator): Promise<Colour> {
-  await expect
-    .poll(async () => Math.max(...(await averageColour(preview))))
-    .toBeGreaterThan(40);
-  return averageColour(preview);
-}
-
-/** The mean colour of a video's current frame or an image, drawn small. */
-export async function averageColour(element: Locator): Promise<Colour> {
-  return element.evaluate(
-    async (source: HTMLVideoElement | HTMLImageElement) => {
-      if (source instanceof HTMLImageElement) await source.decode();
-      const canvas = document.createElement("canvas");
-      canvas.width = canvas.height = 32;
-      const context = canvas.getContext("2d")!;
-      context.drawImage(source, 0, 0, 32, 32);
-      const { data } = context.getImageData(0, 0, 32, 32);
-      const sum = [0, 0, 0];
-      for (let i = 0; i < data.length; i += 4)
-        for (let c = 0; c < 3; c++) sum[c] += data[i + c];
-      const pixels = data.length / 4;
-      return sum.map((s) => s / pixels) as Colour;
-    },
-  );
-}
-
-export function distance(a: Colour, b: Colour): number {
-  return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
-}
-
-/** Waits until a preview shows a picture rather than the camera. */
-export async function expectWearing(
-  preview: Locator,
-  picture: Colour,
-  camera: Colour,
-): Promise<void> {
-  // Long enough for the first effect of a session to be built.
-  await expect
-    .poll(async () => distance(await averageColour(preview), picture), {
-      timeout: 60_000,
-    })
-    .toBeLessThan(distance(camera, picture) / 2);
-}

playwright/widget/background-effects.spec.ts

@@ -1,43 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { expect, test } from "@playwright/test";
-
-import { widgetTest } from "../fixtures/widget-user.ts";
-import { TestHelpers } from "./test-helpers.ts";
-import { averageColour, cameraColour, expectWearing } from "../utils/colour.ts";
-
-// Background effects need WebGL2, and headless Firefox on a CI runner has none,
-// so it rightly offers none of them.
-test.skip(
-  ({ browserName }) => browserName === "firefox",
-  "Background effects need WebGL2, which headless Firefox on CI does not have",
-);
-
-widgetTest(
-  "puts a picture on the preview inside Element Web",
-  async ({ asWidget }) => {
-    test.slow();
-    const { brooks } = asWidget;
-    await TestHelpers.startCallInCurrentRoom(brooks.page, false);
-    const frame = brooks.page
-      .locator('iframe[title="Element Call"]')
-      .contentFrame();
-    await expect(frame.getByTestId("lobby_joinCall")).toBeVisible();
-    const preview = frame.locator("video").first();
-    const camera = await cameraColour(preview);
-
-    await frame.getByRole("button", { name: "Camera", exact: true }).click();
-    const tile = frame
-      .getByRole("group", { name: "Background effects" })
-      .getByRole("menuitemradio", { name: "Background 1" });
-    const picture = await averageColour(tile.locator("img"));
-    await tile.click();
-    await expect(tile).toHaveAttribute("aria-checked", "true");
-    await expectWearing(preview, picture, camera);
-  },
-);

playwright/widget/test-helpers.ts

@@ -157,34 +157,25 @@ export class TestHelpers {
   // Toast can be stacked, and only the top one can be dismiss, so just look at what is on top and
   // dismiss (if part of expected toats)
   public static async dismissStartupToasts(page: Page): Promise<void> {
-    const expectedToasts: {
-      title: string;
-      button: string;
-      confirm?: string;
-    }[] = [
+    const expectedToasts = [
       { title: "Failed to load service worker", button: "OK" },
       { title: "Back up your chats", button: "Not now" },
-      {
-        title: "Turn on key storage",
-        button: "Dismiss",
-        confirm: "Yes, dismiss",
-      },
-      { title: "Notifications", button: "Dismiss" },
+      { title: "Turn on key storage", button: "Dismiss" },
       { title: "Element does not support this browser", button: "Dismiss" },
     ];
 
     const toast = page.locator(".mx_Toast_toast");
-    const toastTitle = toast.locator(".mx_Toast_title h2");
 
     // eslint-disable-next-line no-constant-condition
     while (true) {
       try {
         await toast.waitFor({ state: "visible", timeout: 700 });
-        const title = await toastTitle.textContent();
-        if (!title) break;
+        const title = await toast.locator(".mx_Toast_title h2").textContent();
 
         // Find the matching toast config
-        const toastConfig = expectedToasts.find((t) => title.includes(t.title));
+        const toastConfig = expectedToasts.find((t) =>
+          title?.includes(t.title),
+        );
 
         if (toastConfig) {
           // Bounded so that a renamed button leaves the toast in place and the
@@ -192,16 +183,6 @@ export class TestHelpers {
           await toast
             .getByRole("button", { name: toastConfig.button })
             .click({ timeout: 5000 });
-          if (toastConfig.confirm) {
-            const dialog = page.getByRole("dialog");
-            await dialog
-              .getByRole("button", { name: toastConfig.confirm })
-              .click({ timeout: 5000 });
-            await expect(dialog).toBeHidden({ timeout: 5000 });
-          }
-          // The same element shows the next toast a moment after the click, so
-          // reading it straight away acts on the dismissed one a second time
-          await expect(toastTitle).not.toHaveText(title, { timeout: 5000 });
         } else {
           // Unknown toast. We don't want to act on unknown toasts
           break;
@@ -213,16 +194,6 @@ export class TestHelpers {
     }
   }
 
-  /**
-   * Clears what Element Web stacks over the room list after sign-in. The
-   * release announcement is held back while any toast is up, so it is closed
-   * after the toasts, not before.
-   */
-  public static async clearRoomListOverlays(page: Page): Promise<void> {
-    await TestHelpers.dismissStartupToasts(page);
-    await TestHelpers.closeReleaseAnnouncement(page, "Introducing Sections");
-  }
-
   public static async closeReleaseAnnouncement(
     page: Page,
     name: string,
@@ -252,7 +223,16 @@ export class TestHelpers {
     page: Page,
     andInvite: string[] = [],
   ): Promise<void> {
-    await TestHelpers.chooseFromRoomListNewMenu(page, "New Room");
+    await TestHelpers.closeReleaseAnnouncement(page, "Introducing Sections");
+
+    await page
+      .getByRole("navigation", { name: "Room list" })
+      .getByRole("button", { name: "New", exact: true })
+      .click();
+
+    await page.getByRole("menuitem", { name: "New Room" }).click({
+      timeout: 5000,
+    });
     await page.getByRole("textbox", { name: "Name" }).fill(name);
     await page.getByRole("button", { name: "Create room" }).click();
     await expect(page.getByText("You created this room.")).toBeVisible({
@@ -279,25 +259,6 @@ export class TestHelpers {
     }
   }
 
-  /**
-   * Opens the room list's "New" menu and picks the given item.
-   *
-   * While the sections announcement is anchored to the "New" button, the
-   * button has no menu at all, so the overlays go first. Driven by keyboard,
-   * as a toast arriving afterwards sits over the button and swallows clicks.
-   */
-  public static async chooseFromRoomListNewMenu(
-    page: Page,
-    itemName: string,
-  ): Promise<void> {
-    await TestHelpers.clearRoomListOverlays(page);
-    await page
-      .getByRole("navigation", { name: "Room list" })
-      .getByRole("button", { name: "New", exact: true })
-      .press("Enter");
-    await page.getByRole("menuitem", { name: itemName }).press("Enter");
-  }
-
   /**
    * Accepts a room invite using the room name.
    * Locatest the invite in the room list.
@@ -307,7 +268,9 @@ export class TestHelpers {
     roomName: string,
     page: Page,
   ): Promise<void> {
-    await TestHelpers.openRoomInvite(page, roomName);
+    await TestHelpers.closeReleaseAnnouncement(page, "Introducing Sections");
+    await TestHelpers.expandAllSections(page);
+    await TestHelpers.roomListItem(page, roomName).click({ timeout: 10000 });
     await page.getByRole("button", { name: "Accept" }).click({
       timeout: 5000,
     });
@@ -413,29 +376,6 @@ export class TestHelpers {
     return page.locator(`[aria-label^="Open room ${roomName}"]`);
   }
 
-  /**
-   * Opens a pending invite from the room list by its room name.
-   *
-   * Element Web collapses the Invites section every time it appears, so it is
-   * expanded here once the invite has arrived.
-   */
-  public static async openRoomInvite(
-    page: Page,
-    roomName: string,
-  ): Promise<void> {
-    const invitesSection = page.getByRole("button", {
-      name: "Toggle Invites section",
-    });
-    await expect(invitesSection).toBeVisible({ timeout: 10000 });
-    // Toasts and the announcement sit over the top of the room list, where
-    // this header is
-    await TestHelpers.clearRoomListOverlays(page);
-    if ((await invitesSection.getAttribute("aria-expanded")) !== "true") {
-      await invitesSection.click();
-    }
-    await TestHelpers.roomListItem(page, roomName).click({ timeout: 10000 });
-  }
-
   /**
    * Switches to a room in the room list by its name.
    * @param page - The EW page

pnpm-lock.yaml

@@ -160,9 +160,6 @@ importers:
       eslint-plugin-storybook:
         specifier: ^10.3.6
         version: 10.6.2(eslint@8.57.1(supports-color@7.2.0))(supports-color@7.2.0)(typescript@5.9.3)
-      fake-indexeddb:
-        specifier: ^6.2.5
-        version: 6.2.5
       fetch-mock:
         specifier: 11.1.5
         version: 11.1.5(node-fetch@2.7.0)
@@ -4051,10 +4048,6 @@ packages:
     resolution: {integrity: sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==}
     engines: {node: '>=12.0.0'}
 
-  fake-indexeddb@6.2.5:
-    resolution: {integrity: sha512-CGnyrvbhPlWYMngksqrSSUT1BAVP49dZocrHuK0SvtR0D5TMs5wP0o3j7jexDJW01KSadjBp1M/71o/KR3nD1w==}
-    engines: {node: '>=18'}
-
   fast-deep-equal@3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
 
@@ -9719,8 +9712,6 @@ snapshots:
 
   expect-type@1.4.0: {}
 
-  fake-indexeddb@6.2.5: {}
-
   fast-deep-equal@3.1.3: {}
 
   fast-glob@3.3.3:

src/App.tsx

@@ -30,7 +30,7 @@ import { HomePage } from "./home/HomePage";
 import { LoginPage } from "./auth/LoginPage";
 import { RegisterPage } from "./auth/RegisterPage";
 import { RoomPage } from "./room/RoomPage";
-import { ClientProvider } from "./ClientContext";
+import { type ClientLoader, ClientProvider } from "./ClientContext";
 import { ErrorPage, LoadingPage } from "./FullScreenView";
 import { Initializer } from "./initializer";
 import { type WidgetHelpers } from "./widget";
@@ -57,6 +57,16 @@ import { LeaveToHomeProvider } from "./LeaveToHomeContext";
 
 const SentryRoute = Sentry.withSentryReactRouterV7Routing(Route);
 
+// Element Call's own session, for when no host supplies a client.
+// - Passed in here, not imported by ClientProvider: this module is only in the
+//   app builds, so the client setup and the store worker behind it stay out of
+//   the component package (see the `loadClient` prop).
+// - Imported on demand, as it was before, so that a widget, which gets its
+//   client from the host, never downloads it.
+// - Module-level, so that the provider's effect sees one stable loader.
+const loadStandaloneClient: ClientLoader = async (...args) =>
+  (await import("./utils/spa")).initSPA(...args);
+
 interface SimpleProviderProps {
   children: JSX.Element;
 }
@@ -146,7 +156,7 @@ export const App: FC<Props> = ({ vm, widget }) => {
 
   const content =
     loaded && clientReady ? (
-      <ClientProvider client={widgetClient}>
+      <ClientProvider client={widgetClient} loadClient={loadStandaloneClient}>
         <MediaDevicesContext value={vm.mediaDevices}>
           <BackgroundEffectsProvider effects={vm.backgroundEffects}>
             <Sentry.ErrorBoundary

src/ClientContext.test.tsx

@@ -11,7 +11,11 @@ import { BrowserRouter } from "react-router-dom";
 import { type MatrixClient } from "matrix-js-sdk";
 import { type FC } from "react";
 
-import { ClientProvider, useClientState } from "./ClientContext";
+import {
+  type ClientLoader,
+  ClientProvider,
+  useClientState,
+} from "./ClientContext";
 
 const mockClient = (userId = "@alice:example.org"): MatrixClient =>
   ({
@@ -95,13 +99,13 @@ test("follows the client when the host swaps it", () => {
 
 test("finds a client of its own when the host supplies none", async () => {
   const client = mockClient();
-  vi.doMock("./utils/spa", () => ({
-    initSPA: vi.fn().mockResolvedValue({ client, passwordlessUser: true }),
-  }));
+  const loadClient = vi
+    .fn<ClientLoader>()
+    .mockResolvedValue({ client, passwordlessUser: true });
 
   const { container } = render(
     <BrowserRouter>
-      <ClientProvider>
+      <ClientProvider loadClient={loadClient}>
         <ShowClientState />
       </ClientProvider>
     </BrowserRouter>,
@@ -110,6 +114,21 @@ test("finds a client of its own when the host supplies none", async () => {
   // Nothing to show until a session has been restored or created
   expect(container.textContent).toBe("loading");
   await waitFor(() => expect(container.textContent).toBe("@alice:example.org"));
+  // Given the session store to restore from and to clear on a stale session
+  expect(loadClient).toHaveBeenCalledWith(
+    expect.any(Function),
+    expect.any(Function),
+  );
+});
 
-  vi.doUnmock("./utils/spa");
+test("has no one signed in when given neither a client nor a way to load one", async () => {
+  const { container } = render(
+    <BrowserRouter>
+      <ClientProvider>
+        <ShowClientState />
+      </ClientProvider>
+    </BrowserRouter>,
+  );
+
+  await waitFor(() => expect(container.textContent).toBe("unauthenticated"));
 });

src/ClientContext.tsx

@@ -143,9 +143,34 @@ interface Props {
    * own.
    */
   client?: MatrixClient;
+  /**
+   * How Element Call finds a client when none is supplied: the standalone app
+   * restores or creates a session of its own. Stable, as a hook dependency.
+   * Left out along with the client, no one is signed in.
+   *
+   * A prop, rather than this module importing `utils/spa` itself, because:
+   * - This module is in the component build, and so is everything it imports,
+   *   dynamically or not: a dynamic import becomes a chunk in the package,
+   *   not a module left out of it.
+   * - Behind `utils/spa` sits `utils/initClient` and the client store worker,
+   *   which the bundler emits as soon as it loads the import (see there).
+   * - `App.tsx`, which the component never imports, is where the standalone
+   *   app passes the loader in; the component passes nothing, having the
+   *   host's client.
+   */
+  loadClient?: ClientLoader;
 }
 
-export const ClientProvider: FC<Props> = ({ children, client }) => {
+/**
+ * Restores or creates a session of Element Call's own, kept where the given
+ * functions keep it. Resolves to null when no one is signed in.
+ */
+export type ClientLoader = (
+  loadSession: () => Session | undefined,
+  clearSession: () => void,
+) => Promise<InitResult | null>;
+
+export const ClientProvider: FC<Props> = ({ children, client, loadClient }) => {
   const leaveToHome = useLeaveToHome();
   const hostBridge = useHostBridge();
 
@@ -179,9 +204,13 @@ export const ClientProvider: FC<Props> = ({ children, client }) => {
     // React does in strict mode), we need to make sure not to doubly initialize
     // the client.
     if (initializing.current) return;
+    if (loadClient === undefined) {
+      setInitClientState(null);
+      return;
+    }
     initializing.current = true;
 
-    loadClient()
+    loadClient(loadSession, clearSession)
       .then((initResult) => {
         setInitClientState(initResult);
         if (PosthogAnalytics.instance.isEnabled())
@@ -189,7 +218,7 @@ export const ClientProvider: FC<Props> = ({ children, client }) => {
       })
       .catch((err) => logger.error(err))
       .finally(() => (initializing.current = false));
-  }, [client]);
+  }, [client, loadClient]);
 
   const changePassword = useCallback(
     async (password: string) => {
@@ -360,15 +389,6 @@ export type InitResult = {
   passwordlessUser: boolean;
 };
 
-/**
- * Restores or creates a session of Element Call's own. Only reached when no
- * client was supplied for it to use.
- */
-async function loadClient(): Promise<InitResult | null> {
-  const { initSPA } = await import("./utils/spa");
-  return initSPA(loadSession, clearSession);
-}
-
 export interface Session {
   user_id: string;
   device_id: string;

src/auth/useInteractiveLogin.ts

@@ -13,7 +13,7 @@ import {
   type MatrixClient,
 } from "matrix-js-sdk";
 
-import { initClient } from "../utils/matrix";
+import { initClient } from "../utils/initClient";
 import { type Session } from "../ClientContext";
 /**
  * This provides the login method to login using user credentials.

src/auth/useInteractiveRegistration.ts

@@ -14,7 +14,7 @@ import {
 } from "matrix-js-sdk";
 import { logger } from "matrix-js-sdk/lib/logger";
 
-import { initClient } from "../utils/matrix";
+import { initClient } from "../utils/initClient";
 import { type Session } from "../ClientContext";
 import { Config } from "../config/Config";
 import { useUrlParams } from "../UrlParams";

src/components/BackgroundEffectGrid.module.css

@@ -90,42 +90,3 @@ Please see LICENSE in the repository root for full details.
   text-align: center;
   overflow-wrap: anywhere;
 }
-
-.removable {
-  position: relative;
-  display: flex;
-  min-inline-size: 0;
-}
-
-.removable > .tile {
-  flex: 1;
-}
-
-/* Clear of the target for choosing the tile. */
-.remove {
-  position: absolute;
-  inset-block-start: 0;
-  inset-inline-end: 0;
-  translate: 20% -20%;
-  display: none;
-  align-items: center;
-  justify-content: center;
-  inline-size: 28px;
-  block-size: 28px;
-  border-radius: 50%;
-  background: var(--cpd-color-bg-canvas-default);
-  color: var(--cpd-color-icon-critical-primary);
-  box-shadow: 0 1.2px 2.4px 0 rgb(0 0 0 / 15%);
-  cursor: pointer;
-}
-
-.remove:hover {
-  background: var(--cpd-color-bg-critical-subtle-hovered);
-  box-shadow: 0 0 0 var(--cpd-border-width-1)
-    var(--cpd-color-border-critical-subtle);
-}
-
-.removable:hover .remove,
-.removable:focus-within .remove {
-  display: flex;
-}

src/components/BackgroundEffectGrid.tsx

@@ -5,16 +5,14 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { type FC, type KeyboardEvent, type ReactElement } from "react";
+import { type FC, type ReactElement } from "react";
 import { useTranslation } from "react-i18next";
 import { VisuallyHidden } from "@radix-ui/react-visually-hidden";
-import { InlineSpinner, MenuItem, Tooltip } from "@vector-im/compound-web";
+import { InlineSpinner, MenuItem } from "@vector-im/compound-web";
 import {
   BlockIcon,
   BlurIcon,
   CheckCircleSolidIcon,
-  CloseIcon,
-  PlusIcon,
 } from "@vector-im/compound-design-tokens/assets/web/icons";
 
 import styles from "./BackgroundEffectGrid.module.css";
@@ -29,8 +27,6 @@ export interface BackgroundEffectGridItem {
   kind: "none" | "blur" | "image";
   /** For kind "image". */
   imageUrl?: string;
-  /** Whether it is the user's to remove. */
-  removable?: boolean;
 }
 
 interface Props {
@@ -42,12 +38,6 @@ interface Props {
   settling?: boolean;
   /** Id of the text saying what the user should know before choosing. */
   describedBy?: string;
-  /** Offers to add a background of one's own. Omit to leave that tile out. */
-  onAdd?: () => void;
-  addLabel?: string;
-  /** Removes a removable one, never the one in force. Omit to offer none. */
-  onRemove?: (id: string) => void;
-  removeLabel?: string;
 }
 
 /**
@@ -61,10 +51,6 @@ export const BackgroundEffectGrid: FC<Props> = ({
   onSelect,
   settling = false,
   describedBy,
-  onAdd,
-  addLabel,
-  onRemove,
-  removeLabel,
 }) => {
   const { t } = useTranslation();
   const choose = (id: string): void => {
@@ -80,30 +66,7 @@ export const BackgroundEffectGrid: FC<Props> = ({
           : t("background_effects.numbered", { n: ++pictures });
     const checked = effect.id === selected;
     const disabled = onSelect === undefined && effect.kind !== "none";
-    const remove =
-      effect.removable && !checked && onRemove !== undefined
-        ? (): void => onRemove(effect.id)
-        : undefined;
-    const removeProps =
-      remove === undefined
-        ? {}
-        : {
-            "aria-keyshortcuts": "Delete",
-            onKeyDown: (e: KeyboardEvent): void => {
-              if (e.key !== "Delete" && e.key !== "Backspace") return;
-              e.preventDefault();
-              remove();
-            },
-          };
-    const content = (
-      <TileContent
-        effect={effect}
-        label={label}
-        checked={checked}
-        settling={checked && settling}
-      />
-    );
-    const tile = (
+    return (
       <MenuItem
         key={effect.id}
         role="menuitemradio"
@@ -125,57 +88,21 @@ export const BackgroundEffectGrid: FC<Props> = ({
                 choose(effect.id);
               }
         }
-        {...removeProps}
       >
-        {content}
+        <TileContent
+          effect={effect}
+          label={label}
+          checked={checked}
+          settling={checked && settling}
+        />
       </MenuItem>
     );
-    if (remove === undefined) return tile;
-    // Beside the item, not in it: inside, the item takes the press first and
-    // the tile is chosen instead.
-    return (
-      <div key={effect.id} className={styles.removable}>
-        {tile}
-        <Tooltip label={removeLabel ?? ""}>
-          {/* Not a control of its own, so the menu keeps one keyboard model:
-              the keyboard reaches the same action through Delete. */}
-          <span aria-hidden className={styles.remove} onClick={remove}>
-            <CloseIcon width={20} height={20} />
-          </span>
-        </Tooltip>
-      </div>
-    );
   });
 
-  // A command rather than a choice, so an item beside the radios.
-  const addContent = (
-    <>
-      <span aria-hidden className={styles.swatch}>
-        <PlusIcon width={24} height={24} />
-      </span>
-      <VisuallyHidden>{addLabel}</VisuallyHidden>
-    </>
-  );
-  const addTile =
-    onAdd === undefined ? null : (
-      <MenuItem
-        label={null}
-        hideChevron
-        className={styles.tile}
-        onSelect={(e) => {
-          e.preventDefault();
-          onAdd();
-        }}
-      >
-        {addContent}
-      </MenuItem>
-    );
-
   return (
     // A group of its own, as the section's can't carry the description.
     <div role="group" aria-describedby={describedBy} className={styles.grid}>
       {tiles}
-      {addTile}
     </div>
   );
 };

src/components/CallFooter.stories.tsx

@@ -127,21 +127,16 @@ export const Default: Story = {
     selectBackgroundEffect: fn(),
     backgroundEffect: "blur",
     backgroundEffects: [
-      { id: "none", kind: "none", removable: false },
-      { id: "blur", kind: "blur", removable: false },
+      { id: "none", kind: "none" },
+      { id: "blur", kind: "blur" },
       ...shippedBackgrounds.map((background) => ({
         id: `image:${background.id}`,
         kind: "image" as const,
         imageUrl: background.imagePath,
-        removable: false,
       })),
     ],
     backgroundEffectNotice: undefined,
     backgroundEffectSettling: false,
-    backgroundImageRefusal: undefined,
-    addBackgroundImage: fn(),
-    removeBackgroundEffect: fn(),
-    cameraTrack: null,
     hangup: fn(),
     buttonSize: "lg",
     showFooter: true,

src/components/CallFooter.tsx

@@ -33,13 +33,6 @@ import { useBehavior } from "../useBehavior";
 import { type LayoutSwitchViewModel } from "../state/LayoutSwitchViewModel";
 import { LayoutSwitch } from "../room/LayoutSwitch";
 import { type BackgroundEffectGridItem } from "./BackgroundEffectGrid";
-import { SelfPreview } from "./SelfPreview";
-import { type UnusableReason } from "../tracks/backgroundImages";
-import { type ShownCamera } from "../tracks/cameraTrack";
-
-export interface BackgroundImageRefusal {
-  reason: UnusableReason | "not-kept";
-}
 
 export interface AudioOutputSwitcher {
   targetOutput: string;
@@ -67,10 +60,6 @@ export interface FooterActions {
   toggleVideo: (() => void) | undefined;
   /** Undefined where background effects can't be chosen. */
   selectBackgroundEffect: ((id: string) => void) | undefined;
-  /** Undefined where no background can be added. */
-  addBackgroundImage: ((file: File) => void) | undefined;
-  /** Removes an added background by its option id; never the one in force. */
-  removeBackgroundEffect: ((id: string) => void) | undefined;
   toggleScreenSharing: (() => void) | undefined;
   /** Also controls if the settings button is visible */
   openSettings: (() => void) | undefined;
@@ -92,10 +81,6 @@ export interface FooterState {
   backgroundEffectNotice: "unavailable" | "slow" | undefined;
   /** Whether the first effect chosen is still being prepared. */
   backgroundEffectSettling: boolean;
-  /** Why the last file offered couldn't be kept, if it couldn't. */
-  backgroundImageRefusal: BackgroundImageRefusal | undefined;
-  /** The camera to preview, with the effect in force; null while it is off. */
-  cameraTrack: ShownCamera | null;
   showFooter: boolean;
 
   /* This is needed for WindowMode = "flat" */
@@ -183,24 +168,6 @@ export const CallFooter: FC<FooterProps> = ({
   const selectBackgroundEffect = useBehavior(vm.selectBackgroundEffect$);
   const backgroundEffectNotice = useBehavior(vm.backgroundEffectNotice$);
   const backgroundEffectSettling = useBehavior(vm.backgroundEffectSettling$);
-  const addBackgroundImage = useBehavior(vm.addBackgroundImage$);
-  const removeBackgroundEffect = useBehavior(vm.removeBackgroundEffect$);
-  const cameraTrack = useBehavior(vm.cameraTrack$);
-  const refusal = useBehavior(vm.backgroundImageRefusal$);
-  const refusalMessage = useMemo(() => {
-    switch (refusal?.reason) {
-      case undefined:
-        return undefined;
-      case "not-an-image":
-        return { text: t("error.background_not_an_image") };
-      case "animated":
-        return { text: t("error.background_animated") };
-      case "undecodable":
-        return { text: t("error.background_undecodable") };
-      case "not-kept":
-        return { text: t("error.background_not_kept") };
-    }
-  }, [refusal, t]);
   const backgroundEffects = useBehavior(vm.backgroundEffects$);
   const buttonSize = useBehavior(vm.buttonSize$);
   const showLogo = useBehavior(vm.showLogo$);
@@ -267,10 +234,6 @@ export const CallFooter: FC<FooterProps> = ({
         selectedBackgroundEffect={backgroundEffect}
         onSelectBackgroundEffect={selectBackgroundEffect}
         backgroundEffectSettling={backgroundEffectSettling}
-        onAddBackgroundImage={addBackgroundImage}
-        onRemoveBackgroundEffect={removeBackgroundEffect}
-        selfPreview={<SelfPreview track={cameraTrack} />}
-        backgroundImageRefusal={refusalMessage}
         backgroundEffectNotice={
           backgroundEffectNotice === "unavailable"
             ? t("background_effects.unavailable")

src/components/CallFooterViewModel.test.ts

@@ -8,12 +8,7 @@ Please see LICENSE in the repository root for full details.
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { BehaviorSubject } from "rxjs";
 
-import {
-  flushPromises,
-  testScope,
-  mockMuteStates,
-  mockMediaDevices,
-} from "../utils/test";
+import { testScope, mockMuteStates, mockMediaDevices } from "../utils/test";
 import { constant } from "../state/Behavior";
 import type { CallViewModel } from "../state/CallViewModel/CallViewModel";
 import type { Layout } from "../state/layout-types";
@@ -24,18 +19,8 @@ import {
   createLobbyFooterViewModel,
 } from "./CallFooterViewModel";
 import { HeaderStyle } from "../UrlParams";
-import { type BackgroundEffectsState } from "../state/BackgroundEffects";
-import { type ShownCamera, SyncedCameraTrack } from "../tracks/cameraTrack";
-import { type MuteStates } from "../state/MuteStates";
 import { backgroundEffect as backgroundEffectSetting } from "../settings/settings";
 import { shippedBackgrounds } from "../tracks/backgroundEffectCatalog";
-import type * as BackgroundImages from "../tracks/backgroundImages";
-import {
-  type AddedBackground,
-  addedBackgrounds,
-  maxAddedBackgrounds,
-  UnusableImage,
-} from "../tracks/backgroundImages";
 
 const platformMock = vi.hoisted(() => vi.fn(() => "desktop"));
 vi.mock("../Platform", () => ({
@@ -52,22 +37,6 @@ vi.mock("@livekit/track-processors", () => ({
   supportsModernBackgroundProcessors: (): boolean => modernRouteMock(),
 }));
 
-const store = vi.hoisted(() => ({
-  add: vi.fn<(file: Blob) => Promise<string>>(),
-  remove: vi.fn<(id: string) => Promise<void>>(),
-}));
-vi.mock("../tracks/backgroundImages", async (original) => {
-  const { BehaviorSubject } = await import("rxjs");
-  return {
-    ...(await original<typeof BackgroundImages>()),
-    addedBackgrounds: {
-      added$: new BehaviorSubject<AddedBackground[] | undefined>([]),
-      add: store.add,
-      remove: store.remove,
-    },
-  };
-});
-
 const outputSelectionMock = vi.hoisted(() => vi.fn(() => true));
 vi.mock("livekit-client", () => ({
   supportsAudioOutputSelection: (): boolean => outputSelectionMock(),
@@ -112,11 +81,6 @@ const pipLayout: Layout = {
   spotlight: {} as SpotlightTileViewModel,
 };
 
-const noPipeline = constant<BackgroundEffectsState>({
-  supported: false,
-  processor: undefined,
-});
-
 const twoMicsAndOneCamMediaDevices = mockMediaDevices({
   audioInput: {
     available$: constant(
@@ -148,7 +112,7 @@ describe("createCallFooterViewModel", () => {
         buildMinimalCallViewModel(gridLayout),
         mockMuteStates(),
         twoMicsAndOneCamMediaDevices,
-        noPipeline,
+        constant(false),
         /* reactionIdentifier */ undefined,
         { showControls: true, header: HeaderStyle.Standard },
       );
@@ -191,7 +155,7 @@ describe("createCallFooterViewModel", () => {
             select: vi.fn(),
           },
         }),
-        noPipeline,
+        constant(false),
         /* reactionIdentifier */ undefined,
         { showControls: true, header: HeaderStyle.Standard },
       );
@@ -210,7 +174,7 @@ describe("createCallFooterViewModel", () => {
         buildMinimalCallViewModel(layout),
         mockMuteStates(),
         twoMicsAndOneCamMediaDevices,
-        noPipeline,
+        constant(false),
         /* reactionIdentifier */ undefined,
         { showControls: true, header: HeaderStyle.Standard },
       );
@@ -233,7 +197,7 @@ describe("createCallFooterViewModel", () => {
         buildMinimalCallViewModel(gridLayout),
         mockMuteStates(),
         twoMicsAndOneCamMediaDevices,
-        noPipeline,
+        constant(false),
         /* reactionIdentifier */ undefined,
         { showControls: true, header: HeaderStyle.Standard },
       );
@@ -279,7 +243,7 @@ describe("createCallFooterViewModel", () => {
         testScope(),
         mockMuteStates(),
         twoMicsAndOneCamMediaDevices,
-        noPipeline,
+        constant(false),
         /* openSettings */ undefined,
         /* hangup */ undefined,
         /* showLogo */ false,
@@ -299,7 +263,6 @@ describe("createCallFooterViewModel", () => {
     it("offers nothing where the browser itself cannot run them", () => {
       sdkSupportMock.mockReturnValue(false);
       expect(lobbyOn("desktop").selectBackgroundEffect$.value).toBeUndefined();
-      expect(lobbyOn("desktop").addBackgroundImage$.value).toBeUndefined();
     });
 
     it("puts no effect in force where the browser cannot run them", () => {
@@ -330,29 +293,17 @@ describe("createCallFooterViewModel", () => {
       expect(lobbyOn("desktop").backgroundEffectNotice$.value).toBeUndefined();
     });
 
-    it("offers every effect in order, the added ones removable", () => {
+    it("offers every effect in order", () => {
       sdkSupportMock.mockReturnValue(true);
-      const added$ = addedBackgrounds.added$ as BehaviorSubject<
-        AddedBackground[] | undefined
-      >;
-      added$.next([{ id: "mine", url: "blob:mine" }]);
       expect(lobbyOn("desktop").backgroundEffects$.value).toEqual([
-        { id: "none", kind: "none", removable: false },
-        { id: "blur", kind: "blur", removable: false },
+        { id: "none", kind: "none" },
+        { id: "blur", kind: "blur" },
         ...shippedBackgrounds.map((background) => ({
           id: `image:${background.id}`,
           kind: "image",
           imageUrl: background.imagePath,
-          removable: false,
         })),
-        {
-          id: "added:mine",
-          kind: "image",
-          imageUrl: "blob:mine",
-          removable: true,
-        },
       ]);
-      added$.next([]);
     });
 
     it("says they are unavailable where they cannot be chosen", () => {
@@ -364,108 +315,21 @@ describe("createCallFooterViewModel", () => {
 
     it("passes on the wait for the first effect", () => {
       platformMock.mockReturnValue("desktop");
-      const pipeline$ = new BehaviorSubject<BackgroundEffectsState>({
-        supported: true,
-        processor: undefined,
-        settling: true,
-      });
+      const settling$ = new BehaviorSubject(true);
       const vm = createLobbyFooterViewModel(
         testScope(),
         mockMuteStates(),
         twoMicsAndOneCamMediaDevices,
-        pipeline$,
+        settling$,
         /* openSettings */ undefined,
         /* hangup */ undefined,
         /* showLogo */ false,
       );
       expect(vm.backgroundEffectSettling$.value).toBe(true);
-      pipeline$.next({ ...pipeline$.value, settling: false });
+      settling$.next(false);
       expect(vm.backgroundEffectSettling$.value).toBe(false);
     });
 
-    it("adding is unavailable at the limit", () => {
-      sdkSupportMock.mockReturnValue(true);
-      const added$ = addedBackgrounds.added$ as BehaviorSubject<
-        AddedBackground[] | undefined
-      >;
-      const vm = lobbyOn("desktop");
-      expect(vm.addBackgroundImage$.value).toBeDefined();
-      added$.next(
-        Array.from({ length: maxAddedBackgrounds }, (_, i) => ({
-          id: `${i}`,
-          url: `blob:${i}`,
-        })),
-      );
-      expect(vm.addBackgroundImage$.value).toBeUndefined();
-      added$.next(added$.value!.slice(1));
-      expect(vm.addBackgroundImage$.value).toBeDefined();
-      added$.next([]);
-    });
-
-    it("says why each refused file was refused", async () => {
-      sdkSupportMock.mockReturnValue(true);
-      const vm = lobbyOn("desktop");
-      store.add.mockRejectedValue(new UnusableImage("animated"));
-      vm.addBackgroundImage$.value!(new File(["x"], "a.gif"));
-      await flushPromises();
-      const first = vm.backgroundImageRefusal$.value;
-      expect(first).toEqual({ reason: "animated" });
-
-      // The same again is a refusal of its own, so it is shown again.
-      vm.addBackgroundImage$.value!(new File(["x"], "a.gif"));
-      await flushPromises();
-      expect(vm.backgroundImageRefusal$.value).toEqual({ reason: "animated" });
-      expect(vm.backgroundImageRefusal$.value).not.toBe(first);
-
-      store.add.mockRejectedValue(new Error("quota"));
-      vm.addBackgroundImage$.value!(new File(["x"], "b.png"));
-      await flushPromises();
-      expect(vm.backgroundImageRefusal$.value).toEqual({ reason: "not-kept" });
-
-      store.add.mockResolvedValue("kept");
-      vm.addBackgroundImage$.value!(new File(["x"], "c.png"));
-      await flushPromises();
-      expect(vm.backgroundImageRefusal$.value).toBeUndefined();
-    });
-
-    it("never removes the background in force", () => {
-      sdkSupportMock.mockReturnValue(true);
-      store.remove.mockResolvedValue();
-      const vm = lobbyOn("desktop");
-      backgroundEffectSetting.setValue("added:worn");
-      vm.removeBackgroundEffect$.value!("added:worn");
-      expect(store.remove).not.toHaveBeenCalled();
-      vm.removeBackgroundEffect$.value!("added:spare");
-      expect(store.remove).toHaveBeenCalledWith("spare");
-    });
-
-    it("previews the camera only while it is on", () => {
-      const camera = new SyncedCameraTrack();
-      const track = {} as ShownCamera;
-      camera.report(track);
-      const videoEnabled$ = new BehaviorSubject(true);
-      const muteStates = mockMuteStates();
-      const vm = createLobbyFooterViewModel(
-        testScope(),
-        {
-          ...muteStates,
-          video: { ...muteStates.video, enabled$: videoEnabled$ },
-        } as unknown as MuteStates,
-        twoMicsAndOneCamMediaDevices,
-        constant({
-          supported: true,
-          processor: undefined,
-          cameraTrack: camera,
-        }),
-        /* openSettings */ undefined,
-        /* hangup */ undefined,
-        /* showLogo */ false,
-      );
-      expect(vm.cameraTrack$.value).toBe(track);
-      videoEnabled$.next(false);
-      expect(vm.cameraTrack$.value).toBeNull();
-    });
-
     it("availability is the same before and during a call", () => {
       for (const supported of [true, false]) {
         sdkSupportMock.mockReturnValue(supported);
@@ -475,7 +339,7 @@ describe("createCallFooterViewModel", () => {
           buildMinimalCallViewModel(gridLayout),
           mockMuteStates(),
           twoMicsAndOneCamMediaDevices,
-          noPipeline,
+          constant(false),
           /* reactionIdentifier */ undefined,
           { showControls: true, header: HeaderStyle.Standard },
         );

src/components/CallFooterViewModel.tsx

@@ -6,12 +6,10 @@ Please see LICENSE in the repository root for full details.
 */
 
 import {
-  BehaviorSubject,
   combineLatest,
   distinctUntilChanged,
   map,
   type Observable,
-  of,
   switchMap,
 } from "rxjs";
 import { supportsAudioOutputSelection } from "livekit-client";
@@ -19,20 +17,12 @@ import {
   supportsBackgroundProcessors,
   supportsModernBackgroundProcessors,
 } from "@livekit/track-processors";
-import { logger } from "matrix-js-sdk/lib/logger";
 
 import {
   parseEffect,
   serializeEffect,
   shippedBackgrounds,
 } from "../tracks/backgroundEffectCatalog";
-import { type BackgroundEffectsState } from "../state/BackgroundEffects";
-import {
-  type AddedBackground,
-  addedBackgrounds,
-  maxAddedBackgrounds,
-  UnusableImage,
-} from "../tracks/backgroundImages";
 
 import { type CallViewModel } from "../state/CallViewModel/CallViewModel";
 import { type MenuOptions } from "./MediaMuteAndSwitchButton";
@@ -47,7 +37,7 @@ import { type MuteStates } from "../state/MuteStates";
 import { createStaticViewModel, type ViewModel } from "../state/ViewModel";
 import { HeaderStyle } from "../UrlParams";
 import { platform } from "../Platform";
-import { type BackgroundImageRefusal, type FooterSnapshot } from "./CallFooter";
+import { type FooterSnapshot } from "./CallFooter";
 import { type BackgroundEffectGridItem } from "./BackgroundEffectGrid";
 
 /**
@@ -89,8 +79,7 @@ function buildDeviceBehaviors(
   mediaDevices: MediaDevices,
   /** return empty arrays for  audioOptions and videoOptions*/
   disableSwitcher$: Behavior<boolean>,
-  backgroundEffectsState$: Observable<BackgroundEffectsState>,
-  videoEnabled$: Behavior<boolean>,
+  backgroundEffectSettling$: Observable<boolean>,
 ): Pick<
   ViewModel<FooterSnapshot>,
   | "audioOptions$"
@@ -107,10 +96,6 @@ function buildDeviceBehaviors(
   | "backgroundEffects$"
   | "backgroundEffectNotice$"
   | "backgroundEffectSettling$"
-  | "addBackgroundImage$"
-  | "backgroundImageRefusal$"
-  | "removeBackgroundEffect$"
-  | "cameraTrack$"
 > {
   const options$ = (
     available$: Behavior<Map<string, MenuOptions["label"]>>,
@@ -132,10 +117,6 @@ function buildDeviceBehaviors(
   const offered$ = disableSwitcher$.pipe(
     map((switcherDisabled) => !switcherDisabled && supported),
   );
-  // A new object for each refusal, so the same one twice is shown twice.
-  const refusal$ = new BehaviorSubject<BackgroundImageRefusal | undefined>(
-    undefined,
-  );
   return {
     audioOptions$: scope.behavior(options$(mediaDevices.audioInput.available$)),
     selectedAudio$: scope.behavior(
@@ -177,11 +158,7 @@ function buildDeviceBehaviors(
         ),
       ),
     ),
-    backgroundEffects$: scope.behavior(
-      addedBackgrounds.added$.pipe(
-        map((added) => backgroundEffectChoices(added ?? [])),
-      ),
-    ),
+    backgroundEffects$: constant(backgroundEffectChoices()),
     backgroundEffectNotice$: scope.behavior(
       offered$.pipe(
         map((offered) =>
@@ -190,59 +167,9 @@ function buildDeviceBehaviors(
       ),
     ),
     backgroundEffectSettling$: scope.behavior(
-      backgroundEffectsState$.pipe(
-        map(({ settling }) => settling ?? false),
-        distinctUntilChanged(),
-      ),
+      backgroundEffectSettling$.pipe(distinctUntilChanged()),
       false,
     ),
-    // Kept and offered, not put on: that waits for the user to choose it.
-    addBackgroundImage$: scope.behavior(
-      combineLatest([offered$, addedBackgrounds.added$]).pipe(
-        map(([offered, added]) =>
-          offered && (added?.length ?? 0) < maxAddedBackgrounds
-            ? (file: File): void => {
-                refusal$.next(undefined);
-                addedBackgrounds.add(file).catch((e) => {
-                  logger.warn("Could not keep that background", e);
-                  refusal$.next({
-                    reason: e instanceof UnusableImage ? e.reason : "not-kept",
-                  });
-                });
-              }
-            : undefined,
-        ),
-      ),
-    ),
-    backgroundImageRefusal$: refusal$,
-    cameraTrack$: scope.behavior(
-      combineLatest([
-        backgroundEffectsState$.pipe(
-          switchMap(({ cameraTrack }) => cameraTrack?.track$ ?? of(null)),
-        ),
-        videoEnabled$,
-      ]).pipe(map(([track, videoEnabled]) => (videoEnabled ? track : null))),
-      null,
-    ),
-    // Never the one in force: taking it away would leave nothing chosen.
-    removeBackgroundEffect$: scope.behavior(
-      offered$.pipe(
-        map((offered) =>
-          offered
-            ? (optionId: string): void => {
-                const effect = parseEffect(optionId);
-                if (effect.kind !== "added") return;
-                if (backgroundEffectSetting.getValue() === optionId) return;
-                addedBackgrounds
-                  .remove(effect.id)
-                  .catch((e) =>
-                    logger.warn("Could not remove that background", e),
-                  );
-              }
-            : undefined,
-        ),
-      ),
-    ),
   };
 }
 
@@ -253,8 +180,8 @@ function buildDeviceBehaviors(
  * @param callModel - The root CallViewModel; provides layout, grid mode, reactions, etc.
  * @param muteStates - Audio and video mute state + toggles.
  * @param mediaDevices - Available and selected input devices.
- * @param backgroundEffectsState$ - The background pipeline's state: whether effects
- *   run here, the wait for the first, and the camera it is synced to.
+ * @param backgroundEffectSettling$ - Whether the first effect chosen is still
+ *   being prepared.
  * @param reactionIdentifier - The local user's reaction identifier string, or
  *   undefined when reactions are not supported (hides the reaction button).
  * @param options - `showControls`: whether the call controls should be shown.
@@ -265,7 +192,7 @@ export function createCallFooterViewModel(
   callModel: CallViewModel,
   muteStates: MuteStates,
   mediaDevices: MediaDevices,
-  backgroundEffectsState$: Observable<BackgroundEffectsState>,
+  backgroundEffectSettling$: Observable<boolean>,
   reactionIdentifier: string | undefined,
   options: { showControls: boolean; header: HeaderStyle },
 ): ViewModel<FooterSnapshot> {
@@ -284,8 +211,7 @@ export function createCallFooterViewModel(
       scope,
       mediaDevices,
       disableDeviceSwitcher$,
-      backgroundEffectsState$,
-      muteStates.video.enabled$,
+      backgroundEffectSettling$,
     ),
     // candidat to move into the FooterViewModel
     showFooter$: callModel.showFooter$,
@@ -348,8 +274,8 @@ export function createCallFooterViewModel(
  * @param scope - ObservableScope that bounds the lifetime of derived behaviors.
  * @param muteStates - Audio and video mute state + toggles.
  * @param mediaDevices - Available and selected input devices.
- * @param backgroundEffectsState$ - The background pipeline's state: whether effects
- *   run here, the wait for the first, and the camera it is synced to.
+ * @param backgroundEffectSettling$ - Whether the first effect chosen is still
+ *   being prepared.
  * @param openSettings - Callback to open the settings modal, or undefined.
  * @param hangup - Callback to leave/cancel, or undefined (hides the button).
  * @param showLogo - Whether to show the Element Call logo.
@@ -358,7 +284,7 @@ export function createLobbyFooterViewModel(
   scope: ObservableScope,
   muteStates: MuteStates,
   mediaDevices: MediaDevices,
-  backgroundEffectsState$: Observable<BackgroundEffectsState>,
+  backgroundEffectSettling$: Observable<boolean>,
   openSettings: (() => void) | undefined,
   hangup: (() => void) | undefined,
   showLogo: boolean,
@@ -406,29 +332,19 @@ export function createLobbyFooterViewModel(
       scope,
       mediaDevices,
       constant(false),
-      backgroundEffectsState$,
-      muteStates.video.enabled$,
+      backgroundEffectSettling$,
     ),
   };
 }
 
-function backgroundEffectChoices(
-  added: AddedBackground[],
-): BackgroundEffectGridItem[] {
+function backgroundEffectChoices(): BackgroundEffectGridItem[] {
   return [
-    { id: serializeEffect({ kind: "none" }), kind: "none", removable: false },
-    { id: serializeEffect({ kind: "blur" }), kind: "blur", removable: false },
+    { id: serializeEffect({ kind: "none" }), kind: "none" },
+    { id: serializeEffect({ kind: "blur" }), kind: "blur" },
     ...shippedBackgrounds.map((background) => ({
       id: serializeEffect({ kind: "shipped", id: background.id }),
       kind: "image" as const,
       imageUrl: background.imagePath,
-      removable: false,
-    })),
-    ...added.map((background) => ({
-      id: serializeEffect({ kind: "added", id: background.id }),
-      kind: "image" as const,
-      imageUrl: background.url,
-      removable: true,
     })),
   ];
 }

src/components/MediaMuteAndSwitchButton.module.css

@@ -93,39 +93,3 @@ Please see LICENSE in the repository root for full details.
   flex-shrink: 0;
   color: var(--cpd-color-icon-secondary);
 }
-
-.refusal {
-  margin: var(--cpd-space-2x) var(--cpd-space-4x) 0;
-}
-
-.selfPreview {
-  position: relative;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  flex-shrink: 0;
-  aspect-ratio: 16 / 9;
-  margin-block-end: var(--cpd-space-2x);
-  overflow: clip;
-  border-start-start-radius: var(--cpd-space-3x);
-  border-start-end-radius: var(--cpd-space-3x);
-  background: var(--cpd-color-bg-subtle-secondary);
-  color: var(--cpd-color-icon-secondary);
-}
-
-.selfPreview > video {
-  position: absolute;
-  inset: 0;
-  inline-size: 100%;
-  block-size: 100%;
-  object-fit: cover;
-  /* Rounded itself too: a video can be drawn on a layer of its own, which the
-     frame's rounded clip doesn't always reach. */
-  border-radius: inherit;
-}
-
-/* Up to the menu's frame, over the padding at its top. */
-.selfPreviewPinned,
-.deviceListLeadsWithPreview {
-  margin-block-start: calc(-1 * var(--cpd-space-5x));
-}

src/components/MediaMuteAndSwitchButton.stories.tsx

@@ -12,7 +12,6 @@ import type { Meta, StoryObj } from "@storybook/react-vite";
 import { MediaMuteAndSwitchButton } from "./MediaMuteAndSwitchButton";
 import styles from "./MediaMuteAndSwitchButton.module.css";
 import { type BackgroundEffectGridItem } from "./BackgroundEffectGrid";
-import { SelfPreview } from "./SelfPreview";
 import { shippedBackgrounds } from "../tracks/backgroundEffectCatalog";
 import meterStyles from "./MicrophoneLevelMeter.module.css";
 import { MediaDevicesContext } from "../MediaDevicesContext";
@@ -61,50 +60,6 @@ const WithAMicrophone: FC<{ children: ReactNode }> = ({ children }) => {
   return <>{children}</>;
 };
 
-/** A camera for the preview: a figure against a room, drawn to a stream. */
-const FakeCamera: FC = () => {
-  const [stream, setStream] = useState<MediaStream>();
-  useEffect(() => {
-    const canvas = document.createElement("canvas");
-    canvas.width = 640;
-    canvas.height = 360;
-    const context = canvas.getContext("2d")!;
-    const draw = (): void => {
-      context.fillStyle = "#6b7f8e";
-      context.fillRect(0, 0, 640, 360);
-      context.fillStyle = "#c9a27e";
-      context.beginPath();
-      context.arc(320, 150, 62, 0, 2 * Math.PI);
-      context.fill();
-      context.fillStyle = "#34495e";
-      context.beginPath();
-      context.ellipse(320, 380, 150, 140, 0, Math.PI, 2 * Math.PI);
-      context.fill();
-    };
-    draw();
-    // Redrawn, so the stream keeps delivering frames.
-    const timer = setInterval(draw, 200);
-    const captured = canvas.captureStream(10);
-    setStream(captured);
-    return (): void => {
-      clearInterval(timer);
-      captured.getTracks().forEach((track) => track.stop());
-    };
-  }, []);
-  return (
-    <video
-      data-testid="preview-camera"
-      autoPlay
-      muted
-      playsInline
-      ref={(video): void => {
-        if (video && stream && video.srcObject !== stream)
-          video.srcObject = stream;
-      }}
-    />
-  );
-};
-
 /** Supplies a call-sized root. Without one the list is bounded by the whole Storybook frame. */
 const WithACallArea: FC<{ children: ReactNode; blockSize?: number }> = ({
   children,
@@ -216,8 +171,8 @@ export const VideoMute: Story = {
       { label: { type: "name", name: "Camera 1" }, id: "1" },
       { label: { type: "name", name: "Camera 2" }, id: "2" },
     ],
+
     selectedOption: "1",
-    selfPreview: <SelfPreview track={null} />,
   },
 };
 
@@ -243,9 +198,6 @@ export const VideoUnmute: Story = {
     backgroundEffects: effects,
     selectedBackgroundEffect: "none",
     onSelectBackgroundEffect: fn(),
-    onAddBackgroundImage: fn(),
-    // As the footer always gives the camera menu one.
-    selfPreview: <FakeCamera />,
   },
 };
 
@@ -289,11 +241,6 @@ export const BackgroundEffects: Story = {
         true,
       );
 
-    const add = within(section).getByRole("menuitem", { name: "Add image" });
-    await expect(
-      tiles[3].compareDocumentPosition(add) & Node.DOCUMENT_POSITION_FOLLOWING,
-    ).toBeTruthy();
-
     await userEvent.click(menu.getByRole("menuitemradio", { name: "Blur" }));
     await expect(args.onSelectBackgroundEffect).toHaveBeenCalledWith("blur");
     await expect(menu.getByRole("menu")).toBeVisible();
@@ -391,270 +338,6 @@ export const BackgroundEffectsSettling: Story = {
       checked: false,
     }))
       await expect(other).toHaveAttribute("aria-busy", "false");
-    await expect(menu.queryByTestId("preview-camera")).toBeNull();
-    const frames = document.body.querySelectorAll(`.${styles.selfPreview} svg`);
-    await expect(frames).toHaveLength(1);
-  },
-};
-
-/** A file that can't be used: said where it was chosen, and nothing changes. */
-export const BackgroundImageRefused: Story = {
-  args: {
-    ...VideoUnmute.args,
-    selectedBackgroundEffect: "blur",
-    backgroundEffectNotice:
-      "Background effects run slowly on this platform, which may cause your video to stutter.",
-    backgroundImageRefusal: { text: "That file is not a supported image" },
-  },
-  decorators: [
-    (Story): JSX.Element => (
-      <WithACallArea blockSize={300}>
-        <Story />
-      </WithACallArea>
-    ),
-  ],
-  play: async ({ canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const menu = within(document.body);
-    const message = await menu.findByText("That file is not a supported image");
-    const list = document.body.querySelector<HTMLElement>(
-      `.${styles.deviceList}`,
-    )!;
-    await expect(list.scrollHeight).toBeGreaterThan(list.clientHeight);
-    const scrollport = list.getBoundingClientRect();
-    const shown = message.getBoundingClientRect();
-    await expect(shown.bottom).toBeLessThanOrEqual(scrollport.bottom + 1);
-    await expect(shown.top).toBeGreaterThanOrEqual(scrollport.top - 1);
-    await expect(menu.queryByText(/run slowly/)).toBeNull();
-    await expect(
-      menu.getByRole("menuitemradio", { name: "Blur" }),
-    ).toHaveAttribute("aria-checked", "true");
-  },
-};
-
-/** A flat picture, for backgrounds of one's own. */
-function swatch(colour: string): string {
-  return `data:image/svg+xml,${encodeURIComponent(
-    `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="9"><rect width="16" height="9" fill="${colour}"/></svg>`,
-  )}`;
-}
-
-/** One's own backgrounds are removable, never the one in force. */
-export const AddedBackgroundsCanBeRemoved: Story = {
-  args: {
-    ...VideoUnmute.args,
-    backgroundEffects: [
-      ...effects,
-      {
-        id: "added:one",
-        kind: "image",
-        imageUrl: swatch("#c2410c"),
-        removable: true,
-      },
-      {
-        id: "added:two",
-        kind: "image",
-        imageUrl: swatch("#1d4ed8"),
-        removable: true,
-      },
-    ],
-    selectedBackgroundEffect: "added:one",
-    onRemoveBackgroundEffect: fn(),
-  },
-  play: async ({ args, canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const body = within(document.body);
-
-    const inForce = await body.findByRole("menuitemradio", {
-      name: "Background 3",
-    });
-    await expect(inForce).not.toHaveAttribute("aria-keyshortcuts");
-
-    const other = body.getByRole("menuitemradio", { name: "Background 4" });
-    await expect(other).toHaveAttribute("aria-keyshortcuts", "Delete");
-    other.focus();
-    await userEvent.keyboard("{Delete}");
-    await expect(args.onRemoveBackgroundEffect).toHaveBeenCalledWith(
-      "added:two",
-    );
-
-    const wrapper = other.parentElement!;
-    await userEvent.hover(wrapper);
-    const cross = wrapper.querySelector<HTMLElement>(
-      "[aria-hidden]:last-child",
-    )!;
-    const probe = document.createElement("span");
-    probe.style.color = "var(--cpd-color-icon-critical-primary)";
-    cross.append(probe);
-    const critical = getComputedStyle(probe).color;
-    probe.remove();
-    await expect(getComputedStyle(cross).color).toBe(critical);
-    const tile = other.getBoundingClientRect();
-    const box = cross.getBoundingClientRect();
-    await expect(box.right).toBeGreaterThan(tile.right);
-    await expect(box.top).toBeLessThan(tile.top);
-
-    await userEvent.hover(cross);
-    await waitFor(async () =>
-      expect(
-        [...document.body.querySelectorAll("div")].some(
-          (d) => d.textContent === "Remove" && d.offsetParent !== null,
-        ),
-      ).toBe(true),
-    );
-  },
-};
-
-/** Removing by pointer while the selection really changes. */
-export const RemovingWithLiveSelection: Story = {
-  args: AddedBackgroundsCanBeRemoved.args,
-  render: function WithLiveSelection(args): JSX.Element {
-    const [selected, setSelected] = useState("none");
-    const [offered, setOffered] = useState(args.backgroundEffects ?? []);
-    return (
-      <MediaMuteAndSwitchButton
-        {...args}
-        backgroundEffects={offered}
-        selectedBackgroundEffect={selected}
-        onSelectBackgroundEffect={setSelected}
-        onRemoveBackgroundEffect={(id): void =>
-          setOffered((current) => current.filter((o) => o.id !== id))
-        }
-      />
-    );
-  },
-  play: async ({ canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const body = within(document.body);
-
-    const tile = await body.findByRole("menuitemradio", {
-      name: "Background 4",
-    });
-    await userEvent.hover(tile);
-    const cross = tile.parentElement!.querySelector<HTMLElement>(
-      "[aria-hidden]:last-child",
-    )!;
-    await expect(cross).toBeVisible();
-    await userEvent.click(cross);
-
-    await waitFor(async () =>
-      expect(
-        body.queryByRole("menuitemradio", { name: "Background 4" }),
-      ).toBeNull(),
-    );
-    await expect(
-      body.getByRole("menuitemradio", { name: "None" }),
-    ).toHaveAttribute("aria-checked", "true");
-  },
-};
-
-/** Where the call leaves room, the camera holds the top while the options scroll. */
-export const BackgroundEffectsWithPreview: Story = {
-  args: {
-    ...VideoUnmute.args,
-    // Enough that the list fills its share, so the preview's cost counts.
-    options: Array.from({ length: 8 }, (_, i) => ({
-      label: { type: "name" as const, name: `Camera ${i + 1}` },
-      id: `${i + 1}`,
-    })),
-  },
-  decorators: [
-    (Story): JSX.Element => (
-      <WithACallArea blockSize={640}>
-        <Story />
-      </WithACallArea>
-    ),
-  ],
-  play: async ({ canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const picture = await within(document.body).findByTestId("preview-camera");
-    const preview = picture.parentElement!;
-    const list = document.body.querySelector<HTMLElement>(
-      `.${styles.deviceList}`,
-    )!;
-    const frame = document.body
-      .querySelector("[role='menu']")!
-      .getBoundingClientRect();
-
-    const box = preview.getBoundingClientRect();
-    await expect(list.contains(preview)).toBe(false);
-    await expect(box.top - frame.top).toBeLessThanOrEqual(2);
-    await expect(frame.width - box.width).toBeLessThanOrEqual(2);
-    await expect(box.width / box.height).toBeCloseTo(16 / 9, 1);
-    await expect(box.bottom).toBeLessThanOrEqual(
-      list.getBoundingClientRect().top,
-    );
-
-    const listShare = Math.round(640 * 0.6);
-    // The list runs on through the menu's padding at its foot, which isn't
-    // part of its share.
-    const listEnd =
-      list.getBoundingClientRect().bottom -
-      Number.parseFloat(getComputedStyle(list).paddingBlockEnd);
-    await expect(listEnd - box.top).toBeLessThanOrEqual(listShare + 1);
-
-    await expect(list.scrollHeight).toBeGreaterThan(list.clientHeight);
-    list.scrollTop = list.scrollHeight;
-    await expect(preview.getBoundingClientRect().top).toBe(box.top);
-  },
-};
-
-/** With the camera off the preview says so, and effects can still be chosen. */
-export const BackgroundEffectsPreviewWithTheCameraOff: Story = {
-  args: {
-    ...VideoUnmute.args,
-    enabled: false,
-    selfPreview: <SelfPreview track={null} />,
-  },
-  play: async ({ args, canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const menu = within(document.body);
-    await menu.findByRole("group", { name: "Background effects" });
-    const preview = document.body.querySelector(`.${styles.selfPreview}`)!;
-    await expect(preview.querySelector("video")).toBeNull();
-    await expect(preview.querySelector("svg")).not.toBeNull();
-
-    await userEvent.click(menu.getByRole("menuitemradio", { name: "Blur" }));
-    await expect(args.onSelectBackgroundEffect).toHaveBeenCalledWith("blur");
-  },
-};
-
-/** In a call too short to hold it, the camera leads the options and scrolls away. */
-export const BackgroundEffectsPreviewScrollsWithTheList: Story = {
-  args: VideoUnmute.args,
-  decorators: [
-    (Story): JSX.Element => (
-      <WithACallArea blockSize={300}>
-        <Story />
-      </WithACallArea>
-    ),
-  ],
-  play: async ({ canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const picture = await within(document.body).findByTestId("preview-camera");
-    const preview = picture.parentElement!;
-    const list = document.body.querySelector<HTMLElement>(
-      `.${styles.deviceList}`,
-    )!;
-    await expect(list.contains(preview)).toBe(true);
-    const cameras = within(document.body).getByRole("group", {
-      name: "Camera",
-    });
-    await expect(
-      preview.compareDocumentPosition(cameras) &
-        Node.DOCUMENT_POSITION_FOLLOWING,
-    ).toBeTruthy();
-
-    list.scrollTop = list.scrollHeight;
-    await expect(preview.getBoundingClientRect().bottom).toBeLessThan(
-      list.getBoundingClientRect().top,
-    );
   },
 };
 

src/components/MediaMuteAndSwitchButton.test.tsx

@@ -5,7 +5,7 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { afterEach, describe, expect, onTestFinished, test, vi } from "vitest";
+import { afterEach, describe, expect, test, vi } from "vitest";
 import { axe } from "vitest-axe";
 import {
   act,
@@ -367,120 +367,6 @@ describe("MediaMuteAndSwitchButton", () => {
     expect(onSelectBackgroundEffect).not.toHaveBeenCalled();
   });
 
-  test("added images are chosen like shipped ones", async () => {
-    const user = userEvent.setup();
-    const onSelectBackgroundEffect = vi.fn();
-    const { getByRole } = renderComponent(
-      <MediaMuteAndSwitchButton
-        iconsAndLabels="video"
-        enabled={true}
-        options={[{ label: { type: "name", name: "Camera 1" }, id: "cam1" }]}
-        selectedOption="cam1"
-        backgroundEffects={[
-          ...effects,
-          {
-            id: "added:mine",
-            kind: "image",
-            imageUrl: "",
-          },
-        ]}
-        selectedBackgroundEffect="none"
-        onSelectBackgroundEffect={onSelectBackgroundEffect}
-      />,
-    );
-
-    await user.click(getByRole("button", { name: "Camera" }));
-    const section = screen.getByRole("group", { name: "Background effects" });
-    await user.click(
-      within(section).getByRole("menuitemradio", { name: "Background 3" }),
-    );
-    expect(onSelectBackgroundEffect).toHaveBeenCalledWith("added:mine");
-  });
-
-  test("adds the file chosen from the add tile, and stays open", async () => {
-    const user = userEvent.setup();
-    const onAddBackgroundImage = vi.fn();
-    const pick = vi
-      .spyOn(HTMLInputElement.prototype, "click")
-      .mockImplementation(() => {});
-    try {
-      const { getByRole, container } = renderComponent(
-        <MediaMuteAndSwitchButton
-          iconsAndLabels="video"
-          enabled={true}
-          options={[{ label: { type: "name", name: "Camera 1" }, id: "cam1" }]}
-          selectedOption="cam1"
-          backgroundEffects={effects}
-          selectedBackgroundEffect="none"
-          onSelectBackgroundEffect={vi.fn()}
-          onAddBackgroundImage={onAddBackgroundImage}
-        />,
-      );
-
-      await user.click(getByRole("button", { name: "Camera" }));
-      await user.click(screen.getByRole("menuitem", { name: "Add image" }));
-      expect(pick).toHaveBeenCalled();
-      // The picker takes the focus, which would otherwise close the menu.
-      await user.keyboard("{Escape}");
-      expect(screen.getByRole("menu")).toBeInTheDocument();
-
-      const file = new File(["x"], "mine.png", { type: "image/png" });
-      // What the picker hands back; the open menu blocks pointer events.
-      fireEvent.change(
-        container.querySelector<HTMLInputElement>("input[type=file]")!,
-        { target: { files: [file] } },
-      );
-      expect(onAddBackgroundImage).toHaveBeenCalledWith(file);
-      screen.getByRole("menuitemradio", { name: "None", checked: true });
-    } finally {
-      pick.mockRestore();
-    }
-  });
-
-  test("a refusal can be dismissed and does not outlive the menu", async () => {
-    const user = userEvent.setup();
-    // jsdom lays nothing out, so has nothing to scroll.
-    const scroll = Element.prototype.scrollIntoView;
-    Element.prototype.scrollIntoView = vi.fn();
-    onTestFinished(() => {
-      Element.prototype.scrollIntoView = scroll;
-    });
-    const menu = (refusal?: { text: string }): JSX.Element =>
-      withProviders(
-        <MediaMuteAndSwitchButton
-          iconsAndLabels="video"
-          enabled={true}
-          options={[{ label: { type: "name", name: "Camera 1" }, id: "cam1" }]}
-          selectedOption="cam1"
-          backgroundEffects={effects}
-          selectedBackgroundEffect="blur"
-          onSelectBackgroundEffect={vi.fn()}
-          onAddBackgroundImage={vi.fn()}
-          backgroundImageRefusal={refusal}
-        />,
-      );
-    const { rerender, getByRole } = render(menu());
-    await user.click(getByRole("button", { name: "Camera" }));
-
-    rerender(menu({ text: "That file is not a supported image" }));
-    expect(
-      screen.getByText("That file is not a supported image"),
-    ).toBeVisible();
-    screen.getByRole("menuitemradio", { name: "Blur", checked: true });
-    await user.click(screen.getByRole("button", { name: "Close" }));
-    expect(screen.queryByText("That file is not a supported image")).toBeNull();
-
-    // The next refusal is shown, even if it says the same.
-    rerender(menu({ text: "That file is not a supported image" }));
-    expect(
-      screen.getByText("That file is not a supported image"),
-    ).toBeVisible();
-
-    await user.keyboard("{Escape}");
-    await user.click(getByRole("button", { name: "Camera" }));
-    expect(screen.queryByText("That file is not a supported image")).toBeNull();
-  });
-
   test("offers the background effects in a phone's drawer", async () => {
     const userAgent = vi
       .spyOn(navigator, "userAgent", "get")

src/components/MediaMuteAndSwitchButton.tsx

@@ -8,18 +8,14 @@ Please see LICENSE in the repository root for full details.
 import {
   useCallback,
   useId,
-  useRef,
   useState,
   type CSSProperties,
   type FC,
   useEffect,
   type ReactElement,
-  type ReactNode,
 } from "react";
 import {
-  Alert,
   Button,
-  InlineSpinner,
   Menu,
   MenuItem,
   MenuScrollArea,
@@ -83,14 +79,6 @@ export interface MediaMuteAndSwitchButtonProps {
   backgroundEffectNotice?: string;
   /** Whether the first effect chosen is still being prepared. */
   backgroundEffectSettling?: boolean;
-  /** Called with the file chosen from the add tile. Omit to leave it out. */
-  onAddBackgroundImage?: (file: File) => void;
-  /** Removes a removable effect, never the one in force. */
-  onRemoveBackgroundEffect?: (id: string) => void;
-  /** Why the last file offered couldn't be used; a new object each time. */
-  backgroundImageRefusal?: { text: string };
-  /** The user's own camera, shown at the top of the camera menu. */
-  selfPreview?: ReactNode;
   /**
    * For any toggle and option this method will be called.
    * So toggles need to be implemented by listening here and setting the right toggle item to `enabled`
@@ -107,10 +95,6 @@ const LIST_SHARE_OF_CALL = 0.6;
 /** Smallest device list height in px, so a short call still shows more than one device. */
 const MIN_LIST_HEIGHT = 160;
 
-/** The menu's width as its stylesheet sets it, to place the preview before
-    the menu is drawn. */
-const MENU_WIDTH = 296;
-
 /** Space kept between the menu and the call area's sides. */
 const MENU_MARGIN = 16;
 
@@ -129,10 +113,6 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
   onSelectBackgroundEffect,
   backgroundEffectNotice,
   backgroundEffectSettling,
-  onAddBackgroundImage,
-  onRemoveBackgroundEffect,
-  backgroundImageRefusal,
-  selfPreview,
   onSelect,
 }) => {
   // Requested but not yet selected. Keyed by kind too, since Chrome uses
@@ -142,42 +122,11 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
     id: string;
   } | null>(null);
   const [menuOpen, setMenuOpen] = useState(false);
-  // The file picker takes the focus, which the menu reads as a click
-  // elsewhere; it is held open until the picker is done.
-  const choosingFile = useRef(false);
-  const fileInput = useRef<HTMLInputElement | null>(null);
-  // A refusal is about the attempt that caused it: shown until dismissed or
-  // until the menu closes, and again for the next one.
-  const [seenRefusal, setSeenRefusal] = useState<object>();
-  const refusal =
-    backgroundImageRefusal !== seenRefusal ? backgroundImageRefusal : undefined;
-  const onOpenChange = useCallback(
-    (open: boolean): void => {
-      if (!open && choosingFile.current) return;
-      setMenuOpen(open);
-      // Drop a request that never arrived.
-      if (!open) setPlannedSelection(null);
-      if (!open) setSeenRefusal(backgroundImageRefusal);
-    },
-    [backgroundImageRefusal],
-  );
-  // Scrolled to as it appears, as the list may be scrolled away from it.
-  const scrollIntoView = useCallback((element: HTMLElement | null): void => {
-    element?.scrollIntoView({ block: "nearest" });
+  const onOpenChange = useCallback((open: boolean): void => {
+    setMenuOpen(open);
+    // Drop a request that never arrived.
+    if (!open) setPlannedSelection(null);
   }, []);
-  const watchFileInput = useCallback(
-    (input: HTMLInputElement | null): (() => void) | undefined => {
-      fileInput.current = input;
-      if (input === null) return;
-      // Dismissing the picker fires cancel, which React doesn't type.
-      const done = (): void => {
-        choosingFile.current = false;
-      };
-      input.addEventListener("cancel", done);
-      return (): void => input.removeEventListener("cancel", done);
-    },
-    [],
-  );
   const isBusy = busy ?? false;
   const { t } = useTranslation();
   const devices = useMediaDevices();
@@ -211,59 +160,21 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
 
   // Measured on the call area: CSS can't size the portalled menu against it.
   const rootElement = useRootElement();
-  const [listShare, setListShare] = useState<number>();
-  const [previewBlock, setPreviewBlock] = useState(0);
+  const [listMaxHeight, setListMaxHeight] = useState<number>();
   useEffect(() => {
     if (!menuOpen) return;
-    // From the tokens the stylesheets size the preview with, so that it is
-    // placed once rather than measured and moved.
-    const tokens = getComputedStyle(rootElement);
-    const px = (token: string): number =>
-      parseFloat(tokens.getPropertyValue(token)) || 0;
-    const below = px("--cpd-space-2x") + px("--cpd-space-1x");
     // Followed, since a host can resize the call while the menu is open.
     const subscription = observeElementSize$(rootElement)
       .pipe(
-        map(({ width, height }) => ({
-          height: Math.round(height * LIST_SHARE_OF_CALL),
-          width: Math.min(MENU_WIDTH, Math.round(width - 2 * MENU_MARGIN)),
-        })),
-        distinctUntilChanged(
-          (a, b) => a.height === b.height && a.width === b.width,
+        map(({ height }) =>
+          Math.max(MIN_LIST_HEIGHT, Math.round(height * LIST_SHARE_OF_CALL)),
         ),
+        distinctUntilChanged(),
       )
-      .subscribe(({ height, width }) => {
-        setListShare(height);
-        setPreviewBlock(Math.round((width * 9) / 16) + below);
-      });
+      .subscribe(setListMaxHeight);
     return (): void => subscription.unsubscribe();
   }, [menuOpen, rootElement]);
 
-  // Paid for out of the list's share, so a preview makes the menu no taller.
-  const hasPreview =
-    iconsAndLabels === "video" &&
-    selfPreview !== undefined &&
-    listShare !== undefined;
-  const previewPinned =
-    hasPreview && listShare - previewBlock >= MIN_LIST_HEIGHT;
-  const listMaxHeight =
-    listShare === undefined
-      ? undefined
-      : Math.max(
-          MIN_LIST_HEIGHT,
-          listShare - (previewPinned ? previewBlock : 0),
-        );
-  const preview = hasPreview && (
-    <div
-      aria-hidden
-      className={classNames(styles.selfPreview, {
-        [styles.selfPreviewPinned]: previewPinned,
-      })}
-    >
-      {backgroundEffectSettling ? <InlineSpinner size={32} /> : selfPreview}
-    </div>
-  );
-
   useEffect(() => {
     if (menuOpen) devices.requestDeviceNames(); // No-op after the first call
   }, [menuOpen, devices]);
@@ -415,21 +326,6 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
     >
       {/* The mute button lives inside */}
       {button}
-      {onAddBackgroundImage !== undefined && (
-        <input
-          ref={watchFileInput}
-          type="file"
-          accept="image/*"
-          hidden
-          onChange={(e) => {
-            const file = e.target.files?.[0];
-            // Cleared, so the same file can be chosen twice in a row.
-            e.target.value = "";
-            choosingFile.current = false;
-            if (file) onAddBackgroundImage(file);
-          }}
-        />
-      )}
       <Menu
         className={styles.menu}
         // Named for screen readers only: each section has its own heading.
@@ -454,12 +350,9 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
           />
         }
       >
-        {previewPinned && preview}
         <MenuScrollArea
           ref={trackFocusSource}
-          className={classNames(styles.deviceList, {
-            [styles.deviceListLeadsWithPreview]: hasPreview && !previewPinned,
-          })}
+          className={styles.deviceList}
           data-testid="device-list"
           style={
             {
@@ -468,7 +361,6 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
             } as CSSProperties
           }
         >
-          {hasPreview && !previewPinned && preview}
           {audioMeter && speakerOptions && (
             <MenuScrollSection title={t("settings.devices.speaker")}>
               {deviceItems(
@@ -502,39 +394,14 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
                 describedBy={
                   backgroundEffectNotice === undefined ? undefined : noticeId
                 }
-                onAdd={
-                  onAddBackgroundImage === undefined
-                    ? undefined
-                    : (): void => {
-                        choosingFile.current = true;
-                        fileInput.current?.click();
-                      }
-                }
-                addLabel={t("action.add_background_image")}
-                onRemove={onRemoveBackgroundEffect}
-                removeLabel={t("action.remove")}
               />
               {/* In the list, so the menu grows no taller for it. */}
-              {refusal !== undefined && (
-                <div
-                  ref={scrollIntoView}
-                  role="none"
-                  className={styles.refusal}
-                >
-                  <Alert
-                    type="critical"
-                    title={refusal.text}
-                    onClose={(): void => setSeenRefusal(refusal)}
-                  />
+              {backgroundEffectNotice !== undefined && (
+                <div id={noticeId} role="none" className={styles.notice}>
+                  <InfoIcon width={20} height={20} />
+                  <span>{backgroundEffectNotice}</span>
                 </div>
               )}
-              {refusal === undefined &&
-                backgroundEffectNotice !== undefined && (
-                  <div id={noticeId} role="none" className={styles.notice}>
-                    <InfoIcon width={20} height={20} />
-                    <span>{backgroundEffectNotice}</span>
-                  </div>
-                )}
             </MenuScrollSection>
           )}
         </MenuScrollArea>

src/components/SelfPreview.module.css

@@ -1,10 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-.mirrored {
-  transform: scaleX(-1);
-}

src/components/SelfPreview.tsx

@@ -1,36 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { type FC } from "react";
-import { VideoCallOffIcon } from "@vector-im/compound-design-tokens/assets/web/icons";
-
-import styles from "./SelfPreview.module.css";
-import { useAttachedTrack } from "../useAttachedTrack";
-import { type ShownCamera } from "../tracks/cameraTrack";
-
-interface Props {
-  /** The camera as the pipeline has it, or none while the camera is off. */
-  track: ShownCamera | null;
-}
-
-/**
- * The user's own camera with the effect in force: the pipeline's own track,
- * shown a second time rather than captured again.
- */
-export const SelfPreview: FC<Props> = ({ track }) => {
-  const { videoRef, mirrored } = useAttachedTrack(track);
-
-  if (!track) return <VideoCallOffIcon width={32} height={32} />;
-  return (
-    <video
-      ref={videoRef}
-      muted
-      playsInline
-      className={mirrored ? styles.mirrored : undefined}
-    />
-  );
-};

src/config/Config.test.ts

@@ -95,19 +95,6 @@ describe("Config.initWith", () => {
     expect(Config.get().ssla).toBe("https://example.invalid/ssla");
   });
 
-  it("falls back to the defaults when fetching config.json rejects", async () => {
-    // A rejected promise is what a webview gives for a missing local file.
-    vi.spyOn(globalThis, "fetch").mockRejectedValue(
-      new TypeError("Load failed"),
-    );
-    vi.spyOn(logger, "info").mockImplementation(() => {});
-    Reflect.set(Config, "internalInstance", undefined);
-
-    await expect(Config.init()).resolves.toBeUndefined();
-
-    expect(Config.get().media_quality).toEqual(DEFAULT_CONFIG.media_quality);
-  });
-
   it("replaces a config initialized earlier", () => {
     Config.initWith({ ssla: "https://first.invalid/ssla" });
     Config.initWith({ ssla: "https://second.invalid/ssla" });

src/config/Config.ts

@@ -140,20 +140,13 @@ export function validateConfig(config: ConfigOptions): ConfigOptions {
 }
 
 async function downloadConfig(fetchTarget: string): Promise<ConfigOptions> {
-  let response: Response;
-  try {
-    response = await fetch(fetchTarget);
-  } catch (e) {
-    // The embedded package ships no config.json, and some webviews (Element X
-    // iOS) reject the fetch of a missing local file rather than answering 404.
-    logger.info(`No config at ${fetchTarget}, using defaults`, e);
-    // resolveConfig merges in the defaults.
-    return {};
-  }
+  const response = await fetch(fetchTarget);
 
   if (isFailure(response)) {
-    // resolveConfig merges in the defaults.
-    return {};
+    // Lack of a config isn't an error, we should just use the defaults.
+    // Also treat a blank config as no config, assuming the status code is 0, because we don't get 404s from file:
+    // URIs so this is the only way we can not fail if the file doesn't exist when loading from a file:// URI.
+    return DEFAULT_CONFIG;
   }
 
   return response.json();

src/room/InCallView.tsx

@@ -110,11 +110,7 @@ import { useBehavior } from "../useBehavior.ts";
 import { useValueBehavior } from "../useValueBehavior.ts";
 import { Toast } from "../Toast.tsx";
 import overlayStyles from "../Overlay.module.css";
-import {
-  reportCamera,
-  useBackgroundEffectsState$,
-} from "../tracks/BackgroundEffectsContext.tsx";
-import { sdkCamera } from "../tracks/cameraTrack.ts";
+import { useBackgroundEffectsState$ } from "../tracks/BackgroundEffectsContext";
 import { type Layout } from "../state/layout-types.ts";
 import { ObservableScope } from "../state/ObservableScope.ts";
 import { CallFooter, type FooterSnapshot } from "../components/CallFooter.tsx";
@@ -215,12 +211,6 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
       reactionsReader.reactions$,
     );
     setVm(vm);
-    // The call's camera is the one the camera menu shows from here on.
-    reportCamera(
-      scope,
-      vm.camera$.pipe(map((camera) => (camera ? sdkCamera(camera) : null))),
-      backgroundEffectsState$,
-    );
 
     vm.leave$.pipe(scope.bind()).subscribe(props.onLeft);
 
@@ -251,7 +241,7 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
       vm,
       props.muteStates,
       mediaDevices,
-      backgroundEffectsState$,
+      backgroundEffectsState$.pipe(map(({ settling }) => settling ?? false)),
       `${props.client.getUserId()}:${props.client.getDeviceId()}`,
       { showControls: urlParams.showControls, header: urlParams.header },
     );

src/room/KnockLobbyView.test.tsx

@@ -28,7 +28,6 @@ const stable = vi.hoisted(() => ({
   media: undefined as unknown,
 }));
 vi.mock("../tracks/BackgroundEffectsContext", () => ({
-  reportCamera: (): void => {},
   useBackgroundEffectsState$: (): Behavior<BackgroundEffectsState> =>
     (stable.processorState$ ??= constant({
       supported: false,

src/room/LobbyView.test.tsx

@@ -45,7 +45,6 @@ const leaveToHome = vi.fn();
 // One instance: the view keys an effect on it
 const processorState$ = vi.hoisted(() => ({ current: undefined as unknown }));
 vi.mock("../tracks/BackgroundEffectsContext", () => ({
-  reportCamera: (): void => {},
   useBackgroundEffectsState$: (): Behavior<BackgroundEffectsState> =>
     (processorState$.current ??= constant({
       supported: false,

src/room/LobbyView.tsx

@@ -31,11 +31,7 @@ import { LeaveToHomeLink } from "../button/LeaveToHomeLink";
 import { useLeaveToHome } from "../LeaveToHomeContext";
 import { useMediaDevices } from "../MediaDevicesContext";
 import { ObservableScope } from "../state/ObservableScope";
-import {
-  reportCamera,
-  useBackgroundEffectsState$,
-} from "../tracks/BackgroundEffectsContext";
-import { sdkCamera } from "../tracks/cameraTrack";
+import { useBackgroundEffectsState$ } from "../tracks/BackgroundEffectsContext";
 import { useBehavior } from "../useBehavior";
 import { CallFooter, type FooterSnapshot } from "../components/CallFooter";
 import { useCallViewKeyboardShortcuts } from "../useCallViewKeyboardShortcuts";
@@ -131,23 +127,18 @@ export const LobbyView: FC<Props> = ({
   const [mediaVm, setMediaVm] = useState<LobbyMediaViewModel | null>(null);
   useEffect(() => {
     const mediaScope = new ObservableScope();
-    const vm = createLobbyMediaViewModel(
-      mediaScope,
-      media,
-      muteStates,
-      devices,
-      captureSettings(),
-      mediaScope.behavior(
-        backgroundEffectsState$.pipe(map((state) => state.processor)),
+    setMediaVm(
+      createLobbyMediaViewModel(
+        mediaScope,
+        media,
+        muteStates,
+        devices,
+        captureSettings(),
+        mediaScope.behavior(
+          backgroundEffectsState$.pipe(map((state) => state.processor)),
+        ),
       ),
     );
-    // The lobby's camera is the one the camera menu shows until the call's
-    reportCamera(
-      mediaScope,
-      vm.videoTrack$.pipe(map((camera) => camera && sdkCamera(camera))),
-      backgroundEffectsState$,
-    );
-    setMediaVm(vm);
     return (): void => {
       mediaScope.end();
     };
@@ -173,7 +164,7 @@ export const LobbyView: FC<Props> = ({
         footerScope,
         muteStates,
         devices,
-        backgroundEffectsState$,
+        backgroundEffectsState$.pipe(map(({ settling }) => settling ?? false)),
         openSettings,
         hangup,
         // Logo and header are connected: only show the logo in SPA with header.

src/room/VideoPreview.tsx

@@ -5,9 +5,9 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { useMemo, type FC, type ReactNode } from "react";
+import { useEffect, useMemo, useRef, type FC, type ReactNode } from "react";
 import useMeasure from "react-use-measure";
-import { type LocalVideoMediaTrack } from "@element-hq/matrixrtc-sdk";
+import { constant, type LocalVideoMediaTrack } from "@element-hq/matrixrtc-sdk";
 import classNames from "classnames";
 import { useTranslation } from "react-i18next";
 
@@ -15,8 +15,9 @@ import { TileAvatar } from "../tile/TileAvatar";
 import styles from "./VideoPreview.module.css";
 import { type EncryptionSystem } from "../e2ee/sharedKeyManagement";
 import videoPlaceholder from "../graphics/video-placeholder.gif";
-import { useAttachedTrack } from "../useAttachedTrack";
-import { sdkCamera } from "../tracks/cameraTrack";
+import { useBehavior } from "../useBehavior";
+
+const noFacingMode = constant(undefined);
 
 export type MatrixInfo = {
   userId: string;
@@ -45,9 +46,15 @@ export const VideoPreview: FC<Props> = ({
   const { t } = useTranslation();
   const [previewRef, previewBounds] = useMeasure();
 
-  const { videoRef, mirrored } = useAttachedTrack(
-    videoTrack && sdkCamera(videoTrack),
-  );
+  const videoEl = useRef<HTMLVideoElement | null>(null);
+
+  useEffect(() => {
+    const element = videoEl.current;
+    if (!element || !videoTrack) return;
+    videoTrack.attach(element);
+    return (): void => videoTrack.detach(element);
+  }, [videoTrack]);
+  const facingMode = useBehavior(videoTrack?.facingMode$ ?? noFacingMode);
 
   const cameraIsStarting = useMemo(
     () => videoEnabled && !videoTrack,
@@ -57,8 +64,8 @@ export const VideoPreview: FC<Props> = ({
   return (
     <div className={classNames(styles.preview)} ref={previewRef}>
       <video
-        className={mirrored ? styles.mirror : undefined}
-        ref={videoRef}
+        className={facingMode === "user" ? styles.mirror : undefined}
+        ref={videoEl}
         muted
         playsInline
         // There's no reason for this to be focusable

src/state/BackgroundEffects.test.ts

@@ -15,7 +15,6 @@ import {
   type BackgroundEffectsOptions,
   type BackgroundEffectsState,
 } from "./BackgroundEffects";
-import { type AddedBackground } from "../tracks/backgroundImages";
 import { shippedBackgrounds } from "../tracks/backgroundEffectCatalog";
 import { flushPromises, testScope, withTestScheduler } from "../utils/test";
 
@@ -70,8 +69,6 @@ describe("the pipeline's state", () => {
       const effects = createBackgroundEffects(testScope(), {
         supported: true,
         effect$: behavior(effect, { n: "none", b: "blur" }),
-        setEffect: vi.fn(),
-        added$: new BehaviorSubject<AddedBackground[] | undefined>([]),
         pipeline: fakePipeline().pipeline,
         transformer,
       });
@@ -97,8 +94,6 @@ describe("the pipeline's state", () => {
 
 describe("background effects", () => {
   let effect$: BehaviorSubject<string>;
-  let added$: BehaviorSubject<AddedBackground[] | undefined>;
-  let setEffect: (raw: string) => void;
   let fake: ReturnType<typeof fakePipeline>;
 
   function build(
@@ -107,8 +102,6 @@ describe("background effects", () => {
     return createBackgroundEffects(testScope(), {
       supported: true,
       effect$,
-      setEffect,
-      added$,
       pipeline: fake.pipeline,
       transformer: { onFirstFrame: undefined },
       ...options,
@@ -123,8 +116,6 @@ describe("background effects", () => {
 
   beforeEach(() => {
     effect$ = new BehaviorSubject("none");
-    added$ = new BehaviorSubject<AddedBackground[] | undefined>(undefined);
-    setEffect = vi.fn((raw: string) => effect$.next(raw));
     fake = fakePipeline();
   });
 
@@ -178,63 +169,4 @@ describe("background effects", () => {
       { mode: "disabled" },
     ]);
   });
-
-  it("clears a remembered effect when it cannot be honoured", () => {
-    effect$.next(`image:${shippedBackgrounds[0].id}`);
-    const effects = build({ supported: false });
-    expect(effect$.value).toBe("none");
-    expect(effects.state$.value.processor).toBeUndefined();
-  });
-
-  it("puts an added background on as its picture", async () => {
-    added$.next([{ id: "mine", url: "blob:mine" }]);
-    build();
-    await choose("added:mine");
-    expect(fake.switches).toEqual([
-      { mode: "virtual-background", imagePath: "blob:mine" },
-    ]);
-  });
-
-  it("switches between any two effects in place", async () => {
-    added$.next([{ id: "mine", url: "blob:mine" }]);
-    const shipped = shippedBackgrounds[0];
-    const options: Record<string, unknown> = {
-      none: { mode: "disabled" },
-      blur: { mode: "background-blur", blurRadius: 15 },
-      [`image:${shipped.id}`]: {
-        mode: "virtual-background",
-        imagePath: shipped.imagePath,
-      },
-      "added:mine": { mode: "virtual-background", imagePath: "blob:mine" },
-    };
-    // Each kind to each other kind, and back.
-    const order = [
-      "blur",
-      `image:${shipped.id}`,
-      "added:mine",
-      "blur",
-      "added:mine",
-      `image:${shipped.id}`,
-      "none",
-      "added:mine",
-      "none",
-      "blur",
-    ];
-    const effects = build();
-    await choose(order[0]);
-    const pipeline = effects.state$.value.processor;
-    for (const raw of order.slice(1)) await choose(raw);
-
-    expect(effects.state$.value.processor).toBe(pipeline);
-    expect(fake.switches).toEqual(order.map((raw) => options[raw]));
-  });
-
-  it("forgets an added background the device no longer keeps", () => {
-    effect$.next("added:gone");
-    build();
-    // Not before the device has said what it keeps.
-    expect(effect$.value).toBe("added:gone");
-    added$.next([]);
-    expect(effect$.value).toBe("none");
-  });
 });

src/state/BackgroundEffects.ts

@@ -27,12 +27,9 @@ import { type Behavior } from "./Behavior";
 import { type ObservableScope } from "./ObservableScope";
 import {
   type BackgroundEffect,
-  type EffectId,
   imagePathFor,
   parseEffect,
 } from "../tracks/backgroundEffectCatalog";
-import { type AddedBackground } from "../tracks/backgroundImages";
-import { SyncedCameraTrack } from "../tracks/cameraTrack";
 
 const blurRadius = 15;
 
@@ -41,8 +38,6 @@ export interface BackgroundEffectsState {
   processor: undefined | VideoProcessor;
   /** From the first effect chosen until a frame carrying it is drawn. */
   settling?: boolean;
-  /** The camera this provider's pipeline is synced to. */
-  cameraTrack?: SyncedCameraTrack;
 }
 
 export interface BackgroundEffectsOptions {
@@ -50,10 +45,6 @@ export interface BackgroundEffectsOptions {
   supported: boolean;
   /** The effect chosen, as the setting stores it. */
   effect$: Behavior<string>;
-  /** Stores a choice, to forget one that can't be honoured. */
-  setEffect: (id: EffectId) => void;
-  /** The backgrounds the device keeps, undefined until it has said. */
-  added$: Behavior<AddedBackground[] | undefined>;
   /** The background processor pipeline to be switched between effects. */
   pipeline: BackgroundProcessorWrapper;
   /** Tells, once, that a frame carrying an effect has been drawn. */
@@ -68,38 +59,16 @@ export interface BackgroundEffects {
 /** Switches the pipeline as the choice changes, for as long as the scope lasts. */
 export function createBackgroundEffects(
   scope: ObservableScope,
-  {
-    supported,
-    effect$,
-    setEffect,
-    added$,
-    pipeline,
-    transformer,
-  }: BackgroundEffectsOptions,
+  { supported, effect$, pipeline, transformer }: BackgroundEffectsOptions,
 ): BackgroundEffects {
   // Wrapped once, so the call and the preview see one processor throughout.
   const processor = fromLivekitProcessor(pipeline);
-  // The camera the pipeline is synced to.
-  const cameraTrack = new SyncedCameraTrack();
   const choice$ = effect$.pipe(map(parseEffect));
   const wanted$ = choice$.pipe(
     map((effect) => effect.kind !== "none"),
     distinctUntilChanged(),
   );
 
-  combineLatest([choice$, added$])
-    .pipe(scope.bind())
-    .subscribe(([effect, added]) => {
-      if (effect.kind === "none") return;
-      if (
-        !supported ||
-        (effect.kind === "added" &&
-          added !== undefined &&
-          !added.some(({ id }) => id === effect.id))
-      )
-        setEffect("none");
-    });
-
   const drewAFrame$ = scope.behavior(
     new Observable<boolean>((subscriber) => {
       subscriber.next(false);
@@ -122,7 +91,6 @@ export function createBackgroundEffects(
             supported,
             processor: enable ? processor : undefined,
             settling: enable && !drewAFrame,
-            cameraTrack,
           };
         },
         { supported, processor: undefined },
@@ -133,16 +101,9 @@ export function createBackgroundEffects(
   const switchOptions$ = scope.behavior<
     SwitchBackgroundProcessorOptions | undefined
   >(
-    combineLatest([state$, choice$, added$]).pipe(
-      map(([{ processor }, effect, added]) =>
-        processor === undefined
-          ? undefined
-          : switchOptionsFor(
-              effect,
-              effect.kind === "added"
-                ? added?.find(({ id }) => id === effect.id)?.url
-                : undefined,
-            ),
+    combineLatest([state$, choice$]).pipe(
+      map(([{ processor }, effect]) =>
+        processor === undefined ? undefined : switchOptionsFor(effect),
       ),
       distinctUntilChanged(deepCompare),
     ),
@@ -160,24 +121,18 @@ export function createBackgroundEffects(
   return { state$ };
 }
 
-/** `addedUrl` is the picture of the added background chosen, if still kept. */
 function switchOptionsFor(
   effect: BackgroundEffect,
-  addedUrl: string | undefined,
 ): SwitchBackgroundProcessorOptions {
-  const withImage = (
-    imagePath: string | undefined,
-  ): SwitchBackgroundProcessorOptions =>
-    imagePath
-      ? { mode: "virtual-background", imagePath }
-      : { mode: "disabled" };
   switch (effect.kind) {
     case "blur":
       return { mode: "background-blur", blurRadius };
-    case "shipped":
-      return withImage(imagePathFor(effect.id));
-    case "added":
-      return withImage(addedUrl);
+    case "shipped": {
+      const imagePath = imagePathFor(effect.id);
+      return imagePath
+        ? { mode: "virtual-background", imagePath }
+        : { mode: "disabled" };
+    }
     default:
       return { mode: "disabled" };
   }

src/state/CallViewModel/CallViewModel.ts

@@ -363,8 +363,6 @@ export interface CallViewModel {
   keyRotationSuppressed$: Behavior<boolean>;
   /** The local member, once our membership has been seen in the room. */
   localMember$: Behavior<LocalRTCMember | null>;
-  /** Our own camera track, while one is published. */
-  camera$: Behavior<LocalVideoMediaTrack | undefined>;
   remoteMembers$: Behavior<RemoteRTCMember[]>;
   /** The transports the client holds a connection to, for the developer panel. */
   connectedTransports$: Behavior<TransportMetadata[]>;
@@ -1510,7 +1508,6 @@ export function createCallViewModel$(
     leave,
     toggleScreenSharing: toggleScreenSharing,
     sharingScreen$: sharingScreen$,
-    camera$,
 
     tapScreen: (): void => screenTap$.next(),
     tapControls: (): void => controlsTap$.next(),

src/tracks/BackgroundEffectsContext.test.ts

@@ -8,11 +8,9 @@ Please see LICENSE in the repository root for full details.
 import { act, createElement, type FC } from "react";
 import { render } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { BehaviorSubject } from "rxjs";
 
 import {
   BackgroundEffectsProvider,
-  reportCamera,
   useBackgroundEffects,
   createAppBackgroundEffects,
 } from "./BackgroundEffectsContext";
@@ -21,12 +19,8 @@ import {
   type BackgroundEffectsState,
 } from "../state/BackgroundEffects";
 import { backgroundEffect } from "../settings/settings";
-import { sdkCamera, type ShownCamera, SyncedCameraTrack } from "./cameraTrack";
-import { type AddedBackground } from "./backgroundImages";
-import { constant } from "../state/Behavior";
-import { flushPromises, mockVideoTrack, testScope } from "../utils/test";
+import { flushPromises, testScope } from "../utils/test";
 
-const sdkSupportMock = vi.hoisted(() => vi.fn(() => true));
 const pipelines = vi.hoisted(() => ({
   built: 0,
   destroyed: 0,
@@ -47,99 +41,14 @@ vi.mock("@livekit/track-processors", () => ({
       return Promise.resolve();
     });
   }),
-  supportsBackgroundProcessors: (): boolean => sdkSupportMock(),
+  supportsBackgroundProcessors: (): boolean => true,
 }));
 const platformMock = vi.hoisted(() => ({ platform: "desktop" }));
 vi.mock("../Platform", () => platformMock);
-vi.mock("./backgroundImages", async () => {
-  const { BehaviorSubject } = await import("rxjs");
-  return {
-    addedBackgrounds: {
-      added$: new BehaviorSubject<AddedBackground[] | undefined>(undefined),
-    },
-  };
-});
 vi.mock("./BackgroundEffectTransformer", () => ({
   BackgroundEffectTransformer: vi.fn(),
 }));
 
-describe("the synced camera", () => {
-  it("is the track last synced, and cleared only while still its own", () => {
-    const synced = new SyncedCameraTrack();
-    const pipeline = constant<BackgroundEffectsState>({
-      supported: false,
-      processor: undefined,
-      cameraTrack: synced,
-    });
-    const lobby = sdkCamera(mockVideoTrack({ id: "lobby" }));
-    const call = sdkCamera(mockVideoTrack({ id: "call" }));
-    const lobbyCamera$ = new BehaviorSubject<ShownCamera | null>(lobby);
-    reportCamera(testScope(), lobbyCamera$, pipeline);
-    expect(synced.track$.value).toBe(lobby);
-
-    const callScope = testScope();
-    reportCamera(callScope, constant(call), pipeline);
-    expect(synced.track$.value).toBe(call);
-
-    lobbyCamera$.next(null);
-    expect(synced.track$.value).toBe(call);
-    callScope.end();
-    expect(synced.track$.value).toBeNull();
-  });
-
-  it("reports the camera once, however often the pipeline's state changes", () => {
-    const synced = new SyncedCameraTrack();
-    const report = vi.spyOn(synced, "report");
-    const state$ = new BehaviorSubject<BackgroundEffectsState>({
-      supported: true,
-      processor: undefined,
-      cameraTrack: synced,
-    });
-    reportCamera(testScope(), constant(sdkCamera(mockVideoTrack({}))), state$);
-    state$.next({ ...state$.value, settling: true });
-    state$.next({ ...state$.value, settling: false });
-    expect(report).toHaveBeenCalledOnce();
-  });
-
-  it("is the SDK's camera once the call reports it", () => {
-    const synced = new SyncedCameraTrack();
-    const state$ = constant<BackgroundEffectsState>({
-      supported: true,
-      processor: undefined,
-      cameraTrack: synced,
-    });
-    const callCamera = mockVideoTrack({ facingMode$: constant("user") });
-    const callCamera$ = new BehaviorSubject<ShownCamera | null>(
-      sdkCamera(callCamera),
-    );
-    reportCamera(testScope(), callCamera$, state$);
-    expect(synced.track$.value).toBe(sdkCamera(callCamera));
-    expect(synced.track$.value?.facesUser()).toBe(true);
-
-    const element = document.createElement("video");
-    synced.track$.value!.attach(element);
-    expect(callCamera.attach).toHaveBeenCalledWith(element);
-
-    callCamera$.next(null);
-    expect(synced.track$.value).toBeNull();
-  });
-
-  it("keeps each call's camera to its own", () => {
-    const mine = createAppBackgroundEffects(testScope());
-    const theirs = createAppBackgroundEffects(testScope());
-    const first = sdkCamera(mockVideoTrack({ id: "first" }));
-    const second = sdkCamera(mockVideoTrack({ id: "second" }));
-    reportCamera(testScope(), constant(first), mine.state$);
-    reportCamera(testScope(), constant(second), theirs.state$);
-
-    expect(mine.state$.value.cameraTrack).not.toBe(
-      theirs.state$.value.cameraTrack,
-    );
-    expect(mine.state$.value.cameraTrack?.track$.value).toBe(first);
-    expect(theirs.state$.value.cameraTrack?.track$.value).toBe(second);
-  });
-});
-
 describe("BackgroundEffectsProvider", () => {
   let seen: BackgroundEffectsState[];
   const Surface: FC = () => {
@@ -168,7 +77,6 @@ describe("BackgroundEffectsProvider", () => {
     pipelines.destroyed = 0;
     pipelines.switches = [];
     platformMock.platform = "desktop";
-    sdkSupportMock.mockReturnValue(true);
     backgroundEffect.setValue("none");
   });
   afterEach(() => backgroundEffect.setValue("none"));

src/tracks/BackgroundEffectsContext.tsx

@@ -5,14 +5,6 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import {
-  combineLatest,
-  distinctUntilChanged,
-  EMPTY,
-  map,
-  Observable,
-  switchMap,
-} from "rxjs";
 import {
   BackgroundProcessorWrapper,
   supportsBackgroundProcessors,
@@ -21,8 +13,6 @@ import { createContext, type FC, type JSX, use } from "react";
 
 import { backgroundEffect as backgroundEffectSetting } from "../settings/settings";
 import { BackgroundEffectTransformer } from "./BackgroundEffectTransformer";
-import { type ShownCamera } from "./cameraTrack";
-import { addedBackgrounds } from "./backgroundImages";
 import { type Behavior } from "../state/Behavior";
 import { type ObservableScope } from "../state/ObservableScope";
 import {
@@ -63,8 +53,6 @@ export function createAppBackgroundEffects(
   return createBackgroundEffects(scope, {
     supported: supportsBackgroundProcessors(),
     effect$: backgroundEffectSetting.value$,
-    setEffect: backgroundEffectSetting.setValue,
-    added$: addedBackgrounds.added$,
     pipeline: new BackgroundProcessorWrapper(transformer, "background-effect"),
     transformer,
   });
@@ -80,32 +68,3 @@ export const BackgroundEffectsProvider: FC<Props> = ({ effects, children }) => (
     {children}
   </BackgroundEffectsContext>
 );
-
-/**
- * Reports the camera the pipeline is synced to while the scope lasts: the
- * lobby's before joining, or the call's, each syncing its own.
- */
-export function reportCamera(
-  scope: ObservableScope,
-  camera$: Observable<ShownCamera | null>,
-  backgroundEffectsState$: Behavior<BackgroundEffectsState>,
-): void {
-  // Keyed on the camera alone: reporting again for every change of state would
-  // blank the preview each time.
-  combineLatest([
-    camera$,
-    backgroundEffectsState$.pipe(
-      map(({ cameraTrack }) => cameraTrack),
-      distinctUntilChanged(),
-    ),
-  ])
-    .pipe(
-      switchMap(([camera, cameraTrack]) =>
-        camera === null || cameraTrack === undefined
-          ? EMPTY
-          : new Observable<never>(() => cameraTrack.report(camera)),
-      ),
-      scope.bind(),
-    )
-    .subscribe();
-}

src/tracks/backgroundEffectCatalog.test.ts

@@ -15,7 +15,6 @@ import {
   serializeEffect,
   shippedBackgrounds,
 } from "./backgroundEffectCatalog";
-import { maxAddedBackgrounds } from "./backgroundImages";
 
 describe("the chosen background effect", () => {
   test("round-trips through its stored form", () => {
@@ -23,7 +22,6 @@ describe("the chosen background effect", () => {
       { kind: "none" },
       { kind: "blur" },
       ...shippedBackgrounds.map(({ id }) => ({ kind: "shipped" as const, id })),
-      { kind: "added", id: "d3b07384" },
     ];
     for (const effect of effects)
       expect(parseEffect(serializeEffect(effect))).toEqual(effect);
@@ -32,7 +30,6 @@ describe("the chosen background effect", () => {
   test("falls back to no effect when the stored form names nothing we ship", () => {
     expect(parseEffect("image:gone")).toEqual({ kind: "none" });
     expect(parseEffect("")).toEqual({ kind: "none" });
-    expect(parseEffect("added:")).toEqual({ kind: "none" });
   });
 
   test("reads a stored value that is not a string as no effect", () => {
@@ -40,14 +37,6 @@ describe("the chosen background effect", () => {
       expect(parseEffect(raw)).toEqual({ kind: "none" });
   });
 
-  test("fills the grid at the limit and one short of it", () => {
-    // No effect, blur and the shipped ones, then the added ones.
-    const fixed = 2 + shippedBackgrounds.length;
-    expect((fixed + maxAddedBackgrounds) % 3).toBe(0);
-    // One short, the add tile takes the last place.
-    expect((fixed + maxAddedBackgrounds - 1 + 1) % 3).toBe(0);
-  });
-
   test("gives every shipped background an image to draw", () => {
     for (const { id } of shippedBackgrounds)
       expect(imagePathFor(id)).toBeTruthy();

src/tracks/backgroundEffectCatalog.ts

@@ -22,18 +22,16 @@ export const shippedBackgrounds: ShippedBackground[] = [
 export type BackgroundEffect =
   | { kind: "none" }
   | { kind: "blur" }
-  | { kind: "shipped"; id: string }
-  | { kind: "added"; id: string };
+  | { kind: "shipped"; id: string };
 
 /** An effect as the setting stores it, and as the menu names its option. */
-export type EffectId = "none" | "blur" | `image:${string}` | `added:${string}`;
+export type EffectId = "none" | "blur" | `image:${string}`;
 
 export const noEffect: BackgroundEffect = { kind: "none" };
 
 /**
- * Reads a stored effect; one we no longer ship reads as no effect. Whether an
- * added one is still kept only the device knows. Stored by hand or by another
- * build, the value need not even be a string.
+ * Reads a stored effect; one we no longer ship reads as no effect. Stored by
+ * hand or by another build, the value need not even be a string.
  */
 export function parseEffect(raw: unknown): BackgroundEffect {
   if (typeof raw !== "string") return noEffect;
@@ -43,10 +41,6 @@ export function parseEffect(raw: unknown): BackgroundEffect {
     if (shippedBackgrounds.some((b) => b.id === id))
       return { kind: "shipped", id };
   }
-  if (raw.startsWith("added:")) {
-    const id = raw.slice("added:".length);
-    if (id) return { kind: "added", id };
-  }
   return noEffect;
 }
 
@@ -56,8 +50,6 @@ export function serializeEffect(effect: BackgroundEffect): EffectId {
       return "blur";
     case "shipped":
       return `image:${effect.id}`;
-    case "added":
-      return `added:${effect.id}`;
     default:
       return "none";
   }

src/tracks/backgroundImages.test.ts

@@ -1,172 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { IDBFactory } from "fake-indexeddb";
-
-import {
-  AddedBackgrounds,
-  type BackgroundImageStorage,
-  IndexedDBImageStorage,
-  type KeptImage,
-  maxAddedBackgrounds,
-  prepareImage,
-  UnusableImage,
-} from "./backgroundImages";
-import { flushPromises } from "../utils/test";
-
-describe("AddedBackgrounds", () => {
-  beforeEach(() => {
-    let n = 0;
-    vi.spyOn(URL, "createObjectURL").mockImplementation(() => `blob:${++n}`);
-  });
-
-  it("offers what the device keeps, oldest first", async () => {
-    const image = new Blob(["x"], { type: "image/png" });
-    const store = new AddedBackgrounds(
-      memoryStorage([
-        { id: "later", image, addedAt: 2 },
-        { id: "earlier", image, addedAt: 1 },
-      ]),
-      asGiven,
-    );
-    expect(store.added$.value).toBeUndefined();
-    await flushPromises();
-    expect(store.added$.value?.map(({ id }) => id)).toEqual([
-      "earlier",
-      "later",
-    ]);
-  });
-
-  it("keeps an added image and offers it after the others", async () => {
-    const storage = memoryStorage();
-    const store = new AddedBackgrounds(storage, asGiven);
-    await flushPromises();
-    const id = await store.add(new Blob(["x"], { type: "image/png" }));
-    expect(store.added$.value?.map((a) => a.id)).toEqual([id]);
-    expect((await storage.list()).map((k) => k.id)).toEqual([id]);
-  });
-
-  it("keeps the prepared image, not the file", async () => {
-    const storage = memoryStorage();
-    const prepared = new Blob(["y"], { type: "image/webp" });
-    const store = new AddedBackgrounds(storage, async () =>
-      Promise.resolve(prepared),
-    );
-    await store.add(new Blob(["x"], { type: "image/png" }));
-    expect((await storage.list())[0].image).toBe(prepared);
-  });
-
-  it("keeps nothing of a file it refuses", async () => {
-    const storage = memoryStorage();
-    const store = new AddedBackgrounds(storage, async () =>
-      Promise.reject(new UnusableImage("animated")),
-    );
-    await flushPromises();
-    await expect(store.add(new Blob(["x"]))).rejects.toThrow(UnusableImage);
-    expect(await storage.list()).toEqual([]);
-    expect(store.added$.value).toEqual([]);
-  });
-
-  it("keeps no more than the grid holds", async () => {
-    const storage = memoryStorage();
-    const store = new AddedBackgrounds(storage, asGiven);
-    for (let i = 0; i < maxAddedBackgrounds; i++)
-      await store.add(new Blob([`${i}`]));
-    await expect(store.add(new Blob(["more"]))).rejects.toThrow(RangeError);
-    expect(await storage.list()).toHaveLength(maxAddedBackgrounds);
-  });
-
-  it("forgets a removed image, and lets its picture go", async () => {
-    const revoke = vi
-      .spyOn(URL, "revokeObjectURL")
-      .mockImplementation(() => {});
-    const storage = memoryStorage();
-    const store = new AddedBackgrounds(storage, asGiven);
-    await flushPromises();
-    const first = await store.add(new Blob(["a"]));
-    const second = await store.add(new Blob(["b"]));
-    const url = store.added$.value![0].url;
-
-    await store.remove(first);
-    expect(store.added$.value?.map((a) => a.id)).toEqual([second]);
-    expect((await storage.list()).map((k) => k.id)).toEqual([second]);
-    expect(revoke).toHaveBeenCalledWith(url);
-  });
-
-  it("offers nothing where the browser keeps nothing", async () => {
-    const store = new AddedBackgrounds(null);
-    await flushPromises();
-    expect(store.added$.value).toEqual([]);
-    await expect(store.add(new Blob(["x"]))).rejects.toThrow();
-  });
-
-  it("offers none, rather than waiting, where the device can't be read", async () => {
-    const unreadable: BackgroundImageStorage = {
-      ...memoryStorage(),
-      list: async () => Promise.reject(new Error("storage cleared")),
-    };
-    const store = new AddedBackgrounds(unreadable);
-    await flushPromises();
-    expect(store.added$.value).toEqual([]);
-  });
-});
-
-describe("prepareImage", () => {
-  // Refused before anything is decoded, which only a real browser could do.
-  it("refuses a file that isn't an image", async () => {
-    await expect(
-      prepareImage(new Blob(["x"], { type: "text/plain" })),
-    ).rejects.toEqual(new UnusableImage("not-an-image"));
-  });
-
-  it("refuses an animated type where the browser can't count frames", async () => {
-    expect(globalThis.ImageDecoder).toBeUndefined();
-    await expect(
-      prepareImage(new Blob(["GIF89a"], { type: "image/gif" })),
-    ).rejects.toEqual(new UnusableImage("animated"));
-  });
-});
-
-describe("IndexedDBImageStorage", () => {
-  it("keeps images across sessions until they are deleted", async () => {
-    const indexedDB = new IDBFactory();
-    const image = new Blob(["x"], { type: "image/webp" });
-    const first = new IndexedDBImageStorage(indexedDB);
-    await first.put({ id: "a", image, addedAt: 1 });
-    await first.put({ id: "b", image, addedAt: 2 });
-
-    // A session of its own, as after a reload.
-    const second = new IndexedDBImageStorage(indexedDB);
-    expect(
-      (await second.list()).map(({ id, addedAt }) => [id, addedAt]),
-    ).toEqual([
-      ["a", 1],
-      ["b", 2],
-    ]);
-    await second.delete("a");
-    expect((await first.list()).map(({ id }) => id)).toEqual(["b"]);
-  });
-});
-
-// Decoding needs a real browser; the end-to-end checks cover it.
-const asGiven = async (file: Blob): Promise<Blob> => Promise.resolve(file);
-
-function memoryStorage(kept: KeptImage[] = []): BackgroundImageStorage {
-  return {
-    list: async (): Promise<KeptImage[]> => Promise.resolve([...kept]),
-    put: async (image): Promise<void> => {
-      kept.push(image);
-      return Promise.resolve();
-    },
-    delete: async (id): Promise<void> => {
-      const index = kept.findIndex((k) => k.id === id);
-      if (index !== -1) kept.splice(index, 1);
-      return Promise.resolve();
-    },
-  };
-}

src/tracks/backgroundImages.ts

@@ -1,220 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { BehaviorSubject } from "rxjs";
-import { logger } from "matrix-js-sdk/lib/logger";
-
-import { type Behavior } from "../state/Behavior";
-
-export const maxAddedBackgrounds = 5;
-
-/** The longest edge kept; the pipeline scales every image to the camera. */
-export const maxStoredEdge = 1920;
-
-/** Why a file can't be used as a background. */
-export type UnusableReason = "not-an-image" | "animated" | "undecodable";
-
-export class UnusableImage extends Error {
-  public constructor(public readonly reason: UnusableReason) {
-    super(reason);
-    this.name = "UnusableImage";
-  }
-}
-
-/** A background the user added, as the menu and the pipeline use it. */
-export interface AddedBackground {
-  id: string;
-  url: string;
-}
-
-/** A background the user added, as it is kept on the device. */
-export interface KeptImage {
-  id: string;
-  image: Blob;
-  addedAt: number;
-}
-
-/** Where added backgrounds are kept. */
-export interface BackgroundImageStorage {
-  list(): Promise<KeptImage[]>;
-  put(image: KeptImage): Promise<void>;
-  delete(id: string): Promise<void>;
-}
-
-/** The backgrounds this device keeps, which never leave it. */
-export class AddedBackgrounds {
-  private readonly subject$ = new BehaviorSubject<
-    AddedBackground[] | undefined
-  >(undefined);
-  /** Undefined until what the device keeps has been read. */
-  public readonly added$: Behavior<AddedBackground[] | undefined> =
-    this.subject$;
-
-  public constructor(
-    private readonly storage: BackgroundImageStorage | null,
-    private readonly prepare: (file: Blob) => Promise<Blob> = prepareImage,
-  ) {
-    this.read().catch((e) => {
-      logger.warn("Could not read added backgrounds", e);
-      this.subject$.next([]);
-    });
-  }
-
-  private async read(): Promise<void> {
-    const kept = (await this.storage?.list()) ?? [];
-    kept.sort((a, b) => a.addedAt - b.addedAt);
-    this.subject$.next(
-      kept.map(({ id, image }) => ({ id, url: URL.createObjectURL(image) })),
-    );
-  }
-
-  /**
-   * Keeps a file as a background, and answers with its id. Throws
-   * {@link UnusableImage} for a file that can't be used, and a RangeError
-   * once maxAddedBackgrounds are kept.
-   */
-  public async add(file: Blob): Promise<string> {
-    if (this.storage === null)
-      throw new Error("This browser keeps no backgrounds");
-    const image = await this.prepare(file);
-    if ((await this.storage.list()).length >= maxAddedBackgrounds)
-      throw new RangeError(
-        `${maxAddedBackgrounds} backgrounds are kept already`,
-      );
-    const kept: KeptImage = {
-      id: crypto.randomUUID(),
-      image,
-      addedAt: Date.now(),
-    };
-    await this.storage.put(kept);
-    this.subject$.next([
-      ...(this.subject$.value ?? []),
-      { id: kept.id, url: URL.createObjectURL(image) },
-    ]);
-    return kept.id;
-  }
-
-  public async remove(id: string): Promise<void> {
-    await this.storage?.delete(id);
-    const current = this.subject$.value ?? [];
-    const gone = current.find((a) => a.id === id);
-    if (gone) URL.revokeObjectURL(gone.url);
-    this.subject$.next(current.filter((a) => a.id !== id));
-  }
-}
-
-/**
- * Refuses what can't be used, reduces what is larger than is kept, and lays
- * every image on an opaque ground: a background has to cover what is behind
- * it, so a transparent pixel would be a hole in it.
- */
-export async function prepareImage(file: Blob): Promise<Blob> {
-  if (!file.type.startsWith("image/")) throw new UnusableImage("not-an-image");
-  if (await isAnimated(file)) throw new UnusableImage("animated");
-
-  let bitmap: ImageBitmap;
-  try {
-    bitmap = await createImageBitmap(file);
-  } catch (e) {
-    logger.debug("Could not decode the chosen file", e);
-    throw new UnusableImage("undecodable");
-  }
-  try {
-    const scale = Math.min(
-      1,
-      maxStoredEdge / Math.max(bitmap.width, bitmap.height),
-    );
-    const canvas = new OffscreenCanvas(
-      Math.round(bitmap.width * scale),
-      Math.round(bitmap.height * scale),
-    );
-    const context = canvas.getContext("2d");
-    if (!context) throw new UnusableImage("undecodable");
-    context.fillStyle = "black";
-    context.fillRect(0, 0, canvas.width, canvas.height);
-    context.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
-    return await canvas.convertToBlob({ type: "image/webp", quality: 0.9 });
-  } finally {
-    bitmap.close();
-  }
-}
-
-// Read from the file, not its type: a still and an animated WebP share one.
-async function isAnimated(file: Blob): Promise<boolean> {
-  if (typeof ImageDecoder === "undefined") return /gif|apng/.test(file.type);
-  try {
-    const decoder = new ImageDecoder({
-      data: await file.arrayBuffer(),
-      type: file.type,
-    });
-    // Some browsers have no selected track until the tracks are ready.
-    await decoder.tracks.ready;
-    await decoder.completed;
-    return (decoder.tracks.selectedTrack?.frameCount ?? 1) > 1;
-  } catch (e) {
-    logger.debug("Could not read the frame count, judging by type", e);
-    return /gif|apng/.test(file.type);
-  }
-}
-
-const DB_NAME = "element-call-background-images";
-const STORE = "backgrounds";
-
-export class IndexedDBImageStorage implements BackgroundImageStorage {
-  private db?: Promise<IDBDatabase>;
-
-  public constructor(private readonly indexedDB: IDBFactory) {}
-
-  private async open(): Promise<IDBDatabase> {
-    return (this.db ??= new Promise((resolve, reject) => {
-      const request = this.indexedDB.open(DB_NAME, 1);
-      request.onupgradeneeded = (): void => {
-        request.result.createObjectStore(STORE, { keyPath: "id" });
-      };
-      request.onsuccess = (): void => resolve(request.result);
-      request.onerror = (): void => reject(request.error);
-    }));
-  }
-
-  private async run<T>(
-    mode: IDBTransactionMode,
-    body: (store: IDBObjectStore) => IDBRequest<T>,
-  ): Promise<T> {
-    const db = await this.open();
-    return new Promise((resolve, reject) => {
-      const request = body(db.transaction(STORE, mode).objectStore(STORE));
-      request.onsuccess = (): void => resolve(request.result);
-      request.onerror = (): void => reject(request.error);
-    });
-  }
-
-  public async list(): Promise<KeptImage[]> {
-    return this.run<KeptImage[]>("readonly", (s) => s.getAll());
-  }
-
-  public async put(image: KeptImage): Promise<void> {
-    await this.run("readwrite", (s) => s.put(image));
-  }
-
-  public async delete(id: string): Promise<void> {
-    await this.run("readwrite", (s) => s.delete(id));
-  }
-}
-
-function openStorage(): BackgroundImageStorage | null {
-  // Merely reading indexedDB throws where it is disabled.
-  try {
-    return globalThis.indexedDB
-      ? new IndexedDBImageStorage(globalThis.indexedDB)
-      : null;
-  } catch (e) {
-    logger.warn("Could not reach IndexedDB", e);
-    return null;
-  }
-}
-
-export const addedBackgrounds = new AddedBackgrounds(openStorage());

src/tracks/cameraTrack.ts

@@ -1,61 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { BehaviorSubject } from "rxjs";
-import { type LocalVideoMediaTrack } from "@element-hq/matrixrtc-sdk";
-
-import { type Behavior } from "../state/Behavior";
-
-/**
- * A camera that can be shown in a video element: the MatrixRTC SDK's track,
- * before joining and in the call alike.
- */
-export interface ShownCamera {
-  attach(element: HTMLVideoElement): void;
-  /** Detaches this element only: another may be showing the same camera. */
-  detach(element: HTMLVideoElement): void;
-  /** Whether it faces the user, so that it is shown mirrored. */
-  facesUser(): boolean;
-}
-
-// One per track, so that a view showing it isn't attached again on every render.
-const shown = new WeakMap<object, ShownCamera>();
-
-function shownOnce(track: object, make: () => ShownCamera): ShownCamera {
-  let camera = shown.get(track);
-  if (camera === undefined) {
-    camera = make();
-    shown.set(track, camera);
-  }
-  return camera;
-}
-
-/** A camera as the MatrixRTC SDK has it. */
-export function sdkCamera(track: LocalVideoMediaTrack): ShownCamera {
-  return shownOnce(track, () => ({
-    attach: (element): void => track.attach(element),
-    detach: (element): void => track.detach(element),
-    facesUser: (): boolean => track.facingMode$.value === "user",
-  }));
-}
-
-/**
- * The camera track a background pipeline is synced to: the lobby's before
- * joining, the call's after, none while the camera is off.
- */
-export class SyncedCameraTrack {
-  private readonly subject$ = new BehaviorSubject<ShownCamera | null>(null);
-  public readonly track$: Behavior<ShownCamera | null> = this.subject$;
-
-  public report(track: ShownCamera): () => void {
-    this.subject$.next(track);
-    // Only if still this one, so a lobby leaving doesn't blank a call starting.
-    return (): void => {
-      if (this.subject$.value === track) this.subject$.next(null);
-    };
-  }
-}

src/useAttachedTrack.test.tsx

@@ -1,53 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { type FC } from "react";
-import { render } from "@testing-library/react";
-import { describe, expect, it, vi } from "vitest";
-
-import { useAttachedTrack } from "./useAttachedTrack";
-import { type ShownCamera } from "./tracks/cameraTrack";
-
-function cameraTrack(facing: string): ShownCamera {
-  return {
-    attach: vi.fn(),
-    detach: vi.fn(),
-    facesUser: (): boolean => facing === "user",
-  };
-}
-
-const Video: FC<{ track: ShownCamera | null }> = ({ track }) => {
-  const { videoRef, mirrored } = useAttachedTrack(track);
-  return <video ref={videoRef} data-mirrored={mirrored} />;
-};
-
-describe("useAttachedTrack", () => {
-  it("detaches only its own element from a track shown twice", () => {
-    const track = cameraTrack("user");
-    const first = render(<Video track={track} />);
-    const second = render(<Video track={track} />);
-    const [a, b] = [first, second].map((r) =>
-      r.container.querySelector("video"),
-    );
-    expect(track.attach).toHaveBeenCalledWith(a);
-    expect(track.attach).toHaveBeenCalledWith(b);
-
-    first.unmount();
-    expect(track.detach).toHaveBeenCalledExactlyOnceWith(a);
-  });
-
-  it("mirrors a camera facing the user, and only that", () => {
-    const { container, rerender } = render(
-      <Video track={cameraTrack("user")} />,
-    );
-    expect(container.querySelector("video")?.dataset.mirrored).toBe("true");
-    rerender(<Video track={cameraTrack("environment")} />);
-    expect(container.querySelector("video")?.dataset.mirrored).toBe("false");
-    rerender(<Video track={null} />);
-    expect(container.querySelector("video")?.dataset.mirrored).toBe("false");
-  });
-});

src/useAttachedTrack.ts

@@ -1,31 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { type RefObject, useEffect, useRef } from "react";
-
-import { type ShownCamera } from "./tracks/cameraTrack";
-
-/**
- * Shows a camera in the video element given the returned ref, and says
- * whether to mirror it, as a camera facing the user is. Only that element is
- * detached again: another may be showing the same camera.
- */
-export function useAttachedTrack(camera: ShownCamera | null): {
-  videoRef: RefObject<HTMLVideoElement | null>;
-  mirrored: boolean;
-} {
-  const videoRef = useRef<HTMLVideoElement | null>(null);
-  useEffect(() => {
-    const element = videoRef.current;
-    if (!camera || !element) return;
-    camera.attach(element);
-    return (): void => {
-      camera.detach(element);
-    };
-  }, [camera]);
-  return { videoRef, mirrored: camera?.facesUser() ?? false };
-}

src/utils/initClient.test.ts

@@ -0,0 +1,214 @@
+/*
+Copyright 2026 Element Creations Ltd.
+
+SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE in the repository root for full details.
+*/
+
+import { EventEmitter } from "events";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  type Mock,
+  vi,
+} from "vitest";
+import {
+  ClientEvent,
+  createClient,
+  type ICreateClientOpts,
+  IndexedDBStore,
+  MemoryStore,
+} from "matrix-js-sdk";
+import type * as MatrixSdk from "matrix-js-sdk";
+
+import { initClient } from "./initClient";
+import { flushPromises } from "./test";
+
+interface Store {
+  startup: Mock<() => Promise<void>>;
+  getSavedSyncToken: Mock<() => Promise<string | null>>;
+}
+
+const store = (): Store => ({
+  startup: vi.fn<() => Promise<void>>().mockResolvedValue(undefined),
+  getSavedSyncToken: vi
+    .fn<() => Promise<string | null>>()
+    .mockResolvedValue(null),
+});
+
+// The client is the SDK's business; what these tests are about is how it is
+// set up: its stores, its crypto, and when it counts as ready.
+vi.mock("matrix-js-sdk", async (importOriginal) => ({
+  ...(await importOriginal<typeof MatrixSdk>()),
+  createClient: vi.fn(),
+  IndexedDBStore: vi.fn(function (this: Store) {
+    Object.assign(this, store());
+  }),
+  MemoryStore: vi.fn(function (this: Store) {
+    Object.assign(this, store());
+  }),
+}));
+
+interface FakeClient extends EventEmitter {
+  store: Store;
+  clearStores: Mock<() => Promise<void>>;
+  initRustCrypto: Mock<() => Promise<void>>;
+  startClient: Mock<() => Promise<void>>;
+}
+
+/**
+ * A client that, unless told otherwise, reports its first sync a tick after
+ * being started, as the real one does once the network answers.
+ */
+function fakeClient(opts: ICreateClientOpts, syncs = true): FakeClient {
+  const client = Object.assign(new EventEmitter(), {
+    store: opts.store as unknown as Store,
+    clearStores: vi.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    initRustCrypto: vi.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    startClient: vi.fn(async () => {
+      if (!syncs) return;
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      client.emit(ClientEvent.Sync, "PREPARED", null);
+    }),
+  });
+  return client;
+}
+
+const options: ICreateClientOpts = { baseUrl: "https://hs.example.org" };
+const clients = vi.mocked(createClient) as unknown as Mock<
+  (opts: ICreateClientOpts) => FakeClient
+>;
+const indexedDBStores = vi.mocked(IndexedDBStore);
+const memoryStores = vi.mocked(MemoryStore);
+
+describe("initClient", () => {
+  beforeEach(() => {
+    clients.mockImplementation((opts) => fakeClient(opts));
+  });
+  afterEach(() => {
+    vi.clearAllMocks();
+    vi.unstubAllGlobals();
+    vi.unstubAllEnvs();
+  });
+
+  it("hands back the client once its first sync is done", async () => {
+    const client = await initClient(options, true);
+
+    expect(client).toBe(clients.mock.results[0].value);
+    expect(client.startClient).toHaveBeenCalledWith({
+      clientWellKnownPollPeriod: 600,
+    });
+    expect(clients).toHaveBeenCalledWith(
+      expect.objectContaining({
+        baseUrl: "https://hs.example.org",
+        useAuthorizationHeader: true,
+        localTimeoutMs: 5000,
+      }),
+    );
+  });
+
+  it("keeps the stores when restoring a session", async () => {
+    const client = (await initClient(options, true)) as unknown as FakeClient;
+    expect(client.clearStores).not.toHaveBeenCalled();
+  });
+
+  it("clears the stores before starting them when not restoring", async () => {
+    const client = (await initClient(options, false)) as unknown as FakeClient;
+
+    expect(client.clearStores).toHaveBeenCalled();
+    expect(client.clearStores.mock.invocationCallOrder[0]).toBeLessThan(
+      client.store.startup.mock.invocationCallOrder[0],
+    );
+  });
+
+  it("syncs into memory where there is no IndexedDB", async () => {
+    // jsdom has no indexedDB
+    const client = await initClient(options, true);
+
+    expect(client.store).toBe(memoryStores.mock.instances[0]);
+    expect(indexedDBStores).not.toHaveBeenCalled();
+  });
+
+  it("syncs into IndexedDB through a worker, where it was bundled", async () => {
+    vi.stubGlobal("indexedDB", {});
+    vi.stubEnv("DEV", false);
+
+    const client = await initClient(options, true);
+
+    expect(client.store).toBe(indexedDBStores.mock.instances[0]);
+    const [storeOptions] = indexedDBStores.mock.calls[0];
+    expect(storeOptions.dbName).toBe("element-call-sync");
+    expect(storeOptions.workerFactory).toBeTypeOf("function");
+  });
+
+  it("syncs into IndexedDB without a worker in development", async () => {
+    vi.stubGlobal("indexedDB", {});
+    vi.stubEnv("DEV", true);
+
+    await initClient(options, true);
+
+    // The dev server does not bundle the worker
+    expect(indexedDBStores.mock.calls[0][0].workerFactory).toBeUndefined();
+  });
+
+  it("falls back to memory when the IndexedDB store cannot start", async () => {
+    vi.stubGlobal("indexedDB", {});
+    const failing = store();
+    failing.startup.mockRejectedValue(new Error("quota exceeded"));
+    indexedDBStores.mockImplementationOnce(function (this: IndexedDBStore) {
+      Object.assign(this, failing);
+    });
+
+    const client = await initClient(options, true);
+
+    expect(client.store).toBe(memoryStores.mock.instances[0]);
+    expect(client.store.startup).toHaveBeenCalled();
+  });
+
+  it("carries on without crypto when it cannot be initialised", async () => {
+    clients.mockImplementation((opts) => {
+      const client = fakeClient(opts);
+      client.initRustCrypto.mockRejectedValue(new Error("stores in use"));
+      return client;
+    });
+
+    await expect(initClient(options, true)).resolves.toBeDefined();
+  });
+
+  it("waits for a sync from the network, past one restored from the store", async () => {
+    let client!: FakeClient;
+    clients.mockImplementation((opts) => {
+      client = fakeClient(opts, false);
+      client.store.getSavedSyncToken.mockResolvedValue("saved");
+      return client;
+    });
+    let ready = false;
+    const result = initClient(options, true).then(() => (ready = true));
+    await flushPromises();
+
+    // The first sync the client reports is the one restored from the store
+    client.emit(ClientEvent.Sync, "PREPARED", null);
+    await flushPromises();
+    expect(ready).toBe(false);
+
+    client.emit(ClientEvent.Sync, "PREPARED", null);
+    await result;
+    expect(ready).toBe(true);
+  });
+
+  it("fails when the first sync does", async () => {
+    let client!: FakeClient;
+    clients.mockImplementation((opts) => (client = fakeClient(opts, false)));
+    const result = initClient(options, true);
+    await flushPromises();
+
+    client.emit(ClientEvent.Sync, "ERROR", null, {
+      error: new Error("offline"),
+    });
+
+    await expect(result).rejects.toThrow("offline");
+  });
+});

src/utils/initClient.ts

@@ -0,0 +1,170 @@
+/*
+Copyright 2022-2024 New Vector Ltd.
+Copyright 2026 Element Creations Ltd.
+
+SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE in the repository root for full details.
+*/
+
+import {
+  ClientEvent,
+  createClient,
+  type ICreateClientOpts,
+  IndexedDBStore,
+  type MatrixClient,
+  MemoryStore,
+} from "matrix-js-sdk";
+import { type ISyncStateData, type SyncState } from "matrix-js-sdk/lib/sync";
+import { logger } from "matrix-js-sdk/lib/logger";
+
+// This import is why `initClient` has a module of its own:
+// - The bundler emits the worker file (11 MB: the Matrix SDK and its crypto
+//   wasm) the moment it loads this import — whether or not anything ever calls
+//   `new IndexedDBWorker()`. Tree shaking drops the call, not the file.
+// - So it may only sit in a module the component build never loads. It used
+//   to be in `./matrix`, which the component reaches for the room URL helpers,
+//   and the worker shipped in the package, unused and unusable by any host.
+import IndexedDBWorker from "../IndexedDBWorker?worker";
+import { getUrlParams } from "../UrlParams";
+import { Config } from "../config/Config";
+import { fallbackICEServerAllowed } from "./matrix";
+
+const SYNC_STORE_NAME = "element-call-sync";
+
+/**
+ * Initialises and returns a new standalone Matrix Client.
+ * This can only be called safely if no other client is running
+ * otherwise rust crypto will throw since it is not ready to initialize a new session.
+ * If another client is running make sure `.logout()` is called before executing this function.
+ * @param clientOptions Object of options passed through to the client
+ * @param restore If the rust crypto should be reset before the client initialization or
+ * if the initialization should try to restore the crypto state from the indexDB.
+ * @returns The MatrixClient instance
+ */
+export async function initClient(
+  clientOptions: ICreateClientOpts,
+  restore: boolean,
+): Promise<MatrixClient> {
+  let indexedDB: IDBFactory | undefined;
+  try {
+    indexedDB = window.indexedDB;
+  } catch (e) {
+    logger.warn("Could not get indexDB from window.", e);
+  }
+
+  // options we always pass to the client (stuff that we need in order to work)
+  const baseOpts = {
+    fallbackICEServerAllowed: fallbackICEServerAllowed,
+    isVoipWithNoMediaAllowed:
+      Config.get().features?.feature_group_calls_without_video_and_audio,
+  } as ICreateClientOpts;
+
+  if (indexedDB && localStorage) {
+    baseOpts.store = new IndexedDBStore({
+      indexedDB: window.indexedDB,
+      localStorage,
+      dbName: SYNC_STORE_NAME,
+      // We can't use the worker in dev mode because Vite simply doesn't bundle workers
+      // in dev mode: it expects them to use native modules. Ours don't, and even then only
+      // Chrome supports it. (It bundles them fine in production mode.)
+      workerFactory: import.meta.env.DEV
+        ? undefined
+        : (): Worker => new IndexedDBWorker(),
+    });
+  } else if (localStorage) {
+    baseOpts.store = new MemoryStore({ localStorage });
+  }
+
+  // XXX: we read from the URL params in RoomPage too:
+  // it would be much better to read them in one place and pass
+  // the values around, but we initialise the matrix client in
+  // many different places so we'd have to pass it into all of
+  // them.
+  const { e2eEnabled } = getUrlParams();
+  if (!e2eEnabled) {
+    logger.info("Disabling E2E: group call signalling will NOT be encrypted.");
+  }
+
+  const client = createClient({
+    ...baseOpts,
+    ...clientOptions,
+    useAuthorizationHeader: true,
+    // Use a relatively low timeout for API calls: this is a realtime app
+    // so we don't want API calls taking ages, we'd rather they just fail.
+    localTimeoutMs: 5000,
+    useE2eForGroupCall: e2eEnabled,
+    fallbackICEServerAllowed: fallbackICEServerAllowed,
+  });
+
+  // In case of logging in a new matrix account but there is still crypto local store. This is needed for:
+  // - We lost the auth tokens and cannot restore the client resulting in registering a new user.
+  // - We start the sign in flow but are registered with a guest user. (It should additionally log out the guest before)
+  // - A new account is created because of missing LocalStorage: "matrix-auth-store", but the crypto IndexDB is still available.
+  if (!restore) {
+    await client.clearStores();
+  }
+
+  // Start client store.
+  // Note: The `client.store` is used to store things like sync results. It's independent of
+  // the cryptostore, and uses a separate indexeddb database.
+  try {
+    await client.store.startup();
+  } catch (error) {
+    logger.error(
+      "Error starting matrix client indexDB store. Falling back to memory store.",
+      error,
+    );
+    client.store = new MemoryStore({ localStorage });
+    await client.store.startup();
+  }
+
+  // Also creates and starts any crypto related stores.
+  try {
+    await client.initRustCrypto();
+  } catch (err) {
+    logger.warn(
+      err,
+      "Make sure to clear client stores before initializing the rust crypto.",
+    );
+  }
+
+  // Once startClient is called, syncs are run asynchronously.
+  // Also, sync completion is communicated only via events.
+  // So, apply the event listener *before* starting the client.
+  // Otherwise, a sync may complete before the listener gets applied,
+  // and we will miss it.
+  const syncPromise = waitForSync(client);
+  await client.startClient({ clientWellKnownPollPeriod: 60 * 10 });
+  await syncPromise;
+
+  return client;
+}
+
+async function waitForSync(client: MatrixClient): Promise<void> {
+  // If there is a saved sync, the client will fire an additional sync event
+  // for restoring it before it runs the first network sync.
+  // However, the sync we want to wait for is the network sync,
+  // as the saved sync may be missing some state.
+  // Thus, don't resolve on the first sync when we know it's for the saved sync.
+  let waitForSavedSync = !!(await client.store.getSavedSyncToken());
+  return new Promise<void>((resolve, reject) => {
+    const onSync = (
+      state: SyncState,
+      _old: SyncState | null,
+      data?: ISyncStateData,
+    ): void => {
+      if (state === "PREPARED") {
+        if (waitForSavedSync) {
+          waitForSavedSync = false;
+        } else {
+          client.removeListener(ClientEvent.Sync, onSync);
+          resolve();
+        }
+      } else if (state === "ERROR") {
+        client.removeListener(ClientEvent.Sync, onSync);
+        reject(data?.error);
+      }
+    };
+    client.on(ClientEvent.Sync, onSync);
+  });
+}

src/utils/matrix.ts

@@ -5,21 +5,12 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import {
-  ClientEvent,
-  createClient,
-  IndexedDBStore,
-  MemoryStore,
-  Preset,
-  Visibility,
-} from "matrix-js-sdk";
-import { type ISyncStateData, type SyncState } from "matrix-js-sdk/lib/sync";
+import { ClientEvent, Preset, Visibility } from "matrix-js-sdk";
 import { logger } from "matrix-js-sdk/lib/logger";
 import { secureRandomBase64Url } from "matrix-js-sdk/lib/randomstring";
 
-import type { ICreateClientOpts, MatrixClient, Room } from "matrix-js-sdk";
-import IndexedDBWorker from "../IndexedDBWorker?worker";
-import { generateUrlSearchParams, getUrlParams } from "../UrlParams";
+import type { MatrixClient, Room } from "matrix-js-sdk";
+import { generateUrlSearchParams } from "../UrlParams";
 import { Config } from "../config/Config";
 import { E2eeType } from "../e2ee/e2eeType";
 import {
@@ -27,149 +18,14 @@ import {
   saveKeyForRoom,
 } from "../e2ee/sharedKeyManagement";
 
+// Shared with the component, which reaches this module for the room URLs. So
+// nothing in here may import the client store worker: the bundler emits the
+// worker file on loading the import, used or not. The one function that needs
+// it, `initClient`, lives in `./initClient` for that reason.
+
 export const fallbackICEServerAllowed =
   import.meta.env.VITE_FALLBACK_STUN_ALLOWED === "true";
 
-const SYNC_STORE_NAME = "element-call-sync";
-
-async function waitForSync(client: MatrixClient): Promise<void> {
-  // If there is a saved sync, the client will fire an additional sync event
-  // for restoring it before it runs the first network sync.
-  // However, the sync we want to wait for is the network sync,
-  // as the saved sync may be missing some state.
-  // Thus, don't resolve on the first sync when we know it's for the saved sync.
-  let waitForSavedSync = !!(await client.store.getSavedSyncToken());
-  return new Promise<void>((resolve, reject) => {
-    const onSync = (
-      state: SyncState,
-      _old: SyncState | null,
-      data?: ISyncStateData,
-    ): void => {
-      if (state === "PREPARED") {
-        if (waitForSavedSync) {
-          waitForSavedSync = false;
-        } else {
-          client.removeListener(ClientEvent.Sync, onSync);
-          resolve();
-        }
-      } else if (state === "ERROR") {
-        client.removeListener(ClientEvent.Sync, onSync);
-        reject(data?.error);
-      }
-    };
-    client.on(ClientEvent.Sync, onSync);
-  });
-}
-
-/**
- * Initialises and returns a new standalone Matrix Client.
- * This can only be called safely if no other client is running
- * otherwise rust crypto will throw since it is not ready to initialize a new session.
- * If another client is running make sure `.logout()` is called before executing this function.
- * @param clientOptions Object of options passed through to the client
- * @param restore If the rust crypto should be reset before the client initialization or
- * if the initialization should try to restore the crypto state from the indexDB.
- * @returns The MatrixClient instance
- */
-export async function initClient(
-  clientOptions: ICreateClientOpts,
-  restore: boolean,
-): Promise<MatrixClient> {
-  let indexedDB: IDBFactory | undefined;
-  try {
-    indexedDB = window.indexedDB;
-  } catch (e) {
-    logger.warn("Could not get indexDB from window.", e);
-  }
-
-  // options we always pass to the client (stuff that we need in order to work)
-  const baseOpts = {
-    fallbackICEServerAllowed: fallbackICEServerAllowed,
-    isVoipWithNoMediaAllowed:
-      Config.get().features?.feature_group_calls_without_video_and_audio,
-  } as ICreateClientOpts;
-
-  if (indexedDB && localStorage) {
-    baseOpts.store = new IndexedDBStore({
-      indexedDB: window.indexedDB,
-      localStorage,
-      dbName: SYNC_STORE_NAME,
-      // We can't use the worker in dev mode because Vite simply doesn't bundle workers
-      // in dev mode: it expects them to use native modules. Ours don't, and even then only
-      // Chrome supports it. (It bundles them fine in production mode.)
-      workerFactory: import.meta.env.DEV
-        ? undefined
-        : (): Worker => new IndexedDBWorker(),
-    });
-  } else if (localStorage) {
-    baseOpts.store = new MemoryStore({ localStorage });
-  }
-
-  // XXX: we read from the URL params in RoomPage too:
-  // it would be much better to read them in one place and pass
-  // the values around, but we initialise the matrix client in
-  // many different places so we'd have to pass it into all of
-  // them.
-  const { e2eEnabled } = getUrlParams();
-  if (!e2eEnabled) {
-    logger.info("Disabling E2E: group call signalling will NOT be encrypted.");
-  }
-
-  const client = createClient({
-    ...baseOpts,
-    ...clientOptions,
-    useAuthorizationHeader: true,
-    // Use a relatively low timeout for API calls: this is a realtime app
-    // so we don't want API calls taking ages, we'd rather they just fail.
-    localTimeoutMs: 5000,
-    useE2eForGroupCall: e2eEnabled,
-    fallbackICEServerAllowed: fallbackICEServerAllowed,
-  });
-
-  // In case of logging in a new matrix account but there is still crypto local store. This is needed for:
-  // - We lost the auth tokens and cannot restore the client resulting in registering a new user.
-  // - We start the sign in flow but are registered with a guest user. (It should additionally log out the guest before)
-  // - A new account is created because of missing LocalStorage: "matrix-auth-store", but the crypto IndexDB is still available.
-  if (!restore) {
-    await client.clearStores();
-  }
-
-  // Start client store.
-  // Note: The `client.store` is used to store things like sync results. It's independent of
-  // the cryptostore, and uses a separate indexeddb database.
-  try {
-    await client.store.startup();
-  } catch (error) {
-    logger.error(
-      "Error starting matrix client indexDB store. Falling back to memory store.",
-      error,
-    );
-    client.store = new MemoryStore({ localStorage });
-    await client.store.startup();
-  }
-
-  // Also creates and starts any crypto related stores.
-  try {
-    await client.initRustCrypto();
-  } catch (err) {
-    logger.warn(
-      err,
-      "Make sure to clear client stores before initializing the rust crypto.",
-    );
-  }
-
-  // Once startClient is called, syncs are run asynchronously.
-  // Also, sync completion is communicated only via events.
-  // So, apply the event listener *before* starting the client.
-  // Otherwise, a sync may complete before the listener gets applied,
-  // and we will miss it.
-  const syncPromise = waitForSync(client);
-  await client.startClient({ clientWellKnownPollPeriod: 60 * 10 });
-  await syncPromise;
-
-  return client;
-}
-
 export function roomAliasLocalpartFromRoomName(roomName: string): string {
   return roomName
     .trim()

src/utils/spa.test.ts

@@ -0,0 +1,83 @@
+/*
+Copyright 2026 Element Creations Ltd.
+
+SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE in the repository root for full details.
+*/
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { type MatrixClient, MatrixError } from "matrix-js-sdk";
+
+import { initClient } from "./initClient";
+import { initSPA } from "./spa";
+import { Config } from "../config/Config";
+import { type Session } from "../ClientContext";
+
+vi.mock("./initClient", () => ({ initClient: vi.fn() }));
+
+const session: Session = {
+  user_id: "@alice:example.org",
+  device_id: "AAAA",
+  access_token: "secret",
+  passwordlessUser: true,
+};
+const client = {} as MatrixClient;
+
+describe("initSPA", () => {
+  const clearSession = vi.fn();
+
+  beforeEach(() => {
+    vi.spyOn(Config, "defaultHomeserverUrl").mockReturnValue(
+      "https://hs.example.org",
+    );
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  });
+
+  it("continues without a client when no session is stored", async () => {
+    await expect(initSPA(() => undefined, clearSession)).resolves.toBeNull();
+
+    expect(initClient).not.toHaveBeenCalled();
+    expect(clearSession).not.toHaveBeenCalled();
+  });
+
+  it("restores the stored session into a client", async () => {
+    vi.mocked(initClient).mockResolvedValue(client);
+
+    await expect(initSPA(() => session, clearSession)).resolves.toEqual({
+      client,
+      passwordlessUser: true,
+    });
+
+    expect(initClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        baseUrl: "https://hs.example.org",
+        accessToken: "secret",
+        userId: "@alice:example.org",
+        deviceId: "AAAA",
+      }),
+      // Restoring: the crypto store is the session's, not to be wiped
+      true,
+    );
+  });
+
+  it("drops a session the homeserver no longer knows", async () => {
+    vi.mocked(initClient).mockRejectedValue(
+      new MatrixError({ errcode: "M_UNKNOWN_TOKEN", error: "Unknown token" }),
+    );
+
+    await expect(initSPA(() => session, clearSession)).resolves.toBeNull();
+    expect(clearSession).toHaveBeenCalled();
+  });
+
+  it("drops the session and fails on any other error", async () => {
+    vi.mocked(initClient).mockRejectedValue(new Error("offline"));
+
+    await expect(initSPA(() => session, clearSession)).rejects.toThrow(
+      "offline",
+    );
+    expect(clearSession).toHaveBeenCalled();
+  });
+});

src/utils/spa.ts

@@ -9,7 +9,8 @@ import { type ICreateClientOpts, MatrixError } from "matrix-js-sdk";
 import { logger } from "matrix-js-sdk/lib/logger";
 
 import { Config } from "../config/Config";
-import { fallbackICEServerAllowed, initClient } from "./matrix";
+import { fallbackICEServerAllowed } from "./matrix";
+import { initClient } from "./initClient";
 import type { InitResult, Session } from "../ClientContext";
 
 export async function initSPA(

src/utils/test-viewmodel.ts

@@ -217,7 +217,7 @@ export function getBasicCallViewModelEnvironment(
     vm,
     muteStates,
     mediaDevices,
-    constant({ supported: false, processor: undefined }),
+    constant(false),
     "reactionId",
     { showControls: true, header: HeaderStyle.Standard },
   );