Merge pull request #4395 from element-hq/toger5/backport-publish-npm-component

[backport] Publish npm component

.github/workflows/publish-component.yaml

@@ -0,0 +1,135 @@
+name: Build & publish the component package for releases
+
+on:
+  release:
+    types: [published]
+  pull_request:
+    types:
+      - synchronize
+      - opened
+      - labeled
+  push:
+    branches: [main]
+
+# Each job asks for what it needs
+permissions: {}
+
+jobs:
+  versioning:
+    name: Versioning
+    runs-on: ubuntu-latest
+    outputs:
+      DRY_RUN: ${{ steps.dry_run.outputs.DRY_RUN }}
+      PREFIXED_VERSION: ${{ steps.prefixed_version.outputs.PREFIXED_VERSION }}
+      TAG: ${{ steps.tag.outputs.TAG }}
+    steps:
+      - name: Calculate VERSION
+        # Safely store dynamic values in environment variables
+        # to prevent shell injection (template-injection)
+        run: |
+          if [ "$EVENT_NAME" = "release" ]; then
+            echo "VERSION=$RELEASE_TAG" >> "$GITHUB_ENV"
+          else
+            echo "VERSION=v0.0.0-pre.0" >> "$GITHUB_ENV"
+          fi
+        env:
+          RELEASE_TAG: ${{ github.event.release.tag_name }}
+          EVENT_NAME: ${{ github.event_name }}
+      - id: dry_run
+        name: Set DRY_RUN
+        # A dry run for everything but releases, so that a broken package shows up
+        # ahead of a release
+        run: echo "DRY_RUN=${{ github.event_name != 'release' }}" >> "$GITHUB_OUTPUT"
+      - id: prefixed_version
+        name: Set PREFIXED_VERSION
+        run: echo "PREFIXED_VERSION=${VERSION}" >> "$GITHUB_OUTPUT"
+      - id: tag
+        # latest = a proper release
+        # other = anything else
+        name: Set tag
+        run: |
+          if [[ "${VERSION}" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "TAG=latest" >> "$GITHUB_OUTPUT"
+          elif [[ "${VERSION}" =~ ^v[0-9]+\.[0-9]+\.[0-9]+\-rc\.[0-9]+$ ]]; then
+            echo "TAG=rc" >> "$GITHUB_OUTPUT"
+          else
+            echo "TAG=other" >> "$GITHUB_OUTPUT"
+          fi
+
+  publish_npm:
+    needs: versioning
+    name: Publish NPM
+    runs-on: ubuntu-latest
+    outputs:
+      ARTIFACT_VERSION: ${{ steps.artifact_version.outputs.ARTIFACT_VERSION }}
+    permissions:
+      contents: read
+      id-token: write # Allow npm to authenticate as a trusted publisher
+    steps:
+      - name: Checkout
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          persist-credentials: false
+      - name: Enable Corepack
+        run: corepack enable
+      - name: Setup node
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        # No dependency cache: a release build must not restore one another workflow could have poisoned
+        with:
+          node-version-file: .node-version
+          registry-url: "https://registry.npmjs.org"
+      # Layered like build-element-call.yaml, so a PR paired with a matrix-js-sdk branch
+      # builds against it; a release pins the SDK, so layered.sh leaves it as locked
+      - name: Install dependencies
+        run: scripts/layered.sh --ignore-pnpmfile
+        env:
+          PR_HEAD_REPO_OWNER: ${{ github.event.pull_request.head.repo.owner.login }}
+      - name: Build component
+        run: pnpm build:component:production
+        env:
+          VITE_APP_VERSION: component-${{ needs.versioning.outputs.PREFIXED_VERSION }}
+          NODE_OPTIONS: "--max-old-space-size=4096"
+
+      # `devEngines` (pnpm only, which npm refuses) and the `prepare` build exist for
+      # git-dependency installs; the published package is already built
+      - name: Publish npm
+        working-directory: component
+        run: |
+          jq 'del(.devEngines, .scripts)' package.json > package.json.tmp && mv package.json.tmp package.json
+          npm version ${NEEDS_VERSIONING_OUTPUTS_PREFIXED_VERSION} --no-git-tag-version
+          echo "ARTIFACT_VERSION=$(jq '.version' --raw-output package.json)" >> "$GITHUB_ENV"
+          npm publish --provenance --access public --tag ${NEEDS_VERSIONING_OUTPUTS_TAG} ${{ needs.versioning.outputs.DRY_RUN == 'true' && '--dry-run' || '' }}
+        env:
+          NEEDS_VERSIONING_OUTPUTS_PREFIXED_VERSION: ${{ needs.versioning.outputs.PREFIXED_VERSION }}
+          NEEDS_VERSIONING_OUTPUTS_TAG: ${{ needs.versioning.outputs.TAG }}
+
+      - id: artifact_version
+        name: Output artifact version
+        run: echo "ARTIFACT_VERSION=${ARTIFACT_VERSION}" >> "$GITHUB_OUTPUT"
+
+  release_notes:
+    needs: [versioning, publish_npm]
+    if: ${{ needs.versioning.outputs.DRY_RUN == 'false' }}
+    name: Update release notes
+    runs-on: ubuntu-latest
+    # Shared with publish-embedded-packages.yaml, which appends to the same release: two
+    # appends at once would each write back the body without the other's section
+    concurrency:
+      group: release-notes-${{ github.event.release.tag_name || github.run_id }}
+      cancel-in-progress: false
+    permissions:
+      contents: write # to update release notes
+    steps:
+      - name: Add release notes
+        uses: softprops/action-gh-release@3bb12739c298aeb8a4eeaf626c5b8d85266b0e65 # v2
+        with:
+          append_body: true
+          body: |
+
+            ## React component (experimental)
+
+            Element Call as a React component, rendered in the host's page instead of in an iframe.
+
+            ```
+            npm install @element-hq/element-call-component@${{ needs.publish_npm.outputs.ARTIFACT_VERSION }}
+            ```

.github/workflows/publish-embedded-packages.yaml

@@ -283,6 +283,11 @@ jobs:
     if: always()
     name: Update release notes
     runs-on: ubuntu-latest
+    # Shared with publish-component.yaml, which appends to the same release: two appends
+    # at once would each write back the body without the other's section
+    concurrency:
+      group: release-notes-${{ github.event.release.tag_name || github.run_id }}
+      cancel-in-progress: false
     permissions:
       contents: write # to update release notes
     steps:

PR4331-merge.md

@@ -0,0 +1,232 @@
+# Merging PR #4331 onto the SDK / Element Call split
+
+How [element-hq/element-call#4331](https://github.com/element-hq/element-call/pull/4331)
+("LiveKit updates": MSC4195 client-server API tokens, `url` transports, delegation
+through the homeserver, a transport dev override) lands on `toger5/use-sdk`, where
+the MatrixRTC logic lives in `sdk/` and Element Call consumes it through
+`sdk/src/api.ts`. The PR was written against `main`, where all of this still sat
+in `src/state/CallViewModel/`. This document goes through the PR commit by commit,
+says whether each one lands in `sdk/` or `src/`, and how; the section
+[Changes to `api.ts`](#changes-to-apits) covers the public interface in full. The
+end state: this branch behaves exactly as the PR does, with the split and the
+`api.ts` seam intact.
+
+The PR's branch is checked out at `agent-workspace/pr4331-merge/worktree` for
+comparison. The `matrix-js-sdk` dependency is pinned to the same `develop`
+commit the PR uses (`4df2f2bf`, 43.0.0), which brings `UnstableLivekitTransport`,
+`CallMembership.backendIdentities`, `_unstable_getLivekitToken` and
+`_unstable_delegateDelayedLeave`. That bump also renamed
+`MatrixRTCSession.leaveRoomSession` to `leave`, which the SDK now calls.
+
+## Where each commit lands
+
+| #   | Commit                                                                    | Lands in      | How                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| --- | ------------------------------------------------------------------------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 1   | Remove stray pause and improve logging for hung e2e tests                 | e2e           | Applied as is: `playwright.config.ts`, `playwright/widget/federated-call.test.ts`.                                                                                                                                                                                                                                                                                                                                                                                                |
+| 2   | Fix typo in the name of the createJWTToken Playwright fixture             | e2e           | Applied as is.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| 3   | Advertise the loopback address from the dev LiveKit SFUs                  | backend       | Applied as is: `backend/dev_livekit*.yaml`.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| 4   | Match LiveKit participants against all backend identities                 | sdk           | `RTCMember.backendIdentities` (new, see api.ts). `LivekitBackend.mediaFor` matches `member.backendIdentities.includes(p.identity)`; `RTCParticipation.data$` maps a packet's sender the same way. `mockRtcMembership` in both `sdk/src/utils/test.ts` and `src/utils/test.ts` takes the new 4-argument constructor and a `backendIdentities` override.                                                                                                                            |
+| 5   | Model ConnectionState as a discriminated union                            | sdk           | `Connection.ts` state is `{state: "initialized" \| "authenticating" \| "authenticated" (+ `livekitState`) \| "error" (+ `error`) \| "stopped"}`. Internal to the LiveKit backend: `connectionState.ts` maps it onto the backend-neutral `MediaConnectionState`, so nothing above the backend changes. `DataChannel.ts` and `ConnectionFactory.ts` follow.                                                                                                                         |
+| 6   | Show the whole transport in debug UI and logs                             | sdk + src     | SDK log lines use `JSON.stringify(transport)`. Element Call: `focusUrl$: Behavior<string>` on the member media view models becomes `transport$: Behavior<Transport>` (`TransportMetadata.raw`), carried through `GridTile`, `SpotlightTile`, `MediaView` to `RTCConnectionStats`, which prints the JSON. The old code showed `extractDomain(transport.id)`, which on this branch was already a JSON string, so this also fixes a latent bug.                                      |
+| 7   | Group livekitRoomItems$ by connection                                     | n/a           | `livekitRoomItems$` and `LivekitRoomAudioRenderer` do not exist on this branch: audio renders from `tracks$` (`MemberAudioRenderer`). Nothing to port.                                                                                                                                                                                                                                                                                                                            |
+| 8   | Move SFU authentication into livekit/auth and choose the endpoint by role | sdk           | `sdk/src/media-backend/livekit/auth/{index,openID,csApi,types}.ts` replace `openIDSFU.ts`. Publisher → legacy `/sfu/get`; subscriber → `/get_token`. `slotId` replaces the hard-coded `m.call#ROOM`: `MediaBackendContext.slotId`, taken from the js-sdk session in `RTCParticipation`. The `tokenEndpoint` option of `createLivekitBackend` and the derivation from `MatrixRTCMode` are gone.                                                                                    |
+| 9   | Let the publishing Connection authenticate itself                         | sdk           | Every `Connection` has a `role` and fetches its own token; `existingSFUConfig` is gone. `prepareLocalTransport` no longer fetches a token itself: it starts the publisher connection (through the connection map) and resolves once that connection reports `authenticated`, rejecting with its error otherwise. Since `LocalMembership` joins only after `preparedTransport$` resolves, the join waits for the publisher's token exactly as the PR's `authenticated$` gate does. |
+| 10  | Reduce ConnectionManager to a ConnectionMap                               | sdk           | `ConnectionMap.ts` replaces `ConnectionManager.ts`; `createConnectionMap$` takes a resolved local transport, and `LivekitBackend` wraps it in `mapScoped` over the local transport, as the PR's `CallViewModel` did. `LocalMedia.ts`, `DataChannel.ts` take `connectionMap$`.                                                                                                                                                                                                     |
+| 11  | Use the unstable LiveKit transport type                                   | sdk + src     | `UnstableLivekitTransport` / `isUnstableLivekitTransport` throughout the backend; `src/settings/settings.ts`, `DeveloperSettingsTab`, test helpers. Transport discovery in `sdk/src/matrixrtc/` is now backend neutral (filters by `type`, see commit 15).                                                                                                                                                                                                                        |
+| 12  | Identify transports by server name as well as URLs                        | sdk           | `TransportLocator {transport, serverName}` in `auth/types.ts`; `ConnectionMap.keyFor` keys on `(url, livekit_service_url, serverName)`. The server name is derived from the user id (`serverNameOf`) for remote members and from our own membership identity for the local transport, so neither `api.ts` nor the backend options need it.                                                                                                                                        |
+| 13  | Pin matrix-js-sdk to the member_id branch                                 | superseded    | By commit 19; the lockfile pins the PR's final `develop` commit.                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| 14  | Get SFU tokens and delegate delayed leaves through the MSC4195 CS API     | sdk           | `auth/csApi.ts` (`_unstable_getLivekitToken`, `_unstable_delegateDelayedLeave`), `auth/index.ts` facade with the fallback rules. `LivekitBackend.delegateDelayedLeave` goes through the facade; the delegation probe asks only the service the publisher flow uses. `LivekitBackendOptions.client` picks the two new client methods.                                                                                                                                              |
+| 15  | Let developers override the whole transport                               | sdk + src     | `RTCParticipationOptions.transport` / `fallbackTransport` take a `Transport` instead of `transportUrl` / `fallbackTransportUrl` (see api.ts). Element Call: setting `custom-transport` (JSON) replaces `custom-livekit-url`; `DeveloperSettingsTab` edits JSON and validates through `authenticateWithTransport`; `InCallView` turns `config.livekit.livekit_service_url` into the fallback transport. Locale keys `developer_mode.custom_transport.*`.                           |
+| 16  | Deprecate the livekit.livekit_service_url config option                   | src           | Applied as is in `ConfigOptions.ts`.                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| 17  | Cover url transports end to end                                           | e2e + backend | `playwright/url-transport.spec.ts`, `backend/app-service*.yaml`, `docker-compose-dev.yml` (lk-jwt-service 0.8.0) copied as is.                                                                                                                                                                                                                                                                                                                                                    |
+| 18  | Retain compatibility in compatibility mode                                | superseded    | Reverted by commit 23 inside the PR; only its e2e spec edits survive, in the final spec file.                                                                                                                                                                                                                                                                                                                                                                                     |
+| 19  | Switch JS SDK back to develop                                             | deps          | `pnpm-lock.yaml` pins `4df2f2bf` and `matrix-widget-api` 1.20.0; `package.json` keeps `#develop`.                                                                                                                                                                                                                                                                                                                                                                                 |
+| 20  | Fall back to get_token as subscriber on widget API errors                 | sdk           | `isCsApiUnavailable` in `auth/index.ts`; `doNetworkOperationWithRetry(op, shouldRetry)` in `sdk/src/utils/network.ts` with `isNetworkError` in `csApi.ts`.                                                                                                                                                                                                                                                                                                                        |
+| 21  | Share a connection between homeservers using the same JWT service         | sdk           | `keyFor` ignores the server name for transports without a `url`; `removeDuplicateTransports` keeps the first locator so the local one wins.                                                                                                                                                                                                                                                                                                                                       |
+| 22  | Avoid null in transport dev setting                                       | src           | `transportText()` in `DeveloperSettingsTab.tsx`.                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| 23  | Make the auth choice mode independent again                               | sdk           | `chooseAuthFlow(transport, role)` has no mode parameter; `config.ts` documents that `MatrixRTCMode` decides how the membership is written, not how the transport is authenticated.                                                                                                                                                                                                                                                                                                |
+| 24  | Cover identity matching and delegation across transport shapes            | sdk + e2e     | Unit tests in `LivekitBackend.test.ts` (see below); `playwright/url-transport.spec.ts` final version.                                                                                                                                                                                                                                                                                                                                                                             |
+| 25  | Cover the subscriber token path, widget fallback and server names         | sdk + e2e     | `auth/openID.test.ts` subscriber cases; `playwright/widget/url-transport.test.ts`; the server-name test lives in `LivekitBackend.test.ts` ("connects to a remote member's transport on the member's homeserver").                                                                                                                                                                                                                                                                 |
+
+## Changes to `api.ts`
+
+Three changes to the public SDK interface, all forced by the PR's behaviour.
+
+### `RTCMember.backendIdentities` (new)
+
+```ts
+/** The membership's `rtcBackendIdentity`, `${userId}:${deviceId}`: a key and a debug label. */
+rtcBackendIdentity: string;
+/**
+ * Every identity the member may publish under on its transport: the
+ * participant identity the SFU sees, and the sender of its data packets.
+ * One per authentication flow the member's transport allows, so a transport
+ * with both a `url` and a `livekit_service_url` lists the hashed and the
+ * legacy identity, and the backend matches whichever shows up.
+ */
+backendIdentities: readonly string[];
+```
+
+Commit 4 of the PR. A member on a transport that carries both a `url` and a
+`livekit_service_url` may have authenticated through either flow and so has
+two candidate identities; the js-sdk now lists them on the membership. The
+backend matches media and data packets against the list.
+`rtcBackendIdentity` stays as the stable per-membership key Element Call uses
+for tile ids and the debug overlay, and its doc says that it is no longer
+what the backend matches on. Read off the membership, like the single identity
+before it; the backend will derive both once the identity scheme is its own.
+
+### `RTCParticipationOptions.transport` / `fallbackTransport` replace the url options
+
+```ts
+/**
+ * Use this transport instead of asking the homeserver. Any shape the
+ * backend serves: for LiveKit a `url`, a `livekit_service_url` or both.
+ */
+transport?: Transport;
+/** Use this transport when the homeserver advertises none of the backend's type. */
+fallbackTransport?: Transport;
+```
+
+Commit 15 of the PR. The developer override has to carry a whole transport so
+that a `url`-only or combined shape can be tested against a homeserver that
+does not advertise one yet; a URL cannot say which shape it is. This also
+removes the one piece of LiveKit knowledge that sat outside the backend:
+`LocalTransport.ts` and `TransportAutoDiscovery.ts` no longer build a
+`{type: "livekit", livekit_service_url}` object and filter by `transportType`
+only, which `LocalTransport.ts` had marked as the moment to do this. The
+host turns its config URL into a transport (`InCallView.rtcParticipationOptions`).
+
+### `TransportMetadata` is unchanged, with one documented limit
+
+`TransportMetadata.id` is still the raw transport serialised with sorted keys.
+The LiveKit backend now keys its connections on the transport plus the server
+name where the transport has a `url` (commits 12 and 21), so two homeservers
+advertising the same `url` get two connections but one `TransportMetadata`.
+`connectedTransports$` deduplicates, and `resolved$` reports the first
+connection's resolution. This is diagnostics only; the media and data paths
+go through the backend's own keys. Extending `TransportMetadata` with the
+server name was left out to keep the type transport neutral; a developer panel
+that needs it can be given a `serverName` on `BackendConnection` later.
+
+### Related, outside `api.ts`
+
+- `media-backend/api.ts`: `MediaBackendContext.slotId` (commit 8). The
+  client-server API issues a token for a slot, so the backend needs it;
+  `RTCParticipation` reads it from the js-sdk session.
+- `sdk/index.ts`: `authenticateWithTransport` is now the auth facade's
+  `getSFUConfig({client, membership, transport, serverName, roomId, slotId, role, logger})`
+  (object parameter, whole transport, server name); `AuthenticateWithTransportParams`
+  is exported for it; `TokenEndpoint` is gone.
+- `createLivekitBackend` options: `tokenEndpoint` is gone; `client` now picks
+  `_unstable_getLivekitToken` and `_unstable_delegateDelayedLeave` as well.
+- `config.ts`: the `MatrixRTCMode` doc no longer claims the mode picks the
+  JWT endpoint (commit 23).
+
+## Behaviour, side by side
+
+| Behaviour                              | PR on `main`                                                                                | This branch                                                                                                                 |
+| -------------------------------------- | ------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| Endpoint choice                        | `chooseAuthFlow` in `src/livekit/auth`                                                      | Same function, `sdk/src/media-backend/livekit/auth/index.ts`                                                                |
+| Join waits for the publisher's token   | `authenticated$` gate in `LocalMember.ts`                                                   | `prepareLocalTransport` resolves on the publisher connection's `authenticated` state; `LocalMembership` joins after it      |
+| Delegation probe                       | The flow's service only, in `LocalMember.joinParams$`                                       | The flow's service only, in `prepareLocalTransport`                                                                         |
+| Delegation handover                    | `delegateDelayedLeave` facade from `LocalMember`                                            | Same facade from `LivekitBackend.delegateDelayedLeave`, with the delay timeout from the session timings instead of `Config` |
+| Transport keys and connection sharing  | `ConnectionMap.keyFor` on `TransportLocator`                                                | Same, moved                                                                                                                 |
+| Server names                           | `membershipsAndTransports$` from the user id; `getLocalTransport` from `client.getDomain()` | `serverNameOf(userId)` for members; our own membership identity's user id for the local transport                           |
+| Identity matching                      | `membership.backendIdentities.includes(p.identity)`                                         | `member.backendIdentities.includes(p.identity)` in `mediaFor` and for data packets                                          |
+| Dev transport override                 | `customTransport` setting → `getLocalTransport`                                             | `customTransport` setting → `RTCParticipationOptions.transport`                                                             |
+| Config fallback                        | `RtcTransportAutoDiscovery.tryConfigTransport`                                              | Host builds the transport, `RTCParticipationOptions.fallbackTransport`                                                      |
+| Error for a `url` host without MSC4195 | `NoMatrix2AuthorizationService` from the publisher connection                               | Same error, surfaced through `prepareLocalTransport` → `state$ failed` → `fromMatrixRTCError`                               |
+
+One deliberate difference: on `main` the publisher connection fetches its token
+on every (re)creation and nothing else does; here it is the same, since the
+up-front token fetch in `prepareLocalTransport` is gone. There is no second
+token request per join.
+
+## Where the PR's new tests went
+
+| PR test                                                                               | Here                                                                                                                                                                                                                                                                                                 |
+| ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `src/livekit/auth/index.test.ts`                                                      | `sdk/src/media-backend/livekit/auth/index.test.ts`. Rewritten on the network layer (fetch-mock for the JWT service, mocked client methods) because a `vi.mock` of the sibling `openID` module does not reach the facade's own import under `sdk/`. Same cases, plus a table for `chooseAuthFlow`.    |
+| `src/livekit/auth/openID.test.ts`                                                     | `sdk/src/media-backend/livekit/auth/openID.test.ts`, replacing `openIDSFU.test.ts`                                                                                                                                                                                                                   |
+| `ConnectionMap.test.ts` (incl. commit 21's sharing tests)                             | `sdk/src/media-backend/livekit/ConnectionMap.test.ts`, replacing `ConnectionManager.test.ts`; plus a role-tagging test                                                                                                                                                                               |
+| `Connection.test.ts` changes                                                          | `sdk/src/media-backend/livekit/Connection.test.ts`; plus a publisher-through-the-JWT-service case                                                                                                                                                                                                    |
+| `LocalMember.test.ts` "joins session with %s delegation support" (by transport shape) | `LivekitBackend.test.ts` "prepares the local transport and asks %s about delegation", "waits for the publisher connection to hold its token before the join", "fails the preparation with the publisher connection's error", "delegates the leave through the flow that authenticated the publisher" |
+| `MatrixLivekitMembers.test.ts` two-candidate-identity tests                           | `LivekitBackend.test.ts` › `mediaFor`                                                                                                                                                                                                                                                                |
+| `SessionBehaviors.test.ts` server-name test                                           | `LivekitBackend.test.ts` "connects to a remote member's transport on the member's homeserver"                                                                                                                                                                                                        |
+| `LocalTransport.test.ts` / `RtcTransportAutoDiscovery.test.ts` changes                | `sdk/src/matrixrtc/TransportAutoDiscovery.test.ts` (fallback is a transport)                                                                                                                                                                                                                         |
+| `DeveloperSettingsTab.test.tsx` custom transport cases                                | `src/settings/DeveloperSettingsTab.test.tsx`, snapshot updated for the label                                                                                                                                                                                                                         |
+| `DataChannel`, `LivekitBackend` registry tests                                        | Adapted to the state union and `TransportLocator`                                                                                                                                                                                                                                                    |
+| `playwright/url-transport.spec.ts`, `playwright/widget/url-transport.test.ts`         | Copied as is: they drive the app, which behaves the same                                                                                                                                                                                                                                             |
+
+The PR's `CallViewModel.test.ts`, `CallViewModelTestUtils.ts`, `LocalMember.test.ts`
+(the rest) and `MatrixAudioRenderer.test.tsx` edits have no counterpart: those
+modules were replaced by the SDK before this merge.
+
+## One fix the e2e run forced
+
+The bumped js-sdk sets `rtcBackendIdentity` to the legacy `${userId}:${deviceId}`
+identity for every membership (it is deprecated there; the hashed one now only
+appears in `backendIdentities`). On this branch the call view model keyed its
+tiles by `[dup, mediaId, rtcBackendIdentity]`, so a device that rejoined after an
+improper leave, which has two memberships until the stale one expires, produced
+duplicate keys and crashed the host's page with `UNKNOWN_ERROR`
+(`spa-call-sticky.spec.ts`, "rejoin after improper leave"). The key is now the
+membership's own `memberId`, and `MemberAudioRenderer` and the SDK harness key
+by it too. The PR on `main` keyed by the participant object as well and did not
+hit this.
+
+## Coverage added on the package branch, and one bug it found
+
+The PR's tests mostly covered the auth layer; the SDK modules under them had
+little or none. Added on the package branch, which this branch is rebased onto:
+
+| Module                                       | Test                                                                                                                                                                                  |
+| -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `media-backend/livekit/Publisher.ts`         | `Publisher.test.ts`: the cases from `main`'s `localMember/Publisher.test.ts` on a real `LocalParticipant` with faked device and signalling calls, plus publish, unpublish and destroy |
+| `media-backend/livekit/LocalMedia.ts`        | `LocalMedia.test.ts`: on a fake connection map; publish before and after the connection, republish on a new connection, mutes remembered, first publish error, output device          |
+| `RTCParticipation.ts`                        | `RTCParticipation.test.ts`: on a fake media backend; join options, state machine, publishing only while joined, delegation, member ids per mode, key replay, data sender check        |
+| `matrixrtc/LocalTransport.ts`                | `LocalTransport.test.ts`: override, homeserver, fallback, none                                                                                                                        |
+| `matrixrtc/joinJsSdkSession.ts`              | `joinJsSdkSession.test.ts`: the js-sdk join options, the retry budget, the intent and sticky events                                                                                   |
+| `media-backend/livekit/publishOptions.ts`    | `publishOptions.test.ts`                                                                                                                                                              |
+| `media-backend/livekit/ConnectionFactory.ts` | `ConnectionFactory.test.ts`: the room options from the requests and media quality (the cases from `main`'s `ECConnectionFactory.test.ts`), `resolved$`                                |
+| `LivekitBackend.ts` › `mediaFor`             | A member on another transport, a member changing transport, a member without one (from `main`'s `MatrixLivekitMembers.test.ts`)                                                       |
+
+`ConnectionFactory.test.ts` reads the options off the real LiveKit room the
+factory builds instead of mocking `livekit-client`: a `vi.mock` of the package
+reached the factory's import on the package branch but not on this one.
+
+The `LocalMedia` tests found a race in `ObservableScope.reconcile`: the loop was
+marked as running until the promise of its last run had settled, a few
+microtasks after it had last checked for new values, so a value arriving in
+that window (a connection appearing at just that moment) was never processed.
+Fixed in `[SDK] Keep a value that reaches reconcile as its loop winds down`,
+with a test that drives the window microtask by microtask. Element Call's
+`src/state/ObservableScope.ts` re-exports the SDK's class, so the fix applies
+to the app as well.
+
+## Checked
+
+- `pnpm lint` (tsc, oxlint, knip, externals), `pnpm format:check`, `pnpm i18n:check`.
+- `pnpm test`: 119 unit files, 950 tests; 4 storybook files, 45 tests (after the coverage above).
+- Playwright on Chromium against the local Playwright backend, one worker:
+  - `playwright/url-transport.spec.ts`: 10 of 10 pass, including delegation
+    through the homeserver and the JWT service, the subscriber fallback, the
+    publisher error and the federated token.
+  - `playwright/widget/url-transport.test.ts`: passes.
+  - The rest of `playwright/*.spec.ts`, `playwright/component`, `playwright/sdk`:
+    48 pass, 1 skipped, 1 fails (`reconnect.spec.ts`, which fails on `main`
+    locally too because the local JWT service is slower than the spec's wait).
+  - `playwright/widget`: 7 of 10 pass, including `federated-call`. `huddle-call`
+    fails before any call code runs (the Element Web develop image's room list no
+    longer matches the helper's "Open room" selector), and `screen-share` looks
+    for `video[data-lk-source="screen_share"]`, an attribute the LiveKit React
+    components set and the SDK's plain `<video>` elements do not: a failure of this
+    branch that predates the PR.
+  - Local environment work needed for that: the othersite JWT service and nginx
+    containers had to be recreated from the compose file, two stale containers held
+    port 16080, and the widget helper's hard-coded `https://localhost:3000` was
+    pointed at 3100 for the run only, since port 3000 is taken on this machine.
+- Standalone, widget and component all go through `InCallView.rtcParticipationOptions`
+  and the SDK, so the change is the same in all three modes; the widget-specific
+  fallback (a host without MSC4533) is in `isCsApiUnavailable`.

README.md

@@ -289,8 +289,14 @@ callback; with one, it asks the host to unmount it instead. The
 [global JS controls](./docs/controls.md) on `window` are unchanged and remain
 page-wide, so with several instances on one page they apply to all of them.
 
-The package is not published yet. A host installs it as a git dependency on the
-`component` directory of this repository,
+Each release publishes the package to npm, with the same version as the release:
+
+```sh
+npm install @element-hq/element-call-component
+```
+
+To use an unreleased commit, a host can instead install it as a git dependency
+on the `component` directory of this repository,
 
 ```json
 "@element-hq/element-call-component": "github:element-hq/element-call#main&path:/component"

codecov.yml

@@ -0,0 +1,20 @@
+# Coverage comes from a single vitest run (see .github/workflows/test.yaml), so
+# the app and the SDK are split by path into codecov components rather than
+# uploaded under separate flags. Each component gets its own coverage figure in
+# the PR comment and on codecov.io.
+#
+# Validate with: curl --data-binary @codecov.yml https://codecov.io/validate
+
+comment:
+  layout: "reach, diff, flags, components, files"
+
+component_management:
+  individual_components:
+    - component_id: app
+      name: app
+      paths:
+        - src/**
+    - component_id: sdk
+      name: sdk
+      paths:
+        - sdk/**

component/LICENSE-AGPL-3.0

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

component/LICENSE-COMMERCIAL

@@ -0,0 +1,6 @@
+Licensees holding a valid commercial license with Element may use this
+software in accordance with the terms contained in a written agreement
+between you and Element.
+
+To purchase a commercial license please contact our sales team at
+licensing@element.io

component/README.md

@@ -0,0 +1,7 @@
+# @element-hq/element-call-component
+
+Element Call as a React component, rendered in the host application's page
+instead of in an iframe. Experimental.
+
+See [Element Call as a component](https://github.com/element-hq/element-call#element-call-as-a-component-experimental)
+in the Element Call README for usage.

component/index.tsx

@@ -74,7 +74,7 @@ import {
 import { MediaDevicesContext } from "../src/MediaDevicesContext";
 import { MediaDevices } from "../src/state/MediaDevices";
 import { ObservableScope } from "../src/state/ObservableScope";
-import { ProcessorProvider } from "../src/livekit/TrackProcessorContext";
+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";

component/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@element-hq/element-call-component",
   "version": "0.0.0",
-  "description": "Element Call as a React component. Consumed straight from the repository as a git dependency (github:element-hq/element-call#<ref>&path:/component): the host's package manager runs `prepare`, which builds `dist/`.",
-  "license": "SEE LICENSE IN ../README.md",
+  "description": "Element Call as a React component.",
+  "license": "AGPL-3.0-only OR LicenseRef-Element-Commercial",
   "repository": {
     "type": "git",
     "url": "https://github.com/element-hq/element-call",
@@ -15,6 +15,8 @@
     }
   },
   "files": [
+    "LICENSE-AGPL-3.0",
+    "LICENSE-COMMERCIAL",
     "dist"
   ],
   "main": "./dist/element-call.js",

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

locales/en/app.json

@@ -106,7 +106,7 @@
     "insufficient_capacity_description": "The server has reached its maximum capacity and you cannot join the call at this time. Try again later, or contact your server admin if the problem persists.",
     "livekit_connection_error": "Failed to connect to Livekit server",
     "livekit_connection_error_description": "An error occurred while connecting to the Livekit server (<1>Reason:</1> <2>{{ reason }}</2>).",
-    "matrix_rtc_transport_missing": "The server is not configured to work with {{brand}}. Please contact your server admin (Domain: {{domain}}, Error Code: {{ errorCode }}).",
+    "matrix_rtc_transport_missing": "The server is not configured to work with {{brand}} and no other call participant provides a usable transport. Please contact your server admin (Domain: {{domain}}, Error Code: {{ errorCode }}).",
     "membership_manager": "Membership Manager Error",
     "membership_manager_description": "The Membership Manager had to shut down. This is caused by many consecutive failed network requests.",
     "no_matrix_2_authorization_service": "The authorization service for your media server (SFU) is out of date.",

package.json

@@ -107,7 +107,7 @@
     "livekit-client": "^2.18.1",
     "lodash-es": "^4.17.21",
     "loglevel": "^1.9.1",
-    "matrix-js-sdk": "github:matrix-org/matrix-js-sdk#develop",
+    "matrix-js-sdk": "github:matrix-org/matrix-js-sdk#3f05dc4d104a3dfc753c5e3549a18c74fab4b076",
     "matrix-widget-api": "^1.18.0",
     "node-stdlib-browser": "^1.3.1",
     "normalize.css": "^8.0.1",

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,38 @@ 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,
+}) => {
+  test.slow();
+  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 +199,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/screen-share.test.ts

@@ -76,9 +76,9 @@ widgetTest("Sharing screen in group call", async ({ addUser, browserName }) => {
       timeout: 5000,
     });
 
-    await expect(
-      frame.locator('video[data-lk-source="screen_share"]'),
-    ).toHaveCount(1);
+    await expect(frame.locator('video[data-source="screenShare"]')).toHaveCount(
+      1,
+    );
   }
 
   // Alice should be in grid mode as she is local sharing
@@ -117,9 +117,9 @@ widgetTest("Sharing screen in group call", async ({ addUser, browserName }) => {
       timeout: 5000,
     });
 
-    await expect(
-      frame.locator('video[data-lk-source="screen_share"]'),
-    ).toHaveCount(2);
+    await expect(frame.locator('video[data-source="screenShare"]')).toHaveCount(
+      2,
+    );
 
     // Expect 2 indicators at the bottom
     await expect(frame.getByTestId("screenshare-indicator")).toHaveCount(2);

playwright/widget/test-helpers.ts

@@ -159,7 +159,7 @@ export class TestHelpers {
   public static async dismissStartupToasts(page: Page): Promise<void> {
     const expectedToasts = [
       { title: "Failed to load service worker", button: "OK" },
-      { title: "Back up your chats", button: "Dismiss" },
+      { title: "Back up your chats", button: "Not now" },
       { title: "Turn on key storage", button: "Dismiss" },
       { title: "Element does not support this browser", button: "Dismiss" },
     ];
@@ -178,7 +178,11 @@ export class TestHelpers {
         );
 
         if (toastConfig) {
-          await toast.getByRole("button", { name: toastConfig.button }).click();
+          // Bounded so that a renamed button leaves the toast in place and the
+          // next step reports it, instead of hanging until the test timeout.
+          await toast
+            .getByRole("button", { name: toastConfig.button })
+            .click({ timeout: 5000 });
         } else {
           // Unknown toast. We don't want to act on unknown toasts
           break;

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
@@ -66,13 +63,9 @@ widgetTest(
       await TestHelpers.expectVisibleVideoCount(frame, 2);
     }
 
-    // Element Web does not expose the MSC4195 endpoints to widgets yet, so
-    // neither side reached the CS API. The host published through the JWT
-    // service's legacy endpoint and subscribed to the guest through its
-    // default one; the guest published the same way and fell back to the
-    // default endpoint for the host's transport.
-    expect(hostFlows).toEqual(new Set(["service-legacy", "service-default"]));
-    expect(guestFlows).toEqual(new Set(["service-legacy", "service-default"]));
+    // Element Web used for Playwright does support MSC4195 for widgets.
+    expect(hostFlows).toEqual(new Set(["cs-api", "service-default"]));
+    expect(guestFlows).toEqual(new Set(["service-legacy", "cs-api"]));
   },
 );
 

sdk-target-based-on-call-view-model/README.md

@@ -1,8 +1,10 @@
-# SDK mode (EXPERIMENTAL, superseded)
+# SDK mode (LEGACY)
 
 > Superseded by the `sdk/` package (`@element-hq/matrixrtc-sdk`) and its harness in
-> `sdk/dev`; see `sdk-plan.md`. This folder still builds, with its own script, until
-> that package can do what this does.
+> `sdk/dev`; see `sdk/SdkArchitecture.md`. This bundle is in production use, so it
+> keeps building as a thin layer over that package until its consumers have moved
+> to the package directly. It will then be removed. Its members are the package's
+> `RTCMember`s now, in place of its own wrapper around the raw membership.
 
 EC can be build in sdk mode. This will result in a compiled js file that can be imported in very simple webapps.
 

sdk-target-based-on-call-view-model/helper.ts

@@ -1,51 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-/**
- * This file contains helper functions and types for the MatrixRTC SDK.
- */
-
-import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
-import { scan } from "rxjs";
-
-import { type WidgetHelpers } from "../src/widget";
-import { type LivekitRoomItem } from "../src/state/CallViewModel/CallViewModel";
-
-export const tryMakeSticky = (widget: WidgetHelpers): void => {
-  const logger = rootLogger.getChild("[MatrixRTCSdk]");
-  logger.info("try making sticky MatrixRTCSdk");
-  void widget.api
-    .setAlwaysOnScreen(true)
-    .then(() => {
-      logger.info("sticky MatrixRTCSdk");
-    })
-    .catch((error) => {
-      logger.error("failed to make sticky MatrixRTCSdk", error);
-    });
-};
-export const TEXT_LK_TOPIC = "matrixRTC";
-/**
- * simple helper operator to combine the last emitted and the current emitted value of a rxjs observable
- *
- * I think there should be a builtin for this but i did not find it...
- */
-export const currentAndPrev = scan<
-  LivekitRoomItem[],
-  {
-    prev: LivekitRoomItem[];
-    current: LivekitRoomItem[];
-  }
->(
-  ({ current: lastCurrentVal }, items) => ({
-    prev: lastCurrentVal,
-    current: items,
-  }),
-  {
-    prev: [],
-    current: [],
-  },
-);

sdk-target-based-on-call-view-model/index.html

@@ -30,12 +30,12 @@
         div.appendChild(child);
       });
 
-      sdk.members$.subscribe((memberObjects) => {
+      sdk.remoteMembers$.subscribe((memberObjects) => {
         const div = document.getElementById("members");
         div.innerHTML = "<h3>Members:</h3>";
 
         // Create member list
-        const members = memberObjects.map((member) => member.membership.sender);
+        const members = memberObjects.map((member) => member.userId);
         console.info("members changed", members);
         for (const m of members) {
           console.info("member", m);

sdk-target-based-on-call-view-model/main.ts

@@ -6,131 +6,82 @@ Please see LICENSE in the repository root for full details.
 */
 
 /**
- * EXPERIMENTAL
+ * LEGACY, in production use
  *
- * This file is the entrypoint for the sdk build of element call:
- * `pnpm build:sdk-target-based-on-call-view-model`
- * use in widgets.
- * It exposes the `createMatrixRTCSdk` which creates the `MatrixRTCSdk` interface (see below) that
- * can be used to join a rtc session and exchange realtime data.
- * It takes care of all the tricky bits:
- *  - sending delayed events
- *  - finding the right sfu
- *  - handling the media stream
- *  - sending join/leave state or sticky events
- *  - setting up encryption and scharing keys
+ * The entrypoint of `pnpm build:sdk-target-based-on-call-view-model`, a
+ * bundle for widgets that exposes `createMatrixRTCSdk`: join a slot and
+ * exchange realtime data, with the `@element-hq/matrixrtc-sdk` package and
+ * Element Call's call view model doing the work underneath. New consumers use
+ * the package directly; this bundle goes away once the existing ones have.
  */
 
+import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
+import { EMPTY, filter, map, type Observable, of, switchMap, take } from "rxjs";
 import {
-  combineLatest,
-  map,
-  type Observable,
-  of,
-  shareReplay,
-  Subject,
-  switchMap,
-  tap,
-} from "rxjs";
-import {
-  type CallMembership,
-  MatrixRTCSessionEvent,
-  MatrixRTCSessionManager,
-} from "matrix-js-sdk/lib/matrixrtc";
-import {
-  type Room as LivekitRoom,
-  type TextStreamReader,
-  type LocalParticipant,
-  type RemoteParticipant,
-} from "livekit-client";
+  type Behavior,
+  createRTCSlot,
+  E2eeType,
+  type LocalRTCMember,
+  ObservableScope,
+  type RemoteRTCMember,
+  type RTCParticipation,
+} from "@element-hq/matrixrtc-sdk";
 
-// TODO how can this get fixed? to just be part of `livekit-client`
-// Can this be done in the tsconfig.json
-import { type TextStreamInfo } from "../node_modules/livekit-client/dist/src/room/types";
-import { type Behavior, constant } from "../src/state/Behavior";
 import {
   callViewModelOptionsFromParams,
+  type CallViewModel,
   createCallViewModel$,
+  initialPublishRequests,
 } from "../src/state/CallViewModel/CallViewModel";
-import { ObservableScope } from "../src/state/ObservableScope";
-import { getUrlParams } from "../src/UrlParams";
-import { MuteStates } from "../src/state/MuteStates";
-import { MediaDevices } from "../src/state/MediaDevices";
-import { E2eeType } from "../src/e2ee/e2eeType";
-import { currentAndPrev, TEXT_LK_TOPIC, tryMakeSticky } from "./helper";
-import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
-import { initializeWidget } from "../src/widget";
-import { type Connection } from "../src/state/CallViewModel/remoteMembers/Connection";
+import {
+  captureSettings,
+  rtcParticipationOptions,
+  rtcSlotOptions,
+} from "../src/room/InCallView";
 import { createWidgetHostBridge } from "../src/HostBridge";
+import { MediaDevices } from "../src/state/MediaDevices";
+import { MuteStates } from "../src/state/MuteStates";
+import { getUrlParams } from "../src/UrlParams";
 import { observeElementSize$ } from "../src/utils/elementSize";
+import { initializeWidget } from "../src/widget";
 
-interface MatrixRTCSdk {
-  /**
-   * observe connected$ to track the state.
-   * @returns
-   */
+/** The data channel topic this bundle has always used, so that old and new builds talk. */
+const TOPIC = "matrixRTC";
+
+export interface MatrixRTCSdk {
+  /** Joins the slot; `connected$` tracks the progress. A second call does nothing. */
   join: () => void;
-  /** @throws on leave errors */
   leave: () => void;
-  /**
-   * Ends the rtc sdk. This will unsubscribe any event listeners. And end the associated scope.
-   * No updates can be received from the rtc sdk. The sdk cannot be restarted after.
-   * A new sdk needs to be created via createMatrixRTCSdk.
-   */
+  /** Ends everything. The sdk cannot be restarted; create a new one. */
   stop: () => void;
-  data$: Observable<{ rtcBackendIdentity: string; data: string }>;
-  /**
-   * flattened list of remote members
-   */
-  remoteMembers$: Behavior<
-    {
-      connection: Connection | null;
-      membership: CallMembership;
-      participant: LocalParticipant | RemoteParticipant | null;
-    }[]
-  >;
-  /**
-   * flattened local member
-   */
-  localMember$: Behavior<{
-    connection: Connection | null;
-    membership: CallMembership;
-    participant: LocalParticipant | null;
-  } | null>;
-  /** Use the LocalMemberConnectionState returned from `join` for a more detailed connection state  */
   connected$: Behavior<boolean>;
-  sendData?: (data: unknown) => Promise<void>;
-  sendRoomMessage?: (message: string) => Promise<void>;
+  /** Our own member, null until our membership has been seen in the room. */
+  localMember$: Behavior<LocalRTCMember | null>;
+  /** The other members of the slot, with the media the participation carries for them. */
+  remoteMembers$: Behavior<RemoteRTCMember[]>;
+  /** What other members sent with `sendData`. */
+  data$: Observable<{ rtcBackendIdentity: string; data: string }>;
+  /** Sends to every member on our transport. Rejects while not joined. */
+  sendData: (data: unknown) => Promise<void>;
+  sendRoomMessage: (message: string) => Promise<void>;
 }
 
 export async function createMatrixRTCSdk(
-  application: string = "m.call",
-  id: string = "",
-  sticky: boolean = false,
+  application = "m.call",
+  id = "",
+  sticky = false,
 ): Promise<MatrixRTCSdk> {
   const logger = rootLogger.getChild("[MatrixRTCSdk]");
   const scope = new ObservableScope();
-
-  // widget client
   const widget = initializeWidget(application, true);
-  if (!widget) throw Error("No widget. This webapp can only start as a widget");
+  if (!widget) throw new Error("No widget: this bundle only runs as a widget");
   const client = await widget.client;
   const hostBridge = createWidgetHostBridge(widget);
-  logger.info("client created");
-
-  // url params
   const urlParams = getUrlParams();
   const { roomId, controlledAudioDevices, callIntent } = urlParams;
-  if (roomId === null) throw Error("could not get roomId from url params");
-  const room = client.getRoom(roomId);
-  if (room === null) throw Error("could not get room from client");
+  const room = roomId === null ? null : client.getRoom(roomId);
+  if (room === null) throw new Error("No room: the url needs a joined roomId");
 
-  // rtc session
-  const slot = { application, id };
-  const rtcSessionManager = new MatrixRTCSessionManager(logger, client, slot);
-  rtcSessionManager.start();
-  const rtcSession = rtcSessionManager.getRoomSession(room);
-
-  // media devices
   const mediaDevices = new MediaDevices(scope, {
     controlledAudioDevices,
     callIntent,
@@ -141,243 +92,100 @@ export async function createMatrixRTCSdk(
     { audioEnabled: false, videoEnabled: false },
     hostBridge,
   );
+  const encryptionSystem = { kind: E2eeType.PER_PARTICIPANT } as const;
+  const capture = captureSettings();
+  const slot = createRTCSlot(scope, client, room, {
+    ...rtcSlotOptions(encryptionSystem),
+    application,
+    id,
+  });
+  let vm: CallViewModel | undefined;
+  const failed =
+    (what: string) =>
+    (e: unknown): void =>
+      logger.error(what, e);
 
-  // call view model
-  const callViewModel = createCallViewModel$(
-    scope,
-    rtcSession,
-    room,
-    mediaDevices,
-    muteStates,
-    {
-      ...callViewModelOptionsFromParams(urlParams),
-      encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
-      hostBridge,
-      // The SDK owns its page, so the body is the space it has
-      windowSize$: scope.behavior(observeElementSize$(document.body)),
-    },
-    of({}),
-    of({}),
-    constant({ supported: false, processor: undefined }),
-  );
-  logger.info("CallViewModelCreated");
-
-  // create data listener
-  const data$ = new Subject<{ rtcBackendIdentity: string; data: string }>();
-
-  const lkTextStreamHandlerFunction = async (
-    reader: TextStreamReader,
-    participantInfo: { identity: string },
-    livekitRoom: LivekitRoom,
-  ): Promise<void> => {
-    const info = reader.info;
-    logger.info(
-      `Received text stream from ${participantInfo.identity}\n` +
-        `  Topic: ${info.topic}\n` +
-        `  Timestamp: ${info.timestamp}\n` +
-        `  ID: ${info.id}\n` +
-        `  Size: ${info.size}`, // Optional, only available if the stream was sent with `sendText`
-    );
-
-    const participants = callViewModel.livekitRoomItems$.value.find(
-      (i) => i.livekitRoom === livekitRoom,
-    )?.participants;
-    if (participants && participants.includes(participantInfo.identity)) {
-      const text = await reader.readAll();
-      logger.info(`Received text: ${text}`);
-      data$.next({ rtcBackendIdentity: participantInfo.identity, data: text });
-    } else {
-      logger.warn(
-        "Received text from unknown participant",
-        participantInfo.identity,
-      );
-    }
-  };
-
-  const livekitRoomItemsSub = callViewModel.livekitRoomItems$
-    .pipe(
-      tap((beforecurrentAndPrev) => {
-        logger.info(
-          `LiveKit room items updated: ${beforecurrentAndPrev.length}`,
-          beforecurrentAndPrev,
-        );
-      }),
-      currentAndPrev,
-      tap((aftercurrentAndPrev) => {
-        logger.info(
-          `LiveKit room items updated: ${aftercurrentAndPrev.current.length}, ${aftercurrentAndPrev.prev.length}`,
-          aftercurrentAndPrev,
-        );
-      }),
-    )
-    .subscribe({
-      next: ({ prev, current }) => {
-        const prevRooms = prev.map((i) => i.livekitRoom);
-        const currentRooms = current.map((i) => i.livekitRoom);
-        const addedRooms = currentRooms.filter((r) => !prevRooms.includes(r));
-        const removedRooms = prevRooms.filter((r) => !currentRooms.includes(r));
-        addedRooms.forEach((r) => {
-          logger.info(`Registering text stream handler for room `);
-          r.registerTextStreamHandler(
-            TEXT_LK_TOPIC,
-            (reader, participantInfo) =>
-              void lkTextStreamHandlerFunction(reader, participantInfo, r),
-          );
-        });
-        removedRooms.forEach((r) => {
-          logger.info(`Unregistering text stream handler for room `);
-          r.unregisterTextStreamHandler(TEXT_LK_TOPIC);
-        });
-      },
-      complete: () => {
-        logger.info("Livekit room items subscription completed");
-        for (const item of callViewModel.livekitRoomItems$.value) {
-          logger.info("unregistering room item from room", item.transport);
-          item.livekitRoom.unregisterTextStreamHandler(TEXT_LK_TOPIC);
-        }
-      },
-    });
-
-  // create sendData function
-  const sendFn: Behavior<(data: string) => Promise<TextStreamInfo>> =
+  const over = <T>(
+    pick: (participation: RTCParticipation) => Observable<T>,
+    fallback: T,
+  ): Behavior<T> =>
     scope.behavior(
-      callViewModel.localMatrixLivekitMember$.pipe(
-        switchMap((m) => {
-          if (!m)
-            return of((data: string): never => {
-              throw Error("local membership not yet ready.");
-            });
-          return m.participant.value$.pipe(
-            map((p) => {
-              if (p === null) {
-                return (data: string): never => {
-                  throw Error("local participant not yet ready to send data.");
-                };
-              } else {
-                return async (data: string): Promise<TextStreamInfo> =>
-                  p.sendText(data, { topic: TEXT_LK_TOPIC });
-              }
-            }),
-          );
-        }),
+      slot.participation$.pipe(
+        switchMap((p) => (p === null ? of(fallback) : pick(p))),
       ),
     );
 
-  const sendData = async (data: unknown): Promise<void> => {
-    const dataString = JSON.stringify(data);
-    logger.info("try sending: ", dataString);
-    try {
-      await Promise.resolve();
-      const info = await sendFn.value(dataString);
-      logger.info(`Sent text with stream ID: ${info.id}`);
-    } catch (e) {
-      logger.error("failed sending: ", dataString, e);
-    }
-  };
-
-  const sendRoomMessage = async (message: string): Promise<void> => {
-    const messageString = JSON.stringify(message);
-    logger.info("try sending to room: ", messageString);
-    try {
-      await client.sendTextMessage(room.roomId, message);
-    } catch (e) {
-      logger.error("failed sending to room: ", messageString, e);
-    }
-  };
-
-  // after hangup gets called
-  const leaveSubs = callViewModel.leave$.subscribe(() => {
-    const scheduleWidgetCloseOnLeave = async (): Promise<void> => {
-      const leaveResolver = Promise.withResolvers<void>();
-      logger.info("waiting for RTC leave");
-      rtcSession.on(MatrixRTCSessionEvent.JoinStateChanged, (isJoined) => {
-        logger.info("received RTC join update: ", isJoined);
-        if (!isJoined) leaveResolver.resolve();
-      });
-      await leaveResolver.promise;
-      logger.info("send Unstick");
-      await hostBridge
-        .setAlwaysOnScreen(false)
-        .catch((e: unknown) =>
-          logger.error("Failed to set `alwaysOnScreen` to false", e),
-        );
-      logger.info("send Close");
-      await hostBridge
-        .close?.()
-        .catch((e: unknown) =>
-          logger.error("Failed to ask the host to close", e),
-        );
-    };
-
-    // schedule close first and then leave (scope.end)
-    void scheduleWidgetCloseOnLeave();
-  });
-
-  logger.info("createMatrixRTCSdk done");
-
   return {
     join: (): void => {
-      // first lets try making the widget sticky
-      if (sticky) tryMakeSticky(widget);
-      callViewModel.join();
-    },
-    leave: (): void => {
-      callViewModel.leave();
-    },
-    stop: (): void => {
-      leaveSubs.unsubscribe();
-      livekitRoomItemsSub.unsubscribe();
-      scope.end();
-    },
-    data$,
-    localMember$: scope.behavior(
-      callViewModel.localMatrixLivekitMember$.pipe(
-        tap((member) =>
-          logger.info("localMatrixLivekitMember$ next: ", member),
-        ),
-        switchMap((member) => {
-          if (member === null) return of(null);
-          return combineLatest([
-            member.connection$,
-            member.membership$,
-            member.participant.value$,
-          ]).pipe(
-            map(([connection, membership, participant]) => ({
-              connection,
-              membership,
-              participant,
-            })),
-          );
-        }),
-        tap((member) => logger.info("localMember$ next: ", member)),
-      ),
-    ),
-    connected$: callViewModel.connected$,
-    remoteMembers$: scope.behavior(
-      callViewModel.remoteMatrixLivekitMembers$.pipe(
-        switchMap((members) => {
-          const listOfMemberObservables = members.map((member) =>
-            combineLatest([
-              member.connection$,
-              member.membership$,
-              member.participant.value$,
-            ]).pipe(
-              map(([connection, membership, participant]) => ({
-                connection,
-                membership,
-                participant,
-              })),
-              // using shareReplay instead of a Behavior here because the behavior would need
-              // a tricky scope.end() setup.
-              shareReplay({ bufferSize: 1, refCount: true }),
+      if (slot.participation$.value !== null) return;
+      if (sticky)
+        widget.api
+          .setAlwaysOnScreen(true)
+          .catch(failed("Failed to make the widget sticky"));
+      const participation = slot.join({
+        ...rtcParticipationOptions(urlParams),
+        publish: initialPublishRequests(muteStates, mediaDevices, capture),
+      });
+      vm = createCallViewModel$(
+        scope,
+        participation,
+        room,
+        mediaDevices,
+        muteStates,
+        {
+          ...callViewModelOptionsFromParams(urlParams),
+          encryptionSystem,
+          capture,
+          hostBridge,
+          // The bundle owns its page, so the body is the space it has
+          windowSize$: scope.behavior(observeElementSize$(document.body)),
+        },
+        of({}),
+        of({}),
+      );
+      // Once the hang-up has gone through, unstick and ask the host to close us
+      vm.leave$
+        .pipe(
+          switchMap(() =>
+            participation.state$.pipe(
+              filter((state) => state.kind === "left"),
+              take(1),
             ),
-          );
-          return combineLatest(listOfMemberObservables);
-        }),
-      ),
-      [],
+          ),
+          scope.bind(),
+        )
+        .subscribe(() => {
+          hostBridge
+            .setAlwaysOnScreen(false)
+            .catch(failed("Failed to unstick the widget"))
+            .then(() => hostBridge.close?.())
+            .catch(failed("Failed to ask the host to close"));
+        });
+    },
+    leave: (): void => vm?.leave(),
+    stop: (): void => scope.end(),
+    connected$: over(
+      (p) => p.state$.pipe(map((state) => state.kind === "connected")),
+      false,
     ),
-    sendData,
-    sendRoomMessage,
+    localMember$: over((p) => p.localMember$, null),
+    remoteMembers$: over((p) => p.remoteMembers$, []),
+    // Attested members only: the SDK has matched the sender
+    data$: slot.participation$.pipe(
+      switchMap((p) => p?.data$ ?? EMPTY),
+      filter(({ topic }) => topic === TOPIC),
+      map(({ member, text }) => ({
+        rtcBackendIdentity: member.rtcBackendIdentity,
+        data: text,
+      })),
+    ),
+    sendData: async (data): Promise<void> => {
+      const participation = slot.participation$.value;
+      if (participation === null) throw new Error("Not joined");
+      await participation.sendData(TOPIC, JSON.stringify(data));
+    },
+    sendRoomMessage: async (message): Promise<void> => {
+      await client.sendTextMessage(room.roomId, message);
+    },
   };
 }

sdk/SdkArchitecture.md

@@ -101,6 +101,8 @@ LiveKit participants.
   │  create ───▶│                                       │                         │
   │             │ GET rtc/transports (session) ────────▶│                         │
   │             │◀── first transport of the backend's type                        │
+  │             │   (none, LiveKit only: a member's SFU │                         │
+  │             │    that lets us publish, get_token) ─▶│                         │
   │             │ prepareLocalTransport (backend):      │                         │
   │             │   publisher token: CS API get_token,  │                         │
   │             │   or OpenID token then /sfu/get ─────▶│                         │
@@ -556,7 +558,10 @@ export interface MediaBackend {
 ```
 
 What stays on the client's side: discovery of the local transport from the
-homeserver's list (a homeserver endpoint, so not a backend's), the membership
+homeserver's list (a homeserver endpoint, so not a backend's) with, for the
+LiveKit backend only, a last resort of another member's SFU that lets us
+publish (`findRemotePublishLivekitTransport`, wired in by `RTCParticipation` rather
+than by the backend interface, since it is an MSC4195 matter), the membership
 state machine in `LocalMembership.ts` and its combination with
 `local.connectionState$` into `state$`, the choice of delayed leave timings,
 mapping a data packet's sender to a member, and the transport registry, which keys on the raw

sdk/pnpm-lock.yaml

@@ -0,0 +1,9 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: false
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .: {}

sdk/src/RTCParticipation.test.ts

@@ -8,9 +8,11 @@ Please see LICENSE in the repository root for full details.
 import { type MatrixClient, type Room, SyncState } from "matrix-js-sdk";
 import { logger } from "matrix-js-sdk/lib/logger";
 import {
+  type CallMembership,
   MatrixRTCSessionEvent,
   MembershipManagerEvent,
   type Transport,
+  type UnstableLivekitTransport,
 } from "matrix-js-sdk/lib/matrixrtc";
 import { BehaviorSubject, EMPTY, Subject } from "rxjs";
 import { describe, expect, it, type Mock, vi } from "vitest";
@@ -38,13 +40,32 @@ import { constant } from "./reactive/Behavior";
 import { ObservableScope } from "./reactive/ObservableScope";
 import { createRTCParticipation } from "./RTCParticipation";
 import { transportId } from "./matrixrtc/Transports";
-import { flushPromises, mockEmitter, MockRTCSession } from "./utils/test";
+import {
+  flushPromises,
+  mockEmitter,
+  mockRtcMembership,
+  MockRTCSession,
+} from "./utils/test";
 
-const transport: Transport = {
+const transport: UnstableLivekitTransport = {
   type: "livekit",
   livekit_service_url: "https://lk.example.org",
 };
+
+const transportWithAlias: Transport = {
+  livekit_alias: "!room:example.org",
+  ...transport,
+};
+
 const userId = "@alice:example.org";
+/** A token with the publish grant, as a homeserver issues it for its own SFU. */
+const publisherJWT = [
+  {},
+  { sub: "identity", video: { room: "room", canPublish: true } },
+  {},
+]
+  .map((d) => global.btoa(JSON.stringify(d)))
+  .join(".");
 const deviceId = "AAAA";
 const legacyMemberId = `${userId}:${deviceId}`;
 
@@ -91,6 +112,13 @@ interface FakeBackend {
 function setup(
   options: Partial<RTCParticipationOptions> = {},
   slotOptions: { matrixRTCMode?: MatrixRTCMode } = {},
+  {
+    homeserverTransports = [transport],
+    memberships = [],
+  }: {
+    homeserverTransports?: Transport[];
+    memberships?: CallMembership[];
+  } = {},
 ): {
   scope: ObservableScope;
   participation: ReturnType<typeof createRTCParticipation>["participation"];
@@ -103,7 +131,7 @@ function setup(
 } {
   const scope = new ObservableScope();
   const room = { roomId: "!room:example.org" } as Room;
-  const session = new MockRTCSession(room);
+  const session = new MockRTCSession(room, memberships);
   const mockedSession = session.asMockedSession();
   const join = vi.spyOn(session, "join");
   const client = {
@@ -112,7 +140,8 @@ function setup(
     getDeviceId: () => deviceId,
     getDomain: () => "example.org",
     getSyncState: () => SyncState.Syncing,
-    _unstable_getRTCTransports: vi.fn().mockResolvedValue([transport]),
+    _unstable_getRTCTransports: vi.fn().mockResolvedValue(homeserverTransports),
+    _unstable_getLivekitToken: vi.fn().mockResolvedValue({ jwt: publisherJWT }),
   } as unknown as MatrixClient;
   const members$ = new BehaviorSubject<RTCMember[]>([]);
 
@@ -201,7 +230,7 @@ describe("createRTCParticipation", () => {
     await flushPromises();
     expect(join).toHaveBeenCalledWith(
       { userId, deviceId, memberId: legacyMemberId },
-      [transport],
+      [transportWithAlias],
       expect.objectContaining({
         manageMediaKeys: true,
         unstableSendStickyEvents: false,
@@ -220,6 +249,32 @@ describe("createRTCParticipation", () => {
     });
   });
 
+  it("publishes on another member's SFU where the homeserver advertises none", async () => {
+    const bobOnSfu = mockRtcMembership("@bob:example.org", "BOB", {
+      fociPreferred: [{ type: "livekit", url: "wss://sfu.example.org" }],
+    });
+    const { join, fake } = setup(
+      {},
+      {},
+      { homeserverTransports: [], memberships: [bobOnSfu] },
+    );
+    fake.prepared.resolve({ canDelegateDelayedLeave: false });
+    await flushPromises();
+    await flushPromises();
+
+    expect(join).toHaveBeenCalledWith(
+      expect.anything(),
+      [
+        {
+          type: "livekit",
+          url: "wss://sfu.example.org",
+          server_name: "example.org",
+        },
+      ],
+      expect.anything(),
+    );
+  });
+
   it("publishes only while joined", async () => {
     const { participation, session, fake, scope } = setup();
     const ended = vi.fn();
@@ -271,7 +326,7 @@ describe("createRTCParticipation", () => {
     await flushPromises();
     expect(join).toHaveBeenCalledWith(
       expect.anything(),
-      [transport],
+      [transportWithAlias],
       expect.objectContaining({ delayedLeaveEventDelayMs: 7_200_000 }),
     );
     expect(fake.delegateDelayedLeave).not.toHaveBeenCalled();

sdk/src/RTCParticipation.ts

@@ -11,6 +11,7 @@ import {
   type MatrixRTCSession as JsSdkRTCSession,
   MatrixRTCSessionEvent,
   MembershipManagerEvent,
+  type Transport,
 } from "matrix-js-sdk/lib/matrixrtc";
 import { type IMembershipManager } from "matrix-js-sdk/lib/matrixrtc/IMembershipManager";
 import { type CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
@@ -50,6 +51,7 @@ import {
   type MediaKey,
 } from "./media-backend/api";
 import { createLivekitBackend } from "./media-backend/livekit/LivekitBackend";
+import { findRemotePublishLivekitTransport } from "./media-backend/livekit/RemotePublishTransport";
 import { createHomeserverConnected$ } from "./matrixrtc/HomeserverConnected";
 import { joinJsSdkSession } from "./matrixrtc/joinJsSdkSession";
 import {
@@ -130,13 +132,34 @@ export function createRTCParticipation(
     logger,
   });
 
+  // If the backend is LiveKit, we check it for transports as well, as a
+  // fallback: another member's SFU may let us publish (MSC4195). LiveKit only,
+  // so it stays out of the backend interface
+  const transportFromBackends = async (): Promise<Transport | null> =>
+    backend.transportType === "livekit"
+      ? findRemotePublishLivekitTransport({
+          client,
+          // A snapshot: if nobody with a usable SFU is here yet, the user has
+          // to come back later rather than wait in a half-working lobby
+          memberships: jsSdkSession.memberships,
+          ownMembershipIdentity,
+          roomId: room.roomId,
+          slotId: jsSdkSession.slotId,
+          logger,
+        })
+      : null;
+
   const preparedTransport$ = from(
-    discoverLocalTransport(client, backend.transportType, options, logger).then(
-      async (transport): Promise<PreparedTransport> => ({
-        transport,
-        ...(await backend.prepareLocalTransport(transport)),
-      }),
-    ),
+    discoverLocalTransport(
+      client,
+      backend.transportType,
+      options,
+      transportFromBackends,
+      logger,
+    ).then(async (transport): Promise<PreparedTransport> => ({
+      transport,
+      ...(await backend.prepareLocalTransport(transport)),
+    })),
   );
 
   const localMembership = createLocalMembership$({
@@ -151,14 +174,20 @@ export function createRTCParticipation(
       timings.syncDisconnectGracePeriodMs,
     ),
     joinMatrixRTC: (transport, delayedLeave) =>
-      joinJsSdkSession(jsSdkSession, ownMembershipIdentity, transport, {
-        encryptMedia: encryptionSystem.kind !== E2eeType.NONE,
-        matrixRTCMode,
-        sendNotificationType: options.sendNotificationType,
-        applicationData: options.applicationData,
-        timings,
-        delayedLeave,
-      }),
+      joinJsSdkSession(
+        room.roomId,
+        jsSdkSession,
+        ownMembershipIdentity,
+        transport,
+        {
+          encryptMedia: encryptionSystem.kind !== E2eeType.NONE,
+          matrixRTCMode,
+          sendNotificationType: options.sendNotificationType,
+          applicationData: options.applicationData,
+          timings,
+          delayedLeave,
+        },
+      ),
     membershipManagerError$: fromEvent(
       jsSdkSession,
       MatrixRTCSessionEvent.MembershipManagerError,

sdk/src/matrixrtc/LocalTransport.test.ts

@@ -20,6 +20,11 @@ const hostTransport: Transport = {
   type: "livekit",
   livekit_service_url: "https://host.example.org",
 };
+const bobsTransport: Transport = {
+  type: "livekit",
+  url: "wss://sfu.bob.com",
+  server_name: "bob.com",
+};
 
 function client(
   advertised: Transport[],
@@ -30,6 +35,12 @@ function client(
   };
 }
 
+function fromBackends(
+  transport: Transport | null = null,
+): ReturnType<typeof vi.fn<() => Promise<Transport | null>>> {
+  return vi.fn(async () => Promise.resolve(transport));
+}
+
 describe("discoverLocalTransport", () => {
   it("takes the transport the host names without asking the homeserver", async () => {
     const c = client([homeserverTransport]);
@@ -39,6 +50,7 @@ describe("discoverLocalTransport", () => {
         c,
         "livekit",
         { transport: hostTransport },
+        fromBackends(),
         logger,
       ),
     ).resolves.toBe(hostTransport);
@@ -51,6 +63,7 @@ describe("discoverLocalTransport", () => {
         client([homeserverTransport]),
         "livekit",
         { fallbackTransport: hostTransport },
+        fromBackends(),
         logger,
       ),
     ).resolves.toEqual(homeserverTransport);
@@ -62,13 +75,35 @@ describe("discoverLocalTransport", () => {
         client([{ type: "not_livekit" }]),
         "livekit",
         { fallbackTransport: hostTransport },
+        fromBackends(),
         logger,
       ),
     ).resolves.toEqual(hostTransport);
   });
 
+  it("prefers a local transport over the backends' without asking them", async () => {
+    const backends = fromBackends(bobsTransport);
+
+    await expect(
+      discoverLocalTransport(
+        client([homeserverTransport]),
+        "livekit",
+        {},
+        backends,
+        logger,
+      ),
+    ).resolves.toEqual(homeserverTransport);
+    expect(backends).not.toHaveBeenCalled();
+  });
+
   it("fails naming the homeserver where there is no transport at all", async () => {
-    const promise = discoverLocalTransport(client([]), "livekit", {}, logger);
+    const promise = discoverLocalTransport(
+      client([]),
+      "livekit",
+      {},
+      fromBackends(),
+      logger,
+    );
 
     await expect(promise).rejects.toBeInstanceOf(
       MatrixRTCTransportMissingError,

sdk/src/matrixrtc/LocalTransport.ts

@@ -15,7 +15,10 @@ import { TransportAutoDiscovery } from "./TransportAutoDiscovery";
 
 /**
  * The transport the local member advertises: the one the host names, else the
- * homeserver's first of the type the backend serves, else the host's fallback.
+ * homeserver's first of the type the backend serves, else the host's fallback,
+ * else the first the backends can provide, which are asked only then.
+ *
+ * @throws {MatrixRTCTransportMissingError} where none of these exists.
  */
 export async function discoverLocalTransport(
   client: Pick<MatrixClient, "getDomain" | "_unstable_getRTCTransports">,
@@ -24,6 +27,7 @@ export async function discoverLocalTransport(
     transport: override,
     fallbackTransport,
   }: Pick<RTCParticipationOptions, "transport" | "fallbackTransport">,
+  transportFromBackends: () => Promise<Transport | null>,
   logger: Logger,
 ): Promise<Transport> {
   const transport =
@@ -33,7 +37,9 @@ export async function discoverLocalTransport(
       transportType,
       fallbackTransport,
       logger,
-    }).discoverPreferredTransport());
+    }).discoverPreferredTransport()) ??
+    (await transportFromBackends()) ??
+    null;
   if (transport === null)
     throw new MatrixRTCTransportMissingError(client.getDomain() ?? "");
   return transport;

sdk/src/matrixrtc/joinJsSdkSession.test.ts

@@ -6,6 +6,7 @@ Please see LICENSE in the repository root for full details.
 */
 
 import {
+  type UnstableLivekitTransport,
   type MatrixRTCSession,
   type Transport,
 } from "matrix-js-sdk/lib/matrixrtc";
@@ -15,11 +16,16 @@ import { defaultSessionTimings, MatrixRTCMode } from "../config";
 import { ownMemberMock } from "../utils/test";
 import { joinJsSdkSession } from "./joinJsSdkSession";
 
-const transport: Transport = {
+const transport: UnstableLivekitTransport = {
   type: "livekit",
   livekit_service_url: "https://lk.example.org",
 };
 
+const transportWithAlias: Transport = {
+  livekit_alias: "!room:example.org",
+  ...transport,
+};
+
 /** A session that only records the join; nothing else of it is touched. */
 function session(): MatrixRTCSession & {
   join: Mock<MatrixRTCSession["join"]>;
@@ -39,7 +45,7 @@ describe("joinJsSdkSession", () => {
       keyRotationParticipantLimit: 20,
     };
 
-    joinJsSdkSession(s, ownMemberMock, transport, {
+    joinJsSdkSession("!room:example.org", s, ownMemberMock, transport, {
       encryptMedia: true,
       matrixRTCMode: MatrixRTCMode.Compatibility,
       sendNotificationType: "ring",
@@ -51,7 +57,7 @@ describe("joinJsSdkSession", () => {
       },
     });
 
-    expect(s.join).toHaveBeenCalledWith(ownMemberMock, [transport], {
+    expect(s.join).toHaveBeenCalledWith(ownMemberMock, [transportWithAlias], {
       notificationType: "ring",
       callIntent: undefined,
       applicationData: {},
@@ -72,7 +78,7 @@ describe("joinJsSdkSession", () => {
   it("gives up on the network once the delayed leave has probably been sent", () => {
     const s = session();
 
-    joinJsSdkSession(s, ownMemberMock, transport, {
+    joinJsSdkSession("!room:example.org", s, ownMemberMock, transport, {
       encryptMedia: false,
       matrixRTCMode: MatrixRTCMode.Compatibility,
       timings: { ...defaultSessionTimings, networkErrorRetryMs: 4_000 },
@@ -81,7 +87,7 @@ describe("joinJsSdkSession", () => {
 
     expect(s.join).toHaveBeenCalledWith(
       ownMemberMock,
-      [transport],
+      [transportWithAlias],
       expect.objectContaining({
         manageMediaKeys: false,
         maximumNetworkErrorRetryCount: 4,
@@ -92,7 +98,30 @@ describe("joinJsSdkSession", () => {
   it("lifts the call intent out of the application data and sends sticky events in Matrix 2.0 mode", () => {
     const s = session();
 
-    joinJsSdkSession(s, ownMemberMock, transport, {
+    joinJsSdkSession("!room:example.org", s, ownMemberMock, transport, {
+      encryptMedia: true,
+      matrixRTCMode: MatrixRTCMode.Matrix_2_0,
+      applicationData: { "m.call.intent": "audio", custom: 1 },
+      timings: defaultSessionTimings,
+      delayedLeave: defaultSessionTimings.delayedLeave,
+    });
+
+    expect(s.join).toHaveBeenCalledWith(
+      ownMemberMock,
+      [transportWithAlias],
+      expect.objectContaining({
+        callIntent: "audio",
+        applicationData: { custom: 1 },
+        unstableSendStickyEvents: true,
+      }),
+    );
+  });
+
+  it("does not add livekit_alias to newer transport format", () => {
+    const s = session();
+    const transport = { type: "livekit", url: "wss://lk.example.org" };
+
+    joinJsSdkSession("!room:example.org", s, ownMemberMock, transport, {
       encryptMedia: true,
       matrixRTCMode: MatrixRTCMode.Matrix_2_0,
       applicationData: { "m.call.intent": "audio", custom: 1 },

sdk/src/matrixrtc/joinJsSdkSession.ts

@@ -35,6 +35,7 @@ interface Options {
  * @throws If the join could not be started.
  */
 export function joinJsSdkSession(
+  roomId: string,
   session: JsSdkRTCSession,
   ownMembershipIdentity: CallMembershipIdentityParts,
   transport: Transport,
@@ -58,20 +59,37 @@ export function joinJsSdkSession(
     timings.syncDisconnectGracePeriodMs,
     delayedLeave.delay_ms,
   );
-  session.join(ownMembershipIdentity, [transport], {
-    notificationType: sendNotificationType,
-    callIntent,
-    applicationData: rest,
-    manageMediaKeys: encryptMedia,
-    delayedLeaveEventRestartMs: delayedLeave.restart_ms,
-    delayedLeaveEventDelayMs: delayedLeave.delay_ms,
-    delayedLeaveEventRestartLocalTimeoutMs: delayedLeave.restart_timeout_ms,
-    networkErrorRetryMs: timings.networkErrorRetryMs,
-    makeKeyDelay: timings.waitForKeyRotationMs,
-    membershipEventExpiryMs: timings.membershipEventExpiryMs,
-    keyRotationParticipantLimit: timings.keyRotationParticipantLimit,
-    unstableSendStickyEvents: matrixRTCMode === MatrixRTCMode.Matrix_2_0,
-    maximumNetworkErrorRetryCount:
-      Math.ceil(maxWaitMs / timings.networkErrorRetryMs) + 1,
-  });
+
+  session.join(
+    ownMembershipIdentity,
+    // TODO: `livekit_alias` should be unused these days, but some Ruma-based
+    // clients still expect it to be present. Remove from `publishedTransports`
+    // as soon as https://github.com/ruma/ruma/pull/2642 and
+    // https://github.com/matrix-org/matrix-rust-sdk/pull/7335 are widely
+    // deployed.
+    [
+      {
+        ...("livekit_service_url" in transport
+          ? { livekit_alias: roomId }
+          : {}),
+        ...transport,
+      },
+    ],
+    {
+      notificationType: sendNotificationType,
+      callIntent,
+      applicationData: rest,
+      manageMediaKeys: encryptMedia,
+      delayedLeaveEventRestartMs: delayedLeave.restart_ms,
+      delayedLeaveEventDelayMs: delayedLeave.delay_ms,
+      delayedLeaveEventRestartLocalTimeoutMs: delayedLeave.restart_timeout_ms,
+      networkErrorRetryMs: timings.networkErrorRetryMs,
+      makeKeyDelay: timings.waitForKeyRotationMs,
+      membershipEventExpiryMs: timings.membershipEventExpiryMs,
+      keyRotationParticipantLimit: timings.keyRotationParticipantLimit,
+      unstableSendStickyEvents: matrixRTCMode === MatrixRTCMode.Matrix_2_0,
+      maximumNetworkErrorRetryCount:
+        Math.ceil(maxWaitMs / timings.networkErrorRetryMs) + 1,
+    },
+  );
 }

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.test.ts

@@ -258,6 +258,23 @@ describe("createLivekitBackend", () => {
     },
   );
 
+  it("prepares a remote SFU's transport on its homeserver, where delegation is not possible", async () => {
+    // Our own homeserver would delegate, so only the SFU being remote can
+    // explain delegation being skipped
+    fetchMock.post(homeserverEndpoint, 401);
+    const remoteTransport: UnstableLivekitTransport = {
+      type: "livekit",
+      url: "wss://sfu.sample.com",
+      server_name: "sample.com",
+    };
+
+    const capabilities = await backend().prepareLocalTransport(remoteTransport);
+
+    expect(capabilities).toEqual({ canDelegateDelayedLeave: false });
+    expect(connections[0].connection.role).toBe("publisher");
+    expect(connections[0].connection.serverName).toBe("sample.com");
+  });
+
   it("waits for the publisher connection to hold its token before the join", async () => {
     fetchMock.post(homeserverEndpoint, 404);
     fetchMock.post(`${exampleServiceUrl}/delegate_delayed_leave`, 404);
@@ -488,6 +505,27 @@ describe("createLivekitBackend", () => {
       expect(remote?.connection.transport).toEqual(carlsTransport);
       expect(remote?.connection.serverName).toBe("sample.com");
     });
+
+    it("connects to a remote publisher's transport on the SFU's homeserver", async () => {
+      const b = await prepared();
+      // Dave has no SFU of his own and publishes on sample.com's
+      const remoteTransport: UnstableLivekitTransport = {
+        type: "livekit",
+        url: "wss://sfu.sample.com",
+        server_name: "sample.com",
+      };
+      b.mediaFor(testScope(), {
+        ...bob(remoteTransport, ["dave-hashed"]),
+        userId: "@dave:example.org",
+      });
+      await flushPromises();
+
+      const remote = connections.find(
+        (c) => c.connection.role === "subscriber",
+      );
+      expect(remote?.connection.transport).toEqual(remoteTransport);
+      expect(remote?.connection.serverName).toBe("sample.com");
+    });
   });
 });
 

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

@@ -34,7 +34,7 @@ import {
   trackEpoch,
 } from "../../reactive/ObservableScope";
 import { mapScoped } from "../../utils/mapScoped";
-import { serverNameOf } from "../../utils/serverName";
+import { serverNameOf, serverNameOfTransport } from "../../utils/serverName";
 import {
   type BackendConnection,
   type MediaBackend,
@@ -60,7 +60,10 @@ import {
 import { toMediaConnectionState } from "./connectionState";
 import { createDataChannel$ } from "./DataChannel";
 import { createKeyProvider } from "./KeyProvider";
-import { createLivekitMemberMedia } from "./LivekitMemberMedia";
+import {
+  createLivekitMemberMedia,
+  participantSourcesEqual,
+} from "./LivekitMemberMedia";
 import { createLivekitLocalMedia } from "./LocalMedia";
 
 export interface LivekitBackendOptions {
@@ -146,26 +149,37 @@ export function createLivekitBackend(
     logger,
   );
 
+  const ownServerName = serverNameOf(ownMembershipIdentity.userId);
+
   const prepareLocalTransport = async (
     transport: Transport,
   ): Promise<TransportCapabilities> => {
     if (!isUnstableLivekitTransport(transport))
       throw new MatrixRTCError(`Not a LiveKit transport: ${transport.type}`);
-    const locator: TransportLocator = {
+    const serverName = serverNameOfTransport(
       transport,
-      serverName: serverNameOf(ownMembershipIdentity.userId),
-    };
-    // Delegation goes through whichever service authenticates us as a
-    // publisher, so only that service's support counts
-    const flow = chooseAuthFlow(transport, "publisher");
-    const canDelegate =
-      flow.kind === "openID"
-        ? supportsDelegation(
-            `${flow.serviceUrl}/delegate_delayed_leave`,
-            `transport ${flow.serviceUrl}`,
-            logger,
-          )
-        : homeserverSupportsDelegation;
+      ownMembershipIdentity.userId,
+    );
+    const locator: TransportLocator = { transport, serverName };
+    let canDelegate: Promise<boolean>;
+    if (serverName !== ownServerName) {
+      // Our homeserver only takes over leaves for its own SFUs
+      logger.info(
+        `Publishing on a remote SFU of ${serverName}, delegation is not possible`,
+      );
+      canDelegate = Promise.resolve(false);
+    } else {
+      // Check for support using the same auth flow that we intend to use later
+      const flow = chooseAuthFlow(transport);
+      canDelegate =
+        flow.kind === "openID"
+          ? supportsDelegation(
+              `${flow.serviceUrl}/delegate_delayed_leave`,
+              `transport ${flow.serviceUrl}`,
+              logger,
+            )
+          : homeserverSupportsDelegation;
+    }
     localTransport$.next(locator);
     // The membership is only sent once the publisher connection holds its
     // token, so that the LiveKit room exists before anyone subscribes to it:
@@ -204,7 +218,10 @@ export function createLivekitBackend(
         map((transport): TransportLocator | undefined => {
           const raw = transport?.raw;
           return isUnstableLivekitTransport(raw)
-            ? { transport: raw, serverName: serverNameOf(member.userId) }
+            ? {
+                transport: raw,
+                serverName: serverNameOfTransport(raw, member.userId),
+              }
             : undefined;
         }),
         distinctUntilChanged((a, b) => (a && keyFor(a)) === (b && keyFor(b))),
@@ -219,22 +236,28 @@ export function createLivekitBackend(
           const connection = connections.getConnectionForTransport(locator);
           // A member advertising both a `url` and a `livekit_service_url` may
           // have authenticated through either flow, under either identity
-          const participant = connections
+          const participants = connections
             .getParticipantsForTransport(locator)
-            .find((p) => backendIdentities.includes(p.identity));
-          return connection && participant
-            ? { participant, room: connection.livekitRoom }
+            .filter((p) => backendIdentities.includes(p.identity));
+          return connection && participants.length
+            ? { participants, room: connection.livekitRoom }
             : null;
         }),
-        distinctUntilChanged(
-          (a, b) => a?.participant === b?.participant && a?.room === b?.room,
-        ),
+        distinctUntilChanged(participantSourcesEqual),
       ),
     );
     source$.pipe(memberScope.bind()).subscribe((source) => {
-      logger.info(
-        `${member.rtcBackendIdentity}: LiveKit participant ${source ? `matched (${source.participant.sid})` : "missing"} on ${locator$.value ? JSON.stringify(locator$.value.transport) : "no transport"}`,
-      );
+      const transportString = locator$.value
+        ? JSON.stringify(locator$.value.transport)
+        : "no transport";
+      if (source)
+        logger.info(
+          `${member.rtcBackendIdentity}: ${source.participants.length} LiveKit participant(s) matched (${source.participants.map((p) => p.sid).join(", ")}) on ${transportString}`,
+        );
+      else
+        logger.info(
+          `${member.rtcBackendIdentity}: LiveKit participant missing on ${transportString}`,
+        );
     });
     return createLivekitMemberMedia(memberScope, source$, encryptionSystem);
   };

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

@@ -25,7 +25,7 @@ describe("createLivekitMemberMedia", () => {
     const { participant, publications, room, emitter } = fakes();
     const media = createLivekitMemberMedia(
       testScope(),
-      constant({ participant, room }),
+      constant({ participants: [participant], room }),
       { kind: E2eeType.NONE },
     );
     expect(media.tracks$.value).toEqual([]);
@@ -52,7 +52,7 @@ describe("createLivekitMemberMedia", () => {
     const { participant, publications, room, emitter } = fakes();
     const media = createLivekitMemberMedia(
       testScope(),
-      constant({ participant, room }),
+      constant({ participants: [participant], room }),
       { kind: E2eeType.NONE },
     );
     emitter.emit(

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

@@ -16,13 +16,20 @@ import {
   RoomEvent,
   type TrackPublication,
 } from "livekit-client";
-import { EMPTY, filter, map, type Observable, of, switchMap } from "rxjs";
+import {
+  EMPTY,
+  filter,
+  map,
+  type Observable,
+  of,
+  switchMap,
+  combineLatest,
+} from "rxjs";
 
 import { type ObservableScope } from "../../reactive/ObservableScope";
 import { generateItems } from "../../reactive/observable";
 import { E2eeType, type EncryptionSystem } from "../../encryption";
 import { type Behavior } from "../../reactive/Behavior";
-import { mapScoped } from "../../utils/mapScoped";
 import {
   type EncryptionError,
   type LocalMemberMedia,
@@ -33,13 +40,27 @@ import {
   createLivekitMediaTrack,
   createLocalLivekitMediaTrack,
 } from "./LivekitMediaTrack";
+import { shallowEquals as arrayShallowEquals } from "../../utils/array";
 
 /** Where a member's media comes from: its participant on a room, null while it has none. */
 export type ParticipantSource<P extends Participant = Participant> = {
-  participant: P;
+  participants: P[];
   room: LivekitRoom;
 } | null;
 
+export function participantSourcesEqual<P extends Participant = Participant>(
+  a: ParticipantSource<P>,
+  b: ParticipantSource<P>,
+): boolean {
+  return (
+    a === b ||
+    (a !== null &&
+      b !== null &&
+      arrayShallowEquals(a.participants, b.participants) &&
+      a.room === b.room)
+  );
+}
+
 /**
  * A member's media from its participant. The only place, with
  * `LivekitMediaTrack`, that reads a LiveKit participant; everything above
@@ -99,21 +120,28 @@ function memberTracks$<P extends Participant, T>(
   ) => T,
 ): Behavior<T[] | null> {
   return scope.behavior(
-    mapScoped(scope, source$, (participantScope, { participant, room }) =>
-      participantScope.behavior(
-        observeParticipantMedia(participant).pipe(
-          generateItems(
-            `${participant.identity} tracks$`,
-            function* () {
-              for (const publication of participant.trackPublications.values())
-                yield { keys: [publication.trackSid], data: publication };
-            },
-            (trackScope, publication$) =>
-              factory(trackScope, participant, publication$.value, room),
+    source$.pipe(
+      switchMap((source) => {
+        if (source === null) return of(null);
+        const { participants, room } = source;
+        return combineLatest(
+          participants.map((participant) =>
+            observeParticipantMedia(participant).pipe(
+              generateItems(
+                `${participant.identity} tracks$`,
+                function* () {
+                  for (const publication of participant.trackPublications.values())
+                    yield { keys: [publication.trackSid], data: publication };
+                },
+                (trackScope, publication$) =>
+                  factory(trackScope, participant, publication$.value, room),
+              ),
+            ),
           ),
-        ),
-      ),
-    ).pipe(switchMap((tracks$) => tracks$ ?? of(null))),
+          (...tracks) => tracks.flat(1),
+        );
+      }),
+    ),
   );
 }
 
@@ -133,7 +161,7 @@ function encryptionErrors$(
             filter(
               (message) =>
                 encryptionSystem.kind === E2eeType.SHARED_KEY ||
-                message.includes(source.participant.identity),
+                source.participants.some((p) => message.includes(p.identity)),
             ),
             map((message): EncryptionError | undefined =>
               message.includes("MissingKey")

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

@@ -10,7 +10,6 @@ import {
   type LocalParticipant,
   type LocalTrackPublication,
   ParticipantEvent,
-  type Room as LivekitRoom,
 } from "livekit-client";
 import { type Logger } from "matrix-js-sdk/lib/logger";
 import {
@@ -43,7 +42,11 @@ import { type LocalMediaBackend, MediaConnectionState } from "../api";
 import { type TransportLocator } from "./auth";
 import { type Connection } from "./Connection";
 import { type ConnectionMap } from "./ConnectionMap";
-import { createLocalLivekitMemberMedia } from "./LivekitMemberMedia";
+import {
+  createLocalLivekitMemberMedia,
+  type ParticipantSource,
+  participantSourcesEqual,
+} from "./LivekitMemberMedia";
 import { livekitSources } from "./LivekitMediaTrack";
 import { type DesiredMedia, Publisher } from "./Publisher";
 import { toMediaConnectionState } from "./connectionState";
@@ -217,17 +220,15 @@ function participantAndRoom$(
   scope: ObservableScope,
   participant$: Behavior<LocalParticipant | null>,
   connection$: Behavior<Connection | null>,
-): Behavior<{ participant: LocalParticipant; room: LivekitRoom } | null> {
+): Behavior<ParticipantSource<LocalParticipant>> {
   return scope.behavior(
     combineLatest([participant$, connection$]).pipe(
       map(([participant, connection]) =>
         participant && connection
-          ? { participant, room: connection.livekitRoom }
+          ? { participants: [participant], room: connection.livekitRoom }
           : null,
       ),
-      distinctUntilChanged(
-        (a, b) => a?.participant === b?.participant && a?.room === b?.room,
-      ),
+      distinctUntilChanged(participantSourcesEqual),
     ),
   );
 }

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

@@ -0,0 +1,172 @@
+/*
+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 { MatrixError } from "matrix-js-sdk";
+import { logger } from "matrix-js-sdk/lib/logger";
+import { type CallMembership } from "matrix-js-sdk/lib/matrixrtc";
+import { beforeEach, describe, expect, it, type Mocked, vi } from "vitest";
+
+import { mockRtcMembership, ownMemberMock } from "../../utils/test";
+import { type ClientGetTokenParts } from "./auth/csApi";
+import { findRemotePublishLivekitTransport } from "./RemotePublishTransport";
+
+/** A JWT whose payload states whether the issuing server lets us publish. */
+function jwtWithPublishGrant(canPublish: boolean): string {
+  return [
+    {}, // header
+    { sub: "identity", video: { room: "room", canPublish } }, // payload
+    {}, // signature
+  ]
+    .map((d) => global.btoa(JSON.stringify(d)))
+    .join(".");
+}
+
+const bobSfu = { type: "livekit", url: "wss://sfu.bob.com" };
+const carolSfu = { type: "livekit", url: "wss://sfu.carol.com" };
+const bobsTransport = { ...bobSfu, server_name: "bob.com" };
+const carolsTransport = { ...carolSfu, server_name: "carol.com" };
+
+// Bob is the oldest member, Carol joined after him
+const bob = mockRtcMembership("@bob:bob.com", "BOB", {
+  fociPreferred: [bobSfu],
+  membership: { created_ts: 100 },
+});
+const carol = mockRtcMembership("@carol:carol.com", "CAROL", {
+  fociPreferred: [carolSfu],
+  membership: { created_ts: 200 },
+});
+// Bob's other device, and Dave who publishes on Bob's SFU remotely
+const bobsLaptop = mockRtcMembership("@bob:bob.com", "LAPTOP", {
+  fociPreferred: [bobSfu],
+  membership: { created_ts: 150 },
+});
+const dave = mockRtcMembership("@dave:dave.com", "DAVE", {
+  fociPreferred: [bobsTransport],
+  membership: { created_ts: 160 },
+});
+const legacyErin = mockRtcMembership("@erin:erin.com", "ERIN", {
+  fociPreferred: [
+    { type: "livekit", livekit_service_url: "https://jwt.erin.com" },
+  ],
+  membership: { created_ts: 50 },
+});
+const ourselves = mockRtcMembership(
+  ownMemberMock.userId,
+  ownMemberMock.deviceId,
+  {
+    fociPreferred: [{ type: "livekit", url: "wss://sfu.example.org" }],
+    membership: { created_ts: 10 },
+  },
+);
+
+const csApiMissing = new MatrixError(
+  { errcode: "M_UNRECOGNIZED", error: "" },
+  404,
+);
+
+describe("findRemotePublishLivekitTransport", () => {
+  let client: Mocked<ClientGetTokenParts>;
+  const find = async (
+    memberships: CallMembership[],
+  ): ReturnType<typeof findRemotePublishLivekitTransport> =>
+    findRemotePublishLivekitTransport({
+      client,
+      memberships,
+      ownMembershipIdentity: ownMemberMock,
+      roomId: "!room:example.org",
+      slotId: "m.call#ROOM",
+      logger,
+    });
+
+  beforeEach(() => {
+    client = {
+      _unstable_getLivekitToken: vi
+        .fn()
+        .mockResolvedValue({ jwt: jwtWithPublishGrant(true) }),
+    };
+  });
+
+  it("publishes on the oldest member's SFU with its server_name", async () => {
+    await expect(find([carol, bob])).resolves.toEqual(bobsTransport);
+    expect(client._unstable_getLivekitToken).toHaveBeenCalledTimes(1);
+    expect(client._unstable_getLivekitToken).toHaveBeenCalledWith({
+      url: "wss://sfu.bob.com",
+      server_name: "bob.com",
+      room_id: "!room:example.org",
+      slot_id: "m.call#ROOM",
+      member_id: ownMemberMock.memberId,
+    });
+  });
+
+  it("asks about an SFU once however many members are on it", async () => {
+    client._unstable_getLivekitToken.mockResolvedValue({
+      jwt: jwtWithPublishGrant(false),
+    });
+
+    await expect(find([dave, bobsLaptop, bob])).resolves.toBeNull();
+    expect(client._unstable_getLivekitToken).toHaveBeenCalledTimes(1);
+  });
+
+  it("skips our own membership", async () => {
+    await expect(find([ourselves, bob])).resolves.toEqual(bobsTransport);
+    expect(client._unstable_getLivekitToken).toHaveBeenCalledTimes(1);
+  });
+
+  it("ignores members publishing through a legacy JWT service", async () => {
+    await expect(find([legacyErin, bob])).resolves.toEqual(bobsTransport);
+    expect(client._unstable_getLivekitToken).toHaveBeenCalledTimes(1);
+  });
+
+  it("moves on when a homeserver does not let us publish", async () => {
+    client._unstable_getLivekitToken.mockImplementation(
+      async ({ server_name }) =>
+        Promise.resolve({
+          jwt: jwtWithPublishGrant(server_name === "carol.com"),
+        }),
+    );
+
+    await expect(find([bob, carol])).resolves.toEqual(carolsTransport);
+    expect(client._unstable_getLivekitToken).toHaveBeenCalledTimes(2);
+  });
+
+  it("moves on when a homeserver refuses to issue a token", async () => {
+    client._unstable_getLivekitToken.mockImplementation(
+      async ({ server_name }) =>
+        server_name === "bob.com"
+          ? Promise.reject(
+              new MatrixError(
+                { errcode: "M_FORBIDDEN", error: "Not joined" },
+                403,
+              ),
+            )
+          : Promise.resolve({ jwt: jwtWithPublishGrant(true) }),
+    );
+
+    await expect(find([bob, carol])).resolves.toEqual(carolsTransport);
+  });
+
+  it("finds nothing once all candidates are exhausted", async () => {
+    client._unstable_getLivekitToken.mockResolvedValue({
+      jwt: jwtWithPublishGrant(false),
+    });
+
+    await expect(find([bob, carol])).resolves.toBeNull();
+    expect(client._unstable_getLivekitToken).toHaveBeenCalledTimes(2);
+  });
+
+  it("gives up immediately if our homeserver lacks the CS API", async () => {
+    client._unstable_getLivekitToken.mockRejectedValue(csApiMissing);
+
+    await expect(find([bob, carol])).resolves.toBeNull();
+    expect(client._unstable_getLivekitToken).toHaveBeenCalledTimes(1);
+  });
+
+  it("finds nothing where there are no other members", async () => {
+    await expect(find([ourselves])).resolves.toBeNull();
+    expect(client._unstable_getLivekitToken).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,105 @@
+/*
+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 Logger } from "matrix-js-sdk/lib/logger";
+import {
+  type CallMembership,
+  isUnstableLivekitTransport,
+  type Transport,
+} from "matrix-js-sdk/lib/matrixrtc";
+import { type CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
+
+import { isCsApiUnavailable } from "./auth";
+import * as csApi from "./auth/csApi";
+import { decodeSFUJWTPayload } from "./auth/types";
+
+export interface RemotePublishTransportParams {
+  client: csApi.ClientGetTokenParts;
+  /** The members whose SFUs are the candidates. */
+  memberships: CallMembership[];
+  ownMembershipIdentity: CallMembershipIdentityParts;
+  roomId: string;
+  slotId: string;
+  logger: Logger;
+}
+
+/**
+ * The SFU of another member that its homeserver lets us publish on, as the
+ * transport to advertise, or null where none does. Candidates are tried
+ * oldest membership first, each SFU once, and each is checked by asking for a
+ * publisher token through our homeserver (MSC4195): a homeserver may restrict
+ * remote publishers, which shows as a token without the publish grant.
+ */
+export async function findRemotePublishLivekitTransport({
+  client,
+  memberships,
+  ownMembershipIdentity: own,
+  roomId,
+  slotId,
+  logger,
+}: RemotePublishTransportParams): Promise<Transport | null> {
+  logger.info(
+    "No local transport available, looking for another member's SFU to publish on",
+  );
+  const tried = new Set<string>();
+  const byAge = [...memberships].sort((a, b) => a.createdTs() - b.createdTs());
+  for (const membership of byAge) {
+    if (
+      membership.userId === own.userId &&
+      membership.deviceId === own.deviceId
+    )
+      continue;
+    for (const transport of membership.transports) {
+      // Publishing remotely goes through the client-server API, which a JWT
+      // service cannot stand in for, so only a `url` qualifies
+      if (!isUnstableLivekitTransport(transport) || !("url" in transport))
+        continue;
+      const { url } = transport;
+      const serverName = membership.getTransportServerName(transport);
+      const key = JSON.stringify([url, serverName]);
+      if (tried.has(key)) continue;
+      tried.add(key);
+      try {
+        const { jwt } = await csApi.getSFUConfig({
+          client,
+          membership: own,
+          url,
+          serverName,
+          roomId,
+          slotId,
+        });
+        try {
+          // The SFU treats an absent canPublish grant as publishing allowed.
+          if (decodeSFUJWTPayload(jwt).video.canPublish !== false) {
+            logger.info(`Publishing on remote SFU ${url} of ${serverName}`);
+            return { type: "livekit", url, server_name: serverName };
+          }
+          logger.info(
+            `${serverName} does not let us publish on ${url}, skipping`,
+          );
+          continue;
+        } catch (e) {
+          logger.info(
+            `${serverName}: failed to decode SFUJWT payload: ${e}, skipping`,
+          );
+          continue;
+        }
+      } catch (e) {
+        if (isCsApiUnavailable(e)) {
+          // Without the endpoint no further candidate can work
+          logger.warn(
+            `Cannot use the MSC4195 get_token endpoint (${e}), so no remote SFU can be used`,
+          );
+          return null;
+        }
+        logger.warn(`Failed to get a token for ${url} of ${serverName}:`, e);
+        continue;
+      }
+    }
+  }
+  return null;
+}

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

@@ -48,7 +48,7 @@ function isEndpointUnsupported(e: unknown): boolean {
  * (MSC4533), which the widget API reports as a plain error. A connection
  * error is neither: the endpoint may well exist.
  */
-function isCsApiUnavailable(e: unknown): boolean {
+export function isCsApiUnavailable(e: unknown): boolean {
   if (isEndpointUnsupported(e)) return true;
   return !(e instanceof MatrixError) && !(e instanceof ConnectionError);
 }
@@ -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/auth/types.ts

@@ -34,11 +34,13 @@ export interface SFUConfig {
 }
 
 /** The parts of the JWT payload the backend reads. */
-interface SFUJWTPayload {
+export interface SFUJWTPayload {
   /** The subject: the participant identity the token carries. */
   sub: string;
   video: {
     room: string;
+    /** Whether the token lets us publish; a homeserver may deny this to remote publishers. */
+    canPublish?: boolean;
   };
 }
 
@@ -47,8 +49,7 @@ export function extractFullConfigFromToken(sfuConfig: {
   url: string;
   jwt: string;
 }): SFUConfig {
-  const [, payloadStr] = sfuConfig.jwt.split(".");
-  const payload = JSON.parse(global.atob(payloadStr)) as SFUJWTPayload;
+  const payload = decodeSFUJWTPayload(sfuConfig.jwt);
   return {
     jwt: sfuConfig.jwt,
     url: sfuConfig.url,
@@ -56,3 +57,9 @@ export function extractFullConfigFromToken(sfuConfig: {
     livekitIdentity: payload.sub,
   };
 }
+
+/** Decodes the payload of an SFU JWT, without verifying its signature. */
+export function decodeSFUJWTPayload(jwt: string): SFUJWTPayload {
+  const [, payloadStr] = jwt.split(".");
+  return JSON.parse(global.atob(payloadStr)) as SFUJWTPayload;
+}

sdk/src/utils/array.ts

@@ -0,0 +1,16 @@
+/*
+Copyright 2024 New Vector Ltd.
+
+SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE in the repository root for full details.
+*/
+
+/**
+ * Determine whether two arrays are equal by shallow comparison.
+ */
+export function shallowEquals<A>(first: A[], second: A[]): boolean {
+  if (first.length !== second.length) return false;
+  for (let i = 0; i < first.length; i++)
+    if (first[i] !== second[i]) return false;
+  return true;
+}

sdk/src/utils/serverName.ts

@@ -5,7 +5,23 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
+import { type Transport } from "matrix-js-sdk/lib/matrixrtc";
+
 /** The homeserver a Matrix user id belongs to: everything after the first colon. */
 export function serverNameOf(userId: string): string {
   return userId.replace(/^.*?:/, "");
 }
+
+/**
+ * The homeserver that operates a transport: the one the transport names, else
+ * the one of the member advertising it. A member publishing on another
+ * homeserver's SFU (MSC4195) names that homeserver in `server_name`.
+ */
+export function serverNameOfTransport(
+  transport: Transport,
+  userId: string,
+): string {
+  return typeof transport.server_name === "string"
+    ? transport.server_name
+    : serverNameOf(userId);
+}

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 { ProcessorProvider } from "./livekit/TrackProcessorContext";
+import { ProcessorProvider } from "./tracks/TrackProcessorContext";
 import { type AppViewModel } from "./state/AppViewModel";
 import { MediaDevicesContext } from "./MediaDevicesContext";
 import {

src/AppBar.module.css

@@ -7,6 +7,7 @@
   padding-top: env(safe-area-inset-top);
   opacity: 1;
   transition: opacity 0.15s;
+  text-align: center;
 }
 
 /* Pseudo-element for the gradient background */
@@ -52,7 +53,7 @@
     ". . ."
     "primaryButton title secondaryButton"
     ". . .";
-  place-items: center;
+  place-items: center stretch;
   column-gap: var(--cpd-space-2x);
 }
 

src/RTCConnectionStats.tsx

@@ -16,12 +16,12 @@ import classNames from "classnames";
 import { Modal } from "./Modal";
 import styles from "./RTCConnectionStats.module.css";
 import mediaViewStyles from "../src/tile/MediaView.module.css";
-import { type UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
+import { type Transport } from "matrix-js-sdk/lib/matrixrtc";
 
 interface Props {
   audio?: RTCInboundRtpStreamStats | RTCOutboundRtpStreamStats;
   video?: RTCInboundRtpStreamStats | RTCOutboundRtpStreamStats;
-  transport?: UnstableLivekitTransport;
+  transport?: Transport;
   rtcBackendIdentity?: string;
 }
 

src/button/ReactionToggleButton.test.tsx

@@ -6,7 +6,7 @@ Please see LICENSE in the repository root for full details.
 */
 
 import { act, render } from "@testing-library/react";
-import { expect, test, vi } from "vitest";
+import { expect, test } from "vitest";
 import { TooltipProvider } from "@vector-im/compound-web";
 import { userEvent } from "@testing-library/user-event";
 import { type ReactNode } from "react";
@@ -20,7 +20,6 @@ import { type MockRTCSession } from "../utils/test";
 import { ReactionsSenderProvider } from "../reactions/useReactionsSender";
 import { initializeWidget } from "../widget";
 initializeWidget();
-vi.mock("livekit-client/e2ee-worker?worker");
 
 const localIdent = `${localRtcMember.userId}:${localRtcMember.deviceId}`;
 

src/config/ConfigOptions.ts

@@ -6,23 +6,9 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-/**
- * The MatrixRTC mode determines how Element Call interacts with the
- * MatrixRTC backend and other participants. Selectable via the Developer
- * Settings, or pinned for a deployment via `matrix_rtc_mode` in config.json.
- */
-export enum MatrixRTCMode {
-  /** Multi-SFU transport, legacy JWT endpoint, state events. */
-  Compatibility = "compatibility",
-  /**
-   * Multi-SFU transport with:
-   *  - sticky events
-   *  - hashed RTC backend identity
-   *  - the new endpoint for the jwt token on the local membership (remote memberships will always try the new jwt endpoint first -> then the legacy one)
-   *  - use the hashed identity for the local membership
-   */
-  Matrix_2_0 = "matrix_2_0",
-}
+import { MatrixRTCMode } from "@element-hq/matrixrtc-sdk";
+
+export { MatrixRTCMode };
 
 export interface DelayedLeaveTimings {
   /**

src/e2ee/e2eeType.ts

@@ -1,12 +1,8 @@
 /*
-Copyright 2023, 2024 New Vector Ltd.
+Copyright 2026 Element Creations Ltd.
 
 SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-export enum E2eeType {
-  NONE = 0,
-  PER_PARTICIPANT = 1,
-  SHARED_KEY = 2,
-}
+export { E2eeType } from "@element-hq/matrixrtc-sdk";

src/e2ee/matrixKeyProvider.test.ts

@@ -1,72 +0,0 @@
-/*
-Copyright 2024 New Vector 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, test, vi } from "vitest";
-import {
-  type MatrixRTCSession,
-  MatrixRTCSessionEvent,
-} from "matrix-js-sdk/lib/matrixrtc";
-import { KeyProviderEvent } from "livekit-client";
-
-import { MatrixKeyProvider } from "./matrixKeyProvider";
-
-function mockRTCSession(): MatrixRTCSession {
-  return {
-    on: vi.fn(),
-    off: vi.fn(),
-    reemitEncryptionKeys: vi.fn(),
-  } as unknown as MatrixRTCSession;
-}
-
-describe("matrixKeyProvider", () => {
-  test("initializes", () => {
-    const keyProvider = new MatrixKeyProvider();
-    expect(keyProvider).toBeTruthy();
-  });
-
-  test("listens for key requests and emits existing keys", () => {
-    const keyProvider = new MatrixKeyProvider();
-
-    const session = mockRTCSession();
-
-    keyProvider.setRTCSession(session);
-
-    expect(session.on).toHaveBeenCalledWith(
-      MatrixRTCSessionEvent.EncryptionKeyChanged,
-      expect.any(Function),
-    );
-    expect(session.off).not.toHaveBeenCalled();
-  });
-
-  test("stops listening when session changes", () => {
-    const keyProvider = new MatrixKeyProvider();
-
-    const session1 = mockRTCSession();
-    const session2 = mockRTCSession();
-
-    keyProvider.setRTCSession(session1);
-    expect(session1.off).not.toHaveBeenCalled();
-
-    keyProvider.setRTCSession(session2);
-    expect(session1.off).toHaveBeenCalledWith(
-      MatrixRTCSessionEvent.EncryptionKeyChanged,
-      expect.any(Function),
-    );
-  });
-
-  test("emits existing keys", () => {
-    const keyProvider = new MatrixKeyProvider();
-    const setKeyListener = vi.fn();
-    keyProvider.on(KeyProviderEvent.SetKey, setKeyListener);
-
-    const session = mockRTCSession();
-
-    keyProvider.setRTCSession(session);
-
-    expect(session.reemitEncryptionKeys).toHaveBeenCalled();
-  });
-});

src/e2ee/matrixKeyProvider.ts

@@ -1,75 +0,0 @@
-/*
-Copyright 2023, 2024 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { BaseKeyProvider } from "livekit-client";
-import {
-  type MatrixRTCSession,
-  MatrixRTCSessionEvent,
-} from "matrix-js-sdk/lib/matrixrtc";
-import { logger as rootLogger, type Logger } from "matrix-js-sdk/lib/logger";
-import { type CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
-
-export class MatrixKeyProvider extends BaseKeyProvider {
-  private rtcSession?: MatrixRTCSession;
-  private logger: Logger;
-  public constructor() {
-    super({ ratchetWindowSize: 10, keyringSize: 256 });
-    this.logger = rootLogger.getChild("[MatrixKeyProvider]");
-  }
-
-  public setRTCSession(rtcSession: MatrixRTCSession): void {
-    if (this.rtcSession) {
-      this.rtcSession.off(
-        MatrixRTCSessionEvent.EncryptionKeyChanged,
-        this.onEncryptionKeyChanged,
-      );
-    }
-
-    this.rtcSession = rtcSession;
-
-    this.rtcSession.on(
-      MatrixRTCSessionEvent.EncryptionKeyChanged,
-      this.onEncryptionKeyChanged,
-    );
-
-    // The new session could be aware of keys of which the old session wasn't,
-    // so emit key changed events
-    this.rtcSession.reemitEncryptionKeys();
-  }
-
-  private onEncryptionKeyChanged = (
-    encryptionKey: Uint8Array<ArrayBuffer>,
-    encryptionKeyIndex: number,
-    membershipParts: CallMembershipIdentityParts,
-    rtcBackendIdentity: string,
-  ): void => {
-    crypto.subtle
-      .importKey("raw", encryptionKey, "HKDF", false, [
-        "deriveBits",
-        "deriveKey",
-      ])
-      .then(
-        (keyMaterial) => {
-          this.onSetEncryptionKey(
-            keyMaterial,
-            rtcBackendIdentity,
-            encryptionKeyIndex,
-          );
-
-          this.logger.debug(
-            `Sent new key to livekit room=${this.rtcSession?.room.roomId} participantId=${rtcBackendIdentity} (before hash: ${membershipParts.userId}:${membershipParts.deviceId}) encryptionKeyIndex=${encryptionKeyIndex}`,
-          );
-        },
-        (e) => {
-          this.logger.error(
-            `Failed to create key material from buffer for livekit room=${this.rtcSession?.room.roomId} participantId before hash=${membershipParts.userId}:${membershipParts.deviceId} encryptionKeyIndex=${encryptionKeyIndex}`,
-            e,
-          );
-        },
-      );
-  };
-}

src/e2ee/sharedKeyManagement.ts

@@ -13,7 +13,7 @@ import {
   useLocalStorage,
 } from "../useLocalStorage";
 import { getUrlParams, useUrlParams } from "../UrlParams";
-import { E2eeType } from "./e2eeType";
+import { E2eeType, type EncryptionSystem } from "@element-hq/matrixrtc-sdk";
 import { useClient } from "../ClientContext";
 
 /**
@@ -82,10 +82,7 @@ export function getKeyForRoom(roomId: string): string | null {
   return keyForRoom(roomId, paramsRoomId, password);
 }
 
-export type Unencrypted = { kind: E2eeType.NONE };
-export type SharedSecret = { kind: E2eeType.SHARED_KEY; secret: string };
-export type PerParticipantE2EE = { kind: E2eeType.PER_PARTICIPANT };
-export type EncryptionSystem = Unencrypted | SharedSecret | PerParticipantE2EE;
+export { type EncryptionSystem } from "@element-hq/matrixrtc-sdk";
 
 export function useRoomEncryptionSystem(roomId: string): EncryptionSystem {
   const { client } = useClient();

src/livekit/MatrixAudioRenderer.test.tsx

@@ -1,342 +0,0 @@
-/*
-Copyright 2023, 2024 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import { render, type RenderResult } from "@testing-library/react";
-import {
-  getTrackReferenceId,
-  type TrackReference,
-} from "@livekit/components-core";
-import {
-  type Participant,
-  type RemoteAudioTrack,
-  type Room,
-  Track,
-} from "livekit-client";
-import { type ReactNode } from "react";
-import { useTracks } from "@livekit/components-react";
-
-import { testAudioContext } from "../useAudioContext.test";
-import * as MediaDevicesContext from "../MediaDevicesContext";
-import { LivekitRoomAudioRenderer } from "./MatrixAudioRenderer";
-import {
-  exampleTransportLocator,
-  mockLocalParticipant,
-  mockMediaDevices,
-  mockRemoteParticipant,
-  mockTrack,
-} from "../utils/test";
-import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
-import { initializeWidget } from "../widget";
-initializeWidget();
-export const TestAudioContextConstructor = vi.fn(
-  class {
-    public constructor() {
-      return testAudioContext;
-    }
-  },
-);
-
-const MediaDevicesProvider = MediaDevicesContext.MediaDevicesContext.Provider;
-
-beforeEach(() => {
-  vi.stubGlobal("AudioContext", TestAudioContextConstructor);
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.clearAllMocks();
-});
-
-vi.mock("@livekit/components-react", async (importOriginal) => {
-  return {
-    ...(await importOriginal()),
-    AudioTrack: (props: { trackRef: TrackReference }): ReactNode => {
-      return (
-        <audio data-testid={"audio"}>
-          {getTrackReferenceId(props.trackRef)}
-        </audio>
-      );
-    },
-    useTracks: vi.fn(),
-  };
-});
-
-let tracks: TrackReference[] = [];
-
-/**
- * Render the test component with given rtc members and livekit participant identities.
- *
- * It is possible to have rtc members that are not in livekit (e.g. not yet joined) and vice versa.
- *
- * @param rtcMembers - Array of active rtc members with userId and deviceId.
- * @param livekitParticipantIdentities - Array of livekit participant (that are publishing).
- * @param explicitTracks - Array of tracks available in livekit, if not provided, one audio track per livekitParticipantIdentities will be created.
- * */
-
-function renderTestComponent(
-  rtcMembers: { userId: string; deviceId: string }[],
-  livekitParticipantIdentities: string[],
-  explicitTracks?: {
-    participantId: string;
-    kind: Track.Kind;
-    source: Track.Source;
-  }[],
-): RenderResult {
-  const liveKitParticipants = livekitParticipantIdentities.map((identity) =>
-    mockRemoteParticipant({ identity }),
-  );
-  const participants = rtcMembers.flatMap(({ userId, deviceId }) => {
-    const p = liveKitParticipants.find(
-      (p) => p.identity === `${userId}:${deviceId}`,
-    );
-    return p === undefined ? [] : [p];
-  });
-  const livekitRoom = {
-    remoteParticipants: new Map<string, Participant>(
-      liveKitParticipants.map((p) => [p.identity, p]),
-    ),
-  } as unknown as Room;
-
-  if ((explicitTracks?.length ?? 0) > 0) {
-    tracks = explicitTracks!.map(({ participantId, source, kind }) => {
-      const participant =
-        liveKitParticipants.find((p) => p.identity === participantId) ??
-        mockRemoteParticipant({ identity: participantId });
-      return mockTrack(participant, kind, source);
-    });
-  } else {
-    tracks = participants.map((p) => mockTrack(p));
-  }
-
-  vi.mocked(useTracks).mockReturnValue(tracks);
-  return render(
-    <MediaDevicesProvider value={mockMediaDevices({})}>
-      <LivekitRoomAudioRenderer
-        validIdentities={participants.map((p) => p.identity)}
-        livekitRoom={livekitRoom}
-        transport={exampleTransportLocator}
-      />
-    </MediaDevicesProvider>,
-  );
-}
-
-it("should render for member", () => {
-  const { container, queryAllByTestId } = renderTestComponent(
-    [{ userId: "@alice", deviceId: "DEV0" }],
-    ["@alice:DEV0"],
-  );
-  expect(container).toBeTruthy();
-  expect(queryAllByTestId("audio")).toHaveLength(1);
-});
-
-function spyOnWarn(): ReturnType<typeof vi.fn> {
-  const warn = vi.fn();
-  vi.spyOn(rootLogger, "getChild").mockReturnValue({
-    warn,
-  } as unknown as typeof rootLogger);
-  return warn;
-}
-
-it("should not render or warn for the local participant", () => {
-  const warn = spyOnWarn();
-  const local = mockLocalParticipant({ identity: "@alice:DEV0" });
-  vi.mocked(useTracks).mockReturnValue([mockTrack(local)]);
-  const { queryAllByTestId } = render(
-    <MediaDevicesProvider value={mockMediaDevices({})}>
-      <LivekitRoomAudioRenderer
-        validIdentities={[]}
-        livekitRoom={{ remoteParticipants: new Map() } as unknown as Room}
-        transport={exampleTransportLocator}
-      />
-    </MediaDevicesProvider>,
-  );
-  expect(queryAllByTestId("audio")).toHaveLength(0);
-  expect(warn).not.toHaveBeenCalled();
-});
-
-it("should warn only once per unexpected participant", () => {
-  const warn = spyOnWarn();
-  const { rerender } = renderTestComponent(
-    [{ userId: "@bob", deviceId: "DEV0" }],
-    ["@alice:DEV0"],
-    [
-      {
-        participantId: "@alice:DEV0",
-        kind: Track.Kind.Audio,
-        source: Track.Source.Microphone,
-      },
-    ],
-  );
-  expect(warn).toHaveBeenCalledTimes(1);
-  rerender(
-    <MediaDevicesProvider value={mockMediaDevices({})}>
-      <LivekitRoomAudioRenderer
-        validIdentities={[]}
-        livekitRoom={{ remoteParticipants: new Map() } as unknown as Room}
-        transport={exampleTransportLocator}
-      />
-    </MediaDevicesProvider>,
-  );
-  expect(warn).toHaveBeenCalledTimes(1);
-});
-
-it("should not render without member", () => {
-  const { container, queryAllByTestId } = renderTestComponent(
-    [{ userId: "@bob", deviceId: "DEV0" }],
-    ["@alice:DEV0"],
-  );
-  expect(container).toBeTruthy();
-  expect(queryAllByTestId("audio")).toHaveLength(0);
-});
-
-const TEST_CASES: {
-  name: string;
-  rtcUsers: { userId: string; deviceId: string }[];
-  livekitParticipantIdentities: string[];
-  explicitTracks?: {
-    participantId: string;
-    kind: Track.Kind;
-    source: Track.Source;
-  }[];
-  expectedAudioTracks: number;
-}[] = [
-  {
-    name: "single user single device",
-    rtcUsers: [
-      { userId: "@alice", deviceId: "DEV0" },
-      { userId: "@alice", deviceId: "DEV1" },
-      { userId: "@bob", deviceId: "DEV0" },
-    ],
-    livekitParticipantIdentities: ["@alice:DEV0", "@bob:DEV0", "@alice:DEV1"],
-    expectedAudioTracks: 3,
-  },
-  // Charlie is a rtc member but not in livekit
-  {
-    name: "Charlie is rtc member but not in livekit",
-    rtcUsers: [
-      { userId: "@alice", deviceId: "DEV0" },
-      { userId: "@bob", deviceId: "DEV0" },
-      { userId: "@charlie", deviceId: "DEV0" },
-    ],
-    livekitParticipantIdentities: ["@alice:DEV0", "@bob:DEV0"],
-    expectedAudioTracks: 2,
-  },
-  // Charlie is in livekit but not rtc member
-  {
-    name: "Charlie is in livekit but not rtc member",
-    rtcUsers: [
-      { userId: "@alice", deviceId: "DEV0" },
-      { userId: "@bob", deviceId: "DEV0" },
-    ],
-    livekitParticipantIdentities: ["@alice:DEV0", "@bob:DEV0", "@charlie:DEV0"],
-    expectedAudioTracks: 2,
-  },
-  {
-    name: "no audio track, only video track",
-    rtcUsers: [{ userId: "@alice", deviceId: "DEV0" }],
-    livekitParticipantIdentities: ["@alice:DEV0"],
-    explicitTracks: [
-      {
-        participantId: "@alice:DEV0",
-        kind: Track.Kind.Video,
-        source: Track.Source.Camera,
-      },
-    ],
-    expectedAudioTracks: 0,
-  },
-  {
-    name: "Audio track from unknown source",
-    rtcUsers: [{ userId: "@alice", deviceId: "DEV0" }],
-    livekitParticipantIdentities: ["@alice:DEV0"],
-    explicitTracks: [
-      {
-        participantId: "@alice:DEV0",
-        kind: Track.Kind.Audio,
-        source: Track.Source.Unknown,
-      },
-    ],
-    expectedAudioTracks: 1,
-  },
-  {
-    name: "Audio track from other device",
-    rtcUsers: [{ userId: "@alice", deviceId: "DEV0" }],
-    livekitParticipantIdentities: ["@alice:DEV0"],
-    explicitTracks: [
-      {
-        participantId: "@alice:DEV1",
-        kind: Track.Kind.Audio,
-        source: Track.Source.Microphone,
-      },
-    ],
-    expectedAudioTracks: 0,
-  },
-  {
-    name: "two audio tracks, microphone and screenshare",
-    rtcUsers: [{ userId: "@alice", deviceId: "DEV0" }],
-    livekitParticipantIdentities: ["@alice:DEV0"],
-    explicitTracks: [
-      {
-        participantId: "@alice:DEV0",
-        kind: Track.Kind.Audio,
-        source: Track.Source.Microphone,
-      },
-      {
-        participantId: "@alice:DEV0",
-        kind: Track.Kind.Audio,
-        source: Track.Source.ScreenShareAudio,
-      },
-    ],
-    expectedAudioTracks: 2,
-  },
-];
-
-it.each(TEST_CASES)(
-  `should render sound test cases $name`,
-  ({
-    rtcUsers,
-    livekitParticipantIdentities,
-    explicitTracks,
-    expectedAudioTracks,
-  }) => {
-    const { queryAllByTestId } = renderTestComponent(
-      rtcUsers,
-      livekitParticipantIdentities,
-      explicitTracks,
-    );
-    expect(queryAllByTestId("audio")).toHaveLength(expectedAudioTracks);
-  },
-);
-
-it("should not setup audioContext gain and pan if there is no need to.", () => {
-  renderTestComponent([{ userId: "@bob", deviceId: "DEV0" }], ["@bob:DEV0"]);
-  const audioTrack = tracks[0].publication.track! as RemoteAudioTrack;
-
-  expect(audioTrack.setAudioContext).toHaveBeenCalledTimes(1);
-  expect(audioTrack.setAudioContext).toHaveBeenCalledWith(undefined);
-  expect(audioTrack.setWebAudioPlugins).toHaveBeenCalledTimes(1);
-  expect(audioTrack.setWebAudioPlugins).toHaveBeenCalledWith([]);
-
-  expect(testAudioContext.gain.gain.value).toEqual(1);
-  expect(testAudioContext.pan.pan.value).toEqual(0);
-});
-
-it("should setup audioContext gain and pan", () => {
-  vi.spyOn(MediaDevicesContext, "useEarpieceAudioConfig").mockReturnValue({
-    pan: 1,
-    volume: 0.1,
-  });
-
-  renderTestComponent([{ userId: "@bob", deviceId: "DEV0" }], ["@bob:DEV0"]);
-
-  const audioTrack = tracks[0].publication.track! as RemoteAudioTrack;
-  expect(audioTrack.setAudioContext).toHaveBeenCalled();
-  expect(audioTrack.setWebAudioPlugins).toHaveBeenCalled();
-
-  expect(testAudioContext.gain.gain.value).toEqual(0.1);
-  expect(testAudioContext.pan.pan.value).toEqual(1);
-});

src/livekit/MatrixAudioRenderer.tsx

@@ -1,216 +0,0 @@
-/*
-Copyright 2025 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { getTrackReferenceId } from "@livekit/components-core";
-import { type Room as LivekitRoom } from "livekit-client";
-import { type RemoteAudioTrack, Track } from "livekit-client";
-import { useEffect, useMemo, useRef, useState, type ReactNode } from "react";
-import {
-  useTracks,
-  AudioTrack,
-  type AudioTrackProps,
-} from "@livekit/components-react";
-import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
-
-import { useEarpieceAudioConfig } from "../MediaDevicesContext";
-import { useReactiveState } from "../useReactiveState";
-import * as controls from "../controls";
-import { type TransportLocator } from "./auth";
-
-export interface MatrixAudioRendererProps {
-  transport: TransportLocator;
-  livekitRoom: LivekitRoom;
-  /**
-   * The list of participant identities to render audio for.
-   * This list needs to be composed based on the matrixRTC members so that we do not play audio from users
-   * that are not expected to be in the rtc session (local user is excluded).
-   */
-  validIdentities: string[];
-  /**
-   * If set to `true`, mutes all audio tracks rendered by the component.
-   * @remarks
-   * If set to `true`, the server will stop sending audio track data to the client.
-   */
-  muted?: boolean;
-}
-
-/**
- * Takes care of handling remote participants’ audio tracks and makes sure that microphones and screen share are audible.
- *
- * It also takes care of the earpiece audio configuration for iOS devices.
- * This is done by using the WebAudio API to create a stereo pan effect that mimics the earpiece audio.
- * @example
- * ```tsx
- * <LiveKitRoom>
- *   <MatrixAudioRenderer />
- * </LiveKitRoom>
- * ```
- * @public
- */
-export function LivekitRoomAudioRenderer({
-  transport,
-  livekitRoom,
-  validIdentities,
-  muted,
-}: MatrixAudioRendererProps): ReactNode {
-  const logger = rootLogger.getChild("[MatrixAudioRenderer]");
-  // Identities we have already warned about, so that re-renders (which happen
-  // on every active speaker update) don't repeat the warning.
-  const warnedIdentities = useRef(new Set<string>());
-  const tracks = useTracks(
-    [
-      Track.Source.Microphone,
-      Track.Source.ScreenShareAudio,
-      Track.Source.Unknown,
-    ],
-    {
-      updateOnlyOn: [],
-      onlySubscribed: true,
-      room: livekitRoom,
-    },
-  )
-    // Only keep remote audio tracks (we never render our own audio)
-    .filter(
-      (ref) =>
-        ref.publication.kind === Track.Kind.Audio && !ref.participant.isLocal,
-    )
-    // Only keep tracks from participants that are in the validIdentities list
-    .filter((ref) => {
-      const { identity } = ref.participant;
-      const isValid = validIdentities.includes(identity);
-      if (!isValid && !warnedIdentities.current.has(identity)) {
-        warnedIdentities.current.add(identity);
-        // Log that there is an invalid identity, that means that someone is publishing audio that is not expected to be in the call.
-        logger.warn(
-          `Audio track ${identity} from ${JSON.stringify(transport)} has no matching matrix call member`,
-          `current members: ${validIdentities.join()}`,
-          `track will not get rendered`,
-        );
-      } else if (isValid) {
-        warnedIdentities.current.delete(identity);
-      }
-      return isValid;
-    });
-
-  // This component is also (in addition to the "only play audio for connected members" logic above)
-  // responsible for mimicking earpiece audio on iPhones.
-  // The Safari audio devices enumeration does not expose an earpiece audio device.
-  // We alternatively use the audioContext pan node to only use one of the stereo channels.
-
-  // This component does get additionally complicated because of a Safari bug.
-  // (see: https://bugs.webkit.org/show_bug.cgi?id=251532
-  // and the related issues: https://bugs.webkit.org/show_bug.cgi?id=237878
-  // and https://bugs.webkit.org/show_bug.cgi?id=231105)
-  //
-  // AudioContext gets stopped if the webview gets moved into the background.
-  // Once the phone is in standby audio playback will stop.
-  // So we can only use the pan trick only works is the phone is not in standby.
-  // If earpiece mode is not used we do not use audioContext to allow standby playback.
-  // shouldUseAudioContext is set to false if stereoPan === 0 to allow standby bluetooth playback.
-
-  const { pan: stereoPan, volume: volumeFactor } = useEarpieceAudioConfig();
-  const shouldUseAudioContext = stereoPan !== 0;
-
-  // initialize the potentially used audio context.
-  const [audioContext, setAudioContext] = useState<AudioContext | undefined>(
-    undefined,
-  );
-  useEffect(() => {
-    const ctx = new AudioContext();
-    setAudioContext(ctx);
-    return (): void => {
-      void ctx.close();
-    };
-  }, []);
-  const audioNodes = useMemo(
-    () => ({
-      gain: audioContext?.createGain(),
-      pan: audioContext?.createStereoPanner(),
-    }),
-    [audioContext],
-  );
-
-  // Simple effects to update the gain and pan node based on the props
-  useEffect(() => {
-    if (audioNodes.pan) audioNodes.pan.pan.value = stereoPan;
-  }, [audioNodes.pan, stereoPan]);
-  useEffect(() => {
-    if (audioNodes.gain) audioNodes.gain.gain.value = volumeFactor;
-  }, [audioNodes.gain, volumeFactor]);
-
-  return (
-    // We add all audio elements into one <div> for the browser developer tool experience/tidyness.
-    <div style={{ display: "none" }}>
-      {tracks.map((trackRef) => (
-        <AudioTrackWithAudioNodes
-          key={getTrackReferenceId(trackRef)}
-          trackRef={trackRef}
-          muted={muted}
-          audioContext={shouldUseAudioContext ? audioContext : undefined}
-          audioNodes={audioNodes}
-        />
-      ))}
-    </div>
-  );
-}
-
-interface StereoPanAudioTrackProps {
-  muted?: boolean;
-  audioContext?: AudioContext;
-  audioNodes: {
-    gain?: GainNode;
-    pan?: StereoPannerNode;
-  };
-}
-
-/**
- * This wraps `livekit.AudioTrack` to allow adding audio nodes to a track.
- * It main purpose is to remount the AudioTrack component when switching from
- * audioContext to normal audio playback.
- * As of now the AudioTrack component does not support adding audio nodes while being mounted.
- * @param props The component props
- * @param props.trackRef The track reference
- * @param props.muted If the track should be muted
- * @param props.audioContext The audio context to use
- * @param props.audioNodes The audio nodes to use
- * @returns
- */
-function AudioTrackWithAudioNodes({
-  trackRef,
-  muted,
-  audioContext,
-  audioNodes,
-  ...props
-}: StereoPanAudioTrackProps &
-  AudioTrackProps &
-  React.RefAttributes<HTMLAudioElement>): ReactNode {
-  // This is used to unmount/remount the AudioTrack component.
-  // Mounting needs to happen after the audioContext is set.
-  // (adding the audio context when already mounted did not work outside strict mode)
-  const [trackReady, setTrackReady] = useReactiveState(
-    () => false,
-    // We only want the track to reset once both (audioNodes and audioContext) are set.
-    // for unsetting the audioContext its enough if one of the two is undefined.
-    [audioContext && audioNodes],
-  );
-
-  useEffect(() => {
-    if (!trackRef || trackReady) return;
-    const track = trackRef.publication.track as RemoteAudioTrack;
-    const useContext = audioContext && audioNodes.gain && audioNodes.pan;
-    track.setAudioContext(useContext ? audioContext : undefined);
-    track.setWebAudioPlugins(
-      useContext ? [audioNodes.gain!, audioNodes.pan!] : [],
-    );
-    setTrackReady(true);
-    controls.setPlaybackStarted();
-  }, [audioContext, audioNodes, setTrackReady, trackReady, trackRef]);
-
-  return (
-    trackReady && <AudioTrack trackRef={trackRef} muted={muted} {...props} />
-  );
-}

src/livekit/auth/csApi.ts

@@ -1,137 +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 { ConnectionError, HTTPError, type MatrixClient } from "matrix-js-sdk";
-import { type CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
-
-import { extractFullConfigFromToken, type SFUConfig } from "./types.ts";
-import { doNetworkOperationWithRetry } from "../../utils/matrix.ts";
-
-/**
- * In widget mode the host may refuse an action before any request is made
- * which surfaces as a plain error. Asking again cannot change its answer,
- * so only errors from the network are worth retrying.
- */
-function isNetworkError(e: unknown): boolean {
-  return e instanceof HTTPError || e instanceof ConnectionError;
-}
-
-export type ClientGetTokenParts = Pick<
-  MatrixClient,
-  "_unstable_getLivekitToken"
->;
-
-export interface GetSFUConfigParams {
-  /**
-   * The Matrix client.
-   */
-  client: ClientGetTokenParts;
-  /**
-   * Data identifying the local user's session membership.
-   */
-  membership: CallMembershipIdentityParts;
-  /**
-   * The WebSocket URL of the SFU for which we wish to get an access token.
-   */
-  url: string;
-  /**
-   * The name of the homeserver to which the SFU belongs.
-   */
-  serverName: string;
-  /**
-   * The ID of the Matrix room in which the session takes place.
-   */
-  roomId: string;
-  /**
-   * The ID of the MatrixRTC slot in which the session takes place.
-   */
-  slotId: string;
-}
-
-/**
- * Gets an {@link SFUConfig} appropriate for connecting to a given SFU, using
- * the MSC4195 LiveKit client-server API endpoints.
- */
-export async function getSFUConfig({
-  client,
-  membership,
-  url,
-  serverName,
-  roomId,
-  slotId,
-}: GetSFUConfigParams): Promise<SFUConfig> {
-  const res = await doNetworkOperationWithRetry(
-    async () =>
-      client._unstable_getLivekitToken({
-        url,
-        server_name: serverName,
-        room_id: roomId,
-        slot_id: slotId,
-        member_id: membership.memberId,
-      }),
-    isNetworkError,
-  );
-  return extractFullConfigFromToken({ url, jwt: res.jwt });
-}
-
-export type ClientDelegationParts = Pick<
-  MatrixClient,
-  "_unstable_delegateDelayedLeave" | "baseUrl"
->;
-
-export interface DelegateDelayedLeaveParams {
-  /**
-   * The Matrix client.
-   */
-  client: ClientDelegationParts;
-  /**
-   * Data identifying the local user's session membership.
-   */
-  membership: CallMembershipIdentityParts;
-  /**
-   * The WebSocket URL of the SFU to which we are publishing and wish to
-   * delegate the delayed leave event.
-   */
-  url: string;
-  /**
-   * The ID of the Matrix room in which the session takes place.
-   */
-  roomId: string;
-  /**
-   * The ID of the MatrixRTC slot in which the session takes place.
-   */
-  slotId: string;
-  /**
-   * The delay ID of the leave event to be delegated.
-   */
-  delayId: string;
-}
-
-/**
- * Delegates a delayed leave event to a given SFU, so that the event will
- * be sent on our behalf whenever we disconnect from the SFU.
- */
-export async function delegateDelayedLeave({
-  client,
-  membership,
-  url,
-  roomId,
-  slotId,
-  delayId,
-}: DelegateDelayedLeaveParams): Promise<void> {
-  await doNetworkOperationWithRetry(
-    async () =>
-      client._unstable_delegateDelayedLeave({
-        url,
-        room_id: roomId,
-        slot_id: slotId,
-        member_id: membership.memberId,
-        delay_id: delayId,
-      }),
-    isNetworkError,
-  );
-}

src/livekit/auth/index.test.ts

@@ -1,306 +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, expect, type Mocked, vi, describe, it } from "vitest";
-import { type UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
-import { logger } from "matrix-js-sdk/lib/logger";
-
-import {
-  aliceDeviceId,
-  aliceId,
-  aliceUserId,
-  createJWTToken,
-} from "../../utils/test-fixtures";
-import type * as csApi from "./csApi";
-import * as openID from "./openID";
-import { delegateDelayedLeave, getSFUConfig } from ".";
-import { mocked } from "storybook/test";
-import { ConnectionError, MatrixError } from "matrix-js-sdk";
-import { NoMatrix2AuthorizationService } from "../../utils/errors";
-import { type CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
-
-vi.mock("./openID", () => ({ getSFUConfig: vi.fn() }));
-vi.useFakeTimers();
-
-const csApiJWTToken = createJWTToken(aliceId, "via CS API");
-const openIDJWTToken = createJWTToken(aliceId, "via OpenID");
-
-mocked(openID).getSFUConfig.mockResolvedValue({
-  url: "mock-openID-url",
-  jwt: openIDJWTToken,
-  livekitAlias: "via OpenID",
-  livekitIdentity: aliceId,
-});
-
-const client: Mocked<
-  csApi.ClientGetTokenParts &
-    csApi.ClientDelegationParts &
-    openID.ClientOpenIDParts
-> = {
-  baseUrl: "https://matrix.example.org",
-  _unstable_getLivekitToken: vi.fn().mockResolvedValue({ jwt: csApiJWTToken }),
-  _unstable_delegateDelayedLeave: vi.fn().mockResolvedValue({}),
-  getOpenIdToken: vi
-    .fn()
-    .mockResolvedValue({ access_token: "mock-openID-token" }),
-};
-
-const membership: CallMembershipIdentityParts = {
-  userId: aliceUserId,
-  deviceId: aliceDeviceId,
-  memberId: "123",
-};
-
-const roomId = "!room:example.org";
-const slotId = "m.call#ROOM";
-
-const unsupportedError = new MatrixError({ errcode: "M_UNSUPPORTED" }, 404);
-
-const urlTransport: UnstableLivekitTransport = {
-  type: "livekit",
-  url: "wss://livekit.example.org",
-};
-
-const serviceUrlTransport: UnstableLivekitTransport = {
-  type: "livekit",
-  livekit_service_url: "https://livekit-jwt.example.org",
-};
-
-const urlAndServiceUrlTransport: UnstableLivekitTransport = {
-  ...urlTransport,
-  ...serviceUrlTransport,
-};
-
-afterEach(() => vi.clearAllMocks());
-
-describe("getSFUConfig", () => {
-  const defaultParams = {
-    client,
-    membership,
-    serverName: "example.org",
-    role: "subscriber" as const,
-    roomId,
-    slotId,
-    logger,
-  };
-
-  it("uses CS API with url transport", async () => {
-    expect(
-      await getSFUConfig({ ...defaultParams, transport: urlTransport }),
-    ).toEqual(
-      expect.objectContaining({
-        jwt: csApiJWTToken,
-        livekitAlias: "via CS API",
-      }),
-    );
-    expect(client._unstable_getLivekitToken).toHaveBeenCalled();
-    expect(openID.getSFUConfig).not.toHaveBeenCalled();
-  });
-
-  it("does not fall back to OpenID with url transport", async () => {
-    client._unstable_getLivekitToken.mockRejectedValueOnce(unsupportedError);
-    await expect(
-      getSFUConfig({ ...defaultParams, transport: urlTransport }),
-    ).rejects.toThrow(expect.any(NoMatrix2AuthorizationService));
-    expect(client._unstable_getLivekitToken).toHaveBeenCalled();
-    expect(openID.getSFUConfig).not.toHaveBeenCalled();
-  });
-
-  it("uses OpenID with livekit_service_url transport", async () => {
-    expect(
-      await getSFUConfig({ ...defaultParams, transport: serviceUrlTransport }),
-    ).toEqual(
-      expect.objectContaining({
-        jwt: openIDJWTToken,
-        livekitAlias: "via OpenID",
-      }),
-    );
-    expect(client._unstable_getLivekitToken).not.toHaveBeenCalled();
-    expect(openID.getSFUConfig).toHaveBeenCalled();
-  });
-
-  it("uses CS API with url + livekit_service_url transport", async () => {
-    expect(
-      await getSFUConfig({
-        ...defaultParams,
-        transport: urlAndServiceUrlTransport,
-      }),
-    ).toEqual(
-      expect.objectContaining({
-        jwt: csApiJWTToken,
-        livekitAlias: "via CS API",
-      }),
-    );
-    expect(client._unstable_getLivekitToken).toHaveBeenCalled();
-    expect(openID.getSFUConfig).not.toHaveBeenCalled();
-  });
-
-  it("falls back to OpenID with url + livekit_service_url transport", async () => {
-    client._unstable_getLivekitToken.mockRejectedValueOnce(unsupportedError);
-    expect(
-      await getSFUConfig({
-        ...defaultParams,
-        transport: urlAndServiceUrlTransport,
-      }),
-    ).toEqual(
-      expect.objectContaining({
-        jwt: openIDJWTToken,
-        livekitAlias: "via OpenID",
-      }),
-    );
-    expect(client._unstable_getLivekitToken).toHaveBeenCalled();
-    expect(openID.getSFUConfig).toHaveBeenCalled();
-  });
-
-  it("falls back to OpenID when the widget host refuses the CS API", async () => {
-    // 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: openIDJWTToken }));
-    expect(openID.getSFUConfig).toHaveBeenCalled();
-  });
-
-  it("surfaces the widget host's refusal with url transport", async () => {
-    const error = new Error(
-      "The rtc_livekit_get_token action is not supported by the client.",
-    );
-    client._unstable_getLivekitToken.mockRejectedValueOnce(error);
-    await expect(
-      getSFUConfig({ ...defaultParams, transport: urlTransport }),
-    ).rejects.toThrow(error);
-    expect(openID.getSFUConfig).not.toHaveBeenCalled();
-  });
-
-  it("uses CS API when publishing with url transport", async () => {
-    expect(
-      await getSFUConfig({
-        ...defaultParams,
-        transport: urlTransport,
-        role: "publisher",
-      }),
-    ).toEqual(expect.objectContaining({ jwt: csApiJWTToken }));
-    expect(client._unstable_getLivekitToken).toHaveBeenCalled();
-    expect(openID.getSFUConfig).not.toHaveBeenCalled();
-  });
-
-  it("does not fall back to OpenID when publishing", async () => {
-    client._unstable_getLivekitToken.mockRejectedValueOnce(unsupportedError);
-    await expect(
-      getSFUConfig({
-        ...defaultParams,
-        transport: urlTransport,
-        role: "publisher",
-      }),
-    ).rejects.toThrow(expect.any(NoMatrix2AuthorizationService));
-    expect(client._unstable_getLivekitToken).toHaveBeenCalled();
-    expect(openID.getSFUConfig).not.toHaveBeenCalled();
-  });
-
-  it("uses OpenID when publishing with url + livekit_service_url transport", async () => {
-    // Subscribers predating MSC4195 expect a legacy participant identity from
-    // anyone advertising a state event, which only the JWT service assigns
-    expect(
-      await getSFUConfig({
-        ...defaultParams,
-        transport: urlAndServiceUrlTransport,
-        role: "publisher",
-      }),
-    ).toEqual(
-      expect.objectContaining({
-        jwt: openIDJWTToken,
-        livekitAlias: "via OpenID",
-      }),
-    );
-    expect(client._unstable_getLivekitToken).not.toHaveBeenCalled();
-    expect(openID.getSFUConfig).toHaveBeenCalledWith(
-      expect.objectContaining({ role: "publisher" }),
-    );
-  });
-
-  it("does not fall back to OpenID on connection error", async () => {
-    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(openID.getSFUConfig).not.toHaveBeenCalled();
-  });
-});
-
-describe("delegateDelayedLeave", () => {
-  const defaultParams = {
-    client,
-    membership,
-    roomId,
-    slotId,
-    delayId: "delay123",
-    logger,
-  };
-
-  it("uses CS API with url transport", async () => {
-    await delegateDelayedLeave({ ...defaultParams, transport: urlTransport });
-    expect(client._unstable_delegateDelayedLeave).toHaveBeenCalled();
-    expect(openID.getSFUConfig).not.toHaveBeenCalled();
-  });
-
-  it("does not fall back to OpenID with url transport", async () => {
-    client._unstable_delegateDelayedLeave.mockRejectedValueOnce(
-      unsupportedError,
-    );
-    await expect(
-      delegateDelayedLeave({ ...defaultParams, transport: urlTransport }),
-    ).rejects.toThrow();
-    expect(client._unstable_delegateDelayedLeave).toHaveBeenCalled();
-    expect(openID.getSFUConfig).not.toHaveBeenCalled();
-  });
-
-  it("uses OpenID with livekit_service_url transport", async () => {
-    await delegateDelayedLeave({
-      ...defaultParams,
-      transport: serviceUrlTransport,
-    });
-    expect(client._unstable_delegateDelayedLeave).not.toHaveBeenCalled();
-    expect(openID.getSFUConfig).toHaveBeenCalled();
-  });
-
-  it("uses OpenID with url + livekit_service_url transport", async () => {
-    // Must match the flow that got the token, so the identities line up
-    await delegateDelayedLeave({
-      ...defaultParams,
-      transport: urlAndServiceUrlTransport,
-    });
-    expect(client._unstable_delegateDelayedLeave).not.toHaveBeenCalled();
-    expect(openID.getSFUConfig).toHaveBeenCalledWith(
-      expect.objectContaining({
-        role: "publisher",
-        delayId: "delay123",
-        delayEndpointBaseUrl: client.baseUrl,
-      }),
-    );
-  });
-});

src/livekit/auth/index.ts

@@ -1,253 +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 CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
-import { type Logger } from "matrix-js-sdk/lib/logger";
-
-import { ConnectionError, MatrixError } from "matrix-js-sdk";
-import { type UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
-import * as openID from "./openID";
-import * as csApi from "./csApi";
-import { type SFUConfig } from "./types";
-import { NoMatrix2AuthorizationService } from "../../utils/errors";
-
-export type { ClientOpenIDParts } from "./openID";
-export type { ClientGetTokenParts, ClientDelegationParts } from "./csApi";
-export type * from "./types";
-
-/**
- * Checks whether an error means "this homeserver does not implement the
- * (unstable) MSC4195 endpoints".
- *
- * MSC4195 documents `M_NOT_FOUND` for this, but a homeserver without support
- * answers with whatever it uses for unknown endpoints (Synapse: 404 with
- * `M_UNRECOGNIZED`), so we accept any 404 as "unsupported".
- * @param e The error to check.
- */
-function isEndpointUnsupported(e: unknown): boolean {
-  return (
-    e instanceof MatrixError &&
-    (e.httpStatus === 404 ||
-      e.errcode === "M_NOT_FOUND" ||
-      e.errcode === "M_UNRECOGNIZED")
-  );
-}
-
-/**
- * Checks whether an error means the MSC4195 CS API cannot be used from here:
- * the homeserver does not implement it, or the request never reached the
- * homeserver because in widget mode the host does not expose the endpoint
- * (MSC4533), which the widget API reports as a plain error rather than a
- * Matrix error. A connection error is neither, as the endpoint may well exist.
- * @param e The error to check.
- */
-function isCsApiUnavailable(e: unknown): boolean {
-  if (isEndpointUnsupported(e)) return true;
-  return !(e instanceof MatrixError) && !(e instanceof ConnectionError);
-}
-
-export interface GetSFUConfigParams {
-  /**
-   * The Matrix client.
-   */
-  client: csApi.ClientGetTokenParts & openID.ClientOpenIDParts;
-  /**
-   * Data identifying the local user's session membership.
-   */
-  membership: CallMembershipIdentityParts;
-  /**
-   * The transport for which we wish to get an access token.
-   */
-  transport: UnstableLivekitTransport;
-  /**
-   * The name of the homeserver to which the {@link transport} belongs.
-   */
-  serverName: string;
-  /**
-   * The ID of the Matrix room in which the session takes place.
-   */
-  roomId: string;
-  /**
-   * The ID of the MatrixRTC slot in which the session takes place.
-   */
-  slotId: string;
-  /**
-   * Whether we want to publish or only subscribe on the {@link transport}.
-   */
-  role: "publisher" | "subscriber";
-  logger: Logger;
-}
-
-/**
- * Gets an {@link SFUConfig} appropriate for connecting to a given transport.
- */
-export async function getSFUConfig({
-  client,
-  membership,
-  transport,
-  serverName,
-  roomId,
-  slotId,
-  role,
-  logger,
-}: GetSFUConfigParams): Promise<SFUConfig> {
-  const viaOpenID = async (serviceUrl: string): Promise<SFUConfig> =>
-    await openID.getSFUConfig({
-      client,
-      membership,
-      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) {
-    // Publishers should never fall back. If a homeserver advertises a `url`
-    // but doesn't support MSC4195 itself, that's a misconfiguration which
-    // the admin should know about so they can prepare for the future
-    // deprecation of `livekit_service_url`.
-    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);
-    }
-    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;
-  }
-}
-
-export interface DelegateDelayedLeaveParams {
-  /**
-   * The Matrix client.
-   */
-  client: csApi.ClientDelegationParts & openID.ClientOpenIDParts;
-  /**
-   * Data identifying the local user's session membership.
-   */
-  membership: CallMembershipIdentityParts;
-  /**
-   * The transport to which we are publishing and wish to delegate the delayed
-   * leave event.
-   */
-  transport: UnstableLivekitTransport;
-  /**
-   * The ID of the Matrix room in which the session takes place.
-   */
-  roomId: string;
-  /**
-   * The ID of the MatrixRTC slot in which the session takes place.
-   */
-  slotId: string;
-  /**
-   * The delay ID of the leave event to be delegated.
-   */
-  delayId: string;
-  logger: Logger;
-}
-
-/**
- * Delegates a delayed leave event to a given transport, so that the event will
- * be sent on our behalf whenever we disconnect from the transport's SFU.
- */
-export async function delegateDelayedLeave({
-  client,
-  membership,
-  transport,
-  roomId,
-  slotId,
-  delayId,
-  logger,
-}: DelegateDelayedLeaveParams): Promise<void> {
-  // It's important that we use the same flow (CS API or OpenID) as whatever we
-  // would've used to get a JWT token for this transport, since the participant
-  // identity computed by the service needs to match.
-  const flow = chooseAuthFlow(transport, "publisher");
-  if (flow.kind === "csApi") {
-    try {
-      await csApi.delegateDelayedLeave({
-        client,
-        membership,
-        url: flow.url,
-        roomId,
-        slotId,
-        delayId,
-      });
-    } catch (e) {
-      if (isEndpointUnsupported(e))
-        logger.error(
-          "Server misconfigured: transport contains a 'url' field but server does not support the MSC4195 delegate_delayed_leave endpoint",
-        );
-      throw e;
-    }
-  } else {
-    // This will technically cause the service to issue a new JWT token, but
-    // it's safe to discard. We're only interested in triggering delegation.
-    await openID.getSFUConfig({
-      client,
-      membership,
-      serviceUrl: flow.serviceUrl,
-      roomId,
-      slotId,
-      role: "publisher",
-      delayEndpointBaseUrl: client.baseUrl,
-      delayId,
-      logger,
-    });
-  }
-}
-
-/**
- * The flow with which the local member authenticates against a transport.
- */
-export type AuthFlow =
-  | { kind: "csApi"; url: string }
-  | { kind: "openID"; serviceUrl: string };
-
-/**
- * Chooses between the MSC4195 CS API and the legacy 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 state event. So a publisher keeps using the JWT service wherever
- * the transport still offers one, even if it also has a `url`. Subscribers may
- * use the CS API regardless, as nobody matches their identity.
- * @param transport The transport to authenticate against.
- * @param role Whether we want to publish or only subscribe on the transport.
- */
-export function chooseAuthFlow(
-  transport: UnstableLivekitTransport,
-  role: "publisher" | "subscriber",
-): AuthFlow {
-  if ("url" in transport) {
-    const useCsApi =
-      !("livekit_service_url" in transport) || role === "subscriber";
-    if (useCsApi) return { kind: "csApi", url: transport.url };
-  }
-  return { kind: "openID", serviceUrl: transport.livekit_service_url };
-}

src/livekit/auth/openID.test.ts

@@ -1,230 +0,0 @@
-/*
-Copyright 2025 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,
-  afterEach,
-  describe,
-  expect,
-  it,
-  type MockedObject,
-  vitest,
-} from "vitest";
-import fetchMock from "fetch-mock";
-import { MatrixError } from "matrix-js-sdk";
-
-import {
-  getSFUConfig,
-  type GetSFUConfigParams,
-  type ClientOpenIDParts,
-} from "./openID";
-import { testJWTToken } from "../../utils/test-fixtures";
-import { ownMemberMock } from "../../utils/test";
-import { FailToGetOpenIdToken } from "../../utils/errors";
-import { logger } from "matrix-js-sdk/lib/logger";
-
-const serviceUrl = "https://sfu.example.org";
-
-const delayParams = {
-  delayEndpointBaseUrl: "https://matrix.homeserverserver.org",
-  delayId: "mock_delay_id",
-};
-
-describe("getSFUConfig", () => {
-  let matrixClient: MockedObject<ClientOpenIDParts>;
-  let params: GetSFUConfigParams;
-  beforeEach(() => {
-    fetchMock.catch(404);
-    matrixClient = { getOpenIdToken: vitest.fn() };
-    params = {
-      client: matrixClient,
-      membership: ownMemberMock,
-      serviceUrl: "https://sfu.example.org",
-      roomId: "!example_room_id",
-      slotId: "m.call#ROOM",
-      role: "publisher",
-      logger,
-    };
-  });
-  afterEach(async () => {
-    void (await fetchMock.flush());
-    vitest.clearAllMocks();
-    fetchMock.reset();
-  });
-
-  it("should handle fetching a token", async () => {
-    fetchMock.post("https://sfu.example.org/sfu/get", () => {
-      return {
-        status: 200,
-        body: { url: serviceUrl, jwt: testJWTToken },
-      };
-    });
-    const config = await getSFUConfig(params);
-    expect(config).toEqual({
-      jwt: testJWTToken,
-      url: serviceUrl,
-      livekitIdentity: "@me:example.org:ABCDEF",
-      livekitAlias: "!example_room_id",
-    });
-  });
-
-  it("should fail if the SFU errors", async () => {
-    fetchMock.post("https://sfu.example.org/sfu/get", () => {
-      return {
-        status: 500,
-        body: {
-          errcode: "M_LOOKUP_FAILED",
-          error: "Failed to look up user info from homeserver",
-        },
-      };
-    });
-    try {
-      await getSFUConfig(params);
-    } catch (ex: unknown) {
-      expect(ex).toBeInstanceOf(FailToGetOpenIdToken);
-      expect((ex as FailToGetOpenIdToken).cause).toBeInstanceOf(MatrixError);
-      const mxError = (ex as Error).cause as MatrixError;
-      expect(mxError.message).toEqual(
-        "MatrixError: [500] Failed to look up user info from homeserver",
-      );
-
-      return;
-    }
-    expect.fail("Expected test to throw;");
-  });
-
-  it("should retry without delay params if the JWT service legacy endpoint returns M_BAD_JSON 400", async () => {
-    let callCount = 0;
-
-    fetchMock.post(
-      "https://sfu.example.org/sfu/get",
-      (url, opts) => {
-        callCount++;
-        const body = JSON.parse(opts.body as string);
-
-        // First call: check if it has delay parts and return 400
-        if (callCount === 1) {
-          expect(body).toHaveProperty("delay_id", "mock_delay_id");
-          return {
-            status: 400,
-            body: { errcode: "M_BAD_JSON", error: "Unsupported parameters" },
-          };
-        }
-
-        // Second call: check if delay parts were stripped and return success
-        expect(body).not.toHaveProperty("delay_id");
-        expect(body).not.toHaveProperty("delay_timeout");
-        expect(body).not.toHaveProperty("delay_cs_api_url");
-
-        return {
-          status: 200,
-          body: { url: serviceUrl, jwt: testJWTToken },
-        };
-      },
-      { overwriteRoutes: true },
-    );
-
-    // Note: Assuming getSFUConfig eventually calls getLiveKitJWT
-    const config = await getSFUConfig({ ...params, ...delayParams });
-
-    expect(config.jwt).toBe(testJWTToken);
-    expect(callCount).toBe(2);
-  });
-
-  it("should successfully send delay parameters to the JWT service legacy endpoint", async () => {
-    fetchMock.post(
-      "https://sfu.example.org/sfu/get",
-      (url, opts) => {
-        const body = JSON.parse(opts.body as string);
-
-        // Verify, that the request contains the expected delay parameters
-        if (
-          body.delay_id === "mock_delay_id" &&
-          body.delay_timeout === 3600000 &&
-          body.delay_cs_api_url === "https://matrix.homeserverserver.org"
-        ) {
-          return {
-            status: 200,
-            body: { url: serviceUrl, jwt: testJWTToken },
-          };
-        }
-        return {
-          status: 400,
-          body: { error: "Missing expected delay params" },
-        };
-      },
-      { overwriteRoutes: true },
-    );
-
-    const config = await getSFUConfig({ ...params, ...delayParams });
-
-    // Prüfe das Ergebnis
-    expect(config).toMatchObject({
-      jwt: testJWTToken,
-      url: serviceUrl,
-    });
-  });
-
-  it("should use the default endpoint when subscribing", async () => {
-    fetchMock.post("https://sfu.example.org/get_token", (url, opts) => {
-      const body = JSON.parse(opts.body as string);
-      expect(body).toMatchObject({
-        room_id: "!example_room_id",
-        slot_id: "m.call#ROOM",
-        member: {
-          id: ownMemberMock.memberId,
-          claimed_user_id: ownMemberMock.userId,
-          claimed_device_id: ownMemberMock.deviceId,
-        },
-      });
-      return { status: 200, body: { url: serviceUrl, jwt: testJWTToken } };
-    });
-    const config = await getSFUConfig({ ...params, role: "subscriber" });
-    expect(config.jwt).toBe(testJWTToken);
-    expect(fetchMock.called("https://sfu.example.org/sfu/get")).toBe(false);
-  });
-
-  it("should fail when subscribing if the default endpoint is missing", async () => {
-    // Nothing but the catch-all 404 answers the default endpoint. Subscribers
-    // must not fall back to the legacy endpoint, which would hand them a
-    // legacy identity.
-    await expect(
-      getSFUConfig({ ...params, role: "subscriber" }),
-    ).rejects.toThrow(FailToGetOpenIdToken);
-    expect(fetchMock.called("https://sfu.example.org/get_token")).toBe(true);
-    expect(fetchMock.called("https://sfu.example.org/sfu/get")).toBe(false);
-  });
-
-  it("should retry fetching the openid token", async () => {
-    let count = 0;
-    matrixClient.getOpenIdToken.mockImplementation(async () => {
-      count++;
-      if (count < 2) {
-        throw Error("Test failure");
-      }
-      return Promise.resolve({
-        token_type: "Bearer",
-        access_token: "foobar",
-        matrix_server_name: "example.org",
-        expires_in: 30,
-      });
-    });
-    fetchMock.post("https://sfu.example.org/sfu/get", () => {
-      return {
-        status: 200,
-        body: { url: serviceUrl, jwt: testJWTToken },
-      };
-    });
-    const config = await getSFUConfig({ ...params, ...delayParams });
-    expect(config).toEqual({
-      jwt: testJWTToken,
-      url: serviceUrl,
-      livekitIdentity: "@me:example.org:ABCDEF",
-      livekitAlias: "!example_room_id",
-    });
-  });
-});

src/livekit/auth/openID.ts

@@ -1,262 +0,0 @@
-/*
-Copyright 2023, 2024 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import {
-  type IOpenIDToken,
-  type MatrixClient,
-  parseErrorResponse,
-} from "matrix-js-sdk";
-import { type CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
-import { type Logger } from "matrix-js-sdk/lib/logger";
-
-import { FailToGetOpenIdToken } from "../../utils/errors";
-import { doNetworkOperationWithRetry } from "../../utils/matrix";
-import { Config } from "../../config/Config";
-import { extractFullConfigFromToken, type SFUConfig } from "./types";
-
-// The bits we need from MatrixClient
-export type ClientOpenIDParts = Pick<MatrixClient, "getOpenIdToken">;
-
-export interface GetSFUConfigParams {
-  client: ClientOpenIDParts;
-  /**
-   * Data identifying the local user's session membership.
-   */
-  membership: CallMembershipIdentityParts;
-  /**
-   * The base URL of the LiveKit JWT service.
-   */
-  serviceUrl: string;
-  /**
-   * The ID of the Matrix room in which the session takes place.
-   */
-  roomId: string;
-  /**
-   * The ID of the MatrixRTC slot in which the session takes place.
-   */
-  slotId: string;
-  /**
-   * Whether we want to publish or only subscribe on the {@link transport}.
-   */
-  role: "publisher" | "subscriber";
-  /**
-   * The base URL of the Matrix homeserver, for delayed leave delegation.
-   */
-  delayEndpointBaseUrl?: string;
-  /**
-   * The delay ID of the leave event to be delegated to the JWT service.
-   */
-  delayId?: string;
-  logger: Logger;
-}
-
-/**
- * Gets an {@link SFUConfig} appropriate for connecting to the SFU behind a
- * given service URL, using the legacy OpenID flow.
- * @throws {@link FailToGetOpenIdToken}
- */
-export async function getSFUConfig({
-  client,
-  membership,
-  serviceUrl,
-  roomId,
-  slotId,
-  role,
-  delayEndpointBaseUrl,
-  delayId,
-  logger,
-}: GetSFUConfigParams): Promise<SFUConfig> {
-  let openIdToken: IOpenIDToken;
-  try {
-    openIdToken = await doNetworkOperationWithRetry(async () =>
-      client.getOpenIdToken(),
-    );
-  } catch (error) {
-    throw new FailToGetOpenIdToken(
-      error instanceof Error ? error : new Error("Unknown error"),
-    );
-  }
-  logger.debug("Got openID token", openIdToken);
-  let sfuConfig: { url: string; jwt: string } | undefined;
-
-  let endpoint: "default" | "legacy";
-  if (role === "publisher") {
-    // When publishing a legacy transport (one with a `livekit_service_url`),
-    // subscribers will expect our participant identity to use the legacy
-    // `@user_id:device_id` format. Only the legacy JWT service endpoint assigns
-    // identities in this format, so we must use it.
-    endpoint = "legacy";
-  } else {
-    // Use the default endpoint as it affords us slightly better metadata
-    // protection (pseudonymous participant identities).
-    endpoint = "default";
-  }
-
-  try {
-    logger.info(
-      `Trying to get JWT with ${endpoint} endpoint for focus ${serviceUrl}...`,
-    );
-    sfuConfig = await (
-      endpoint === "legacy" ? getLiveKitJWTLegacy : getLiveKitJWT
-    )(
-      membership,
-      serviceUrl,
-      roomId,
-      slotId,
-      openIdToken,
-      delayEndpointBaseUrl,
-      delayId,
-    );
-    logger.info(`Got JWT from call's active focus URL.`);
-    return extractFullConfigFromToken(sfuConfig);
-  } catch (e) {
-    logger.error(`Failed fetching jwt with ${endpoint} endpoint:`, e);
-    throw new FailToGetOpenIdToken(
-      e instanceof Error ? e : new Error(`Unknown error ${e}`),
-    );
-  }
-}
-
-/**
- * Gets a JWT token appropriate for connecting to the SFU behind a given service
- * URL, using the legacy `/sfu/get` endpoint, which assigns us a legacy
- * (`<user_id>:<device_id>`) participant identity.
- */
-async function getLiveKitJWTLegacy(
-  membership: CallMembershipIdentityParts,
-  livekitServiceURL: string,
-  matrixRoomId: string,
-  _slotId: string, // Unused - the legacy endpoint is from before slots existed.
-  openIDToken: IOpenIDToken,
-  delayEndpointBaseUrl?: string,
-  delayId?: string,
-): Promise<{ url: string; jwt: string }> {
-  interface IDelayParams {
-    delay_id?: string;
-    delay_timeout?: number;
-    delay_cs_api_url?: string;
-  }
-  let bodyDalayParts: IDelayParams = {};
-  // Also check for empty string
-  if (delayId && delayEndpointBaseUrl) {
-    bodyDalayParts = {
-      delay_id: delayId,
-      delay_timeout:
-        Config.get().matrix_rtc_session.delegated_delayed_leave.delay_ms,
-      delay_cs_api_url: delayEndpointBaseUrl,
-    };
-  }
-
-  const makeRequest = async (delayParts: IDelayParams): Promise<Response> => {
-    return await fetch(livekitServiceURL + "/sfu/get", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        // The legacy JWT endpoint uses only the matrix room id to calculate the livekit room alias.
-        // However, the livekit room alias is provided as part of the JWT payload.
-        room: matrixRoomId,
-        openid_token: openIDToken,
-        device_id: membership.deviceId,
-        ...delayParts,
-      }),
-    });
-  };
-
-  const res = await doNetworkOperationWithRetry(async () => {
-    let response = await makeRequest(bodyDalayParts);
-
-    // Old service compatibility check
-    const oldServiceDoesNotSupportDelayParts =
-      response.status === 400 && Object.keys(bodyDalayParts).length > 0;
-    // If http status 400 with M_BAD_JSON and we sent delay parts, retry without them
-    if (oldServiceDoesNotSupportDelayParts) {
-      try {
-        const errorBody = await response.json();
-        if (errorBody.errcode === "M_BAD_JSON") {
-          response = await makeRequest({});
-        }
-      } catch {
-        // If we can't parse the error, treat as real error
-      }
-    }
-
-    return response;
-  });
-
-  if (!res.ok) {
-    throw parseErrorResponse(res, await res.text());
-  }
-  return await res.json();
-}
-
-class NotSupportedError extends Error {
-  public constructor(message: string) {
-    super(message);
-    this.name = "NotSupported";
-  }
-}
-
-/**
- * Gets a JWT token appropriate for connecting to the SFU behind a given service
- * URL, using the default `/get_token` endpoint, which assigns us a hashed
- * (pseudonymised) participant identity.
- */
-async function getLiveKitJWT(
-  membership: CallMembershipIdentityParts,
-  livekitServiceURL: string,
-  matrixRoomId: string,
-  slotId: string,
-  openIDToken: IOpenIDToken,
-  delayEndpointBaseUrl?: string,
-  delayId?: string,
-): Promise<{ url: string; jwt: string }> {
-  const { userId, deviceId, memberId } = membership;
-
-  const body = {
-    room_id: matrixRoomId,
-    slot_id: slotId,
-    openid_token: openIDToken,
-    member: {
-      id: memberId,
-      claimed_user_id: userId,
-      claimed_device_id: deviceId,
-    },
-  };
-
-  let bodyDalayParts = {};
-  // Also check for empty string
-  if (delayId && delayEndpointBaseUrl) {
-    bodyDalayParts = {
-      delay_id: delayId,
-      delay_timeout:
-        Config.get().matrix_rtc_session.delegated_delayed_leave.delay_ms,
-      delay_cs_api_url: delayEndpointBaseUrl,
-    };
-  }
-
-  const res = await doNetworkOperationWithRetry(async () => {
-    return await fetch(livekitServiceURL + "/get_token", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ ...body, ...bodyDalayParts }),
-    });
-  });
-
-  if (!res.ok) {
-    const msg = "SFU Config fetch failed with status code " + res.status;
-    if (res.status === 404) {
-      throw new NotSupportedError(msg);
-    } else {
-      throw parseErrorResponse(res, await res.text());
-    }
-  }
-  return await res.json();
-}

src/livekit/auth/types.ts

@@ -1,90 +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 UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
-
-/**
- * Data identifying a transport and the homeserver to which it belongs, so
- * consumers know how to reach it.
- */
-export interface TransportLocator {
-  transport: UnstableLivekitTransport;
-  serverName: string;
-}
-
-/**
- * Configuration and access tokens provided by the SFU on successful authentication.
- */
-export interface SFUConfig {
-  /**
-   * The WebSocket URL of the LiveKit SFU. This is what we connect the LiveKit
-   * room to. Note that this is NOT the JWT service URL
-   * (`livekit_service_url`): the legacy JWT service returns this URL as part of
-   * its response, while the CS-Api based flow requires us to know it upfront.
-   */
-  url: string;
-  jwt: string;
-  livekitAlias: string;
-  // NOTE: Currently unused.
-  livekitIdentity: string;
-}
-
-/**
- * Decoded details from the JWT.
- */
-interface SFUJWTPayload {
-  /**
-   * Expiration time for the JWT.
-   * Note: This value is in seconds since Unix epoch.
-   */
-  exp: number;
-  /**
-   * Name of the instance which authored the JWT
-   */
-  iss: string;
-  /**
-   * Time at which the JWT can start to be used.
-   * Note: This value is in seconds since Unix epoch.
-   */
-  nbf: number;
-  /**
-   * Subject. The Livekit alias in this context.
-   */
-  sub: string;
-  /**
-   * The set of permissions for the user.
-   */
-  video: {
-    canPublish: boolean;
-    canSubscribe: boolean;
-    room: string;
-    roomJoin: boolean;
-  };
-}
-
-/**
- * Complements the SFU websocket url and the JWT with the information encoded in
- * the JWT payload itself.
- * @param sfuConfig The SFU websocket url and the JWT to connect with.
- * @returns The full SFU config, including the LiveKit alias and identity.
- */
-export function extractFullConfigFromToken(sfuConfig: {
-  url: string;
-  jwt: string;
-}): SFUConfig {
-  const [, payloadStr] = sfuConfig.jwt.split(".");
-  const payload = JSON.parse(global.atob(payloadStr)) as SFUJWTPayload;
-  return {
-    jwt: sfuConfig.jwt,
-    url: sfuConfig.url,
-    livekitAlias: payload.video.room,
-    // NOTE: Currently unused.
-    // Probably also not helpful since we now compute the backendIdentity on joining the call so we can use it for the encryption manager.
-    // The only reason for us to know it locally is to connect the right users with the lk world. (and to set our own keys)
-    livekitIdentity: payload.sub,
-  };
-}

src/livekit/options.test.ts

@@ -1,213 +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 { describe, expect, it, vi } from "vitest";
-import { VideoPresets, type VideoPreset } from "livekit-client";
-
-import { buildLiveKitOptions, getLiveKitOptions } from "./options";
-import { Config } from "../config/Config";
-
-vi.mock("../config/Config", () => ({
-  Config: {
-    get: vi.fn(),
-  },
-}));
-
-describe("buildLiveKitOptions", () => {
-  it("returns sensible defaults with no config", () => {
-    const opts = buildLiveKitOptions();
-    expect(opts.adaptiveStream).toBe(true);
-    expect(opts.dynacast).toBe(true);
-    expect(opts.videoCaptureDefaults?.resolution).toEqual(
-      VideoPresets.h720.resolution,
-    );
-    expect(opts.publishDefaults?.videoCodec).toBe("vp8");
-    expect(opts.publishDefaults?.videoEncoding).toEqual({
-      maxBitrate: 1_700_000,
-      maxFramerate: 30,
-    });
-    expect(opts.publishDefaults?.screenShareEncoding).toEqual({
-      maxBitrate: 5_000_000,
-      maxFramerate: 30,
-    });
-    expect(opts.publishDefaults?.videoSimulcastLayers).toEqual([
-      VideoPresets.h180,
-      VideoPresets.h360,
-    ]);
-  });
-
-  it("applies video codec from config", () => {
-    const opts = buildLiveKitOptions({ video_codec: "vp9" });
-    expect(opts.publishDefaults?.videoCodec).toBe("vp9");
-  });
-
-  it("applies video resolution and encoding from config", () => {
-    const baseVideoConfig = {
-      max_resolution: 1080,
-      max_bitrate: 3_000_000,
-      max_framerate: 60,
-    };
-    const opts1080 = buildLiveKitOptions({
-      video: baseVideoConfig,
-    });
-    const opts1440 = buildLiveKitOptions({
-      video: { ...baseVideoConfig, max_resolution: 1440 },
-    });
-    const opts2160 = buildLiveKitOptions({
-      video: { ...baseVideoConfig, max_resolution: 2160 },
-    });
-    expect(opts1080.videoCaptureDefaults?.resolution).toEqual(
-      VideoPresets.h1080.resolution,
-    );
-    expect(opts1440.videoCaptureDefaults?.resolution).toEqual(
-      VideoPresets.h1440.resolution,
-    );
-    expect(opts2160.videoCaptureDefaults?.resolution).toEqual(
-      VideoPresets.h2160.resolution,
-    );
-    expect(opts1080.publishDefaults?.videoEncoding).toEqual({
-      maxBitrate: 3_000_000,
-      maxFramerate: 60,
-    });
-  });
-
-  it("applies screen share encoding from config", () => {
-    const opts = buildLiveKitOptions({
-      screen_share: {
-        max_bitrate: 8_000_000,
-        max_framerate: 15,
-      },
-    });
-    expect(opts.publishDefaults?.screenShareEncoding).toEqual({
-      maxBitrate: 8_000_000,
-      maxFramerate: 15,
-    });
-  });
-
-  it("uses DEFAULT_CONFIG defaults when only resolution is set", () => {
-    const opts = buildLiveKitOptions({
-      screen_share: {
-        max_resolution: 720,
-      },
-    });
-    // Bitrate and framerate fall back to DEFAULT_CONFIG, not the preset
-    expect(opts.publishDefaults?.screenShareEncoding).toEqual({
-      maxBitrate: 5_000_000,
-      maxFramerate: 30,
-    });
-  });
-
-  it("maps low resolutions to the closest preset, rounding up", () => {
-    const expectations: [number, VideoPreset][] = [
-      [180, VideoPresets.h180],
-      [360, VideoPresets.h360],
-      [480, VideoPresets.h540],
-      [540, VideoPresets.h540],
-      [720, VideoPresets.h720],
-    ];
-    for (const [height, preset] of expectations) {
-      const opts = buildLiveKitOptions({ video: { max_resolution: height } });
-      expect(opts.videoCaptureDefaults?.resolution).toEqual(preset.resolution);
-    }
-  });
-
-  it("screen share layers fall back to max_framerate, then 30", () => {
-    const fromMax = buildLiveKitOptions({
-      screen_share: {
-        max_framerate: 15,
-        simulcast_layers: [{ height: 540, bitrate: 1_000_000 }],
-      },
-    });
-    expect(
-      fromMax.publishDefaults?.screenShareSimulcastLayers?.[0],
-    ).toMatchObject({ encoding: { maxFramerate: 15 } });
-
-    const fromDefault = buildLiveKitOptions({
-      screen_share: {
-        simulcast_layers: [{ height: 540, bitrate: 1_000_000 }],
-      },
-    });
-    expect(
-      fromDefault.publishDefaults?.screenShareSimulcastLayers?.[0],
-    ).toMatchObject({ encoding: { maxFramerate: 30 } });
-  });
-
-  it("applies custom video simulcast layers", () => {
-    const opts = buildLiveKitOptions({
-      video: {
-        simulcast_layers: [
-          { height: 180, bitrate: 100_000 },
-          { height: 360, bitrate: 300_000 },
-          { height: 540, bitrate: 600_000 },
-        ],
-        max_framerate: 24,
-      },
-    });
-    const layers = opts.publishDefaults?.videoSimulcastLayers;
-    expect(layers).toHaveLength(3);
-    expect(layers?.[0]).toMatchObject({
-      width: 320,
-      height: 180,
-      encoding: { maxBitrate: 100_000, maxFramerate: 24 },
-    });
-    expect(layers?.[2]).toMatchObject({
-      width: 960,
-      height: 540,
-      encoding: { maxBitrate: 600_000, maxFramerate: 24 },
-    });
-  });
-
-  it("applies custom screen share simulcast layers", () => {
-    const opts = buildLiveKitOptions({
-      screen_share: {
-        simulcast_layers: [{ height: 540, bitrate: 1_000_000, framerate: 5 }],
-      },
-    });
-    const layers = opts.publishDefaults?.screenShareSimulcastLayers;
-    expect(layers).toHaveLength(1);
-    expect(layers?.[0]).toMatchObject({
-      width: 960,
-      height: 540,
-      encoding: { maxBitrate: 1_000_000, maxFramerate: 5 },
-    });
-  });
-
-  it("does not include screenShareSimulcastLayers when not configured", () => {
-    const opts = buildLiveKitOptions();
-    expect(opts.publishDefaults?.screenShareSimulcastLayers).toBeUndefined();
-  });
-
-  it("backupCodec always uses stock VP8 720p encoding", () => {
-    const opts = buildLiveKitOptions({
-      video_codec: "av1",
-      video: { max_bitrate: 10_000_000, max_framerate: 60 },
-    });
-    const backup = opts.publishDefaults?.backupCodec as {
-      codec: string;
-      encoding: { maxBitrate: number; maxFramerate: number };
-    };
-    expect(backup.codec).toBe("vp8");
-    expect(backup.encoding).toEqual(VideoPresets.h720.encoding);
-  });
-});
-
-describe("getLiveKitOptions", () => {
-  it("reads from Config singleton", () => {
-    vi.mocked(Config.get).mockReturnValue({
-      media_quality: { video_codec: "h264" },
-    } as ReturnType<typeof Config.get>);
-    const opts = getLiveKitOptions();
-    expect(opts.publishDefaults?.videoCodec).toBe("h264");
-  });
-
-  it("throws when Config is not initialized", () => {
-    vi.mocked(Config.get).mockImplementation(() => {
-      throw new Error("Config not initialized");
-    });
-    expect(() => getLiveKitOptions()).toThrow("Config not initialized");
-  });
-});

src/livekit/options.ts

@@ -1,152 +0,0 @@
-/*
-Copyright 2023, 2024 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import {
-  AudioPresets,
-  DefaultReconnectPolicy,
-  type RoomOptions,
-  type TrackPublishDefaults,
-  type VideoPreset,
-  VideoPresets,
-  VideoPreset as VideoPresetClass,
-} from "livekit-client";
-
-import { Config } from "../config/Config";
-import { DEFAULT_CONFIG, type ConfigOptions } from "../config/ConfigOptions";
-
-/**
- * Find the closest matching VideoPreset for a given height.
- */
-function videoPresetForHeight(height: number): VideoPreset {
-  if (height <= 180) return VideoPresets.h180;
-  if (height <= 360) return VideoPresets.h360;
-  if (height <= 540) return VideoPresets.h540;
-  if (height <= 720) return VideoPresets.h720;
-  if (height <= 1080) return VideoPresets.h1080;
-  if (height <= 1440) return VideoPresets.h1440;
-  return VideoPresets.h2160;
-}
-
-/**
- * Build LiveKit publish options from config, falling back to sensible defaults.
- */
-function buildPublishOptions(
-  mediaQuality: ConfigOptions["media_quality"],
-): TrackPublishDefaults {
-  const defaults = DEFAULT_CONFIG.media_quality;
-  const videoConf = mediaQuality?.video;
-  const screenConf = mediaQuality?.screen_share;
-  const codec = mediaQuality?.video_codec ?? defaults.video_codec;
-
-  // Camera video encoding
-  const videoEncoding = {
-    maxBitrate: videoConf?.max_bitrate ?? defaults.video.max_bitrate,
-    maxFramerate: videoConf?.max_framerate ?? defaults.video.max_framerate,
-  };
-
-  // Camera simulcast layers
-  let videoSimulcastLayers: VideoPreset[];
-  if (videoConf?.simulcast_layers) {
-    videoSimulcastLayers = videoConf.simulcast_layers.map(
-      (layer) =>
-        new VideoPresetClass(
-          Math.round((layer.height * 16) / 9),
-          layer.height,
-          layer.bitrate,
-          videoConf?.max_framerate ?? defaults.video.max_framerate,
-        ),
-    );
-  } else {
-    videoSimulcastLayers = [VideoPresets.h180, VideoPresets.h360];
-  }
-
-  // Screen share encoding
-  const screenShareEncoding = {
-    maxBitrate: screenConf?.max_bitrate ?? defaults.screen_share.max_bitrate,
-    maxFramerate:
-      screenConf?.max_framerate ?? defaults.screen_share.max_framerate,
-  };
-
-  // Screen share simulcast layers
-  let screenShareSimulcastLayers: VideoPreset[] | undefined;
-  if (screenConf?.simulcast_layers) {
-    screenShareSimulcastLayers = screenConf.simulcast_layers.map(
-      (layer) =>
-        new VideoPresetClass(
-          Math.round((layer.height * 16) / 9),
-          layer.height,
-          layer.bitrate,
-          layer.framerate ?? screenConf?.max_framerate ?? 30,
-        ),
-    );
-  }
-
-  return {
-    audioPreset: AudioPresets.music,
-    dtx: true,
-    // disable red because the livekit server strips out red packets for clients
-    // that don't support it (firefox) but of course that doesn't work with e2ee.
-    red: false,
-    forceStereo: false,
-    simulcast: true,
-    videoSimulcastLayers: videoSimulcastLayers as VideoPreset[],
-    screenShareEncoding,
-    ...(screenShareSimulcastLayers && {
-      screenShareSimulcastLayers: screenShareSimulcastLayers as VideoPreset[],
-    }),
-    stopMicTrackOnMute: false,
-    videoCodec: codec,
-    videoEncoding,
-    backupCodec: {
-      codec: "vp8",
-      encoding: VideoPresets.h720.encoding,
-    },
-  } as TrackPublishDefaults;
-}
-
-/**
- * Build LiveKit RoomOptions from config.
- * Call this after Config.init() has resolved.
- */
-export function buildLiveKitOptions(
-  mediaQuality?: ConfigOptions["media_quality"],
-): RoomOptions {
-  const videoHeight =
-    mediaQuality?.video?.max_resolution ??
-    DEFAULT_CONFIG.media_quality.video.max_resolution;
-  const basePreset = videoPresetForHeight(videoHeight);
-
-  return {
-    // automatically manage subscribed video quality
-    adaptiveStream: true,
-
-    // optimize publishing bandwidth and CPU for published tracks
-    dynacast: true,
-
-    // capture settings
-    videoCaptureDefaults: {
-      resolution: basePreset.resolution,
-    },
-
-    // publish settings
-    publishDefaults: buildPublishOptions(mediaQuality),
-
-    // default LiveKit options that seem to be sane
-    stopLocalTrackOnUnpublish: true,
-    reconnectPolicy: new DefaultReconnectPolicy(),
-    disconnectOnPageLeave: true,
-    webAudioMix: false,
-  };
-}
-
-/**
- * Get LiveKit options, reading from the loaded Config singleton.
- * Requires Config.init() to have resolved first.
- */
-export function getLiveKitOptions(): RoomOptions {
-  return buildLiveKitOptions(Config.get().media_quality);
-}

src/room/CallEventAudioRenderer.test.tsx

@@ -41,7 +41,6 @@ import {
 import { MAX_PARTICIPANT_COUNT_FOR_SOUND } from "../state/CallViewModel/CallViewModel";
 import { initializeWidget } from "../widget";
 initializeWidget();
-vitest.mock("livekit-client/e2ee-worker?worker");
 vitest.mock("../useAudioContext");
 vitest.mock("../soundUtils");
 vitest.mock("../rtcSessionHelpers", async (importOriginal) => ({

src/room/CallView.test.tsx

@@ -61,7 +61,7 @@ import {
 } from "../HostBridge";
 import { type JoinCallData } from "../widget";
 import { MatrixRTCTransportMissingError } from "../utils/errors";
-import { ProcessorProvider } from "../livekit/TrackProcessorContext";
+import { ProcessorProvider } from "../tracks/TrackProcessorContext";
 import { MediaDevicesContext } from "../MediaDevicesContext";
 import { constant } from "../state/Behavior";
 

src/room/InCallView.test.tsx

@@ -15,22 +15,19 @@ import {
   vi,
 } from "vitest";
 import { act, render, type RenderResult } from "@testing-library/react";
-import { type LocalParticipant } from "livekit-client";
-import { BehaviorSubject, of } from "rxjs";
+import { BehaviorSubject } from "rxjs";
 import { BrowserRouter } from "react-router-dom";
 import { TooltipProvider } from "@vector-im/compound-web";
-import { RoomContext, useLocalParticipant } from "@livekit/components-react";
 import userEvent from "@testing-library/user-event";
 
 import { ActiveCall, InCallView } from "./InCallView";
 import {
-  mockLivekitRoom,
-  mockLocalParticipant,
   mockMediaDevices,
   mockMuteStates,
-  mockRemoteParticipant,
   mockRtcMembership,
   type MockRTCSession,
+  mockRTCSlot,
+  mockRTCMember,
 } from "../utils/test";
 import { E2eeType } from "../e2ee/e2eeType";
 import {
@@ -41,15 +38,17 @@ import {
   type CallViewModel,
   type CallViewModelOptions,
 } from "../state/CallViewModel/CallViewModel";
-import { alice, local } from "../utils/test-fixtures";
+import { alice, local, aliceRtcMember } from "../utils/test-fixtures";
 import { ReactionsSenderProvider } from "../reactions/useReactionsSender";
 import { useRoomEncryptionSystem } from "../e2ee/sharedKeyManagement";
-import { LivekitRoomAudioRenderer } from "../livekit/MatrixAudioRenderer";
+import { MemberAudioRenderer } from "../tracks/MemberAudioRenderer";
+import type * as MatrixRTCSdk from "@element-hq/matrixrtc-sdk";
+import { constant, type ObservableScope } from "@element-hq/matrixrtc-sdk";
 import { MediaDevicesContext } from "../MediaDevicesContext";
 import { type MediaDevices as ECMediaDevices } from "../state/MediaDevices";
 import { AppBar } from "../AppBar";
 import { type MatrixInfo } from "./VideoPreview";
-import { ProcessorProvider } from "../livekit/TrackProcessorContext";
+import { ProcessorProvider } from "../tracks/TrackProcessorContext";
 import { initializeWidget } from "../widget";
 import { RootElementProvider } from "../RootElementContext";
 
@@ -68,21 +67,19 @@ vi.mock("../soundUtils");
 vi.mock("../useAudioContext");
 vi.mock("../tile/GridTile");
 vi.mock("../tile/SpotlightTile");
-vi.mock("@livekit/components-react");
-vi.mock("livekit-client/e2ee-worker?worker");
 vi.mock("../e2ee/sharedKeyManagement");
-vi.mock("../livekit/MatrixAudioRenderer");
+vi.mock("../tracks/MemberAudioRenderer");
+// ActiveCall builds the slot itself; the view is what these tests are about
+const createRTCSlotMock = vi.hoisted(() => vi.fn());
+vi.mock("@element-hq/matrixrtc-sdk", async (importOriginal) => ({
+  ...(await importOriginal<typeof MatrixRTCSdk>()),
+  createRTCSlot: createRTCSlotMock,
+}));
 vi.mock("react-use-measure", () => ({
   default: (): [() => void, object] => [(): void => {}, {}],
 }));
 
 const localRtcMember = mockRtcMembership("@carol:example.org", "CCCC");
-const localParticipant = mockLocalParticipant({
-  identity: "@local:example.org:AAAAAA",
-});
-const remoteParticipant = mockRemoteParticipant({
-  identity: "@alice:example.org:AAAAAA",
-});
 
 const matrixInfo = {
   userId: "",
@@ -100,21 +97,26 @@ let useRoomEncryptionSystemMock: MockedFunction<typeof useRoomEncryptionSystem>;
 beforeEach(() => {
   vi.clearAllMocks();
 
-  // MatrixAudioRenderer is tested separately.
-  (
-    LivekitRoomAudioRenderer as MockedFunction<typeof LivekitRoomAudioRenderer>
-  ).mockImplementation((_props) => {
-    return <div>mocked: MatrixAudioRenderer</div>;
-  });
-  (
-    useLocalParticipant as MockedFunction<typeof useLocalParticipant>
-  ).mockImplementation(
-    () =>
-      ({
-        isScreenShareEnabled: false,
-        localParticipant: localRtcMember as unknown as LocalParticipant,
-      }) as unknown as ReturnType<typeof useLocalParticipant>,
+  createRTCSlotMock.mockImplementation((scope: ObservableScope) =>
+    mockRTCSlot(scope, {
+      localMember$: constant(
+        mockRTCMember(true, {
+          membership: localRtcMember,
+          tracks$: constant([]),
+        }),
+      ),
+      remoteMembers$: constant([
+        mockRTCMember(false, {
+          membership: aliceRtcMember,
+          tracks$: constant([]),
+        }),
+      ]),
+    }),
   );
+  // MemberAudioRenderer is tested separately.
+  (
+    MemberAudioRenderer as MockedFunction<typeof MemberAudioRenderer>
+  ).mockImplementation(() => <div>mocked: MemberAudioRenderer</div>);
   useRoomEncryptionSystemMock =
     useRoomEncryptionSystem as typeof useRoomEncryptionSystemMock;
   useRoomEncryptionSystemMock.mockReturnValue({ kind: E2eeType.NONE });
@@ -131,14 +133,6 @@ function createInCallView(args: CreateInCallViewArgs = {}): RenderResult & {
 } {
   const mediaDevices = args.mediaDevices ?? mockMediaDevices({});
   const muteState = mockMuteStates();
-  const livekitRoom = mockLivekitRoom(
-    {
-      localParticipant,
-    },
-    {
-      remoteParticipants$: of([remoteParticipant]),
-    },
-  );
   const { vm, footerVm, developerSettingsVm, rtcSession } =
     getBasicCallViewModelEnvironment(
       [local, alice],
@@ -174,9 +168,7 @@ function createInCallView(args: CreateInCallViewArgs = {}): RenderResult & {
           vm={vm}
           rtcSession={rtcSession.asMockedSession()}
         >
-          <TooltipProvider>
-            <RoomContext value={livekitRoom}>{content}</RoomContext>
-          </TooltipProvider>
+          <TooltipProvider>{content}</TooltipProvider>
         </ReactionsSenderProvider>
       </MediaDevicesContext>
     </BrowserRouter>,
@@ -244,18 +236,16 @@ describe("ActiveCall", () => {
         <MediaDevicesContext value={mediaDevices}>
           <ProcessorProvider>
             <TooltipProvider>
-              <RoomContext value={mockLivekitRoom({ localParticipant })}>
-                <ActiveCall
-                  client={matrixRoom.client}
-                  rtcSession={rtcSession.asMockedSession()}
-                  matrixRoom={matrixRoom}
-                  muteStates={mockMuteStates()}
-                  matrixInfo={matrixInfo}
-                  onShareClick={null}
-                  e2eeSystem={{ kind: E2eeType.NONE }}
-                  onLeft={(): void => {}}
-                />
-              </RoomContext>
+              <ActiveCall
+                client={matrixRoom.client}
+                rtcSession={rtcSession.asMockedSession()}
+                matrixRoom={matrixRoom}
+                muteStates={mockMuteStates()}
+                matrixInfo={matrixInfo}
+                onShareClick={null}
+                e2eeSystem={{ kind: E2eeType.NONE }}
+                onLeft={(): void => {}}
+              />
             </TooltipProvider>
           </ProcessorProvider>
         </MediaDevicesContext>
@@ -294,18 +284,16 @@ describe("ActiveCall", () => {
             <MediaDevicesContext value={mediaDevices}>
               <ProcessorProvider>
                 <TooltipProvider>
-                  <RoomContext value={mockLivekitRoom({ localParticipant })}>
-                    <ActiveCall
-                      client={matrixRoom.client}
-                      rtcSession={rtcSession.asMockedSession()}
-                      matrixRoom={matrixRoom}
-                      muteStates={mockMuteStates()}
-                      matrixInfo={matrixInfo}
-                      onShareClick={null}
-                      e2eeSystem={{ kind: E2eeType.NONE }}
-                      onLeft={(): void => {}}
-                    />
-                  </RoomContext>
+                  <ActiveCall
+                    client={matrixRoom.client}
+                    rtcSession={rtcSession.asMockedSession()}
+                    matrixRoom={matrixRoom}
+                    muteStates={mockMuteStates()}
+                    matrixInfo={matrixInfo}
+                    onShareClick={null}
+                    e2eeSystem={{ kind: E2eeType.NONE }}
+                    onLeft={(): void => {}}
+                  />
                 </TooltipProvider>
               </ProcessorProvider>
             </MediaDevicesContext>

src/room/InCallView.tsx

@@ -42,11 +42,16 @@ import { InviteButton } from "../button/InviteButton";
 import {
   type CallViewModel,
   callViewModelOptionsFromParams,
+  type CaptureSettings,
   createCallViewModel$,
+  initialPublishRequests,
 } from "../state/CallViewModel/CallViewModel.ts";
 import { Grid, type TileProps } from "../grid/Grid";
 import { SpotlightTile } from "../tile/SpotlightTile";
-import { type EncryptionSystem } from "../e2ee/sharedKeyManagement";
+import {
+  type EncryptionSystem,
+  type MatrixRTCMode,
+} from "@element-hq/matrixrtc-sdk";
 import { E2eeType } from "../e2ee/e2eeType";
 import { makeGridLayout } from "../grid/GridLayout";
 import { type CallLayoutOutputs } from "../grid/CallLayout";
@@ -63,9 +68,35 @@ import {
 import { ReactionsAudioRenderer } from "./ReactionAudioRenderer";
 import { ReactionsOverlay } from "./ReactionsOverlay";
 import { CallEventAudioRenderer } from "./CallEventAudioRenderer";
-import { matrixRTCMode as matrixRTCModeSetting } from "../settings/settings";
+import {
+  createRTCSlot,
+  type RTCParticipationOptions,
+  type RTCSlotOptions,
+  constant,
+} from "@element-hq/matrixrtc-sdk";
+import { map } from "rxjs";
+import {
+  advancedCamera,
+  advancedScreenShare,
+  autoGainControlSetting,
+  cameraBitrate,
+  cameraCodec,
+  cameraFramerate,
+  cameraResolution,
+  customTransport,
+  echoCancellationSetting,
+  matrixRTCMode as matrixRTCModeSetting,
+  noiseSuppressionSetting,
+  parseResolution,
+  screenShareBitrate,
+  screenShareCodec,
+  screenShareFramerate,
+  screenShareResolution,
+} from "../settings/settings";
+import { Config } from "../config/Config";
+import { createSentCallNotification$ } from "../state/CallViewModel/CallNotificationLifecycle.ts";
 import { ReactionsReader } from "../reactions/ReactionsReader";
-import { LivekitRoomAudioRenderer } from "../livekit/MatrixAudioRenderer.tsx";
+import { MemberAudioRenderer } from "../tracks/MemberAudioRenderer.tsx";
 import { muteAllAudio$ } from "../state/MuteAllAudioModel.ts";
 import { useMediaDevices } from "../MediaDevicesContext.ts";
 import { EarpieceOverlay } from "./EarpieceOverlay.tsx";
@@ -76,10 +107,9 @@ import {
 } from "../AppBar.tsx";
 import { useBehavior } from "../useBehavior.ts";
 import { useValueBehavior } from "../useValueBehavior.ts";
-import { constant } from "../state/Behavior.ts";
 import { Toast } from "../Toast.tsx";
 import overlayStyles from "../Overlay.module.css";
-import { useTrackProcessorState$ } from "../livekit/TrackProcessorContext.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";
@@ -100,7 +130,7 @@ declare module "react" {
 
 export interface ActiveCallProps extends Omit<
   InCallViewProps,
-  "vm" | "livekitRoom" | "connState" | "footerVm" | "developerSettingsVm"
+  "vm" | "footerVm" | "developerSettingsVm"
 > {
   e2eeSystem: EncryptionSystem;
   // TODO refactor those reasons into an enum
@@ -131,29 +161,43 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
     const { autoLeaveWhenOthersLeft, waitForCallPickup, sendNotificationType } =
       urlParams;
 
+    const capture = captureSettings();
+    const slot = createRTCSlot(
+      scope,
+      props.client,
+      props.matrixRoom,
+      rtcSlotOptions(props.e2eeSystem),
+    );
+    const rtcParticipation = slot.join({
+      ...rtcParticipationOptions(urlParams),
+      publish: initialPublishRequests(props.muteStates, mediaDevices, capture),
+    });
+
     const vm = createCallViewModel$(
       scope,
-      props.rtcSession,
+      rtcParticipation,
       props.matrixRoom,
       mediaDevices,
       props.muteStates,
       {
         ...callViewModelOptionsFromParams(urlParams),
         encryptionSystem: props.e2eeSystem,
+        capture,
+        videoProcessor$: scope.behavior(
+          trackProcessorState$.pipe(map((state) => state.processor)),
+        ),
         hostBridge,
         autoLeaveWhenOthersLeft,
         waitForCallPickup: waitForCallPickup && sendNotificationType === "ring",
-        // We merely sample the current mode here, so the user would need to
-        // manually rejoin to switch to a different one.
-        matrixRTCMode: matrixRTCModeSetting.value$.value,
+        sentCallNotification$: createSentCallNotification$(
+          scope,
+          props.rtcSession,
+        ),
         windowSize$: scope.behavior(observeElementSize$(rootElement)),
       },
       reactionsReader.raisedHands$,
       reactionsReader.reactions$,
-      trackProcessorState$,
     );
-    // TODO move this somewhere else once we use the callViewModel in the lobby as well!
-    vm.join();
     setVm(vm);
 
     vm.leave$.pipe(scope.bind()).subscribe(props.onLeft);
@@ -250,16 +294,6 @@ export const InCallView: FC<InCallViewProps> = ({
   const { sendReaction, toggleRaisedHand } = useReactionsSender();
 
   useWakeLock();
-  // TODO-MULTI-SFU This is unused now??
-  // const connectionState = useBehavior(vm.livekitConnectionState$);
-
-  // annoyingly we don't get the disconnection reason this way,
-  // only by listening for the emitted event
-  // This needs to be done differential. with the vm connection state we start with Disconnected.
-  // TODO-MULTI-SFU decide how to handle this properly
-  // @BillCarsonFr
-  // if (connectionState === ConnectionState.Disconnected)
-  //   throw new ConnectionLostError();
 
   const containerRef1 = useRef<HTMLDivElement | null>(null);
   const [containerRef2, bounds] = useMeasure();
@@ -296,7 +330,7 @@ export const InCallView: FC<InCallViewProps> = ({
   );
 
   const ringingVm = useBehavior(vm.ringingVm$);
-  const audioParticipants = useBehavior(vm.livekitRoomItems$);
+  const remoteMembers = useBehavior(vm.remoteMembers$);
   const participantCount = useBehavior(vm.participantCount$);
   const reconnecting = useBehavior(vm.reconnecting$);
   const screenShareError = useBehavior(vm.screenShareError$);
@@ -646,7 +680,11 @@ export const InCallView: FC<InCallViewProps> = ({
   const footer = footerVm !== null && (
     <CallFooter className={styles.footer} ref={footerRef} vm={footerVm} />
   );
-  const allConnections = useBehavior(vm.allConnections$);
+  const connectedTransports = useBehavior(vm.connectedTransports$);
+  const localMember = useBehavior(vm.localMember$);
+  const localTransport = useBehavior(
+    localMember?.transport$ ?? constant(undefined),
+  );
 
   return (
     // The pointer handler here exists to control the visibility of the footer,
@@ -665,15 +703,7 @@ export const InCallView: FC<InCallViewProps> = ({
       onPointerOut={onPointerOut}
     >
       {header}
-      {audioParticipants.map(({ livekitRoom, transport, participants }) => (
-        <LivekitRoomAudioRenderer
-          key={JSON.stringify(transport)}
-          transport={transport}
-          livekitRoom={livekitRoom}
-          validIdentities={participants}
-          muted={muteAllAudio}
-        />
-      ))}
+      <MemberAudioRenderer members={remoteMembers} muted={muteAllAudio} />
       {renderContent()}
       <CallEventAudioRenderer vm={vm} muted={muteAllAudio} />
       <ReactionsAudioRenderer vm={vm} muted={muteAllAudio} />
@@ -694,22 +724,109 @@ export const InCallView: FC<InCallViewProps> = ({
             tab={settingsTab}
             onTabChange={setSettingsTab}
             developerSettingsVm={developerSettingsVm}
-            livekitRooms={allConnections.map(
-              ({ livekitRoom: room, livekitAlias, transport, role }) => ({
-                room,
-                livekitAlias,
-                role,
-                url:
-                  // It should be relatively clear to the user which kind of URL
-                  // this is, based on the scheme (ws:// vs. http://)
-                  "url" in transport
-                    ? transport.url
-                    : transport.livekit_service_url,
-              }),
-            )}
+            transports={connectedTransports.map((transport) => ({
+              transport,
+              local: transport === localTransport,
+            }))}
           />
         </>
       )}
     </div>
   );
 };
+
+/**
+ * How the tracks are captured and encoded, from Element Call's settings and
+ * configuration. Shared with the legacy SDK bundle so that a widget built from
+ * it behaves like the app.
+ */
+export function captureSettings(): CaptureSettings {
+  const config = Config.get();
+  const cameraSettings = advancedCamera.getValue()
+    ? {
+        resolution: {
+          ...parseResolution(cameraResolution.getValue()),
+          frameRate: cameraFramerate.getValue(),
+        },
+        maxBitrate: cameraBitrate.getValue(),
+        maxFramerate: cameraFramerate.getValue(),
+        codec: cameraCodec.getValue(),
+      }
+    : undefined;
+  const screenConfig = config.media_quality?.screen_share;
+  const screenShareSettings = advancedScreenShare.getValue()
+    ? {
+        resolution: {
+          ...parseResolution(screenShareResolution.getValue()),
+          frameRate: screenShareFramerate.getValue(),
+        },
+        maxBitrate: screenShareBitrate.getValue(),
+        maxFramerate: screenShareFramerate.getValue(),
+        codec: screenShareCodec.getValue(),
+      }
+    : screenConfig?.max_resolution
+      ? {
+          resolution: {
+            width: Math.round((screenConfig.max_resolution * 16) / 9),
+            height: screenConfig.max_resolution,
+            frameRate: screenConfig.max_framerate ?? 30,
+          },
+        }
+      : undefined;
+  return {
+    audio: {
+      echoCancellation: echoCancellationSetting.getValue(),
+      noiseSuppression: noiseSuppressionSetting.getValue(),
+      autoGainControl: autoGainControlSetting.getValue(),
+    },
+    camera: cameraSettings,
+    screenShare: screenShareSettings,
+  };
+}
+
+/**
+ * What the client needs from Element Call's configuration, settings and URL:
+ * the SDK reads none of them itself. What to publish depends on the mute
+ * switches and the devices, so the caller adds that. Shared with the legacy
+ * SDK bundle so that a widget built from it behaves like the app.
+ */
+export function rtcSlotOptions(
+  encryptionSystem: EncryptionSystem,
+): RTCSlotOptions {
+  return {
+    encryptionSystem,
+    // matrix_rtc_mode in config.json overrides the user's Developer Settings
+    // choice. We merely sample the current mode here, so the user would need
+    // to manually rejoin to switch to a different one.
+    matrixRTCMode:
+      (Config.get().matrix_rtc_mode as MatrixRTCMode | undefined) ??
+      matrixRTCModeSetting.value$.value,
+  };
+}
+
+export function rtcParticipationOptions(
+  urlParams: ReturnType<typeof useUrlParams>,
+): Omit<RTCParticipationOptions, "publish"> {
+  const config = Config.get();
+  const session = config.matrix_rtc_session;
+  return {
+    sendNotificationType: urlParams.sendNotificationType,
+    applicationData: urlParams.callIntent
+      ? { "m.call.intent": urlParams.callIntent }
+      : undefined,
+    timings: {
+      syncDisconnectGracePeriodMs: config.sync_disconnect_grace_period_ms,
+      networkErrorRetryMs: session.network_error_retry_ms,
+      membershipEventExpiryMs: session.membership_event_expiry_ms,
+      keyRotationParticipantLimit: session.key_rotation_participant_limit,
+      delayedLeave: session.delayed_leave,
+      delegatedDelayedLeave: session.delegated_delayed_leave,
+    },
+    mediaQuality: config.media_quality,
+    transport: customTransport.value$.value ?? undefined,
+    fallbackTransport: config.livekit && {
+      type: "livekit",
+      livekit_service_url: config.livekit.livekit_service_url,
+    },
+  };
+}

src/room/KnockLobbyView.test.tsx

@@ -14,14 +14,14 @@ import { type MatrixClient, type RoomSummary } from "matrix-js-sdk";
 import { KnockLobbyView } from "./KnockLobbyView";
 import { LeaveToHomeProvider } from "../LeaveToHomeContext";
 import { MediaDevicesContext } from "../MediaDevicesContext";
-import { type ProcessorState } from "../livekit/TrackProcessorContext";
+import { type ProcessorState } from "../tracks/TrackProcessorContext";
 import { mockMediaDevices } from "../utils/test";
 
 vi.mock("@livekit/components-react", () => ({
   usePreviewTracks: (): unknown[] => [],
 }));
 
-vi.mock("../livekit/TrackProcessorContext", () => ({
+vi.mock("../tracks/TrackProcessorContext", () => ({
   useTrackProcessor: (): ProcessorState => ({
     supported: false,
     processor: undefined,

src/room/LobbyView.test.tsx

@@ -28,7 +28,7 @@ import {
 } from "../utils/test";
 import { type MediaDevices } from "../state/MediaDevices";
 import { MediaDevicesContext } from "../MediaDevicesContext";
-import { type ProcessorState } from "../livekit/TrackProcessorContext";
+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,7 +41,7 @@ vi.mock("@livekit/components-react", () => ({
   usePreviewTracks: (): unknown[] => [],
 }));
 
-vi.mock("../livekit/TrackProcessorContext", () => ({
+vi.mock("../tracks/TrackProcessorContext", () => ({
   useTrackProcessor: (): ProcessorState => ({
     supported: false,
     processor: undefined,

src/room/LobbyView.tsx

@@ -24,6 +24,7 @@ import {
   type LocalVideoTrack,
   Track,
 } from "livekit-client";
+import { convertToLivekitProcessor } from "@element-hq/matrixrtc-sdk";
 
 import inCallStyles from "./InCallView.module.css";
 import styles from "./LobbyView.module.css";
@@ -42,7 +43,7 @@ import { useInitial } from "../useInitial";
 import {
   useTrackProcessor,
   useTrackProcessorSync,
-} from "../livekit/TrackProcessorContext";
+} from "../tracks/TrackProcessorContext";
 import { getValue } from "../utils/observable";
 import { useBehavior } from "../useBehavior";
 import { CallFooter, type FooterSnapshot } from "../components/CallFooter";
@@ -150,7 +151,8 @@ export const LobbyView: FC<Props> = ({
       audio: Object.assign({}, initialAudioOptions),
       video: videoEnabled && {
         deviceId: videoInputId,
-        processor: initialProcessor,
+        processor:
+          initialProcessor && convertToLivekitProcessor(initialProcessor),
       },
     }),
     [initialAudioOptions, videoEnabled, videoInputId, initialProcessor],

src/room/ReactionAudioRenderer.test.tsx

@@ -48,7 +48,6 @@ function TestComponent({ vm }: { vm: CallViewModel }): ReactNode {
   );
 }
 
-vitest.mock("livekit-client/e2ee-worker?worker");
 vitest.mock("../useAudioContext");
 vitest.mock("../soundUtils");
 

src/room/ReactionsOverlay.test.tsx

@@ -6,7 +6,7 @@ Please see LICENSE in the repository root for full details.
 */
 
 import { render } from "@testing-library/react";
-import { expect, test, afterEach, vi } from "vitest";
+import { expect, test, afterEach } from "vitest";
 import { act } from "react";
 
 import { showReactions } from "../settings/settings";
@@ -22,8 +22,6 @@ import { getBasicCallViewModelEnvironment } from "../utils/test-viewmodel";
 import { initializeWidget } from "../widget";
 initializeWidget();
 
-vi.mock("livekit-client/e2ee-worker?worker");
-
 afterEach(() => {
   showReactions.setValue(showReactions.defaultValue);
 });

src/room/__snapshots__/GroupCallErrorBoundary.test.tsx.snap

@@ -1228,7 +1228,7 @@ exports[`should have a close button when the host can dismiss us 1`] = `
             Call is not supported
           </h1>
           <p>
-            The server is not configured to work with Element Call. Please contact your server admin (Domain: example.com, Error Code: MISSING_MATRIX_RTC_TRANSPORT).
+            The server is not configured to work with Element Call and no other call participant provides a usable transport. Please contact your server admin (Domain: example.com, Error Code: MISSING_MATRIX_RTC_TRANSPORT).
           </p>
           <button
             class="_button_1nw83_8"
@@ -1381,7 +1381,7 @@ exports[`should render the error page with link back to home 1`] = `
             Call is not supported
           </h1>
           <p>
-            The server is not configured to work with Element Call. Please contact your server admin (Domain: example.com, Error Code: MISSING_MATRIX_RTC_TRANSPORT).
+            The server is not configured to work with Element Call and no other call participant provides a usable transport. Please contact your server admin (Domain: example.com, Error Code: MISSING_MATRIX_RTC_TRANSPORT).
           </p>
           <button
             class="_button_1nw83_8"
@@ -1534,7 +1534,7 @@ exports[`should report correct error for 'Call is not supported' 1`] = `
             Call is not supported
           </h1>
           <p>
-            The server is not configured to work with Element Call. Please contact your server admin (Domain: example.com, Error Code: MISSING_MATRIX_RTC_TRANSPORT).
+            The server is not configured to work with Element Call and no other call participant provides a usable transport. Please contact your server admin (Domain: example.com, Error Code: MISSING_MATRIX_RTC_TRANSPORT).
           </p>
           <button
             class="_button_1nw83_8"

src/room/__snapshots__/InCallView.test.tsx.snap

@@ -84,6 +84,9 @@ exports[`InCallView > rendering > renders 1`] = `
         class="_nav_e4b327 _rightNav_e4b327"
       />
     </header>
+    <div>
+      mocked: MemberAudioRenderer
+    </div>
     <div
       class="_scrollingGrid_4e7ff8 _grid_b0d1cd"
     >

src/settings/DeveloperSettingsTab.test.tsx

@@ -11,10 +11,10 @@ import userEvent, { type UserEvent } from "@testing-library/user-event";
 import { TooltipProvider } from "@vector-im/compound-web";
 
 import type { MatrixClient } from "matrix-js-sdk";
-import type { Room as LivekitRoom } from "livekit-client";
 import {
   DeveloperSettingsTab,
   type DeveloperSettingsSnapshot,
+  type TransportInfo,
 } from "./DeveloperSettingsTab";
 import { outOfCallDeveloperSettingsTabViewModel } from "./DeveloperSettingsTabViewModel";
 import { createStaticViewModel } from "../state/ViewModel";
@@ -23,9 +23,13 @@ import {
   enableExtendedLivekitLogs as enableExtendedLivekitLogsSetting,
   matrixRTCMode as matrixRTCModeSetting,
 } from "./settings";
-import { MatrixRTCMode } from "../config/ConfigOptions";
+import {
+  authenticateWithTransport,
+  constant,
+  MatrixRTCMode,
+} from "@element-hq/matrixrtc-sdk";
+import type * as MatrixRTCSdk from "@element-hq/matrixrtc-sdk";
 import { exampleTransport, mockConfig } from "../utils/test";
-import { getSFUConfig } from "../livekit/auth";
 
 // Mock url params hook to avoid environment-dependent snapshot churn.
 vi.mock("../UrlParams", () => ({
@@ -36,32 +40,30 @@ vi.mock("../UrlParams", () => ({
 }));
 
 // IMPORTANT: mock the same specifier used by DeveloperSettingsTab
-vi.mock("../livekit/auth", () => ({
-  getSFUConfig: vi.fn().mockResolvedValue({
+vi.mock("@element-hq/matrixrtc-sdk", async (importOriginal) => ({
+  ...(await importOriginal<typeof MatrixRTCSdk>()),
+  authenticateWithTransport: vi.fn().mockResolvedValue({
     url: "mock-url",
     jwt: "mock-jwt",
   }),
 }));
 
-// Provide a minimal mock of a Livekit Room structure used by the component.
-function createMockLivekitRoom(
-  wsUrl: string,
-  serverInfo: object,
-  metadata: string,
-): { isLocal: boolean; url: string; room: LivekitRoom; livekitAlias: string } {
-  const mockRoom = {
-    serverInfo,
-    metadata,
-    engine: { client: { ws: { url: wsUrl } } },
-    localParticipant: { identity: "localParticipantIdentity" },
-    remoteParticipants: new Map(),
-  } as unknown as LivekitRoom;
-
+/** A transport the panel shows, as the client would hand it out. */
+function mockTransport(
+  url: string,
+  local: boolean,
+  resolved?: { url: string; roomAlias: string; identity: string },
+): TransportInfo {
   return {
-    isLocal: true,
-    url: wsUrl,
-    room: mockRoom,
-    livekitAlias: "TestAlias",
+    local,
+    transport: {
+      type: "livekit",
+      id: url,
+      raw: { type: "livekit", livekit_service_url: url },
+      resolved$: constant(
+        resolved && { type: "livekit", token: "secret", ...resolved },
+      ),
+    },
   };
 }
 
@@ -96,36 +98,20 @@ describe("DeveloperSettingsTab", () => {
   it("renders and matches snapshot", async () => {
     const client = createMockMatrixClient();
 
-    const livekitRooms: {
-      room: LivekitRoom;
-      url: string;
-      isLocal?: boolean;
-      livekitAlias: string;
-    }[] = [
-      createMockLivekitRoom(
-        "wss://local-sfu.example.org",
-        { region: "local", version: "1.2.3" },
-        "local-metadata",
-      ),
-      {
-        isLocal: false,
-        livekitAlias: "TestAlias2",
-        url: "wss://remote-sfu.example.org",
-        room: {
-          localParticipant: { identity: "localParticipantIdentity" },
-          remoteParticipants: new Map(),
-          serverInfo: { region: "remote", version: "4.5.6" },
-          metadata: "remote-metadata",
-          engine: { client: { ws: { url: "wss://remote-sfu.example.org" } } },
-        } as unknown as LivekitRoom,
-      },
+    const transports = [
+      mockTransport("https://local-sfu.example.org/jwt", true, {
+        url: "wss://local-sfu.example.org",
+        roomAlias: "TestAlias",
+        identity: "localParticipantIdentity",
+      }),
+      mockTransport("https://remote-sfu.example.org/jwt", false),
     ];
 
     const { container } = render(
       <DeveloperSettingsTab
         client={client}
         roomId={"#room:example.org"}
-        livekitRooms={livekitRooms}
+        transports={transports}
         env={{ MY_MOCK_ENV: 10, ENV: "test" } as unknown as ImportMetaEnv}
         vm={outOfCallDeveloperSettingsTabViewModel}
       />,
@@ -169,7 +155,7 @@ describe("DeveloperSettingsTab", () => {
 
       const saveButton = screen.getByRole("button", { name: "Save" });
       await user.click(saveButton);
-      expect(getSFUConfig).not.toHaveBeenCalled();
+      expect(authenticateWithTransport).not.toHaveBeenCalled();
 
       expect(customTransportSetting.getValue()).toBe(null);
     });
@@ -192,7 +178,7 @@ describe("DeveloperSettingsTab", () => {
 
       const saveButton = screen.getByRole("button", { name: "Save" });
       await user.click(saveButton);
-      expect(getSFUConfig).not.toHaveBeenCalled();
+      expect(authenticateWithTransport).not.toHaveBeenCalled();
 
       expect(customTransportSetting.getValue()).toBe(null);
     });
@@ -218,7 +204,7 @@ describe("DeveloperSettingsTab", () => {
         name: "Reset overwrite",
       });
       await user.click(cancelButton);
-      expect(getSFUConfig).not.toHaveBeenCalled();
+      expect(authenticateWithTransport).not.toHaveBeenCalled();
 
       expect(customTransportSetting.getValue()).toBe(null);
     });
@@ -245,10 +231,12 @@ describe("DeveloperSettingsTab", () => {
 
       const saveButton = screen.getByRole("button", { name: "Save" });
       await user.click(saveButton);
-      expect(getSFUConfig).toHaveBeenCalledWith(
+      expect(authenticateWithTransport).toHaveBeenCalledWith(
         expect.objectContaining({
           transport: { type: "livekit", url: "wss://example.livekit.valid" },
+          serverName: "hs",
           roomId: "#testRoom",
+          role: "publisher",
         }),
       );
 
@@ -279,7 +267,7 @@ describe("DeveloperSettingsTab", () => {
       });
 
       const saveButton = screen.getByRole("button", { name: "Save" });
-      (getSFUConfig as Mock).mockImplementation(() => {
+      (authenticateWithTransport as Mock).mockImplementation(() => {
         throw new Error("Failed to get SFU config");
       });
       await user.click(saveButton);
@@ -290,9 +278,6 @@ describe("DeveloperSettingsTab", () => {
     });
   });
 
-  // Add this test inside the describe("DeveloperSettingsTab", () => { block,
-  // after the custom transport tests:
-
   describe("enable extended livekit logs", () => {
     afterEach(() => {
       enableExtendedLivekitLogsSetting.setValue(false);

src/settings/DeveloperSettingsTab.tsx

@@ -11,7 +11,6 @@ import {
   type ReactNode,
   useCallback,
   useEffect,
-  useMemo,
   useId,
   useState,
 } from "react";
@@ -21,6 +20,7 @@ import {
   type MatrixClient,
 } from "matrix-js-sdk";
 import { logger } from "matrix-js-sdk/lib/logger";
+import { type UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
 import {
   EditInPlace,
   ErrorMessage,
@@ -32,7 +32,6 @@ import {
   RadioControl,
   Separator,
 } from "@vector-im/compound-web";
-import { type Room as LivekitRoom } from "livekit-client";
 
 import { FieldRow, InputField } from "../input/Input";
 import { Config } from "../config/Config";
@@ -67,14 +66,23 @@ import styles from "./DeveloperSettingsTab.module.css";
 import settingsStyles from "./SettingsModal.module.css";
 import { Slider } from "../Slider";
 import { useUrlParams } from "../UrlParams";
+import {
+  authenticateWithTransport,
+  type TransportMetadata,
+} from "@element-hq/matrixrtc-sdk";
 import { useBehavior } from "../useBehavior";
 import { type ViewModel } from "../state/ViewModel.ts";
-import { getSFUConfig } from "../livekit/auth/index.ts";
-import { type UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
 
 /**
  * The state of MatrixRTC's media key rotation.
  */
+/** One connected transport, as the panel shows it. */
+export interface TransportInfo {
+  transport: TransportMetadata;
+  /** Whether this is the transport the local member publishes on. */
+  local: boolean;
+}
+
 export interface KeyRotationInfo {
   /** Whether the call is large enough that MatrixRTC has stopped rotating the media key. */
   suppressed: boolean;
@@ -106,19 +114,15 @@ const KeyRotationStatus: FC<{ info: KeyRotationInfo }> = ({ info }) => (
 interface Props {
   client: MatrixClient;
   roomId?: string;
-  livekitRooms?: {
-    room: LivekitRoom;
-    url: string;
-    isLocal?: boolean;
-    livekitAlias?: string;
-  }[];
+  /** The transports the client is connected to, while in a call. */
+  transports?: TransportInfo[];
   env: ImportMetaEnv;
   vm: ViewModel<DeveloperSettingsSnapshot>;
 }
 
 export const DeveloperSettingsTab: FC<Props> = ({
   client,
-  livekitRooms,
+  transports,
   roomId,
   env,
   vm,
@@ -168,34 +172,23 @@ export const DeveloperSettingsTab: FC<Props> = ({
     enableExtendedLivekitLogsSetting,
   );
 
-  const [customTransportUpdateError, setCustomLivekitUrlUpdateError] = useState<
+  const [customTransportUpdateError, setCustomTransportUpdateError] = useState<
     string | null
   >(null);
   const [customTransport, setCustomTransport] = useSetting(
     customTransportSetting,
   );
-  const [customTransportTextBuffer, setCustomLivekitUrlTextBuffer] = useState(
+  const [customTransportTextBuffer, setCustomTransportTextBuffer] = useState(
     () => transportText(customTransport),
   );
   useEffect(() => {
-    setCustomLivekitUrlTextBuffer(transportText(customTransport));
+    setCustomTransportTextBuffer(transportText(customTransport));
   }, [customTransport]);
 
   const [muteAllAudio, setMuteAllAudio] = useSetting(muteAllAudioSetting);
 
   const urlParams = useUrlParams();
 
-  const localSfuUrl = useMemo((): URL | null => {
-    const localRoom = livekitRooms?.find((r) => r.isLocal)?.room;
-    if (localRoom?.engine.client.ws?.url) {
-      // strip the URL params
-      const url = new URL(localRoom.engine.client.ws.url);
-      url.search = "";
-      return url;
-    }
-    return null;
-  }, [livekitRooms]);
-
   const MediaQualitySettings: React.FC<{
     id: string;
     header: string;
@@ -505,11 +498,7 @@ export const DeveloperSettingsTab: FC<Props> = ({
         cancelButtonLabel={t("developer_mode.custom_transport.reset")}
         onSave={useCallback(
           async (e: React.FormEvent<HTMLFormElement>): Promise<void> => {
-            if (
-              roomId === undefined ||
-              customTransportTextBuffer === "" ||
-              customTransportTextBuffer === null
-            ) {
+            if (roomId === undefined || customTransportTextBuffer === "") {
               setCustomTransport(null);
               return;
             }
@@ -517,38 +506,39 @@ export const DeveloperSettingsTab: FC<Props> = ({
             try {
               const userId = client.getUserId();
               const deviceId = client.getDeviceId();
+              const serverName = client.getDomain();
 
-              if (userId === null || deviceId === null) {
-                throw new Error("Invalid user or device ID");
+              if (userId === null || deviceId === null || serverName === null) {
+                throw new Error("Invalid user, device ID or server name");
               }
               const transport = JSON.parse(customTransportTextBuffer);
               // Validate the transport by attempting to get a token for it
-              await getSFUConfig({
+              await authenticateWithTransport({
                 client,
                 membership: { userId, deviceId, memberId: "" },
                 transport,
-                serverName: client.getDomain()!,
+                serverName: transport.server_name ?? serverName,
                 roomId,
                 slotId: "org.example.fake-slot#room",
                 role: "publisher",
                 logger,
               });
-              setCustomLivekitUrlUpdateError(null);
+              setCustomTransportUpdateError(null);
               setCustomTransport(transport);
             } catch {
-              setCustomLivekitUrlUpdateError(
+              setCustomTransportUpdateError(
                 "invalid transport (did not update)",
               );
             }
           },
           [customTransportTextBuffer, setCustomTransport, client, roomId],
         )}
-        value={customTransportTextBuffer ?? ""}
+        value={customTransportTextBuffer}
         onChange={useCallback(
           (event: ChangeEvent<HTMLInputElement>): void => {
-            setCustomLivekitUrlTextBuffer(event.target.value);
+            setCustomTransportTextBuffer(event.target.value);
           },
-          [setCustomLivekitUrlTextBuffer],
+          [setCustomTransportTextBuffer],
         )}
         onCancel={useCallback(
           (e: React.FormEvent<HTMLFormElement>) => {
@@ -601,39 +591,8 @@ export const DeveloperSettingsTab: FC<Props> = ({
           </HelpMessage>
         </InlineField>
       </Form>
-      {livekitRooms?.map((livekitRoom) => (
-        <div className={styles.livekit_room_box}>
-          <h4>
-            {t("developer_mode.livekit_sfu", {
-              url: livekitRoom.url || "unknown",
-            })}
-          </h4>
-          <p>LivekitAlias: {livekitRoom.livekitAlias}</p>
-          <p>connectionState (wont hot reload): {livekitRoom.room.state}</p>
-          {livekitRoom.isLocal && <p>ws-url: {localSfuUrl?.href}</p>}
-          <p>
-            {t("developer_mode.livekit_server_info")}(
-            {livekitRoom.isLocal ? "local" : "remote"})
-          </p>
-          <pre className={styles.pre}>
-            {livekitRoom.room.serverInfo
-              ? JSON.stringify(livekitRoom.room.serverInfo, null, 2)
-              : "undefined"}
-            {livekitRoom.room.metadata}
-          </pre>
-          <p>Local Participant</p>
-          <pre className={styles.pre}>
-            {livekitRoom.room.localParticipant.identity}
-          </pre>
-          <p>Remote Participants</p>
-          <ul>
-            {Array.from(livekitRoom.room.remoteParticipants.keys()).map(
-              (id) => (
-                <li key={id}>{id}</li>
-              ),
-            )}
-          </ul>
-        </div>
+      {transports?.map(({ transport, local }) => (
+        <TransportBox key={transport.id} transport={transport} local={local} />
       ))}
       <Separator />
       <MediaQualitySettings
@@ -698,9 +657,29 @@ export const DeveloperSettingsTab: FC<Props> = ({
   );
 };
 
-/**
- * The text shown in the custom transport field for a given setting value.
- */
+/** The text shown in the custom transport field for a given setting value. */
 function transportText(transport: UnstableLivekitTransport | null): string {
   return transport === null ? "" : JSON.stringify(transport);
 }
+
+const TransportBox: FC<TransportInfo> = ({ transport, local }) => {
+  const { t } = useTranslation();
+  const resolved = useBehavior(transport.resolved$);
+  return (
+    <div className={styles.livekit_room_box}>
+      <h4>{t("developer_mode.livekit_sfu", { url: transport.id })}</h4>
+      <p>
+        {t("developer_mode.livekit_server_info")}({local ? "local" : "remote"})
+      </p>
+      <pre className={styles.pre}>
+        {resolved === undefined
+          ? "not connected"
+          : JSON.stringify(
+              { ...resolved, token: resolved.token && "<redacted>" },
+              null,
+              2,
+            )}
+      </pre>
+    </div>
+  );
+};

src/settings/SettingsModal.tsx

@@ -9,7 +9,6 @@ import { type FC, type ReactNode, useEffect, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { type MatrixClient } from "matrix-js-sdk";
 import { Button, Root as Form, Separator } from "@vector-im/compound-web";
-import { type Room as LivekitRoom } from "livekit-client";
 
 import { Modal } from "../Modal";
 import styles from "./SettingsModal.module.css";
@@ -28,10 +27,11 @@ import {
 import { PreferencesSettingsTab } from "./PreferencesSettingsTab";
 import { Slider } from "../Slider";
 import { DeviceSelection } from "./DeviceSelection";
-import { useTrackProcessor } from "../livekit/TrackProcessorContext";
+import { useTrackProcessor } from "../tracks/TrackProcessorContext";
 import {
   DeveloperSettingsTab,
   type DeveloperSettingsSnapshot,
+  type TransportInfo,
 } from "./DeveloperSettingsTab";
 import { FieldRow, InputField } from "../input/Input";
 import { useSubmitRageshake } from "./submit-rageshake";
@@ -56,11 +56,8 @@ interface Props {
   onTabChange: (tab: SettingsTab) => void;
   client: MatrixClient;
   roomId?: string;
-  livekitRooms?: {
-    room: LivekitRoom;
-    url: string;
-    role: "publisher" | "subscriber";
-  }[];
+  /** The transports the client is connected to, while in a call. */
+  transports?: TransportInfo[];
   /** Only available while in a call. Used by the developer tab. */
   developerSettingsVm?: ViewModel<DeveloperSettingsSnapshot>;
 }
@@ -74,7 +71,7 @@ export const SettingsModal: FC<Props> = ({
   onTabChange,
   client,
   roomId,
-  livekitRooms,
+  transports,
   developerSettingsVm,
 }) => {
   const { t } = useTranslation();
@@ -227,7 +224,7 @@ export const SettingsModal: FC<Props> = ({
       <DeveloperSettingsTab
         env={import.meta.env}
         client={client}
-        livekitRooms={livekitRooms}
+        transports={transports}
         roomId={roomId}
         vm={developerSettingsVm ?? outOfCallDeveloperSettingsTabViewModel}
       />

src/settings/__snapshots__/DeveloperSettingsTab.test.tsx.snap

@@ -361,19 +361,8 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = `
     class="_livekit_room_box_2ddec4"
   >
     <h4>
-      LiveKit SFU: wss://local-sfu.example.org
+      LiveKit SFU: https://local-sfu.example.org/jwt
     </h4>
-    <p>
-      LivekitAlias: 
-      TestAlias
-    </p>
-    <p>
-      connectionState (wont hot reload): 
-    </p>
-    <p>
-      ws-url: 
-      wss://local-sfu.example.org/
-    </p>
     <p>
       LiveKit Server Info
       (
@@ -384,37 +373,20 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = `
       class="_pre_2ddec4"
     >
       {
-  "region": "local",
-  "version": "1.2.3"
+  "type": "livekit",
+  "token": "&lt;redacted&gt;",
+  "url": "wss://local-sfu.example.org",
+  "roomAlias": "TestAlias",
+  "identity": "localParticipantIdentity"
 }
-      local-metadata
     </pre>
-    <p>
-      Local Participant
-    </p>
-    <pre
-      class="_pre_2ddec4"
-    >
-      localParticipantIdentity
-    </pre>
-    <p>
-      Remote Participants
-    </p>
-    <ul />
   </div>
   <div
     class="_livekit_room_box_2ddec4"
   >
     <h4>
-      LiveKit SFU: wss://remote-sfu.example.org
+      LiveKit SFU: https://remote-sfu.example.org/jwt
     </h4>
-    <p>
-      LivekitAlias: 
-      TestAlias2
-    </p>
-    <p>
-      connectionState (wont hot reload): 
-    </p>
     <p>
       LiveKit Server Info
       (
@@ -424,24 +396,8 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = `
     <pre
       class="_pre_2ddec4"
     >
-      {
-  "region": "remote",
-  "version": "4.5.6"
-}
-      remote-metadata
+      not connected
     </pre>
-    <p>
-      Local Participant
-    </p>
-    <pre
-      class="_pre_2ddec4"
-    >
-      localParticipantIdentity
-    </pre>
-    <p>
-      Remote Participants
-    </p>
-    <ul />
   </div>
   <div
     class="_separator_13qwf_8"

src/state/Behavior.ts

@@ -1,29 +1,8 @@
 /*
-Copyright 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 { BehaviorSubject } from "rxjs";
-
-/**
- * A stateful, read-only reactive value. As an Observable, it is "hot" and
- * always replays the current value upon subscription.
- *
- * A Behavior is to BehaviorSubject what Observable is to Subject; it does not
- * provide a way to imperatively set new values. For more info on the
- * distinction between Behaviors and Observables, see
- * https://monoid.dk/post/behaviors-and-streams-why-both/.
- */
-export type Behavior<T> = Omit<
-  BehaviorSubject<T>,
-  "next" | "observers" | "error"
->;
-
-/**
- * Creates a Behavior which never changes in value.
- */
-export function constant<T>(value: T): Behavior<T> {
-  return new BehaviorSubject(value);
-}
+export { type Behavior, constant } from "@element-hq/matrixrtc-sdk";

src/state/CallViewModel/CallNotificationLifecycle.test.ts

@@ -27,7 +27,6 @@ import {
   createCallNotificationLifecycle$,
   type RingAttempt,
 } from "./CallNotificationLifecycle";
-import { Epoch, trackEpoch } from "../ObservableScope";
 import { constant } from "../Behavior";
 
 function mockRingEvent(
@@ -44,8 +43,8 @@ function mockRingEvent(
 }
 
 const defaultProps = {
-  memberships$: constant(new Epoch([])),
-  matrixRoomMembers$: constant(new Map([[alice.userId, alice]])),
+  memberUserIds$: constant<string[]>([]),
+  roomMemberUserIds$: constant([alice.userId]),
   receivedDecline$: NEVER,
   options: {
     waitForCallPickup: true,
@@ -122,7 +121,7 @@ test("ring attempt times out after nobody joins", () => {
       scope,
       ...defaultProps,
       // No one ever joins (only local user)
-      memberships$: constant(new Epoch([])),
+      memberUserIds$: constant<string[]>([]),
       sentCallNotification$: hot("-a", {
         a: mockRingEvent("$notif1", 30),
       }),
@@ -140,8 +139,8 @@ test("ring attempt is accepted once recipient joins", () => {
     const { ringAttempts$ } = createCallNotificationLifecycle$({
       scope,
       ...defaultProps,
-      memberships$: scope.behavior(
-        behavior("a-b", { a: [], b: [aliceRtcMember] }).pipe(trackEpoch()),
+      memberUserIds$: scope.behavior(
+        behavior("a-b", { a: [], b: [aliceRtcMember.userId] }),
       ),
       sentCallNotification$: hot("-a", {
         a: mockRingEvent("$notif1", 30),
@@ -160,7 +159,7 @@ test("ring attempt is immediately accepted if recipient is already joined", () =
     const { ringAttempts$ } = createCallNotificationLifecycle$({
       scope,
       ...defaultProps,
-      memberships$: constant(new Epoch([aliceRtcMember])),
+      memberUserIds$: constant([aliceRtcMember.userId]),
       sentCallNotification$: hot("-a", {
         a: mockRingEvent("$notif1", 30),
       }),

src/state/CallViewModel/CallNotificationLifecycle.ts

@@ -6,7 +6,6 @@ Please see LICENSE in the repository root for full details.
 */
 
 import {
-  type CallMembership,
   type IRTCNotificationContent,
   type MatrixRTCSession,
   MatrixRTCSessionEvent,
@@ -35,9 +34,7 @@ import {
 } from "matrix-js-sdk";
 import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
 
-import { type Behavior } from "../Behavior";
-import { type Epoch, type ObservableScope } from "../ObservableScope";
-import { type RoomMemberMap } from "./remoteMembers/MatrixMemberMetadata";
+import { type Behavior, type ObservableScope } from "@element-hq/matrixrtc-sdk";
 
 export type AutoLeaveReason = "allOthersLeft" | "timeout" | "decline";
 
@@ -81,8 +78,10 @@ export function createReceivedDecline$(
 
 export interface Props {
   scope: ObservableScope;
-  memberships$: Behavior<Epoch<CallMembership[]>>;
-  matrixRoomMembers$: Behavior<RoomMemberMap>;
+  /** The user ids of the session's members, ours included. */
+  memberUserIds$: Behavior<string[]>;
+  /** The user ids of the room's members, ours included. */
+  roomMemberUserIds$: Behavior<string[]>;
   sentCallNotification$: Observable<CallNotificationWrapper | null>;
   receivedDecline$: Observable<
     Parameters<EventTimelineSetHandlerMap[RoomEvent.Timeline]>
@@ -93,8 +92,8 @@ export interface Props {
 
 export function createCallNotificationLifecycle$({
   scope,
-  memberships$,
-  matrixRoomMembers$,
+  memberUserIds$,
+  roomMemberUserIds$,
   sentCallNotification$,
   receivedDecline$,
   options,
@@ -127,7 +126,7 @@ export function createCallNotificationLifecycle$({
       switchMap((notificationEvent) => {
         // We assume that there is only one other user in the room when ringing
         // TODO: Respect io.element.functional_members
-        const recipient = [...matrixRoomMembers$.value.keys()].find(
+        const recipient = roomMemberUserIds$.value.find(
           (userId) => userId !== localUser.userId,
         );
         if (recipient === undefined) {
@@ -140,8 +139,8 @@ export function createCallNotificationLifecycle$({
           map(() => "timeout" as const),
         );
         // Call is accepted when the recipient joins
-        const accept$ = memberships$.pipe(
-          filter((ms) => ms.value.some((m) => m.userId === recipient)),
+        const accept$ = memberUserIds$.pipe(
+          filter((userIds) => userIds.includes(recipient)),
           map(() => "accept" as const),
         );
         // Call is declined when we receive a decline event
@@ -171,12 +170,12 @@ export function createCallNotificationLifecycle$({
       scope.share,
     );
 
-  const allOthersLeft$ = memberships$.pipe(
+  const allOthersLeft$ = memberUserIds$.pipe(
     pairwise(),
     filter(
-      ([{ value: prev }, { value: current }]) =>
-        current.every((m) => m.userId === localUser.userId) &&
-        prev.some((m) => m.userId !== localUser.userId),
+      ([prev, current]) =>
+        current.every((userId) => userId === localUser.userId) &&
+        prev.some((userId) => userId !== localUser.userId),
     ),
     map(() => {}),
   );

src/state/CallViewModel/CallViewModel.test.ts

@@ -15,34 +15,23 @@ import {
   map,
   NEVER,
   type Observable,
-  of,
   switchMap,
 } from "rxjs";
-import { SyncState } from "matrix-js-sdk";
 import {
-  ConnectionState,
-  type LocalTrackPublication,
-  type Participant,
-  type RemoteParticipant,
-} from "livekit-client";
-import * as ComponentsCore from "@livekit/components-core";
-import {
-  Status,
   type CallMembership,
   type IRTCNotificationContent,
   MatrixRTCSessionEvent,
-  type UnstableLivekitTransport,
 } from "matrix-js-sdk/lib/matrixrtc";
 import { deepCompare } from "matrix-js-sdk/lib/utils";
 
 import { type Layout } from "../layout-types.ts";
 import {
   mockMatrixRoomMember,
+  mockMediaDevices,
   mockRemoteParticipant,
   withTestScheduler,
   mockRtcMembership,
   testScope,
-  exampleTransport,
 } from "../../utils/test.ts";
 import { E2eeType } from "../../e2ee/e2eeType.ts";
 import {
@@ -59,11 +48,15 @@ import {
   localRtcMember,
   localRtcMemberDevice2,
 } from "../../utils/test-fixtures.ts";
-import { MediaDevices } from "../MediaDevices.ts";
+import {
+  MediaDevices,
+  type SelectedAudioOutputDevice,
+} from "../MediaDevices.ts";
 import { getValue } from "../../utils/observable.ts";
 import { type Behavior, constant } from "../Behavior.ts";
 import {
   localParticipant,
+  type Participant,
   withCallViewModel as withCallViewModelInMode,
 } from "./CallViewModelTestUtils.ts";
 import { MatrixRTCMode } from "../../config/ConfigOptions.ts";
@@ -80,11 +73,6 @@ vi.mock("rxjs", async (importOriginal) => ({
   interval: (): Observable<number> => NEVER,
 }));
 
-vi.mock("@livekit/components-core");
-vi.mock("livekit-client/e2ee-worker?worker");
-
-vi.mock("../e2ee/matrixKeyProvider");
-
 const getPlatform = vi.hoisted(() => vi.fn(() => "desktop"));
 vi.mock("../../Platform", () => ({
   get platform(): string {
@@ -93,15 +81,6 @@ vi.mock("../../Platform", () => ({
   isFirefox: (): boolean => false,
 }));
 
-vi.mock(
-  "../state/CallViewModel/localMember/localTransport",
-  async (importOriginal) => ({
-    ...(await importOriginal()),
-    makeTransport: async (): Promise<UnstableLivekitTransport> =>
-      Promise.resolve(exampleTransport),
-  }),
-);
-
 const yesNo = {
   y: true,
   n: false,
@@ -262,6 +241,56 @@ const modes = [[MatrixRTCMode.Compatibility], [MatrixRTCMode.Matrix_2_0]];
 describe.each(modes)("CallViewModel (%s mode)", (mode) => {
   const withCallViewModel = withCallViewModelInMode(mode);
 
+  /** Media devices whose audio output the test selects. */
+  const withAudioOutput = (): {
+    mediaDevices: MediaDevices;
+    selected$: BehaviorSubject<SelectedAudioOutputDevice | undefined>;
+  } => {
+    const selected$ = new BehaviorSubject<
+      SelectedAudioOutputDevice | undefined
+    >(undefined);
+    const mediaDevices = mockMediaDevices({
+      audioOutput: {
+        available$: constant(new Map()),
+        selected$,
+        select: vi.fn(),
+      },
+    });
+    return { mediaDevices, selected$ };
+  };
+
+  test("the selected audio output is handed to the client as it changes", () => {
+    const { mediaDevices, selected$ } = withAudioOutput();
+    withCallViewModel(
+      { mediaDevices },
+      (_vm, _session, { rtcParticipation: participation }) => {
+        // Nothing selected yet, so the browser's choice stands
+        expect(participation.setAudioOutputDeviceId).not.toHaveBeenCalled();
+        selected$.next({ id: "speaker", virtualEarpiece: false });
+        expect(participation.setAudioOutputDeviceId).toHaveBeenCalledWith(
+          "speaker",
+        );
+        selected$.next({ id: "headphones", virtualEarpiece: false });
+        expect(participation.setAudioOutputDeviceId).toHaveBeenLastCalledWith(
+          "headphones",
+        );
+        expect(participation.setAudioOutputDeviceId).toHaveBeenCalledTimes(2);
+      },
+    );
+  });
+
+  test("a host that controls the audio devices keeps the output from the client", () => {
+    const { mediaDevices, selected$ } = withAudioOutput();
+    withCallViewModel(
+      { mediaDevices },
+      (_vm, _session, { rtcParticipation: participation }) => {
+        selected$.next({ id: "earpiece", virtualEarpiece: true });
+        expect(participation.setAudioOutputDeviceId).not.toHaveBeenCalled();
+      },
+      { controlledAudioDevices: true },
+    );
+  });
+
   test("participants are retained during a focus switch", () => {
     withTestScheduler(({ behavior, expectObservable }) => {
       // Participants disappear on frame 2 and come back on frame 3
@@ -278,10 +307,7 @@ describe.each(modes)("CallViewModel (%s mode)", (mode) => {
             b: [],
           }),
           rtcMembers$: constant([localRtcMember, aliceRtcMember, bobRtcMember]),
-          livekitConnectionState$: behavior(connectionInputMarbles, {
-            c: ConnectionState.Connected,
-            s: ConnectionState.Connecting,
-          }),
+          connected$: behavior(connectionInputMarbles, { c: true, s: false }),
         },
         (vm) => {
           expectObservable(summarizeLayout$(vm.layout$)).toBe(
@@ -1388,9 +1414,9 @@ describe.each(modes)("CallViewModel (%s mode)", (mode) => {
   function participantJoinLeave$(
     behavior: (
       marbles: string,
-      values: Record<string, RemoteParticipant[]>,
-    ) => Behavior<RemoteParticipant[]>,
-  ): Behavior<RemoteParticipant[]> {
+      values: Record<string, Participant[]>,
+    ) => Behavior<Participant[]>,
+  ): Behavior<Participant[]> {
     return behavior("a-b-c-d", {
       a: [], // Start empty
       b: [aliceParticipant], // Alice joins
@@ -1592,10 +1618,6 @@ describe.each(modes)("CallViewModel (%s mode)", (mode) => {
 
   it.skip("audio output changes when toggling earpiece mode", () => {
     withTestScheduler(({ schedule, expectObservable }) => {
-      vi.mocked(ComponentsCore.createMediaDeviceObserver).mockReturnValue(
-        of([]),
-      );
-
       const devices = new MediaDevices(testScope(), {
         controlledAudioDevices: true,
       });
@@ -1627,78 +1649,6 @@ describe.each(modes)("CallViewModel (%s mode)", (mode) => {
       });
     });
   });
-
-  it.skip("media tracks are paused while reconnecting to MatrixRTC", () => {
-    withTestScheduler(({ schedule, expectObservable }) => {
-      const trackRunning$ = new BehaviorSubject(true);
-      const originalPublications = localParticipant.trackPublications;
-      localParticipant.trackPublications = new Map([
-        [
-          "video",
-          {
-            track: new (class {
-              public get isUpstreamPaused(): boolean {
-                return !trackRunning$.value;
-              }
-              public async pauseUpstream(): Promise<void> {
-                trackRunning$.next(false);
-                return Promise.resolve();
-              }
-              public async resumeUpstream(): Promise<void> {
-                trackRunning$.next(true);
-                return Promise.resolve();
-              }
-            })(),
-          } as unknown as LocalTrackPublication,
-        ],
-      ]);
-      onTestFinished(() => {
-        localParticipant.trackPublications = originalPublications;
-      });
-
-      // There are three indicators that the client might be disconnected from
-      // MatrixRTC: whether the sync loop is connected, whether the membership is
-      // present in local room state, and whether the membership manager thinks
-      // we've hit the timeout for the delayed leave event. Let's test all
-      // combinations of these conditions.
-      const syncingMarbles = "             nyny----n--y";
-      const membershipStatusMarbles = "    y---ny-n-yn-y";
-      const probablyLeftMarbles = "        n-----y-ny---n";
-      const expectedReconnectingMarbles = "n-ynyny------n";
-      const expectedTrackRunningMarbles = "nynynyn------y";
-
-      withCallViewModel(
-        { initialSyncState: SyncState.Reconnecting },
-        (vm, rtcSession, _subjects, setSyncState) => {
-          schedule(syncingMarbles, {
-            y: () => setSyncState(SyncState.Syncing),
-            n: () => setSyncState(SyncState.Reconnecting),
-          });
-          schedule(membershipStatusMarbles, {
-            y: () => {
-              rtcSession.membershipStatus = Status.Connected;
-            },
-          });
-          schedule(probablyLeftMarbles, {
-            y: () => {
-              rtcSession.probablyLeft = true;
-            },
-            n: () => {
-              rtcSession.probablyLeft = false;
-            },
-          });
-          expectObservable(vm.reconnecting$).toBe(
-            expectedReconnectingMarbles,
-            yesNo,
-          );
-          expectObservable(trackRunning$).toBe(
-            expectedTrackRunningMarbles,
-            yesNo,
-          );
-        },
-      );
-    });
-  });
 });
 
 describe("callViewModelOptionsFromParams", () => {
@@ -1709,33 +1659,8 @@ describe("callViewModelOptionsFromParams", () => {
   const widgetUrl = (extra: string): string =>
     `#?widgetId=id&parentUrl=${encodeURIComponent("http://parent")}&${extra}`;
 
-  it("carries an explicitly requested notification type", () => {
-    const params = computeUrlParams("", widgetUrl("sendNotificationType=ring"));
-    expect(callViewModelOptionsFromParams(params).sendNotificationType).toBe(
-      "ring",
-    );
-  });
-
-  it("carries the notification type an intent implies", () => {
-    const params = computeUrlParams("", widgetUrl("intent=start_call_dm"));
-    expect(callViewModelOptionsFromParams(params).sendNotificationType).toBe(
-      "ring",
-    );
-  });
-
   it("carries hideScreensharing", () => {
     const params = computeUrlParams("", widgetUrl("hideScreensharing=true"));
     expect(callViewModelOptionsFromParams(params).hideScreensharing).toBe(true);
   });
-
-  it("carries controlledAudioDevices and the call intent", () => {
-    const params = computeUrlParams(
-      "",
-      widgetUrl("controlledAudioDevices=true&intent=start_call_voice"),
-    );
-    expect(callViewModelOptionsFromParams(params)).toMatchObject({
-      controlledAudioDevices: true,
-      callIntent: "audio",
-    });
-  });
 });

src/state/CallViewModel/CallViewModelTestUtils.ts

@@ -7,39 +7,41 @@ Please see LICENSE in the repository root for full details.
 */
 
 import {
-  ConnectionState,
-  type Participant,
-  ParticipantEvent,
-  type RemoteParticipant,
-  type Room as LivekitRoom,
-  type TrackPublication,
-} from "livekit-client";
+  type Behavior,
+  constant,
+  E2eeType,
+  type LocalRTCMember,
+  type ParticipationState,
+  type RTCParticipation,
+  type MatrixRTCMode,
+  type ObservableScope,
+  type RemoteRTCMember,
+} from "@element-hq/matrixrtc-sdk";
 import { SyncState } from "matrix-js-sdk/lib/sync";
-import { BehaviorSubject, combineLatest, map, of } from "rxjs";
-import { onTestFinished, vi } from "vitest";
+import { BehaviorSubject, map, of, switchMap } from "rxjs";
 import { ClientEvent, type RoomMember, type MatrixClient } from "matrix-js-sdk";
 import EventEmitter from "events";
-import * as ComponentsCore from "@livekit/components-core";
 
 import type { CallMembership } from "matrix-js-sdk/lib/matrixrtc";
-import { E2eeType } from "../../e2ee/e2eeType";
 import { type RaisedHandInfo, type ReactionInfo } from "../../reactions";
 import {
   type CallViewModel,
   createCallViewModel$,
   type CallViewModelOptions,
 } from "./CallViewModel";
+import { createSentCallNotification$ } from "./CallNotificationLifecycle";
 import {
-  exampleTransportLocator,
   mockConfig,
-  MockConnection,
-  mockLivekitRoom,
-  mockLocalParticipant,
   mockMatrixRoom,
   mockMatrixRoomMember,
+  mockRTCParticipation,
+  mockAudioTrack,
   mockMediaDevices,
+  mockVideoTrack,
+  type MockTracks,
   mockMuteStates,
   MockRTCSession,
+  mockRTCMember,
   testScope,
 } from "../../utils/test";
 import {
@@ -52,10 +54,7 @@ import {
   local,
   localRtcMember,
 } from "../../utils/test-fixtures";
-import { type Behavior, constant } from "../Behavior";
-import { type ProcessorState } from "../../livekit/TrackProcessorContext";
 import { type MediaDevices } from "../MediaDevices";
-import { type MatrixRTCMode } from "../../config/ConfigOptions";
 
 mockConfig({
   livekit: { livekit_service_url: "http://my-default-service-url.com" },
@@ -65,11 +64,18 @@ const carol = local;
 
 const dave = mockMatrixRoomMember(daveRTLRtcMember, { rawDisplayName: "Dave" });
 
+/** Whoever publishes media: a stand-in for a LiveKit participant, by identity. */
+export interface Participant {
+  identity: string;
+}
+
 export interface CallViewModelInputs {
-  remoteParticipants$: Behavior<RemoteParticipant[]>;
+  /** The members whose media has arrived. The local member's always has. */
+  remoteParticipants$: Behavior<Participant[]>;
   rtcMembers$: Behavior<Partial<CallMembership>[]>;
   roomMembers: RoomMember[];
-  livekitConnectionState$: Behavior<ConnectionState>;
+  /** Whether the local transport is connected. */
+  connected$: Behavior<boolean>;
   speaking: Map<Participant, Behavior<boolean>>;
   videoEnabled: Map<Participant, Behavior<boolean>>;
   sharingScreen: Map<Participant, Behavior<boolean>>;
@@ -78,7 +84,7 @@ export interface CallViewModelInputs {
   windowSize$: Behavior<{ width: number; height: number }>;
 }
 
-export const localParticipant = mockLocalParticipant({ identity: "" });
+export const localParticipant: Participant = { identity: "" };
 
 export function withCallViewModel(mode: MatrixRTCMode) {
   return (
@@ -94,9 +100,7 @@ export function withCallViewModel(mode: MatrixRTCMode) {
         dave,
         daveRTL,
       ],
-      livekitConnectionState$: connectionState$ = constant(
-        ConnectionState.Connected,
-      ),
+      connected$ = constant(true),
       speaking = new Map(),
       videoEnabled = new Map(),
       sharingScreen = new Map(),
@@ -109,6 +113,8 @@ export function withCallViewModel(mode: MatrixRTCMode) {
       rtcSession: MockRTCSession,
       subjects: {
         raisedHands$: BehaviorSubject<Record<string, RaisedHandInfo>>;
+        /** The participation the view model was built on, with spies for its calls. */
+        rtcParticipation: RTCParticipation;
       },
       setSyncState: (value: SyncState) => void,
     ) => void,
@@ -122,8 +128,6 @@ export function withCallViewModel(mode: MatrixRTCMode) {
     };
     const room = mockMatrixRoom({
       client: new (class extends EventEmitter {
-        public readonly baseUrl = "https://matrix.example.com";
-
         public getUserId(): string | undefined {
           return localRtcMember.userId;
         }
@@ -146,114 +150,141 @@ export function withCallViewModel(mode: MatrixRTCMode) {
     const rtcSession = new MockRTCSession(room, []).withMemberships(
       rtcMembers$,
     );
-    const participantsSpy = vi
-      .spyOn(ComponentsCore, "connectedParticipantsObserver")
-      .mockReturnValue(remoteParticipants$);
-    const mediaSpy = vi
-      .spyOn(ComponentsCore, "observeParticipantMedia")
-      .mockImplementation((p) => {
-        return (videoEnabled.get(p) ?? constant(false)).pipe(
-          map((videoEnabled) => ({
-            participant: p,
-            isMicrophoneEnabled: false,
-            isCameraEnabled: videoEnabled,
-            isScreenShareEnabled: false,
-            cameraTrack: {
-              isMuted: !videoEnabled,
-            } as unknown as TrackPublication,
-          })),
-        );
-      });
-    const eventsSpy = vi
-      .spyOn(ComponentsCore, "observeParticipantEvents")
-      .mockImplementation((p, ...eventTypes) => {
-        return combineLatest([
-          (eventTypes.includes(ParticipantEvent.IsSpeakingChanged) &&
-            speaking.get(p)) ||
-            constant(false),
-          (eventTypes.includes(ParticipantEvent.TrackPublished) &&
-            sharingScreen.get(p)) ||
-            constant(false),
-        ]).pipe(
-          map(
-            ([isSpeaking, isScreenShareEnabled]) =>
-              ({ ...p, isSpeaking, isScreenShareEnabled }) as Participant,
-          ),
-        );
-      });
+    const scope = testScope();
 
-    const roomEventSelectorSpy = vi
-      .spyOn(ComponentsCore, "roomEventSelector")
-      .mockImplementation((_room, _eventType) => of());
+    const tracksOf = (
+      scope: ObservableScope,
+      participant: Participant,
+    ): Behavior<MockTracks> => {
+      // A microphone and a camera are always published; the screen share
+      // comes and goes
+      const microphone = mockAudioTrack({
+        isActive$: speaking.get(participant) ?? constant(false),
+      });
+      const camera = mockVideoTrack({
+        source: "camera",
+        muted$: scope.behavior(
+          (videoEnabled.get(participant) ?? constant(false)).pipe(
+            map((enabled) => !enabled),
+          ),
+        ),
+      });
+      const screenShare = mockVideoTrack({ source: "screenShare" });
+      return scope.behavior(
+        (sharingScreen.get(participant) ?? constant(false)).pipe(
+          map((sharing) =>
+            sharing ? [microphone, camera, screenShare] : [microphone, camera],
+          ),
+        ),
+      );
+    };
+    const participantOf = (
+      scope: ObservableScope,
+      membership: CallMembership,
+    ): Behavior<Participant | undefined> =>
+      scope.behavior(
+        remoteParticipants$.pipe(
+          map((participants) =>
+            participants.find(
+              (p) => p.identity === membership.rtcBackendIdentity,
+            ),
+          ),
+        ),
+      );
+    const memberOf = (
+      scope: ObservableScope,
+      membership: CallMembership,
+    ): RemoteRTCMember =>
+      mockRTCMember(false, {
+        membership,
+        roomMember: roomMembers.find((m) => m.userId === membership.userId),
+        transportUrl: "http://my-default-service-url.com",
+        tracks$: scope.behavior(
+          participantOf(scope, membership).pipe(
+            switchMap((participant) =>
+              participant === undefined
+                ? of(null)
+                : tracksOf(scope, participant),
+            ),
+          ),
+        ),
+      });
+    const remoteMembers$ = scope.behavior<RemoteRTCMember[]>(
+      rtcMembers$.pipe(
+        map((memberships) =>
+          (memberships as CallMembership[])
+            .filter(
+              (m) =>
+                m.userId !== localRtcMember.userId ||
+                m.deviceId !== localRtcMember.deviceId,
+            )
+            .map((membership) => memberOf(scope, membership)),
+        ),
+      ),
+    );
+    const localMember$ = scope.behavior<LocalRTCMember | null>(
+      rtcMembers$.pipe(
+        map((memberships) =>
+          (memberships as CallMembership[]).some(
+            (m) =>
+              m.userId === localRtcMember.userId &&
+              m.deviceId === localRtcMember.deviceId,
+          )
+            ? mockRTCMember(true, {
+                membership: localRtcMember,
+                roomMember: carol,
+                transportUrl: "http://my-default-service-url.com",
+                tracks$: tracksOf(scope, localParticipant),
+              })
+            : null,
+        ),
+      ),
+    );
+    const rtcParticipation = mockRTCParticipation(scope, {
+      localMember$,
+      remoteMembers$,
+      state$: scope.behavior(
+        connected$.pipe(
+          map((connected): ParticipationState =>
+            connected
+              ? { kind: "connected" }
+              : { kind: "reconnecting", reason: "media" },
+          ),
+        ),
+      ),
+    });
     const muteStates = mockMuteStates();
     const raisedHands$ = new BehaviorSubject<Record<string, RaisedHandInfo>>(
       {},
     );
     const reactions$ = new BehaviorSubject<Record<string, ReactionInfo>>({});
 
-    const livekitRoomFactory = (): LivekitRoom =>
-      mockLivekitRoom({
-        localParticipant,
-        disconnect: async () => Promise.resolve(),
-        setE2EEEnabled: async () => Promise.resolve(),
-      });
-
     const vm = createCallViewModel$(
-      testScope(),
-      rtcSession.asMockedSession(),
+      scope,
+      rtcParticipation,
       room,
       mediaDevices,
       muteStates,
       {
         encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
         autoLeaveWhenOthersLeft: false,
-        livekitRoomFactory,
-        connectionState$,
+        sentCallNotification$: createSentCallNotification$(
+          scope,
+          rtcSession.asMockedSession(),
+        ),
         windowSize$,
-        localTransport: exampleTransportLocator,
-        connectionFactory: {
-          createConnection(
-            scope,
-            role,
-            transport,
-            serverName,
-            ownMembershipIdentity,
-            logger,
-          ) {
-            return new MockConnection(
-              {
-                scope,
-                role,
-                transport,
-                serverName,
-                ownMembershipIdentity,
-                client: room.client,
-                roomId: room.roomId,
-                slotId: "m.call#ROOM",
-                livekitRoomFactory,
-              },
-              logger,
-            );
-          },
-        },
-        matrixRTCMode: mode,
         ...options,
       },
       raisedHands$,
       reactions$,
-      new BehaviorSubject<ProcessorState>({
-        processor: undefined,
-        supported: undefined,
-      }),
     );
+    void mode;
 
-    onTestFinished(() => {
-      participantsSpy.mockRestore();
-      mediaSpy.mockRestore();
-      eventsSpy.mockRestore();
-      roomEventSelectorSpy.mockRestore();
-    });
-
-    continuation(vm, rtcSession, { raisedHands$: raisedHands$ }, setSyncState);
+    continuation(
+      vm,
+      rtcSession,
+      { raisedHands$, rtcParticipation },
+      setSyncState,
+    );
   };
 }

src/state/CallViewModel/localMember/HomeserverConnected.test.ts

@@ -1,336 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-Copyright 2024 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { EventEmitter } from "events";
-import { ClientEvent, SyncState } from "matrix-js-sdk";
-import { MembershipManagerEvent, Status } from "matrix-js-sdk/lib/matrixrtc";
-
-import { ObservableScope } from "../../ObservableScope";
-import { createHomeserverConnected$ } from "./HomeserverConnected";
-import { testScope, withTestScheduler } from "../../../utils/test";
-
-/**
- * Minimal stub of a Matrix client sufficient for our tests:
- ```
-  createHomeserverConnected$(
-     scope: ObservableScope,
-     client: NodeStyleEventEmitter & Pick<MatrixClient, "getSyncState">,
-     matrixRTCSession: NodeStyleEventEmitter &
-       Pick<MatrixRTCSession, "membershipStatus" | "probablyLeft">,
- )
- ```
- */
-class MockMatrixClient extends EventEmitter {
-  private syncState: SyncState;
-  public constructor(initial: SyncState) {
-    super();
-    this.syncState = initial;
-  }
-  public setSyncState(state: SyncState): void {
-    this.syncState = state;
-    // Matrix's Sync event in createHomeserverConnected$ expects [SyncState]
-    this.emit(ClientEvent.Sync, [state]);
-  }
-  public getSyncState(): SyncState {
-    return this.syncState;
-  }
-}
-
-/**
- * Minimal stub of MatrixRTCSession (membership manager):
- ```
-  createHomeserverConnected$(
-     scope: ObservableScope,
-     client: NodeStyleEventEmitter & Pick<MatrixClient, "getSyncState">,
-     matrixRTCSession: NodeStyleEventEmitter &
-       Pick<MatrixRTCSession, "membershipStatus" | "probablyLeft">,
- )
- ```
- */
-class MockMatrixRTCSession extends EventEmitter {
-  public membershipStatus: Status;
-  public probablyLeft: boolean;
-
-  public constructor(props: {
-    membershipStatus: Status;
-    probablyLeft: boolean;
-  }) {
-    super();
-    this.membershipStatus = props.membershipStatus;
-    this.probablyLeft = props.probablyLeft;
-  }
-
-  public setMembershipStatus(status: Status): void {
-    this.membershipStatus = status;
-    this.emit(MembershipManagerEvent.StatusChanged);
-  }
-
-  public setProbablyLeft(flag: boolean): void {
-    this.probablyLeft = flag;
-    this.emit(MembershipManagerEvent.ProbablyLeft);
-  }
-}
-
-describe("createHomeserverConnected$", () => {
-  let scope: ObservableScope;
-  let client: MockMatrixClient;
-  let session: MockMatrixRTCSession;
-
-  beforeEach(() => {
-    scope = new ObservableScope();
-    client = new MockMatrixClient(SyncState.Error); // start disconnected
-    session = new MockMatrixRTCSession({
-      membershipStatus: Status.Disconnected,
-      probablyLeft: false,
-    });
-  });
-
-  afterEach(() => {
-    scope.end();
-  });
-
-  // LLM generated test cases. They are a bit overkill but I improved the mocking so it is
-  // easy enough to read them so I think they can stay.
-  // Note: gracePeriodMs is set to 0 to avoid debouncing delays in tests
-  it("reports syncing reason when sync state is not Syncing", () => {
-    const hsConnected = createHomeserverConnected$(scope, client, session, 0);
-    expect(hsConnected.combined$.value).toEqual([false, "sync"]);
-  });
-
-  it("reports membership reason when sync is Syncing but membership is not Connected", () => {
-    const hsConnected = createHomeserverConnected$(scope, client, session, 0);
-    client.setSyncState(SyncState.Syncing);
-    expect(hsConnected.combined$.value).toEqual([false, "membership"]);
-  });
-
-  it("reports probablyLeft reason when membership transitions to Connected but ProbablyLeft is true", () => {
-    const hsConnected = createHomeserverConnected$(scope, client, session, 0);
-    // Make sync loop OK
-    client.setSyncState(SyncState.Syncing);
-    // Indicate probable leave before connection
-    session.setProbablyLeft(true);
-    session.setMembershipStatus(Status.Connected);
-    expect(hsConnected.combined$.value).toEqual([false, "probablyLeft"]);
-  });
-
-  it("becomes null (connected) only when all three conditions are satisfied", () => {
-    const hsConnected = createHomeserverConnected$(scope, client, session, 0);
-    // 1. Sync loop connected
-    client.setSyncState(SyncState.Syncing);
-    expect(hsConnected.combined$.value).toEqual([false, "membership"]); // not yet membership connected
-    // 2. Membership connected
-    session.setMembershipStatus(Status.Connected);
-    expect(hsConnected.combined$.value).toEqual([true, null]); // probablyLeft is false
-  });
-
-  it("returns syncing reason when sync loop leaves Syncing", () => {
-    const hsConnected = createHomeserverConnected$(scope, client, session, 0);
-    // Reach connected state
-    client.setSyncState(SyncState.Syncing);
-    session.setMembershipStatus(Status.Connected);
-    expect(hsConnected.combined$.value).toEqual([true, null]);
-
-    // Sync loop error => should report syncing reason
-    client.setSyncState(SyncState.Error);
-    expect(hsConnected.combined$.value).toEqual([false, "sync"]);
-  });
-
-  it("returns membershipConnected reason when membership status becomes disconnected", () => {
-    const hsConnected = createHomeserverConnected$(scope, client, session, 0);
-    client.setSyncState(SyncState.Syncing);
-    session.setMembershipStatus(Status.Connected);
-    expect(hsConnected.combined$.value).toEqual([true, null]);
-
-    session.setMembershipStatus(Status.Disconnected);
-    expect(hsConnected.combined$.value).toEqual([false, "membership"]);
-  });
-
-  it("returns certainlyConnected reason when ProbablyLeft is emitted", () => {
-    const hsConnected = createHomeserverConnected$(scope, client, session, 0);
-    client.setSyncState(SyncState.Syncing);
-    session.setMembershipStatus(Status.Connected);
-    expect(hsConnected.combined$.value).toEqual([true, null]);
-
-    session.setProbablyLeft(true);
-    expect(hsConnected.combined$.value).toEqual([false, "probablyLeft"]);
-  });
-
-  it("recovers to null (connected) if ProbablyLeft becomes false again while other conditions remain true", () => {
-    const hsConnected = createHomeserverConnected$(scope, client, session, 0);
-    client.setSyncState(SyncState.Syncing);
-    session.setMembershipStatus(Status.Connected);
-    expect(hsConnected.combined$.value).toEqual([true, null]);
-
-    session.setProbablyLeft(true);
-    expect(hsConnected.combined$.value).toEqual([false, "probablyLeft"]);
-
-    // Simulate clearing the flag (in realistic scenario membership manager would update)
-    session.setProbablyLeft(false);
-    expect(hsConnected.combined$.value).toEqual([true, null]);
-  });
-
-  it("composite sequence reflects each individual failure reason", () => {
-    const hsConnected = createHomeserverConnected$(scope, client, session, 0);
-
-    // Initially: sync error + membership disconnected → syncing wins (highest priority)
-    expect(hsConnected.combined$.value).toEqual([false, "sync"]);
-
-    // Fix sync only → membershipConnected is now the blocker
-    client.setSyncState(SyncState.Syncing);
-    expect(hsConnected.combined$.value).toEqual([false, "membership"]);
-
-    // Fix membership → all conditions satisfied
-    session.setMembershipStatus(Status.Connected);
-    expect(hsConnected.combined$.value).toEqual([true, null]);
-
-    // Introduce probablyLeft → certainlyConnected
-    session.setProbablyLeft(true);
-    expect(hsConnected.combined$.value).toEqual([false, "probablyLeft"]);
-
-    // Restore notProbablyLeft → connected again
-    session.setProbablyLeft(false);
-    expect(hsConnected.combined$.value).toEqual([true, null]);
-
-    // Drop sync → syncing reason
-    client.setSyncState(SyncState.Error);
-    expect(hsConnected.combined$.value).toEqual([false, "sync"]);
-  });
-});
-
-describe("createHomeserverConnected$ - combined$ reason values", () => {
-  let scope: ObservableScope;
-  let client: MockMatrixClient;
-  let session: MockMatrixRTCSession;
-
-  beforeEach(() => {
-    scope = new ObservableScope();
-    // Start with sync failing and membership disconnected
-    client = new MockMatrixClient(SyncState.Error);
-    session = new MockMatrixRTCSession({
-      membershipStatus: Status.Disconnected,
-      probablyLeft: false,
-    });
-  });
-
-  afterEach(() => {
-    scope.end();
-  });
-
-  it("is [true, null] when all three conditions are satisfied", () => {
-    const { combined$ } = createHomeserverConnected$(scope, client, session, 0);
-    client.setSyncState(SyncState.Syncing);
-    session.setMembershipStatus(Status.Connected);
-    expect(combined$.value).toEqual([true, null]);
-  });
-
-  it("reports syncing when sync loop is not Syncing", () => {
-    const { combined$ } = createHomeserverConnected$(scope, client, session, 0);
-    // client starts with SyncState.Error, membership also disconnected
-    expect(combined$.value).toEqual([false, "sync"]);
-  });
-
-  it("reports membershipConnected when sync is fine but membership is not Connected", () => {
-    const { combined$ } = createHomeserverConnected$(scope, client, session, 0);
-    client.setSyncState(SyncState.Syncing);
-    // session still Status.Disconnected
-    expect(combined$.value).toEqual([false, "membership"]);
-  });
-
-  it("reports certainlyConnected when probablyLeft is true", () => {
-    const { combined$ } = createHomeserverConnected$(scope, client, session, 0);
-    client.setSyncState(SyncState.Syncing);
-    session.setMembershipStatus(Status.Connected);
-    session.setProbablyLeft(true);
-    expect(combined$.value).toEqual([false, "probablyLeft"]);
-  });
-
-  it("prioritises syncing over membershipConnected when both fail", () => {
-    const { combined$ } = createHomeserverConnected$(scope, client, session, 0);
-    // Both sync (Error) and membership (Disconnected) are failing
-    expect(combined$.value).toEqual([false, "sync"]);
-  });
-
-  it("updates reason as conditions change", () => {
-    const { combined$ } = createHomeserverConnected$(scope, client, session, 0);
-    // Initially: syncing fails
-    expect(combined$.value).toEqual([false, "sync"]);
-
-    // Fix sync → membershipConnected is now the blocker
-    client.setSyncState(SyncState.Syncing);
-    expect(combined$.value).toEqual([false, "membership"]);
-
-    // Fix membership → probablyLeft makes certainlyConnected fail
-    session.setProbablyLeft(true);
-    session.setMembershipStatus(Status.Connected);
-    expect(combined$.value).toEqual([false, "probablyLeft"]);
-
-    // Clear probablyLeft → all conditions satisfied
-    session.setProbablyLeft(false);
-    expect(combined$.value).toEqual([true, null]);
-  });
-});
-
-describe("createHomeserverConnected$ - Grace Period", () => {
-  const GRACE_PERIOD = 5;
-
-  function marbleTest(
-    syncStateMarbles: string,
-    expectedConnectedMarbles: string,
-  ): void {
-    withTestScheduler(({ behavior, schedule, expectObservable }) => {
-      const syncState$ = behavior(syncStateMarbles, {
-        s: SyncState.Syncing,
-        e: SyncState.Error,
-      });
-      const client = new MockMatrixClient(syncState$.value);
-      schedule(syncStateMarbles, {
-        s: () => client.setSyncState(SyncState.Syncing),
-        e: () => client.setSyncState(SyncState.Error),
-      });
-      const session = new MockMatrixRTCSession({
-        membershipStatus: Status.Connected,
-        probablyLeft: false,
-      });
-      const hsConnected = createHomeserverConnected$(
-        testScope(),
-        client,
-        session,
-        GRACE_PERIOD,
-      );
-      expectObservable(hsConnected.combined$).toBe(expectedConnectedMarbles, {
-        y: [true, null],
-        n: [false, "sync"],
-      });
-    });
-  }
-
-  it("respects gracePeriodMs: stays true during grace period and flips false after", () => {
-    // - Initial state: Everything is connected
-    // - Sync error occurs -> should remain connected due to grace period
-    // - After grace period, not connected
-    marbleTest("se", "y-----n");
-    // If the sync error takes longer to occur, it should take equally long for
-    // the connection state to change
-    marbleTest("s--e", "y-------n");
-  });
-
-  it("recovers immediately if sync returns during grace period", () => {
-    // - Initial state: Connected
-    // - Sync error occurs
-    // - Sync recovers BEFORE the grace period expires
-    // - Connection state remains constant
-    marbleTest("se--s", "y");
-  });
-
-  it("flips to true IMMEDIATELY even if a grace period was pending", () => {
-    // - Initial error: connection eventually flips to false
-    // - Back to Syncing -> Must be connected immediately (synchronously)
-    marbleTest("e-----s", "y----ny");
-  });
-});

src/state/CallViewModel/localMember/HomeserverConnected.ts

@@ -1,136 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-Copyright 2024 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import {
-  MembershipManagerEvent,
-  Status,
-  type MatrixRTCSession,
-} from "matrix-js-sdk/lib/matrixrtc";
-import { ClientEvent, type MatrixClient, SyncState } from "matrix-js-sdk";
-import {
-  fromEvent,
-  startWith,
-  map,
-  tap,
-  type Observable,
-  distinctUntilChanged,
-  switchMap,
-  of,
-  delay,
-  combineLatest,
-} from "rxjs";
-import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
-
-import { Config } from "../../../config/Config";
-import { type ObservableScope } from "../../ObservableScope";
-import { type Behavior } from "../../Behavior";
-import { type NodeStyleEventEmitter } from "../../../utils/test";
-
-export type HomeserverDisconnectReason = "sync" | "membership" | "probablyLeft";
-
-export interface HomeserverConnected {
-  /**
-   * Emits `[true, null]` when the homeserver connection is healthy, or
-   * `[false, reason]` when one of the three sub-conditions fails.
-   */
-  combined$: Behavior<[boolean, HomeserverDisconnectReason | null]>;
-  rtsSession$: Behavior<Status>;
-}
-
-/**
- * Behavior representing whether we consider ourselves connected to the Matrix homeserver
- * for the purposes of a MatrixRTC session.
- *
- * `combined$` emits `null` when all conditions are satisfied, or the first failing
- * reason (priority: syncing > membershipConnected > certainlyConnected):
- * 1. Sync loop is not in SyncState.Syncing (after grace period) → "sync"
- * 2. membershipStatus !== Status.Connected → "membership"
- * 3. probablyLeft === true → "probablyLeft"
- *
- * @param scope - The observable scope for lifecycle management.
- * @param client - The Matrix client to monitor sync state.
- * @param matrixRTCSession - The RTC session to monitor membership.
- * @param gracePeriodMs - Grace period in milliseconds to wait before reporting sync disconnect.
- *                        If not provided, uses the config value (default 10000ms).
- */
-export function createHomeserverConnected$(
-  scope: ObservableScope,
-  client: NodeStyleEventEmitter & Pick<MatrixClient, "getSyncState">,
-  matrixRTCSession: NodeStyleEventEmitter &
-    Pick<MatrixRTCSession, "membershipStatus" | "probablyLeft">,
-  gracePeriodMs?: number,
-): HomeserverConnected {
-  const logger = rootLogger.getChild("[HomeserverConnected]");
-  // Get grace period from parameter or config (default 10000ms)
-  const graceMs = gracePeriodMs ?? Config.get().sync_disconnect_grace_period_ms;
-
-  const syncing$ = (
-    fromEvent(client, ClientEvent.Sync) as Observable<[SyncState]>
-  ).pipe(
-    startWith([client.getSyncState()]),
-    map(([state]) => state === SyncState.Syncing),
-    distinctUntilChanged(),
-    switchMap((isSyncing) => {
-      if (isSyncing || graceMs <= 0) {
-        return of(isSyncing);
-      }
-      return of(false).pipe(delay(graceMs), startWith(true));
-    }),
-    distinctUntilChanged(),
-  );
-
-  const rtsSession$ = scope.behavior<Status>(
-    fromEvent(matrixRTCSession, MembershipManagerEvent.StatusChanged).pipe(
-      map(() => matrixRTCSession.membershipStatus ?? Status.Unknown),
-    ),
-    matrixRTCSession.membershipStatus ?? Status.Unknown,
-  );
-
-  const membershipConnected$ = rtsSession$.pipe(
-    map((status) => status === Status.Connected),
-  );
-
-  // This is basically notProbablyLeft$
-  //
-  // probablyLeft is computed by a local timer that mimics the server delayed event.
-  // If we locally predict our server event timed out. We consider ourselves as probablyLeft
-  // even though we might not yet have received the delayed event leave.
-  //
-  // If that is not the case we certainly still have a valid membership on the matrix network
-  // independet if the sync currently works.
-  const certainlyConnected$ = fromEvent(
-    matrixRTCSession,
-    MembershipManagerEvent.ProbablyLeft,
-  ).pipe(
-    startWith(null),
-    map(() => matrixRTCSession.probablyLeft !== true),
-  );
-
-  const combined$ = scope.behavior(
-    combineLatest([syncing$, membershipConnected$, certainlyConnected$]).pipe(
-      map(
-        ([syncing, membership, certainly]): [
-          boolean,
-          HomeserverDisconnectReason | null,
-        ] => {
-          if (!syncing) return [false, "sync"];
-          if (!membership) return [false, "membership"];
-          if (!certainly) return [false, "probablyLeft"];
-          return [true, null];
-        },
-      ),
-      tap(([connected, reason]) => {
-        logger.info(
-          `Homeserver connected update: ${connected ? "connected" : reason}`,
-        );
-      }),
-    ),
-  );
-
-  return { combined$, rtsSession$ };
-}

src/state/CallViewModel/localMember/LocalMember.test.ts

@@ -1,920 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-Copyright 2024 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import {
-  Status as RTCMemberStatus,
-  type UnstableLivekitTransport,
-  type MatrixRTCSession,
-} from "matrix-js-sdk/lib/matrixrtc";
-import {
-  describe,
-  expect,
-  it,
-  vi,
-  beforeAll,
-  afterAll,
-  beforeEach,
-  afterEach,
-} from "vitest";
-import { BehaviorSubject, of, Subject } from "rxjs";
-import { logger } from "matrix-js-sdk/lib/logger";
-import {
-  ConnectionState as LivekitConnectionState,
-  type LocalParticipant,
-  type LocalTrack,
-} from "livekit-client";
-import fetchMock from "fetch-mock";
-
-import { PosthogAnalytics } from "../../../analytics/PosthogAnalytics";
-import {
-  MatrixRTCMode,
-  type ResolvedDelayedLeaveTimings,
-} from "../../../config/ConfigOptions";
-import { type HomeserverDisconnectReason } from "./HomeserverConnected";
-import {
-  flushPromises,
-  mockConfig,
-  mockLivekitRoom,
-  mockLocalParticipant,
-  mockMuteStates,
-  withTestScheduler,
-  ownMemberMock,
-  testScope,
-} from "../../../utils/test";
-import {
-  TransportState,
-  createLocalMembership$,
-  enterRTCSession,
-  PublishState,
-  TrackState,
-  watchScreenShareToggle,
-} from "./LocalMember";
-import { MatrixRTCTransportMissingError } from "../../../utils/errors";
-import { Epoch, ObservableScope } from "../../ObservableScope";
-import { constant } from "../../Behavior";
-import { ConnectionMap } from "../remoteMembers/ConnectionMap";
-import {
-  type ConnectionState,
-  type Connection,
-} from "../remoteMembers/Connection";
-import { type Publisher } from "./Publisher";
-import { initializeWidget } from "../../../widget";
-import { nullHostBridge } from "../../../HostBridge";
-import * as livekitAuth from "../../../livekit/auth";
-
-initializeWidget();
-
-const MATRIX_RTC_MODE = MatrixRTCMode.Compatibility;
-const getUrlParams = vi.hoisted(() => vi.fn(() => ({})));
-vi.mock("../../../UrlParams", () => ({ getUrlParams }));
-vi.mock("@livekit/components-core", () => ({
-  observeParticipantEvents: vi
-    .fn()
-    .mockReturnValue(of({ isScreenShareEnabled: false })),
-}));
-
-describe("watchScreenShareToggle", () => {
-  it("reports nothing when the toggle completes", async () => {
-    const onError = vi.fn();
-    watchScreenShareToggle(Promise.resolve(), true, logger, onError);
-    await flushPromises();
-    expect(onError).not.toHaveBeenCalled();
-  });
-
-  it("reports failures other than the user cancelling", async () => {
-    const onError = vi.fn();
-    const e = new Error("NotReadableError");
-    watchScreenShareToggle(Promise.reject(e), true, logger, onError);
-    await flushPromises();
-    expect(onError).toHaveBeenCalledWith(e);
-  });
-
-  it("does not report the user cancelling the picker", async () => {
-    const onError = vi.fn();
-    const cancelled = new DOMException("Permission denied", "NotAllowedError");
-    watchScreenShareToggle(Promise.reject(cancelled), true, logger, onError);
-    await flushPromises();
-    expect(onError).not.toHaveBeenCalled();
-  });
-});
-
-const timings: ResolvedDelayedLeaveTimings = {
-  delay_ms: 10000,
-  restart_ms: 4000,
-  restart_timeout_ms: 1000,
-};
-
-const delegatedTimings: ResolvedDelayedLeaveTimings = {
-  delay_ms: timings.delay_ms * 10,
-  restart_ms: timings.restart_ms! * 10,
-  restart_timeout_ms: timings.restart_timeout_ms! * 10,
-};
-
-const mockedClient = {
-  baseUrl: "https://matrix.example.org",
-  getDomain: vi.fn().mockReturnValue("example.org"),
-  getDeviceId: vi.fn().mockReturnValue("AAAA"),
-  getOpenIdToken: vi.fn().mockResolvedValue({
-    access_token: "ACCCESS_TOKEN",
-    token_type: "Bearer",
-    matrix_server_name: "localhost",
-    expires_in: 10000,
-  }),
-  _unstable_delegateDelayedLeave: vi.fn().mockResolvedValue({}),
-};
-
-describe("enterRTCSession", () => {
-  const transport: UnstableLivekitTransport = {
-    livekit_service_url: "http://my-livekit-service-url.com",
-    type: "livekit",
-  };
-
-  const options = {
-    encryptMedia: true,
-    matrixRTCMode: MATRIX_RTC_MODE,
-    delayedLeaveTimings: timings,
-  };
-
-  const mockedSession = vi.mocked({
-    room: {
-      roomId: "roomId",
-      client: mockedClient,
-    },
-    memberships: [],
-    join: vi.fn(),
-  }) as unknown as MatrixRTCSession;
-
-  beforeEach(() =>
-    mockConfig({
-      livekit: { livekit_service_url: "http://my-default-service-url.com" },
-    }),
-  );
-
-  it("It joins the correct Session", () => {
-    enterRTCSession(mockedSession, ownMemberMock, transport, options);
-
-    expect(mockedSession.join).toHaveBeenLastCalledWith(
-      {
-        deviceId: "DEVICE",
-        memberId: "@alice:example.org:DEVICE",
-        userId: "@alice:example.org",
-      },
-      [transport],
-      expect.objectContaining({ manageMediaKeys: true }),
-    );
-  });
-
-  it("passes keyRotationParticipantLimit from config to join", () => {
-    mockConfig({
-      livekit: { livekit_service_url: "http://my-default-service-url.com" },
-      matrix_rtc_session: {
-        network_error_retry_ms: 0,
-        key_rotation_participant_limit: 50,
-        delayed_leave: timings,
-        delegated_delayed_leave: timings,
-      },
-    });
-
-    enterRTCSession(mockedSession, ownMemberMock, transport, options);
-
-    expect(mockedSession.join).toHaveBeenLastCalledWith(
-      expect.any(Object),
-      expect.any(Object),
-      expect.objectContaining({
-        keyRotationParticipantLimit: 50,
-      }),
-    );
-  });
-
-  it("uses the specified delayed leave timings", () => {
-    enterRTCSession(mockedSession, ownMemberMock, transport, options);
-
-    expect(mockedSession.join).toHaveBeenLastCalledWith(
-      expect.anything(),
-      expect.anything(),
-      expect.objectContaining({
-        delayedLeaveEventRestartMs: timings.restart_ms,
-        delayedLeaveEventDelayMs: timings.delay_ms,
-        delayedLeaveEventRestartLocalTimeoutMs: timings.restart_timeout_ms,
-      }),
-    );
-  });
-});
-
-describe("LocalMembership", () => {
-  const defaultCreateLocalMemberValues = {
-    options: constant({
-      encryptMedia: false,
-      matrixRTCMode: MatrixRTCMode.Matrix_2_0,
-    }),
-    matrixRTCSession: {
-      updateCallIntent: vi.fn().mockReturnValue(Promise.resolve()),
-      leave: vi.fn(),
-    } as unknown as MatrixRTCSession,
-    muteStates: mockMuteStates(),
-    trackProcessorState$: constant({
-      supported: false,
-      processor: undefined,
-    }),
-    logger: logger,
-    createPublisherFactory: vi.fn().mockReturnValue({
-      destroy: vi.fn(),
-      createAndSetupTracks: vi.fn().mockResolvedValue(undefined),
-    }),
-    joinMatrixRTC: async (): Promise<void> => {},
-    homeserverConnected: {
-      combined$: constant<[boolean, HomeserverDisconnectReason | null]>([
-        true,
-        null,
-      ]),
-      rtsSession$: constant(RTCMemberStatus.Connected),
-    },
-    roomId: "!test-room-id:example.org",
-    hideScreensharing: false,
-    hostBridge: nullHostBridge,
-    baseUrl: "https://matrix.example.org",
-    ownMembershipIdentity: ownMemberMock,
-    client: mockedClient,
-    delayId$: constant(null),
-    matrixRTCMode: MATRIX_RTC_MODE,
-  };
-
-  beforeEach(() => {
-    mockConfig({
-      livekit: { livekit_service_url: "http://my-default-service-url.com" },
-      matrix_rtc_session: {
-        network_error_retry_ms: 1000,
-        delayed_leave: timings,
-        delegated_delayed_leave: delegatedTimings,
-      },
-    });
-    fetchMock.catch(404);
-  });
-
-  afterEach(async () => {
-    void (await fetchMock.flush());
-    fetchMock.reset();
-    vi.clearAllMocks();
-  });
-
-  it("throws error on missing RTC config error", () => {
-    withTestScheduler(({ scope, hot, expectObservable }) => {
-      const localMembership = createLocalMembership$({
-        scope,
-        ...defaultCreateLocalMemberValues,
-        // we do not need any connection data since we want to fail before reaching that.
-        connectionMap$: constant(new Epoch(new ConnectionMap())),
-        localTransport$: hot(
-          "1ms #",
-          {},
-          new MatrixRTCTransportMissingError("domain.com"),
-        ),
-      });
-
-      expectObservable(localMembership.localMemberState$).toBe("ne", {
-        n: TransportState.Waiting,
-        e: expect.toSatisfy((e) => e instanceof MatrixRTCTransportMissingError),
-      });
-    });
-  });
-
-  it("logs if callIntent cannot be updated", async () => {
-    async function reject(): Promise<void> {
-      return Promise.reject(new Error("Not connected yet"));
-    }
-    const localMembership = createLocalMembership$({
-      scope: testScope(),
-      ...defaultCreateLocalMemberValues,
-      matrixRTCSession: {
-        slotId: "m.call#ROOM",
-        updateCallIntent: vi.fn().mockImplementation(reject),
-        leave: vi.fn(),
-      },
-      connectionMap$: constant(new Epoch(new ConnectionMap())),
-      localTransport$: constant(mockTransportLocator),
-    });
-    const expextedLog =
-      "'not connected yet' while updating the call intent (this is expected on startup)";
-    const internalLogger = vi.spyOn(localMembership.internalLoggerRef, "debug");
-
-    await flushPromises();
-    defaultCreateLocalMemberValues.muteStates.video.setEnabled$.value?.(true);
-    expect(internalLogger).toHaveBeenCalledWith(expextedLog);
-  });
-
-  const mockTransport: UnstableLivekitTransport = {
-    type: "livekit",
-    url: "https://sfu.example.org",
-    livekit_service_url: "https://jwt.example.org",
-  };
-
-  const mockTransportLocator: livekitAuth.TransportLocator = {
-    transport: mockTransport,
-    serverName: "example.org",
-  };
-
-  const connectionTransportAConnected = {
-    livekitRoom: mockLivekitRoom({
-      localParticipant: {
-        isScreenShareEnabled: false,
-        trackPublications: [],
-      } as unknown as LocalParticipant,
-    }),
-    state$: constant({
-      state: "authenticated",
-      livekitState: LivekitConnectionState.Connected,
-    }),
-    transport: mockTransport,
-    serverName: "example.org",
-  } as Connection;
-  const connectionTransportAConnecting = {
-    ...connectionTransportAConnected,
-    state$: constant({
-      state: "authenticated",
-      livekitState: LivekitConnectionState.Connecting,
-    }),
-    livekitRoom: mockLivekitRoom({}),
-  } as unknown as Connection;
-
-  const delegationSpy = vi
-    .spyOn(livekitAuth, "delegateDelayedLeave")
-    .mockResolvedValue();
-  afterEach(() => delegationSpy.mockClear());
-
-  const urlOnlyTransport: UnstableLivekitTransport = {
-    type: "livekit",
-    url: "https://sfu.example.org",
-  };
-
-  // With a `url` only we publish through the CS API, so the homeserver
-  // delegates. With a `livekit_service_url` we publish through the JWT
-  // service, so that delegates.
-  it.each([
-    ["no", mockTransport, null, timings],
-    [
-      "homeserver",
-      urlOnlyTransport,
-      "https://matrix.example.org/_matrix/client/unstable/io.element.msc4195/rtc/livekit/delegate_delayed_leave",
-      delegatedTimings,
-    ],
-    [
-      "transport",
-      mockTransport,
-      "https://jwt.example.org/delegate_delayed_leave",
-      delegatedTimings,
-    ],
-  ])(
-    "joins session with %s delegation support",
-    async (_serviceName, transport, delegationUrl, delayedLeaveTimings) => {
-      const scope = testScope();
-      const joinMatrixRTC = vi.fn();
-      const delayId$ = new BehaviorSubject<string | null>(null);
-
-      if (delegationUrl !== null)
-        fetchMock.post(delegationUrl, () => ({ status: 401, body: {} }));
-
-      const connectionMap = new ConnectionMap();
-      connectionMap.add(
-        { ...connectionTransportAConnected, transport } as Connection,
-        [],
-      );
-      const localMembership = createLocalMembership$({
-        scope,
-        ...defaultCreateLocalMemberValues,
-        connectionMap$: constant(new Epoch(connectionMap)),
-        joinMatrixRTC,
-        localTransport$: constant({ transport, serverName: "example.org" }),
-        delayId$,
-      });
-
-      localMembership.requestJoinAndPublish();
-      void (await fetchMock.flush());
-      await flushPromises();
-      // Joins with timings appropriate for the level of delegation support
-      expect(joinMatrixRTC).toHaveBeenCalledWith(
-        transport,
-        delayedLeaveTimings,
-      );
-
-      expect(delegationSpy).not.toHaveBeenCalled();
-      delayId$.next("leave1");
-      await flushPromises();
-      if (delegationUrl === null) {
-        expect(delegationSpy).not.toHaveBeenCalled();
-      } else {
-        // Delegation is supported in this test case, so go on to check that
-        // LocalMember actually performs delegation
-        const expectDelegation = (delayId: string) =>
-          expect(delegationSpy).toHaveBeenLastCalledWith({
-            client: mockedClient,
-            membership: ownMemberMock,
-            transport,
-            roomId: "!test-room-id:example.org",
-            delayId,
-            logger: expect.anything(),
-          });
-
-        expectDelegation("leave1");
-        delayId$.next("leave2"); // Can change delegated leaves
-        await flushPromises();
-        expectDelegation("leave2");
-      }
-    },
-  );
-
-  it("only starts tracks if requested", async () => {
-    const scope = new ObservableScope();
-
-    const publishers: Publisher[] = [];
-
-    const tracks$ = new BehaviorSubject<LocalTrack[]>([]);
-    const publishing$ = constant<boolean>(false);
-    defaultCreateLocalMemberValues.createPublisherFactory.mockImplementation(
-      () => {
-        const p = {
-          // It is enought to check if destroy is called. Destroy itself is tested in the publisher to make sure it does
-          // all the cleanup we need.
-          destroy: vi.fn(),
-          createAndSetupTracks: vi.fn().mockImplementation(async () => {
-            tracks$.next([{}, {}] as LocalTrack[]);
-            return Promise.resolve();
-          }),
-          tracks$,
-          publishing$,
-        };
-        publishers.push(p as unknown as Publisher);
-        return p;
-      },
-    );
-    const publisherFactory =
-      defaultCreateLocalMemberValues.createPublisherFactory as ReturnType<
-        typeof vi.fn
-      >;
-
-    const connectionMap = new ConnectionMap();
-    connectionMap.add(connectionTransportAConnected, []);
-    // connectionMap.add(connectionTransportB, []);
-    const localMembership = createLocalMembership$({
-      scope,
-      ...defaultCreateLocalMemberValues,
-      connectionMap$: constant(new Epoch(connectionMap)),
-      localTransport$: constant(mockTransportLocator),
-    });
-    await flushPromises();
-    expect(publisherFactory).toHaveBeenCalledOnce();
-    // expect(localMembership.tracks$.value.length).toBe(0);
-    expect(publishers[0].createAndSetupTracks).not.toHaveBeenCalled();
-    localMembership.startTracks();
-    await flushPromises();
-    expect(publishers[0].createAndSetupTracks).toHaveBeenCalled();
-
-    scope.end();
-    await flushPromises();
-    // stop all tracks after ending scopes
-    expect(publishers[0].destroy).toHaveBeenCalled();
-    // expect(publishers[0].stopTracks).toHaveBeenCalled();
-    publisherFactory.mockClear();
-  });
-  // TODO add an integration test combining publisher and localMembership
-  //
-  it("tracks livekit state correctly", async () => {
-    const scope = new ObservableScope();
-    const connectionMap = new ConnectionMap();
-    const localTransport$ = new Subject<livekitAuth.TransportLocator>();
-
-    const connectionMap$ = new BehaviorSubject(new Epoch(connectionMap));
-    const publishers: Publisher[] = [];
-
-    const publishing$ = new BehaviorSubject<boolean>(false);
-    const createTrackResolver = Promise.withResolvers<void>();
-    const publishResolver = Promise.withResolvers<void>();
-    defaultCreateLocalMemberValues.createPublisherFactory.mockImplementation(
-      () => {
-        const p = {
-          // It is enought to check if destroy is called. Destroy itself is tested in the publisher to make sure it does
-          // all the cleanup we need.
-          destroy: vi.fn(),
-          createAndSetupTracks: vi.fn().mockImplementation(async () => {
-            await createTrackResolver.promise;
-          }),
-          startPublishing: vi.fn().mockImplementation(async () => {
-            await publishResolver.promise;
-            publishing$.next(true);
-          }),
-          publishing$,
-        };
-        publishers.push(p as unknown as Publisher);
-        return p;
-      },
-    );
-
-    const publisherFactory =
-      defaultCreateLocalMemberValues.createPublisherFactory as ReturnType<
-        typeof vi.fn
-      >;
-
-    const localMembership = createLocalMembership$({
-      scope,
-      ...defaultCreateLocalMemberValues,
-      connectionMap$: connectionMap$,
-      localTransport$,
-    });
-
-    await flushPromises();
-    expect(localMembership.localMemberState$.value).toStrictEqual(
-      TransportState.Waiting,
-    );
-    localTransport$.next(mockTransportLocator);
-    await flushPromises();
-    expect(localMembership.localMemberState$.value).toStrictEqual({
-      matrix: RTCMemberStatus.Connected,
-      media: {
-        connection: { state: "initializing" },
-        tracks: TrackState.WaitingForUser,
-      },
-    });
-
-    const connectionMap2 = new ConnectionMap();
-    connectionMap2.add(
-      // clone because we will mutate this later.
-      { ...connectionTransportAConnecting } as unknown as Connection,
-      [],
-    );
-
-    connectionMap$.next(new Epoch(connectionMap2));
-    await flushPromises();
-    expect(localMembership.localMemberState$.value).toStrictEqual({
-      matrix: RTCMemberStatus.Connected,
-      media: {
-        connection: {
-          state: "authenticated",
-          livekitState: LivekitConnectionState.Connecting,
-        },
-        tracks: TrackState.WaitingForUser,
-      },
-    });
-
-    (
-      connectionMap2.getConnectionForTransport(mockTransportLocator)!
-        .state$ as BehaviorSubject<ConnectionState>
-    ).next({
-      state: "authenticated",
-      livekitState: LivekitConnectionState.Connected,
-    });
-    expect(localMembership.localMemberState$.value).toStrictEqual({
-      matrix: RTCMemberStatus.Connected,
-      media: {
-        connection: {
-          state: "authenticated",
-          livekitState: LivekitConnectionState.Connected,
-        },
-        tracks: TrackState.WaitingForUser,
-      },
-    });
-
-    expect(publisherFactory).toHaveBeenCalledOnce();
-    // expect(localMembership.tracks$.value.length).toBe(0);
-
-    // -------
-    localMembership.startTracks();
-    // -------
-
-    await flushPromises();
-    // expect(localMembership.localMemberState$.value).toStrictEqual({
-    //   matrix: RTCMemberStatus.Connected,
-    //   media: {
-    //     tracks: TrackState.Creating,
-    //     connection: ConnectionState.LivekitConnected,
-    //   },
-    // });
-    createTrackResolver.resolve();
-    await flushPromises();
-    expect(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (localMembership.localMemberState$.value as any).media,
-    ).toStrictEqual(PublishState.WaitingForUser);
-
-    // -------
-    localMembership.requestJoinAndPublish();
-    // -------
-
-    expect(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (localMembership.localMemberState$.value as any).media,
-    ).toStrictEqual(PublishState.Publishing);
-
-    publishResolver.resolve();
-    await flushPromises();
-    expect(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (localMembership.localMemberState$.value as any).media,
-    ).toStrictEqual(PublishState.Publishing);
-
-    expect(publishers[0].destroy).not.toHaveBeenCalled();
-
-    expect(localMembership.localMemberState$.isStopped).toBe(false);
-    scope.end();
-    await flushPromises();
-    // stays in connected state because it is stopped before the update to tracks update the state.
-    expect(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (localMembership.localMemberState$.value as any).media,
-    ).toStrictEqual(PublishState.Publishing);
-    // stop all tracks after ending scopes
-    expect(publishers[0].destroy).toHaveBeenCalled();
-    // expect(publishers[0].stopTracks).toHaveBeenCalled();
-  });
-  // TODO add tests for matrix local matrix participation.
-
-  describe("reconnecting analytics", () => {
-    beforeAll(() => {
-      mockConfig();
-    });
-
-    beforeEach(() => {
-      vi.restoreAllMocks();
-    });
-
-    afterAll(() => {
-      PosthogAnalytics.resetInstance();
-    });
-
-    it("does not fire CallReconnecting for the initial non-connected state at startup", async () => {
-      const scope = new ObservableScope();
-      const trackSpy = vi.spyOn(
-        PosthogAnalytics.instance.eventCallReconnecting,
-        "track",
-      );
-
-      // Simulate startup where membership isn't established yet
-      const hsReason$ = new BehaviorSubject<
-        [boolean, HomeserverDisconnectReason | null]
-      >([false, "membership"]);
-
-      const connectionMap = new ConnectionMap();
-      connectionMap.add(connectionTransportAConnected, []);
-
-      createLocalMembership$({
-        scope,
-        ...defaultCreateLocalMemberValues,
-        homeserverConnected: {
-          combined$: hsReason$,
-          rtsSession$: constant(RTCMemberStatus.Connected),
-        },
-        connectionMap$: constant(new Epoch(connectionMap)),
-        localTransport$: constant(mockTransportLocator),
-      });
-
-      await flushPromises();
-
-      // Membership is established — call is now connected
-      hsReason$.next([true, null]);
-
-      expect(trackSpy).not.toHaveBeenCalled();
-
-      scope.end();
-    });
-
-    it("fires CallReconnecting with homeserver reason and duration when reconnected", async () => {
-      const scope = new ObservableScope();
-      const trackSpy = vi.spyOn(
-        PosthogAnalytics.instance.eventCallReconnecting,
-        "track",
-      );
-
-      const hsReason$ = new BehaviorSubject<
-        [boolean, HomeserverDisconnectReason | null]
-      >([true, null]);
-
-      const connectionMap = new ConnectionMap();
-      connectionMap.add(connectionTransportAConnected, []);
-
-      createLocalMembership$({
-        scope,
-        ...defaultCreateLocalMemberValues,
-        homeserverConnected: {
-          combined$: hsReason$,
-          rtsSession$: constant(RTCMemberStatus.Connected),
-        },
-        connectionMap$: constant(new Epoch(connectionMap)),
-        localTransport$: constant(mockTransportLocator),
-      });
-
-      await flushPromises();
-
-      hsReason$.next([false, "sync"]);
-      hsReason$.next([true, null]);
-
-      expect(trackSpy).toHaveBeenCalledWith(
-        defaultCreateLocalMemberValues.roomId,
-        "sync",
-        expect.any(Number),
-      );
-
-      scope.end();
-    });
-
-    it("reports livekit reason when livekit disconnects then reconnects", async () => {
-      const scope = new ObservableScope();
-      const trackSpy = vi.spyOn(
-        PosthogAnalytics.instance.eventCallReconnecting,
-        "track",
-      );
-
-      const connectionState$ = new BehaviorSubject<ConnectionState>({
-        state: "authenticated",
-        livekitState: LivekitConnectionState.Connected,
-      });
-      const mutableConnection = {
-        ...connectionTransportAConnected,
-        state$: connectionState$,
-      } as unknown as Connection;
-
-      const connectionMap = new ConnectionMap();
-      connectionMap.add(mutableConnection, []);
-
-      createLocalMembership$({
-        scope,
-        ...defaultCreateLocalMemberValues,
-        homeserverConnected: {
-          combined$: constant<[boolean, HomeserverDisconnectReason | null]>([
-            true,
-            null,
-          ]),
-          rtsSession$: constant(RTCMemberStatus.Connected),
-        },
-        connectionMap$: constant(new Epoch(connectionMap)),
-        localTransport$: constant(mockTransportLocator),
-      });
-
-      await flushPromises();
-
-      connectionState$.next({
-        state: "authenticated",
-        livekitState: LivekitConnectionState.Disconnected,
-      });
-      connectionState$.next({
-        state: "authenticated",
-        livekitState: LivekitConnectionState.Connected,
-      });
-
-      expect(trackSpy).toHaveBeenCalledWith(
-        defaultCreateLocalMemberValues.roomId,
-        "livekit",
-        expect.any(Number),
-      );
-
-      scope.end();
-    });
-
-    it("fires one event per completed reconnection cycle", async () => {
-      const scope = new ObservableScope();
-      const trackSpy = vi.spyOn(
-        PosthogAnalytics.instance.eventCallReconnecting,
-        "track",
-      );
-
-      const hsReason$ = new BehaviorSubject<
-        [boolean, HomeserverDisconnectReason | null]
-      >([true, null]);
-
-      const connectionMap = new ConnectionMap();
-      connectionMap.add(connectionTransportAConnected, []);
-
-      createLocalMembership$({
-        scope,
-        ...defaultCreateLocalMemberValues,
-        homeserverConnected: {
-          combined$: hsReason$,
-          rtsSession$: constant(RTCMemberStatus.Connected),
-        },
-        connectionMap$: constant(new Epoch(connectionMap)),
-        localTransport$: constant(mockTransportLocator),
-      });
-
-      await flushPromises();
-
-      hsReason$.next([false, "membership"]);
-      hsReason$.next([true, null]);
-
-      hsReason$.next([false, "probablyLeft"]);
-      hsReason$.next([false, "sync"]);
-      hsReason$.next([false, "membership"]);
-      hsReason$.next([true, null]);
-
-      expect(trackSpy).toHaveBeenCalledTimes(2);
-      expect(trackSpy).toHaveBeenNthCalledWith(
-        1,
-        defaultCreateLocalMemberValues.roomId,
-        "membership",
-        expect.any(Number),
-      );
-      expect(trackSpy).toHaveBeenNthCalledWith(
-        2,
-        defaultCreateLocalMemberValues.roomId,
-        "probablyLeft",
-        expect.any(Number),
-      );
-
-      scope.end();
-    });
-  });
-
-  describe("toggleScreenSharing", () => {
-    let originalMediaDevices: MediaDevices | undefined;
-
-    beforeAll(() => {
-      mockConfig();
-      // Screen sharing is only offered when getDisplayMedia is available.
-      originalMediaDevices = navigator.mediaDevices;
-      Object.defineProperty(navigator, "mediaDevices", {
-        configurable: true,
-        value: { getDisplayMedia: vi.fn() },
-      });
-    });
-
-    afterAll(() => {
-      Object.defineProperty(navigator, "mediaDevices", {
-        configurable: true,
-        value: originalMediaDevices,
-      });
-    });
-
-    const createMembershipWithConnection = (
-      connection: Connection | null,
-    ): {
-      scope: ObservableScope;
-      localMembership: ReturnType<typeof createLocalMembership$>;
-    } => {
-      const scope = new ObservableScope();
-      const connectionMap = new ConnectionMap();
-      if (connection) connectionMap.add(connection, []);
-      const localMembership = createLocalMembership$({
-        scope,
-        ...defaultCreateLocalMemberValues,
-        connectionMap$: constant(new Epoch(connectionMap)),
-        localTransport$: constant(mockTransportLocator),
-      });
-      return { scope, localMembership };
-    };
-
-    it("surfaces a failure and clears it on dismiss", async () => {
-      const error = new Error("NotReadableError");
-      const setScreenShareEnabled = vi.fn().mockRejectedValue(error);
-      const connection = {
-        state$: constant({
-          state: "authenticated",
-          livekitState: LivekitConnectionState.Connected,
-        }),
-        transport: mockTransport,
-        serverName: "example.org",
-        livekitRoom: mockLivekitRoom({
-          localParticipant: mockLocalParticipant({
-            isScreenShareEnabled: false,
-            setScreenShareEnabled,
-          }),
-        }),
-      } as unknown as Connection;
-      const { scope, localMembership } =
-        createMembershipWithConnection(connection);
-      await flushPromises();
-
-      expect(localMembership.toggleScreenSharing).not.toBeNull();
-      expect(localMembership.screenShareError$.value).toBeNull();
-
-      localMembership.toggleScreenSharing!();
-      await flushPromises();
-
-      expect(setScreenShareEnabled).toHaveBeenCalledWith(
-        true,
-        expect.any(Object),
-        undefined,
-      );
-      expect(localMembership.screenShareError$.value).toBe(error);
-
-      localMembership.dismissScreenShareError();
-      expect(localMembership.screenShareError$.value).toBeNull();
-
-      scope.end();
-    });
-
-    it("does nothing when there is no local participant", async () => {
-      // No connection means participant$ never resolves to a participant.
-      const { scope, localMembership } = createMembershipWithConnection(null);
-      await flushPromises();
-
-      expect(localMembership.toggleScreenSharing).not.toBeNull();
-      localMembership.toggleScreenSharing!();
-      await flushPromises();
-
-      expect(localMembership.screenShareError$.value).toBeNull();
-
-      scope.end();
-    });
-  });
-});

src/state/CallViewModel/localMember/LocalTransport.test.ts

@@ -1,126 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  type MockedObject,
-  vi,
-} from "vitest";
-import fetchMock from "fetch-mock";
-
-import { mockConfig } from "../../../utils/test";
-import { getLocalTransport } from "./LocalTransport";
-import { MatrixRTCTransportMissingError } from "../../../utils/errors";
-import { customTransport } from "../../../settings/settings";
-import { type MatrixClient } from "matrix-js-sdk";
-
-describe("LocalTransport", () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it("throws if config is missing", async () => {
-    await expect(
-      getLocalTransport({
-        _unstable_getRTCTransports: async () => Promise.resolve([]),
-        getDomain: () => "example.org",
-      }),
-    ).rejects.toThrow(new MatrixRTCTransportMissingError("example.org"));
-  });
-
-  it("returns preferred transport", async () => {
-    // Use config so transport discovery succeeds
-    mockConfig({
-      livekit: { livekit_service_url: "https://lk.example.org" },
-    });
-
-    expect(
-      await getLocalTransport({
-        _unstable_getRTCTransports: async () => Promise.resolve([]),
-        getDomain: () => "example.org",
-      }),
-    ).toStrictEqual({
-      transport: {
-        livekit_service_url: "https://lk.example.org",
-        type: "livekit",
-      },
-      serverName: "example.org",
-    });
-  });
-
-  describe("transport configuration mechanisms", () => {
-    let client: MockedObject<
-      Pick<MatrixClient, "getDomain" | "_unstable_getRTCTransports">
-    >;
-    beforeEach(() => {
-      mockConfig({});
-      customTransport.setValue(customTransport.defaultValue);
-      client = {
-        getDomain: vi.fn().mockReturnValue("example.org"),
-        _unstable_getRTCTransports: vi.fn().mockResolvedValue([]),
-      };
-    });
-
-    afterEach(() => {
-      fetchMock.reset();
-    });
-
-    it("supports getting transport via application config", async () => {
-      mockConfig({
-        livekit: { livekit_service_url: "https://lk.example.org" },
-      });
-
-      expect(await getLocalTransport(client)).toStrictEqual({
-        transport: {
-          livekit_service_url: "https://lk.example.org",
-          type: "livekit",
-        },
-        serverName: "example.org",
-      });
-    });
-
-    it("supports getting transport via user settings", async () => {
-      customTransport.setValue({
-        type: "livekit",
-        livekit_service_url: "https://lk.example.org",
-      });
-
-      expect(await getLocalTransport(client)).toStrictEqual({
-        transport: {
-          livekit_service_url: "https://lk.example.org",
-          type: "livekit",
-        },
-        serverName: "example.org",
-      });
-    });
-
-    it("supports getting transport via backend", async () => {
-      client._unstable_getRTCTransports.mockResolvedValue([
-        { type: "livekit", livekit_service_url: "https://lk.example.org" },
-      ]);
-
-      expect(await getLocalTransport(client)).toStrictEqual({
-        transport: {
-          livekit_service_url: "https://lk.example.org",
-          type: "livekit",
-        },
-        serverName: "example.org",
-      });
-    });
-
-    it("throws if no options are available", async () => {
-      await expect(
-        getLocalTransport({
-          getDomain: () => "example.org",
-          _unstable_getRTCTransports: async () => Promise.resolve([]),
-        }),
-      ).rejects.toThrow(new MatrixRTCTransportMissingError("example.org"));
-    });
-  });
-});

src/state/CallViewModel/localMember/LocalTransport.ts

@@ -1,41 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-
-SPDX-License-IdFentifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { type MatrixClient } from "matrix-js-sdk";
-import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
-
-import { Config } from "../../../config/Config.ts";
-import { MatrixRTCTransportMissingError } from "../../../utils/errors.ts";
-import { customTransport as customTransportSetting } from "../../../settings/settings.ts";
-import { RtcTransportAutoDiscovery } from "./RtcTransportAutoDiscovery.ts";
-import { type TransportLocator } from "../../../livekit/auth/types.ts";
-
-/**
- * Determines the transport to advertise in our MatrixRTC membership and publish
- * media on.
- */
-export async function getLocalTransport(
-  client: Pick<MatrixClient, "getDomain" | "_unstable_getRTCTransports">,
-): Promise<TransportLocator> {
-  const serverName = client.getDomain();
-  if (serverName === null) throw new Error("No server name");
-
-  const discovery = new RtcTransportAutoDiscovery({
-    client,
-    resolvedConfig: Config.get(),
-    logger: rootLogger.getChild("[LocalTransport]"),
-  });
-
-  // Respect the user's custom transport, if set
-  const transport =
-    customTransportSetting.value$.value ??
-    (await discovery.discoverPreferredTransport());
-
-  if (transport === null) throw new MatrixRTCTransportMissingError(serverName);
-
-  return { transport, serverName };
-}

src/state/CallViewModel/localMember/Publisher.test.ts

@@ -1,402 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { afterEach, beforeEach, describe, expect, it, test, vi } from "vitest";
-import {
-  ConnectionState as LivekitConnectionState,
-  LocalParticipant,
-  type LocalTrack,
-  type LocalTrackPublication,
-  ParticipantEvent,
-  Track,
-} from "livekit-client";
-import { BehaviorSubject } from "rxjs";
-import { logger } from "matrix-js-sdk/lib/logger";
-
-import { ObservableScope } from "../../ObservableScope";
-import { constant } from "../../Behavior";
-import {
-  flushPromises,
-  mockLivekitRoom,
-  mockMediaDevices,
-} from "../../../utils/test";
-import { Publisher } from "./Publisher";
-import { type Connection } from "../remoteMembers/Connection";
-import { type MuteStates } from "../../MuteStates";
-
-let scope: ObservableScope;
-
-beforeEach(() => {
-  scope = new ObservableScope();
-});
-
-afterEach(() => scope.end());
-
-function createMockLocalTrack(source: Track.Source): LocalTrack {
-  const track = {
-    source,
-    isMuted: false,
-    isUpstreamPaused: false,
-  } as Partial<LocalTrack> as LocalTrack;
-
-  vi.mocked(track).mute = vi.fn().mockImplementation(() => {
-    track.isMuted = true;
-  });
-  vi.mocked(track).unmute = vi.fn().mockImplementation(() => {
-    track.isMuted = false;
-  });
-  vi.mocked(track).pauseUpstream = vi.fn().mockImplementation(() => {
-    // @ts-expect-error - for that test we want to set isUpstreamPaused directly
-    track.isUpstreamPaused = true;
-  });
-  vi.mocked(track).resumeUpstream = vi.fn().mockImplementation(() => {
-    // @ts-expect-error - for that test we want to set isUpstreamPaused directly
-    track.isUpstreamPaused = false;
-  });
-
-  return track;
-}
-
-function createMockMuteState(enabled$: BehaviorSubject<boolean>): {
-  enabled$: BehaviorSubject<boolean>;
-  syncing$: BehaviorSubject<boolean>;
-  setHandler: (h: (enabled: boolean) => void) => void;
-  unsetHandler: () => void;
-} {
-  let currentHandler = (enabled: boolean): void => {};
-
-  const ms = {
-    enabled$,
-    syncing$: new BehaviorSubject(false),
-    setHandler: vi.fn().mockImplementation((h: (enabled: boolean) => void) => {
-      currentHandler = h;
-    }),
-    unsetHandler: vi.fn().mockImplementation(() => {
-      currentHandler = (enabled: boolean): void => {};
-    }),
-  };
-  // forward enabled$ emissions to the current handler
-  enabled$.subscribe((enabled) => {
-    logger.info(`MockMuteState: enabled changed to ${enabled}`);
-    currentHandler(enabled);
-  });
-
-  return ms;
-}
-
-let connection: Connection;
-let muteStates: MuteStates;
-let localParticipant: LocalParticipant;
-let audioEnabled$: BehaviorSubject<boolean>;
-let videoEnabled$: BehaviorSubject<boolean>;
-let trackPublications: LocalTrackPublication[];
-// use it to control when track creation resolves, default to resolved
-let createTrackLock: Promise<void>;
-
-beforeEach(() => {
-  trackPublications = [];
-  audioEnabled$ = new BehaviorSubject(false);
-  videoEnabled$ = new BehaviorSubject(false);
-  createTrackLock = Promise.resolve();
-
-  muteStates = {
-    audio: createMockMuteState(audioEnabled$),
-    video: createMockMuteState(videoEnabled$),
-  } as unknown as MuteStates;
-
-  const mockSendDataPacket = vi.fn();
-  const mockEngine = {
-    client: {
-      sendUpdateLocalMetadata: vi.fn(),
-    },
-    on: vi.fn().mockReturnThis(),
-    sendDataPacket: mockSendDataPacket,
-  };
-
-  localParticipant = new LocalParticipant(
-    "local-sid",
-    "local-identity",
-    // @ts-expect-error - for that test we want a real LocalParticipant to have the pending publications logic
-    mockEngine,
-    {
-      adaptiveStream: true,
-      dynacase: false,
-      audioCaptureDefaults: {},
-      videoCaptureDefaults: {},
-      stopLocalTrackOnUnpublish: true,
-      reconnectPolicy: "always",
-      disconnectOnPageLeave: true,
-    },
-    new Map(),
-    {},
-    {},
-    {},
-  );
-
-  vi.mocked(localParticipant).createTracks = vi
-    .fn()
-    .mockImplementation(async (opts) => {
-      const tracks: LocalTrack[] = [];
-      if (opts.audio) {
-        tracks.push(createMockLocalTrack(Track.Source.Microphone));
-      }
-      if (opts.video) {
-        tracks.push(createMockLocalTrack(Track.Source.Camera));
-      }
-      await createTrackLock;
-      return tracks;
-    });
-
-  vi.mocked(localParticipant).publishTrack = vi
-    .fn()
-    .mockImplementation(async (track: LocalTrack) => {
-      const pub = {
-        track,
-        source: track.source,
-        mute: track.mute,
-        unmute: track.unmute,
-      } as Partial<LocalTrackPublication> as LocalTrackPublication;
-      trackPublications.push(pub);
-      localParticipant.emit(ParticipantEvent.LocalTrackPublished, pub);
-      return Promise.resolve(pub);
-    });
-
-  vi.mocked(localParticipant).getTrackPublication = vi
-    .fn()
-    .mockImplementation((source: Track.Source) => {
-      return trackPublications.find((pub) => pub.track?.source === source);
-    });
-
-  connection = {
-    state$: constant({
-      state: "ConnectedToLkRoom",
-      livekitConnectionState$: constant(LivekitConnectionState.Connected),
-    }),
-    livekitRoom: mockLivekitRoom({
-      localParticipant: localParticipant,
-    }),
-  } as unknown as Connection;
-});
-
-describe("Publisher", () => {
-  let publisher: Publisher;
-
-  beforeEach(() => {
-    publisher = new Publisher(
-      connection,
-      mockMediaDevices({}),
-      muteStates,
-      constant({ supported: false, processor: undefined }),
-      logger,
-      false,
-    );
-  });
-
-  afterEach(async () => {
-    await publisher.destroy();
-  });
-
-  it("Should not create tracks if started muted to avoid unneeded permission requests", async () => {
-    const createTracksSpy = vi.spyOn(
-      connection.livekitRoom.localParticipant,
-      "createTracks",
-    );
-
-    audioEnabled$.next(false);
-    videoEnabled$.next(false);
-    await publisher.createAndSetupTracks();
-
-    expect(createTracksSpy).not.toHaveBeenCalled();
-  });
-
-  it("should unsetHandler and stop tracks on destroy", async () => {
-    // setup all spies
-    const unsetVideoSpy = vi.spyOn(
-      (
-        publisher as unknown as {
-          muteStates: { video: { unsetHandler: () => void } };
-        }
-      ).muteStates.video,
-      "unsetHandler",
-    );
-    const unsetAudioSpy = vi.spyOn(
-      (
-        publisher as unknown as {
-          muteStates: { audio: { unsetHandler: () => void } };
-        }
-      ).muteStates.audio,
-      "unsetHandler",
-    );
-    const scopeEndSpy = vi.spyOn(
-      (publisher as unknown as { scope: { end: () => void } }).scope,
-      "end",
-    );
-    const stopTracksSpy = vi.spyOn(publisher, "stopTracks");
-    // destroy publisher
-    await publisher.destroy();
-
-    expect(stopTracksSpy).toHaveBeenCalledOnce();
-    expect(unsetVideoSpy).toHaveBeenCalledOnce();
-    expect(unsetAudioSpy).toHaveBeenCalledOnce();
-    expect(scopeEndSpy).toHaveBeenCalled();
-  });
-
-  it("Should minimize permission request by querying create at once", async () => {
-    const enableCameraAndMicrophoneSpy = vi.spyOn(
-      localParticipant,
-      "enableCameraAndMicrophone",
-    );
-    const createTracksSpy = vi.spyOn(localParticipant, "createTracks");
-
-    audioEnabled$.next(true);
-    videoEnabled$.next(true);
-    await publisher.createAndSetupTracks();
-    await flushPromises();
-
-    expect(enableCameraAndMicrophoneSpy).toHaveBeenCalled();
-
-    // It should create both at once
-    expect(createTracksSpy).toHaveBeenCalledWith({
-      audio: true,
-      video: true,
-    });
-  });
-
-  it("Ensure no data is streamed until publish has been called", async () => {
-    audioEnabled$.next(true);
-    await publisher.createAndSetupTracks();
-
-    // The track should be created and paused
-    expect(localParticipant.createTracks).toHaveBeenCalledWith({
-      audio: true,
-      video: undefined,
-    });
-    await flushPromises();
-    expect(localParticipant.publishTrack).toHaveBeenCalled();
-
-    await flushPromises();
-    const track = localParticipant.getTrackPublication(
-      Track.Source.Microphone,
-    )?.track;
-    expect(track).toBeDefined();
-    expect(track!.pauseUpstream).toHaveBeenCalled();
-    expect(track!.isUpstreamPaused).toBe(true);
-  });
-
-  it("Ensure resume upstream when published is called", async () => {
-    videoEnabled$.next(true);
-    await publisher.createAndSetupTracks();
-    // await flushPromises();
-    await publisher.startPublishing();
-
-    const track = localParticipant.getTrackPublication(
-      Track.Source.Camera,
-    )?.track;
-    expect(track).toBeDefined();
-    // expect(track.pauseUpstream).toHaveBeenCalled();
-    expect(track!.isUpstreamPaused).toBe(false);
-  });
-
-  describe("Mute states", () => {
-    let publisher: Publisher;
-    beforeEach(() => {
-      publisher = new Publisher(
-        connection,
-        mockMediaDevices({}),
-        muteStates,
-        constant({ supported: false, processor: undefined }),
-        logger,
-        false,
-      );
-    });
-    afterEach(async () => {
-      await publisher.destroy();
-    });
-
-    test.each([
-      { mutes: { audioEnabled: true, videoEnabled: false } },
-      { mutes: { audioEnabled: true, videoEnabled: false } },
-    ])("only create the tracks that are unmuted $mutes", async ({ mutes }) => {
-      // Ensure all muted
-      audioEnabled$.next(mutes.audioEnabled);
-      videoEnabled$.next(mutes.videoEnabled);
-
-      vi.mocked(connection.livekitRoom.localParticipant).createTracks = vi
-        .fn()
-        .mockResolvedValue([]);
-
-      await publisher.createAndSetupTracks();
-
-      expect(
-        connection.livekitRoom.localParticipant.createTracks,
-      ).toHaveBeenCalledOnce();
-
-      expect(
-        connection.livekitRoom.localParticipant.createTracks,
-      ).toHaveBeenCalledWith({
-        audio: mutes.audioEnabled ? true : undefined,
-        video: mutes.videoEnabled ? true : undefined,
-      });
-    });
-  });
-
-  it("does mute unmute audio", async () => {});
-});
-
-describe("Bug fix", () => {
-  // There is a race condition when creating and publishing tracks while the mute state changes.
-  // This race condition could cause tracks to be published even though they are muted at the
-  // beginning of a call coming from lobby.
-  // This is caused by our stack using manually the low level API to create and publish tracks,
-  // but also using the higher level setMicrophoneEnabled and setCameraEnabled functions that also create
-  // and publish tracks, and managing pending publications.
-  // Race is as follow, on creation of the Publisher we create the tracks then publish them.
-  // If in the middle of that process the mute state changes:
-  //  - the `setMicrophoneEnabled` will be no-op because it is not aware of our created track and can't see any pending publication
-  //  - If start publication is requested it will publish the track even though there was a mute request.
-  it("wrongly publish tracks while muted", async () => {
-    // setLogLevel(`debug`);
-    const publisher = new Publisher(
-      connection,
-      mockMediaDevices({}),
-      muteStates,
-      constant({ supported: false, processor: undefined }),
-      logger,
-      false,
-    );
-    audioEnabled$.next(true);
-
-    const resolvers = Promise.withResolvers<void>();
-    createTrackLock = resolvers.promise;
-
-    // Initially the audio is unmuted, so creating tracks should publish the audio track
-    const createTracks = publisher.createAndSetupTracks();
-    void publisher.startPublishing();
-    void createTracks.then(() => {
-      void publisher.startPublishing();
-    });
-    // now mute the audio before allowing track creation to complete
-    audioEnabled$.next(false);
-    resolvers.resolve(undefined);
-    await createTracks;
-
-    await flushPromises();
-
-    const track = localParticipant.getTrackPublication(
-      Track.Source.Microphone,
-    )?.track;
-    expect(track).toBeDefined();
-
-    try {
-      expect(localParticipant.publishTrack).not.toHaveBeenCalled();
-    } catch {
-      expect(track!.mute).toHaveBeenCalled();
-      expect(track!.isMuted).toBe(true);
-    }
-    await publisher.destroy();
-  });
-});

src/state/CallViewModel/localMember/Publisher.ts

@@ -1,445 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-Copyright 2025 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-import {
-  ConnectionState as LivekitConnectionState,
-  type LocalTrackPublication,
-  LocalVideoTrack,
-  ParticipantEvent,
-  type Room as LivekitRoom,
-  Track,
-} from "livekit-client";
-import {
-  map,
-  NEVER,
-  type Observable,
-  type Subscription,
-  switchMap,
-} from "rxjs";
-import { type Logger } from "matrix-js-sdk/lib/logger";
-
-import type { Behavior } from "../../Behavior.ts";
-import type { MediaDevices, SelectedDevice } from "../../MediaDevices.ts";
-import type { MuteStates } from "../../MuteStates.ts";
-import {
-  type ProcessorState,
-  trackProcessorSync,
-} from "../../../livekit/TrackProcessorContext.tsx";
-
-import { observeTrackReference$ } from "../../observeTrackReference";
-import { type Connection } from "../remoteMembers/Connection.ts";
-import { ObservableScope } from "../../ObservableScope.ts";
-
-/**
- * A wrapper for a Connection object.
- * This wrapper will manage the connection used to publish to the LiveKit room.
- * The Publisher is also responsible for creating the media tracks.
- */
-export class Publisher {
-  /**
-   * By default, livekit will start publishing tracks as soon as they are created.
-   * In the matrix RTC world, we want to control when tracks are published based
-   * on whether the user is part of the RTC session or not.
-   */
-  public shouldPublish = false;
-
-  private readonly scope = new ObservableScope();
-
-  /**
-   * Creates a new Publisher.
-   * @param connection - The connection to use for publishing.
-   * @param devices - The media devices to use for audio and video input.
-   * @param muteStates - The mute states for audio and video.
-   * @param trackerProcessorState$ - The processor state for the video track processor (e.g. background blur).
-   * @param logger - The logger to use for logging :D.
-   * @param controlledAudioDevices - Whether the app hosting Element Call
-   *   controls the audio output devices, rather than the browser.
-   */
-  public constructor(
-    private connection: Pick<Connection, "livekitRoom" | "state$">, //setE2EEEnabled,
-    devices: MediaDevices,
-    private readonly muteStates: MuteStates,
-    trackerProcessorState$: Behavior<ProcessorState>,
-    private logger: Logger,
-    controlledAudioDevices: boolean,
-  ) {
-    const room = connection.livekitRoom;
-
-    room.setE2EEEnabled(room.options.e2ee !== undefined)?.catch((e: Error) => {
-      this.logger.error("Failed to set E2EE enabled on room", e);
-    });
-
-    // Setup track processor syncing (blur)
-    this.observeTrackProcessors(this.scope, room, trackerProcessorState$);
-    // Observe media device changes and update LiveKit active devices accordingly
-    this.observeMediaDevices(this.scope, devices, controlledAudioDevices);
-
-    this.workaroundRestartAudioInputTrackChrome(devices, this.scope);
-
-    this.connection.livekitRoom.localParticipant.on(
-      ParticipantEvent.LocalTrackPublished,
-      this.onLocalTrackPublished.bind(this),
-    );
-  }
-
-  public async destroy(): Promise<void> {
-    this.scope.end();
-    this.logger.info("Scope ended -> unset handler");
-    this.muteStates.audio.unsetHandler();
-    this.muteStates.video.unsetHandler();
-
-    this.logger.info(`Start to stop tracks`);
-    try {
-      await this.stopTracks();
-      this.logger.info(`Done to stop tracks`);
-    } catch (e) {
-      this.logger.error(`Failed to stop tracks: ${e}`);
-    }
-  }
-
-  // LiveKit will publish the tracks as soon as they are created
-  // but we want to control when tracks are published.
-  // We cannot just mute the tracks, even if this will effectively stop the publishing,
-  // it would also prevent the user from seeing their own video/audio preview.
-  // So for that we use pauseUpStream():  Stops sending media to the server by replacing
-  // the sender track with null, but keeps the local MediaStreamTrack active.
-  // The user can still see/hear themselves locally, but remote participants see nothing.
-  private onLocalTrackPublished(
-    localTrackPublication: LocalTrackPublication,
-  ): void {
-    this.logger.info("Local track published", localTrackPublication);
-    const lkRoom = this.connection.livekitRoom;
-    if (!this.shouldPublish) {
-      this.logger.debug("Not publishing, pausing upstream");
-      this.pauseUpstreams(lkRoom, [localTrackPublication.source]).catch((e) => {
-        this.logger.error(`Failed to pause upstreams`, e);
-      });
-    }
-    if (localTrackPublication.source === Track.Source.Microphone) {
-      const muteState = this.muteStates.audio;
-      // skip this if a sync is in progress: enabled$ still reflects the old
-      // state while the handler is mid-flight, so the handler itself will apply
-      // the correct mute state once it completes.
-      if (!muteState.syncing$.value) {
-        const enabled = muteState.enabled$.value;
-        if (!enabled) {
-          this.logger.info(
-            "Local audio track just published but muted meanwhile, setting enabled to false",
-          );
-          lkRoom.localParticipant.setMicrophoneEnabled(false).catch((e) => {
-            this.logger.error(
-              `Failed to enable microphone track, enabled:${enabled}`,
-              e,
-            );
-          });
-        }
-      }
-    } else if (localTrackPublication.source === Track.Source.Camera) {
-      const muteState = this.muteStates.video;
-      // skip this if a sync is in progress: enabled$ still reflects the old
-      // state while the handler is mid-flight, so the handler itself will apply
-      // the correct mute state once it completes.
-      if (!muteState.syncing$.value) {
-        const enabled = muteState.enabled$.value;
-        if (!enabled) {
-          this.logger.info(
-            "Local video track just published but muted meanwhile, setting enabled to false",
-          );
-          lkRoom.localParticipant.setCameraEnabled(false).catch((e) => {
-            this.logger.error(
-              `Failed to enable camera track, enabled:${enabled}`,
-              e,
-            );
-          });
-        }
-      }
-    }
-  }
-  /**
-   * Create and setup local audio and video tracks based on the current mute states.
-   * It creates the tracks only if audio and/or video is enabled, to avoid unnecessary
-   * permission prompts.
-   *
-   * It also observes mute state changes to update LiveKit microphone/camera states accordingly.
-   * If a track is not created initially because disabled, it will be created when unmuting.
-   *
-   * This call is not blocking anymore, instead callers can listen to the
-   * `RoomEvent.MediaDevicesError` event in the LiveKit room to be notified of any errors.
-   *
-   */
-  public async createAndSetupTracks(): Promise<void> {
-    this.logger.debug("createAndSetupTracks called");
-    const lkRoom = this.connection.livekitRoom;
-    // Observe mute state changes and update LiveKit microphone/camera states accordingly
-    this.observeMuteStates();
-
-    // Check if audio and/or video is enabled. We only create tracks if enabled,
-    // because it could prompt for permission, and we don't want to do that unnecessarily.
-    const audio = this.muteStates.audio.enabled$.value;
-    const video = this.muteStates.video.enabled$.value;
-
-    // We don't await the creation, because livekit could block until the tracks
-    // are fully published, and not only that they are created.
-    // We don't have control on that, localParticipant creates and publishes the tracks
-    // asap.
-    // We are using the `ParticipantEvent.LocalTrackPublished` to be notified
-    // when tracks are actually published, and at that point
-    // we can pause upstream if needed (depending on if startPublishing has been called).
-    if (audio && video) {
-      // Enable both at once in order to have a single permission prompt!
-      void lkRoom.localParticipant.enableCameraAndMicrophone();
-    } else if (audio) {
-      void lkRoom.localParticipant.setMicrophoneEnabled(true);
-    } else if (video) {
-      void lkRoom.localParticipant.setCameraEnabled(true);
-    }
-
-    return Promise.resolve();
-  }
-
-  private async pauseUpstreams(
-    lkRoom: LivekitRoom,
-    sources: Track.Source[],
-  ): Promise<void> {
-    for (const source of sources) {
-      const track = lkRoom.localParticipant.getTrackPublication(source)?.track;
-      if (track) {
-        await track.pauseUpstream();
-      } else {
-        this.logger.warn(
-          `No track found for source ${source} to pause upstream`,
-        );
-      }
-    }
-  }
-
-  private async resumeUpstreams(
-    lkRoom: LivekitRoom,
-    sources: Track.Source[],
-  ): Promise<void> {
-    for (const source of sources) {
-      const track = lkRoom.localParticipant.getTrackPublication(source)?.track;
-      if (track) {
-        await track.resumeUpstream();
-      } else {
-        this.logger.warn(
-          `No track found for source ${source} to resume upstream`,
-        );
-      }
-    }
-  }
-
-  /**
-   *
-   * Request to publish local tracks to the LiveKit room.
-   * This will wait for the connection to be ready before publishing.
-   * Livekit also have some local retry logic for publishing tracks.
-   * Can be called multiple times, localparticipant manages the state of published tracks (or pending publications).
-   *
-   * @returns
-   */
-  public async startPublishing(): Promise<void> {
-    if (this.shouldPublish) {
-      this.logger.debug(`Already publishing, ignoring startPublishing call`);
-      return;
-    }
-    this.shouldPublish = true;
-    this.logger.debug("startPublishing called");
-
-    const lkRoom = this.connection.livekitRoom;
-
-    // Resume upstream for both audio and video tracks
-    // We need to call it explicitly because call setTrackEnabled does not always
-    // resume upstream. It will only if you switch the track from disabled to enabled,
-    // but if the track is already enabled but upstream is paused, it won't resume it.
-    // TODO what about screen share?
-    try {
-      await this.resumeUpstreams(lkRoom, [
-        Track.Source.Microphone,
-        Track.Source.Camera,
-      ]);
-    } catch (e) {
-      this.logger.error(`Failed to resume upstreams`, e);
-    }
-  }
-
-  public async stopPublishing(): Promise<void> {
-    this.logger.debug("stopPublishing called");
-    this.shouldPublish = false;
-    // Pause upstream will stop sending media to the server, while keeping
-    // the local MediaStreamTrack active, so the user can still see themselves.
-    await this.pauseUpstreams(this.connection.livekitRoom, [
-      Track.Source.Microphone,
-      Track.Source.Camera,
-      Track.Source.ScreenShare,
-    ]);
-  }
-
-  public async stopTracks(): Promise<void> {
-    const lkRoom = this.connection.livekitRoom;
-    for (const source of [
-      Track.Source.Microphone,
-      Track.Source.Camera,
-      Track.Source.ScreenShare,
-    ]) {
-      const localPub = lkRoom.localParticipant.getTrackPublication(source);
-      if (localPub?.track) {
-        // stops and unpublishes the track
-        await lkRoom.localParticipant.unpublishTrack(localPub!.track, true);
-      }
-    }
-  }
-
-  /// Private methods
-
-  // Restart the audio input track whenever we detect that the active media
-  // device has changed to refer to a different hardware device. We do this
-  // for the sake of Chrome, which provides a "default" device that is meant
-  // to match the system's default audio input, whatever that may be.
-  // This is special-cased for only audio inputs because we need to dig around
-  // in the LocalParticipant object for the track object and there's not a nice
-  // way to do that generically. There is usually no OS-level default video capture
-  // device anyway, and audio outputs work differently.
-  private workaroundRestartAudioInputTrackChrome(
-    devices: MediaDevices,
-    scope: ObservableScope,
-  ): void {
-    const lkRoom = this.connection.livekitRoom;
-    devices.audioInput.selected$
-      .pipe(
-        switchMap((device) => device?.hardwareDeviceChange$ ?? NEVER),
-        scope.bind(),
-      )
-      .subscribe(() => {
-        if (lkRoom.state != LivekitConnectionState.Connected) return;
-        const activeMicTrack = Array.from(
-          lkRoom.localParticipant.audioTrackPublications.values(),
-        ).find((d) => d.source === Track.Source.Microphone)?.track;
-
-        if (
-          activeMicTrack &&
-          // only restart if the stream is still running: LiveKit will detect
-          // when a track stops & restart appropriately, so this is not our job.
-          // Plus, we need to avoid restarting again if the track is already in
-          // the process of being restarted.
-          activeMicTrack.mediaStreamTrack.readyState !== "ended"
-        ) {
-          this.logger?.info(
-            "Restarting audio device track due to active media device changed (workaroundRestartAudioInputTrackChrome)",
-          );
-          // Restart the track, which will cause Livekit to do another
-          // getUserMedia() call with deviceId: default to get the *new* default device.
-          // Note that room.switchActiveDevice() won't work: Livekit will ignore it because
-          // the deviceId hasn't changed (was & still is default).
-          lkRoom.localParticipant
-            .getTrackPublication(Track.Source.Microphone)
-            ?.audioTrack?.restartTrack()
-            .catch((e) => {
-              this.logger.error(`Failed to restart audio device track`, e);
-            });
-        }
-      });
-  }
-
-  // Observe changes in the selected media devices and update the LiveKit room accordingly.
-  private observeMediaDevices(
-    scope: ObservableScope,
-    devices: MediaDevices,
-    controlledAudioDevices: boolean,
-  ): void {
-    const lkRoom = this.connection.livekitRoom;
-    const syncDevice = (
-      kind: MediaDeviceKind,
-      selected$: Observable<SelectedDevice | undefined>,
-    ): Subscription =>
-      selected$.pipe(scope.bind()).subscribe((device) => {
-        if (lkRoom.state != LivekitConnectionState.Connected) return;
-        // if (this.connectionState$.value !== ConnectionState.Connected) return;
-        this.logger.info(
-          "[LivekitRoom] syncDevice room.getActiveDevice(kind) !== d.id :",
-          lkRoom.getActiveDevice(kind),
-          " !== ",
-          device?.id,
-        );
-        if (
-          device !== undefined &&
-          lkRoom.getActiveDevice(kind) !== device.id
-        ) {
-          lkRoom
-            .switchActiveDevice(kind, device.id)
-            .catch((e: Error) =>
-              this.logger.error(
-                `Failed to sync ${kind} device with LiveKit`,
-                e,
-              ),
-            );
-        }
-      });
-
-    syncDevice("audioinput", devices.audioInput.selected$);
-    if (!controlledAudioDevices)
-      syncDevice("audiooutput", devices.audioOutput.selected$);
-    syncDevice("videoinput", devices.videoInput.selected$);
-  }
-
-  /**
-   * Observe changes in the mute states and update the LiveKit room accordingly.
-   * @private
-   */
-  private observeMuteStates(): void {
-    const lkRoom = this.connection.livekitRoom;
-    this.muteStates.audio.setHandler(async (enable) => {
-      try {
-        this.logger.debug(
-          `handler: Setting LiveKit microphone enabled: ${enable}`,
-        );
-        await lkRoom.localParticipant.setMicrophoneEnabled(enable);
-        // Unmute will restart the track if it was paused upstream,
-        // but until explicitly requested, we want to keep it paused.
-        if (!this.shouldPublish && enable) {
-          await this.pauseUpstreams(lkRoom, [Track.Source.Microphone]);
-        }
-        return enable;
-      } catch (e) {
-        this.logger.error("Failed to update LiveKit audio input mute state", e);
-        return lkRoom.localParticipant.isMicrophoneEnabled;
-      }
-    });
-    this.muteStates.video.setHandler(async (enable) => {
-      try {
-        this.logger.debug(`handler: Setting LiveKit camera enabled: ${enable}`);
-        await lkRoom.localParticipant.setCameraEnabled(enable);
-        // Unmute will restart the track if it was paused upstream,
-        // but until explicitly requested, we want to keep it paused.
-        if (!this.shouldPublish && enable) {
-          await this.pauseUpstreams(lkRoom, [Track.Source.Camera]);
-        }
-        return enable;
-      } catch (e) {
-        this.logger.error("Failed to update LiveKit video input mute state", e);
-        return lkRoom.localParticipant.isCameraEnabled;
-      }
-    });
-  }
-
-  private observeTrackProcessors(
-    scope: ObservableScope,
-    room: LivekitRoom,
-    trackerProcessorState$: Behavior<ProcessorState>,
-  ): void {
-    const track$ = scope.behavior(
-      observeTrackReference$(room.localParticipant, Track.Source.Camera).pipe(
-        map((trackRef) => {
-          const track = trackRef?.publication.track;
-          return track instanceof LocalVideoTrack ? track : null;
-        }),
-      ),
-      null,
-    );
-    trackProcessorSync(scope, track$, trackerProcessorState$);
-  }
-}

src/state/CallViewModel/localMember/RtcTransportAutoDiscovery.test.ts

@@ -1,153 +0,0 @@
-/*
-Copyright 2025 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,
-  type MockedObject,
-  vi,
-} from "vitest";
-import { MatrixError } from "matrix-js-sdk";
-import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
-import {
-  type UnstableLivekitTransport,
-  type Transport,
-} from "matrix-js-sdk/lib/matrixrtc";
-
-import type { ResolvedConfigOptions } from "../../../config/ConfigOptions.ts";
-import {
-  RtcTransportAutoDiscovery,
-  type RtcTransportAutoDiscoveryProps,
-} from "./RtcTransportAutoDiscovery.ts";
-
-type DiscoveryClient = RtcTransportAutoDiscoveryProps["client"];
-
-const backendTransport: UnstableLivekitTransport = {
-  type: "livekit",
-  livekit_service_url: "https://backend.example.org",
-};
-
-const configTransport: UnstableLivekitTransport = {
-  type: "livekit",
-  livekit_service_url: "https://config.example.org",
-};
-
-function makeClient(): MockedObject<DiscoveryClient> {
-  return {
-    getDomain: vi.fn().mockReturnValue("example.org"),
-    baseUrl: "https://matrix.example.org",
-    _unstable_getRTCTransports: vi.fn().mockResolvedValue([]),
-    getOpenIdToken: vi.fn(),
-    getDeviceId: vi.fn(),
-  } as unknown as MockedObject<DiscoveryClient>;
-}
-
-function makeResolvedConfig(livekitServiceUrl?: string): ResolvedConfigOptions {
-  return {
-    livekit: livekitServiceUrl
-      ? {
-          livekit_service_url: livekitServiceUrl,
-        }
-      : undefined,
-  } as ResolvedConfigOptions;
-}
-
-describe("RtcTransportAutoDiscovery", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-  const VALID_TEST_CASES: Array<{ transports: Transport[] }> = [
-    { transports: [backendTransport] },
-    // will pick the first livekit transport in the list, even if there are other non-livekit transports
-    { transports: [{ type: "not_livekit" }, backendTransport] },
-  ];
-  it.each(VALID_TEST_CASES)(
-    "prefers backend transport other app config $transports",
-    async ({ transports }) => {
-      const client = makeClient();
-      client._unstable_getRTCTransports.mockResolvedValue(transports);
-
-      const discovery = new RtcTransportAutoDiscovery({
-        client,
-        resolvedConfig: makeResolvedConfig(configTransport.livekit_service_url),
-        logger: rootLogger,
-      });
-
-      const discoveredTransport = await discovery.discoverPreferredTransport();
-
-      expect(discoveredTransport).toStrictEqual(backendTransport);
-      expect(discoveredTransport).not.toStrictEqual(configTransport);
-
-      expect(client._unstable_getRTCTransports).toHaveBeenCalledTimes(1);
-    },
-  );
-
-  it("Retries limit_exceeded backend transport", async () => {
-    const client = makeClient();
-    client._unstable_getRTCTransports
-      .mockRejectedValueOnce(
-        new MatrixError(
-          {
-            errcode: "M_LIMIT_EXCEEDED",
-            error: "Too many requests",
-            retry_after_ms: 100,
-          },
-          429,
-        ),
-      )
-      .mockResolvedValue([backendTransport]);
-
-    const discovery = new RtcTransportAutoDiscovery({
-      client,
-      resolvedConfig: makeResolvedConfig("https://config.example.org"),
-      logger: rootLogger,
-    });
-
-    await expect(discovery.discoverPreferredTransport()).resolves.toStrictEqual(
-      backendTransport,
-    );
-
-    expect(client._unstable_getRTCTransports).toHaveBeenCalledTimes(2);
-  });
-
-  const INVALID_TEST_CASES: Array<{ transports: Transport[] }> = [
-    { transports: [] },
-    { transports: [{ type: "not_livekit" }] },
-  ];
-  it.each(INVALID_TEST_CASES)(
-    "falls back to config when backend has no (valid) livekit transports $transports",
-    async ({ transports }) => {
-      const client = makeClient();
-      client._unstable_getRTCTransports.mockResolvedValue(transports);
-
-      const discovery = new RtcTransportAutoDiscovery({
-        client,
-        resolvedConfig: makeResolvedConfig(configTransport.livekit_service_url),
-        logger: rootLogger,
-      });
-
-      const discoveredTransport = await discovery.discoverPreferredTransport();
-      expect(discoveredTransport).not.toStrictEqual(backendTransport);
-      expect(discoveredTransport).toStrictEqual(configTransport);
-    },
-  );
-
-  it("returns null when backend and config are all unavailable", async () => {
-    const client = makeClient();
-    client._unstable_getRTCTransports.mockResolvedValue([]);
-
-    const discovery = new RtcTransportAutoDiscovery({
-      client,
-      resolvedConfig: makeResolvedConfig(undefined),
-      logger: rootLogger,
-    });
-
-    await expect(discovery.discoverPreferredTransport()).resolves.toBeNull();
-  });
-});

src/state/CallViewModel/localMember/RtcTransportAutoDiscovery.ts

@@ -1,103 +0,0 @@
-/*
-Copyright 2026 Element Creations Ltd.
-
-SPDX-License-IdFentifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-import {
-  isUnstableLivekitTransport,
-  type UnstableLivekitTransport,
-} from "matrix-js-sdk/lib/matrixrtc";
-import { type MatrixClient } from "matrix-js-sdk";
-import { type Logger } from "matrix-js-sdk/lib/logger";
-
-import type { ResolvedConfigOptions } from "../../../config/ConfigOptions.ts";
-import { doNetworkOperationWithRetry } from "../../../utils/matrix.ts";
-
-type TransportDiscoveryClient = Pick<
-  MatrixClient,
-  "getDomain" | "_unstable_getRTCTransports"
->;
-
-export interface RtcTransportAutoDiscoveryProps {
-  client: TransportDiscoveryClient;
-  resolvedConfig: ResolvedConfigOptions;
-  logger: Logger;
-}
-
-export class RtcTransportAutoDiscovery {
-  private readonly client: TransportDiscoveryClient;
-  private readonly resolvedConfig: ResolvedConfigOptions;
-  private readonly logger: Logger;
-
-  public constructor({
-    client,
-    resolvedConfig,
-    logger,
-  }: RtcTransportAutoDiscoveryProps) {
-    this.client = client;
-    this.resolvedConfig = resolvedConfig;
-    this.logger = logger.getChild("[RtcTransportAutoDiscovery]");
-  }
-
-  public async discoverPreferredTransport(): Promise<UnstableLivekitTransport | null> {
-    // 1) backend transports
-    const backendTransport = await this.tryBackendTransports();
-    if (backendTransport) {
-      this.logger.info(
-        `Found backend transport: ${JSON.stringify(backendTransport)}`,
-      );
-      return backendTransport;
-    }
-
-    // 2) app config URL
-    const configTransport = this.tryConfigTransport();
-    if (configTransport) {
-      this.logger.info(
-        `Found app config transport: ${JSON.stringify(configTransport)}`,
-      );
-      return configTransport;
-    }
-
-    return null;
-  }
-
-  /**
-   * Fetches the first rtc_foci from the backend.
-   * This will not throw errors, but instead just log them and return null if the expected config is not found or malformed.
-   * @private
-   */
-  private async tryBackendTransports(): Promise<UnstableLivekitTransport | null> {
-    const client = this.client;
-    // MSC4143: Attempt to fetch transports from backend.
-    this.logger.info("First try to use getRTCTransports end point ...");
-    try {
-      const transportList = await doNetworkOperationWithRetry(async () =>
-        client._unstable_getRTCTransports(),
-      );
-      const first = transportList.find(isUnstableLivekitTransport);
-      if (first) {
-        return first;
-      } else {
-        this.logger.info(
-          `No livekit transport found in getRTCTransports end point`,
-          transportList,
-        );
-      }
-    } catch (ex) {
-      this.logger.info(`Failed to use getRTCTransports end point: ${ex}`);
-    }
-    return null;
-  }
-
-  private tryConfigTransport(): UnstableLivekitTransport | null {
-    const url = this.resolvedConfig.livekit?.livekit_service_url;
-    if (url) {
-      return {
-        type: "livekit",
-        livekit_service_url: url,
-      };
-    }
-    return null;
-  }
-}

src/state/CallViewModel/remoteMembers/Connection.test.ts

@@ -1,749 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-Copyright 2025 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  type MockedObject,
-  onTestFinished,
-  vi,
-} from "vitest";
-import {
-  type LocalParticipant,
-  type RemoteParticipant,
-  type RemoteTrack,
-  type RemoteTrackPublication,
-  type Room as LivekitRoom,
-  RoomEvent,
-  Track,
-  ConnectionState as LivekitConnectionState,
-} from "livekit-client";
-import fetchMock from "fetch-mock";
-import EventEmitter from "events";
-import { MatrixError } from "matrix-js-sdk";
-import { logger, type Logger } from "matrix-js-sdk/lib/logger";
-import {
-  type LivekitGetTokenResponse,
-  type UnstableLivekitTransport,
-} from "matrix-js-sdk/lib/matrixrtc";
-
-import {
-  Connection,
-  type ConnectionState,
-  type ConnectionOpts,
-} from "./Connection.ts";
-import { ObservableScope } from "../../ObservableScope.ts";
-import { FailToGetOpenIdToken } from "../../../utils/errors.ts";
-import { testJWTToken } from "../../../utils/test-fixtures.ts";
-import { mockRemoteParticipant, ownMemberMock } from "../../../utils/test.ts";
-import {
-  type ClientGetTokenParts,
-  type ClientOpenIDParts,
-} from "../../../livekit/auth";
-
-let testScope: ObservableScope;
-
-let client: MockedObject<ClientGetTokenParts & ClientOpenIDParts>;
-
-let fakeLivekitRoom: MockedObject<LivekitRoom>;
-
-let localParticipantEventEmiter: EventEmitter;
-let fakeLocalParticipant: MockedObject<LocalParticipant>;
-
-const ROOM_ID = "!roomID:example.org";
-const SLOT_ID = "m.call#ROOM";
-
-const transport: UnstableLivekitTransport = {
-  type: "livekit",
-  url: "wss://matrix-rtc.m.localhost/livekit/sfu",
-};
-
-function setupTest(): void {
-  testScope = new ObservableScope();
-  client = vi.mocked<ClientGetTokenParts & ClientOpenIDParts>({
-    getOpenIdToken: vi.fn().mockResolvedValue({
-      access_token: "rYsmGUEwNjKgJYyeNUkZseJN",
-      token_type: "Bearer",
-      matrix_server_name: "example.org",
-      expires_in: 3600,
-    }),
-    _unstable_getLivekitToken: vi.fn().mockResolvedValue({ jwt: testJWTToken }),
-  });
-
-  localParticipantEventEmiter = new EventEmitter();
-
-  fakeLocalParticipant = vi.mocked<LocalParticipant>({
-    identity: "@me:example.org",
-    isMicrophoneEnabled: vi.fn().mockReturnValue(true),
-    getTrackPublication: vi.fn().mockReturnValue(undefined),
-    on: localParticipantEventEmiter.on.bind(localParticipantEventEmiter),
-    off: localParticipantEventEmiter.off.bind(localParticipantEventEmiter),
-    addListener: localParticipantEventEmiter.addListener.bind(
-      localParticipantEventEmiter,
-    ),
-    removeListener: localParticipantEventEmiter.removeListener.bind(
-      localParticipantEventEmiter,
-    ),
-    removeAllListeners: localParticipantEventEmiter.removeAllListeners.bind(
-      localParticipantEventEmiter,
-    ),
-  } as unknown as LocalParticipant);
-
-  const fakeRoomEventEmitter = new EventEmitter();
-  fakeLivekitRoom = vi.mocked<LivekitRoom>({
-    connect: vi.fn(),
-    disconnect: vi.fn(),
-    remoteParticipants: new Map(),
-    localParticipant: fakeLocalParticipant,
-    state: LivekitConnectionState.Disconnected,
-    on: fakeRoomEventEmitter.on.bind(fakeRoomEventEmitter),
-    off: fakeRoomEventEmitter.off.bind(fakeRoomEventEmitter),
-    addListener: fakeRoomEventEmitter.addListener.bind(fakeRoomEventEmitter),
-    removeListener:
-      fakeRoomEventEmitter.removeListener.bind(fakeRoomEventEmitter),
-    removeAllListeners:
-      fakeRoomEventEmitter.removeAllListeners.bind(fakeRoomEventEmitter),
-    setE2EEEnabled: vi.fn().mockResolvedValue(undefined),
-    emit: (eventName: string | symbol, ...args: unknown[]) => {
-      fakeRoomEventEmitter.emit(eventName, ...args);
-    },
-  } as unknown as LivekitRoom);
-}
-
-function setupRemoteConnection(): Connection {
-  const opts: ConnectionOpts = {
-    client,
-    roomId: ROOM_ID,
-    slotId: SLOT_ID,
-    role: "subscriber",
-    transport,
-    serverName: "m.localhost",
-    scope: testScope,
-    ownMembershipIdentity: ownMemberMock,
-    livekitRoomFactory: () => fakeLivekitRoom,
-  };
-
-  fakeLivekitRoom.connect.mockImplementation(async (): Promise<void> => {
-    const changeEv = RoomEvent.ConnectionStateChanged;
-
-    fakeLivekitRoom.state = LivekitConnectionState.Connecting;
-    fakeLivekitRoom.emit(changeEv, fakeLivekitRoom.state);
-    fakeLivekitRoom.state = LivekitConnectionState.Connected;
-    fakeLivekitRoom.emit(changeEv, fakeLivekitRoom.state);
-
-    return Promise.resolve();
-  });
-
-  return new Connection(opts, logger);
-}
-
-afterEach(() => {
-  vi.useRealTimers();
-  vi.clearAllMocks();
-  fetchMock.reset();
-});
-
-describe("Start connection states", () => {
-  beforeEach(() => {
-    fetchMock.post(
-      `https://matrix-rtc.example.org/livekit/jwt/get_token`,
-      () => {
-        return {
-          // Return a non-retryable error, if not, the retry logic will
-          // wait and fail the test with a timeout.
-          status: 404,
-        };
-      },
-    );
-  });
-
-  it("start in initialized state", () => {
-    setupTest();
-
-    const opts: ConnectionOpts = {
-      client,
-      roomId: ROOM_ID,
-      slotId: SLOT_ID,
-      role: "subscriber",
-      transport,
-      serverName: "m.localhost",
-      scope: testScope,
-      ownMembershipIdentity: ownMemberMock,
-      livekitRoomFactory: () => fakeLivekitRoom,
-    };
-    const connection = new Connection(opts, logger);
-
-    expect(connection.state$.getValue()).toEqual({ state: "initialized" });
-  });
-
-  it("fail to get SFU token then error state", async () => {
-    setupTest();
-    vi.useFakeTimers();
-
-    const opts: ConnectionOpts = {
-      client,
-      roomId: ROOM_ID,
-      slotId: SLOT_ID,
-      role: "subscriber",
-      transport,
-      serverName: "m.localhost",
-      scope: testScope,
-      ownMembershipIdentity: ownMemberMock,
-      livekitRoomFactory: () => fakeLivekitRoom,
-    };
-
-    const connection = new Connection(opts, logger);
-
-    const capturedStates: ConnectionState[] = [];
-    const s = connection.state$.subscribe((value) => {
-      capturedStates.push(value);
-    });
-    onTestFinished(() => s.unsubscribe());
-
-    const deferred = Promise.withResolvers<LivekitGetTokenResponse>();
-
-    client._unstable_getLivekitToken.mockImplementation(
-      async (): Promise<LivekitGetTokenResponse> => {
-        return await deferred.promise;
-      },
-    );
-
-    connection.start().catch(() => {
-      // expected to throw
-    });
-
-    let capturedState = capturedStates.pop();
-    expect(capturedState).toBeDefined();
-    expect(capturedState).toEqual({ state: "authenticating" });
-
-    deferred.reject(new FailToGetOpenIdToken(new Error("Failed to get token")));
-
-    await vi.runAllTimersAsync();
-
-    capturedState = capturedStates.pop();
-    if (capturedState?.state === "error") {
-      expect(capturedState.error.message).toEqual("Something went wrong");
-      expect(connection.transport).toEqual(transport);
-    } else {
-      expect.fail(
-        "Expected FailedToStart state but got " + JSON.stringify(capturedState),
-      );
-    }
-  });
-
-  it("fail to get JWT token and error state", async () => {
-    setupTest();
-    vi.useFakeTimers();
-
-    const opts: ConnectionOpts = {
-      client,
-      roomId: ROOM_ID,
-      slotId: SLOT_ID,
-      role: "subscriber",
-      transport,
-      serverName: "m.localhost",
-      scope: testScope,
-      ownMembershipIdentity: ownMemberMock,
-      livekitRoomFactory: () => fakeLivekitRoom,
-    };
-
-    const connection = new Connection(opts, logger);
-
-    const capturedStates: ConnectionState[] = [];
-    const s = connection.state$.subscribe((value) => {
-      capturedStates.push(value);
-    });
-    onTestFinished(() => s.unsubscribe());
-
-    const deferredSFU = Promise.withResolvers<void>();
-    client._unstable_getLivekitToken.mockImplementation(async () => {
-      await deferredSFU.promise;
-      throw new MatrixError(
-        {
-          errcode: "M_LOOKUP_FAILED",
-          error: "Failed to look up user info from homeserver",
-        },
-        500,
-      );
-    });
-
-    connection.start().catch(() => {
-      // expected to throw
-    });
-
-    let capturedState = capturedStates.pop();
-    expect(capturedState).toBeDefined();
-    expect(capturedState).toEqual({ state: "authenticating" });
-
-    deferredSFU.resolve();
-    await vi.runAllTimersAsync();
-
-    capturedState = capturedStates.pop();
-
-    if (
-      capturedState?.state === "error" &&
-      capturedState.error.cause instanceof Error
-    ) {
-      expect(capturedState.error.cause.message).toContain(
-        "Failed to look up user info from homeserver",
-      );
-      expect(connection.transport).toEqual(transport);
-    } else {
-      expect.fail(
-        "Expected FailedToStart state but got " + JSON.stringify(capturedState),
-      );
-    }
-  });
-
-  it("fail to connect to livekit error state", async () => {
-    setupTest();
-    vi.useFakeTimers();
-
-    const opts: ConnectionOpts = {
-      client,
-      roomId: ROOM_ID,
-      slotId: SLOT_ID,
-      role: "subscriber",
-      transport,
-      serverName: "m.localhost",
-      scope: testScope,
-      ownMembershipIdentity: ownMemberMock,
-      livekitRoomFactory: () => fakeLivekitRoom,
-    };
-
-    const connection = new Connection(opts, logger);
-
-    const capturedStates: ConnectionState[] = [];
-    const s = connection.state$.subscribe((value) => {
-      capturedStates.push(value);
-    });
-    onTestFinished(() => s.unsubscribe());
-
-    const deferredSFU = Promise.withResolvers<void>();
-    fakeLivekitRoom.connect.mockImplementation(async () => {
-      await deferredSFU.promise;
-      throw new Error("Failed to connect to livekit");
-    });
-
-    connection.start().catch(() => {
-      // expected to throw
-    });
-
-    let capturedState = capturedStates.pop();
-    expect(capturedState).toBeDefined();
-
-    expect(capturedState).toEqual({ state: "authenticating" });
-
-    deferredSFU.resolve();
-    await vi.runAllTimersAsync();
-
-    capturedState = capturedStates.pop();
-
-    if (
-      capturedState?.state === "error" &&
-      capturedState.error.cause instanceof Error
-    ) {
-      expect(capturedState.error.cause.message).toContain(
-        "Failed to connect to livekit",
-      );
-      expect(connection.transport).toEqual(transport);
-    } else {
-      expect.fail(
-        "Expected FailedToStart state but got " + JSON.stringify(capturedState),
-      );
-    }
-  });
-
-  it("connection states happy path", async () => {
-    vi.useFakeTimers();
-    setupTest();
-
-    const connection = setupRemoteConnection();
-
-    const capturedStates: ConnectionState[] = [];
-    const s = connection.state$.subscribe((value) => {
-      capturedStates.push(value);
-    });
-    onTestFinished(() => s.unsubscribe());
-
-    await connection.start();
-    await vi.runAllTimersAsync();
-
-    const initialState = capturedStates.shift();
-    expect(initialState).toEqual({ state: "initialized" });
-    const fetchingState = capturedStates.shift();
-    expect(fetchingState).toEqual({ state: "authenticating" });
-    const disconnectedState = capturedStates.shift();
-    expect(disconnectedState).toEqual({
-      state: "authenticated",
-      livekitState: LivekitConnectionState.Disconnected,
-    });
-    const connectingState = capturedStates.shift();
-    expect(connectingState).toEqual({
-      state: "authenticated",
-      livekitState: LivekitConnectionState.Connecting,
-    });
-    const connectedState = capturedStates.shift();
-    expect(connectedState).toEqual({
-      state: "authenticated",
-      livekitState: LivekitConnectionState.Connected,
-    });
-  });
-
-  it("stopping while connecting does not report an error", async () => {
-    setupTest();
-    const connection = setupRemoteConnection();
-
-    const capturedStates: ConnectionState[] = [];
-    const s = connection.state$.subscribe((value) => {
-      capturedStates.push(value);
-    });
-    onTestFinished(() => s.unsubscribe());
-
-    // livekit-client rejects a pending connect() when disconnect() is called.
-    const pendingConnect = Promise.withResolvers<void>();
-    fakeLivekitRoom.connect.mockReturnValue(pendingConnect.promise);
-    fakeLivekitRoom.disconnect.mockResolvedValue(undefined);
-
-    const started = connection.start();
-    await vi.waitFor(() => expect(fakeLivekitRoom.connect).toHaveBeenCalled());
-    const stopping = connection.stop();
-    pendingConnect.reject(new Error("Client initiated disconnect"));
-    await stopping;
-
-    // start() resolves rather than rejecting (it is not awaited by the caller,
-    // so a rejection would be unhandled).
-    await expect(started).resolves.toBeUndefined();
-    expect(capturedStates.at(-1)).toEqual({ state: "stopped" });
-    expect(capturedStates.some((st) => st instanceof Error)).toBe(false);
-  });
-
-  it("shutting down the scope should stop the connection", async () => {
-    setupTest();
-    vi.useFakeTimers();
-
-    const connection = setupRemoteConnection();
-    await connection.start();
-
-    const stopSpy = vi.spyOn(connection, "stop");
-    testScope.end();
-
-    expect(stopSpy).toHaveBeenCalled();
-    expect(fakeLivekitRoom.disconnect).toHaveBeenCalled();
-  });
-});
-
-describe("remote participants", () => {
-  it("emits the list of remote participants", () => {
-    setupTest();
-
-    const connection = setupRemoteConnection();
-
-    const observedParticipants: RemoteParticipant[][] = [];
-    const s = connection.remoteParticipants$.subscribe((participants) => {
-      observedParticipants.push(participants);
-    });
-    onTestFinished(() => s.unsubscribe());
-    // The remoteParticipants$ observable is derived from the current members of the
-    // livekitRoom and the rtc membership in order to publish the members that are publishing
-    // on this connection.
-
-    let participants: RemoteParticipant[] = [
-      mockRemoteParticipant({ identity: "@alice:example.org:DEV000" }),
-      mockRemoteParticipant({ identity: "@bob:example.org:DEV111" }),
-      mockRemoteParticipant({ identity: "@carol:example.org:DEV222" }),
-      // Mock Dan to have no published tracks. We want him to still show show up
-      // in the participants list.
-      mockRemoteParticipant({
-        identity: "@dan:example.org:DEV333",
-        getTrackPublication: () => undefined,
-        getTrackPublications: () => [],
-      }),
-    ];
-
-    // Let's simulate 3 members on the livekitRoom
-    vi.spyOn(fakeLivekitRoom, "remoteParticipants", "get").mockImplementation(
-      () => new Map(participants.map((p) => [p.identity, p])),
-    );
-
-    participants.forEach((p) =>
-      fakeLivekitRoom.emit(RoomEvent.ParticipantConnected, p),
-    );
-
-    // At this point there should be ~~no~~ publishers
-    // We do have publisher now, since we do not filter for publishers anymore (to also have participants with only data tracks)
-    // The filtering we do is just based on the matrixRTC member events.
-    expect(observedParticipants.pop()!.length).toEqual(4);
-
-    participants = [
-      mockRemoteParticipant({ identity: "@alice:example.org:DEV000" }),
-      mockRemoteParticipant({ identity: "@bob:example.org:DEV111" }),
-      mockRemoteParticipant({ identity: "@carol:example.org:DEV222" }),
-      mockRemoteParticipant({ identity: "@dan:example.org:DEV333" }),
-    ];
-    participants.forEach((p) =>
-      fakeLivekitRoom.emit(RoomEvent.ParticipantConnected, p),
-    );
-
-    // At this point there should be no publishers
-    expect(observedParticipants.pop()!.length).toEqual(4);
-  });
-
-  it("should be scoped to parent scope", (): void => {
-    setupTest();
-
-    const connection = setupRemoteConnection();
-
-    let observedParticipants: RemoteParticipant[][] = [];
-    const s = connection.remoteParticipants$.subscribe((participants) => {
-      observedParticipants.push(participants);
-    });
-    onTestFinished(() => s.unsubscribe());
-
-    let participants: RemoteParticipant[] = [
-      mockRemoteParticipant({ identity: "@bob:example.org:DEV111" }),
-    ];
-
-    // Let's simulate 3 members on the livekitRoom
-    vi.spyOn(fakeLivekitRoom, "remoteParticipants", "get").mockImplementation(
-      () => new Map(participants.map((p) => [p.identity, p])),
-    );
-
-    for (const participant of participants) {
-      fakeLivekitRoom.emit(RoomEvent.ParticipantConnected, participant);
-    }
-
-    // We should have bob as a participant now
-    const ps = observedParticipants.pop();
-    expect(ps?.length).toEqual(1);
-    expect(ps?.[0]?.identity).toEqual("@bob:example.org:DEV111");
-
-    // end the parent scope
-    testScope.end();
-    observedParticipants = [];
-
-    // SHOULD NOT emit any more participants as the scope is ended
-    participants = participants.filter(
-      (p) => p.identity !== "@bob:example.org:DEV111",
-    );
-
-    fakeLivekitRoom.emit(
-      RoomEvent.ParticipantDisconnected,
-      mockRemoteParticipant({ identity: "@bob:example.org:DEV111" }),
-    );
-
-    expect(observedParticipants.length).toEqual(0);
-  });
-});
-
-describe("remote track logging", () => {
-  it("logs remote participant and track events on the connection logger", () => {
-    setupTest();
-    const info = vi.fn();
-    const warn = vi.fn();
-    const testLogger = {
-      getChild: (): unknown => testLogger,
-      info,
-      debug: vi.fn(),
-      warn,
-      error: vi.fn(),
-    } as unknown as Logger;
-    new Connection(
-      {
-        client,
-        roomId: ROOM_ID,
-        slotId: SLOT_ID,
-        role: "subscriber",
-        transport,
-        serverName: "m.localhost",
-        scope: testScope,
-        ownMembershipIdentity: ownMemberMock,
-        livekitRoomFactory: () => fakeLivekitRoom,
-      },
-      testLogger,
-    );
-    info.mockClear(); // drop the constructor log line
-
-    const bob = mockRemoteParticipant({
-      identity: "@bob:example.org:DEV111",
-      sid: "PA_bob",
-    });
-    const pub = {
-      kind: "audio",
-      source: "microphone",
-      trackSid: "TR_mic",
-      isMuted: false,
-      isEncrypted: true,
-    } as unknown as RemoteTrackPublication;
-    const messages = (): string[] => info.mock.calls.map((c) => c[0] as string);
-
-    fakeLivekitRoom.emit(RoomEvent.ParticipantConnected, bob);
-    fakeLivekitRoom.emit(
-      RoomEvent.TrackSubscribed,
-      {} as RemoteTrack,
-      pub,
-      bob,
-    );
-    fakeLivekitRoom.emit(RoomEvent.TrackMuted, pub, bob);
-    fakeLivekitRoom.emit(
-      RoomEvent.TrackStreamStateChanged,
-      pub,
-      Track.StreamState.Paused,
-      bob,
-    );
-    expect(messages()).toEqual([
-      "Participant connected: @bob:example.org:DEV111 (PA_bob)",
-      "Subscribed: audio microphone TR_mic of @bob:example.org:DEV111 encrypted=true muted=false",
-      "Muted: audio microphone TR_mic of @bob:example.org:DEV111 encrypted=true",
-      "Stream paused: audio microphone TR_mic of @bob:example.org:DEV111 encrypted=true",
-    ]);
-
-    // Encryption status changes are logged; cryptor errors are warnings
-    fakeLivekitRoom.emit(
-      RoomEvent.ParticipantEncryptionStatusChanged,
-      false,
-      bob,
-    );
-    expect(messages().at(-1)).toBe(
-      "Encryption status of @bob:example.org:DEV111: encrypted=false",
-    );
-    const cryptorError = new Error("missing key at index 3");
-    fakeLivekitRoom.emit(RoomEvent.EncryptionError, cryptorError, bob);
-    expect(warn).toHaveBeenCalledWith(
-      "Encryption error for @bob:example.org:DEV111:",
-      cryptorError,
-    );
-
-    // Local mute events are already logged by the Publisher
-    fakeLivekitRoom.emit(RoomEvent.TrackMuted, pub, {
-      ...fakeLocalParticipant,
-      isLocal: true,
-    } as unknown as LocalParticipant);
-    expect(messages().filter((m) => m.startsWith("Muted"))).toHaveLength(1);
-
-    // Listeners are removed when the scope ends
-    testScope.end();
-    fakeLivekitRoom.emit(RoomEvent.ParticipantDisconnected, bob);
-    expect(
-      messages().filter((m) => m.startsWith("Participant disconnected")),
-    ).toHaveLength(0);
-  });
-});
-
-//
-// NOT USED ANYMORE ?
-//
-// This setup look like sth for the Publisher. Not a connection.
-
-// describe("PublishConnection", () => {
-//   // let fakeBlurProcessor: ProcessorWrapper<BackgroundOptions>;
-//   let roomFactoryMock: Mock<() => LivekitRoom>;
-//   let muteStates: MockedObject<MuteStates>;
-
-//   function setUpPublishConnection(): void {
-//     setupTest();
-
-//     roomFactoryMock = vi.fn().mockReturnValue(fakeLivekitRoom);
-
-//     muteStates = mockMuteStates();
-
-//     // fakeBlurProcessor = vi.mocked<ProcessorWrapper<BackgroundOptions>>({
-//     //   name: "BackgroundBlur",
-//     //   restart: vi.fn().mockResolvedValue(undefined),
-//     //   setOptions: vi.fn().mockResolvedValue(undefined),
-//     //   getOptions: vi.fn().mockReturnValue({ strength: 0.5 }),
-//     //   isRunning: vi.fn().mockReturnValue(false)
-//     // });
-//   }
-
-// describe("Livekit room creation", () => {
-//   function createSetup(): void {
-//     setUpPublishConnection();
-
-//     const fakeTrackProcessorSubject$ = new BehaviorSubject<ProcessorState>({
-//       supported: true,
-//       processor: undefined,
-//     });
-
-//     const opts: ConnectionOpts = {
-//       client: client,
-//       transport: livekitFocus,
-//       scope: testScope,
-//       livekitRoomFactory: roomFactoryMock,
-//     };
-
-//     const audioInput = {
-//       available$: of(new Map([["mic1", { id: "mic1" }]])),
-//       selected$: new BehaviorSubject({ id: "mic1" }),
-//       select(): void {},
-//     };
-
-//     const videoInput = {
-//       available$: of(new Map([["cam1", { id: "cam1" }]])),
-//       selected$: new BehaviorSubject({ id: "cam1" }),
-//       select(): void {},
-//     };
-
-//     const audioOutput = {
-//       available$: of(new Map([["speaker", { id: "speaker" }]])),
-//       selected$: new BehaviorSubject({ id: "speaker" }),
-//       select(): void {},
-//     };
-
-//     // TODO understand what is wrong with our mocking that requires ts-expect-error
-//     const fakeDevices = mockMediaDevices({
-//       // @ts-expect-error Mocking only
-//       audioInput,
-//       // @ts-expect-error Mocking only
-//       videoInput,
-//       // @ts-expect-error Mocking only
-//       audioOutput,
-//     });
-
-//     new Connection(
-//       opts,
-//       fakeDevices,
-//       muteStates,
-//       undefined,
-//       fakeTrackProcessorSubject$,
-//     );
-//   }
-
-//   it("should create room with proper initial audio and video settings", () => {
-//     createSetup();
-
-//     expect(roomFactoryMock).toHaveBeenCalled();
-
-//     const lastCallArgs =
-//       roomFactoryMock.mock.calls[roomFactoryMock.mock.calls.length - 1];
-
-//     const roomOptions = lastCallArgs.pop() as unknown as RoomOptions;
-//     expect(roomOptions).toBeDefined();
-
-//     expect(roomOptions!.videoCaptureDefaults?.deviceId).toEqual("cam1");
-//     expect(roomOptions!.audioCaptureDefaults?.deviceId).toEqual("mic1");
-//     expect(roomOptions!.audioOutput?.deviceId).toEqual("speaker");
-//   });
-
-//   it("respect controlledAudioDevices", () => {
-//     // TODO: Refactor the code to make it testable.
-//     // The UrlParams module is a singleton has a cache and is very hard to test.
-//     // This breaks other tests as well if not handled properly.
-//     // vi.mock(import("./../UrlParams"), () => {
-//     //   return {
-//     //     getUrlParams: vi.fn().mockReturnValue({
-//     //       controlledAudioDevices: true
-//     //     })
-//     //   };
-//     // });
-//   });
-// });
-// });

src/state/CallViewModel/remoteMembers/Connection.ts

@@ -1,417 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-Copyright 2025 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import {
-  connectedParticipantsObserver,
-  connectionStateObserver,
-} from "@livekit/components-core";
-import {
-  ConnectionError,
-  ConnectionErrorReason,
-  type ConnectionState as LivekitConnectionState,
-  type Participant,
-  type RemoteParticipant,
-  type RemoteTrackPublication,
-  type Room as LivekitRoom,
-  RoomEvent,
-  type SubscriptionError,
-  type Track,
-  type TrackPublication,
-} from "livekit-client";
-import { type UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
-import { BehaviorSubject } from "rxjs";
-import { type Logger } from "matrix-js-sdk/lib/logger";
-import { type CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
-
-import { type Behavior } from "../../Behavior.ts";
-import { type ObservableScope } from "../../ObservableScope.ts";
-import {
-  ElementCallError,
-  InsufficientCapacityError,
-  LivekitConnectionError,
-  PeerConnectionTimeoutError,
-  SFURoomCreationRestrictedError,
-  UnknownCallError,
-} from "../../../utils/errors.ts";
-import {
-  type ClientGetTokenParts,
-  getSFUConfig,
-  type ClientOpenIDParts,
-  type SFUConfig,
-} from "../../../livekit/auth";
-
-export interface ConnectionOpts {
-  /** The identity parts to use on this connection */
-  ownMembershipIdentity: CallMembershipIdentityParts;
-  /** Whether we want to publish or only subscribe on this connection. */
-  role: "publisher" | "subscriber";
-  /** The media transport to connect to. */
-  transport: UnstableLivekitTransport;
-  /** The name of the homeserver to which the {@link transport} belongs. */
-  serverName: string;
-  /** The Matrix client to use for OpenID and SFU config requests. */
-  client: ClientGetTokenParts & ClientOpenIDParts;
-  /** The ID of the Matrix room in which the session takes place. */
-  roomId: string;
-  /** The ID of the MatrixRTC slot in which the session takes place. */
-  slotId: string;
-  /** The observable scope to use for this connection. */
-  scope: ObservableScope;
-
-  /** Optional factory to create the LiveKit room, mainly for testing purposes. */
-  livekitRoomFactory: () => LivekitRoom;
-}
-
-export type ConnectionState =
-  // The start state of a connection. It has been created but nothing has loaded yet.
-  | { state: "initialized" }
-  // `start` has been called on the connection. It acquires the JWT token to connect to the LK room.
-  | { state: "authenticating" }
-  | { state: "authenticated"; livekitState: LivekitConnectionState }
-  | { state: "error"; error: ElementCallError }
-  | { state: "stopped" };
-
-/**
- * A connection to a Matrix RTC LiveKit backend.
- *
- * Expose observables for participants and connection state.
- */
-export class Connection {
-  // Private Behavior
-  private readonly _state$ = new BehaviorSubject<ConnectionState>({
-    state: "initialized",
-  });
-
-  /**
-   * The current state of the connection to the media transport.
-   */
-  public readonly state$: Behavior<ConnectionState> = this._state$;
-
-  /**
-   * Whether we want to publish or only subscribe on this connection.
-   */
-  public readonly role: "publisher" | "subscriber";
-
-  /**
-   * The media transport to connect to.
-   */
-  public readonly transport: UnstableLivekitTransport;
-
-  /**
-   * The name of the homeserver to which the {@link transport} belongs.
-   */
-  public readonly serverName: string;
-
-  public readonly livekitRoom: LivekitRoom;
-
-  private scope: ObservableScope;
-
-  /**
-   * The remote LiveKit participants that are visible on this connection.
-   *
-   * Note that this may include participants that are connected only to
-   * subscribe, or publishers that are otherwise unattested in MatrixRTC state.
-   * It is therefore more low-level than what should be presented to the user.
-   */
-  public readonly remoteParticipants$: Behavior<RemoteParticipant[]>;
-
-  /**
-   * The alias of the LiveKit room.
-   */
-  public get livekitAlias(): string | undefined {
-    return this._livekitAlias;
-  }
-  private _livekitAlias?: string;
-
-  /**
-   * Whether the connection has been stopped.
-   * @see Connection.stop
-   * */
-  protected stopped = false;
-
-  // TODO: can we just keep the ConnectionOpts object instead of spreading?
-  private readonly client: ClientGetTokenParts & ClientOpenIDParts;
-  private readonly roomId: string;
-  private readonly slotId: string;
-  private readonly logger: Logger;
-  private readonly ownMembershipIdentity: CallMembershipIdentityParts;
-  /**
-   * Creates a new connection to a matrix RTC LiveKit backend.
-   *
-   * @param opts - Connection options {@link ConnectionOpts}.
-   *
-   * @param logger - The logger to use.
-   */
-  public constructor(opts: ConnectionOpts, logger: Logger) {
-    this.ownMembershipIdentity = opts.ownMembershipIdentity;
-    this.roomId = opts.roomId;
-    this.slotId = opts.slotId;
-    this.logger = logger.getChild(
-      `[Connection ${JSON.stringify(opts.transport)}]`,
-    );
-    this.logger.debug(`constructor called`);
-    const { role, transport, serverName, client, scope } = opts;
-
-    this.scope = scope;
-    this.livekitRoom = opts.livekitRoomFactory();
-    this.role = role;
-    this.transport = transport;
-    this.serverName = serverName;
-    this.client = client;
-
-    this.remoteParticipants$ = scope.behavior(
-      // Only tracks remote participants
-      connectedParticipantsObserver(this.livekitRoom),
-    );
-    this.logRemoteTrackEvents();
-
-    scope.onEnd(() => {
-      this.logger.info(`Connection scope ended, stopping connection`);
-      void this.stop();
-    });
-  }
-
-  /**
-   * Logs the lifecycle of remote participants and their tracks as seen by
-   * livekit-client, so that rageshakes show what a tile should have been
-   * rendering (published, subscribed, muted, paused) for each remote member.
-   */
-  private logRemoteTrackEvents(): void {
-    const room = this.livekitRoom;
-    const log = this.logger.getChild("[RemoteTracks]");
-    // The encryption flag matters: if the publisher encrypts but this client
-    // believes the track is unencrypted, the cryptor is bypassed and raw
-    // ciphertext reaches the decoder (audible as loud noise bursts).
-    const track = (pub: TrackPublication, p: Participant): string =>
-      `${pub.kind} ${pub.source} ${pub.trackSid} of ${p.identity} encrypted=${pub.isEncrypted}`;
-
-    const onParticipantConnected = (p: RemoteParticipant): void =>
-      log.info(`Participant connected: ${p.identity} (${p.sid})`);
-    const onParticipantDisconnected = (p: RemoteParticipant): void =>
-      log.info(`Participant disconnected: ${p.identity} (${p.sid})`);
-    const onTrackPublished = (
-      pub: RemoteTrackPublication,
-      p: RemoteParticipant,
-    ): void => log.info(`Published: ${track(pub, p)} muted=${pub.isMuted}`);
-    const onTrackUnpublished = (
-      pub: RemoteTrackPublication,
-      p: RemoteParticipant,
-    ): void => log.info(`Unpublished: ${track(pub, p)}`);
-    const onTrackSubscribed = (
-      _t: Track,
-      pub: RemoteTrackPublication,
-      p: RemoteParticipant,
-    ): void => log.info(`Subscribed: ${track(pub, p)} muted=${pub.isMuted}`);
-    const onTrackUnsubscribed = (
-      _t: Track,
-      pub: RemoteTrackPublication,
-      p: RemoteParticipant,
-    ): void => log.info(`Unsubscribed: ${track(pub, p)}`);
-    const onTrackSubscriptionFailed = (
-      trackSid: string,
-      p: RemoteParticipant,
-      reason?: SubscriptionError,
-    ): void =>
-      log.warn(
-        `Subscription failed: ${trackSid} of ${p.identity} reason=${reason}`,
-      );
-    // Mute events also fire for the local participant, which the Publisher
-    // already logs.
-    const onTrackMuted = (pub: TrackPublication, p: Participant): void => {
-      if (!p.isLocal) log.info(`Muted: ${track(pub, p)}`);
-    };
-    const onTrackUnmuted = (pub: TrackPublication, p: Participant): void => {
-      if (!p.isLocal) log.info(`Unmuted: ${track(pub, p)}`);
-    };
-    const onTrackStreamStateChanged = (
-      pub: RemoteTrackPublication,
-      state: Track.StreamState,
-      p: RemoteParticipant,
-    ): void => log.info(`Stream ${state}: ${track(pub, p)}`);
-    const onEncryptionStatusChanged = (
-      encrypted: boolean,
-      p?: Participant,
-    ): void =>
-      log.info(
-        `Encryption status of ${p?.identity ?? "unknown participant"}: encrypted=${encrypted}`,
-      );
-    // livekit-client throttles these per cryptor; they indicate frames being
-    // dropped (missing/invalid key).
-    const onEncryptionError = (error: Error, p?: Participant): void =>
-      log.warn(
-        `Encryption error for ${p?.identity ?? "unknown participant"}:`,
-        error,
-      );
-
-    room
-      .on(RoomEvent.ParticipantConnected, onParticipantConnected)
-      .on(RoomEvent.ParticipantDisconnected, onParticipantDisconnected)
-      .on(RoomEvent.TrackPublished, onTrackPublished)
-      .on(RoomEvent.TrackUnpublished, onTrackUnpublished)
-      .on(RoomEvent.TrackSubscribed, onTrackSubscribed)
-      .on(RoomEvent.TrackUnsubscribed, onTrackUnsubscribed)
-      .on(RoomEvent.TrackSubscriptionFailed, onTrackSubscriptionFailed)
-      .on(RoomEvent.TrackMuted, onTrackMuted)
-      .on(RoomEvent.TrackUnmuted, onTrackUnmuted)
-      .on(RoomEvent.TrackStreamStateChanged, onTrackStreamStateChanged)
-      .on(
-        RoomEvent.ParticipantEncryptionStatusChanged,
-        onEncryptionStatusChanged,
-      )
-      .on(RoomEvent.EncryptionError, onEncryptionError);
-    this.scope.onEnd(() => {
-      room
-        .off(RoomEvent.ParticipantConnected, onParticipantConnected)
-        .off(RoomEvent.ParticipantDisconnected, onParticipantDisconnected)
-        .off(RoomEvent.TrackPublished, onTrackPublished)
-        .off(RoomEvent.TrackUnpublished, onTrackUnpublished)
-        .off(RoomEvent.TrackSubscribed, onTrackSubscribed)
-        .off(RoomEvent.TrackUnsubscribed, onTrackUnsubscribed)
-        .off(RoomEvent.TrackSubscriptionFailed, onTrackSubscriptionFailed)
-        .off(RoomEvent.TrackMuted, onTrackMuted)
-        .off(RoomEvent.TrackUnmuted, onTrackUnmuted)
-        .off(RoomEvent.TrackStreamStateChanged, onTrackStreamStateChanged)
-        .off(
-          RoomEvent.ParticipantEncryptionStatusChanged,
-          onEncryptionStatusChanged,
-        )
-        .off(RoomEvent.EncryptionError, onEncryptionError);
-    });
-  }
-
-  /**
-   * Starts the connection.
-   *
-   * This will:
-   * 1. Request an OpenId token `request_token` (allows matrix users to verify their identity with a third-party service.)
-   * 2. Use this token to request the SFU config to the MatrixRtc authentication service.
-   * 3. Connect to the configured LiveKit room.
-   *
-   * The errors are also represented as a state in the `state$` observable.
-   * It is safe to ignore those errors and handle them accordingly via the `state$` observable.
-   * @throws {InsufficientCapacityError} if the LiveKit server indicates that it has insufficient capacity to accept the connection.
-   * @throws {SFURoomCreationRestrictedError} if the LiveKit server indicates that the room does not exist and cannot be created.
-   */
-  // TODO consider an autostart pattern...
-  public async start(): Promise<void> {
-    this.logger.debug("Starting Connection");
-    this.stopped = false;
-    try {
-      this._state$.next({ state: "authenticating" });
-      const { url, jwt, livekitAlias } = await this.getSFUConfig();
-      this.logger.debug(
-        "Starting Connection - jwt: ",
-        jwt,
-        "wss: ",
-        url,
-        "livekitAlias: ",
-        livekitAlias,
-      );
-      this._livekitAlias = livekitAlias;
-      // If we were stopped while fetching the config, don't proceed to connect
-      if (this.stopped) return;
-
-      // Setup observer once we are done with getSFUConfig
-      connectionStateObserver(this.livekitRoom)
-        .pipe(this.scope.bind())
-        .subscribe((livekitState) =>
-          this._state$.next({ state: "authenticated", livekitState }),
-        );
-
-      try {
-        this.logger.info(`livekitRoom.connect ${url}`);
-        await this.livekitRoom.connect(url, jwt);
-        this.logger.info(`livekitRoom.connect SUCCESS ${url}`);
-      } catch (e) {
-        this.logger.info(`livekitRoom.connect FAILED ${url}`, e);
-        // LiveKit uses 503 to indicate that the server has hit its track limits.
-        // https://github.com/livekit/livekit/blob/fcb05e97c5a31812ecf0ca6f7efa57c485cea9fb/pkg/service/rtcservice.go#L171
-        // It also errors with a status code of 200 (yes, really) for room
-        // participant limits.
-        // LiveKit Cloud uses 429 for connection limits.
-        // Either way, all these errors can be explained as "insufficient capacity".
-        if (e instanceof ConnectionError) {
-          if (e.status === 503 || e.status === 200 || e.status === 429) {
-            throw new InsufficientCapacityError();
-          }
-          if (e.status === 404) {
-            // error msg is "Failed to create call"
-            // error description is "Call creation might be restricted to authorized users only. Try again later, or contact your server admin if the problem persists."
-            // The room does not exist. There are two different modes of operation for the SFU:
-            // - the room is created on the fly when connecting (livekit `auto_create` option)
-            // - Only authorized users can create rooms, so the room must exist before connecting (done by the auth jwt service)
-            // In the first case there will not be a 404, so we are in the second case.
-            throw new SFURoomCreationRestrictedError();
-          }
-
-          if (e.reason === ConnectionErrorReason.Timeout) {
-            // Unabled to establish peer connection within the timeout
-            throw new PeerConnectionTimeoutError();
-          }
-
-          throw new LivekitConnectionError(e);
-        }
-        throw e;
-      }
-      // If we were stopped while connecting, don't proceed to update state.
-      if (this.stopped) return;
-    } catch (error) {
-      if (this.stopped) {
-        // stop() was called while we were connecting, which makes the pending
-        // connect reject. That is the abort we asked for, not a failure, so
-        // don't record an error state on a stopped connection or rethrow it
-        // (start() is not necessarily awaited by the caller, so a throw here
-        // becomes an unhandled promise rejection).
-        this.logger.debug(`Connect aborted because the connection was stopped`);
-        return;
-      }
-      this.logger.debug(`Failed to connect to LiveKit room: ${error}`);
-      this._state$.next({
-        state: "error",
-        error:
-          error instanceof ElementCallError
-            ? error
-            : error instanceof Error
-              ? new UnknownCallError(error)
-              : new UnknownCallError(new Error(`${error}`)),
-      });
-      // Its okay to ignore the throw. The error is part of the state.
-      throw error;
-    }
-  }
-
-  protected async getSFUConfig(): Promise<SFUConfig> {
-    return await getSFUConfig({
-      client: this.client,
-      membership: this.ownMembershipIdentity,
-      role: this.role,
-      transport: this.transport,
-      serverName: this.serverName,
-      roomId: this.roomId,
-      slotId: this.slotId,
-      logger: this.logger,
-    });
-  }
-
-  /**
-   * Stops the connection.
-   *
-   * This will disconnect from the LiveKit room.
-   * If the connection is already stopped, this is a no-op.
-   */
-  public async stop(): Promise<void> {
-    this.logger.debug("stop: disconnecing from lk room");
-    if (this.stopped) return;
-    // Mark as stopped before disconnecting so that a connect() aborted by the
-    // disconnect sees the flag and does not report the abort as an error.
-    this.stopped = true;
-    await this.livekitRoom.disconnect();
-    this._state$.next({ state: "stopped" });
-    this.logger.debug("stop: DONE disconnecing from lk room");
-  }
-}

src/state/CallViewModel/remoteMembers/ConnectionFactory.ts

@@ -1,201 +0,0 @@
-/*
-Copyright 2025 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 {
-  Room as LivekitRoom,
-  type RoomOptions,
-  type BaseKeyProvider,
-  type E2EEManagerOptions,
-  type BaseE2EEManager,
-} from "livekit-client";
-import { logger, type Logger } from "matrix-js-sdk/lib/logger";
-// imported as inline to support worker when loaded from a cdn (cross domain)
-import E2EEWorker from "livekit-client/e2ee-worker?worker&inline";
-import { type CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
-import { type UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
-
-import { type ObservableScope } from "../../ObservableScope.ts";
-import { Connection } from "./Connection.ts";
-import type { MediaDevices } from "../../MediaDevices.ts";
-import type { Behavior } from "../../Behavior.ts";
-import type { ProcessorState } from "../../../livekit/TrackProcessorContext.tsx";
-import { getLiveKitOptions } from "../../../livekit/options.ts";
-import {
-  advancedCamera,
-  cameraResolution,
-  cameraFramerate,
-  cameraBitrate,
-  cameraCodec,
-  parseResolution,
-  echoCancellationSetting,
-  noiseSuppressionSetting,
-  autoGainControlSetting,
-} from "../../../settings/settings.ts";
-import {
-  type ClientGetTokenParts,
-  type ClientOpenIDParts,
-} from "../../../livekit/auth";
-
-// TODO evaluate if this should be done like the Publisher Factory
-export interface ConnectionFactory {
-  createConnection(
-    scope: ObservableScope,
-    role: "publisher" | "subscriber",
-    transport: UnstableLivekitTransport,
-    serverName: string,
-    ownMembershipIdentity: CallMembershipIdentityParts,
-    logger: Logger,
-  ): Connection;
-}
-
-export class ECConnectionFactory implements ConnectionFactory {
-  private readonly livekitRoomFactory: () => LivekitRoom;
-
-  /**
-   * Creates a ConnectionFactory for LiveKit connections.
-   *
-   * @param client - The OpenID client parts for authentication, needed to get openID and JWT tokens.
-   * @param roomId - The ID of the Matrix room in which the session takes place.
-   * @param slotId - The ID of the MatrixRTC slot in which the session takes place.
-   * @param devices - Used for video/audio out/in capture options.
-   * @param processorState$ - Effects like background blur (only for publishing connection?)
-   * @param livekitKeyProvider - Optional key provider for end-to-end encryption.
-   * @param controlledAudioDevices - Option to indicate whether audio output device is controlled externally (native mobile app).
-   * @param livekitRoomFactory - Optional factory function (for testing) to create LivekitRoom instances. If not provided, a default factory is used.
-   */
-  public constructor(
-    private client: ClientGetTokenParts & ClientOpenIDParts,
-    private readonly roomId: string,
-    private readonly slotId: string,
-    private devices: MediaDevices,
-    private processorState$: Behavior<ProcessorState>,
-    livekitKeyProvider: BaseKeyProvider | undefined,
-    private controlledAudioDevices: boolean,
-    livekitRoomFactory?: () => LivekitRoom,
-  ) {
-    const defaultFactory = (): LivekitRoom => {
-      const roomOptions = generateRoomOption({
-        devices: this.devices,
-        processorState: this.processorState$.value,
-        e2eeLivekitOptions: livekitKeyProvider && {
-          keyProvider: livekitKeyProvider,
-          // It's important that every room use a separate E2EE worker.
-          // They get confused if given streams from multiple rooms.
-          worker: new E2EEWorker(),
-        },
-        controlledAudioDevices: this.controlledAudioDevices,
-      });
-      logger.info("[ECConnectionFactory] livekit room options: ", roomOptions);
-      return new LivekitRoom(roomOptions);
-    };
-    this.livekitRoomFactory = livekitRoomFactory ?? defaultFactory;
-  }
-
-  /**
-   *
-   * @param scope The observable scope (used for clean-up)
-   * @param transport The transport to use for this connection.
-   * @param serverName The name of the homeserver to which the {@link transport} belongs.
-   * @param ownMembershipIdentity required to connect (using the jwt service) with the SFU.
-   * @param logger The logger instance to use for this connection.
-   * @param sfuConfig optional config in case we already have a token for this connection.
-   * @returns
-   */
-  public createConnection(
-    scope: ObservableScope,
-    role: "publisher" | "subscriber",
-    transport: UnstableLivekitTransport,
-    serverName: string,
-    ownMembershipIdentity: CallMembershipIdentityParts,
-    logger: Logger,
-  ): Connection {
-    return new Connection(
-      {
-        roomId: this.roomId,
-        slotId: this.slotId,
-        role,
-        transport,
-        serverName,
-        client: this.client,
-        scope: scope,
-        livekitRoomFactory: this.livekitRoomFactory,
-        ownMembershipIdentity,
-      },
-      logger,
-    );
-  }
-}
-
-/**
- *  Generate the initial LiveKit RoomOptions based on the current media devices and processor state.
- *  Reads audio processing and camera quality settings directly from Settings.
- */
-function generateRoomOption({
-  devices,
-  processorState,
-  e2eeLivekitOptions,
-  controlledAudioDevices,
-}: {
-  devices: MediaDevices;
-  processorState: ProcessorState;
-  e2eeLivekitOptions:
-    | E2EEManagerOptions
-    | { e2eeManager: BaseE2EEManager }
-    | undefined;
-  controlledAudioDevices: boolean;
-}): RoomOptions {
-  const liveKitOptions = getLiveKitOptions();
-
-  // Apply advanced camera settings if enabled
-  let videoCaptureDefaults = {
-    ...liveKitOptions.videoCaptureDefaults,
-    deviceId: devices.videoInput.selected$.value?.id,
-    processor: processorState.processor,
-  };
-  let publishDefaults = liveKitOptions.publishDefaults;
-
-  if (advancedCamera.getValue()) {
-    const { width, height } = parseResolution(cameraResolution.getValue());
-    const fps = cameraFramerate.getValue();
-    const bps = cameraBitrate.getValue();
-    const codec = cameraCodec.getValue();
-
-    videoCaptureDefaults = {
-      ...videoCaptureDefaults,
-      resolution: { width, height, frameRate: fps },
-    };
-    publishDefaults = {
-      ...publishDefaults,
-      videoEncoding: { maxBitrate: bps, maxFramerate: fps },
-      videoCodec: codec,
-    };
-  }
-
-  return {
-    ...liveKitOptions,
-    videoCaptureDefaults,
-    publishDefaults,
-    audioCaptureDefaults: {
-      ...liveKitOptions.audioCaptureDefaults,
-      deviceId: devices.audioInput.selected$.value?.id,
-      echoCancellation: echoCancellationSetting.getValue(),
-      noiseSuppression: noiseSuppressionSetting.getValue(),
-      autoGainControl: autoGainControlSetting.getValue(),
-    },
-    audioOutput: {
-      // When using controlled audio devices, we don't want to set the
-      // deviceId here, because it will be set by the native app.
-      // (also the id does not need to match a browser device id)
-      deviceId: controlledAudioDevices
-        ? undefined
-        : devices.audioOutput.selected$.value?.id,
-    },
-    e2ee: e2eeLivekitOptions,
-    // TODO test and consider this:
-    // webAudioMix: true,
-  };
-}

src/state/CallViewModel/remoteMembers/ConnectionMap.test.ts

@@ -1,453 +0,0 @@
-/*
-Copyright 2025 Element Creations Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { BehaviorSubject } from "rxjs";
-import { type UnstableLivekitTransport } from "matrix-js-sdk/lib/matrixrtc";
-import { type RemoteParticipant } from "livekit-client";
-import { logger } from "matrix-js-sdk/lib/logger";
-
-import { Epoch, mapEpoch, ObservableScope } from "../../ObservableScope.ts";
-import {
-  createConnectionMap$,
-  ConnectionMap,
-  keyFor,
-} from "./ConnectionMap.ts";
-import { type ConnectionFactory } from "./ConnectionFactory.ts";
-import { type Connection } from "./Connection.ts";
-import { ownMemberMock, withTestScheduler } from "../../../utils/test.ts";
-import { type Behavior } from "../../Behavior.ts";
-import { type TransportLocator } from "../../../livekit/auth";
-
-// Some test constants
-
-const TRANSPORT_1: TransportLocator = {
-  transport: {
-    type: "livekit",
-    livekit_service_url: "https://lk.example.org",
-  },
-  serverName: "example.org",
-};
-
-const TRANSPORT_2: TransportLocator = {
-  transport: {
-    type: "livekit",
-    livekit_service_url: "https://lk.sample.com",
-  },
-  serverName: "sample.com",
-};
-
-function findConnection(
-  transport: TransportLocator,
-  connections: Connection[],
-): Connection | undefined {
-  const key = keyFor(transport);
-  return connections.find((c) => keyFor(c) === key);
-}
-
-let fakeConnectionFactory: ConnectionFactory;
-let testScope: ObservableScope;
-
-// Can be useful to track all created connections in tests, even the disposed ones
-let allCreatedConnections: Connection[];
-
-beforeEach(() => {
-  testScope = new ObservableScope();
-  allCreatedConnections = [];
-  fakeConnectionFactory = {} as unknown as ConnectionFactory;
-  vi.mocked(fakeConnectionFactory).createConnection = vi
-    .fn()
-    .mockImplementation(
-      (
-        scope: ObservableScope,
-        _role: unknown,
-        transport: UnstableLivekitTransport,
-        serverName: string,
-      ) => {
-        const mockConnection = {
-          transport,
-          serverName,
-          remoteParticipants$: new BehaviorSubject([]),
-        } as unknown as Connection;
-        vi.mocked(mockConnection).start = vi.fn();
-        vi.mocked(mockConnection).stop = vi.fn();
-        // Tie the connection's lifecycle to the scope to test scope lifecycle management
-        scope.onEnd(() => {
-          void mockConnection.stop();
-        });
-        allCreatedConnections.push(mockConnection);
-        return mockConnection;
-      },
-    );
-});
-
-afterEach(() => {
-  testScope.end();
-});
-
-describe("connections$ stream", () => {
-  test("Should create and start new connections for each transports", () => {
-    withTestScheduler(({ behavior, expectObservable }) => {
-      const connectionMap$ = createConnectionMap$({
-        scope: testScope,
-        connectionFactory: fakeConnectionFactory,
-        localTransport: TRANSPORT_1,
-        remoteTransports$: behavior("a", {
-          a: new Epoch([TRANSPORT_1, TRANSPORT_2], 0),
-        }),
-        logger: logger,
-        ownMembershipIdentity: ownMemberMock,
-      });
-
-      expectObservable(
-        connectionMap$.pipe(mapEpoch((d) => d.getConnections())),
-      ).toBe("a", {
-        a: expect.toSatisfy((e: Epoch<Connection[]>) => {
-          const connections = e.value;
-          expect(connections.length).toBe(2);
-
-          expect(
-            vi.mocked(fakeConnectionFactory).createConnection,
-          ).toHaveBeenCalledTimes(2);
-
-          const conn1 = findConnection(TRANSPORT_1, connections);
-          expect(conn1).toBeDefined();
-          expect(conn1!.start).toHaveBeenCalled();
-
-          const conn2 = findConnection(TRANSPORT_2, connections);
-          expect(conn2).toBeDefined();
-          expect(conn2!.start).toHaveBeenCalled();
-          return true;
-        }),
-      });
-    });
-  });
-
-  test("Shares one connection between homeservers advertising the same JWT service", () => {
-    withTestScheduler(({ behavior, expectObservable }) => {
-      const sameServiceElsewhere: TransportLocator = {
-        transport: TRANSPORT_1.transport,
-        serverName: "elsewhere.org",
-      };
-      const connectionMap$ = createConnectionMap$({
-        scope: testScope,
-        connectionFactory: fakeConnectionFactory,
-        localTransport: TRANSPORT_1,
-        remoteTransports$: behavior("a", {
-          a: new Epoch([sameServiceElsewhere], 0),
-        }),
-        logger: logger,
-        ownMembershipIdentity: ownMemberMock,
-      });
-
-      expectObservable(
-        connectionMap$.pipe(mapEpoch((d) => d.getConnections())),
-      ).toBe("a", {
-        a: expect.toSatisfy((e: Epoch<Connection[]>) => {
-          expect(e.value.length).toBe(1);
-          // The JWT service is reached directly, so the server name plays no
-          // part and the local locator, which came first, is the one used
-          expect(
-            vi.mocked(fakeConnectionFactory).createConnection,
-          ).toHaveBeenCalledExactlyOnceWith(
-            expect.anything(),
-            "publisher",
-            TRANSPORT_1.transport,
-            "example.org",
-            expect.anything(),
-            expect.anything(),
-          );
-          return true;
-        }),
-      });
-    });
-  });
-
-  test("Keeps one connection per homeserver for transports with a url", () => {
-    withTestScheduler(({ behavior, expectObservable }) => {
-      const urlTransport: TransportLocator = {
-        transport: { type: "livekit", url: "wss://sfu.example.org" },
-        serverName: "example.org",
-      };
-      const sameUrlElsewhere: TransportLocator = {
-        transport: urlTransport.transport,
-        serverName: "elsewhere.org",
-      };
-      const connectionMap$ = createConnectionMap$({
-        scope: testScope,
-        connectionFactory: fakeConnectionFactory,
-        localTransport: urlTransport,
-        remoteTransports$: behavior("a", {
-          a: new Epoch([sameUrlElsewhere], 0),
-        }),
-        logger: logger,
-        ownMembershipIdentity: ownMemberMock,
-      });
-
-      expectObservable(
-        connectionMap$.pipe(mapEpoch((d) => d.getConnections())),
-      ).toBe("a", {
-        a: expect.toSatisfy((e: Epoch<Connection[]>) => {
-          // Our homeserver asks the named server for the token, so each
-          // server name needs its own connection
-          expect(e.value.length).toBe(2);
-          expect(findConnection(urlTransport, e.value)).toBeDefined();
-          expect(findConnection(sameUrlElsewhere, e.value)).toBeDefined();
-          return true;
-        }),
-      });
-    });
-  });
-
-  test("Should start connection only once", () => {
-    withTestScheduler(({ behavior, expectObservable }) => {
-      const connectionMap$ = createConnectionMap$({
-        scope: testScope,
-        connectionFactory: fakeConnectionFactory,
-        localTransport: TRANSPORT_1,
-        remoteTransports$: behavior("abcdef", {
-          a: new Epoch([TRANSPORT_1], 0),
-          b: new Epoch([TRANSPORT_1], 1),
-          c: new Epoch([TRANSPORT_1], 2),
-          d: new Epoch([TRANSPORT_1], 3),
-          e: new Epoch([TRANSPORT_1], 4),
-          f: new Epoch([TRANSPORT_1, TRANSPORT_2], 5),
-        }),
-        logger: logger,
-        ownMembershipIdentity: ownMemberMock,
-      });
-
-      expectObservable(
-        connectionMap$.pipe(mapEpoch((d) => d.getConnections())),
-      ).toBe("xxxxxa", {
-        x: expect.anything(),
-        a: expect.toSatisfy((e: Epoch<Connection[]>) => {
-          const connections = e.value;
-
-          expect(connections.length).toBe(2);
-          expect(
-            vi.mocked(fakeConnectionFactory).createConnection,
-          ).toHaveBeenCalledTimes(2);
-
-          const conn2 = findConnection(TRANSPORT_2, connections);
-          expect(conn2).toBeDefined();
-
-          const conn1 = findConnection(TRANSPORT_1, connections);
-          expect(conn1).toBeDefined();
-          expect(conn1!.start).toHaveBeenCalledOnce();
-
-          return true;
-        }),
-      });
-    });
-  });
-
-  test("Should cleanup connections when not needed anymore", () => {
-    withTestScheduler(({ behavior, expectObservable }) => {
-      const connectionMap$ = createConnectionMap$({
-        scope: testScope,
-        connectionFactory: fakeConnectionFactory,
-        localTransport: TRANSPORT_1,
-        remoteTransports$: behavior("abc", {
-          a: new Epoch([TRANSPORT_1], 0),
-          b: new Epoch([TRANSPORT_1, TRANSPORT_2], 1),
-          c: new Epoch([TRANSPORT_1], 2),
-        }),
-        logger: logger,
-        ownMembershipIdentity: ownMemberMock,
-      });
-
-      expectObservable(
-        connectionMap$.pipe(mapEpoch((d) => d.getConnections())),
-      ).toBe("xab", {
-        x: expect.anything(),
-        a: expect.toSatisfy((e: Epoch<Connection[]>) => {
-          const connections = e.value;
-          expect(connections.length).toBe(2);
-          return true;
-        }),
-        b: expect.toSatisfy((e: Epoch<Connection[]>) => {
-          const connections = e.value;
-
-          expect(connections.length).toBe(1);
-          // The second connection should have been stopped has it is no longer needed.
-          const connection2 = findConnection(
-            TRANSPORT_2,
-            allCreatedConnections,
-          );
-          expect(connection2).toBeDefined();
-          expect(connection2!.stop).toHaveBeenCalled();
-
-          // The first connection should still be active
-          const conn1 = connections[0];
-          expect(conn1.stop).not.toHaveBeenCalledOnce();
-
-          return true;
-        }),
-      });
-    });
-  });
-});
-
-describe("ConnectionMap", () => {
-  test("warns when a second connection to the same URL is merged", () => {
-    const warn = vi.spyOn(logger, "warn").mockImplementation(() => {});
-    const data = new ConnectionMap(logger);
-    const connection = TRANSPORT_1 as unknown as Connection;
-    const p = (identity: string): RemoteParticipant =>
-      ({ identity }) as unknown as RemoteParticipant;
-    data.add(connection, [p("a")]);
-    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]',
-      ),
-    );
-    expect(data.getParticipantsForTransport(TRANSPORT_1)).toHaveLength(2);
-  });
-});
-
-describe("connectionMap$", () => {
-  // Used in test to control fake connections' remoteParticipants$ streams
-  let fakeRemoteParticipantsStreams: Map<string, Behavior<RemoteParticipant[]>>;
-
-  beforeEach(() => {
-    fakeRemoteParticipantsStreams = new Map();
-
-    function getRemoteParticipantsFor(
-      transport: TransportLocator,
-    ): Behavior<RemoteParticipant[]> {
-      return (
-        fakeRemoteParticipantsStreams.get(keyFor(transport)) ??
-        new BehaviorSubject([])
-      );
-    }
-
-    // need a more advanced fake connection factory
-    vi.mocked(fakeConnectionFactory).createConnection = vi
-      .fn()
-      .mockImplementation(
-        (
-          scope: ObservableScope,
-          _role: unknown,
-          transport: UnstableLivekitTransport,
-          serverName: string,
-        ) => {
-          const fakeRemoteParticipants$ = new BehaviorSubject<
-            RemoteParticipant[]
-          >([]);
-          const mockConnection = {
-            transport,
-            serverName,
-            remoteParticipants$: getRemoteParticipantsFor({
-              transport,
-              serverName,
-            }),
-          } as unknown as Connection;
-          vi.mocked(mockConnection).start = vi.fn();
-          vi.mocked(mockConnection).stop = vi.fn();
-          // Tie the connection's lifecycle to the scope to test scope lifecycle management
-          scope.onEnd(() => {
-            void mockConnection.stop();
-          });
-
-          fakeRemoteParticipantsStreams.set(
-            keyFor({ transport, serverName }),
-            fakeRemoteParticipants$,
-          );
-          return mockConnection;
-        },
-      );
-  });
-
-  test("Should report connections with the remote participants", () => {
-    withTestScheduler(({ expectObservable, schedule, behavior }) => {
-      // Setup the fake participants streams behavior
-      // ==============================
-      fakeRemoteParticipantsStreams.set(
-        keyFor(TRANSPORT_1),
-        behavior("oa-b", {
-          o: [],
-          a: [{ identity: "user1A" } as RemoteParticipant],
-          b: [
-            { identity: "user1A" } as RemoteParticipant,
-            { identity: "user1B" } as RemoteParticipant,
-          ],
-        }),
-      );
-
-      fakeRemoteParticipantsStreams.set(
-        keyFor(TRANSPORT_2),
-        behavior("o-a", {
-          o: [],
-          a: [{ identity: "user2A" } as RemoteParticipant],
-        }),
-      );
-      // ==============================
-
-      const connectionMap$ = createConnectionMap$({
-        scope: testScope,
-        connectionFactory: fakeConnectionFactory,
-        localTransport: TRANSPORT_1,
-        remoteTransports$: behavior("a", {
-          a: new Epoch([TRANSPORT_1, TRANSPORT_2], 0),
-        }),
-        logger,
-        ownMembershipIdentity: ownMemberMock,
-      });
-
-      expectObservable(connectionMap$).toBe("abcd", {
-        a: expect.toSatisfy((e) => {
-          const data: ConnectionMap = e.value;
-          expect(data.getConnections().length).toBe(2);
-          expect(data.getParticipantsForTransport(TRANSPORT_1).length).toBe(0);
-          expect(data.getParticipantsForTransport(TRANSPORT_2).length).toBe(0);
-          return true;
-        }),
-        b: expect.toSatisfy((e) => {
-          const data: ConnectionMap = e.value;
-          expect(data.getConnections().length).toBe(2);
-          expect(data.getParticipantsForTransport(TRANSPORT_1).length).toBe(1);
-          expect(data.getParticipantsForTransport(TRANSPORT_2).length).toBe(0);
-          expect(
-            data.getParticipantsForTransport(TRANSPORT_1)[0].identity,
-          ).toBe("user1A");
-          return true;
-        }),
-        c: expect.toSatisfy((e) => {
-          const data: ConnectionMap = e.value;
-          expect(data.getConnections().length).toBe(2);
-          expect(data.getParticipantsForTransport(TRANSPORT_1).length).toBe(1);
-          expect(data.getParticipantsForTransport(TRANSPORT_2).length).toBe(1);
-          expect(
-            data.getParticipantsForTransport(TRANSPORT_1)[0].identity,
-          ).toBe("user1A");
-          expect(
-            data.getParticipantsForTransport(TRANSPORT_2)[0].identity,
-          ).toBe("user2A");
-          return true;
-        }),
-        d: expect.toSatisfy((e) => {
-          const data: ConnectionMap = e.value;
-          expect(data.getConnections().length).toBe(2);
-          expect(data.getParticipantsForTransport(TRANSPORT_1).length).toBe(2);
-          expect(data.getParticipantsForTransport(TRANSPORT_2).length).toBe(1);
-          expect(
-            data.getParticipantsForTransport(TRANSPORT_1)[0].identity,
-          ).toBe("user1A");
-          expect(
-            data.getParticipantsForTransport(TRANSPORT_1)[1].identity,
-          ).toBe("user1B");
-          expect(
-            data.getParticipantsForTransport(TRANSPORT_2)[0].identity,
-          ).toBe("user2A");
-          return true;
-        }),
-      });
-    });
-  });
-});

src/state/CallViewModel/remoteMembers/ConnectionMap.ts

@@ -1,219 +0,0 @@
-/*
-Copyright 2025-2026 Element Creations Ltd.
-Copyright 2025 New Vector Ltd.
-
-SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE in the repository root for full details.
-*/
-
-import { combineLatest, map, of, switchMap, tap } from "rxjs";
-import { type Logger } from "matrix-js-sdk/lib/logger";
-import { type RemoteParticipant } from "livekit-client";
-import { type CallMembershipIdentityParts } from "matrix-js-sdk/lib/matrixrtc/EncryptionManager";
-
-import { type Behavior } from "../../Behavior.ts";
-import { type Connection } from "./Connection.ts";
-import {
-  Epoch,
-  mapEpoch,
-  type ObservableScope,
-} from "../../ObservableScope.ts";
-import { generateItemsWithEpoch } from "../../../utils/observable.ts";
-import { type ConnectionFactory } from "./ConnectionFactory.ts";
-import { type TransportLocator } from "../../../livekit/auth/types.ts";
-
-// Branded string type, so that only values returned by `keyFor` can be used
-// as keys
-export type TransportKey = string & { __transportKey: true };
-
-/**
- * Converts a {@link TransportLocator} to a key suitable for identifying it in a
- * {@link Map} or {@link Set}. Locators with the same key share a connection.
- */
-export function keyFor({
-  transport,
-  serverName,
-}: TransportLocator): TransportKey {
-  // 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 must share a connection rather than each get their own.
-  const hasUrl = "url" in 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,
-  ]) as TransportKey;
-}
-
-function removeDuplicateTransports(
-  transports: TransportLocator[],
-): TransportLocator[] {
-  // The first locator wins, so the local one stays first in the list
-  const map = new Map<TransportKey, TransportLocator>();
-  for (const transport of transports) {
-    const key = keyFor(transport);
-    if (!map.has(key)) map.set(key, transport);
-  }
-  return [...map.values()];
-}
-
-export class ConnectionMap {
-  private readonly map = new Map<
-    TransportKey,
-    { connection: Connection; participants: RemoteParticipant[] }
-  >();
-
-  public constructor(private readonly logger?: Logger) {}
-
-  public add(connection: Connection, participants: RemoteParticipant[]): void {
-    const key = keyFor(connection);
-    const existing = this.map.get(key);
-    if (!existing) {
-      this.map.set(key, { connection, participants });
-    } else {
-      // Transports are deduplicated by key upstream, so this should never
-      // happen; if it does, members may be matched against the wrong room.
-      this.logger?.warn(
-        `Merging participants from a second connection to ${key}: existing [${existing.participants.map((p) => p.identity).join(", ")}], adding [${participants.map((p) => p.identity).join(", ")}]`,
-      );
-      existing.participants.push(...participants);
-    }
-  }
-
-  public getConnections(): Connection[] {
-    return Array.from(this.map.values()).map(({ connection }) => connection);
-  }
-
-  public getConnectionForTransport(
-    transport: TransportLocator,
-  ): Connection | null {
-    return this.map.get(keyFor(transport))?.connection ?? null;
-  }
-
-  public getParticipantsForTransport(
-    transport: TransportLocator,
-  ): RemoteParticipant[] {
-    const existing = this.map.get(keyFor(transport));
-    if (existing) {
-      return existing.participants;
-    }
-    return [];
-  }
-}
-
-interface Props {
-  scope: ObservableScope;
-  connectionFactory: ConnectionFactory;
-  localTransport: TransportLocator;
-  remoteTransports$: Behavior<Epoch<TransportLocator[]>>;
-
-  logger: Logger;
-  ownMembershipIdentity: CallMembershipIdentityParts;
-}
-
-/**
- * Create a dynamic map of connections and their associated backend participants.
- * @param props - Configuration object
- * @param props.scope - The observable scope used by this object
- * @param props.connectionFactory - Used to create new connections
- * @param props.localTransport - The transport to publish local media on. (deduplicated with remoteTransports$)
- * @param props.remoteTransports$ - All other transports. The connection manager will create connections for each transport. (deduplicated with localTransport)
- * @param props.ownMembershipIdentity - The own membership identity to use.
- * @param props.logger - The logger to use.
- */
-export function createConnectionMap$({
-  scope,
-  connectionFactory,
-  localTransport,
-  remoteTransports$,
-  logger: parentLogger,
-  ownMembershipIdentity,
-}: Props): Behavior<Epoch<ConnectionMap>> {
-  const logger = parentLogger.getChild("[ConnectionMap]");
-  // TODO logger: only construct one logger from the client and make it compatible via a EC specific sing
-
-  /**
-   * All transports currently represented in the connection map. This list does
-   * not include duplicate transports.
-   */
-  const localAndRemoteTransports$: Behavior<Epoch<TransportLocator[]>> =
-    scope.behavior(
-      remoteTransports$.pipe(
-        mapEpoch((remoteTransports) =>
-          removeDuplicateTransports([localTransport, ...remoteTransports]),
-        ),
-        tap((transports) =>
-          logger.debug("localAndRemoteTransports$ = ", transports),
-        ),
-      ),
-    );
-
-  const localTransportKey = keyFor(localTransport);
-
-  /**
-   * Connections for each transport in use by one or more session members.
-   */
-  const connections$ = scope.behavior(
-    localAndRemoteTransports$.pipe(
-      generateItemsWithEpoch(
-        "ConnectionMap connections$",
-        function* (transports) {
-          for (const transport of transports) {
-            const role =
-              keyFor(transport) === localTransportKey
-                ? ("publisher" as const)
-                : ("subscriber" as const);
-            yield {
-              // The locator is an object, so a stable key stands in for it
-              keys: [role, keyFor(transport)],
-              data: transport,
-            };
-          }
-        },
-        (scope, locator$, role, _key) => {
-          const { transport, serverName } = locator$.value;
-          const connection = connectionFactory.createConnection(
-            scope,
-            role,
-            transport,
-            serverName,
-            ownMembershipIdentity,
-            logger,
-          );
-          // Start the connection immediately
-          // Use connection state to track connection progress
-          void connection.start();
-          // TODO subscribe to connection state to retry or log issues?
-          return connection;
-        },
-      ),
-    ),
-  );
-
-  return scope.behavior(
-    connections$.pipe(
-      switchMap(({ value: connections, epoch }) => {
-        if (connections.length === 0)
-          return of(new Epoch(new ConnectionMap(), epoch));
-
-        return combineLatest(
-          // Map the connections to list of Observable<{connection, participants}>
-          connections.map((connection) =>
-            connection.remoteParticipants$.pipe(
-              map((participants) => ({ connection, participants })),
-            ),
-          ),
-          // Collect into a single ConnectionMap
-          (...list) => {
-            const map = new ConnectionMap(logger);
-            for (const item of list)
-              map.add(item.connection, item.participants);
-            return new Epoch(map, epoch);
-          },
-        );
-      }),
-    ),
-  );
-}