Remove hard-coded video tile count from end-to-end tests

By keying the connections by the transport's resolved auth flow. This is important because connecting to the same SFU twice with the same participant ID will cause a 'duplicate participant ID' error that stops one of the connections.

component/build/scopeStylesToRoot.test.ts

@@ -109,12 +109,4 @@ describe("scopeStylesToRoot", () => {
       ".a .b_abc12:hover { border: 0 }",
     );
   });
-
-  it("leaves an excluded stylesheet as it is", async () => {
-    const css = "body { margin: 0 } .menu { color: red }";
-    const result = await postcss([
-      scopeStylesToRoot({ exclude: [/host\.css$/] }),
-    ]).process(css, { from: "/app/host.css" });
-    expect(result.css).toBe(css);
-  });
 });

component/build/scopeStylesToRoot.ts

@@ -60,18 +60,12 @@ const IS_ROOT = `:where(${ROOT_SELECTOR})`;
  * tokens, the component styles, the fonts — is not in this build at all: the
  * host supplies it, unscoped, along with its copy of Compound.
  */
-interface Options {
-  /** Stylesheets left as they are: a host's own, which it doesn't scope. */
-  exclude?: RegExp[];
-}
-
-export function scopeStylesToRoot({ exclude = [] }: Options = {}): Plugin {
+export function scopeStylesToRoot(): Plugin {
   return {
     postcssPlugin: "element-call-scope-styles-to-root",
     Once(root) {
-      const file = root.source?.input.file ?? "";
-      if (exclude.some((pattern) => pattern.test(file))) return;
-      const isModule = file.endsWith(".module.css");
+      const isModule =
+        root.source?.input.file?.endsWith(".module.css") ?? false;
       root.walkRules((rule) => {
         if (isRelative(rule)) return;
         rule.selector = (isModule ? scopeBare : scopeAll).processSync(

component/index.tsx

@@ -72,9 +72,9 @@ import {
   useUrlParams,
 } from "../src/UrlParams";
 import { MediaDevicesContext } from "../src/MediaDevicesContext";
-import { AppViewModel } from "../src/state/AppViewModel";
+import { MediaDevices } from "../src/state/MediaDevices";
 import { ObservableScope } from "../src/state/ObservableScope";
-import { BackgroundEffectsProvider } from "../src/tracks/BackgroundEffectsContext";
+import { ProcessorProvider } from "../src/tracks/TrackProcessorContext";
 import { Config } from "../src/config/Config";
 import { type ConfigOptions } from "../src/config/ConfigOptions";
 import { i18n } from "../src/utils/i18n";
@@ -194,12 +194,14 @@ export const ElementCall: FC<ElementCallProps> = ({
   // observers running for the rest of the page's life. Null until then, which
   // is one render.
   const { controlledAudioDevices, callIntent } = params;
-  const [vm, setVm] = useState<AppViewModel | null>(null);
+  const [mediaDevices, setMediaDevices] = useState<MediaDevices | null>(null);
   useEffect(() => {
     const scope = new ObservableScope();
-    setVm(new AppViewModel(scope, { controlledAudioDevices, callIntent }));
+    setMediaDevices(
+      new MediaDevices(scope, { controlledAudioDevices, callIntent }),
+    );
     return (): void => {
-      setVm(null);
+      setMediaDevices(null);
       scope.end();
     };
   }, [controlledAudioDevices, callIntent]);
@@ -220,7 +222,8 @@ export const ElementCall: FC<ElementCallProps> = ({
   // is told that Element Call has loaded, as the widget tells its client once
   // its own initialisation is over. Once per mount, however often the pieces
   // are later swapped out.
-  const ready = container !== null && rtcSession !== null && vm !== null;
+  const ready =
+    container !== null && rtcSession !== null && mediaDevices !== null;
   const announcedLoaded = useRef(false);
   useEffect(() => {
     if (!ready || announcedLoaded.current) return;
@@ -251,10 +254,8 @@ export const ElementCall: FC<ElementCallProps> = ({
                       <Decoration>
                         <TooltipProvider>
                           <ClientProvider client={client}>
-                            <MediaDevicesContext value={vm.mediaDevices}>
-                              <BackgroundEffectsProvider
-                                effects={vm.backgroundEffects}
-                              >
+                            <MediaDevicesContext value={mediaDevices}>
+                              <ProcessorProvider>
                                 <CallView
                                   client={client}
                                   rtcSession={rtcSession}
@@ -263,7 +264,7 @@ export const ElementCall: FC<ElementCallProps> = ({
                                   preload={params.preload}
                                   skipLobby={params.skipLobby}
                                 />
-                              </BackgroundEffectsProvider>
+                              </ProcessorProvider>
                             </MediaDevicesContext>
                           </ClientProvider>
                         </TooltipProvider>

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:79e47d8d5a93848403cb83042a405d8ed233a7727c499fa53b4b39a80f090be4
+    image: ghcr.io/element-hq/element-web:develop@sha256:ee8ce55012dda2c097147859aece32802ce7a9174e40c3711c56f75ccfe1b169
   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:79e47d8d5a93848403cb83042a405d8ed233a7727c499fa53b4b39a80f090be4
+    image: ghcr.io/element-hq/element-web:develop@sha256:ee8ce55012dda2c097147859aece32802ce7a9174e40c3711c56f75ccfe1b169

locales/en/app.json

@@ -3,6 +3,7 @@
     "user_menu": "User menu"
   },
   "action": {
+    "blur_background": "Blur background",
     "close": "Close",
     "copy_link": "Copy link",
     "edit": "Edit",
@@ -22,13 +23,6 @@
     "upload_file": "Upload file"
   },
   "analytics_notice": "By participating in this beta, you consent to the collection of anonymous data, which we use to improve the product. You can find more information about which data we track in our <2>Privacy Policy</2> and our <6>Cookie Policy</6>.",
-  "background_effects": {
-    "blur": "Blur",
-    "none": "None",
-    "numbered": "Background {{n}}",
-    "slow": "Background effects run slowly on this platform, which may cause your video to stutter.",
-    "unavailable": "Background effects are not supported on this platform."
-  },
   "call_ended_view": {
     "create_account_button": "Create account",
     "create_account_prompt": "<0>Why not finish by setting up a password to keep your account?</0><1>You'll be able to keep your name and set an avatar for use on future calls</1>",
@@ -218,7 +212,6 @@
     "auto_gain_control_label": "Automatic gain control",
     "background_blur_header": "Background",
     "background_blur_label": "Blur the background of the video",
-    "background_effects_header": "Background effects",
     "bitrate_label": "Bitrate",
     "blur_not_supported_by_browser": "(Background blur is not supported by this device.)",
     "camera_header": "Camera quality",

package.json

@@ -87,7 +87,7 @@
     "@types/sdp-transform": "^2.4.5",
     "@typescript-eslint/utils": "^8.61.0",
     "@use-gesture/react": "^10.2.11",
-    "@vector-im/compound-design-tokens": "^11.1.0",
+    "@vector-im/compound-design-tokens": "^11.0.0",
     "@vector-im/compound-web": "^10.4.0",
     "@vitejs/plugin-react": "^6.0.2",
     "@vitest/browser-playwright": "^4.1.5",

playwright/background-effects.spec.ts

@@ -1,126 +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, type Locator, type Page } from "@playwright/test";
-
-import { SpaHelpers } from "./spa-helpers.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",
-);
-
-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 averageColour(preview);
-
-    await page.getByRole("button", { name: "Camera", exact: true }).click();
-    const tile = page
-      .getByRole("group", { name: "Background effects" })
-      .getByRole("menuitemradio", { name: "Background 1" });
-    await tile.click();
-    await expect(tile).toHaveAttribute("aria-checked", "true");
-
-    // The fake camera shows no person, so the whole frame is background: the
-    // preview takes on the picture's colours and leaves the camera's.
-    const picture = await averageColour(tile.locator("img"));
-    // 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);
-  });
-});
-
-test.describe("no effect", () => {
-  test("draws nothing, even after blurring", async ({ page }) => {
-    test.setTimeout(120_000);
-    await countDraws(page);
-    await page.goto("/");
-    await SpaHelpers.createCall(page, "Idle user", "No effect after blur");
-
-    await page.getByRole("button", { name: "Camera", exact: true }).click();
-    const effects = page.getByRole("group", { name: "Background effects" });
-    await effects.getByRole("menuitemradio", { name: "Blur" }).click();
-    // Long enough for the first effect of a session to be built.
-    await expect
-      .poll(async () => drawsPerSecond(page), { timeout: 60_000 })
-      .toBeGreaterThan(0);
-    const blurred = await drawsPerSecond(page);
-
-    await effects.getByRole("menuitemradio", { name: "None" }).click();
-    // A frame already on its way may still be drawn.
-    await expect.poll(async () => drawsPerSecond(page)).toBe(0);
-    test.info().annotations.push({
-      type: "WebGL draws per second",
-      description: `blurred ${blurred}, none 0`,
-    });
-  });
-});
-
-/** Counts every WebGL draw on the page, the segmenter's and the effect's. */
-async function countDraws(page: Page): Promise<void> {
-  await page.addInitScript(() => {
-    const counter = { draws: 0 };
-    (window as unknown as { webglDraws: typeof counter }).webglDraws = counter;
-    for (const name of ["drawArrays", "drawElements"] as const) {
-      const draw = WebGL2RenderingContext.prototype[name] as (
-        ...args: unknown[]
-      ) => void;
-      WebGL2RenderingContext.prototype[name] = function (
-        this: WebGL2RenderingContext,
-        ...args: unknown[]
-      ): void {
-        counter.draws += 1;
-        draw.apply(this, args);
-      } as never;
-    }
-  });
-}
-
-/** WebGL draws over the next second. */
-async function drawsPerSecond(page: Page): Promise<number> {
-  return page.evaluate(async () => {
-    const counter = (window as unknown as { webglDraws: { draws: number } })
-      .webglDraws;
-    const before = counter.draws;
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    return counter.draws - before;
-  });
-}
-
-/** 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 = 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/component-call.spec.ts

@@ -125,19 +125,25 @@ test("leaves the host's own page unstyled", async ({ page }) => {
     timeout: 60_000,
   });
 
-  // Compound's document styles reach the host, but it loads them itself.
+  // Element Call's stylesheet is written for a page of its own: normalize.css
+  // gives `html` a line height, Compound gives `body` its font and feature
+  // settings, and the design tokens live on `:root`. None of that may reach the
+  // host's document — the harness sets none of these itself, so anything other
+  // than the browser's defaults here came from us.
   const host = await page.evaluate(() => {
-    const sub = document.body.appendChild(document.createElement("sub"));
-    const verticalAlign = getComputedStyle(sub).verticalAlign;
-    sub.remove();
+    const html = getComputedStyle(document.documentElement);
+    const body = getComputedStyle(document.body);
     return {
-      verticalAlign,
-      token: getComputedStyle(document.documentElement).getPropertyValue(
-        "--font-scale",
-      ),
+      lineHeight: html.lineHeight,
+      fontFeatureSettings: body.fontFeatureSettings,
+      token: html.getPropertyValue("--cpd-color-text-primary"),
     };
   });
-  expect(host).toEqual({ verticalAlign: "sub", token: "" });
+  expect(host).toEqual({
+    lineHeight: "normal",
+    fontFeatureSettings: "normal",
+    token: "",
+  });
 
   // While inside the container, the same rules do apply
   const root = panes.first().locator("[data-element-call-root]");

playwright/spa-helpers.ts

@@ -133,7 +133,7 @@ async function disableLeaveDelegation(page: Page): Promise<void> {
  * Expect a certain number of video tiles to be present and visible.
  */
 async function expectVideoTilesCount(page: Page, count: number): Promise<void> {
-  await expect(page.getByTestId("videoTile")).toHaveCount(2);
+  await expect(page.getByTestId("videoTile")).toHaveCount(count);
 
   // No one should be waiting for media
   await expect(page.getByText("Waiting for media...")).not.toBeVisible({

playwright/url-transport.spec.ts

@@ -31,7 +31,11 @@ interface Transport {
  */
 const shapes = {
   url: { type: "livekit", url: sfuUrl },
-  both: { type: "livekit", url: sfuUrl, livekit_service_url: serviceUrl },
+  "url+legacy": {
+    type: "livekit",
+    url: sfuUrl,
+    livekit_service_url: serviceUrl,
+  },
   legacy: null,
 } satisfies Record<string, Transport | null>;
 type Shape = keyof typeof shapes;
@@ -56,15 +60,15 @@ const cases: {
   {
     // Publishers keep the legacy participant identity that clients predating
     // MSC4195 expect, which only the JWT service assigns.
-    hostShape: "both",
-    guestShape: "both",
+    hostShape: "url+legacy",
+    guestShape: "url+legacy",
     hostFlows: ["service-legacy"],
     guestFlows: ["service-legacy"],
   },
   {
     // The MatrixRTC mode has no bearing on the choice.
-    hostShape: "both",
-    guestShape: "both",
+    hostShape: "url+legacy",
+    guestShape: "url+legacy",
     mode: "2_0",
     hostFlows: ["service-legacy"],
     guestFlows: ["service-legacy"],
@@ -75,6 +79,12 @@ const cases: {
     hostFlows: ["cs-api", "service-default"],
     guestFlows: ["service-legacy", "cs-api"],
   },
+  {
+    hostShape: "url",
+    guestShape: "url+legacy",
+    hostFlows: ["cs-api", "service-default"],
+    guestFlows: ["service-legacy", "cs-api"],
+  },
 ];
 
 for (const { hostShape, guestShape, mode, hostFlows, guestFlows } of cases) {
@@ -126,47 +136,6 @@ for (const { hostShape, guestShape, mode, hostFlows, guestFlows } of cases) {
   });
 }
 
-test("Subscriber falls back to the JWT service when the homeserver lacks MSC4195", async ({
-  browser,
-  page,
-  browserName,
-}) => {
-  skipOnFirefox(browserName);
-
-  // The host starts the call with both transport shapes.
-  await advertiseTransport(page, shapes.both);
-  await page.goto("/");
-  await SpaHelpers.createCall(page, "Androl", "HelloCall", true);
-  const inviteLink = await SpaHelpers.getCallInviteLink(page);
-
-  // The guest joins but their C-S requests fail.
-  const guestContext = await browser.newContext({ reducedMotion: "reduce" });
-  const guestPage = await guestContext.newPage();
-  await rejectCsApiTokens(guestPage);
-  const guestRequests = recordAuthRequests(guestPage);
-  await SpaHelpers.joinCallFromInviteLink(guestPage, inviteLink, "Pevara");
-
-  // Wait for the call to connect and render.
-  await SpaHelpers.expectVideoTilesCount(page, 2);
-  await SpaHelpers.expectVideoTilesCount(guestPage, 2);
-
-  // The guest ran through all flows.
-  expect(flowsOf(guestRequests)).toEqual(
-    new Set<Flow>(["cs-api", "service-legacy", "service-default"]),
-  );
-
-  // The C-S token requests failed.
-  for (const request of guestRequests) {
-    expect(request.status).toBe(request.flow === "cs-api" ? 404 : 200);
-  }
-
-  // The C-S token requests preceeded the fallback request.
-  const flows = guestRequests.map((r) => r.flow);
-  expect(flows.indexOf("service-default")).toBeGreaterThan(
-    flows.indexOf("cs-api"),
-  );
-});
-
 test("Publisher shows an error when the homeserver lacks MSC4195", async ({
   page,
   browserName,
@@ -191,6 +160,37 @@ test("Publisher shows an error when the homeserver lacks MSC4195", async ({
   ).toBeVisible();
 });
 
+test("Group call with all possible transport shapes at once", async ({
+  browser,
+  page,
+  browserName,
+}) => {
+  skipOnFirefox(browserName);
+
+  // The host starts the call with a url transport.
+  await advertiseTransport(page, shapes.url);
+  await page.goto("/");
+  await SpaHelpers.createCall(page, "Alice", "HelloCall", true);
+  const inviteLink = await SpaHelpers.getCallInviteLink(page);
+
+  // The guest with a legacy transport joins.
+  const bobContext = await browser.newContext({ reducedMotion: "reduce" });
+  const bobPage = await bobContext.newPage();
+  await advertiseTransport(bobPage, shapes.legacy);
+  await SpaHelpers.joinCallFromInviteLink(bobPage, inviteLink, "Bob");
+
+  // The guest with a url+legacy transport joins.
+  const carolContext = await browser.newContext({ reducedMotion: "reduce" });
+  const carolPage = await carolContext.newPage();
+  await advertiseTransport(carolPage, shapes["url+legacy"]);
+  await SpaHelpers.joinCallFromInviteLink(carolPage, inviteLink, "Carol");
+
+  // Wait for the call to connect and render.
+  await SpaHelpers.expectVideoTilesCount(page, 3);
+  await SpaHelpers.expectVideoTilesCount(bobPage, 3);
+  await SpaHelpers.expectVideoTilesCount(carolPage, 3);
+});
+
 /**
  * Delegation follows the flow that authenticated the publisher: the homeserver
  * for a `url`-only transport, the JWT service wherever there is one.
@@ -198,7 +198,7 @@ test("Publisher shows an error when the homeserver lacks MSC4195", async ({
 const delegationCases: { shape: Shape; via: Delegation["via"] }[] = [
   { shape: "url", via: "homeserver" },
   { shape: "legacy", via: "service" },
-  { shape: "both", via: "service" },
+  { shape: "url+legacy", via: "service" },
 ];
 
 for (const { shape, via } of delegationCases) {

playwright/widget/url-transport.test.ts

@@ -11,13 +11,12 @@ import { widgetTest } from "../fixtures/widget-user.ts";
 import { HOST1, TestHelpers } from "./test-helpers.ts";
 
 const sfuUrl = "wss://matrix-rtc.m.localhost/livekit/sfu";
-const serviceUrl = "https://matrix-rtc.m.localhost/livekit/jwt";
 
 /** Which endpoint a page asks for its SFU tokens. */
 type Flow = "cs-api" | "service-legacy" | "service-default";
 
 widgetTest(
-  "Call between a url + livekit_service_url transport and a legacy one",
+  "Call between a url transport and a legacy one",
   async ({ addUser, browserName }) => {
     test.skip(
       browserName === "firefox",
@@ -30,12 +29,10 @@ widgetTest(
       addUser("Pevara", HOST1),
     ]);
 
-    // The host's homeserver has started advertising a `url` next to its JWT
-    // service; the guest's still advertises the JWT service alone.
+    // Host advertises a url transport, guest still advertises a legacy one
     await advertiseTransport(host.page, {
       type: "livekit",
       url: sfuUrl,
-      livekit_service_url: serviceUrl,
     });
     // Element Web answers the widget from a cache it filled at login, so make
     // it fetch the transports again now that they are rerouted
@@ -67,7 +64,7 @@ widgetTest(
     }
 
     // Element Web used for Playwright does support MSC4195 for widgets.
-    expect(hostFlows).toEqual(new Set(["service-legacy", "service-default"]));
+    expect(hostFlows).toEqual(new Set(["cs-api", "service-default"]));
     expect(guestFlows).toEqual(new Set(["service-legacy", "cs-api"]));
   },
 );

pnpm-lock.yaml

@@ -131,7 +131,7 @@ importers:
         specifier: ^10.2.11
         version: 10.3.1(react@19.2.8)
       '@vector-im/compound-design-tokens':
-        specifier: ^11.1.0
+        specifier: ^11.0.0
         version: 11.3.1(@types/react@19.2.18)(react@19.2.8)
       '@vector-im/compound-web':
         specifier: ^10.4.0

sdk/src/media-backend/livekit/ConnectionMap.test.ts

@@ -24,7 +24,7 @@ import {
 import { type ConnectionFactory } from "./ConnectionFactory.ts";
 import { type Connection } from "./Connection.ts";
 import { ownMemberMock, withTestScheduler } from "../../utils/test";
-import { type Behavior } from "../../reactive/Behavior";
+import { constant, type Behavior } from "../../reactive/Behavior";
 import { type TransportLocator } from "./auth";
 
 const TRANSPORT_1: TransportLocator = {
@@ -207,7 +207,7 @@ describe("connections$ stream", () => {
     });
   });
 
-  test("Keeps one connection per homeserver for transports with a url", () => {
+  test("Keeps one connection per homeserver for url transports", () => {
     withTestScheduler(({ behavior, expectObservable }) => {
       const urlTransport: TransportLocator = {
         transport: { type: "livekit", url: "wss://sfu.example.org" },
@@ -243,6 +243,94 @@ describe("connections$ stream", () => {
     });
   });
 
+  test("Shares connection between local livekit_service_url transport and remote url + livekit_service_url transport", () => {
+    withTestScheduler(({ behavior, expectObservable, scope }) => {
+      const serviceUrlTransport: TransportLocator = {
+        transport: {
+          type: "livekit",
+          livekit_service_url: "https://jwt.example.org",
+        },
+        serverName: "example.org",
+      };
+      const urlAndServiceUrlTransport: TransportLocator = {
+        transport: {
+          type: "livekit",
+          livekit_service_url: "https://jwt.example.org",
+          url: "wss://sfu.elsewhere.org",
+        },
+        // Should pass even if local server != remote server
+        serverName: "elsewhere.org",
+      };
+      const connectionMap$ = createConnectionMap$({
+        scope,
+        connectionFactory: fakeConnectionFactory,
+        localTransport: serviceUrlTransport,
+        remoteTransports$: constant(new Epoch([urlAndServiceUrlTransport])),
+        logger,
+        ownMembershipIdentity: ownMemberMock,
+      });
+
+      expectObservable(
+        connectionMap$.pipe(mapEpoch((d) => d.getConnections())),
+      ).toBe("a", {
+        a: expect.toSatisfy(({ value: cs }: Epoch<Connection[]>) => {
+          // One connection total, since local and remote connections are shared
+          expect(cs.length).toBe(1);
+          expect(findConnection(serviceUrlTransport, cs)).toBeDefined();
+          expect(findConnection(serviceUrlTransport, cs)).toBe(
+            findConnection(urlAndServiceUrlTransport, cs),
+          );
+          return true;
+        }),
+      });
+    });
+  });
+
+  test("Shares connection between remote livekit_service_url transport and remote url + livekit_service_url transport", () => {
+    withTestScheduler(({ behavior, expectObservable, scope }) => {
+      const serviceUrlTransport: TransportLocator = {
+        transport: {
+          type: "livekit",
+          livekit_service_url: "https://jwt.example.org",
+        },
+        serverName: "example.org",
+      };
+      const urlAndServiceUrlTransport: TransportLocator = {
+        transport: {
+          type: "livekit",
+          livekit_service_url: "https://jwt.example.org",
+          url: "wss://sfu.elsewhere.org",
+        },
+        // Should pass even if local server != remote server
+        serverName: "elsewhere.org",
+      };
+      const connectionMap$ = createConnectionMap$({
+        scope,
+        connectionFactory: fakeConnectionFactory,
+        localTransport: TRANSPORT_2,
+        remoteTransports$: constant(
+          new Epoch([serviceUrlTransport, urlAndServiceUrlTransport]),
+        ),
+        logger,
+        ownMembershipIdentity: ownMemberMock,
+      });
+
+      expectObservable(
+        connectionMap$.pipe(mapEpoch((d) => d.getConnections())),
+      ).toBe("a", {
+        a: expect.toSatisfy(({ value: cs }: Epoch<Connection[]>) => {
+          // Two connections total: a local connection and a shared remote connection
+          expect(cs.length).toBe(2);
+          expect(findConnection(serviceUrlTransport, cs)).toBeDefined();
+          expect(findConnection(serviceUrlTransport, cs)).toBe(
+            findConnection(urlAndServiceUrlTransport, cs),
+          );
+          return true;
+        }),
+      });
+    });
+  });
+
   test("Should start connection only once", () => {
     withTestScheduler(({ behavior, expectObservable }) => {
       const connectionMap$ = createConnectionMap$({
@@ -344,7 +432,7 @@ describe("ConnectionMap", () => {
     data.add({ ...connection } as Connection, [p("b")]);
     expect(warn).toHaveBeenCalledWith(
       expect.stringContaining(
-        'second connection to [null,"https://lk.example.org",null]: existing [a], adding [b]',
+        'second connection to ["openID","https://lk.example.org"]: existing [a], adding [b]',
       ),
     );
     expect(data.getParticipantsForTransport(TRANSPORT_1)).toHaveLength(2);

sdk/src/media-backend/livekit/ConnectionMap.ts

@@ -18,7 +18,11 @@ import {
   type ObservableScope,
 } from "../../reactive/ObservableScope";
 import { generateItemsWithEpoch } from "../../reactive/observable";
-import { type ConnectionRole, type TransportLocator } from "./auth";
+import {
+  chooseAuthFlow,
+  type ConnectionRole,
+  type TransportLocator,
+} from "./auth";
 import { type Connection } from "./Connection";
 import { type ConnectionFactory } from "./ConnectionFactory";
 
@@ -26,22 +30,25 @@ import { type ConnectionFactory } from "./ConnectionFactory";
 export type TransportKey = string & { __transportKey: true };
 
 /**
- * The key a locator is identified by in a map or set. Locators with the same
- * key share a connection: the server name only takes part in authentication
- * for a transport with a `url`, where our homeserver asks that server for the
- * token. A JWT service is reached directly, so members of several homeservers
- * advertising the same one share a connection rather than each get their own.
+ * Converts a {@link TransportLocator} to a key suitable for identifying it in a
+ * map of connections.
  */
 export function keyFor({
   transport,
   serverName,
 }: TransportLocator): TransportKey {
-  const hasUrl = "url" in transport;
+  // Base the key on the auth flow we would use, so that we never create two
+  // connections that share the same auth details. (That would be bad, as we
+  // might then try to connect to the same SFU twice with the same participant
+  // ID, resulting in only one working connection.)
+  // TODO: This strategy will not work once `chooseAuthFlow` begins allowing for
+  // falling back from the CS API flow to the OpenID flow.
+  const flow = chooseAuthFlow(transport);
   // Serialize the fields in a consistent order
   return JSON.stringify([
-    hasUrl ? transport.url : null,
-    "livekit_service_url" in transport ? transport.livekit_service_url : null,
-    hasUrl ? serverName : null,
+    flow.kind,
+    // With the CS API flow, we additionally need to distinguish server names
+    ...(flow.kind === "csApi" ? [flow.url, serverName] : [flow.serviceUrl]),
   ]) as TransportKey;
 }
 

sdk/src/media-backend/livekit/LivekitBackend.ts

@@ -166,9 +166,8 @@ export function createLivekitBackend(
       );
       canDelegate = Promise.resolve(false);
     } else {
-      // Delegation goes through whichever service authenticates us as a
-      // publisher, so only that service's support counts
-      const flow = chooseAuthFlow(transport, "publisher");
+      // Check for support using the same auth flow that we intend to use later
+      const flow = chooseAuthFlow(transport);
       canDelegate =
         flow.kind === "openID"
           ? supportsDelegation(

sdk/src/media-backend/livekit/LivekitMediaTrack.ts

@@ -230,10 +230,9 @@ export function createLocalLivekitMediaTrack(
       const track = videoTrack();
       // A processor cannot be built on a track that has already ended
       if (!track || track.mediaStreamTrack.readyState === "ended") return;
-      if (processor) {
-        const adapter = convertToLivekitProcessor(processor);
-        if (track.getProcessor() !== adapter) await track.setProcessor(adapter);
-      } else if (track.getProcessor()) await track.stopProcessor();
+      if (processor)
+        await track.setProcessor(convertToLivekitProcessor(processor));
+      else if (track.getProcessor()) await track.stopProcessor();
     },
   };
 }

sdk/src/media-backend/livekit/Publisher.test.ts

@@ -18,10 +18,9 @@ import {
 import { logger } from "matrix-js-sdk/lib/logger";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-import { type PublishRequest, type VideoProcessor } from "../../media-api";
+import { type PublishRequest } from "../../media-api";
 import { flushPromises } from "../../utils/test";
 import { type DesiredMedia, Publisher } from "./Publisher";
-import { convertToLivekitProcessor } from "./videoProcessor";
 
 describe("Publisher", () => {
   describe("setAudioOutputDevice", () => {
@@ -120,24 +119,6 @@ describe("Publisher", () => {
       });
     });
 
-    it("creates both with the options of requests made since the join", async () => {
-      const processor: VideoProcessor = {
-        name: "effect",
-        init: vi.fn(),
-        restart: vi.fn(),
-        destroy: vi.fn(),
-      };
-      want(microphone, { source: "camera", deviceId: "front", processor });
-
-      publisher.start();
-      await flushPromises();
-
-      expect(room.options.videoCaptureDefaults).toMatchObject({
-        deviceId: "front",
-        processor: convertToLivekitProcessor(processor),
-      });
-    });
-
     it.each([
       { enabled: microphone, muted: camera, options: { audio: true } },
       { enabled: camera, muted: microphone, options: { video: true } },

sdk/src/media-backend/livekit/Publisher.ts

@@ -87,10 +87,8 @@ export class Publisher {
     // permission once; the room defaults carry their options. LiveKit
     // resolves these once the track is published, which may block on the
     // connection; LocalTrackPublished is what tells us a track exists.
-    if (sources.has("microphone") && sources.has("camera")) {
-      this.takeCaptureDefaults(requests);
+    if (sources.has("microphone") && sources.has("camera"))
       void this.room.localParticipant.enableCameraAndMicrophone();
-    }
     for (const request of requests)
       if (
         request.source === "screenShare" ||
@@ -101,27 +99,6 @@ export class Publisher {
         });
   }
 
-  /**
-   * Makes the requests the room's capture defaults. The room took its defaults
-   * from the requests at the join, but one made since, such as a camera turned
-   * on before the start, has options of its own: a video processor dropped
-   * here would let the room see the camera before it is applied.
-   */
-  private takeCaptureDefaults(requests: PublishRequest[]): void {
-    const options = this.room.options;
-    for (const request of requests)
-      if (request.source === "microphone")
-        options.audioCaptureDefaults = {
-          ...options.audioCaptureDefaults,
-          ...audioCaptureOptions(request),
-        };
-      else if (request.source === "camera")
-        options.videoCaptureDefaults = {
-          ...options.videoCaptureDefaults,
-          ...videoCaptureOptions(request),
-        };
-  }
-
   /** Publishes one request and resolves with its publication once LiveKit has it. */
   public async publish(
     request: PublishRequest,

sdk/src/media-backend/livekit/auth/index.test.ts

@@ -7,7 +7,7 @@ Please see LICENSE in the repository root for full details.
 
 import { afterEach, describe, expect, it, type Mocked, vi } from "vitest";
 import fetchMock from "fetch-mock";
-import { ConnectionError, MatrixError } from "matrix-js-sdk";
+import { MatrixError } from "matrix-js-sdk";
 import { logger } from "matrix-js-sdk/lib/logger";
 import { type UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
 import { type CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
@@ -144,26 +144,8 @@ describe("getSFUConfig", () => {
     expect(jwtServiceCalls()).toEqual(["/get_token"]);
   });
 
-  it("uses CS API when subscribing with url + livekit_service_url transport", async () => {
+  it("uses OpenID when subscribing with url + livekit_service_url transport", async () => {
     mockJWTService();
-    expect(
-      await getSFUConfig({
-        ...defaultParams,
-        transport: urlAndServiceUrlTransport,
-      }),
-    ).toEqual(
-      expect.objectContaining({
-        jwt: csApiJWTToken,
-        livekitAlias: "via CS API",
-      }),
-    );
-    expect(client._unstable_getLivekitToken).toHaveBeenCalled();
-    expect(jwtServiceCalls()).toEqual([]);
-  });
-
-  it("falls back to OpenID with url + livekit_service_url transport", async () => {
-    mockJWTService();
-    client._unstable_getLivekitToken.mockRejectedValueOnce(unsupportedError);
     expect(
       await getSFUConfig({
         ...defaultParams,
@@ -175,25 +157,7 @@ describe("getSFUConfig", () => {
         livekitAlias: "via default endpoint",
       }),
     );
-    expect(client._unstable_getLivekitToken).toHaveBeenCalled();
-    expect(jwtServiceCalls()).toEqual(["/get_token"]);
-  });
-
-  it("falls back to OpenID when the widget host refuses the CS API", async () => {
-    mockJWTService();
-    // In widget mode a host without MSC4533 rejects the request before it
-    // reaches the homeserver, with a plain error rather than a Matrix error
-    client._unstable_getLivekitToken.mockRejectedValueOnce(
-      new Error(
-        "The rtc_livekit_get_token action is not supported by the client.",
-      ),
-    );
-    expect(
-      await getSFUConfig({
-        ...defaultParams,
-        transport: urlAndServiceUrlTransport,
-      }),
-    ).toEqual(expect.objectContaining({ jwt: defaultJWTToken }));
+    expect(client._unstable_getLivekitToken).not.toHaveBeenCalled();
     expect(jwtServiceCalls()).toEqual(["/get_token"]);
   });
 
@@ -222,7 +186,7 @@ describe("getSFUConfig", () => {
     expect(jwtServiceCalls()).toEqual([]);
   });
 
-  it("does not fall back to OpenID when publishing", async () => {
+  it("does not fall back to OpenID when publishing with url transport", async () => {
     mockJWTService();
     client._unstable_getLivekitToken.mockRejectedValueOnce(unsupportedError);
     await expect(
@@ -255,33 +219,6 @@ describe("getSFUConfig", () => {
     expect(client._unstable_getLivekitToken).not.toHaveBeenCalled();
     expect(jwtServiceCalls()).toEqual(["/sfu/get"]);
   });
-
-  it("does not fall back to OpenID on connection error", async () => {
-    vi.useFakeTimers();
-    try {
-      mockJWTService();
-      const client_ = {
-        ...client,
-        _unstable_getLivekitToken: vi
-          .fn()
-          .mockRejectedValue(new ConnectionError("No connection")),
-      };
-      await Promise.all([
-        expect(
-          getSFUConfig({
-            ...defaultParams,
-            client: client_,
-            transport: urlAndServiceUrlTransport,
-          }),
-        ).rejects.toThrow(expect.any(ConnectionError)),
-        vi.runAllTimersAsync(), // Allow request to be retried
-      ]);
-      expect(client_._unstable_getLivekitToken).toHaveBeenCalled();
-      expect(jwtServiceCalls()).toEqual([]);
-    } finally {
-      vi.useRealTimers();
-    }
-  });
 });
 
 describe("delegateDelayedLeave", () => {
@@ -362,46 +299,21 @@ describe("delegateDelayedLeave", () => {
 
 describe("chooseAuthFlow", () => {
   it.each([
-    [
-      "url",
-      "publisher",
-      urlTransport,
-      { kind: "csApi", url: urlTransport.url },
-    ],
-    [
-      "url",
-      "subscriber",
-      urlTransport,
-      { kind: "csApi", url: urlTransport.url },
-    ],
+    ["url", urlTransport, { kind: "csApi", url: urlTransport.url }],
     [
       "livekit_service_url",
-      "publisher",
-      serviceUrlTransport,
-      { kind: "openID", serviceUrl },
-    ],
-    [
-      "livekit_service_url",
-      "subscriber",
       serviceUrlTransport,
       { kind: "openID", serviceUrl },
     ],
     [
       "url + livekit_service_url",
-      "publisher",
       urlAndServiceUrlTransport,
       { kind: "openID", serviceUrl },
     ],
-    [
-      "url + livekit_service_url",
-      "subscriber",
-      urlAndServiceUrlTransport,
-      { kind: "csApi", url: urlTransport.url },
-    ],
   ] as const)(
     "chooses the flow for a %s transport as %s",
-    (_shape, role, transport, flow) => {
-      expect(chooseAuthFlow(transport, role)).toEqual(flow);
+    (_shape, transport, flow) => {
+      expect(chooseAuthFlow(transport)).toEqual(flow);
     },
   );
 });

sdk/src/media-backend/livekit/auth/index.ts

@@ -65,7 +65,10 @@ export interface GetSFUConfigParams {
   logger: Logger;
 }
 
-/** Authenticates with a transport, through whichever flow suits it and our role. */
+/**
+ * Gets an {@link SFUConfig} appropriate for connecting to a given transport,
+ * using whichever auth flow is appropriate.
+ */
 export async function getSFUConfig({
   client,
   membership,
@@ -76,48 +79,36 @@ export async function getSFUConfig({
   role,
   logger,
 }: GetSFUConfigParams): Promise<SFUConfig> {
-  const viaOpenID = async (serviceUrl: string): Promise<SFUConfig> =>
-    await openID.getSFUConfig({
+  const flow = chooseAuthFlow(transport);
+  if (flow.kind === "openID") {
+    return await openID.getSFUConfig({
       client,
       membership,
-      serviceUrl,
+      serviceUrl: flow.serviceUrl,
       roomId,
       slotId,
       role,
       logger,
     });
-
-  const flow = chooseAuthFlow(transport, role);
-  if (flow.kind === "openID") return await viaOpenID(flow.serviceUrl);
-
-  try {
-    return await csApi.getSFUConfig({
-      client,
-      membership,
-      url: flow.url,
-      serverName,
-      roomId,
-      slotId,
-    });
-  } catch (e) {
-    // A publisher never falls back: a homeserver that advertises a `url` but
-    // does not implement MSC4195 is misconfigured, and the admin should hear
-    // about it before `livekit_service_url` is deprecated
-    const mayFallBack =
-      role === "subscriber" && "livekit_service_url" in transport;
-    if (mayFallBack && isCsApiUnavailable(e)) {
-      logger.warn(
-        `Cannot use the MSC4195 get_token endpoint (${e}), falling back to the OpenID flow with service ${transport.livekit_service_url}`,
-      );
-      return await viaOpenID(transport.livekit_service_url);
+  } else {
+    try {
+      return await csApi.getSFUConfig({
+        client,
+        membership,
+        url: flow.url,
+        serverName,
+        roomId,
+        slotId,
+      });
+    } catch (e) {
+      if (isEndpointUnsupported(e)) {
+        logger.error(
+          `Homeserver does not support the MSC4195 get_token endpoint, cannot get token for transport ${flow.url}`,
+        );
+        throw new NoMatrix2AuthorizationService(e as Error);
+      }
+      throw e;
     }
-    if (isEndpointUnsupported(e)) {
-      logger.error(
-        `Homeserver does not support the MSC4195 get_token endpoint, cannot get token for transport ${flow.url}`,
-      );
-      throw new NoMatrix2AuthorizationService(e as Error);
-    }
-    throw e;
   }
 }
 
@@ -149,7 +140,7 @@ export async function delegateDelayedLeave({
   delayTimeoutMs,
   logger,
 }: DelegateDelayedLeaveParams): Promise<void> {
-  const flow = chooseAuthFlow(transport, "publisher");
+  const flow = chooseAuthFlow(transport);
   if (flow.kind === "csApi") {
     try {
       await csApi.delegateDelayedLeave({
@@ -190,23 +181,18 @@ export type AuthFlow =
   | { kind: "openID"; serviceUrl: string };
 
 /**
- * Chooses between the MSC4195 client-server API and the OpenID flow against
- * the transport's JWT service.
- *
- * Only the JWT service's `/sfu/get` endpoint assigns the legacy participant
- * identity that clients predating MSC4195 expect from anyone advertising a
- * membership, so a publisher keeps using the JWT service wherever the
- * transport still offers one, even next to a `url`. A subscriber may use the
- * client-server API regardless, as nobody matches its identity.
+ * Chooses which auth flow to use for a given transport. For now this returns a
+ * single auth flow, with no provision for a fallback behavior.
  */
-export function chooseAuthFlow(
-  transport: UnstableLivekitTransport,
-  role: ConnectionRole,
-): AuthFlow {
-  if ("url" in transport) {
-    const useCsApi =
-      !("livekit_service_url" in transport) || role === "subscriber";
-    if (useCsApi) return { kind: "csApi", url: transport.url };
-  }
+export function chooseAuthFlow(transport: UnstableLivekitTransport): AuthFlow {
+  if ("url" in transport && !("livekit_service_url" in transport))
+    return { kind: "csApi", url: transport.url };
+  // All other transports use the OpenID flow, even if they contain a `url`.
+  // This is necessary since the auth flow determines the participant identity
+  // format, and we still have older clients out in the wild which would not yet
+  // know to look for a hashed participant identity in case `url` is present in
+  // someone else's transport.
+  // TODO: Once users have updated their clients, choose the CS API flow if
+  // available, keeping OpenID as a fallback.
   return { kind: "openID", serviceUrl: transport.livekit_service_url };
 }

sdk/src/media-backend/livekit/videoProcessor.test.ts

@@ -47,11 +47,4 @@ describe("convertToLivekitProcessor", () => {
     await adapter.destroy();
     expect(processor.destroy).toHaveBeenCalled();
   });
-
-  it("gives one processor one adapter", () => {
-    const processor = fakeProcessor();
-    expect(convertToLivekitProcessor(processor)).toBe(
-      convertToLivekitProcessor(processor),
-    );
-  });
 });

sdk/src/media-backend/livekit/videoProcessor.ts

@@ -9,24 +9,14 @@ import { type Track, type TrackProcessor } from "livekit-client";
 
 import { type VideoProcessor } from "../../media-api";
 
-const adapters = new WeakMap<
-  VideoProcessor,
-  TrackProcessor<Track.Kind.Video>
->();
-
 /**
  * A `VideoProcessor` as livekit-client wants it. LiveKit reads the processed
  * track off the processor after `init` and `restart` rather than taking it as
  * their result, so the adapter keeps it there.
- *
- * One adapter per processor, so a track can tell that it already runs one: a
- * processor set again would otherwise be torn down and built anew.
  */
 export function convertToLivekitProcessor(
   processor: VideoProcessor,
 ): TrackProcessor<Track.Kind.Video> {
-  const existing = adapters.get(processor);
-  if (existing) return existing;
   const adapter: TrackProcessor<Track.Kind.Video> = {
     name: processor.name,
     init: async (opts) => {
@@ -40,6 +30,5 @@ export function convertToLivekitProcessor(
     },
     destroy: async () => processor.destroy(),
   };
-  adapters.set(processor, adapter);
   return adapter;
 }

src/App.tsx

@@ -35,7 +35,7 @@ import { ErrorPage, LoadingPage } from "./FullScreenView";
 import { Initializer } from "./initializer";
 import { type WidgetHelpers } from "./widget";
 import { useTheme } from "./useTheme";
-import { BackgroundEffectsProvider } from "./tracks/BackgroundEffectsContext";
+import { ProcessorProvider } from "./tracks/TrackProcessorContext";
 import { type AppViewModel } from "./state/AppViewModel";
 import { MediaDevicesContext } from "./MediaDevicesContext";
 import {
@@ -148,7 +148,7 @@ export const App: FC<Props> = ({ vm, widget }) => {
     loaded && clientReady ? (
       <ClientProvider client={widgetClient}>
         <MediaDevicesContext value={vm.mediaDevices}>
-          <BackgroundEffectsProvider effects={vm.backgroundEffects}>
+          <ProcessorProvider>
             <Sentry.ErrorBoundary
               fallback={(error) => <ErrorPage error={error} />}
             >
@@ -159,7 +159,7 @@ export const App: FC<Props> = ({ vm, widget }) => {
                 <SentryRoute path="*" element={<RoomPage />} />
               </Routes>
             </Sentry.ErrorBoundary>
-          </BackgroundEffectsProvider>
+          </ProcessorProvider>
         </MediaDevicesContext>
       </ClientProvider>
     ) : (

src/components/BackgroundEffectGrid.module.css

@@ -1,92 +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.
-*/
-
-.grid {
-  display: grid;
-  /* A zero floor, so a long label wraps inside its tile rather than widening
-     the grid past the menu. */
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  grid-auto-rows: 1fr;
-  gap: var(--cpd-space-3x);
-  padding: var(--cpd-space-2x) var(--cpd-space-4x) 0;
-}
-
-/* Within the grid, to outweigh the menu item styles the tiles are built on. */
-.grid .tile {
-  position: relative;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  gap: var(--cpd-space-1x);
-  min-inline-size: 0;
-  padding: var(--cpd-space-3x) var(--cpd-space-2x);
-  /* Not hidden: that makes the tile a scroll container, which focus scrolls
-     into view without its border, and so without the focus ring. */
-  overflow: clip;
-  border: var(--cpd-border-width-2) solid
-    var(--cpd-color-border-interactive-secondary);
-  border-radius: var(--cpd-space-2x);
-  background: none;
-  color: var(--cpd-color-icon-secondary);
-  font: inherit;
-  cursor: pointer;
-}
-
-/* As the menu items highlight on hover. */
-.grid .tile[data-highlighted] {
-  background: var(--cpd-color-bg-action-secondary-hovered);
-}
-
-.grid .tile[aria-checked="true"] {
-  border-color: var(--cpd-color-border-accent);
-}
-
-.grid .tile[data-disabled] {
-  cursor: default;
-  opacity: 0.55;
-}
-
-.tile[data-disabled] .picture {
-  filter: grayscale(1);
-}
-
-.swatch {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-}
-
-.picture {
-  position: absolute;
-  inset: 0;
-  inline-size: 100%;
-  block-size: 100%;
-  object-fit: cover;
-}
-
-/* Positioned, or the picture, positioned itself, would cover it. */
-.mark {
-  position: relative;
-  display: inline-flex;
-  color: var(--cpd-color-icon-accent-primary);
-}
-
-/* On a picture the mark needs a ground of its own to be seen. */
-.picture ~ .mark {
-  border-radius: 50%;
-  background: var(--cpd-color-bg-canvas-default);
-  box-shadow: 0 0 0 var(--cpd-border-width-2) var(--cpd-color-bg-canvas-default);
-}
-
-.label {
-  max-inline-size: 100%;
-  font: var(--cpd-font-body-sm-medium);
-  color: var(--cpd-color-text-primary);
-  text-align: center;
-  overflow-wrap: anywhere;
-}

src/components/BackgroundEffectGrid.tsx

@@ -1,142 +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, type ReactNode, type ReactElement } from "react";
-import { VisuallyHidden } from "@radix-ui/react-visually-hidden";
-import { InlineSpinner, MenuItem } from "@vector-im/compound-web";
-import {
-  BlockIcon,
-  BlurIcon,
-  CheckCircleSolidIcon,
-} from "@vector-im/compound-design-tokens/assets/web/icons";
-
-import styles from "./BackgroundEffectGrid.module.css";
-
-/** One choice in the camera menu's Background effects section. */
-export interface BackgroundEffectOption {
-  id: string;
-  /** The tile's accessible name; drawn only where the tile has no picture. */
-  label: string;
-  kind: "none" | "blur" | "image";
-  /** For kind "image". */
-  imageUrl?: string;
-}
-
-interface Props {
-  /** Names the group, whose heading is hidden from assistive technology. */
-  label: string;
-  heading: ReactNode;
-  effects: BackgroundEffectOption[];
-  selected: string | undefined;
-  /** Undefined where effects can't run: all but no effect are disabled. */
-  onSelect: ((id: string) => void) | undefined;
-  /** Shown on the selected tile until its effect is on screen. */
-  settling?: boolean;
-  /** Id of the text saying what the user should know before choosing. */
-  describedBy?: string;
-}
-
-/**
- * The background effects as a grid of tiles: one radio choice, walked by the
- * menu's arrow keys like the device rows.
- */
-export const BackgroundEffectGrid: FC<Props> = ({
-  label,
-  heading,
-  effects,
-  selected,
-  onSelect,
-  settling = false,
-  describedBy,
-}) => {
-  const choose = (id: string): void => {
-    if (id !== selected) onSelect?.(id);
-  };
-  const tiles = effects.map((effect) => {
-    const checked = effect.id === selected;
-    const disabled = onSelect === undefined && effect.kind !== "none";
-    return (
-      <MenuItem
-        key={effect.id}
-        role="menuitemradio"
-        aria-checked={checked}
-        aria-busy={checked && settling}
-        disabled={disabled}
-        data-disabled={disabled ? "" : undefined}
-        label={null}
-        hideChevron
-        className={styles.tile}
-        // Without a handler it isn't one of the menu's items, so the keyboard
-        // passes over it.
-        onSelect={
-          disabled
-            ? null
-            : (e): void => {
-                // Kept open, so the user sees what they chose take effect.
-                e.preventDefault();
-                choose(effect.id);
-              }
-        }
-      >
-        <TileContent
-          effect={effect}
-          checked={checked}
-          settling={checked && settling}
-        />
-      </MenuItem>
-    );
-  });
-
-  return (
-    <div role="group" aria-label={label} aria-describedby={describedBy}>
-      {heading}
-      <div role="none" className={styles.grid}>
-        {tiles}
-      </div>
-    </div>
-  );
-};
-
-function TileContent({
-  effect,
-  checked,
-  settling,
-}: {
-  effect: BackgroundEffectOption;
-  checked: boolean;
-  settling: boolean;
-}): ReactElement {
-  return (
-    <>
-      <span aria-hidden className={styles.swatch}>
-        {effect.kind === "image" && (
-          <img className={styles.picture} src={effect.imageUrl} alt="" />
-        )}
-        {settling ? (
-          <span className={styles.mark}>
-            <InlineSpinner size={20} />
-          </span>
-        ) : checked ? (
-          <CheckCircleSolidIcon
-            className={styles.mark}
-            width={20}
-            height={20}
-          />
-        ) : effect.kind === "none" ? (
-          <BlockIcon width={20} height={20} />
-        ) : effect.kind === "blur" ? (
-          <BlurIcon width={20} height={20} />
-        ) : null}
-      </span>
-      {effect.kind === "image" ? (
-        <VisuallyHidden>{effect.label}</VisuallyHidden>
-      ) : (
-        <span className={styles.label}>{effect.label}</span>
-      )}
-    </>
-  );
-}

src/components/CallFooter.stories.tsx

@@ -22,7 +22,6 @@ import { MediaDevices } from "../state/MediaDevices";
 import { globalScope } from "../state/ObservableScope";
 import { constant } from "../state/Behavior";
 import { type LayoutMode } from "../state/LayoutSwitchViewModel";
-import { shippedBackgrounds } from "../tracks/backgroundEffects";
 
 // consts for tests
 const reactionIdentifier = "@user:example.com:DEVICE";
@@ -124,19 +123,8 @@ export const Default: Story = {
     toggleAudio: fn(),
     toggleVideo: fn(),
     toggleScreenSharing: fn(),
-    selectBackgroundEffect: fn(),
-    backgroundEffect: "blur",
-    backgroundEffects: [
-      { id: "none", kind: "none" },
-      { id: "blur", kind: "blur" },
-      ...shippedBackgrounds.map((background) => ({
-        id: `image:${background.id}`,
-        kind: "image" as const,
-        imageUrl: background.imagePath,
-      })),
-    ],
-    backgroundEffectNotice: undefined,
-    backgroundEffectSettling: false,
+    toggleBlur: fn(),
+    videoBlurEnabled: true,
     hangup: fn(),
     buttonSize: "lg",
     showFooter: true,

src/components/CallFooter.tsx

@@ -7,7 +7,6 @@ Please see LICENSE in the repository root for full details.
 
 import { type FC, type JSX, type Ref, useMemo } from "react";
 import classNames from "classnames";
-import { useTranslation } from "react-i18next";
 
 import LogoMark from "../icons/LogoMark.svg?react";
 import LogoType from "../icons/LogoType.svg?react";
@@ -32,15 +31,6 @@ import { type ViewModel } from "../state/ViewModel";
 import { useBehavior } from "../useBehavior";
 import { type LayoutSwitchViewModel } from "../state/LayoutSwitchViewModel";
 import { LayoutSwitch } from "../room/LayoutSwitch";
-import { type BackgroundEffectOption } from "./BackgroundEffectGrid";
-
-/** A background effect on offer, which the view names. */
-export interface BackgroundEffectChoice {
-  /** Its option id, as `backgroundEffect` gives the one in force. */
-  id: string;
-  kind: "none" | "blur" | "image";
-  imageUrl?: string;
-}
 
 export interface AudioOutputSwitcher {
   targetOutput: string;
@@ -66,29 +56,20 @@ export interface FooterActions {
   toggleAudio: (() => void) | undefined;
   /** Also controls if the videoMute button is disabled */
   toggleVideo: (() => void) | undefined;
-  /** Undefined where background effects can't be chosen. */
-  selectBackgroundEffect: ((id: string) => void) | undefined;
+  toggleBlur: (() => void) | undefined;
   toggleScreenSharing: (() => void) | undefined;
   /** Also controls if the settings button is visible */
   openSettings: (() => void) | undefined;
   /** Also controls if the hangup button is visible */
   hangup: (() => void) | undefined;
 }
-
 // we do not use any ? optional properties so that the vm type is including all fields.
 export interface FooterState {
   audioEnabled: boolean;
   audioBusy: boolean;
   videoEnabled: boolean;
   videoBusy: boolean;
-  /** The background effect in force, as its option id. */
-  backgroundEffect: string;
-  /** Every effect on offer, in the order they are shown. */
-  backgroundEffects: BackgroundEffectChoice[];
-  /** What the user is told about effects here, if anything. */
-  backgroundEffectNotice: "unavailable" | "slow" | undefined;
-  /** Whether the first effect chosen is still being prepared. */
-  backgroundEffectSettling: boolean;
+  videoBlurEnabled: boolean;
   showFooter: boolean;
 
   /* This is needed for WindowMode = "flat" */
@@ -136,14 +117,12 @@ export interface FooterProps {
   children?: JSX.Element | JSX.Element[] | false;
   vm: ViewModel<FooterSnapshot>;
 }
-
 export const CallFooter: FC<FooterProps> = ({
   className,
   ref,
   children,
   vm,
 }) => {
-  const { t } = useTranslation();
   const asOverlay = useBehavior(vm.asOverlay$);
   const showFooter = useBehavior(vm.showFooter$);
   const hideControls = useBehavior(vm.hideControls$);
@@ -172,13 +151,8 @@ export const CallFooter: FC<FooterProps> = ({
   const selectedAudioOutput = useBehavior(vm.selectedAudioOutput$);
   const selectAudioOutputOption = useBehavior(vm.selectAudioOutputOption$);
   const selectVideoButtonOption = useBehavior(vm.selectVideoButtonOption$);
-  const backgroundEffect = useBehavior(vm.backgroundEffect$);
-  const selectBackgroundEffect = useBehavior(vm.selectBackgroundEffect$);
-  const backgroundEffectNotice = useBehavior(vm.backgroundEffectNotice$);
-  const backgroundEffectSettling = useBehavior(vm.backgroundEffectSettling$);
-  const backgroundEffects = useBackgroundEffectLabels(
-    useBehavior(vm.backgroundEffects$),
-  );
+  const toggleBlur = useBehavior(vm.toggleBlur$);
+  const videoBlurEnabled = useBehavior(vm.videoBlurEnabled$);
   const buttonSize = useBehavior(vm.buttonSize$);
   const showLogo = useBehavior(vm.showLogo$);
 
@@ -240,17 +214,8 @@ export const CallFooter: FC<FooterProps> = ({
         options={videoOptions}
         selectedOption={selectedVideo}
         onSelect={selectVideoButtonOption}
-        backgroundEffects={backgroundEffects}
-        selectedBackgroundEffect={backgroundEffect}
-        onSelectBackgroundEffect={selectBackgroundEffect}
-        backgroundEffectSettling={backgroundEffectSettling}
-        backgroundEffectNotice={
-          backgroundEffectNotice === "unavailable"
-            ? t("background_effects.unavailable")
-            : backgroundEffectNotice === "slow"
-              ? t("background_effects.slow")
-              : undefined
-        }
+        videoBlurToggleClick={toggleBlur}
+        videoBlurEnabled={videoBlurEnabled}
       />,
     );
   } else {
@@ -375,21 +340,3 @@ const TilesDebugInfo: FC<TilesDebugInfoProps> = ({ generation$ }) => {
   const generation = useBehavior(generation$);
   return `Tiles generation: ${generation}`;
 };
-
-function useBackgroundEffectLabels(
-  choices: BackgroundEffectChoice[],
-): BackgroundEffectOption[] {
-  const { t } = useTranslation();
-  return useMemo(() => {
-    let pictures = 0;
-    return choices.map((choice) => ({
-      ...choice,
-      label:
-        choice.kind === "none"
-          ? t("background_effects.none")
-          : choice.kind === "blur"
-            ? t("background_effects.blur")
-            : t("background_effects.numbered", { n: ++pictures }),
-    }));
-  }, [choices, t]);
-}

src/components/CallFooterViewModel.test.ts

@@ -5,22 +5,16 @@ 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, it, vi } from "vitest";
-import { BehaviorSubject } from "rxjs";
+import { describe, expect, it, vi } from "vitest";
 
 import { testScope, mockMuteStates, mockMediaDevices } from "../utils/test";
 import { constant } from "../state/Behavior";
 import type { CallViewModel } from "../state/CallViewModel/CallViewModel";
-import type { Alignment, Layout } from "../state/layout-types";
+import type { Layout } from "../state/layout-types";
 import type { SpotlightTileViewModel } from "../state/TileViewModel";
 import type { DeviceLabel } from "../state/MediaDevices";
-import {
-  createCallFooterViewModel,
-  createLobbyFooterViewModel,
-} from "./CallFooterViewModel";
+import { createCallFooterViewModel } from "./CallFooterViewModel";
 import { HeaderStyle } from "../UrlParams";
-import { backgroundEffect as backgroundEffectSetting } from "../settings/settings";
-import { shippedBackgrounds } from "../tracks/backgroundEffects";
 
 const platformMock = vi.hoisted(() => vi.fn(() => "desktop"));
 vi.mock("../Platform", () => ({
@@ -29,12 +23,10 @@ vi.mock("../Platform", () => ({
   },
 }));
 
-// The SDK's own check needs WebGL and canvas APIs jsdom does not have.
-const sdkSupportMock = vi.hoisted(() => vi.fn(() => false));
-const modernRouteMock = vi.hoisted(() => vi.fn(() => true));
+// Prevent supportsBackgroundProcessors from throwing in jsdom – it is not
+// exercised by these tests (only used in `videoToggles`, not `videoOptions`).
 vi.mock("@livekit/track-processors", () => ({
-  supportsBackgroundProcessors: (): boolean => sdkSupportMock(),
-  supportsModernBackgroundProcessors: (): boolean => modernRouteMock(),
+  supportsBackgroundProcessors: (): boolean => false,
 }));
 
 const outputSelectionMock = vi.hoisted(() => vi.fn(() => true));
@@ -72,10 +64,6 @@ function buildMinimalCallViewModel(layout: Layout): CallViewModel {
 const gridLayout: Layout = {
   type: "grid",
   grid: [],
-  spotlightAlignment$: new BehaviorSubject<Alignment>({
-    inline: "end",
-    block: "end",
-  }),
   setVisibleTiles: (_: number) => {},
 };
 
@@ -116,7 +104,6 @@ describe("createCallFooterViewModel", () => {
         buildMinimalCallViewModel(gridLayout),
         mockMuteStates(),
         twoMicsAndOneCamMediaDevices,
-        constant(false),
         /* reactionIdentifier */ undefined,
         { showControls: true, header: HeaderStyle.Standard },
       );
@@ -159,7 +146,6 @@ describe("createCallFooterViewModel", () => {
             select: vi.fn(),
           },
         }),
-        constant(false),
         /* reactionIdentifier */ undefined,
         { showControls: true, header: HeaderStyle.Standard },
       );
@@ -178,7 +164,6 @@ describe("createCallFooterViewModel", () => {
         buildMinimalCallViewModel(layout),
         mockMuteStates(),
         twoMicsAndOneCamMediaDevices,
-        constant(false),
         /* reactionIdentifier */ undefined,
         { showControls: true, header: HeaderStyle.Standard },
       );
@@ -201,7 +186,6 @@ describe("createCallFooterViewModel", () => {
         buildMinimalCallViewModel(gridLayout),
         mockMuteStates(),
         twoMicsAndOneCamMediaDevices,
-        constant(false),
         /* reactionIdentifier */ undefined,
         { showControls: true, header: HeaderStyle.Standard },
       );
@@ -233,127 +217,4 @@ describe("createCallFooterViewModel", () => {
       ]);
     });
   });
-
-  describe("background effects", () => {
-    afterEach(() => backgroundEffectSetting.setValue("none"));
-
-    // The lobby, because in a call the whole device switcher is already
-    // withheld on a phone, whatever the verdict says.
-    function lobbyOn(
-      platform: string,
-    ): ReturnType<typeof createLobbyFooterViewModel> {
-      platformMock.mockReturnValue(platform);
-      return createLobbyFooterViewModel(
-        testScope(),
-        mockMuteStates(),
-        twoMicsAndOneCamMediaDevices,
-        constant(false),
-        /* openSettings */ undefined,
-        /* hangup */ undefined,
-        /* showLogo */ false,
-      );
-    }
-
-    it("offers them on a phone whose browser can run them", () => {
-      sdkSupportMock.mockReturnValue(true);
-      expect(lobbyOn("ios").selectBackgroundEffect$.value).toBeDefined();
-    });
-
-    it("offers them on a desktop whose browser can run them", () => {
-      sdkSupportMock.mockReturnValue(true);
-      expect(lobbyOn("desktop").selectBackgroundEffect$.value).toBeDefined();
-    });
-
-    it("offers nothing where the browser itself cannot run them", () => {
-      sdkSupportMock.mockReturnValue(false);
-      expect(lobbyOn("desktop").selectBackgroundEffect$.value).toBeUndefined();
-    });
-
-    it("puts no effect in force where the browser cannot run them", () => {
-      backgroundEffectSetting.setValue("blur");
-      sdkSupportMock.mockReturnValue(false);
-      expect(lobbyOn("desktop").backgroundEffect$.value).toBe("none");
-      sdkSupportMock.mockReturnValue(true);
-      expect(lobbyOn("desktop").backgroundEffect$.value).toBe("blur");
-    });
-
-    it("stores the effect chosen", () => {
-      sdkSupportMock.mockReturnValue(true);
-      const vm = lobbyOn("desktop");
-      vm.selectBackgroundEffect$.value?.("image:arc");
-      expect(vm.backgroundEffect$.value).toBe("image:arc");
-      // What isn't an effect on offer is stored as none.
-      vm.selectBackgroundEffect$.value?.("image:gone");
-      expect(backgroundEffectSetting.getValue()).toBe("none");
-    });
-
-    it("says they run slowly where only the slower route exists", () => {
-      sdkSupportMock.mockReturnValue(true);
-      modernRouteMock.mockReturnValue(false);
-      const slow = lobbyOn("desktop");
-      expect(slow.backgroundEffectNotice$.value).toBe("slow");
-      expect(slow.selectBackgroundEffect$.value).toBeDefined();
-      modernRouteMock.mockReturnValue(true);
-      expect(lobbyOn("desktop").backgroundEffectNotice$.value).toBeUndefined();
-    });
-
-    it("offers every effect in order", () => {
-      sdkSupportMock.mockReturnValue(true);
-      expect(lobbyOn("desktop").backgroundEffects$.value).toEqual([
-        { id: "none", kind: "none" },
-        { id: "blur", kind: "blur" },
-        ...shippedBackgrounds.map((background) => ({
-          id: `image:${background.id}`,
-          kind: "image",
-          imageUrl: background.imagePath,
-        })),
-      ]);
-    });
-
-    it("says they are unavailable where they cannot be chosen", () => {
-      sdkSupportMock.mockReturnValue(false);
-      expect(lobbyOn("desktop").backgroundEffectNotice$.value).toBe(
-        "unavailable",
-      );
-    });
-
-    it("passes on the wait for the first effect", () => {
-      platformMock.mockReturnValue("desktop");
-      const settling$ = new BehaviorSubject(true);
-      const vm = createLobbyFooterViewModel(
-        testScope(),
-        mockMuteStates(),
-        twoMicsAndOneCamMediaDevices,
-        settling$,
-        /* openSettings */ undefined,
-        /* hangup */ undefined,
-        /* showLogo */ false,
-      );
-      expect(vm.backgroundEffectSettling$.value).toBe(true);
-      settling$.next(false);
-      expect(vm.backgroundEffectSettling$.value).toBe(false);
-    });
-
-    it("availability is the same before and during a call", () => {
-      for (const supported of [true, false]) {
-        sdkSupportMock.mockReturnValue(supported);
-        const lobby = lobbyOn("desktop");
-        const inCall = createCallFooterViewModel(
-          testScope(),
-          buildMinimalCallViewModel(gridLayout),
-          mockMuteStates(),
-          twoMicsAndOneCamMediaDevices,
-          constant(false),
-          /* reactionIdentifier */ undefined,
-          { showControls: true, header: HeaderStyle.Standard },
-        );
-        const offeredInLobby =
-          lobby.selectBackgroundEffect$.value !== undefined;
-        expect(inCall.selectBackgroundEffect$.value !== undefined).toBe(
-          offeredInLobby,
-        );
-        expect(offeredInLobby).toBe(supported);
-      }
-    });
-  });
 });

src/components/CallFooterViewModel.tsx

@@ -5,30 +5,15 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import {
-  combineLatest,
-  distinctUntilChanged,
-  map,
-  type Observable,
-  switchMap,
-} from "rxjs";
+import { combineLatest, map, type Observable, switchMap } from "rxjs";
+import { supportsBackgroundProcessors } from "@livekit/track-processors";
 import { supportsAudioOutputSelection } from "livekit-client";
-import {
-  supportsBackgroundProcessors,
-  supportsModernBackgroundProcessors,
-} from "@livekit/track-processors";
-
-import {
-  parseEffect,
-  serializeEffect,
-  shippedBackgrounds,
-} from "../tracks/backgroundEffects";
 
 import { type CallViewModel } from "../state/CallViewModel/CallViewModel";
 import { type MenuOptions } from "./MediaMuteAndSwitchButton";
 import { type MediaDevices } from "../state/MediaDevices";
 import {
-  backgroundEffect as backgroundEffectSetting,
+  backgroundBlur as backgroundBlurSettings,
   debugTileLayout as debugTileLayoutSetting,
 } from "../settings/settings";
 import { type Behavior, constant } from "../state/Behavior";
@@ -37,7 +22,7 @@ import { type MuteStates } from "../state/MuteStates";
 import { createStaticViewModel, type ViewModel } from "../state/ViewModel";
 import { HeaderStyle } from "../UrlParams";
 import { platform } from "../Platform";
-import { type BackgroundEffectChoice, type FooterSnapshot } from "./CallFooter";
+import { type FooterSnapshot } from "./CallFooter";
 
 /**
  * Shared helper: maps MuteStates into the audio/video enabled + toggle behaviors
@@ -71,14 +56,13 @@ function buildMuteBehaviors(
 
 /**
  * Shared helper: maps MediaDevices into the audio/video device-list behaviors
- * needed by FooterSnapshot (options, selection, callbacks, background effect).
+ * needed by FooterSnapshot (options, selection, callbacks, blur toggle).
  */
 function buildDeviceBehaviors(
   scope: ObservableScope,
   mediaDevices: MediaDevices,
   /** return empty arrays for  audioOptions and videoOptions*/
   disableSwitcher$: Behavior<boolean>,
-  backgroundEffectSettling$: Observable<boolean>,
 ): Pick<
   ViewModel<FooterSnapshot>,
   | "audioOptions$"
@@ -90,11 +74,8 @@ function buildDeviceBehaviors(
   | "videoOptions$"
   | "selectedVideo$"
   | "selectVideoButtonOption$"
-  | "backgroundEffect$"
-  | "selectBackgroundEffect$"
-  | "backgroundEffects$"
-  | "backgroundEffectNotice$"
-  | "backgroundEffectSettling$"
+  | "toggleBlur$"
+  | "videoBlurEnabled$"
 > {
   const options$ = (
     available$: Behavior<Map<string, MenuOptions["label"]>>,
@@ -111,11 +92,6 @@ function buildDeviceBehaviors(
       ),
     );
 
-  const supported = supportsBackgroundProcessors();
-  const slow = !supportsModernBackgroundProcessors();
-  const offered$ = disableSwitcher$.pipe(
-    map((switcherDisabled) => !switcherDisabled && supported),
-  );
   return {
     audioOptions$: scope.behavior(options$(mediaDevices.audioInput.available$)),
     selectedAudio$: scope.behavior(
@@ -140,35 +116,18 @@ function buildDeviceBehaviors(
       mediaDevices.videoInput.selected$.pipe(map((s) => s?.id)),
     ),
     selectVideoButtonOption$: constant(mediaDevices.videoInput.select),
-    backgroundEffect$: scope.behavior(
-      backgroundEffectSetting.value$.pipe(
-        map((raw) => (supported ? serializeEffect(parseEffect(raw)) : "none")),
+    toggleBlur$: scope.behavior(
+      combineLatest([backgroundBlurSettings.value$, disableSwitcher$]).pipe(
+        map(([current, switcherDisabled]) => {
+          return !switcherDisabled && supportsBackgroundProcessors()
+            ? (): void => {
+                backgroundBlurSettings.setValue(!current);
+              }
+            : undefined;
+        }),
       ),
     ),
-    selectBackgroundEffect$: scope.behavior(
-      offered$.pipe(
-        map((offered) =>
-          offered
-            ? (id: string): void =>
-                backgroundEffectSetting.setValue(
-                  serializeEffect(parseEffect(id)),
-                )
-            : undefined,
-        ),
-      ),
-    ),
-    backgroundEffects$: constant(backgroundEffectChoices()),
-    backgroundEffectNotice$: scope.behavior(
-      offered$.pipe(
-        map((offered) =>
-          !offered ? "unavailable" : slow ? "slow" : undefined,
-        ),
-      ),
-    ),
-    backgroundEffectSettling$: scope.behavior(
-      backgroundEffectSettling$.pipe(distinctUntilChanged()),
-      false,
-    ),
+    videoBlurEnabled$: backgroundBlurSettings.value$,
   };
 }
 
@@ -179,8 +138,6 @@ 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 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.
@@ -191,7 +148,6 @@ export function createCallFooterViewModel(
   callModel: CallViewModel,
   muteStates: MuteStates,
   mediaDevices: MediaDevices,
-  backgroundEffectSettling$: Observable<boolean>,
   reactionIdentifier: string | undefined,
   options: { showControls: boolean; header: HeaderStyle },
 ): ViewModel<FooterSnapshot> {
@@ -206,12 +162,7 @@ export function createCallFooterViewModel(
   );
   return {
     ...buildMuteBehaviors(scope, muteStates),
-    ...buildDeviceBehaviors(
-      scope,
-      mediaDevices,
-      disableDeviceSwitcher$,
-      backgroundEffectSettling$,
-    ),
+    ...buildDeviceBehaviors(scope, mediaDevices, disableDeviceSwitcher$),
     // candidat to move into the FooterViewModel
     showFooter$: callModel.showFooter$,
     hideControls$: constant(!showControls),
@@ -273,8 +224,6 @@ 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 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.
@@ -283,7 +232,6 @@ export function createLobbyFooterViewModel(
   scope: ObservableScope,
   muteStates: MuteStates,
   mediaDevices: MediaDevices,
-  backgroundEffectSettling$: Observable<boolean>,
   openSettings: (() => void) | undefined,
   hangup: (() => void) | undefined,
   showLogo: boolean,
@@ -327,23 +275,6 @@ export function createLobbyFooterViewModel(
       selectVideoButtonOption: undefined,
     }),
     ...buildMuteBehaviors(scope, muteStates),
-    ...buildDeviceBehaviors(
-      scope,
-      mediaDevices,
-      constant(false),
-      backgroundEffectSettling$,
-    ),
+    ...buildDeviceBehaviors(scope, mediaDevices, constant(false)),
   };
 }
-
-function backgroundEffectChoices(): BackgroundEffectChoice[] {
-  return [
-    { 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,
-    })),
-  ];
-}

src/components/MediaMuteAndSwitchButton.module.css

@@ -36,19 +36,20 @@ Please see LICENSE in the repository root for full details.
   }
 }
 
-/* The width design sets: a long device name wraps. */
 .menu {
-  inline-size: 296px;
+  display: flex;
+  flex-direction: column;
 }
 
-/* Its share of the measured call area: the menu is portalled out of the root,
-   so CSS can't size it against the call. */
+/* Only the device lists scroll, bounded by the measured call area: the menu is
+   portalled out of the root, so CSS can't size it against the call. */
 .deviceList {
+  overflow-y: auto;
+  min-block-size: 0;
   max-block-size: var(--device-list-max-height);
-  /* The raised headings stay raised within the list, under the menu's frame. */
-  isolation: isolate;
-  /* Keeps a row reached by keyboard clear of the sticky heading. */
-  scroll-padding-block-start: var(--device-list-scroll-padding-start, 0);
+  /* Keeps a row reached by keyboard clear of the sticky heading and meter. */
+  scroll-padding-block: var(--device-list-scroll-padding-start, 0)
+    var(--device-list-scroll-padding-end, 0);
 }
 
 /* Compound's heading rule heads each section; the design adds space below it. */
@@ -61,40 +62,23 @@ Please see LICENSE in the repository root for full details.
   margin-block-start: var(--cpd-space-7x);
 }
 
-/* Sticky within its own section: opaque, so rows scroll under it, and raised,
-   or the positioned tiles scroll over it. */
+/* Sticky within its own section. Opaque and inset a border width so it doesn't
+   paint over the menu's outline. */
 .sectionHeading {
   position: sticky;
-  z-index: 1;
   inset-block-start: 0;
   background: var(--cpd-color-bg-canvas-default);
+  margin-inline: var(--cpd-border-width-1);
+  margin-block-start: var(--cpd-border-width-1);
 }
 
-/* Sticky at the foot of the microphone section; opaque as above. */
+/* Sticky at the foot of the microphone section; opaque and inset as above. */
 .stickyMeter {
   position: sticky;
   inset-block-end: 0;
   background: var(--cpd-color-bg-canvas-default);
-}
-
-/* Fills the band between the meter and the frame, or rows show through it. */
-.stickyMeter::after {
-  content: "";
-  position: absolute;
-  inset-inline: 0;
-  inset-block-start: 100%;
-  block-size: var(--cpd-menu-padding-block-end, 0px);
-  background: var(--cpd-color-bg-canvas-default);
-}
-
-/* Not Compound's fade: that stays at the edge while a bounce carries the meter.
-   This one starts at the chevron, below the meter at rest. */
-.deviceList.deviceListWithMeter[data-more-below] {
-  mask-image: linear-gradient(
-    to bottom,
-    #000 calc(100% - var(--cpd-space-6x)),
-    transparent calc(100% - var(--cpd-space-3x))
-  );
+  margin-inline: var(--cpd-border-width-1);
+  margin-block-end: var(--cpd-border-width-1);
 }
 
 /* Radix focuses whatever the pointer is over, so the browser's ring would
@@ -108,20 +92,3 @@ Please see LICENSE in the repository root for full details.
   outline: var(--cpd-border-width-2) solid var(--cpd-color-border-focused);
   outline-offset: calc(-1 * var(--cpd-border-width-2));
 }
-
-.notice {
-  display: flex;
-  align-items: flex-start;
-  gap: var(--cpd-space-3x);
-  margin: var(--cpd-space-2x) var(--cpd-space-4x) 0;
-  padding: var(--cpd-space-3x);
-  border-radius: var(--cpd-space-2x);
-  background: var(--cpd-color-bg-subtle-secondary);
-  color: var(--cpd-color-text-primary);
-  font: var(--cpd-font-body-md-regular);
-}
-
-.notice > svg {
-  flex-shrink: 0;
-  color: var(--cpd-color-icon-secondary);
-}

src/components/MediaMuteAndSwitchButton.stories.tsx

@@ -11,8 +11,6 @@ import { useEffect, useState, type FC, type JSX, type ReactNode } from "react";
 import type { Meta, StoryObj } from "@storybook/react-vite";
 import { MediaMuteAndSwitchButton } from "./MediaMuteAndSwitchButton";
 import styles from "./MediaMuteAndSwitchButton.module.css";
-import { type BackgroundEffectOption } from "./BackgroundEffectGrid";
-import { shippedBackgrounds } from "../tracks/backgroundEffects";
 import meterStyles from "./MicrophoneLevelMeter.module.css";
 import { MediaDevicesContext } from "../MediaDevicesContext";
 import { RootElementProvider } from "../RootElementContext";
@@ -61,19 +59,14 @@ const WithAMicrophone: FC<{ children: ReactNode }> = ({ children }) => {
 };
 
 /** Supplies a call-sized root. Without one the list is bounded by the whole Storybook frame. */
-const WithACallArea: FC<{ children: ReactNode; blockSize?: number }> = ({
-  children,
-  // A call's size: anything smaller makes a short device list scroll, and a
-  // narrower one narrows the menu.
-  blockSize = 720,
-}) => {
+const WithACallArea: FC<{ children: ReactNode }> = ({ children }) => {
   const [callArea, setCallArea] = useState<HTMLElement | null>(null);
   return (
     <div
       ref={setCallArea}
       style={{
-        blockSize,
-        inlineSize: 1024,
+        // A call's size: anything smaller makes a short device list scroll.
+        blockSize: 720,
         display: "flex",
         alignItems: "flex-end",
         justifyContent: "center",
@@ -134,6 +127,8 @@ export const AudioMute: Story = {
       { label: { type: "name", name: "Microphone 1" }, id: "1" },
       { label: { type: "name", name: "Microphone 2" }, id: "2" },
     ],
+    videoBlurEnabled: true,
+    videoBlurToggleClick: fn(),
     selectedOption: "2",
   },
   play: async ({ args, canvasElement }) => {
@@ -172,17 +167,6 @@ export const VideoMute: Story = {
   },
 };
 
-const effects: BackgroundEffectOption[] = [
-  { id: "none", kind: "none", label: "None" },
-  { id: "blur", kind: "blur", label: "Blur" },
-  ...shippedBackgrounds.map((background, i) => ({
-    id: `image:${background.id}`,
-    kind: "image" as const,
-    label: `Background ${i + 1}`,
-    imageUrl: background.imagePath,
-  })),
-];
-
 export const VideoUnmute: Story = {
   args: {
     iconsAndLabels: "video",
@@ -191,210 +175,9 @@ export const VideoUnmute: Story = {
       { label: { type: "name", name: "Camera 1" }, id: "1" },
       { label: { type: "name", name: "Camera 2" }, id: "2" },
     ],
+    videoBlurEnabled: true,
+    videoBlurToggleClick: fn(),
     selectedOption: "2",
-    backgroundEffects: effects,
-    selectedBackgroundEffect: "none",
-    onSelectBackgroundEffect: fn(),
-  },
-};
-
-/** One choice among no effect, blur and the shipped images, under the cameras. */
-export const BackgroundEffects: Story = {
-  args: VideoUnmute.args,
-  play: async ({ args, canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const menu = within(document.body);
-    const section = await menu.findByRole("group", {
-      name: "Background effects",
-    });
-    const tiles = within(section).getAllByRole("menuitemradio");
-    await expect(tiles.map((tile) => tile.textContent)).toEqual([
-      "None",
-      "Blur",
-      "Background 1",
-      "Background 2",
-    ]);
-    await expect(
-      within(section).getByRole("menuitemradio", { checked: true }),
-    ).toHaveTextContent("None");
-
-    const cameras = menu.getByRole("group", { name: "Camera" });
-    await expect(
-      cameras.compareDocumentPosition(section) &
-        Node.DOCUMENT_POSITION_FOLLOWING,
-    ).toBeTruthy();
-    const [first, second, third, fourth] = tiles.map((tile) =>
-      tile.getBoundingClientRect(),
-    );
-    await expect(second.top).toBe(first.top);
-    await expect(third.top).toBe(first.top);
-    await expect(fourth.top).toBeGreaterThan(first.bottom);
-    const frame = document.body
-      .querySelector("[role='menu']")!
-      .getBoundingClientRect();
-    for (const tile of [first, second, third])
-      await expect(tile.left >= frame.left && tile.right <= frame.right).toBe(
-        true,
-      );
-
-    await userEvent.click(menu.getByRole("menuitemradio", { name: "Blur" }));
-    await expect(args.onSelectBackgroundEffect).toHaveBeenCalledWith("blur");
-    await expect(menu.getByRole("menu")).toBeVisible();
-  },
-};
-
-/** Where effects can't run: shown, disabled and explained, except no effect. */
-export const BackgroundEffectsUnavailable: Story = {
-  args: {
-    ...VideoUnmute.args,
-    onSelectBackgroundEffect: undefined,
-    backgroundEffectNotice:
-      "Background effects are not supported on this platform.",
-  },
-  play: async ({ canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const menu = within(document.body);
-    const section = await menu.findByRole("group", {
-      name: "Background effects",
-    });
-    await expect(section).toHaveAccessibleDescription(
-      "Background effects are not supported on this platform.",
-    );
-    for (const tile of within(section).getAllByRole("menuitemradio"))
-      if (tile.textContent === "None") await expect(tile).toBeEnabled();
-      else await expect(tile).toBeDisabled();
-  },
-};
-
-/** Where only the slower route exists: offered and choosable, with the cost said. */
-export const BackgroundEffectsSlowInThisBrowser: Story = {
-  args: {
-    ...VideoUnmute.args,
-    backgroundEffectNotice:
-      "Background effects run slowly on this platform, which may cause your video to stutter.",
-  },
-  play: async ({ args, canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const menu = within(document.body);
-    const section = await menu.findByRole("group", {
-      name: "Background effects",
-    });
-    await expect(section).toHaveAccessibleDescription(
-      "Background effects run slowly on this platform, which may cause your video to stutter.",
-    );
-    for (const tile of within(section).getAllByRole("menuitemradio"))
-      await expect(tile).not.toHaveAttribute("aria-disabled");
-    await userEvent.click(
-      within(section).getByRole("menuitemradio", { name: "Background 1" }),
-    );
-    await expect(args.onSelectBackgroundEffect).toHaveBeenCalledWith(
-      "image:arc",
-    );
-
-    const notice = document.body.querySelector(`.${styles.notice}`)!;
-    const frame = document.body
-      .querySelector("[role='menu']")!
-      .getBoundingClientRect();
-    await expect(frame.width).toBeLessThanOrEqual(296);
-    await expect(notice.getBoundingClientRect().right).toBeLessThanOrEqual(
-      frame.right,
-    );
-  },
-};
-
-/** The first effect of a session shows its wait on its own tile. */
-export const BackgroundEffectsSettling: Story = {
-  args: {
-    ...VideoUnmute.args,
-    selectedBackgroundEffect: "blur",
-    backgroundEffectSettling: true,
-  },
-  play: async ({ canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const menu = within(document.body);
-    const chosen = await menu.findByRole("menuitemradio", {
-      name: "Blur",
-      checked: true,
-    });
-    await expect(chosen).toHaveAttribute("aria-busy", "true");
-    const marks = chosen.querySelectorAll("svg");
-    await expect(marks).toHaveLength(1);
-    await expect(getComputedStyle(marks[0]).animationName).not.toBe("none");
-    const section = menu.getByRole("group", { name: "Background effects" });
-    for (const other of within(section).getAllByRole("menuitemradio", {
-      checked: false,
-    }))
-      await expect(other).toHaveAttribute("aria-busy", "false");
-  },
-};
-
-/** In a short call the effects scroll into view with the list. */
-export const BackgroundEffectsScrollWhenTheyDoNotFit: Story = {
-  args: {
-    ...VideoUnmute.args,
-    // It sits with the effects, so it must fit the same share of the call.
-    backgroundEffectNotice:
-      "Background effects run slowly on this platform, which may cause your video to stutter.",
-  },
-  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 last = await menu.findByRole("menuitemradio", {
-      name: "Background 2",
-    });
-    const list = document.body.querySelector<HTMLElement>(
-      `.${styles.deviceList}`,
-    )!;
-    await expect(list.scrollHeight).toBeGreaterThan(list.clientHeight);
-    await expect(last.getBoundingClientRect().top).toBeGreaterThan(
-      list.getBoundingClientRect().bottom,
-    );
-
-    // Scrolled under the section's heading, the tiles pass beneath it.
-    const heading = [
-      ...document.body.querySelectorAll<HTMLElement>(
-        `.${styles.sectionHeading}`,
-      ),
-    ].find((h) => h.textContent === "Background effects")!;
-    list.scrollTop = heading.offsetTop + 30;
-    await waitFor(async () => {
-      const box = heading.getBoundingClientRect();
-      const drawn = document.elementFromPoint(
-        box.left + box.width / 2,
-        box.bottom - 2,
-      );
-      await expect(heading.contains(drawn)).toBe(true);
-    });
-    list.scrollTop = 0;
-
-    for (let i = 0; i < 10 && document.activeElement !== last; i++)
-      await userEvent.keyboard("{ArrowDown}");
-    await expect(document.activeElement).toBe(last);
-    const scrollport = list.getBoundingClientRect();
-    const reached = last.getBoundingClientRect();
-    await expect(reached.bottom).toBeLessThanOrEqual(scrollport.bottom + 1);
-    await expect(reached.top).toBeGreaterThanOrEqual(scrollport.top - 1);
-
-    const callArea = canvasElement
-      .querySelector<HTMLElement>("[style*='block-size: 300px']")!
-      .getBoundingClientRect();
-    const frame = document.body
-      .querySelector("[role='menu']")!
-      .getBoundingClientRect();
-    await expect(frame.top).toBeGreaterThanOrEqual(callArea.top);
-    await expect(frame.bottom).toBeLessThanOrEqual(callArea.bottom);
   },
 };
 
@@ -473,37 +256,6 @@ export const SpeakerAndMicrophoneSections: Story = {
   },
 };
 
-/** A long name wraps rather than widening the menu, which design sets. */
-export const LongDeviceNameWraps: Story = {
-  args: {
-    ...SpeakerAndMicrophoneSections.args,
-    outputOptions: [
-      {
-        label: {
-          type: "name",
-          name: "Logitech BRIO 4K Ultra HD Pro Business Webcam Speakers (046d:085e)",
-        },
-        id: "long",
-      },
-      { label: { type: "name", name: "Headset" }, id: "spk2" },
-    ],
-    selectedOutputOption: "long",
-  },
-  play: async ({ canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByRole("button", { name: "Microphone" }));
-    const body = within(document.body);
-    const long = await body.findByRole("menuitemradio", { name: /Logitech/ });
-    const short = await body.findByRole("menuitemradio", { name: "Headset" });
-
-    const menu = document.body.querySelector("[role='menu']")!;
-    await expect(Math.round(menu.getBoundingClientRect().width)).toBe(296);
-    await expect(long.getBoundingClientRect().height).toBeGreaterThan(
-      short.getBoundingClientRect().height,
-    );
-  },
-};
-
 export const OutputCannotBeChosen: Story = {
   args: {
     ...Default.args,
@@ -684,6 +436,10 @@ export const ManyDevices: Story = {
       .getBoundingClientRect();
     await expect(frame.top).toBeGreaterThanOrEqual(0);
     await expect(frame.bottom).toBeLessThanOrEqual(window.innerHeight + 1);
+
+    // The meter is the menu's one opaque part, so it must stay inside the frame.
+    await expect(pinned.left).toBeGreaterThan(frame.left);
+    await expect(pinned.right).toBeLessThan(frame.right);
   },
 };
 
@@ -851,6 +607,13 @@ export const HeadingsStayWhileScrolling: Story = {
     await expect(heading.getBoundingClientRect().bottom).toBeGreaterThan(
       scrollport.top,
     );
+    // Clear of the menu's frame.
+    const frame = document.body
+      .querySelector("[role='menu']")!
+      .getBoundingClientRect();
+    await expect(heading.getBoundingClientRect().left).toBeGreaterThan(
+      frame.left,
+    );
   },
 };
 
@@ -865,23 +628,31 @@ function overlapping(element: Element, overlays: Element[]): number {
   }, 0);
 }
 
-/** The effect tiles get the keyboard ring the device rows get. */
-export const FocusRingCoversTheEffectTiles: Story = {
-  args: VideoUnmute.args,
+/** The blur toggle gets the keyboard ring too: it is the menu's child, not the list's. */
+export const FocusRingCoversTheBlurToggle: Story = {
+  args: {
+    ...VideoUnmute.args,
+    iconsAndLabels: "video",
+    videoBlurEnabled: false,
+    videoBlurToggleClick: fn(),
+  },
   play: async ({ canvasElement }) => {
     const canvas = within(canvasElement);
     await userEvent.click(canvas.getByRole("button", { name: "Camera" }));
-    const tile = await within(document.body).findByRole("menuitemradio", {
-      name: "Blur",
+    const toggle = await within(document.body).findByRole("menuitemcheckbox", {
+      name: /Blur background/,
     });
 
-    for (let i = 0; i < 6 && document.activeElement !== tile; i++)
+    // Arrow down past the cameras to the toggle.
+    for (let i = 0; i < 6 && document.activeElement !== toggle; i++)
       await userEvent.keyboard("{ArrowDown}");
-    await expect(document.activeElement).toBe(tile);
-    await expect(outlineWidth(tile)).toBeGreaterThan(0);
+    await expect(document.activeElement).toBe(toggle);
+    // The same ring the device rows get.
+    await expect(outlineWidth(toggle)).toBeGreaterThan(0);
 
-    await userEvent.hover(tile);
-    await expect(document.activeElement).toBe(tile);
-    await expect(outlineWidth(tile)).toBe(0);
+    // And the pointer takes it away, with the toggle still focused.
+    await userEvent.hover(toggle);
+    await expect(document.activeElement).toBe(toggle);
+    await expect(outlineWidth(toggle)).toBe(0);
   },
 };

src/components/MediaMuteAndSwitchButton.test.tsx

@@ -9,7 +9,6 @@ import { afterEach, describe, expect, test, vi } from "vitest";
 import { axe } from "vitest-axe";
 import {
   act,
-  fireEvent,
   render,
   screen,
   within,
@@ -23,18 +22,10 @@ import {
   MediaMuteAndSwitchButton,
   type MenuOptions,
 } from "./MediaMuteAndSwitchButton";
-import { type BackgroundEffectOption } from "./BackgroundEffectGrid";
 import { MediaDevicesContext } from "../MediaDevicesContext";
 import { type MediaDevices } from "../state/MediaDevices";
 import { restoreAudioCapture, stubAudioCapture } from "../utils/test";
 
-const effects: BackgroundEffectOption[] = [
-  { id: "none", kind: "none", label: "None" },
-  { id: "blur", kind: "blur", label: "Blur" },
-  { id: "image:arc", kind: "image", label: "Background 1", imageUrl: "" },
-  { id: "image:glow", kind: "image", label: "Background 2", imageUrl: "" },
-];
-
 interface RenderOptions {
   requestDeviceNames: () => void;
 }
@@ -314,88 +305,30 @@ describe("MediaMuteAndSwitchButton", () => {
     expect(mic2ItemAfter.querySelector(".rotate")).toBeNull();
   });
 
-  test("background effects are one keyboard-operable labelled choice", async () => {
+  test("renders menu with toggle control and calls toggle callback", async () => {
     const user = userEvent.setup();
-    const onSelectBackgroundEffect = vi.fn();
+    const onSelect = vi.fn();
+    const onVideoBlurToggle = vi.fn();
     const { getByRole } = renderComponent(
       <MediaMuteAndSwitchButton
         iconsAndLabels="video"
         enabled={true}
-        options={[{ label: { type: "name", name: "Camera 1" }, id: "cam1" }]}
-        selectedOption="cam1"
-        onSelect={vi.fn()}
-        backgroundEffects={effects}
-        selectedBackgroundEffect="none"
-        onSelectBackgroundEffect={onSelectBackgroundEffect}
+        videoBlurToggleClick={onVideoBlurToggle}
+        onSelect={onSelect}
       />,
     );
 
     await user.click(getByRole("button", { name: "Camera" }));
-    const section = screen.getByRole("group", { name: "Background effects" });
-    within(section).getByRole("menuitemradio", { name: "None", checked: true });
-    within(section).getByRole("menuitemradio", {
-      name: "Background 1",
-      checked: false,
+
+    const toggle = screen.getByRole("menuitemcheckbox", {
+      name: "Blur background",
     });
+    expect(toggle).toBeInTheDocument();
+    expect(toggle).toHaveAttribute("aria-checked", "false");
 
-    const blur = within(section).getByRole("menuitemradio", { name: "Blur" });
-    for (let i = 0; i < 6 && document.activeElement !== blur; i++)
-      await user.keyboard("{ArrowDown}");
-    expect(document.activeElement).toBe(blur);
-    await user.keyboard("{Enter}");
-    expect(onSelectBackgroundEffect).toHaveBeenCalledWith("blur");
-    expect(screen.getByRole("menu")).toBeInTheDocument();
-  });
+    await user.click(toggle);
 
-  test("does not choose the effect already in force again", 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}
-        selectedBackgroundEffect="blur"
-        onSelectBackgroundEffect={onSelectBackgroundEffect}
-      />,
-    );
-
-    await user.click(getByRole("button", { name: "Camera" }));
-    await user.click(screen.getByRole("menuitemradio", { name: "Blur" }));
-    expect(onSelectBackgroundEffect).not.toHaveBeenCalled();
-  });
-
-  test("offers the background effects in a phone's drawer", async () => {
-    const userAgent = vi
-      .spyOn(navigator, "userAgent", "get")
-      .mockReturnValue("Mozilla/5.0 (Linux; Android 14)");
-    try {
-      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}
-          selectedBackgroundEffect="none"
-          onSelectBackgroundEffect={onSelectBackgroundEffect}
-        />,
-      );
-
-      await user.click(getByRole("button", { name: "Camera" }));
-      const section = screen.getByRole("group", { name: "Background effects" });
-      // A click alone: the drawer's drag handling reads layout jsdom lacks.
-      fireEvent.click(
-        within(section).getByRole("menuitemradio", { name: "Background 2" }),
-      );
-      expect(onSelectBackgroundEffect).toHaveBeenCalledWith("image:glow");
-    } finally {
-      userAgent.mockRestore();
-    }
+    expect(onVideoBlurToggle).toHaveBeenCalled();
   });
 
   test("marks the selected menu item as checked", async () => {
@@ -619,9 +552,7 @@ describe("MediaMuteAndSwitchButton", () => {
         ]}
         selectedOption="cam1"
         onSelect={vi.fn()}
-        backgroundEffects={effects}
-        selectedBackgroundEffect="none"
-        onSelectBackgroundEffect={vi.fn()}
+        videoBlurToggleClick={vi.fn()}
       />,
     );
 
@@ -629,10 +560,9 @@ describe("MediaMuteAndSwitchButton", () => {
 
     screen.getByRole("menuitemradio", { name: "Camera 1", checked: true });
     screen.getByRole("menuitemradio", { name: "Camera 2", checked: false });
-    within(screen.getByRole("group", { name: "Background effects" })).getByRole(
-      "menuitemradio",
-      { name: "Blur" },
-    );
+    expect(
+      screen.getByRole("menuitemcheckbox", { name: "Blur background" }),
+    ).toBeInTheDocument();
   });
 
   test("marks focus as keyboard-driven only when the keyboard moved it", async () => {

src/components/MediaMuteAndSwitchButton.tsx

@@ -7,7 +7,6 @@ Please see LICENSE in the repository root for full details.
 
 import {
   useCallback,
-  useId,
   useState,
   type CSSProperties,
   type FC,
@@ -18,14 +17,13 @@ import {
   Button,
   Menu,
   MenuItem,
-  MenuScrollArea,
   MenuTitle,
   RadioInput,
+  ToggleMenuItem,
 } from "@vector-im/compound-web";
 import {
   ChevronUpIcon,
   ChevronDownIcon,
-  InfoIcon,
   SpinnerIcon,
 } from "@vector-im/compound-design-tokens/assets/web/icons";
 import classNames from "classnames";
@@ -42,10 +40,6 @@ import { useMediaDevices } from "../MediaDevicesContext";
 import { useRootElement } from "../RootElementContext";
 import { observeElementSize$ } from "../utils/elementSize";
 import { LiveMicrophoneLevelMeter } from "./MicrophoneLevelMeter";
-import {
-  BackgroundEffectGrid,
-  type BackgroundEffectOption,
-} from "./BackgroundEffectGrid";
 
 export interface MenuOptions {
   label: DeviceLabel | AudioOutputDeviceLabel;
@@ -70,15 +64,8 @@ export interface MediaMuteAndSwitchButtonProps {
   selectedOutputOption?: string;
   /** Picks an output device. Undefined disables the speaker section. */
   onSelectOutput?: (id: string) => void;
-  /** Camera menu only. None or an empty list leaves the section out. */
-  backgroundEffects?: BackgroundEffectOption[];
-  selectedBackgroundEffect?: string;
-  /** Undefined where effects can't run: all but no effect are disabled. */
-  onSelectBackgroundEffect?: (id: string) => void;
-  /** What the user should know before choosing an effect, if anything. */
-  backgroundEffectNotice?: string;
-  /** Whether the first effect chosen is still being prepared. */
-  backgroundEffectSettling?: boolean;
+  videoBlurToggleClick?: () => void;
+  videoBlurEnabled?: boolean;
   /**
    * 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`
@@ -86,6 +73,8 @@ export interface MediaMuteAndSwitchButtonProps {
   onSelect?: (id: string) => void;
 }
 
+const BLUR_ID = "blur";
+
 /** Id of the placeholder "Default" row, shown when the platform lists no outputs. */
 const DEFAULT_OUTPUT_ID = "default";
 
@@ -95,9 +84,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;
 
-/** Space kept between the menu and the call area's sides. */
-const MENU_MARGIN = 16;
-
 export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
   enabled,
   busy,
@@ -108,11 +94,8 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
   outputOptions,
   selectedOutputOption,
   onSelectOutput,
-  backgroundEffects,
-  selectedBackgroundEffect,
-  onSelectBackgroundEffect,
-  backgroundEffectNotice,
-  backgroundEffectSettling,
+  videoBlurEnabled,
+  videoBlurToggleClick,
   onSelect,
 }) => {
   // Requested but not yet selected. Keyed by kind too, since Chrome uses
@@ -130,7 +113,6 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
   const isBusy = busy ?? false;
   const { t } = useTranslation();
   const devices = useMediaDevices();
-  const noticeId = useId();
 
   /**
    * Records on the menu whether the keyboard or the pointer moved focus, for
@@ -203,8 +185,16 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
     />
   );
 
-  const showEffects =
-    iconsAndLabels === "video" && (backgroundEffects?.length ?? 0) > 0;
+  const toggles =
+    iconsAndLabels === "video" && videoBlurToggleClick !== undefined
+      ? [
+          {
+            label: t("action.blur_background"),
+            enabled: videoBlurEnabled ?? false,
+            id: BLUR_ID,
+          },
+        ]
+      : [];
 
   let optionsButtonLabel: string;
   let menuTitle: string;
@@ -336,8 +326,6 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
         open={menuOpen}
         onOpenChange={onOpenChange}
         side="top"
-        collisionBoundary={rootElement}
-        collisionPadding={MENU_MARGIN}
         trigger={
           <Button
             iconOnly
@@ -352,22 +340,18 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
           />
         }
       >
-        <MenuScrollArea
+        <div
           ref={trackFocusSource}
-          className={classNames(styles.deviceList, {
-            [styles.deviceListWithMeter]: iconsAndLabels === "audio",
-          })}
+          // Keeps the items the menu's own children for assistive tech.
+          role="none"
+          className={styles.deviceList}
           data-testid="device-list"
           style={
             {
               "--device-list-max-height":
                 listMaxHeight === undefined ? undefined : `${listMaxHeight}px`,
-              // A row reached by keyboard stays above the meter and the band its
-              // ground fills.
-              scrollPaddingBlockEnd:
-                meterHeight === undefined
-                  ? undefined
-                  : `calc(${meterHeight}px + var(--cpd-menu-padding-block-end, 0px))`,
+              "--device-list-scroll-padding-end":
+                meterHeight === undefined ? undefined : `${meterHeight}px`,
               "--device-list-scroll-padding-start":
                 headingHeight === undefined ? undefined : `${headingHeight}px`,
             } as CSSProperties
@@ -415,31 +399,19 @@ export const MediaMuteAndSwitchButton: FC<MediaMuteAndSwitchButtonProps> = ({
               )}
             </div>
           </div>
-          {showEffects && (
-            <BackgroundEffectGrid
-              label={t("settings.background_effects_header")}
-              heading={
-                <div aria-hidden className={styles.sectionHeading}>
-                  <MenuTitle title={t("settings.background_effects_header")} />
-                </div>
-              }
-              effects={backgroundEffects ?? []}
-              selected={selectedBackgroundEffect}
-              onSelect={onSelectBackgroundEffect}
-              settling={backgroundEffectSettling}
-              describedBy={
-                backgroundEffectNotice === undefined ? undefined : noticeId
-              }
-            />
-          )}
-          {/* In the list, so the menu grows no taller for it. */}
-          {showEffects && backgroundEffectNotice !== undefined && (
-            <div id={noticeId} role="none" className={styles.notice}>
-              <InfoIcon width={20} height={20} />
-              <span>{backgroundEffectNotice}</span>
-            </div>
-          )}
-        </MenuScrollArea>
+        </div>
+        {toggles.length > 0 && <hr />}
+        {toggles.map((toggle) => (
+          <ToggleMenuItem
+            label={toggle.label}
+            onSelect={(e) => {
+              videoBlurToggleClick?.();
+              e.preventDefault();
+            }}
+            checked={toggle.enabled}
+            key={toggle.id}
+          />
+        ))}
       </Menu>
     </div>
   );

src/components/MicrophoneLevelMeter.module.css

@@ -16,10 +16,10 @@ Please see LICENSE in the repository root for full details.
   align-items: center;
   gap: var(--cpd-space-3x);
   padding-block: var(--cpd-space-2x);
-  /* Centres the icon on the radio column: less half the icon's extra width.
-     Checked in the MeterAlignsWithTheDeviceRows story. */
+  /* Centres the icon on the radio column: less the row's inset border and half
+     the icon's extra width. Checked in the MeterAlignsWithTheDeviceRows story. */
   padding-inline-start: calc(
-    var(--cpd-space-4x) -
+    var(--cpd-space-4x) - var(--cpd-border-width-1) -
       (var(--meter-icon-size) - var(--device-control-size)) / 2
   );
   padding-inline-end: calc(var(--cpd-space-4x) * 2 + var(--cpd-space-2x));

src/components/__snapshots__/MediaMuteAndSwitchButton.test.tsx.snap

@@ -9,7 +9,7 @@ exports[`MediaMuteAndSwitchButton > renders 1`] = `
       aria-busy="false"
       aria-checked="false"
       aria-disabled="true"
-      aria-labelledby="_r_1_"
+      aria-labelledby="_r_0_"
       class="_button_1nw83_8 _has-icon_1nw83_60 _icon-only_1nw83_53"
       data-kind="primary"
       data-size="lg"
@@ -39,7 +39,7 @@ exports[`MediaMuteAndSwitchButton > renders 1`] = `
       data-kind="tertiary"
       data-size="lg"
       data-state="closed"
-      id="radix-_r_6_"
+      id="radix-_r_5_"
       role="button"
       tabindex="0"
       type="button"

src/grid/CallLayout.test.tsx

@@ -5,28 +5,25 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { act, render, screen } from "@testing-library/react";
-import { BehaviorSubject } from "rxjs";
-import { describe, expect, it, vi } from "vitest";
+import { render } from "@testing-library/react";
+import { expect, test, vi } from "vitest";
 
-import { arrangeTiles, type Bounds } from "./CallLayout";
+import { type CallLayout } from "./CallLayout";
 import { makeGridLayout } from "./GridLayout";
 import { makeSpotlightLandscapeLayout } from "./SpotlightLandscapeLayout";
 import { makeSpotlightPortraitLayout } from "./SpotlightPortraitLayout";
-import { type DragCallback, type LayoutProps } from "./Grid";
+import { type LayoutProps } from "./Grid";
 import { constant } from "../state/Behavior";
-import {
-  type Alignment,
-  type GridLayout,
-  type SpotlightLandscapeLayout,
-  type SpotlightPortraitLayout,
-} from "../state/layout-types";
+import { type Alignment } from "../state/layout-types";
 import { type UserMediaViewModel } from "../state/media/UserMediaViewModel";
 import {
   GridTileViewModel,
   SpotlightTileViewModel,
   type TileViewModel,
 } from "../state/TileViewModel";
+import { makeOneOnOneMobileLayout } from "./OneOnOneMobileLayout";
+import { makeSpotlightExpandedLayout } from "./SpotlightExpandedLayout";
+import { makeOneOnOneDesktopLayout } from "./OneOnOneDesktopLayout";
 
 // Grid supplies these hooks to the layouts it renders; on their own the
 // layouts have no grid to report to
@@ -36,152 +33,105 @@ vi.mock("./Grid", async (importOriginal) => ({
   useVisibleTiles: (): void => {},
 }));
 
-describe("grid layout", () => {
-  it("sizes the tiles from the minimum bounds", () => {
-    const minBounds$ = new BehaviorSubject<Bounds>({ width: 800, height: 600 });
-    const { scrolling: Scrolling } = makeGridLayout({ minBounds$ });
-    render(<Scrolling model={gridModel()} Slot={Slot} />);
-    const layer = screen.getByTestId("slot-0").parentElement!;
-    expect(layer.style.width).toBe("800px");
-    expect(layer.style.getPropertyValue("--width")).toBe(
-      `${Math.floor(arrangeTiles(800, 600, 3).tileWidth)}px`,
-    );
+const minBounds$ = constant({ width: 800, height: 800 });
 
-    act(() => minBounds$.next({ width: 400, height: 300 }));
-    expect(layer.style.width).toBe("400px");
-    expect(layer.style.getPropertyValue("--width")).toBe(
-      `${Math.floor(arrangeTiles(400, 300, 3).tileWidth)}px`,
-    );
-  });
-
-  it("moves the spotlight only when a drag reaches another corner", () => {
-    const model = gridModel();
-    const { fixed: Fixed } = makeGridLayout({ minBounds$: bounds });
-    render(<Fixed model={model} Slot={Slot} />);
-    const alignments: Alignment[] = [];
-    model.spotlightAlignment$.subscribe((a) => alignments.push(a));
-    const drag = drags.get("spotlight")!;
-
-    // Still in the bottom right corner
-    act(() => drag({ x: 0, y: 0, xRatio: 0.9, yRatio: 0.9 }));
-    // Over to the bottom left
-    act(() => drag({ x: 0, y: 0, xRatio: 0.1, yRatio: 0.9 }));
-    // And a little further, still bottom left
-    act(() => drag({ x: 0, y: 0, xRatio: 0.2, yRatio: 0.8 }));
-    // Up to the top left
-    act(() => drag({ x: 0, y: 0, xRatio: 0.2, yRatio: 0.1 }));
-
-    expect(alignments).toEqual([
-      { inline: "end", block: "end" },
-      { inline: "start", block: "end" },
-      { inline: "start", block: "start" },
-    ]);
-    const slot = screen.getByTestId("slot-spotlight");
-    expect(slot.getAttribute("data-inline-alignment")).toBe("start");
-    expect(slot.getAttribute("data-block-alignment")).toBe("start");
-  });
-});
-
-describe("spotlight landscape layout", () => {
-  it("puts the spotlight in the fixed layer and the grid in the scrolling one", () => {
-    const { fixed: Fixed, scrolling: Scrolling } = makeSpotlightLandscapeLayout(
-      { minBounds$: bounds },
-    );
-    const model = landscapeModel();
-    const { unmount } = render(<Fixed model={model} Slot={Slot} />);
-    expect(screen.getByTestId("slot-spotlight")).toBeInTheDocument();
-    unmount();
-
-    render(<Scrolling model={model} Slot={Slot} />);
-    expect(slotIds()).toEqual(model.grid.map((tile) => tile.id));
-  });
-});
-
-describe("spotlight portrait layout", () => {
-  it("sizes the grid tiles from the minimum width", () => {
-    const minBounds$ = new BehaviorSubject<Bounds>({ width: 300, height: 700 });
-    const { scrolling: Scrolling } = makeSpotlightPortraitLayout({
-      minBounds$,
-    });
-    const model = portraitModel();
-    render(<Scrolling model={model} Slot={Slot} />);
-    expect(slotIds()).toEqual(model.grid.map((tile) => tile.id));
-    const layer = screen.getByTestId(`slot-${model.grid[0].id}`).parentElement!
-      .parentElement!;
-    expect(layer.style.getPropertyValue("--grid-tile-width")).toBe(
-      `${Math.floor(arrangeTiles(300, 300, 3).tileWidth)}px`,
-    );
-
-    act(() => minBounds$.next({ width: 500, height: 700 }));
-    expect(layer.style.getPropertyValue("--grid-tile-width")).toBe(
-      `${Math.floor(arrangeTiles(500, 500, 3).tileWidth)}px`,
-    );
-  });
-});
-
-const bounds = constant<Bounds>({ width: 800, height: 600 });
-
-// The layouts only pass tile view models through to their slots
-const media = {} as UserMediaViewModel;
-const spotlight = new SpotlightTileViewModel(
-  constant([]),
-  constant(false),
-  constant("solid"),
+const spotlight = {
+  vm: new SpotlightTileViewModel(
+    constant([]),
+    constant(false),
+    constant("solid"),
+  ),
+  alignment$: constant<Alignment>({ inline: "end", block: "end" }),
+  onDrag: () => {},
+};
+const grid = Array.from(
+  { length: 3 },
+  () => new GridTileViewModel(constant({} as UserMediaViewModel)),
 );
-const tiles = (): GridTileViewModel[] =>
-  Array.from({ length: 3 }, () => new GridTileViewModel(constant(media)));
+const pip = {
+  alignment$: constant<Alignment>({ inline: "end", block: "end" }),
+  onDrag: () => {},
+  vm: { id: "pip" } as GridTileViewModel,
+  size$: constant("sm" as const),
+};
 
-function gridModel(): GridLayout {
-  return {
-    type: "grid",
-    spotlight,
-    grid: tiles(),
-    spotlightAlignment$: new BehaviorSubject<Alignment>({
-      inline: "end",
-      block: "end",
-    }),
-    setVisibleTiles: () => {},
-  };
-}
-
-function landscapeModel(): SpotlightLandscapeLayout {
-  return {
-    type: "spotlight-landscape",
-    spotlight,
-    grid: tiles(),
-    setVisibleTiles: () => {},
-  };
-}
-
-function portraitModel(): SpotlightPortraitLayout {
-  return {
-    type: "spotlight-portrait",
-    spotlight,
-    grid: tiles(),
-    setVisibleTiles: () => {},
-  };
-}
-
-// Slots record their drag callback so a test can drag them, and show the id
-// of the tile they hold
-const drags = new Map<string, DragCallback | undefined>();
 const Slot: LayoutProps<unknown, TileViewModel, HTMLDivElement>["Slot"] = ({
   id,
   model,
   onDrag,
+  children,
   ...props
-}) => {
-  drags.set(id, onDrag);
-  return (
-    <div data-testid={`slot-${id}`} {...props}>
-      {model instanceof GridTileViewModel ? model.id : "spotlight"}
-    </div>
-  );
-};
+}) => (
+  <div data-testid={`slot-${id}`} {...props}>
+    {children}
+  </div>
+);
 
-function slotIds(): string[] {
-  return screen
-    .getAllByTestId(/^slot-/)
-    .map((slot) => slot.textContent ?? "")
-    .filter((id) => id !== "spotlight");
+function snapshotLayout<Model>(layout: CallLayout<Model>, model: Model): void {
+  const {
+    foreground,
+    scrolling: Scrolling,
+    fixed: Fixed,
+  } = layout({ minBounds$ });
+  const scrollingLayer = <Scrolling model={model} Slot={Slot} />;
+  const fixedLayer = <Fixed model={model} Slot={Slot} />;
+  const { container } = render(
+    foreground === "fixed" ? (
+      <>
+        {scrollingLayer}
+        {fixedLayer}
+      </>
+    ) : (
+      <>
+        {fixedLayer}
+        {scrollingLayer}
+      </>
+    ),
+  );
+  expect(container).toMatchSnapshot();
 }
+
+test("grid layout", () =>
+  snapshotLayout(makeGridLayout, {
+    type: "grid",
+    spotlight,
+    grid,
+    setVisibleTiles: () => {},
+  }));
+
+test("spotlight landscape layout", () =>
+  snapshotLayout(makeSpotlightLandscapeLayout, {
+    type: "spotlight-landscape",
+    spotlight,
+    grid,
+    setVisibleTiles: () => {},
+  }));
+
+test("spotlight portrait layout", () =>
+  snapshotLayout(makeSpotlightPortraitLayout, {
+    type: "spotlight-portrait",
+    spotlight,
+    grid,
+    setVisibleTiles: () => {},
+  }));
+
+test("spotlight expanded layout", () =>
+  snapshotLayout(makeSpotlightExpandedLayout, {
+    type: "spotlight-expanded",
+    spotlight: spotlight.vm,
+    pip,
+  }));
+
+test("one-on-one desktop layout", () =>
+  snapshotLayout(makeOneOnOneDesktopLayout, {
+    type: "one-on-one-desktop",
+    spotlight: { id: "spotlight" } as GridTileViewModel,
+    pip,
+  }));
+
+test("one-on-one mobile layout", () =>
+  snapshotLayout(makeOneOnOneMobileLayout, {
+    type: "one-on-one-mobile",
+    spotlight: spotlight.vm,
+    pip,
+  }));

src/grid/Grid.tsx

@@ -40,6 +40,7 @@ import { useMergedRefs } from "../useMergedRefs";
 import { TileWrapper } from "./TileWrapper";
 import { usePrefersReducedMotion } from "../usePrefersReducedMotion";
 import { useInitial } from "../useInitial";
+import { type DragCallback } from "../state/layout-types";
 
 const MAX_ANIMATED_TILES = 50; // Capped for performance reasons
 
@@ -83,7 +84,10 @@ interface DragState {
   cursorY: number;
 }
 
-interface SlotProps<Model> extends Omit<ComponentProps<"div">, "onDrag"> {
+export interface SlotProps<Model> extends Omit<
+  ComponentProps<"div">,
+  "onDrag"
+> {
   id: string;
   model: Model;
   onDrag?: DragCallback;
@@ -181,27 +185,6 @@ export interface TileProps<Model, R extends HTMLElement> {
   model: Model;
 }
 
-interface Drag {
-  /**
-   * The X coordinate of the dragged tile in grid space.
-   */
-  x: number;
-  /**
-   * The Y coordinate of the dragged tile in grid space.
-   */
-  y: number;
-  /**
-   * The X coordinate of the dragged tile, as a scalar of the grid width.
-   */
-  xRatio: number;
-  /**
-   * The Y coordinate of the dragged tile, as a scalar of the grid height.
-   */
-  yRatio: number;
-}
-
-export type DragCallback = (drag: Drag) => void;
-
 interface LayoutMemoProps<
   LayoutModel,
   TileModel,
@@ -464,13 +447,13 @@ export function Grid<
       )
       .catch(logger.error);
 
-    if (endOfGesture)
-      callback({
-        x: tileX,
-        y: tileY,
-        xRatio: tileX / (gridBounds.width - tile.width),
-        yRatio: tileY / (gridBounds.height - tile.height),
-      });
+    callback({
+      x: tileX,
+      y: tileY,
+      xRatio: tileX / (gridBounds.width - tile.width),
+      yRatio: tileY / (gridBounds.height - tile.height),
+      endOfGesture,
+    });
   };
 
   // Callback for useDrag. We could call useDrag here, but the default

src/grid/GridLayout.tsx

@@ -8,15 +8,21 @@ Please see LICENSE in the repository root for full details.
 import {
   type CSSProperties,
   type ReactNode,
-  useCallback,
   useMemo,
+  type FC,
+  type ComponentType,
 } from "react";
 
 import { type GridLayout as GridLayoutModel } from "../state/layout-types.ts";
 import styles from "./GridLayout.module.css";
 import { type CallLayout, arrangeTiles } from "./CallLayout";
-import { type DragCallback, useUpdateLayout, useVisibleTiles } from "./Grid";
+import { type SlotProps, useUpdateLayout, useVisibleTiles } from "./Grid";
 import { useBehavior } from "../useBehavior";
+import {
+  type SpotlightTileViewModel,
+  type TileViewModel,
+} from "../state/TileViewModel.ts";
+import { type FloatingTile } from "../state/FloatingTile.ts";
 
 interface GridCSSProperties extends CSSProperties {
   "--gap": string;
@@ -24,6 +30,27 @@ interface GridCSSProperties extends CSSProperties {
   "--height": string;
 }
 
+interface SpotlightSlotProps {
+  model: FloatingTile & { vm: SpotlightTileViewModel };
+  Slot: ComponentType<SlotProps<TileViewModel>>;
+}
+
+const SpotlightSlot: FC<SpotlightSlotProps> = ({ model, Slot }) => {
+  useUpdateLayout();
+  const alignment = useBehavior(model.alignment$);
+
+  return (
+    <Slot
+      className={styles.slot}
+      id="spotlight"
+      model={model.vm}
+      onDrag={model.onDrag}
+      data-block-alignment={alignment.block}
+      data-inline-alignment={alignment.inline}
+    />
+  );
+};
+
 /**
  * An implementation of the "grid" layout, in which all participants are shown
  * together in a scrolling grid.
@@ -37,32 +64,10 @@ export const makeGridLayout: CallLayout<GridLayoutModel> = ({
   // lives
   fixed: function GridLayoutFixed({ ref, model, Slot }): ReactNode {
     useUpdateLayout();
-    const alignment = useBehavior(model.spotlightAlignment$);
-
-    const onDragSpotlight: DragCallback = useCallback(
-      ({ xRatio, yRatio }) => {
-        const block = yRatio < 0.5 ? "start" : "end";
-        const inline = xRatio < 0.5 ? "start" : "end";
-        // A drag reports the same alignment on every move; only a change is
-        // worth a re-render
-        const current = model.spotlightAlignment$.value;
-        if (current.block !== block || current.inline !== inline)
-          model.spotlightAlignment$.next({ block, inline });
-      },
-      [model.spotlightAlignment$],
-    );
-
     return (
       <div ref={ref} className={styles.fixed}>
         {model.spotlight && (
-          <Slot
-            className={styles.slot}
-            id="spotlight"
-            model={model.spotlight}
-            onDrag={onDragSpotlight}
-            data-block-alignment={alignment.block}
-            data-inline-alignment={alignment.inline}
-          />
+          <SpotlightSlot model={model.spotlight} Slot={Slot} />
         )}
       </div>
     );

src/grid/OneOnOneDesktopLayout.tsx

@@ -6,13 +6,13 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { type ReactNode, useCallback, useMemo } from "react";
+import { type ReactNode, useMemo } from "react";
 import classNames from "classnames";
 
 import { type OneOnOneDesktopLayout as OneOnOneDesktopLayoutModel } from "../state/layout-types.ts";
 import { type CallLayout, arrangeTiles } from "./CallLayout";
 import styles from "./OneOnOneDesktopLayout.module.css";
-import { type DragCallback, useUpdateLayout } from "./Grid";
+import { useUpdateLayout } from "./Grid";
 import { useBehavior } from "../useBehavior";
 
 /**
@@ -37,21 +37,12 @@ export const makeOneOnOneDesktopLayout: CallLayout<
   }): ReactNode {
     useUpdateLayout();
     const { width, height } = useBehavior(minBounds$);
-    const pipAlignment = useBehavior(model.pipAlignment$);
+    const pipAlignment = useBehavior(model.pip.alignment$);
     const { tileWidth, tileHeight } = useMemo(
       () => arrangeTiles(width, height, 1),
       [width, height],
     );
 
-    const onDragLocalTile: DragCallback = useCallback(
-      ({ xRatio, yRatio }) =>
-        model.pipAlignment$.next({
-          block: yRatio < 0.5 ? "start" : "end",
-          inline: xRatio < 0.5 ? "start" : "end",
-        }),
-      [model.pipAlignment$],
-    );
-
     return (
       <div ref={ref} className={styles.layer}>
         <Slot
@@ -62,9 +53,9 @@ export const makeOneOnOneDesktopLayout: CallLayout<
         >
           <Slot
             className={classNames(styles.slot, styles.local)}
-            id={model.pip.id}
-            model={model.pip}
-            onDrag={onDragLocalTile}
+            id={model.pip.vm.id}
+            model={model.pip.vm}
+            onDrag={model.pip.onDrag}
             data-block-alignment={pipAlignment.block}
             data-inline-alignment={pipAlignment.inline}
           />

src/grid/OneOnOneMobileLayout.tsx

@@ -6,14 +6,43 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { type ReactNode, useCallback } from "react";
+import { type ComponentType, type FC, type ReactNode } from "react";
 import classNames from "classnames";
 
 import { type OneOnOneMobileLayout as OneOnOneMobileLayoutModel } from "../state/layout-types.ts";
 import { type CallLayout } from "./CallLayout";
 import styles from "./OneOnOneMobileLayout.module.css";
-import { type DragCallback, useUpdateLayout } from "./Grid";
+import { type SlotProps, useUpdateLayout } from "./Grid";
 import { useBehavior } from "../useBehavior";
+import { type FloatingTile } from "../state/FloatingTile.ts";
+import {
+  type GridTileViewModel,
+  type TileViewModel,
+} from "../state/TileViewModel.ts";
+import { type Behavior } from "../state/Behavior.ts";
+
+interface PipSlotProps {
+  model: FloatingTile & { vm: GridTileViewModel; size$: Behavior<"sm" | "lg"> };
+  Slot: ComponentType<SlotProps<TileViewModel>>;
+}
+
+const PipSlot: FC<PipSlotProps> = ({ model, Slot }) => {
+  useUpdateLayout();
+  const size = useBehavior(model.size$);
+  const alignment = useBehavior(model.alignment$);
+
+  return (
+    <Slot
+      className={classNames(styles.pip)}
+      id={model.vm.id}
+      model={model.vm}
+      onDrag={model.onDrag}
+      data-size={size}
+      data-block-alignment={alignment.block}
+      data-inline-alignment={alignment.inline}
+    />
+  );
+};
 
 /**
  * An implementation of the "one-on-one" layout for mobile platforms, in which
@@ -44,30 +73,9 @@ export const makeOneOnOneMobileLayout: CallLayout<
     Slot,
   }): ReactNode {
     useUpdateLayout();
-    const pipSize = useBehavior(model.pipSize$);
-    const pipAlignment = useBehavior(model.pipAlignment$);
-    const onDragLocalTile: DragCallback = useCallback(
-      ({ xRatio, yRatio }) =>
-        model.pipAlignment$.next({
-          block: yRatio < 0.5 ? "start" : "end",
-          inline: xRatio < 0.5 ? "start" : "end",
-        }),
-      [model.pipAlignment$],
-    );
-
     return (
       <div ref={ref} className={styles.layer}>
-        {model.pip && (
-          <Slot
-            className={classNames(styles.pip)}
-            id={model.pip.id}
-            model={model.pip}
-            onDrag={onDragLocalTile}
-            data-size={pipSize}
-            data-block-alignment={pipAlignment.block}
-            data-inline-alignment={pipAlignment.inline}
-          />
-        )}
+        {model.pip && <PipSlot model={model.pip} Slot={Slot} />}
       </div>
     );
   },

src/grid/SpotlightExpandedLayout.tsx

@@ -5,13 +5,39 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { type ReactNode, useCallback } from "react";
+import { type ReactNode, type ComponentType, type FC } from "react";
 
 import { type SpotlightExpandedLayout as SpotlightExpandedLayoutModel } from "../state/layout-types.ts";
 import { type CallLayout } from "./CallLayout";
-import { type DragCallback, useUpdateLayout } from "./Grid";
+import { type SlotProps, useUpdateLayout } from "./Grid";
 import styles from "./SpotlightExpandedLayout.module.css";
 import { useBehavior } from "../useBehavior";
+import { type FloatingTile } from "../state/FloatingTile.ts";
+import {
+  type GridTileViewModel,
+  type TileViewModel,
+} from "../state/TileViewModel.ts";
+
+interface PipSlotProps {
+  model: FloatingTile & { vm: GridTileViewModel };
+  Slot: ComponentType<SlotProps<TileViewModel>>;
+}
+
+const PipSlot: FC<PipSlotProps> = ({ model, Slot }) => {
+  useUpdateLayout();
+  const alignment = useBehavior(model.alignment$);
+
+  return (
+    <Slot
+      className={styles.pip}
+      id={model.vm.id}
+      model={model.vm}
+      onDrag={model.onDrag}
+      data-block-alignment={alignment.block}
+      data-inline-alignment={alignment.inline}
+    />
+  );
+};
 
 /**
  * An implementation of the "expanded spotlight" layout, in which the spotlight
@@ -28,7 +54,6 @@ export const makeSpotlightExpandedLayout: CallLayout<
     Slot,
   }): ReactNode {
     useUpdateLayout();
-
     return (
       <div ref={ref} className={styles.layer}>
         <Slot
@@ -46,29 +71,9 @@ export const makeSpotlightExpandedLayout: CallLayout<
     Slot,
   }): ReactNode {
     useUpdateLayout();
-    const pipAlignment = useBehavior(model.pipAlignment$);
-
-    const onDragPip: DragCallback = useCallback(
-      ({ xRatio, yRatio }) =>
-        model.pipAlignment$.next({
-          block: yRatio < 0.5 ? "start" : "end",
-          inline: xRatio < 0.5 ? "start" : "end",
-        }),
-      [model.pipAlignment$],
-    );
-
     return (
       <div ref={ref} className={styles.layer}>
-        {model.pip && (
-          <Slot
-            className={styles.pip}
-            id={model.pip.id}
-            model={model.pip}
-            onDrag={onDragPip}
-            data-block-alignment={pipAlignment.block}
-            data-inline-alignment={pipAlignment.inline}
-          />
-        )}
+        {model.pip && <PipSlot model={model.pip} Slot={Slot} />}
       </div>
     );
   },

src/grid/SpotlightLandscapeLayout.tsx

@@ -40,7 +40,7 @@ export const makeSpotlightLandscapeLayout: CallLayout<
           <Slot
             className={styles.slot}
             id="spotlight"
-            model={model.spotlight}
+            model={model.spotlight.vm}
           />
         </div>
         <div className={styles.grid} />
@@ -59,7 +59,7 @@ export const makeSpotlightLandscapeLayout: CallLayout<
 
     return (
       <div ref={ref} className={styles.layer}>
-        <SpotlightSlot media$={model.spotlight.media$} />
+        <SpotlightSlot media$={model.spotlight.vm.media$} />
         <div className={styles.grid}>
           {model.grid.map((m) => (
             <Slot key={m.id} className={styles.slot} id={m.id} model={m} />

src/grid/SpotlightPortraitLayout.tsx

@@ -43,7 +43,7 @@ export const makeSpotlightPortraitLayout: CallLayout<
           <Slot
             className={styles.slot}
             id="spotlight"
-            model={model.spotlight}
+            model={model.spotlight.vm}
           />
         </div>
       </div>
@@ -65,7 +65,7 @@ export const makeSpotlightPortraitLayout: CallLayout<
       width,
       model.grid.length,
     );
-    const withIndicators = useBehavior(model.spotlight.media$).length > 1;
+    const withIndicators = useBehavior(model.spotlight.vm.media$).length > 1;
 
     return (
       <div

src/grid/__snapshots__/CallLayout.test.tsx.snap

@@ -0,0 +1,186 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`grid layout 1`] = `
+<div>
+  <div
+    class="_scrolling_e8555d"
+    style="width: 800px; --gap: 20px; --width: 370px; --height: 277px;"
+  >
+    <div
+      class="_slot_e8555d"
+      data-testid="slot-0"
+    />
+    <div
+      class="_slot_e8555d"
+      data-testid="slot-1"
+    />
+    <div
+      class="_slot_e8555d"
+      data-testid="slot-2"
+    />
+  </div>
+  <div
+    class="_fixed_e8555d"
+  >
+    <div
+      class="_slot_e8555d"
+      data-block-alignment="end"
+      data-inline-alignment="end"
+      data-testid="slot-spotlight"
+    />
+  </div>
+</div>
+`;
+
+exports[`one-on-one desktop layout 1`] = `
+<div>
+  <div
+    class="_layer_185815"
+  >
+    <div
+      class="_container_185815"
+      data-testid="slot-spotlight"
+      style="width: 760px; height: 570px;"
+    >
+      <div
+        class="_slot_185815 _local_185815"
+        data-block-alignment="end"
+        data-inline-alignment="end"
+        data-testid="slot-pip"
+      />
+    </div>
+  </div>
+  <div />
+</div>
+`;
+
+exports[`one-on-one mobile layout 1`] = `
+<div>
+  <div
+    class="_layer_c81c30"
+  >
+    <div
+      class="_spotlight_c81c30"
+      data-testid="slot-spotlight"
+    />
+  </div>
+  <div
+    class="_layer_c81c30"
+  >
+    <div
+      class="_pip_c81c30"
+      data-block-alignment="end"
+      data-inline-alignment="end"
+      data-size="sm"
+      data-testid="slot-pip"
+    />
+  </div>
+</div>
+`;
+
+exports[`spotlight expanded layout 1`] = `
+<div>
+  <div
+    class="_layer_e70191"
+  >
+    <div
+      class="_spotlight_e70191"
+      data-testid="slot-spotlight"
+    />
+  </div>
+  <div
+    class="_layer_e70191"
+  >
+    <div
+      class="_pip_e70191"
+      data-block-alignment="end"
+      data-inline-alignment="end"
+      data-testid="slot-pip"
+    />
+  </div>
+</div>
+`;
+
+exports[`spotlight landscape layout 1`] = `
+<div>
+  <div
+    class="_layer_29809c"
+  >
+    <div
+      class="_spotlight_29809c"
+    >
+      <div
+        class="_slot_29809c"
+        data-testid="slot-spotlight"
+      />
+    </div>
+    <div
+      class="_grid_29809c"
+    />
+  </div>
+  <div
+    class="_layer_29809c"
+  >
+    <div
+      class="_spotlight_29809c"
+    />
+    <div
+      class="_grid_29809c"
+    >
+      <div
+        class="_slot_29809c"
+        data-testid="slot-0"
+      />
+      <div
+        class="_slot_29809c"
+        data-testid="slot-1"
+      />
+      <div
+        class="_slot_29809c"
+        data-testid="slot-2"
+      />
+    </div>
+  </div>
+</div>
+`;
+
+exports[`spotlight portrait layout 1`] = `
+<div>
+  <div
+    class="_layer_065bbc"
+    style="--grid-gap: 20px; --grid-tile-width: 370px; --grid-tile-height: 277px;"
+  >
+    <div
+      class="_spotlight_065bbc"
+    />
+    <div
+      class="_grid_065bbc"
+    >
+      <div
+        class="_slot_065bbc"
+        data-testid="slot-0"
+      />
+      <div
+        class="_slot_065bbc"
+        data-testid="slot-1"
+      />
+      <div
+        class="_slot_065bbc"
+        data-testid="slot-2"
+      />
+    </div>
+  </div>
+  <div
+    class="_layer_065bbc"
+  >
+    <div
+      class="_spotlight_065bbc"
+    >
+      <div
+        class="_slot_065bbc"
+        data-testid="slot-spotlight"
+      />
+    </div>
+  </div>
+</div>
+`;

src/room/CallView.test.tsx

@@ -50,7 +50,6 @@ import {
   mockMediaDevices,
   mockRtcMembership,
   MockRTCSession,
-  testScope,
 } from "../utils/test";
 import { CallView } from "./CallView";
 import { GroupCallErrorBoundary } from "./GroupCallErrorBoundary";
@@ -62,10 +61,7 @@ import {
 } from "../HostBridge";
 import { type JoinCallData } from "../widget";
 import { MatrixRTCTransportMissingError } from "../utils/errors";
-import {
-  BackgroundEffectsProvider,
-  createAppBackgroundEffects,
-} from "../tracks/BackgroundEffectsContext";
+import { ProcessorProvider } from "../tracks/TrackProcessorContext";
 import { MediaDevicesContext } from "../MediaDevicesContext";
 import { constant } from "../state/Behavior";
 
@@ -197,9 +193,7 @@ function createCallView(
       <HostBridgeProvider value={hostBridge}>
         <TooltipProvider>
           <MediaDevicesContext value={mockMediaDevices({})}>
-            <BackgroundEffectsProvider
-              effects={createAppBackgroundEffects(testScope())}
-            >
+            <ProcessorProvider>
               {options.withErrorBoundary ? (
                 <GroupCallErrorBoundary recoveryActionHandler={vi.fn()}>
                   {callView}
@@ -207,7 +201,7 @@ function createCallView(
               ) : (
                 callView
               )}
-            </BackgroundEffectsProvider>
+            </ProcessorProvider>
           </MediaDevicesContext>
         </TooltipProvider>
       </HostBridgeProvider>

src/room/InCallView.test.tsx

@@ -28,7 +28,6 @@ import {
   type MockRTCSession,
   mockRTCSlot,
   mockRTCMember,
-  testScope,
 } from "../utils/test";
 import { E2eeType } from "../e2ee/e2eeType";
 import {
@@ -49,10 +48,7 @@ import { MediaDevicesContext } from "../MediaDevicesContext";
 import { type MediaDevices as ECMediaDevices } from "../state/MediaDevices";
 import { AppBar } from "../AppBar";
 import { type MatrixInfo } from "./VideoPreview";
-import {
-  BackgroundEffectsProvider,
-  createAppBackgroundEffects,
-} from "../tracks/BackgroundEffectsContext";
+import { ProcessorProvider } from "../tracks/TrackProcessorContext";
 import { initializeWidget } from "../widget";
 import { RootElementProvider } from "../RootElementContext";
 
@@ -238,9 +234,7 @@ describe("ActiveCall", () => {
     const { findByTestId } = render(
       <BrowserRouter>
         <MediaDevicesContext value={mediaDevices}>
-          <BackgroundEffectsProvider
-            effects={createAppBackgroundEffects(testScope())}
-          >
+          <ProcessorProvider>
             <TooltipProvider>
               <ActiveCall
                 client={matrixRoom.client}
@@ -253,7 +247,7 @@ describe("ActiveCall", () => {
                 onLeft={(): void => {}}
               />
             </TooltipProvider>
-          </BackgroundEffectsProvider>
+          </ProcessorProvider>
         </MediaDevicesContext>
       </BrowserRouter>,
     );
@@ -288,9 +282,7 @@ describe("ActiveCall", () => {
         <BrowserRouter>
           <RootElementProvider value={root}>
             <MediaDevicesContext value={mediaDevices}>
-              <BackgroundEffectsProvider
-                effects={createAppBackgroundEffects(testScope())}
-              >
+              <ProcessorProvider>
                 <TooltipProvider>
                   <ActiveCall
                     client={matrixRoom.client}
@@ -303,7 +295,7 @@ describe("ActiveCall", () => {
                     onLeft={(): void => {}}
                   />
                 </TooltipProvider>
-              </BackgroundEffectsProvider>
+              </ProcessorProvider>
             </MediaDevicesContext>
           </RootElementProvider>
         </BrowserRouter>,

src/room/InCallView.tsx

@@ -109,7 +109,7 @@ import { useBehavior } from "../useBehavior.ts";
 import { useValueBehavior } from "../useValueBehavior.ts";
 import { Toast } from "../Toast.tsx";
 import overlayStyles from "../Overlay.module.css";
-import { useBackgroundEffectsState$ } from "../tracks/BackgroundEffectsContext.tsx";
+import { useTrackProcessorState$ } from "../tracks/TrackProcessorContext.tsx";
 import { type Layout } from "../state/layout-types.ts";
 import { ObservableScope } from "../state/ObservableScope.ts";
 import { CallFooter, type FooterSnapshot } from "../components/CallFooter.tsx";
@@ -150,7 +150,7 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
   const urlParams = useUrlParams();
   const hostBridge = useHostBridge();
   const mediaDevices = useMediaDevices();
-  const backgroundEffectsState$ = useBackgroundEffectsState$();
+  const trackProcessorState$ = useTrackProcessorState$();
   // The element we have to draw the call in: the page, or the container a host
   // gave us. Its size, not the window's, decides how the call is laid out.
   const rootElement = useRootElement();
@@ -170,12 +170,7 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
     );
     const rtcParticipation = slot.join({
       ...rtcParticipationOptions(urlParams),
-      publish: initialPublishRequests(
-        props.muteStates,
-        mediaDevices,
-        capture,
-        backgroundEffectsState$.value.processor,
-      ),
+      publish: initialPublishRequests(props.muteStates, mediaDevices, capture),
     });
 
     const vm = createCallViewModel$(
@@ -189,7 +184,7 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
         encryptionSystem: props.e2eeSystem,
         capture,
         videoProcessor$: scope.behavior(
-          backgroundEffectsState$.pipe(map((state) => state.processor)),
+          trackProcessorState$.pipe(map((state) => state.processor)),
         ),
         hostBridge,
         autoLeaveWhenOthersLeft,
@@ -219,7 +214,7 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
     urlParams,
     hostBridge,
     mediaDevices,
-    backgroundEffectsState$,
+    trackProcessorState$,
     props.client,
     rootElement,
   ]);
@@ -233,7 +228,6 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
       vm,
       props.muteStates,
       mediaDevices,
-      backgroundEffectsState$.pipe(map(({ settling }) => settling ?? false)),
       `${props.client.getUserId()}:${props.client.getDeviceId()}`,
       { showControls: urlParams.showControls, header: urlParams.header },
     );
@@ -251,7 +245,7 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
     props.onLeft,
     urlParams,
     mediaDevices,
-    backgroundEffectsState$,
+    trackProcessorState$,
     props.client,
     vm,
   ]);

src/room/KnockLobbyView.test.tsx

@@ -10,33 +10,24 @@ import { render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { TooltipProvider } from "@vector-im/compound-web";
 import { type MatrixClient, type RoomSummary } from "matrix-js-sdk";
-import { type Observable } from "rxjs";
 
 import { KnockLobbyView } from "./KnockLobbyView";
 import { LeaveToHomeProvider } from "../LeaveToHomeContext";
 import { MediaDevicesContext } from "../MediaDevicesContext";
-import { type BackgroundEffectsState } from "../tracks/BackgroundEffectsContext";
+import { type ProcessorState } from "../tracks/TrackProcessorContext";
 import { mockMediaDevices } from "../utils/test";
 
 vi.mock("@livekit/components-react", () => ({
   usePreviewTracks: (): unknown[] => [],
 }));
 
-vi.mock("../tracks/BackgroundEffectsContext", async () => {
-  const { of } = await import("rxjs");
-  const none: BackgroundEffectsState = {
+vi.mock("../tracks/TrackProcessorContext", () => ({
+  useTrackProcessor: (): ProcessorState => ({
     supported: false,
     processor: undefined,
-  };
-  // One observable, as the real hook keeps: a fresh one each render would
-  // rebuild the footer on every render.
-  const none$ = of(none);
-  return {
-    useBackgroundEffects: (): BackgroundEffectsState => none,
-    useBackgroundEffectsState$: (): Observable<BackgroundEffectsState> => none$,
-    useSyncBackgroundEffects: (): void => {},
-  };
-});
+  }),
+  useTrackProcessorSync: (): void => {},
+}));
 
 vi.mock("react-use-measure", () => ({
   default: (): [() => void, object] => [(): void => {}, {}],

src/room/LobbyView.test.tsx

@@ -8,7 +8,7 @@ Please see LICENSE in the repository root for full details.
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
-import { type Observable, of } from "rxjs";
+import { of } from "rxjs";
 import { LeaveToHomeProvider } from "../LeaveToHomeContext";
 import { TooltipProvider } from "@vector-im/compound-web";
 import { type MatrixClient } from "matrix-js-sdk";
@@ -28,7 +28,7 @@ import {
 } from "../utils/test";
 import { type MediaDevices } from "../state/MediaDevices";
 import { MediaDevicesContext } from "../MediaDevicesContext";
-import { type BackgroundEffectsState } from "../tracks/BackgroundEffectsContext";
+import { type ProcessorState } from "../tracks/TrackProcessorContext";
 import { type EncryptionSystem } from "../e2ee/sharedKeyManagement";
 import lobbyStyles from "./LobbyView.module.css";
 import headerStyles from "../Header.module.css";
@@ -41,21 +41,13 @@ vi.mock("@livekit/components-react", () => ({
   usePreviewTracks: (): unknown[] => [],
 }));
 
-vi.mock("../tracks/BackgroundEffectsContext", async () => {
-  const { of } = await import("rxjs");
-  const none: BackgroundEffectsState = {
+vi.mock("../tracks/TrackProcessorContext", () => ({
+  useTrackProcessor: (): ProcessorState => ({
     supported: false,
     processor: undefined,
-  };
-  // One observable, as the real hook keeps: a fresh one each render would
-  // rebuild the footer on every render.
-  const none$ = of(none);
-  return {
-    useBackgroundEffects: (): BackgroundEffectsState => none,
-    useBackgroundEffectsState$: (): Observable<BackgroundEffectsState> => none$,
-    useSyncBackgroundEffects: (): void => {},
-  };
-});
+  }),
+  useTrackProcessorSync: (): void => {},
+}));
 
 vi.mock("react-use-measure", () => ({
   default: (): [() => void, object] => [(): void => {}, {}],

src/room/LobbyView.tsx

@@ -25,7 +25,6 @@ import {
   Track,
 } from "livekit-client";
 import { convertToLivekitProcessor } from "@element-hq/matrixrtc-sdk";
-import { map } from "rxjs";
 
 import inCallStyles from "./InCallView.module.css";
 import styles from "./LobbyView.module.css";
@@ -42,10 +41,9 @@ import { useMediaDevices } from "../MediaDevicesContext";
 import { ObservableScope } from "../state/ObservableScope";
 import { useInitial } from "../useInitial";
 import {
-  useBackgroundEffects,
-  useBackgroundEffectsState$,
-  useSyncBackgroundEffects,
-} from "../tracks/BackgroundEffectsContext";
+  useTrackProcessor,
+  useTrackProcessorSync,
+} from "../tracks/TrackProcessorContext";
 import { getValue } from "../utils/observable";
 import { useBehavior } from "../useBehavior";
 import { CallFooter, type FooterSnapshot } from "../components/CallFooter";
@@ -139,8 +137,7 @@ export const LobbyView: FC<Props> = ({
       },
   );
 
-  const { processor } = useBackgroundEffects();
-  const backgroundEffectsState$ = useBackgroundEffectsState$();
+  const { processor } = useTrackProcessor();
 
   const initialProcessor = useInitial(() => processor);
   const localTrackOptions = useMemo<CreateLocalTracksOptions>(
@@ -188,7 +185,7 @@ export const LobbyView: FC<Props> = ({
     }
   }, [devices, videoInputId, videoTrack]);
 
-  useSyncBackgroundEffects(videoTrack);
+  useTrackProcessorSync(videoTrack);
 
   const [footerVm, setFooterVm] = useState<ViewModel<FooterSnapshot> | null>(
     null,
@@ -200,7 +197,6 @@ export const LobbyView: FC<Props> = ({
         footerScope,
         muteStates,
         devices,
-        backgroundEffectsState$.pipe(map(({ settling }) => settling ?? false)),
         openSettings,
         hangup,
         // Logo and header are connected: only show the logo in SPA with header.
@@ -210,14 +206,7 @@ export const LobbyView: FC<Props> = ({
     return (): void => {
       footerScope.end();
     };
-  }, [
-    devices,
-    backgroundEffectsState$,
-    hangup,
-    hideHeader,
-    muteStates,
-    openSettings,
-  ]);
+  }, [devices, hangup, hideHeader, muteStates, openSettings]);
 
   // TODO: Unify this component with InCallView, so we can get slick joining
   // animations and don't have to feel bad about reusing its CSS

src/settings/SettingsModal.test.tsx

@@ -1,93 +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 { afterEach, describe, expect, it, vi } from "vitest";
-import { render, screen } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { type MatrixClient } from "matrix-js-sdk";
-import { TooltipProvider } from "@vector-im/compound-web";
-
-import { SettingsModal } from "./SettingsModal";
-import { backgroundEffect } from "./settings";
-import { MediaDevicesContext } from "../MediaDevicesContext";
-import { type BackgroundEffectsState } from "../tracks/BackgroundEffectsContext";
-import { mockMediaDevices } from "../utils/test";
-import { constant } from "../state/Behavior";
-import { type MediaDevices } from "../state/MediaDevices";
-
-vi.mock("../tracks/BackgroundEffectsContext", () => ({
-  useBackgroundEffects: (): BackgroundEffectsState => ({
-    supported: true,
-    processor: undefined,
-  }),
-}));
-
-// Behaviors, as the device menus read them.
-const noDevices = {
-  available$: constant(new Map()),
-  selected$: constant(undefined),
-  select: vi.fn(),
-};
-
-function renderVideoTab(): void {
-  render(
-    <TooltipProvider>
-      <MediaDevicesContext
-        value={mockMediaDevices({
-          requestDeviceNames: vi.fn(),
-          audioInput: noDevices,
-          audioOutput: noDevices,
-          videoInput: noDevices,
-        } as unknown as Partial<MediaDevices>)}
-      >
-        <SettingsModal
-          open
-          onDismiss={vi.fn()}
-          tab="video"
-          onTabChange={vi.fn()}
-          client={
-            {
-              getUserId: () => "@user:example.org",
-              getUser: () => null,
-            } as unknown as MatrixClient
-          }
-        />
-      </MediaDevicesContext>
-    </TooltipProvider>,
-  );
-}
-
-const blurControl = (): HTMLElement =>
-  screen.getByRole("checkbox", { name: "Blur the background of the video" });
-
-describe("SettingsModal", () => {
-  afterEach(() => backgroundEffect.setValue("none"));
-
-  it("blur control turns blur on and off", async () => {
-    const user = userEvent.setup();
-    renderVideoTab();
-    expect(blurControl()).not.toBeChecked();
-
-    await user.click(blurControl());
-    expect(backgroundEffect.getValue()).toBe("blur");
-    expect(blurControl()).toBeChecked();
-
-    await user.click(blurControl());
-    expect(backgroundEffect.getValue()).toBe("none");
-    expect(blurControl()).not.toBeChecked();
-  });
-
-  it("blur control reflects and replaces an image background", async () => {
-    const user = userEvent.setup();
-    backgroundEffect.setValue("image:arc");
-    renderVideoTab();
-    expect(blurControl()).not.toBeChecked();
-
-    await user.click(blurControl());
-    expect(backgroundEffect.getValue()).toBe("blur");
-  });
-});

src/settings/SettingsModal.tsx

@@ -21,14 +21,13 @@ import { useHostBridge } from "../HostBridge";
 import {
   useSetting,
   soundEffectVolume as soundEffectVolumeSetting,
-  backgroundEffect as backgroundEffectSetting,
+  backgroundBlur as backgroundBlurSetting,
   developerMode,
 } from "./settings";
 import { PreferencesSettingsTab } from "./PreferencesSettingsTab";
 import { Slider } from "../Slider";
 import { DeviceSelection } from "./DeviceSelection";
-import { useBackgroundEffects } from "../tracks/BackgroundEffectsContext";
-import { parseEffect, serializeEffect } from "../tracks/backgroundEffects";
+import { useTrackProcessor } from "../tracks/TrackProcessorContext";
 import {
   DeveloperSettingsTab,
   type DeveloperSettingsSnapshot,
@@ -79,11 +78,9 @@ export const SettingsModal: FC<Props> = ({
 
   // Generate a `Checkbox` input to turn blur on or off.
   const BlurCheckbox: React.FC = (): ReactNode => {
-    const { supported } = useBackgroundEffects();
+    const { supported } = useTrackProcessor();
 
-    // The camera menu's setting, of which this control sees only blur.
-    const [effect, setEffect] = useSetting(backgroundEffectSetting);
-    const blurActive = parseEffect(effect).kind === "blur";
+    const [blurActive, setBlurActive] = useSetting(backgroundBlurSetting);
 
     return (
       <>
@@ -97,12 +94,8 @@ export const SettingsModal: FC<Props> = ({
               supported ? "" : t("settings.blur_not_supported_by_browser")
             }
             type="checkbox"
-            checked={blurActive}
-            onChange={(b): void =>
-              setEffect(
-                serializeEffect({ kind: b.target.checked ? "blur" : "none" }),
-              )
-            }
+            checked={!!blurActive}
+            onChange={(b): void => setBlurActive(b.target.checked)}
             disabled={!supported}
           />
         </FieldRow>

src/settings/settings.ts

@@ -13,7 +13,6 @@ import { type Behavior } from "../state/Behavior";
 import { useBehavior } from "../useBehavior";
 import { MatrixRTCMode } from "../config/ConfigOptions";
 import { type UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
-import { type EffectId } from "../tracks/backgroundEffects";
 
 export class Setting<T> {
   public constructor(
@@ -117,14 +116,7 @@ export const videoInput = new Setting<string | undefined>(
   undefined,
 );
 
-// Only read, to carry blur over for anyone who had it on.
-const backgroundBlur = new Setting<boolean>("background-blur", false);
-
-/** The chosen background effect, in the form `parseEffect` reads. */
-export const backgroundEffect = new Setting<EffectId>(
-  "background-effect",
-  backgroundBlur.getValue() ? "blur" : "none",
-);
+export const backgroundBlur = new Setting<boolean>("background-blur", false);
 
 export const showHandRaisedTimer = new Setting<boolean>(
   "hand-raised-show-timer",

src/state/AppViewModel.ts

@@ -6,7 +6,6 @@ Please see LICENSE in the repository root for full details.
 */
 
 import { type AudioOutputOptions, MediaDevices } from "./MediaDevices";
-import { createAppBackgroundEffects } from "../tracks/BackgroundEffectsContext";
 import { type ObservableScope } from "./ObservableScope";
 
 /**
@@ -17,7 +16,6 @@ export class AppViewModel {
     this.scope,
     this.audioOutputOptions,
   );
-  public readonly backgroundEffects = createAppBackgroundEffects(this.scope);
 
   // TODO: Move more application logic here. The CallViewModel, at the very
   // least, ought to be accessible from this object.

src/state/BackgroundEffects.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 { BehaviorSubject, distinctUntilChanged, map } from "rxjs";
-import { type BackgroundProcessorWrapper } from "@livekit/track-processors";
-
-import {
-  type BackgroundEffects,
-  createBackgroundEffects,
-  type BackgroundEffectsOptions,
-} from "./BackgroundEffects";
-import { type BackgroundEffectsState } from "../tracks/BackgroundEffectsContext";
-import { shippedBackgrounds } from "../tracks/backgroundEffects";
-import { flushPromises, testScope, withTestScheduler } from "../utils/test";
-
-/** A pipeline that records what it is switched to. */
-function fakePipeline(): {
-  pipeline: BackgroundProcessorWrapper;
-  switches: unknown[];
-  /** Holds the next switch until it resolves, as a picture loading does. */
-  holdNext: () => () => void;
-} {
-  const switches: unknown[] = [];
-  let slow: Promise<void> | undefined;
-  const pipeline = {
-    switchTo: vi.fn(async (options: unknown) => {
-      switches.push(options);
-      const held = slow;
-      slow = undefined;
-      await held;
-    }),
-  } as unknown as BackgroundProcessorWrapper;
-  return {
-    pipeline,
-    switches,
-    holdNext: () => {
-      let release!: () => void;
-      slow = new Promise((resolve) => (release = resolve));
-      return release;
-    },
-  };
-}
-
-/** One letter per state: idle, waiting for a frame, attached. */
-function letter(state: BackgroundEffectsState): string {
-  if (state.processor === undefined) return "i";
-  return state.settling ? "w" : "a";
-}
-
-describe("the pipeline's state", () => {
-  function testState({
-    effect,
-    firstFrame = "",
-    expected,
-  }: {
-    effect: string;
-    firstFrame?: string;
-    expected: string;
-  }): void {
-    withTestScheduler(({ behavior, schedule, expectObservable }) => {
-      const transformer = {
-        onFirstFrame: undefined as (() => void) | undefined,
-      };
-      const effects = createBackgroundEffects(testScope(), {
-        supported: true,
-        effect$: behavior(effect, { n: "none", b: "blur" }),
-        pipeline: fakePipeline().pipeline,
-        transformer,
-      });
-      schedule(firstFrame, { f: () => transformer.onFirstFrame?.() });
-      expectObservable(
-        effects.state$.pipe(map(letter), distinctUntilChanged()),
-      ).toBe(expected);
-    });
-  }
-
-  it("defaults to no effect", () => testState({ effect: "n", expected: "i" }));
-
-  it("waits from the first effect until a frame carries it", () =>
-    testState({
-      effect: "    nb-n-b",
-      firstFrame: "  --f",
-      expected: "  iwa",
-    }));
-
-  it("attaches on first use and stays attached", () =>
-    testState({ effect: "nb-n", firstFrame: "--f", expected: "iwa" }));
-});
-
-describe("background effects", () => {
-  let effect$: BehaviorSubject<string>;
-  let fake: ReturnType<typeof fakePipeline>;
-
-  function build(
-    options: Partial<BackgroundEffectsOptions> = {},
-  ): BackgroundEffects {
-    return createBackgroundEffects(testScope(), {
-      supported: true,
-      effect$,
-      pipeline: fake.pipeline,
-      transformer: { onFirstFrame: undefined },
-      ...options,
-    });
-  }
-  const choose = async (raw: string): Promise<void> => {
-    effect$.next(raw);
-    await flushPromises();
-  };
-  const blur = async (on: boolean): Promise<void> =>
-    choose(on ? "blur" : "none");
-
-  beforeEach(() => {
-    effect$ = new BehaviorSubject("none");
-    fake = fakePipeline();
-  });
-
-  it("puts a shipped background on as that picture", async () => {
-    build();
-    await choose(`image:${shippedBackgrounds[0].id}`);
-    expect(fake.switches).toEqual([
-      {
-        mode: "virtual-background",
-        imagePath: shippedBackgrounds[0].imagePath,
-      },
-    ]);
-  });
-
-  it("switches in place rather than reattaching", async () => {
-    const effects = build();
-    await blur(true);
-    const pipeline = effects.state$.value.processor;
-    await blur(false);
-    await blur(true);
-
-    expect(effects.state$.value.processor).toBe(pipeline);
-    expect(fake.switches).toEqual([
-      { mode: "background-blur", blurRadius: 15 },
-      { mode: "disabled" },
-      { mode: "background-blur", blurRadius: 15 },
-    ]);
-  });
-
-  it("keeps switching after a switch fails", async () => {
-    vi.mocked(fake.pipeline.switchTo).mockRejectedValueOnce(new Error("lost"));
-    build();
-    await blur(true);
-    await blur(false);
-    expect(fake.switches).toEqual([{ mode: "disabled" }]);
-  });
-
-  it("switches one at a time, skipping those overtaken", async () => {
-    const finished = fake.holdNext();
-    build();
-    await blur(true);
-    await blur(false);
-    await blur(true);
-    await blur(false);
-    expect(fake.switches).toHaveLength(1);
-
-    finished();
-    await flushPromises();
-    expect(fake.switches).toEqual([
-      { mode: "background-blur", blurRadius: 15 },
-      { mode: "disabled" },
-    ]);
-  });
-});

src/state/BackgroundEffects.ts

@@ -1,131 +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 {
-  combineLatest,
-  distinctUntilChanged,
-  map,
-  Observable,
-  scan,
-} from "rxjs";
-import {
-  type BackgroundProcessorWrapper,
-  type SwitchBackgroundProcessorOptions,
-} from "@livekit/track-processors";
-import { logger } from "matrix-js-sdk/lib/logger";
-import { deepCompare } from "matrix-js-sdk/lib/utils";
-
-import { type Behavior } from "./Behavior";
-import { type ObservableScope } from "./ObservableScope";
-import {
-  fromLivekitProcessor,
-  type BackgroundEffectsState,
-} from "../tracks/BackgroundEffectsContext";
-import {
-  type BackgroundEffect,
-  blurRadius,
-  imagePathFor,
-  parseEffect,
-} from "../tracks/backgroundEffects";
-
-export interface BackgroundEffectsOptions {
-  /** Whether this browser can run a pipeline at all. */
-  supported: boolean;
-  /** The effect chosen, as the setting stores it. */
-  effect$: Behavior<string>;
-  /** The background processor pipeline to be switched between effects. */
-  pipeline: BackgroundProcessorWrapper;
-  /** Tells, once, that a frame carrying an effect has been drawn. */
-  transformer: { onFirstFrame: (() => void) | undefined };
-}
-
-/** The background effect pipeline, as the camera tracks and the menus see it. */
-export interface BackgroundEffects {
-  readonly state$: Behavior<BackgroundEffectsState>;
-}
-
-/** Switches the pipeline as the choice changes, for as long as the scope lasts. */
-export function createBackgroundEffects(
-  scope: ObservableScope,
-  { supported, effect$, pipeline, transformer }: BackgroundEffectsOptions,
-): BackgroundEffects {
-  // Wrapped once, so the call and the preview see one processor throughout.
-  const processor = fromLivekitProcessor(pipeline);
-  const choice$ = effect$.pipe(map(parseEffect));
-  const wanted$ = choice$.pipe(
-    map((effect) => effect.kind !== "none"),
-    distinctUntilChanged(),
-  );
-
-  const drewAFrame$ = scope.behavior(
-    new Observable<boolean>((subscriber) => {
-      subscriber.next(false);
-      transformer.onFirstFrame = (): void => subscriber.next(true);
-      return (): void => {
-        transformer.onFirstFrame = undefined;
-      };
-    }),
-  );
-
-  const state$ = scope.behavior(
-    combineLatest([wanted$, drewAFrame$]).pipe(
-      scan<[boolean, boolean], BackgroundEffectsState>(
-        (previous, [wanted, drewAFrame]) => {
-          // Attached the first time an effect is wanted and never detached
-          // after, so someone who never turns one on pays for none of it.
-          const enable =
-            previous.processor !== undefined || (supported && wanted);
-          return {
-            supported,
-            processor: enable ? processor : undefined,
-            settling: enable && !drewAFrame,
-          };
-        },
-        { supported, processor: undefined },
-      ),
-    ),
-  );
-
-  const switchOptions$ = scope.behavior<
-    SwitchBackgroundProcessorOptions | undefined
-  >(
-    combineLatest([state$, choice$]).pipe(
-      map(([{ processor }, effect]) =>
-        processor === undefined ? undefined : switchOptionsFor(effect),
-      ),
-      distinctUntilChanged(deepCompare),
-    ),
-  );
-  // In turn: a picture's switch ends once it loads, so an earlier one could land last.
-  scope.reconcile(switchOptions$, async (options) => {
-    if (options === undefined) return;
-    try {
-      await pipeline.switchTo(options);
-    } catch (e) {
-      logger.warn("Failed to switch background effect", e);
-    }
-  });
-
-  return { state$ };
-}
-
-function switchOptionsFor(
-  effect: BackgroundEffect,
-): SwitchBackgroundProcessorOptions {
-  switch (effect.kind) {
-    case "blur":
-      return { mode: "background-blur", blurRadius };
-    case "shipped": {
-      const imagePath = imagePathFor(effect.id);
-      return imagePath
-        ? { mode: "virtual-background", imagePath }
-        : { mode: "disabled" };
-    }
-    default:
-      return { mode: "disabled" };
-  }
-}

src/state/CallViewModel/CallViewModel.test.ts

@@ -23,10 +23,6 @@ import {
   MatrixRTCSessionEvent,
 } from "matrix-js-sdk/lib/matrixrtc";
 import { deepCompare } from "matrix-js-sdk/lib/utils";
-import {
-  type RTCParticipation,
-  type VideoProcessor,
-} from "@element-hq/matrixrtc-sdk";
 
 import { type Layout } from "../layout-types.ts";
 import {
@@ -35,9 +31,7 @@ import {
   mockRemoteParticipant,
   withTestScheduler,
   mockRtcMembership,
-  mockMuteStates,
   testScope,
-  flushPromises,
 } from "../../utils/test.ts";
 import { E2eeType } from "../../e2ee/e2eeType.ts";
 import {
@@ -68,11 +62,7 @@ import {
 import { MatrixRTCMode } from "../../config/ConfigOptions.ts";
 import { initializeWidget } from "../../widget.ts";
 import { computeUrlParams } from "../../UrlParams.ts";
-import {
-  callViewModelOptionsFromParams,
-  initialPublishRequests,
-} from "./CallViewModel.ts";
-import { type Handler, MuteState } from "../MuteStates.ts";
+import { callViewModelOptionsFromParams } from "./CallViewModel.ts";
 
 initializeWidget();
 
@@ -165,7 +155,7 @@ function summarizeLayout$(l$: Observable<Layout>): Observable<LayoutSummary> {
         case "grid":
           return combineLatest(
             [
-              l.spotlight?.media$ ?? constant(undefined),
+              l.spotlight?.vm.media$ ?? constant(undefined),
               ...l.grid.map((vm) => vm.media$),
             ],
             (spotlight, ...grid) => ({
@@ -177,7 +167,7 @@ function summarizeLayout$(l$: Observable<Layout>): Observable<LayoutSummary> {
         case "spotlight-landscape":
         case "spotlight-portrait":
           return combineLatest(
-            [l.spotlight.media$, ...l.grid.map((vm) => vm.media$)],
+            [l.spotlight.vm.media$, ...l.grid.map((vm) => vm.media$)],
             (spotlight, ...grid) => ({
               type: l.type,
               spotlight: spotlight.map((vm) => vm.id),
@@ -186,7 +176,7 @@ function summarizeLayout$(l$: Observable<Layout>): Observable<LayoutSummary> {
           );
         case "spotlight-expanded":
           return combineLatest(
-            [l.spotlight.media$, l.pip?.media$ ?? constant(undefined)],
+            [l.spotlight.media$, l.pip?.vm.media$ ?? constant(undefined)],
             (spotlight, pip) => ({
               type: l.type,
               spotlight: spotlight.map((vm) => vm.id),
@@ -195,7 +185,7 @@ function summarizeLayout$(l$: Observable<Layout>): Observable<LayoutSummary> {
           );
         case "one-on-one-desktop":
           return combineLatest(
-            [l.spotlight.media$, l.pip.media$],
+            [l.spotlight.media$, l.pip.vm.media$],
             (spotlight, pip) => ({
               type: l.type,
               spotlight: spotlight.id,
@@ -206,8 +196,8 @@ function summarizeLayout$(l$: Observable<Layout>): Observable<LayoutSummary> {
           return combineLatest(
             [
               l.spotlight.media$,
-              l.pip?.media$ ?? constant(undefined),
-              l.pipSize$,
+              l.pip?.vm.media$ ?? constant(undefined),
+              l.pip?.size$ ?? constant(undefined),
             ],
             (spotlight, pip, pipSize) => ({
               type: l.type,
@@ -516,7 +506,7 @@ describe.each(modes)("CallViewModel (%s mode)", (mode) => {
                 type: "one-on-one-mobile",
                 spotlight: [`${aliceId}:0`],
                 pip: undefined,
-                pipSize: "lg",
+                pipSize: undefined,
               },
               b: {
                 type: "one-on-one-mobile",
@@ -554,7 +544,7 @@ describe.each(modes)("CallViewModel (%s mode)", (mode) => {
               type: "one-on-one-mobile",
               spotlight: [`${aliceId}:0`],
               pip: undefined,
-              pipSize: "lg",
+              pipSize: undefined,
             },
           });
           // It wouldn't be clear whether Alice or Bob is the remote video tile,
@@ -602,7 +592,7 @@ describe.each(modes)("CallViewModel (%s mode)", (mode) => {
                 type: "one-on-one-mobile",
                 spotlight: [`${aliceId}:0`],
                 pip: undefined,
-                pipSize: "sm",
+                pipSize: undefined,
               },
               b: {
                 type: "spotlight-landscape",
@@ -801,7 +791,7 @@ describe.each(modes)("CallViewModel (%s mode)", (mode) => {
                 type: "one-on-one-mobile",
                 spotlight: [`${aliceId}:0`],
                 pip: undefined,
-                pipSize: "lg",
+                pipSize: undefined,
               },
               b: {
                 // In a larger window, expect the one-on-one desktop layout
@@ -1674,73 +1664,3 @@ describe("callViewModelOptionsFromParams", () => {
     expect(callViewModelOptionsFromParams(params).hideScreensharing).toBe(true);
   });
 });
-
-describe("a camera with a video processor", () => {
-  const withCallViewModel = withCallViewModelInMode(MatrixRTCMode.Matrix_2_0);
-  const processor = { name: "effect" } as VideoProcessor;
-
-  /** The handler the view model gives the camera's mute switch. */
-  const cameraHandler = (setHandler: {
-    mock: { calls: [Handler][] };
-  }): Handler => setHandler.mock.calls[1][0];
-
-  it("starts each camera track with the processor", () => {
-    const muteStates = mockMuteStates();
-    vi.spyOn(muteStates.video.enabled$, "value", "get").mockReturnValue(true);
-    expect(
-      initialPublishRequests(
-        muteStates,
-        mockMediaDevices({}),
-        {},
-        processor,
-      ).find((request) => request.source === "camera"),
-    ).toMatchObject({ processor });
-  });
-
-  it("replaces a camera turned off before the processor was chosen", async () => {
-    const setHandler = vi.spyOn(MuteState.prototype, "setHandler");
-    onTestFinished(() => setHandler.mockRestore());
-    const videoProcessor$ = new BehaviorSubject<VideoProcessor | undefined>(
-      undefined,
-    );
-    let participation: RTCParticipation | undefined;
-    withCallViewModel(
-      {},
-      (_vm, _session, { rtcParticipation }) => {
-        participation = rtcParticipation;
-      },
-      { videoProcessor$ },
-    );
-    // The camera is off, so it is stopped and can't take the processor
-    videoProcessor$.next(processor);
-    await cameraHandler(setHandler)(true);
-    await flushPromises();
-
-    expect(participation!.unpublish).toHaveBeenCalledWith("camera");
-    expect(participation!.publish).toHaveBeenCalledWith(
-      expect.objectContaining({ source: "camera", processor }),
-    );
-  });
-
-  it("turns on a camera that took the processor while running", async () => {
-    const setHandler = vi.spyOn(MuteState.prototype, "setHandler");
-    onTestFinished(() => setHandler.mockRestore());
-    const videoProcessor$ = new BehaviorSubject<VideoProcessor | undefined>(
-      undefined,
-    );
-    let participation: RTCParticipation | undefined;
-    withCallViewModel(
-      { videoEnabled: new Map([[localParticipant, constant(true)]]) },
-      (_vm, _session, { rtcParticipation }) => {
-        participation = rtcParticipation;
-      },
-      { videoProcessor$ },
-    );
-    videoProcessor$.next(processor);
-    await cameraHandler(setHandler)(true);
-    await flushPromises();
-
-    expect(participation!.unpublish).not.toHaveBeenCalled();
-    expect(participation!.publish).not.toHaveBeenCalled();
-  });
-});

src/state/CallViewModel/CallViewModel.ts

@@ -78,14 +78,13 @@ import {
   type ReactionInfo,
   type ReactionOption,
 } from "../../reactions";
-import { shallowEquals as shallowArrayEquals } from "../../utils/array";
-import { shallowEquals as shallowObjectEquals } from "../../utils/object";
+import { shallowEquals as arrayShallowEquals } from "../../utils/array";
 import { type MediaDevice, type MediaDevices } from "../MediaDevices";
 import { type Handler, type MuteStates } from "../MuteStates";
 import { HeaderStyle, type UrlParams } from "../../UrlParams";
 import { type HostBridge, nullHostBridge } from "../../HostBridge";
 import {
-  type Alignment,
+  layoutShallowEquals,
   type Layout,
   type LayoutMedia,
   type WindowMode,
@@ -126,6 +125,7 @@ import {
   type RingingMediaViewModel,
 } from "../media/RingingMediaViewModel.ts";
 import { type GridTileViewModel } from "../TileViewModel.ts";
+import { createFloatingTile } from "../FloatingTile.ts";
 
 /** How a call captures and encodes the tracks it publishes. */
 export interface CaptureSettings {
@@ -135,16 +135,14 @@ export interface CaptureSettings {
 }
 
 /**
- * What to publish for a microphone or camera: the device the user picked, the
- * host's capture settings and, for the camera, the video processor, so that
- * the track starts with it rather than letting the room through while it is
- * built.
+ * What to publish for a microphone or camera: the device the user picked and
+ * the host's capture settings. The video processor is not in here; the call
+ * attaches it to the camera track once that exists.
  */
 export function publishRequest(
   source: "microphone" | "camera",
   mediaDevices: MediaDevices,
   capture: CaptureSettings,
-  processor?: VideoProcessor,
 ): PublishRequest {
   return source === "microphone"
     ? {
@@ -156,7 +154,6 @@ export function publishRequest(
         source,
         deviceId: mediaDevices.videoInput.selected$.value?.id,
         capture: capture.camera,
-        ...(processor && { processor }),
       };
 }
 
@@ -165,13 +162,12 @@ export function initialPublishRequests(
   muteStates: MuteStates,
   mediaDevices: MediaDevices,
   capture: CaptureSettings,
-  processor?: VideoProcessor,
 ): PublishRequest[] {
   const requests: PublishRequest[] = [];
   if (muteStates.audio.enabled$.value)
     requests.push(publishRequest("microphone", mediaDevices, capture));
   if (muteStates.video.enabled$.value)
-    requests.push(publishRequest("camera", mediaDevices, capture, processor));
+    requests.push(publishRequest("camera", mediaDevices, capture));
   return requests;
 }
 
@@ -507,17 +503,6 @@ export function createCallViewModel$(
     "screenShare",
   ) as Behavior<LocalVideoMediaTrack | undefined>;
 
-  // Camera tracks the processor reached while they ran. A camera turned off is
-  // stopped, and a stopped track can't take one.
-  const tookProcessor = new WeakMap<LocalVideoMediaTrack, VideoProcessor>();
-  const missesProcessor = (track: LocalMediaTrack): boolean => {
-    const processor = videoProcessor$.value;
-    return (
-      processor !== undefined &&
-      tookProcessor.get(track as LocalVideoMediaTrack) !== processor
-    );
-  };
-
   // The mute switches drive our tracks, which report back what the device
   // allowed, so a denied permission flips the switch back. A source is muted
   // and unmuted while its track exists and published when it does not.
@@ -535,23 +520,14 @@ export function createCallViewModel$(
     muteState.setHandler(async (enabled) => {
       desired = enabled;
       const track = track$.value;
-      // A camera turned off before the processor was chosen is replaced, so
-      // that the new one starts with it.
-      if (enabled && source === "camera" && track && missesProcessor(track))
-        await rtcParticipation.unpublish("camera");
-      else if (track !== undefined) {
+      if (track !== undefined) {
         desired = await track.setEnabled(enabled);
         return desired;
       }
       if (!enabled) return false;
       try {
         await rtcParticipation.publish(
-          publishRequest(
-            source,
-            mediaDevices,
-            capture,
-            source === "camera" ? videoProcessor$.value : undefined,
-          ),
+          publishRequest(source, mediaDevices, capture),
         );
         return true;
       } catch (e) {
@@ -607,15 +583,12 @@ export function createCallViewModel$(
         });
       });
 
-  // Also set on each camera track as it appears and as the choice changes. A
-  // track made with the processor already runs it and is left alone.
+  // Attached once the camera track exists rather than carried in the publish
+  // request, so that a new track and a change of processor take the same path
   combineLatest([camera$, videoProcessor$])
     .pipe(scope.bind())
     .subscribe(([camera, processor]) => {
-      if (camera === undefined) return;
-      if (processor && !camera.muted$.value)
-        tookProcessor.set(camera, processor);
-      camera.setProcessor(processor).catch((e) => {
+      camera?.setProcessor(processor).catch((e) => {
         logger.error("Failed to set the video processor", e);
       });
     });
@@ -857,7 +830,7 @@ export function createCallViewModel$(
               bins.sort(([, bin1], [, bin2]) => bin1 - bin2).map(([m]) => m),
             );
       }),
-      distinctUntilChanged(shallowArrayEquals),
+      distinctUntilChanged(arrayShallowEquals),
     ),
   );
 
@@ -889,13 +862,18 @@ export function createCallViewModel$(
       [ringingMedia$, screenShares$, spotlightSpeaker$, localUserMediaForPip$],
       (ringing, screenShares, speaker, localPip) =>
         computeSpotlight({ ringing, screenShares, speaker, localPip }),
-    ).pipe(distinctUntilChanged(shallowObjectEquals)),
+    ).pipe(
+      distinctUntilChanged(
+        (a, b) =>
+          arrayShallowEquals(a.spotlight, b.spotlight) && a.pip === b.pip,
+      ),
+    ),
   );
 
   const spotlight$ = scope.behavior<MediaViewModel[]>(
     spotlightAndPip$.pipe(
       map(({ spotlight }) => spotlight),
-      distinctUntilChanged<MediaViewModel[]>(shallowArrayEquals),
+      distinctUntilChanged<MediaViewModel[]>(arrayShallowEquals),
     ),
   );
 
@@ -1056,7 +1034,7 @@ export function createCallViewModel$(
           desktop: platform === "desktop",
         }),
       ),
-      distinctUntilChanged(shallowObjectEquals<LayoutMedia>),
+      distinctUntilChanged(layoutShallowEquals),
     ),
   );
 
@@ -1248,32 +1226,28 @@ export function createCallViewModel$(
   );
 
   /**
-   * The alignment of the floating spotlight tile, if present.
+   * State of the floating spotlight tile, if present.
    */
-  const spotlightAlignment$ = new BehaviorSubject<Alignment>({
+  const floatingSpotlightTile = createFloatingTile(scope, {
     inline: "end",
     block: "end",
   });
   /**
-   * The size of the small picture-in-picture tile, if present, when in portrait.
+   * State of the small picture-in-picture tile, if present, when in landscape.
    */
-  const portraitPipSize$ = scope.behavior(
-    showFooter$.pipe(map((showFooter) => (showFooter ? "lg" : "sm"))),
-  );
-  /**
-   * The alignment of the small picture-in-picture tile, if present, when in portrait.
-   */
-  const portraitPipAlignment$ = new BehaviorSubject<Alignment>({
-    inline: "end",
-    block: "end",
-  });
-  /**
-   * The alignment of the small picture-in-picture tile, if present, when in landscape.
-   */
-  const landscapePipAlignment$ = new BehaviorSubject<Alignment>({
+  const landscapePipTile = createFloatingTile(scope, {
     inline: "end",
     block: "start",
   });
+  /**
+   * State of the small picture-in-picture tile, if present, when in portrait.
+   */
+  const portraitPipTile = {
+    ...createFloatingTile(scope, { inline: "end", block: "end" }),
+    size$: scope.behavior(
+      showFooter$.pipe(map((showFooter) => (showFooter ? "lg" : "sm"))),
+    ),
+  };
 
   // There is a cyclical dependency here: the layout algorithms want to know
   // which tiles are on screen, but to know which tiles are on screen we have to
@@ -1303,7 +1277,7 @@ export function createCallViewModel$(
             case "spotlight-portrait":
               [layout, newTiles] = gridLikeLayout(
                 media,
-                spotlightAlignment$,
+                floatingSpotlightTile,
                 visibleTiles,
                 setVisibleTiles,
                 prevTiles,
@@ -1313,26 +1287,25 @@ export function createCallViewModel$(
             case "spotlight-expanded":
               [layout, newTiles] = spotlightExpandedLayout(
                 media,
-                landscapePipAlignment$,
+                landscapePipTile,
                 prevTiles,
               );
               break;
             case "one-on-one-desktop":
               [layout, newTiles] = oneOnOneDesktopLayout(
                 media,
-                landscapePipAlignment$,
+                landscapePipTile,
                 prevTiles,
               );
-              pip = layout.pip;
+              pip = layout.pip.vm;
               break;
             case "one-on-one-mobile":
               [layout, newTiles] = oneOnOneMobileLayout(
                 media,
-                portraitPipSize$,
-                portraitPipAlignment$,
+                portraitPipTile,
                 prevTiles,
               );
-              pip = layout.pip;
+              pip = layout.pip?.vm;
               break;
             case "pip":
               [layout, newTiles] = pipLayout(media, prevTiles);
@@ -1357,7 +1330,7 @@ export function createCallViewModel$(
     layoutInternals$.pipe(
       map(({ layout }) => layout),
       // Drop redundant layout updates before they would hit React.
-      distinctUntilChanged(shallowObjectEquals<Layout>),
+      distinctUntilChanged(layoutShallowEquals),
     ),
   );
 

src/state/FloatingTile.test.ts

@@ -0,0 +1,38 @@
+/*
+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 { test } from "vitest";
+import { withTestScheduler } from "../utils/test";
+import { createFloatingTile } from "./FloatingTile";
+
+test("FloatingTile changes alignment on drag", () =>
+  withTestScheduler(({ scope, expectObservable, schedule }) => {
+    // Tile starts in the top left
+    const { alignment$, onDrag } = createFloatingTile(scope, {
+      inline: "start",
+      block: "start",
+    });
+    // Drag to all four corners, and then repeatedly into the top left.
+    schedule("-↗↘↙↖↖", {
+      "↗": () =>
+        onDrag({ x: 100, y: 0, xRatio: 1, yRatio: 0, endOfGesture: false }),
+      "↘": () =>
+        onDrag({ x: 100, y: 100, xRatio: 1, yRatio: 1, endOfGesture: false }),
+      "↙": () =>
+        onDrag({ x: 0, y: 100, xRatio: 0, yRatio: 1, endOfGesture: false }),
+      "↖": () =>
+        onDrag({ x: 0, y: 0, xRatio: 0, yRatio: 0, endOfGesture: false }),
+    });
+    // Alignment should change accordingly. Notably, the alignment should *not*
+    // update when repeatedly dragged into the same corner, for performance.
+    expectObservable(alignment$).toBe("↖↗↘↙↖-", {
+      "↗": { inline: "end", block: "start" },
+      "↘": { inline: "end", block: "end" },
+      "↙": { inline: "start", block: "end" },
+      "↖": { inline: "start", block: "start" },
+    });
+  }));

src/state/FloatingTile.ts

@@ -0,0 +1,43 @@
+/*
+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 { distinctUntilChanged, map, startWith, Subject } from "rxjs";
+
+import { type Behavior } from "./Behavior";
+import { type DragCallback, type Alignment, type Drag } from "./layout-types";
+import { type ObservableScope } from "./ObservableScope";
+
+/**
+ * Represents a floating tile which may be dragged to different corners of the
+ * call interface.
+ */
+export interface FloatingTile {
+  alignment$: Behavior<Alignment>;
+  onDrag: DragCallback;
+}
+
+export function createFloatingTile(
+  scope: ObservableScope,
+  defaultAlignment: Alignment,
+): FloatingTile {
+  const dragEvents$ = new Subject<Drag>();
+  return {
+    alignment$: scope.behavior(
+      dragEvents$.pipe(
+        map<Drag, Alignment>(({ xRatio, yRatio }) => ({
+          inline: xRatio < 0.5 ? "start" : "end",
+          block: yRatio < 0.5 ? "start" : "end",
+        })),
+        startWith(defaultAlignment),
+        distinctUntilChanged(
+          (a1, a2) => a1.inline === a2.inline && a1.block === a2.block,
+        ),
+      ),
+    ),
+    onDrag: (drag) => dragEvents$.next(drag),
+  };
+}

src/state/GridLikeLayout.ts

@@ -5,14 +5,9 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { type BehaviorSubject } from "rxjs";
-
-import {
-  type Alignment,
-  type Layout,
-  type LayoutMedia,
-} from "./layout-types.ts";
+import { type Layout, type LayoutMedia } from "./layout-types.ts";
 import { type TileStore } from "./TileStore";
+import { type FloatingTile } from "./FloatingTile.ts";
 
 export type GridLikeLayoutType =
   | "grid"
@@ -25,7 +20,7 @@ export type GridLikeLayoutType =
  */
 export function gridLikeLayout(
   media: LayoutMedia & { type: GridLikeLayoutType },
-  spotlightAlignment$: BehaviorSubject<Alignment>,
+  floatingSpotlightTile: FloatingTile,
   visibleTiles: number,
   setVisibleTiles: (value: number) => void,
   prevTiles: TileStore,
@@ -42,9 +37,11 @@ export function gridLikeLayout(
   return [
     {
       type: media.type,
-      spotlight: tiles.spotlightTile,
+      spotlight: tiles.spotlightTile && {
+        vm: tiles.spotlightTile,
+        ...floatingSpotlightTile,
+      },
       grid: tiles.gridTiles,
-      spotlightAlignment$,
       setVisibleTiles,
     } as Layout & { type: GridLikeLayoutType },
     tiles,

src/state/OneOnOneDesktopLayout.ts

@@ -6,21 +6,19 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { type BehaviorSubject } from "rxjs";
-
 import {
-  type Alignment,
   type OneOnOneDesktopLayout,
   type OneOnOneDesktopLayoutMedia,
 } from "./layout-types";
 import { type TileStore } from "./TileStore";
+import { type FloatingTile } from "./FloatingTile";
 
 /**
  * Produces a one-on-one desktop layout with the given media.
  */
 export function oneOnOneDesktopLayout(
   media: OneOnOneDesktopLayoutMedia,
-  pipAlignment$: BehaviorSubject<Alignment>,
+  pipTile: FloatingTile,
   prevTiles: TileStore,
 ): [OneOnOneDesktopLayout, TileStore] {
   const update = prevTiles.from(2);
@@ -32,8 +30,7 @@ export function oneOnOneDesktopLayout(
     {
       type: media.type,
       spotlight: tiles.gridTilesByMedia.get(media.spotlight)!,
-      pip: tiles.gridTilesByMedia.get(media.pip)!,
-      pipAlignment$,
+      pip: { vm: tiles.gridTilesByMedia.get(media.pip)!, ...pipTile },
     },
     tiles,
   ];

src/state/OneOnOneMobileLayout.ts

@@ -6,23 +6,20 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { type BehaviorSubject } from "rxjs";
-
 import {
-  type Alignment,
   type OneOnOneMobileLayout,
   type OneOnOneMobileLayoutMedia,
 } from "./layout-types";
 import { type TileStore } from "./TileStore";
 import { type Behavior } from "./Behavior";
+import { type FloatingTile } from "./FloatingTile";
 
 /**
  * Produces a one-on-one mobile layout with the given media.
  */
 export function oneOnOneMobileLayout(
   media: OneOnOneMobileLayoutMedia,
-  pipSize$: Behavior<"sm" | "lg">,
-  pipAlignment$: BehaviorSubject<Alignment>,
+  pipTile: FloatingTile & { size$: Behavior<"sm" | "lg"> },
   prevTiles: TileStore,
 ): [OneOnOneMobileLayout, TileStore] {
   const update = prevTiles.from(media.pip === undefined ? 0 : 1);
@@ -30,13 +27,12 @@ export function oneOnOneMobileLayout(
   if (media.pip !== undefined) update.registerGridTile(media.pip);
   const tiles = update.build();
 
+  const pipVm = media.pip && tiles.gridTilesByMedia.get(media.pip);
   return [
     {
       type: media.type,
       spotlight: tiles.spotlightTile!,
-      pip: media.pip && tiles.gridTilesByMedia.get(media.pip),
-      pipSize$,
-      pipAlignment$,
+      pip: pipVm && { vm: pipVm, ...pipTile },
     },
     tiles,
   ];

src/state/SpotlightExpandedLayout.ts

@@ -5,21 +5,19 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { type BehaviorSubject } from "rxjs";
-
 import {
-  type Alignment,
   type SpotlightExpandedLayout,
   type SpotlightExpandedLayoutMedia,
 } from "./layout-types";
 import { type TileStore } from "./TileStore";
+import { type FloatingTile } from "./FloatingTile";
 
 /**
  * Produces an expanded spotlight layout with the given media.
  */
 export function spotlightExpandedLayout(
   media: SpotlightExpandedLayoutMedia,
-  pipAlignment$: BehaviorSubject<Alignment>,
+  pipTile: FloatingTile,
   prevTiles: TileStore,
 ): [SpotlightExpandedLayout, TileStore] {
   const update = prevTiles.from(1);
@@ -27,12 +25,12 @@ export function spotlightExpandedLayout(
   if (media.pip !== undefined) update.registerPipTile(media.pip);
   const tiles = update.build();
 
+  const pipVm = tiles.gridTiles.at(0);
   return [
     {
       type: media.type,
       spotlight: tiles.spotlightTile!,
-      pip: tiles.gridTiles.at(0),
-      pipAlignment$,
+      pip: pipVm && { vm: pipVm, ...pipTile },
     },
     tiles,
   ];

src/state/layout-types.test.ts

@@ -0,0 +1,82 @@
+/*
+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 { test, expect } from "vitest";
+import { layoutShallowEquals, type Layout } from "./layout-types";
+import {
+  type SpotlightTileViewModel,
+  type GridTileViewModel,
+} from "./TileViewModel";
+import { type FloatingTile } from "./FloatingTile";
+
+const spotlightTile = {} as unknown as SpotlightTileViewModel;
+const gridTile = {} as unknown as GridTileViewModel;
+const pipTile = {} as unknown as FloatingTile & { vm: GridTileViewModel };
+
+const spotlightExpanded: Layout = {
+  type: "spotlight-expanded",
+  spotlight: spotlightTile,
+};
+
+const spotlightPortrait: Layout = {
+  type: "spotlight-portrait",
+  spotlight: { vm: spotlightTile },
+  grid: [gridTile],
+  setVisibleTiles: () => {},
+};
+
+test("layoutShallowEquals considers a layout to be equal to its shallow clone", () =>
+  expect(layoutShallowEquals(spotlightExpanded, { ...spotlightExpanded })).toBe(
+    true,
+  ));
+
+test("layoutShallowEquals detects a missing key", () => {
+  expect(
+    layoutShallowEquals(spotlightExpanded, {
+      ...spotlightExpanded,
+      pip: pipTile,
+    }),
+  ).toBe(false);
+  expect(
+    layoutShallowEquals(
+      { ...spotlightExpanded, pip: pipTile },
+      spotlightExpanded,
+    ),
+  ).toBe(false);
+});
+
+test("layoutShallowEquals considers tile wrappers with equal contents to be equal", () =>
+  expect(
+    layoutShallowEquals(spotlightPortrait, {
+      ...spotlightPortrait,
+      spotlight: { vm: spotlightTile },
+    }),
+  ).toBe(true));
+
+test("layoutShallowEquals detects tile wrappers with different contents", () =>
+  expect(
+    layoutShallowEquals(spotlightPortrait, {
+      ...spotlightPortrait,
+      spotlight: { vm: {} as unknown as SpotlightTileViewModel },
+    }),
+  ).toBe(false));
+
+test("layoutShallowEquals considers grid arrays with equal contents to be equal", () =>
+  expect(
+    layoutShallowEquals(spotlightPortrait, {
+      ...spotlightPortrait,
+      grid: [...spotlightPortrait.grid],
+    }),
+  ).toBe(true));
+
+test("layoutShallowEquals detects grid arrays with different contents", () =>
+  expect(
+    layoutShallowEquals(spotlightPortrait, {
+      ...spotlightPortrait,
+      grid: [...spotlightPortrait.grid, gridTile],
+    }),
+  ).toBe(false));

src/state/layout-types.ts

@@ -5,8 +5,6 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { type BehaviorSubject } from "rxjs";
-
 import { type LocalUserMediaViewModel } from "./media/LocalUserMediaViewModel.ts";
 import { type MediaViewModel } from "./media/MediaViewModel.ts";
 import { type RingingMediaViewModel } from "./media/RingingMediaViewModel.ts";
@@ -16,6 +14,9 @@ import {
   type SpotlightTileViewModel,
 } from "./TileViewModel.ts";
 import { type Behavior } from "./Behavior.ts";
+import { type FloatingTile } from "./FloatingTile.ts";
+import { shallowEquals } from "../utils/object.ts";
+import { shallowEquals as arrayShallowEquals } from "../utils/array.ts";
 
 /**
  * The general shape of the space the call is drawn in. Called a window because
@@ -86,24 +87,48 @@ export interface Alignment {
   block: "start" | "end";
 }
 
+export interface Drag {
+  /**
+   * The X offset of the dragged tile relative to its container.
+   */
+  x: number;
+  /**
+   * The Y offset of the dragged tile relative to its container.
+   */
+  y: number;
+  /**
+   * The X coordinate of the dragged tile, as a scalar of the container's width.
+   */
+  xRatio: number;
+  /**
+   * The Y coordinate of the dragged tile, as a scalar of the container's height.
+   */
+  yRatio: number;
+  /**
+   * Whether this event ends the drag gesture.
+   */
+  endOfGesture: boolean;
+}
+
+export type DragCallback = (drag: Drag) => void;
+
 export interface GridLayout {
   type: "grid";
-  spotlight?: SpotlightTileViewModel;
+  spotlight?: FloatingTile & { vm: SpotlightTileViewModel };
   grid: GridTileViewModel[];
-  spotlightAlignment$: BehaviorSubject<Alignment>;
   setVisibleTiles: (value: number) => void;
 }
 
 export interface SpotlightLandscapeLayout {
   type: "spotlight-landscape";
-  spotlight: SpotlightTileViewModel;
+  spotlight: { vm: SpotlightTileViewModel };
   grid: GridTileViewModel[];
   setVisibleTiles: (value: number) => void;
 }
 
 export interface SpotlightPortraitLayout {
   type: "spotlight-portrait";
-  spotlight: SpotlightTileViewModel;
+  spotlight: { vm: SpotlightTileViewModel };
   grid: GridTileViewModel[];
   setVisibleTiles: (value: number) => void;
 }
@@ -111,23 +136,19 @@ export interface SpotlightPortraitLayout {
 export interface SpotlightExpandedLayout {
   type: "spotlight-expanded";
   spotlight: SpotlightTileViewModel;
-  pip?: GridTileViewModel;
-  pipAlignment$: BehaviorSubject<Alignment>;
+  pip?: FloatingTile & { vm: GridTileViewModel };
 }
 
 export interface OneOnOneDesktopLayout {
   type: "one-on-one-desktop";
   spotlight: GridTileViewModel;
-  pip: GridTileViewModel;
-  pipAlignment$: BehaviorSubject<Alignment>;
+  pip: FloatingTile & { vm: GridTileViewModel };
 }
 
 export interface OneOnOneMobileLayout {
   type: "one-on-one-mobile";
   spotlight: SpotlightTileViewModel;
-  pip?: GridTileViewModel;
-  pipSize$: Behavior<"sm" | "lg">;
-  pipAlignment$: BehaviorSubject<Alignment>;
+  pip?: FloatingTile & { vm: GridTileViewModel; size$: Behavior<"sm" | "lg"> };
 }
 
 export interface PipLayout {
@@ -147,3 +168,34 @@ export type Layout =
   | OneOnOneDesktopLayout
   | OneOnOneMobileLayout
   | PipLayout;
+
+/**
+ * Tests whether the top-level properties, tile wrapper properties, and array
+ * elements of layout `a` are equal to those of layout `b`. Useful for deduping
+ * redundant layout updates.
+ */
+export function layoutShallowEquals<T extends Layout | LayoutMedia>(
+  a: T,
+  b: T,
+): boolean {
+  return shallowEquals<T>(a, b, (aValue, bValue) => {
+    // Special case for tile wrapper objects so we can detect when the
+    // spotlight or PiP tile is essentially the same
+    if (
+      typeof aValue === "object" &&
+      aValue !== null &&
+      "vm" in aValue &&
+      typeof bValue === "object" &&
+      bValue !== null &&
+      "vm" in bValue
+    )
+      return shallowEquals(aValue, bValue);
+
+    // Special case for arrays so we can detect when the grid tile arrays are
+    // essentially the same
+    if (Array.isArray(aValue) && Array.isArray(bValue))
+      return arrayShallowEquals(aValue, bValue);
+
+    return aValue === bValue;
+  });
+}

src/state/media/MediaViewModel.test.ts

@@ -235,22 +235,35 @@ test("audio and video follow the tracks' mute state", () => {
 
 test("user media polls stream stats only while the setting is on", () => {
   onTestFinished(() => showConnectionStats.setValue(false));
+
   withTestScheduler(({ cold, expectObservable, schedule }) => {
     const stats = { type: "inbound-rtp" } as RTCInboundRtpStreamStats;
     const vm = mockRemoteMedia(rtcMembership, {}, [
-      mockAudioTrack({
-        stats$: () => cold("-s", { s: stats }),
-      }),
+      mockAudioTrack({ stats$: () => cold("-s", { s: { ...stats } }) }),
     ]);
-    schedule("-a-b", {
-      a() {
-        showConnectionStats.setValue(true);
-      },
-      b() {
-        showConnectionStats.setValue(false);
-      },
+    schedule("-t-f-t", {
+      t: () => showConnectionStats.setValue(true),
+      f: () => showConnectionStats.setValue(false),
     });
-    expectObservable(vm.audioStreamStats$).toBe("u-su", {
+
+    expectObservable(vm.audioStreamStats$).toBe("u-s---s", {
+      u: undefined,
+      s: stats,
+    });
+  });
+});
+
+test("stream stats can be enabled before creating media", () => {
+  showConnectionStats.setValue(true);
+  onTestFinished(() => showConnectionStats.setValue(false));
+
+  withTestScheduler(({ cold, expectObservable }) => {
+    const stats = { type: "inbound-rtp" } as RTCInboundRtpStreamStats;
+    const vm = mockRemoteMedia(rtcMembership, {}, [
+      mockAudioTrack({ stats$: () => cold("-s", { s: stats }) }),
+    ]);
+
+    expectObservable(vm.audioStreamStats$).toBe("us", {
       u: undefined,
       s: stats,
     });

src/state/media/UserMediaViewModel.ts

@@ -16,7 +16,9 @@ import {
   BehaviorSubject,
   combineLatest,
   map,
+  NEVER,
   of,
+  startWith,
   Subject,
   switchMap,
 } from "rxjs";
@@ -105,10 +107,9 @@ export function createBaseUserMedia(
         showConnectionStats.value$,
       ]).pipe(
         switchMap(([track, show]) =>
-          track !== undefined && show
-            ? track.stats$(statsIntervalMs)
-            : of(undefined),
+          track !== undefined && show ? track.stats$(statsIntervalMs) : NEVER,
         ),
+        startWith<MediaStreamStats>(undefined),
       ),
     );
 

src/tracks/BackgroundEffectTransformer.test.ts

@@ -1,81 +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 { afterEach, describe, expect, it, vi } from "vitest";
-import {
-  BackgroundTransformer,
-  VideoTransformer,
-  type VideoTransformerInitOptions,
-} from "@livekit/track-processors";
-import { ImageSegmenter } from "@mediapipe/tasks-vision";
-
-import { BackgroundEffectTransformer } from "./BackgroundEffectTransformer";
-
-const frame = {} as VideoFrame;
-const controller = {} as TransformStreamDefaultController<VideoFrame>;
-
-describe("BackgroundEffectTransformer", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("loads a background chosen before it was built", async () => {
-    vi.spyOn(VideoTransformer.prototype, "init").mockResolvedValue();
-    vi.spyOn(ImageSegmenter, "createFromOptions").mockResolvedValue(
-      {} as ImageSegmenter,
-    );
-    const load = vi
-      .spyOn(BackgroundTransformer.prototype, "loadAndSetBackground")
-      .mockResolvedValue();
-    const transformer = new BackgroundEffectTransformer({
-      backgroundDisabled: true,
-    });
-    // Chosen before the camera is processed, as the first effect always is:
-    // loaded then, there is nothing yet to draw it with.
-    await transformer.update({ imagePath: "/background.jpg" });
-    load.mockClear();
-
-    await transformer.init({} as VideoTransformerInitOptions);
-    expect(load).toHaveBeenCalledWith("/background.jpg");
-  });
-
-  it("reports the first frame carrying an effect, once", async () => {
-    vi.spyOn(BackgroundTransformer.prototype, "transform").mockImplementation(
-      async function (this: BackgroundTransformer) {
-        this.isFirstFrame = false;
-        return Promise.resolve();
-      },
-    );
-    const transformer = new BackgroundEffectTransformer({});
-    transformer.onFirstFrame = vi.fn();
-
-    await transformer.transform(frame, controller);
-    await transformer.transform(frame, controller);
-    expect(transformer.onFirstFrame).toHaveBeenCalledTimes(1);
-  });
-
-  it("does not report a frame passed through untouched", async () => {
-    vi.spyOn(BackgroundTransformer.prototype, "transform").mockResolvedValue();
-    const transformer = new BackgroundEffectTransformer({
-      backgroundDisabled: true,
-    });
-    transformer.onFirstFrame = vi.fn();
-
-    await transformer.transform(frame, controller);
-    expect(transformer.onFirstFrame).not.toHaveBeenCalled();
-  });
-
-  it("passes frames on untouched once disabled, even after blurring", async () => {
-    const transformer = new BackgroundEffectTransformer({});
-    await transformer.update({ blurRadius: 15, backgroundDisabled: false });
-    await transformer.update({
-      imagePath: undefined,
-      backgroundDisabled: true,
-    });
-    // With neither, the library passes a frame on without segmenting it.
-    expect(transformer.options.blurRadius).toBeUndefined();
-    expect(transformer.options.imagePath).toBeUndefined();
-  });
-});

src/tracks/BackgroundEffectsContext.test.ts

@@ -1,296 +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 { act, createElement, type FC } from "react";
-import { render } from "@testing-library/react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { type LocalVideoTrack } from "livekit-client";
-import {
-  type BackgroundOptions,
-  type ProcessorWrapper,
-} from "@livekit/track-processors";
-import {
-  convertToLivekitProcessor,
-  type VideoProcessor,
-} from "@element-hq/matrixrtc-sdk";
-
-import {
-  applyProcessor,
-  fromLivekitProcessor,
-  BackgroundEffectsProvider,
-  type BackgroundEffectsState,
-  syncBackgroundEffects,
-  useBackgroundEffects,
-  useSyncBackgroundEffects,
-  createAppBackgroundEffects,
-} from "./BackgroundEffectsContext";
-import { type BackgroundEffects } from "../state/BackgroundEffects";
-import { backgroundEffect } from "../settings/settings";
-import { constant } from "../state/Behavior";
-import { flushPromises, testScope } from "../utils/test";
-
-const pipelines = vi.hoisted(() => ({
-  built: 0,
-  destroyed: 0,
-  switches: [] as unknown[],
-}));
-
-// The pipeline itself needs WebGL and MediaPipe; what these tests are about is
-// what the provider asks of it.
-vi.mock("@livekit/track-processors", () => ({
-  BackgroundProcessorWrapper: vi.fn(function (this: Record<string, unknown>) {
-    pipelines.built += 1;
-    this.switchTo = vi.fn(async (options: unknown) => {
-      pipelines.switches.push(options);
-      return Promise.resolve();
-    });
-    this.destroy = vi.fn(async () => {
-      pipelines.destroyed += 1;
-      return Promise.resolve();
-    });
-  }),
-  supportsBackgroundProcessors: (): boolean => true,
-}));
-const platformMock = vi.hoisted(() => ({ platform: "desktop" }));
-vi.mock("../Platform", () => platformMock);
-vi.mock("./BackgroundEffectTransformer", () => ({
-  BackgroundEffectTransformer: vi.fn(),
-}));
-
-const processor = { name: "blur" } as VideoProcessor;
-
-function mockTrack(
-  readyState: MediaStreamTrackState,
-  current?: VideoProcessor,
-): LocalVideoTrack {
-  return {
-    mediaStreamTrack: { readyState },
-    getProcessor: vi.fn().mockReturnValue(current),
-    setProcessor: vi.fn().mockResolvedValue(undefined),
-    stopProcessor: vi.fn().mockResolvedValue(undefined),
-  } as unknown as LocalVideoTrack;
-}
-
-describe("applyProcessor", () => {
-  it("attaches the processor to a live track", () => {
-    const track = mockTrack("live");
-    applyProcessor(track, processor);
-    expect(track.setProcessor).toHaveBeenCalledWith(
-      expect.objectContaining({ name: "blur" }),
-    );
-  });
-
-  it("does not attach the processor to an ended track", () => {
-    const track = mockTrack("ended");
-    applyProcessor(track, processor);
-    expect(track.setProcessor).not.toHaveBeenCalled();
-  });
-
-  it("does not surface a rejected setProcessor", async () => {
-    const track = mockTrack("live");
-    vi.mocked(track.setProcessor).mockRejectedValue(
-      new TypeError("Input track cannot be ended"),
-    );
-    const unhandled = vi.fn();
-    process.on("unhandledRejection", unhandled);
-    applyProcessor(track, processor);
-    await flushPromises();
-    process.off("unhandledRejection", unhandled);
-    expect(unhandled).not.toHaveBeenCalled();
-  });
-
-  it("stops the processor when none is wanted", () => {
-    const track = mockTrack("live", processor);
-    applyProcessor(track, undefined);
-    expect(track.stopProcessor).toHaveBeenCalled();
-  });
-
-  it("does not surface a rejected stopProcessor", async () => {
-    const track = mockTrack("live", processor);
-    vi.mocked(track.stopProcessor).mockRejectedValue(new Error("nope"));
-    const unhandled = vi.fn();
-    process.on("unhandledRejection", unhandled);
-    applyProcessor(track, undefined);
-    await flushPromises();
-    process.off("unhandledRejection", unhandled);
-    expect(unhandled).not.toHaveBeenCalled();
-  });
-});
-
-describe("syncBackgroundEffects", () => {
-  it("applies the processor to the current track", () => {
-    const track = mockTrack("live");
-    syncBackgroundEffects(
-      testScope(),
-      constant(track),
-      constant({ supported: true, processor }),
-    );
-    expect(track.setProcessor).toHaveBeenCalledWith(
-      expect.objectContaining({ name: "blur" }),
-    );
-  });
-});
-
-describe("fromLivekitProcessor", () => {
-  const captured = { id: "captured" } as MediaStreamTrack;
-  const processed = { id: "processed" } as MediaStreamTrack;
-
-  function mockWrapper(
-    processedTrack: MediaStreamTrack | undefined,
-  ): ProcessorWrapper<BackgroundOptions> {
-    return {
-      name: "background-blur",
-      processedTrack,
-      init: vi.fn().mockResolvedValue(undefined),
-      restart: vi.fn().mockResolvedValue(undefined),
-      destroy: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ProcessorWrapper<BackgroundOptions>;
-  }
-
-  it("resolves with the track the wrapper produced", async () => {
-    const wrapper = mockWrapper(processed);
-    const sdkProcessor = fromLivekitProcessor(wrapper);
-    expect(sdkProcessor.name).toBe("background-blur");
-    await expect(sdkProcessor.init(captured)).resolves.toBe(processed);
-    expect(wrapper.init).toHaveBeenCalledWith({
-      kind: "video",
-      track: captured,
-    });
-    await expect(sdkProcessor.restart(captured)).resolves.toBe(processed);
-    await sdkProcessor.destroy();
-    expect(wrapper.destroy).toHaveBeenCalled();
-  });
-
-  it("rejects where the wrapper produced no track", async () => {
-    await expect(
-      fromLivekitProcessor(mockWrapper(undefined)).init(captured),
-    ).rejects.toThrow("produced no track");
-  });
-});
-
-describe("BackgroundEffectsProvider", () => {
-  /** A camera track that holds whatever processor it is given. */
-  function cameraTrack(): LocalVideoTrack {
-    let current: unknown;
-    return {
-      mediaStreamTrack: { readyState: "live" },
-      getProcessor: vi.fn(() => current),
-      setProcessor: vi.fn(async (next: unknown) => {
-        current = next;
-        return Promise.resolve();
-      }),
-      stopProcessor: vi.fn(async () => {
-        current = undefined;
-        return Promise.resolve();
-      }),
-    } as unknown as LocalVideoTrack;
-  }
-
-  let seen: BackgroundEffectsState[];
-  const Surface: FC<{ track: LocalVideoTrack | null }> = ({ track }) => {
-    seen.push(useBackgroundEffects());
-    useSyncBackgroundEffects(track);
-    return null;
-  };
-  // One component for every render, so a rerender updates the tree rather than
-  // mounting a second provider with a pipeline of its own.
-  let effects: BackgroundEffects | undefined;
-  const Surfaces: FC<{ tracks: (LocalVideoTrack | null)[] }> = ({ tracks }) =>
-    createElement(BackgroundEffectsProvider, {
-      // Made on first render, once a test has set up the platform.
-      effects: (effects ??= createAppBackgroundEffects(testScope())),
-      children: createElement(
-        "div",
-        null,
-        ...tracks.map((track, key) => createElement(Surface, { key, track })),
-      ),
-    });
-  const surfaces = (
-    ...tracks: (LocalVideoTrack | null)[]
-  ): ReturnType<typeof createElement> => createElement(Surfaces, { tracks });
-  const blur = async (on: boolean): Promise<void> => {
-    await act(async () => {
-      backgroundEffect.setValue(on ? "blur" : "none");
-      await flushPromises();
-    });
-  };
-  const latest = (): BackgroundEffectsState => seen[seen.length - 1];
-
-  beforeEach(() => {
-    seen = [];
-    effects = undefined;
-    pipelines.built = 0;
-    pipelines.destroyed = 0;
-    pipelines.switches = [];
-    platformMock.platform = "desktop";
-    backgroundEffect.setValue("none");
-  });
-  afterEach(() => backgroundEffect.setValue("none"));
-
-  // A pipeline primes itself when it is built and when it is destroyed, and a
-  // primed pipeline lets one frame through untouched: so the frame is spent
-  // once, as long as it is built once and never taken off the camera.
-  it("spends one priming frame on first use and none afterwards", async () => {
-    const track = cameraTrack();
-    render(surfaces(track));
-    for (const on of [true, false, true, false, true]) await blur(on);
-
-    expect(pipelines.built).toBe(1);
-    expect(pipelines.destroyed).toBe(0);
-    expect(track.setProcessor).toHaveBeenCalledTimes(1);
-    expect(track.stopProcessor).not.toHaveBeenCalled();
-  });
-
-  it("runs on a phone whose browser can run it", async () => {
-    platformMock.platform = "ios";
-    const track = cameraTrack();
-    render(surfaces(track));
-    await blur(true);
-
-    expect(latest().supported).toBe(true);
-    expect(track.setProcessor).toHaveBeenCalledWith(
-      convertToLivekitProcessor(latest().processor!),
-    );
-  });
-
-  it("preview and call share one pipeline", async () => {
-    const preview = cameraTrack();
-    const call = cameraTrack();
-    render(surfaces(preview, call));
-    await blur(true);
-
-    const pipeline = latest().processor;
-    expect(preview.setProcessor).toHaveBeenCalledWith(
-      convertToLivekitProcessor(pipeline!),
-    );
-    expect(call.setProcessor).toHaveBeenCalledWith(
-      convertToLivekitProcessor(pipeline!),
-    );
-    expect(pipelines.built).toBe(1);
-  });
-
-  it("applies an effect chosen while the camera is off", async () => {
-    const view = render(surfaces(null));
-    await blur(true);
-    // Already switched to blur, with nothing yet to attach it to.
-    expect(pipelines.switches).toEqual([
-      { mode: "background-blur", blurRadius: 15 },
-    ]);
-
-    const track = cameraTrack();
-    await act(async () => {
-      view.rerender(surfaces(track));
-      await flushPromises();
-    });
-    expect(track.setProcessor).toHaveBeenCalledTimes(1);
-    expect(track.setProcessor).toHaveBeenCalledWith(
-      convertToLivekitProcessor(latest().processor!),
-    );
-    expect(pipelines.built).toBe(1);
-    expect(pipelines.switches).toHaveLength(1);
-  });
-});

src/tracks/BlurBackgroundTransformer.ts

@@ -1,6 +1,5 @@
 /*
 Copyright 2024-2025 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.
@@ -10,9 +9,7 @@ import {
   BackgroundTransformer,
   VideoTransformer,
   type VideoTransformerInitOptions,
-  type BackgroundOptions,
 } from "@livekit/track-processors";
-import { logger } from "matrix-js-sdk/lib/logger";
 import { ImageSegmenter } from "@mediapipe/tasks-vision";
 
 import modelAssetPath from "../mediapipe/imageSegmenter/selfie_segmenter.tflite?url";
@@ -52,32 +49,7 @@ const wasmFileset: WasmFileset = {
  * loads the segmentation models from our own bundle rather than as an external
  * resource fetched from the public internet.
  */
-export class BackgroundEffectTransformer extends BackgroundTransformer {
-  /** Called once, when the first frame carrying an effect has been drawn. */
-  public onFirstFrame: (() => void) | undefined;
-
-  public override async transform(
-    frame: VideoFrame,
-    controller: TransformStreamDefaultController<VideoFrame>,
-  ): Promise<void> {
-    const priming = this.isFirstFrame;
-    await super.transform(frame, controller);
-    // Cleared only once a frame has been through the segmenter; a frame
-    // passed through untouched leaves it set.
-    if (priming && !this.isFirstFrame) this.onFirstFrame?.();
-  }
-
-  /**
-   * As the library's, except that disabling also drops the blur radius: kept,
-   * it has every frame segmented and the result thrown away, where with
-   * neither a radius nor a picture frames are passed on untouched.
-   */
-  public override async update(opts: BackgroundOptions): Promise<void> {
-    await super.update(
-      opts.backgroundDisabled ? { ...opts, blurRadius: undefined } : opts,
-    );
-  }
-
+export class BlurBackgroundTransformer extends BackgroundTransformer {
   public async init({
     outputCanvas,
     inputElement: inputVideo,
@@ -101,15 +73,8 @@ export class BackgroundEffectTransformer extends BackgroundTransformer {
       outputConfidenceMasks: false,
     });
 
-    // BackgroundTransformer's own init applies these, and this one replaces it.
-    if (this.options.imagePath) {
-      await this.loadAndSetBackground(this.options.imagePath).catch((e) =>
-        logger.warn("Failed to load the background image", e),
-      );
-    }
     if (this.options.blurRadius) {
       this.gl?.setBlurRadius(this.options.blurRadius);
     }
-    this.gl?.setBackgroundDisabled(this.options.backgroundDisabled ?? false);
   }
 }

src/tracks/OneStepPipeline.test.ts

@@ -1,80 +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 { afterEach, describe, expect, it, vi } from "vitest";
-import { ProcessorWrapper } from "@livekit/track-processors";
-
-import { OneStepPipeline } from "./OneStepPipeline";
-import { BackgroundEffectTransformer } from "./BackgroundEffectTransformer";
-import { flushPromises } from "../utils/test";
-
-const opts = {} as Parameters<OneStepPipeline["init"]>[0];
-
-describe("OneStepPipeline", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("stops and builds again only once a build has finished", async () => {
-    let finishBuild!: () => void;
-    const init = vi
-      .spyOn(ProcessorWrapper.prototype, "init")
-      .mockImplementationOnce(
-        async () => new Promise((resolve) => (finishBuild = resolve)),
-      )
-      .mockResolvedValue();
-    const destroy = vi
-      .spyOn(ProcessorWrapper.prototype, "destroy")
-      .mockResolvedValue();
-    const pipeline = new OneStepPipeline(
-      new BackgroundEffectTransformer({}),
-      "test",
-    );
-
-    const first = pipeline.init(opts);
-    const stopped = pipeline.destroy();
-    const second = pipeline.init(opts);
-    await flushPromises();
-    expect(init).toHaveBeenCalledTimes(1);
-    expect(destroy).not.toHaveBeenCalled();
-
-    finishBuild();
-    await Promise.all([first, stopped, second]);
-    expect(init).toHaveBeenCalledTimes(2);
-    expect(destroy.mock.invocationCallOrder[0]).toBeLessThan(
-      init.mock.invocationCallOrder[1],
-    );
-  });
-
-  it("restarts in one step, without waiting on itself", async () => {
-    const init = vi
-      .spyOn(ProcessorWrapper.prototype, "init")
-      .mockResolvedValue();
-    const destroy = vi
-      .spyOn(ProcessorWrapper.prototype, "destroy")
-      .mockResolvedValue();
-    const pipeline = new OneStepPipeline(
-      new BackgroundEffectTransformer({}),
-      "test",
-    );
-
-    await pipeline.restart(opts);
-    expect(destroy).toHaveBeenCalledWith({ willProcessorRestart: true });
-    expect(init).toHaveBeenCalledOnce();
-  });
-
-  it("carries on after a step that failed", async () => {
-    vi.spyOn(ProcessorWrapper.prototype, "init")
-      .mockRejectedValueOnce(new Error("no GPU"))
-      .mockResolvedValue();
-    const pipeline = new OneStepPipeline(
-      new BackgroundEffectTransformer({}),
-      "test",
-    );
-
-    await expect(pipeline.init(opts)).rejects.toThrow("no GPU");
-    await expect(pipeline.init(opts)).resolves.toBeUndefined();
-  });
-});

src/tracks/OneStepPipeline.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 { BackgroundProcessorWrapper } from "@livekit/track-processors";
-
-type InitOptions = Parameters<BackgroundProcessorWrapper["init"]>[0];
-type DestroyOptions = Parameters<BackgroundProcessorWrapper["destroy"]>[0];
-
-/**
- * A background pipeline that is built, rebuilt and destroyed one step at a
- * time. The camera tracks sharing it attach and stop it independently, and
- * the SDK's wrapper holds a single track's streams: two builds at once
- * overwrite each other's, and a destroy during a build does nothing.
- */
-export class OneStepPipeline extends BackgroundProcessorWrapper {
-  private steps: Promise<void> = Promise.resolve();
-
-  public override async init(opts: InitOptions): Promise<void> {
-    return this.inTurn(async () => super.init(opts));
-  }
-
-  // The SDK's restart calls init and destroy, which would wait on itself.
-  public override async restart(opts: InitOptions): Promise<void> {
-    return this.inTurn(async () => {
-      await super.destroy({ willProcessorRestart: true });
-      await super.init(opts);
-    });
-  }
-
-  public override async destroy(options?: DestroyOptions): Promise<void> {
-    return this.inTurn(async () => super.destroy(options));
-  }
-
-  private async inTurn(step: () => Promise<void>): Promise<void> {
-    const turn = this.steps.then(step);
-    this.steps = turn.catch(() => {});
-    return turn;
-  }
-}

src/tracks/TrackProcessorContext.test.ts

@@ -0,0 +1,133 @@
+/*
+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 { describe, expect, it, vi } from "vitest";
+import { type LocalVideoTrack } from "livekit-client";
+import {
+  type BackgroundOptions,
+  type ProcessorWrapper,
+} from "@livekit/track-processors";
+import { type VideoProcessor } from "@element-hq/matrixrtc-sdk";
+
+import {
+  applyProcessor,
+  fromLivekitProcessor,
+  trackProcessorSync,
+} from "./TrackProcessorContext";
+import { constant } from "../state/Behavior";
+import { flushPromises, testScope } from "../utils/test";
+
+const processor = { name: "blur" } as VideoProcessor;
+
+function mockTrack(
+  readyState: MediaStreamTrackState,
+  current?: VideoProcessor,
+): LocalVideoTrack {
+  return {
+    mediaStreamTrack: { readyState },
+    getProcessor: vi.fn().mockReturnValue(current),
+    setProcessor: vi.fn().mockResolvedValue(undefined),
+    stopProcessor: vi.fn().mockResolvedValue(undefined),
+  } as unknown as LocalVideoTrack;
+}
+
+describe("applyProcessor", () => {
+  it("attaches the processor to a live track", () => {
+    const track = mockTrack("live");
+    applyProcessor(track, processor);
+    expect(track.setProcessor).toHaveBeenCalledWith(
+      expect.objectContaining({ name: "blur" }),
+    );
+  });
+
+  it("does not attach the processor to an ended track", () => {
+    const track = mockTrack("ended");
+    applyProcessor(track, processor);
+    expect(track.setProcessor).not.toHaveBeenCalled();
+  });
+
+  it("does not surface a rejected setProcessor", async () => {
+    const track = mockTrack("live");
+    vi.mocked(track.setProcessor).mockRejectedValue(
+      new TypeError("Input track cannot be ended"),
+    );
+    const unhandled = vi.fn();
+    process.on("unhandledRejection", unhandled);
+    applyProcessor(track, processor);
+    await flushPromises();
+    process.off("unhandledRejection", unhandled);
+    expect(unhandled).not.toHaveBeenCalled();
+  });
+
+  it("stops the processor when none is wanted", () => {
+    const track = mockTrack("live", processor);
+    applyProcessor(track, undefined);
+    expect(track.stopProcessor).toHaveBeenCalled();
+  });
+
+  it("does not surface a rejected stopProcessor", async () => {
+    const track = mockTrack("live", processor);
+    vi.mocked(track.stopProcessor).mockRejectedValue(new Error("nope"));
+    const unhandled = vi.fn();
+    process.on("unhandledRejection", unhandled);
+    applyProcessor(track, undefined);
+    await flushPromises();
+    process.off("unhandledRejection", unhandled);
+    expect(unhandled).not.toHaveBeenCalled();
+  });
+});
+
+describe("trackProcessorSync", () => {
+  it("applies the processor to the current track", () => {
+    const track = mockTrack("live");
+    trackProcessorSync(
+      testScope(),
+      constant(track),
+      constant({ supported: true, processor }),
+    );
+    expect(track.setProcessor).toHaveBeenCalledWith(
+      expect.objectContaining({ name: "blur" }),
+    );
+  });
+});
+
+describe("fromLivekitProcessor", () => {
+  const captured = { id: "captured" } as MediaStreamTrack;
+  const processed = { id: "processed" } as MediaStreamTrack;
+
+  function mockWrapper(
+    processedTrack: MediaStreamTrack | undefined,
+  ): ProcessorWrapper<BackgroundOptions> {
+    return {
+      name: "background-blur",
+      processedTrack,
+      init: vi.fn().mockResolvedValue(undefined),
+      restart: vi.fn().mockResolvedValue(undefined),
+      destroy: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ProcessorWrapper<BackgroundOptions>;
+  }
+
+  it("resolves with the track the wrapper produced", async () => {
+    const wrapper = mockWrapper(processed);
+    const sdkProcessor = fromLivekitProcessor(wrapper);
+    expect(sdkProcessor.name).toBe("background-blur");
+    await expect(sdkProcessor.init(captured)).resolves.toBe(processed);
+    expect(wrapper.init).toHaveBeenCalledWith({
+      kind: "video",
+      track: captured,
+    });
+    await expect(sdkProcessor.restart(captured)).resolves.toBe(processed);
+    await sdkProcessor.destroy();
+    expect(wrapper.destroy).toHaveBeenCalled();
+  });
+
+  it("rejects where the wrapper produced no track", async () => {
+    await expect(
+      fromLivekitProcessor(mockWrapper(undefined)).init(captured),
+    ).rejects.toThrow("produced no track");
+  });
+});

src/tracks/TrackProcessorContext.tsx

@@ -1,17 +1,23 @@
 /*
 Copyright 2024-2025 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 {
-  type ProcessorWrapper,
+  ProcessorWrapper,
+  supportsBackgroundProcessors as supportsBackgroundProcessorsLivekitSdk,
   type BackgroundOptions,
-  supportsBackgroundProcessors,
 } from "@livekit/track-processors";
-import { createContext, type FC, type JSX, use, useEffect } from "react";
+import {
+  createContext,
+  type FC,
+  type JSX,
+  use,
+  useEffect,
+  useMemo,
+} from "react";
 import { type LocalVideoTrack, Track } from "livekit-client";
 import { logger } from "matrix-js-sdk/lib/logger";
 import { combineLatest } from "rxjs";
@@ -20,26 +26,23 @@ import {
   type VideoProcessor,
 } from "@element-hq/matrixrtc-sdk";
 
-import { backgroundEffect as backgroundEffectSetting } from "../settings/settings";
-import { BackgroundEffectTransformer } from "./BackgroundEffectTransformer";
-import { OneStepPipeline } from "./OneStepPipeline";
+import {
+  backgroundBlur as backgroundBlurSettings,
+  useSetting,
+} from "../settings/settings";
+import { BlurBackgroundTransformer } from "./BlurBackgroundTransformer";
 import { type Behavior } from "../state/Behavior";
 import { type ObservableScope } from "../state/ObservableScope";
-import {
-  type BackgroundEffects,
-  createBackgroundEffects,
-} from "../state/BackgroundEffects";
-import { useBehavior } from "../useBehavior";
+import { platform } from "../Platform";
+import { useValueBehavior } from "../useValueBehavior";
 
 //TODO-MULTI-SFU: This is not yet fully there.
 // it is a combination of exposing observable and react hooks.
 // preferably we should not make this a context anymore and instead just a vm?
 
-export type BackgroundEffectsState = {
+export type ProcessorState = {
   supported: boolean | undefined;
   processor: undefined | VideoProcessor;
-  /** From the first effect chosen until a frame carrying it is drawn. */
-  settling?: boolean;
 };
 
 /**
@@ -69,21 +72,19 @@ export function fromLivekitProcessor(
   };
 }
 
-const BackgroundEffectsContext = createContext<BackgroundEffects | undefined>(
-  undefined,
-);
+const ProcessorContext = createContext<ProcessorState | undefined>(undefined);
 
-export function useBackgroundEffects(): BackgroundEffectsState {
-  return useBehavior(useBackgroundEffectsState$());
+export function useTrackProcessor(): ProcessorState {
+  const state = use(ProcessorContext);
+  if (state === undefined)
+    throw new Error(
+      "useTrackProcessor must be used within a ProcessorProvider",
+    );
+  return state;
 }
 
-export function useBackgroundEffectsState$(): Behavior<BackgroundEffectsState> {
-  const effects = use(BackgroundEffectsContext);
-  if (effects === undefined)
-    throw new Error(
-      "useBackgroundEffects must be used within a BackgroundEffectsProvider",
-    );
-  return effects.state$;
+export function useTrackProcessorState$(): Behavior<ProcessorState> {
+  return useValueBehavior(useTrackProcessor());
 }
 
 /**
@@ -103,11 +104,8 @@ export function applyProcessor(
       logger.debug("Not attaching video processor to an ended track");
       return;
     }
-    const track = videoTrack.mediaStreamTrack;
     videoTrack.setProcessor(convertToLivekitProcessor(processor)).catch((e) => {
-      if (track.readyState === "ended")
-        logger.debug("Video processor not attached: the track ended first");
-      else logger.warn("Failed to attach video processor", e);
+      logger.warn("Failed to attach video processor", e);
     });
   }
   if (!processor && videoTrack.getProcessor()) {
@@ -120,52 +118,61 @@ export function applyProcessor(
 /**
  * Updates your video tracks to always use the given processor.
  */
-export const syncBackgroundEffects = (
+export const trackProcessorSync = (
   scope: ObservableScope,
   videoTrack$: Behavior<LocalVideoTrack | null>,
-  backgroundEffectsState$: Behavior<BackgroundEffectsState>,
+  processor$: Behavior<ProcessorState>,
 ): void => {
-  combineLatest([videoTrack$, backgroundEffectsState$])
+  combineLatest([videoTrack$, processor$])
     .pipe(scope.bind())
-    .subscribe(([videoTrack, backgroundEffectsState]) => {
-      if (!backgroundEffectsState) return;
+    .subscribe(([videoTrack, processorState]) => {
+      if (!processorState) return;
       if (!videoTrack) return;
-      applyProcessor(videoTrack, backgroundEffectsState.processor);
+      applyProcessor(videoTrack, processorState.processor);
     });
 };
 
-export const useSyncBackgroundEffects = (
+export const useTrackProcessorSync = (
   videoTrack: LocalVideoTrack | null,
 ): void => {
-  const { processor } = useBackgroundEffects();
+  const { processor } = useTrackProcessor();
   useEffect(() => {
     if (!videoTrack) return;
     applyProcessor(videoTrack, processor);
   }, [processor, videoTrack]);
 };
 
-/** The app's one pipeline, shared by every camera track it opens. */
-export function createAppBackgroundEffects(
-  scope: ObservableScope,
-): BackgroundEffects {
-  const transformer = new BackgroundEffectTransformer({
-    backgroundDisabled: true,
-  });
-  return createBackgroundEffects(scope, {
-    supported: supportsBackgroundProcessors(),
-    effect$: backgroundEffectSetting.value$,
-    pipeline: new OneStepPipeline(transformer, "background-effect"),
-    transformer,
-  });
-}
-
 interface Props {
-  effects: BackgroundEffects;
   children: JSX.Element;
 }
 
-export const BackgroundEffectsProvider: FC<Props> = ({ effects, children }) => (
-  <BackgroundEffectsContext value={effects}>
-    {children}
-  </BackgroundEffectsContext>
-);
+function supportsBackgroundProcessors(): boolean {
+  return supportsBackgroundProcessorsLivekitSdk() && platform === "desktop";
+}
+
+export const ProcessorProvider: FC<Props> = ({ children }) => {
+  // The setting the user wants to have
+  const [blurActivated] = useSetting(backgroundBlurSettings);
+  const supported = useMemo(() => supportsBackgroundProcessors(), []);
+  const blur = useMemo(
+    () =>
+      fromLivekitProcessor(
+        new ProcessorWrapper(
+          new BlurBackgroundTransformer({ blurRadius: 15 }),
+          "background-blur",
+        ),
+      ),
+    [],
+  );
+
+  // This is the actual state exposed through the context
+  const processorState = useMemo(
+    () => ({
+      supported,
+      processor: supported && blurActivated ? blur : undefined,
+    }),
+    [supported, blurActivated, blur],
+  );
+
+  return <ProcessorContext value={processorState}>{children}</ProcessorContext>;
+};

src/tracks/backgroundEffects.test.ts

@@ -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 { readFile } from "node:fs/promises";
-import { describe, expect, test } from "vitest";
-
-import {
-  type BackgroundEffect,
-  imagePathFor,
-  parseEffect,
-  serializeEffect,
-  shippedBackgrounds,
-} from "./backgroundEffects";
-
-describe("the chosen background effect", () => {
-  test("round-trips through its stored form", () => {
-    const effects: BackgroundEffect[] = [
-      { kind: "none" },
-      { kind: "blur" },
-      ...shippedBackgrounds.map(({ id }) => ({ kind: "shipped" as const, id })),
-    ];
-    for (const effect of effects)
-      expect(parseEffect(serializeEffect(effect))).toEqual(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" });
-  });
-
-  test("reads a stored value that is not a string as no effect", () => {
-    for (const raw of [null, 1, {}, ["blur"]])
-      expect(parseEffect(raw)).toEqual({ kind: "none" });
-  });
-
-  test("gives every shipped background an image to draw", () => {
-    for (const { id } of shippedBackgrounds)
-      expect(imagePathFor(id)).toBeTruthy();
-  });
-
-  // A background has to cover what is behind it: JPEG has no alpha channel.
-  test("ships only opaque backgrounds", async () => {
-    for (const { imagePath } of shippedBackgrounds) {
-      const name = imagePath.split("/").pop()!.split("?")[0];
-      const bytes = await readFile(`src/graphics/${name}`);
-      expect([bytes[0], bytes[1], bytes[2]]).toEqual([0xff, 0xd8, 0xff]);
-    }
-  });
-});

src/tracks/backgroundEffects.ts

@@ -1,62 +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 arc from "../graphics/background-arc.jpg?url";
-import glow from "../graphics/background-glow.jpg?url";
-
-export const blurRadius = 15;
-
-export interface ShippedBackground {
-  /** Stored in the user's settings when chosen, so it must not change. */
-  id: string;
-  imagePath: string;
-}
-
-export const shippedBackgrounds: ShippedBackground[] = [
-  { id: "arc", imagePath: arc },
-  { id: "glow", imagePath: glow },
-];
-
-export type BackgroundEffect =
-  | { kind: "none" }
-  | { kind: "blur" }
-  | { 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}`;
-
-export const noEffect: BackgroundEffect = { kind: "none" };
-
-/**
- * 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;
-  if (raw === "blur") return { kind: "blur" };
-  if (raw.startsWith("image:")) {
-    const id = raw.slice("image:".length);
-    if (shippedBackgrounds.some((b) => b.id === id))
-      return { kind: "shipped", id };
-  }
-  return noEffect;
-}
-
-export function serializeEffect(effect: BackgroundEffect): EffectId {
-  switch (effect.kind) {
-    case "blur":
-      return "blur";
-    case "shipped":
-      return `image:${effect.id}`;
-    default:
-      return "none";
-  }
-}
-
-export function imagePathFor(id: string): string | undefined {
-  return shippedBackgrounds.find((b) => b.id === id)?.imagePath;
-}

src/utils/object.test.ts

@@ -7,6 +7,7 @@ Please see LICENSE in the repository root for full details.
 
 import { test, expect } from "vitest";
 import { shallowEquals } from "./object";
+import { shallowEquals as arrayShallowEquals } from "./array";
 
 interface Thing {
   type: string;
@@ -29,12 +30,26 @@ test("shallowEquals detects a missing key", () => {
 test("shallowEquals detects a differing value", () =>
   expect(shallowEquals(withArray, { ...withArray, value: 2 })).toBe(false));
 
-test("shallowEquals considers arrays with equal contents to be equal", () =>
+const comparator = (aValue: unknown, bValue: unknown): boolean => {
+  if (Array.isArray(aValue) && Array.isArray(bValue))
+    return arrayShallowEquals(aValue, bValue);
+  return aValue === bValue;
+};
+
+test("shallowEquals with comparator considers arrays with equal contents to be equal", () =>
   expect(
-    shallowEquals(withArray, { ...withArray, items: [...withArray.items] }),
+    shallowEquals(
+      withArray,
+      { ...withArray, items: [...withArray.items] },
+      comparator,
+    ),
   ).toBe(true));
 
-test("shallowEquals detects arrays with different contents", () =>
+test("shallowEquals with comparator detects arrays with different contents", () =>
   expect(
-    shallowEquals(withArray, { ...withArray, items: [...withArray.items, {}] }),
+    shallowEquals(
+      withArray,
+      { ...withArray, items: [...withArray.items, {}] },
+      comparator,
+    ),
   ).toBe(false));

src/utils/object.ts

@@ -5,17 +5,17 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { shallowEquals as arrayShallowEquals } from "./array.ts";
-
 /**
  * Determine whether two objects are equal by shallow comparison of their
- * top-level properties. Array-valued properties are themselves compared
- * shallowly, so two objects holding distinct arrays with the same elements are
- * considered equal.
+ * top-level properties, using the given `comparator`.
  */
 export function shallowEquals<T extends object>(
   a: Readonly<T>,
   b: Readonly<T>,
+  comparator: (aValue: unknown, bValue: unknown) => boolean = (
+    aValue,
+    bValue,
+  ) => aValue === bValue,
 ): boolean {
   // If a and b have the same number of keys and every key in a is also in b,
   // then they have the same keys.
@@ -29,9 +29,7 @@ export function shallowEquals<T extends object>(
     // Now check that they have the same values.
     const aValue = (a as any)[key];
     const bValue = (b as any)[key];
-    if (Array.isArray(aValue) && Array.isArray(bValue)) {
-      if (!arrayShallowEquals(aValue, bValue)) return false;
-    } else if (aValue !== bValue) return false;
+    if (!comparator(aValue, bValue)) return false;
   }
 
   return true;

src/utils/test-viewmodel.ts

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

vite-component-dev.config.ts

@@ -38,21 +38,8 @@ export default defineConfig(({ mode }) => {
     ...base,
     root: "component/dev",
     // The same scoping the library build applies, so the harness shows what a
-    // host will get — including whether its own page is left alone. The host's
-    // own stylesheets, Compound's among them, stay unscoped, as on a real host.
-    css: {
-      postcss: {
-        plugins: [
-          scopeStylesToRoot({
-            exclude: [
-              /component[\\/]dev[\\/]/,
-              /@vector-im[\\/]compound-/,
-              /@fontsource[\\/]/,
-            ],
-          }),
-        ],
-      },
-    },
+    // host will get — including whether its own page is left alone
+    css: { postcss: { plugins: [scopeStylesToRoot()] } },
     // So that the harness can read the same config.json the standalone app
     // does, if the developer has written one
     publicDir: "../../public",

vite.config.ts

@@ -7,7 +7,6 @@ Please see LICENSE in the repository root for full details.
 
 import {
   loadEnv,
-  type Plugin,
   type PluginOption,
   searchForWorkspaceRoot,
   type ConfigEnv,
@@ -44,12 +43,10 @@ export const vitePluginsConfig = ({
     }),
     react(),
     wasm(),
-    exceptMediaPipeWasm(
-      nodePolyfills({
-        // Enables the 'events' module, which is required by the matrix-js-sdk
-        include: ["events"],
-      }),
-    ),
+    nodePolyfills({
+      // Enables the 'events' module, which is required by the matrix-js-sdk
+      include: ["events"],
+    }),
     svgrPlugin({
       svgrOptions: {
         // This enables ref forwarding on SVGR components, which is needed, for
@@ -194,31 +191,3 @@ export default ({
     },
   };
 };
-
-/**
- * Keeps a plugin's transform off MediaPipe's WASM loader. The loader is a
- * classic script that sets `self.ModuleFactory`; transformed into a module it
- * sets nothing, and the segmenter fails with "ModuleFactory not set".
- */
-function exceptMediaPipeWasm(plugins: PluginOption): PluginOption {
-  const isLoader = (id: string): boolean =>
-    id.includes("tasks-vision") && id.includes("wasm");
-  return (Array.isArray(plugins) ? plugins : [plugins]).map((plugin) => {
-    if (
-      !plugin ||
-      typeof plugin !== "object" ||
-      !("transform" in plugin) ||
-      typeof plugin.transform !== "function"
-    )
-      return plugin;
-    const transform = plugin.transform;
-    const wrapped: Plugin = {
-      ...plugin,
-      transform(code, id, options) {
-        if (isLoader(id)) return null;
-        return transform.call(this, code, id, options);
-      },
-    };
-    return wrapped;
-  });
-}