matrix-js-sdk 42.3.0 → 42.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matrix-js-sdk",
-  "version": "42.3.0",
+  "version": "42.4.0",
   "description": "Matrix Client-Server SDK for Javascript",
   "engines": {
     "node": ">=22.0.0"
@@ -38,13 +38,13 @@
   ],
   "dependencies": {
     "@babel/runtime": "^8.0.0",
-    "@matrix-org/matrix-sdk-crypto-wasm": "^18.4.0",
+    "@matrix-org/matrix-sdk-crypto-wasm": "^18.7.0",
     "another-json": "^0.2.0",
     "bs58": "^6.0.0",
-    "content-type": "^2.0.0",
+    "content-type": "^3.0.0",
     "loglevel": "^1.9.2",
     "matrix-events-sdk": "0.0.1",
-    "matrix-widget-api": "^1.18.0",
+    "matrix-widget-api": "^1.19.0",
     "p-retry": "8",
     "sdp-transform": "^3.0.0",
     "unhomoglyph": "^1.0.6"
@@ -79,7 +79,7 @@
     "knip": "^6.0.0",
     "lint-staged": "^17.0.0",
     "matrix-mock-request": "^2.5.0",
-    "oxfmt": "^0.63.0",
+    "oxfmt": "^0.65.0",
     "oxlint": "^1.70.0",
     "oxlint-tsgolint": "^7.0.0",
     "typedoc": "^0.28.1",

package/src/@types/json.ts

@@ -1,8 +1,17 @@
 /*
 Copyright 2024 New Vector Ltd.
 
-SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
-Please see LICENSE files in the repository root for full details.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
 */
 
 // Types for JSON and JSON objects, copied from element-web (left in both places as I don't think we

package/src/client.ts

@@ -245,7 +245,12 @@ import { sha256 } from "./digest.ts";
 import { type ValidatedAuthMetadata, OAuth2Error, isValidAuthMetadata } from "./oauth/index.ts";
 import { type EmptyObject } from "./@types/common.ts";
 import { UnsupportedDelayedEventsEndpointError, UnsupportedStickyEventsEndpointError } from "./errors.ts";
-import { type Transport } from "./matrixrtc/index.ts";
+import {
+    type LivekitDelegateDelayedLeaveRequest,
+    type LivekitGetTokenRequest,
+    type LivekitGetTokenResponse,
+    type Transport,
+} from "./matrixrtc/index.ts";
 import { RetentionPolicyService } from "./retentionPolicy.ts";
 import { createRtcTransportsCachedValue } from "./rtcTransportsCachedValue.ts";
 import { createWellKnownCachedValue } from "./wellKnownCachedValue.ts";
@@ -525,6 +530,10 @@ export interface IStartClientOpts {
     /**
      * The number of seconds between polls to /.well-known/matrix/client, undefined to disable.
      * This should be in the order of hours. Default: undefined.
+     *
+     * When disabled, the client never requests the well-known on its own: nothing is fetched on
+     * startup and {@link MatrixClient.getClientWellKnown} stays undefined. Callers that still need
+     * it can fetch it on demand via {@link MatrixClient.waitForClientWellKnown}.
      */
     clientWellKnownPollPeriod?: number;
 
@@ -1518,11 +1527,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         this.syncApi.sync().catch((e) => this.logger.info("Sync startup aborted with an error:", e));
 
-        this.cachedWellKnown.start(
-            this.clientOpts.clientWellKnownPollPeriod !== undefined
-                ? 1000 * this.clientOpts.clientWellKnownPollPeriod
-                : undefined,
-        );
+        // Only poll the client well-known when a poll period was configured: leaving
+        // `clientWellKnownPollPeriod` undefined disables the lookups entirely.
+        if (this.clientOpts.clientWellKnownPollPeriod !== undefined) {
+            this.cachedWellKnown.start(1000 * this.clientOpts.clientWellKnownPollPeriod);
+        }
 
         this.toDeviceMessageQueue.start();
         this.serverCapabilitiesService.start();
@@ -1980,7 +1989,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @param args.caCertsPem - Optional PEM-formatted string that provides CA certificates. These will be used to check
      *    X.509 signatures on user identities. Any user identity that has a valid signature according to the supplied
      *    CAs will be considered verified, without any manual verification taking place.
-     *
+     *    NOTE: this is an unspecified extension to Matrix. Applications should exercise caution when using it.
+     * @param args.x509Signer - Optional async function for signing some data with an X.509 certificate. Used to sign
+     *    the user's identity so compatible clients will recognise this user as verified without manual verification
+     *    taking place. If you supply this you must also supply `x509Validity`.
+     *    NOTE: this is an unspecified extension to Matrix. Applications should exercise caution when using it.
+     * @param args.x509Validity - Optional function returning the validity period of the X.509 certificate used for
+     *    signing, as the number of milliseconds since the Unix epoch. If you supply this you must also supply
+     *    `x509Signer`.
      *    NOTE: this is an unspecified extension to Matrix. Applications should exercise caution when using it.
      *
      * @returns a Promise which will resolve when the crypto layer has been
@@ -1993,6 +2009,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             storageKey?: Uint8Array;
             storagePassword?: string;
             caCertsPem?: string;
+            x509Signer?: (item: Uint8Array) => Promise<{
+                signature_bytes: Uint8Array;
+                certificate_chain: string;
+                signature_scheme: "RsaPssSha512";
+            }>;
+            x509Validity?: () => number;
         } = {},
     ): Promise<void> {
         if (this.cryptoBackend) {
@@ -2040,6 +2062,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             enableEncryptedStateEvents: this.enableEncryptedStateEvents,
 
             caCertsPem: args.caCertsPem,
+            x509Signer: args.x509Signer,
+            x509Validity: args.x509Validity,
         });
 
         rustCrypto.setSupportedVerificationMethods(this.verificationMethods);
@@ -3607,6 +3631,45 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         });
     }
 
+    /**
+     * Get information about a specified delayed event owned by the requesting user.
+     *
+     * Note: This endpoint is unstable, and can throw an `Error`.
+     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.
+     */
+    public async _unstable_getDelayedEvent(delayId: string): Promise<{
+        delay_id: string;
+        room_id: string;
+        type: string;
+        state_key?: string;
+        delay_ms: number;
+        delayed_since_ts: number;
+        content: IContent;
+        finalised?: {
+            error?: MatrixError["data"];
+            event_id?: string;
+            finalised_ts: number;
+        };
+    }> {
+        // TODO: define a type/interface for the return shape once MSC4140 has become stable
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+            throw new UnsupportedDelayedEventsEndpointError(
+                "Server does not support the delayed events API",
+                "getDelayedEvents",
+            );
+        }
+
+        return await this.http.authedRequest(
+            Method.Get,
+            utils.encodeUri("/delayed_events/$delayId", { $delayId: delayId }),
+            undefined,
+            undefined,
+            {
+                prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_DELAYED_EVENTS}`,
+            },
+        );
+    }
+
     /**
      * Get information about delayed events owned by the requesting user.
      *
@@ -6181,6 +6244,58 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         ).rtc_transports;
     }
 
+    /**
+     * Requests a token to authenticate against a LiveKit SFU with (MSC4195).
+     *
+     * The homeserver checks that we are joined to `room_id` before obtaining a token from the SFU. If
+     * `server_name` names a remote homeserver, our homeserver forwards the request to it over federation,
+     * which is how a token for another homeserver's SFU is obtained.
+     *
+     * Requires homeserver support for MSC4195.
+     *
+     * @param body - The details of the `m.rtc.member` event to obtain a token for, and the SFU to obtain it from.
+     * @returns The JWT to authenticate with when connecting to the SFU.
+     * @throws A M_NOT_FOUND error if not supported by the homeserver, a M_FORBIDDEN error if we (or, when
+     * federating, our homeserver) are not joined to the room, or a M_INVALID_PARAM error if `url` is not one
+     * of the answering server's SFUs.
+     */
+    public async _unstable_getLivekitToken(body: LivekitGetTokenRequest): Promise<LivekitGetTokenResponse> {
+        // There is no /versions flag to check for support, so we just have to attempt a request.
+        return await this.http.authedRequest<LivekitGetTokenResponse>(
+            Method.Post,
+            "/rtc/livekit/get_token",
+            undefined,
+            body,
+            { prefix: `${ClientPrefix.Unstable}/io.element.msc4195` },
+        );
+    }
+
+    /**
+     * Hands over the management of a delayed MatrixRTC leave event to the homeserver (MSC4195).
+     *
+     * The homeserver restarts the delayed event for as long as it observes our connection to the SFU, and
+     * sends it once we disconnect, so the client does not have to restart it itself. This is more reliable
+     * than client-side restarts under poor network conditions.
+     *
+     * large timeouts are recommended for delayed delegation (in the range of hours)
+     * Requires homeserver support for MSC4195.
+     *
+     * @param body - The details of the `m.rtc.member` event and the delayed leave event to delegate, and the SFU
+     * we are connected to.
+     * @throws A M_NOT_FOUND error if not supported by the homeserver, a M_BAD_JSON error if the delayed
+     * event's timeout is below one hour, or a M_INVALID_PARAM error if `url` is not one of the homeserver's SFUs.
+     */
+    public async _unstable_delegateDelayedLeave(body: LivekitDelegateDelayedLeaveRequest): Promise<EmptyObject> {
+        // There is no /versions flag to check for support, so we just have to attempt a request.
+        return await this.http.authedRequest<EmptyObject>(
+            Method.Post,
+            "/rtc/livekit/delegate_delayed_leave",
+            undefined,
+            body,
+            { prefix: `${ClientPrefix.Unstable}/io.element.msc4195` },
+        );
+    }
+
     /**
      * Get the API versions supported by the server, along with any
      * unstable APIs it supports
@@ -6907,7 +7022,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * @param includeMembership - the membership type to include in the response
      * @param excludeMembership - the membership type to exclude from the response
-     * @param atEventId - the id of the event for which moment in the timeline the members should be returned for
+     * @param atSyncToken - the point in time, as a sync pagination token, for when the members should be returned for
      * @returns Promise which resolves: dictionary of userid to profile information
      * @returns Rejects: with an error response.
      */
@@ -6915,7 +7030,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         roomId: string,
         includeMembership?: string,
         excludeMembership?: string,
-        atEventId?: string,
+        atSyncToken?: string,
     ): Promise<{ [userId: string]: IStateEventWithRoomId[] }> {
         const queryParams: Record<string, string> = {};
         if (includeMembership) {
@@ -6924,8 +7039,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (excludeMembership) {
             queryParams.not_membership = excludeMembership;
         }
-        if (atEventId) {
-            queryParams.at = atEventId;
+        if (atSyncToken) {
+            queryParams.at = atSyncToken;
         }
 
         const queryString = utils.encodeParams(queryParams);

package/src/common-crypto/CryptoBackend.ts

@@ -118,42 +118,64 @@ export interface CryptoBackend extends SyncCryptoCallbacks, CryptoApi {
     markRoomAsPendingKeyBundle(roomId: string, inviterId: string): Promise<void>;
 }
 
-/** The methods which crypto implementations should expose to the Sync api
+/**
+ * The parts of a sync response which are relevant to encryption, as passed to
+ * {@link SyncCryptoCallbacks.processSyncChanges}.
  *
  * @internal
  */
-export interface SyncCryptoCallbacks {
+export interface SyncCryptoChanges {
+    /** The to-device events from the sync response (`to_device.events`), or an empty list if there were none. */
+    toDeviceEvents: IToDeviceEvent[];
+
+    /** The `device_lists` field from the sync response, if any. */
+    deviceLists?: IDeviceLists;
+
     /**
-     * Called by the /sync loop whenever there are incoming to-device messages.
-     *
-     * The implementation may preprocess the received messages (eg, decrypt them) and return an
-     * updated list of messages for dispatch to the rest of the system.
-     *
-     * Note that, unlike {@link ClientEvent.ToDeviceEvent} events, this is called on the raw to-device
-     * messages, rather than the results of any decryption attempts.
-     *
-     * @param events - the received to-device messages
-     * @returns A list of preprocessed to-device messages. This will not map 1:1 to the input list, as some messages may be invalid or
-     * failed to decrypt, and so will be omitted from the output list.
+     * The `device_one_time_keys_count` field from the sync response, if any.
      *
+     * The meaning of an algorithm missing from the map (or of an absent field) depends on {@link useMsc4186}: in
+     * sync v2 it means that there are no one-time keys of that algorithm on the server; in sliding sync it means that
+     * the count is unchanged since the previous response.
      */
-    preprocessToDeviceMessages(events: IToDeviceEvent[]): Promise<ReceivedToDeviceMessage[]>;
+    oneTimeKeysCounts?: Record<string, number>;
 
     /**
-     * Called by the /sync loop when one time key counts and unused fallback key details are received.
-     *
-     * @param oneTimeKeysCounts - the received one time key counts
-     * @param unusedFallbackKeys - the received unused fallback keys
+     * The `device_unused_fallback_key_types` field from the sync response, or `undefined` if the response did not
+     * include it (which means that the server does not support fallback keys).
+     */
+    unusedFallbackKeys?: string[];
+
+    /**
+     * Whether to interpret the response with MSC4186 (simplified sliding sync) semantics rather than sync v2. This
+     * selects the meaning of missing one-time key counts: see {@link oneTimeKeysCounts}. Defaults to `false`.
      */
-    processKeyCounts(oneTimeKeysCounts?: Record<string, number>, unusedFallbackKeys?: string[]): Promise<void>;
+    useMsc4186?: boolean;
+}
 
+/** The methods which crypto implementations should expose to the Sync api
+ *
+ * @internal
+ */
+export interface SyncCryptoCallbacks {
     /**
-     * Handle the notification from /sync that device lists have
-     * been changed.
+     * Called by the sync loop once per sync response, with the parts of the response which are relevant to
+     * encryption: to-device messages, device list changes, one-time key counts and unused fallback key types.
+     *
+     * All of this data must be passed together, in a single call per sync response, because the OlmMachine
+     * interprets it as the complete E2EE state from a sync response. In particular, per the sync v2 specification,
+     * an absent `device_one_time_keys_count` means that there are no one-time keys on the server, so calling this
+     * without the counts from the response would trigger a spurious one-time key upload. (Sliding sync responses
+     * omit the count when it is unchanged; {@link SyncCryptoChanges.useMsc4186} selects that interpretation.)
+     *
+     * This must be called before the room events in the sync response are processed, so that any room keys received
+     * in to-device messages are available when decrypting room events.
      *
-     * @param deviceLists - device_lists field from /sync
+     * @param changes - the E2EE-relevant parts of the sync response
+     * @returns A list of processed to-device messages. This will not map 1:1 to the input list, as some messages may
+     *    be invalid or fail to decrypt, and so will be omitted from the output list.
      */
-    processDeviceLists(deviceLists: IDeviceLists): Promise<void>;
+    processSyncChanges(changes: SyncCryptoChanges): Promise<ReceivedToDeviceMessage[]>;
 
     /**
      * Called by the /sync loop whenever an m.room.encryption event is received.

package/src/embedded.ts

@@ -32,7 +32,12 @@ import {
     UnstableApiVersion,
 } from "matrix-widget-api";
 
-import { type Transport } from "./matrixrtc/index.ts";
+import {
+    type LivekitDelegateDelayedLeaveRequest,
+    type LivekitGetTokenRequest,
+    type LivekitGetTokenResponse,
+    type Transport,
+} from "./matrixrtc/index.ts";
 import { MatrixEvent, type IEvent, EventStatus } from "./models/event.ts";
 import {
     type ISendEventResponse,
@@ -145,6 +150,21 @@ export interface ICapabilities {
      * @defaultValue false
      */
     rtcTransports?: boolean;
+
+    /**
+     * Whether this client needs to be able to obtain LiveKit SFU tokens through the host.
+     * @experimental Part of MSC4195 & MSC4533
+     * @defaultValue false
+     */
+    rtcLivekitGetToken?: boolean;
+
+    /**
+     * Whether this client needs to be able to hand delayed MatrixRTC leave events over to the
+     * homeserver through the host.
+     * @experimental Part of MSC4195 & MSC4533
+     * @defaultValue false
+     */
+    rtcLivekitDelegateDelayedLeave?: boolean;
 }
 
 export enum RoomWidgetClientEvent {
@@ -296,6 +316,12 @@ export class RoomWidgetClient extends MatrixClient {
         if (capabilities.rtcTransports) {
             this.widgetApi.requestCapability(MatrixCapabilities.MSC4515RtcTransports);
         }
+        if (capabilities.rtcLivekitGetToken) {
+            this.widgetApi.requestCapability(MatrixCapabilities.MSC4533RtcLivekitGetToken);
+        }
+        if (capabilities.rtcLivekitDelegateDelayedLeave) {
+            this.widgetApi.requestCapability(MatrixCapabilities.MSC4533RtcLivekitDelegateDelayedLeave);
+        }
     }
 
     public async supportUpdateState(): Promise<boolean> {
@@ -357,9 +383,11 @@ export class RoomWidgetClient extends MatrixClient {
             );
         }
 
-        this.cachedWellKnown.start(
-            opts.clientWellKnownPollPeriod !== undefined ? 1000 * opts.clientWellKnownPollPeriod : undefined,
-        );
+        // Only poll the client well-known when a poll period was configured: leaving
+        // `clientWellKnownPollPeriod` undefined disables the lookups entirely.
+        if (opts.clientWellKnownPollPeriod !== undefined) {
+            this.cachedWellKnown.start(1000 * opts.clientWellKnownPollPeriod);
+        }
         this.setSyncState(SyncState.Syncing);
         logger.info("Finished initial sync");
 
@@ -645,6 +673,41 @@ export class RoomWidgetClient extends MatrixClient {
         return rtcTransports;
     }
 
+    /**
+     * Requests a token to authenticate against a LiveKit SFU with.
+     *
+     * Overrides the homeserver-side {@link MatrixClient._unstable_getLivekitToken} (MSC4195): a widget
+     * cannot make authenticated homeserver calls itself, so we ask the host to make the call on our
+     * behalf over the widget API instead (MSC4533). Requires the `rtcLivekitGetToken` capability and a
+     * host that advertises the `org.matrix.msc4533` API version (otherwise the request throws).
+     *
+     * `server_name` defaults to our own homeserver, matching what the endpoint would do server-side.
+     */
+    public override async _unstable_getLivekitToken(body: LivekitGetTokenRequest): Promise<LivekitGetTokenResponse> {
+        const serverName = body.server_name ?? this.getDomain();
+        if (serverName === null) throw new Error("Cannot determine the server name to request a token from");
+        const { jwt } = await this.widgetApi
+            .getRtcLivekitToken({ ...body, server_name: serverName })
+            .catch(timeoutToConnectionError);
+        return { jwt };
+    }
+
+    /**
+     * Hands over the management of a delayed MatrixRTC leave event to the homeserver.
+     *
+     * Overrides the homeserver-side {@link MatrixClient._unstable_delegateDelayedLeave} (MSC4195): a
+     * widget cannot make authenticated homeserver calls itself, so we ask the host to make the call on
+     * our behalf over the widget API instead (MSC4533). Requires the `rtcLivekitDelegateDelayedLeave`
+     * capability and a host that advertises the `org.matrix.msc4533` API version (otherwise the request
+     * throws).
+     */
+    public override async _unstable_delegateDelayedLeave(
+        body: LivekitDelegateDelayedLeaveRequest,
+    ): Promise<EmptyObject> {
+        await this.widgetApi.delegateRtcLivekitDelayedLeave(body).catch(timeoutToConnectionError);
+        return {};
+    }
+
     public async queueToDevice({ eventType, batch }: ToDeviceBatch): Promise<void> {
         // map: user Id → device Id → payload
         const contentMap: MapWithDefault<string, Map<string, ToDevicePayload>> = new MapWithDefault(() => new Map());

package/src/http-api/fetch.ts

@@ -31,6 +31,7 @@ import {
     type Body,
 } from "./interface.ts";
 import { anySignal, parseErrorResponse, timeoutSignal } from "./utils.ts";
+import { sanitizeUrlForLogs } from "./logging.ts";
 import { type QueryDict } from "../utils.ts";
 import { TokenRefresher, TokenRefreshOutcome } from "./refresh.ts";
 
@@ -241,7 +242,7 @@ export class FetchHttpApi<O extends IHttpOpts> {
             throw new Error("Invalid call to `FetchHttpApi` sets both `opts.json` and `opts.rawResponseBody`");
         }
 
-        const urlForLogs = this.sanitizeUrlForLogs(url);
+        const urlForLogs = sanitizeUrlForLogs(url);
 
         this.opts.logger?.debug(`FetchHttpApi: --> ${method} ${urlForLogs}`);
 
@@ -330,28 +331,6 @@ export class FetchHttpApi<O extends IHttpOpts> {
         }
     }
 
-    private sanitizeUrlForLogs(url: URL | string): string {
-        try {
-            let asUrl: URL;
-            if (typeof url === "string") {
-                asUrl = new URL(url);
-            } else {
-                asUrl = url;
-            }
-            // Remove the values of any URL params that could contain potential secrets
-            const sanitizedQs = new URLSearchParams();
-            for (const key of asUrl.searchParams.keys()) {
-                sanitizedQs.append(key, "xxx");
-            }
-            const sanitizedQsString = sanitizedQs.toString();
-            const sanitizedQsUrlPiece = sanitizedQsString ? `?${sanitizedQsString}` : "";
-
-            return asUrl.origin + asUrl.pathname + sanitizedQsUrlPiece;
-        } catch {
-            // defensive coding for malformed url
-            return "??";
-        }
-    }
     /**
      * Form and return a homeserver request URL based on the given path params and prefix.
      * @param path - The HTTP path <b>after</b> the supplied prefix e.g. "/createRoom".

package/src/http-api/logging.ts

@@ -0,0 +1,46 @@
+/*
+Copyright 2026 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ * Produce a version of the given URL which is safe to write to logs, by redacting the values of any query parameters,
+ * as they may contain secrets.
+ *
+ * @internal
+ * @param url - the URL to sanitize.
+ * @returns the sanitized URL, or `"??"` if the URL could not be parsed.
+ */
+export function sanitizeUrlForLogs(url: URL | string): string {
+    try {
+        let asUrl: URL;
+        if (typeof url === "string") {
+            asUrl = new URL(url);
+        } else {
+            asUrl = url;
+        }
+        // Remove the values of any URL params that could contain potential secrets
+        const sanitizedQs = new URLSearchParams();
+        for (const key of asUrl.searchParams.keys()) {
+            sanitizedQs.append(key, "xxx");
+        }
+        const sanitizedQsString = sanitizedQs.toString();
+        const sanitizedQsUrlPiece = sanitizedQsString ? `?${sanitizedQsString}` : "";
+
+        return asUrl.origin + asUrl.pathname + sanitizedQsUrlPiece;
+    } catch {
+        // defensive coding for malformed url
+        return "??";
+    }
+}

package/src/matrixrtc/EncryptionManager.ts

@@ -15,6 +15,12 @@ export function getEncryptionKeyMapKey(membership: CallMembershipIdentityParts):
  * @internal
  */
 export interface IEncryptionManager {
+    /**
+     * Whether the key rotation is currently halted.
+     * @see EncryptionConfig.keyRotationParticipantLimit
+     */
+    readonly isKeyRotationSuppressed: boolean;
+
     /**
      * Joins the encryption manager with the provided configuration.
      *

package/src/matrixrtc/LivekitTransport.ts

@@ -44,3 +44,89 @@ export interface LivekitFocusSelection extends Transport {
  */
 export const isLivekitFocusSelection = (object: any): object is LivekitFocusSelection =>
     object.type === "livekit" && "focus_selection" in object;
+
+/**
+ * Identifies the MatrixRTC membership that a LiveKit request is made for (MSC4195).
+ *
+ * Note that this is *not* the `member` field of an `m.rtc.member` event verbatim: the homeserver knows
+ * the user ID from the access token, and the device ID is only ever claimed, never verified.
+ */
+export interface LivekitRtcMember {
+    /**
+     * The ID of the member within the MatrixRTC session, i.e. the `member.id` of the `m.rtc.member` event.
+     */
+    id: string;
+    /**
+     * The device ID the member claims to be using, i.e. the `member.device_id` of the `m.rtc.member` event.
+     */
+    claimed_device_id?: string;
+}
+
+/**
+ * The body of a request to the LiveKit `get_token` endpoint (MSC4195).
+ *
+ * Declared as a type alias rather than an interface so that it can be passed to the widget API
+ * (MSC4533), which expects request data to be assignable to an index signature.
+ */
+export type LivekitGetTokenRequest = {
+    /**
+     * The WebSocket URL of the LiveKit SFU to obtain a token for.
+     */
+    url: string;
+    /**
+     * The room ID of the Matrix room the `m.rtc.member` event is in.
+     */
+    room_id: string;
+    /**
+     * The slot ID from the `m.rtc.member` event.
+     */
+    slot_id: string;
+    /**
+     * The MatrixRTC membership to obtain a token for.
+     */
+    member: LivekitRtcMember;
+    /**
+     * The server name of the `m.rtc.member` event's sender. If omitted, the homeserver uses its own
+     * server name. This is what makes it possible to obtain a token for an SFU of a remote homeserver.
+     */
+    server_name?: string;
+};
+
+/**
+ * The response of the LiveKit `get_token` endpoint (MSC4195).
+ */
+export interface LivekitGetTokenResponse {
+    /**
+     * The JWT to authenticate with when connecting to the SFU.
+     */
+    jwt: string;
+}
+
+/**
+ * The body of a request to the LiveKit `delegate_delayed_leave` endpoint (MSC4195).
+ *
+ * Declared as a type alias rather than an interface so that it can be passed to the widget API
+ * (MSC4533), which expects request data to be assignable to an index signature.
+ */
+export type LivekitDelegateDelayedLeaveRequest = {
+    /**
+     * The WebSocket URL of the LiveKit SFU that we are connected to.
+     */
+    url: string;
+    /**
+     * The room ID of the Matrix room the `m.rtc.member` event is in.
+     */
+    room_id: string;
+    /**
+     * The slot ID from the `m.rtc.member` event.
+     */
+    slot_id: string;
+    /**
+     * The MatrixRTC membership the delayed leave event belongs to.
+     */
+    member: LivekitRtcMember;
+    /**
+     * The delay ID of the delayed leave event to hand over to the homeserver.
+     */
+    delay_id: string;
+};