matrix-js-sdk 41.0.0 → 41.1.0

package/src/matrixrtc/CallMembership.ts

@@ -1,5 +1,5 @@
 /*
-Copyright 2023 The Matrix.org Foundation C.I.C.
+Copyright 2023-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.
@@ -14,16 +14,20 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MXID_PATTERN } from "../models/room-member.ts";
 import { deepCompare } from "../utils.ts";
-import { type LivekitFocusSelection } from "./LivekitTransport.ts";
-import { slotDescriptionToId, slotIdToDescription, type SlotDescription } from "./MatrixRTCSession.ts";
-import type { RTCCallIntent, Transport } from "./types.ts";
-import { type MatrixEvent, type IContent } from "../models/event.ts";
-import { type RelationType } from "../@types/event.ts";
-import { sha256 } from "../digest.ts";
-import { encodeUnpaddedBase64 } from "../base64.ts";
-import { type Logger } from "../logger.ts";
+import { type RTCCallIntent, type Transport, type SlotDescription } from "./types.ts";
+import { type MatrixEvent } from "../models/event.ts";
+import { type Logger, logger } from "../logger.ts";
+import { computeSlotId, slotIdToDescription } from "./utils.ts";
+import {
+    checkRtcMembershipData,
+    computeRtcIdentityRaw,
+    type RtcMembershipData,
+    checkSessionsMembershipData,
+    type SessionMembershipData,
+    MatrixRTCMembershipParseError,
+} from "./membershipData/index.ts";
+import { EventType } from "../@types/event.ts";
 
 /**
  * The default duration in milliseconds that a membership is considered valid for.
@@ -32,331 +36,118 @@ import { type Logger } from "../logger.ts";
  */
 export const DEFAULT_EXPIRE_DURATION = 1000 * 60 * 60 * 4;
 
-type CallScope = "m.room" | "m.user";
-type Member = {
-    user_id: string;
-    device_id: string;
-    /**
-     * The id used on the media backend.
-     * (With livekit this is the participant identity on the LK SFU)
-     * This can be a UUID but right now it is `${this.matrixEventData.sender}:${data.device_id}`.
-     */
-    id: string;
-};
-
-export interface RtcMembershipData {
-    "slot_id": string;
-    "member": Member;
-    "m.relates_to"?: {
-        event_id: string;
-        rel_type: RelationType.Reference;
-    };
-    "application": {
-        type: string;
-        // other application specific keys
-        [key: string]: unknown;
-    };
-    "rtc_transports": Transport[];
-    "versions": string[];
-    "msc4354_sticky_key"?: string;
-    "sticky_key"?: string;
-}
-
-const checkRtcMembershipData = (
-    data: IContent,
-    errors: string[],
-    referenceUserId: string,
-): data is RtcMembershipData => {
-    const prefix = " - ";
-
-    // required fields
-    if (typeof data.slot_id !== "string") {
-        errors.push(prefix + "slot_id must be string");
-    } else {
-        if (data.slot_id.split("#").length !== 2) errors.push(prefix + 'slot_id must include exactly one "#"');
-    }
-    if (typeof data.member !== "object" || data.member === null) {
-        errors.push(prefix + "member must be an object");
-    } else {
-        if (typeof data.member.user_id !== "string") errors.push(prefix + "member.user_id must be string");
-        else if (!MXID_PATTERN.test(data.member.user_id)) errors.push(prefix + "member.user_id must be a valid mxid");
-        // This is not what the spec enforces but there currently are no rules what power levels are required to
-        // send a m.rtc.member event for a other user. So we add this check for simplicity and to avoid possible attacks until there
-        // is a proper definition when this is allowed.
-        else if (data.member.user_id !== referenceUserId) errors.push(prefix + "member.user_id must match the sender");
-        if (typeof data.member.device_id !== "string") errors.push(prefix + "member.device_id must be string");
-        if (typeof data.member.id !== "string") errors.push(prefix + "member.id must be string");
-    }
-    if (typeof data.application !== "object" || data.application === null) {
-        errors.push(prefix + "application must be an object");
-    } else {
-        if (typeof data.application.type !== "string") {
-            errors.push(prefix + "application.type must be a string");
-        } else {
-            if (data.application.type.includes("#")) errors.push(prefix + 'application.type must not include "#"');
-        }
-    }
-    if (data.rtc_transports === undefined || !Array.isArray(data.rtc_transports)) {
-        errors.push(prefix + "rtc_transports must be an array");
-    } else {
-        // validate that each transport has at least a string 'type'
-        for (const t of data.rtc_transports) {
-            if (typeof t !== "object" || t === null || typeof (t as any).type !== "string") {
-                errors.push(prefix + "rtc_transports entries must be objects with a string type");
-                break;
-            }
-        }
-    }
-    if (data.versions === undefined || !Array.isArray(data.versions)) {
-        errors.push(prefix + "versions must be an array");
-    } else if (!data.versions.every((v) => typeof v === "string")) {
-        errors.push(prefix + "versions must be an array of strings");
-    }
-
-    // optional fields
-    if ((data.sticky_key ?? data.msc4354_sticky_key) === undefined) {
-        errors.push(prefix + "sticky_key or msc4354_sticky_key must be a defined");
-    }
-    if (data.sticky_key !== undefined && typeof data.sticky_key !== "string") {
-        errors.push(prefix + "sticky_key must be a string");
-    }
-    if (data.msc4354_sticky_key !== undefined && typeof data.msc4354_sticky_key !== "string") {
-        errors.push(prefix + "msc4354_sticky_key must be a string");
-    }
-    if (
-        data.sticky_key !== undefined &&
-        data.msc4354_sticky_key !== undefined &&
-        data.sticky_key !== data.msc4354_sticky_key
-    ) {
-        errors.push(prefix + "sticky_key and msc4354_sticky_key must be equal if both are defined");
-    }
-    if (data["m.relates_to"] !== undefined) {
-        const rel = data["m.relates_to"] as RtcMembershipData["m.relates_to"];
-        if (typeof rel !== "object" || rel === null) {
-            errors.push(prefix + "m.relates_to must be an object if provided");
-        } else {
-            if (typeof rel.event_id !== "string") errors.push(prefix + "m.relates_to.event_id must be a string");
-            if (rel.rel_type !== "m.reference") errors.push(prefix + "m.relates_to.rel_type must be m.reference");
-        }
-    }
-
-    return errors.length === 0;
-};
-
 /**
- * MSC4143 (MatrixRTC) session membership data.
- * Represents the `session` in the memberships section of an m.call.member event as it is on the wire.
- **/
-export type SessionMembershipData = {
-    /**
-     * The RTC application defines the type of the RTC session.
-     */
-    "application": string;
-
-    /**
-     * The id of this session.
-     * A session can never span over multiple rooms so this id is to distinguish between
-     * multiple session in one room. A room wide session that is not associated with a user,
-     * and therefore immune to creation race conflicts, uses the `call_id: ""`.
-     */
-    "call_id": string;
-
-    /**
-     * The Matrix device ID of this session. A single user can have multiple sessions on different devices.
-     */
-    "device_id": string;
-
-    /**
-     * The focus selection system this user/membership is using.
-     */
-    "focus_active": LivekitFocusSelection;
-
-    /**
-     * A list of possible foci this user knows about. One of them might be used based on the focus_active
-     * selection system.
-     */
-    "foci_preferred": Transport[];
-
+ * Describes the source event type that provided the membership data.
+ */
+enum MembershipKind {
     /**
-     * Optional field that contains the creation of the session. If it is undefined the creation
-     * is the `origin_server_ts` of the event itself. For updates to the event this property tracks
-     * the `origin_server_ts` of the initial join event.
-     *  - If it is undefined it can be interpreted as a "Join".
-     *  - If it is defined it can be interpreted as an "Update"
+     * The modern MSC4143 format event.
      */
-    "created_ts"?: number;
-
-    // Application specific data
-
+    RTC = "rtc",
     /**
-     * If the `application` = `"m.call"` this defines if it is a room or user owned call.
-     * There can always be one room scoped call but multiple user owned calls (breakout sessions)
+     * The legacy call event type.
      */
-    "scope"?: CallScope;
+    Session = "session",
+}
 
-    /**
-     * Optionally we allow to define a delta to the `created_ts` that defines when the event is expired/invalid.
-     * This should be set to multiple hours. The only reason it exist is to deal with failed delayed events.
-     * (for example caused by a homeserver crashes)
-     **/
-    "expires"?: number;
+type MembershipData =
+    | { kind: MembershipKind.RTC; data: RtcMembershipData }
+    | { kind: MembershipKind.Session; data: SessionMembershipData };
 
+type LimitedEvent = Pick<MatrixEvent, "getId" | "getSender" | "getTs" | "getType" | "getContent">;
+// TODO: Rename to RtcMembership once we removed the legacy SessionMembership is removed, to avoid confusion.
+export class CallMembership {
     /**
-     * The intent of the call from the perspective of this user. This may be an audio call, video call or
-     * something else.
-     */
-    "m.call.intent"?: RTCCallIntent;
-    /**
-     * The sticky key in case of a sticky event. This string encodes the application + device_id indicating the used slot + device.
+     * Parse the membershipdata from a call membership event.
+     * @param matrixEvent The Matrix event to read.
+     * @returns MembershipData in either MembershipKind.RTC or MembershipKind.Session format.
+     * @throws If the content is neither format.
      */
-    "msc4354_sticky_key"?: string;
+    public static membershipDataFromMatrixEvent(matrixEvent: LimitedEvent): MembershipData {
+        const sender = matrixEvent.getSender();
+        const evType = matrixEvent.getType();
+        const data = matrixEvent.getContent();
+        if (sender === undefined) throw new Error("matrixEvent is missing sender field");
+        try {
+            // Event types are strictly checked here.
+            if (evType === EventType.RTCMembership && checkRtcMembershipData(data, sender)) {
+                return { kind: MembershipKind.RTC, data };
+            } else if (evType === EventType.GroupCallMemberPrefix && checkSessionsMembershipData(data)) {
+                return { kind: MembershipKind.Session, data };
+            } else {
+                throw Error(`'${evType} is not a known call membership type`);
+            }
+        } catch (ex) {
+            if (ex instanceof MatrixRTCMembershipParseError) {
+                logger.debug("CallMembership.MatrixRTCMembershipParseError provided invalid data", data);
+            }
+            throw ex;
+        }
+    }
 
     /**
-     * The id used on the media backend.
-     * (With livekit this is the participant identity on the LK SFU)
-     * This can be a UUID but right now it is `${this.matrixEventData.sender}:${data.device_id}`.
-     *
-     * It is compleatly valid to not set this field. Other clients will treat `undefined` as `${this.matrixEventData.sender}:${data.device_id}`
+     * Parse the contents of a MatrixEvent and create a CallMembership instance.
+     * @param matrixEvent The Matrix event to read.
      */
-    "membershipID"?: string;
-};
-
-const checkSessionsMembershipData = (data: IContent, errors: string[]): data is SessionMembershipData => {
-    const prefix = " - ";
-    if (typeof data.device_id !== "string") errors.push(prefix + "device_id must be string");
-    if (typeof data.call_id !== "string") errors.push(prefix + "call_id must be string");
-    if (typeof data.application !== "string") errors.push(prefix + "application must be a string");
-    if (typeof data.focus_active?.type !== "string") errors.push(prefix + "focus_active.type must be a string");
-    if (data.focus_active === undefined) {
-        errors.push(prefix + "focus_active has an invalid type");
+    public static async parseFromEvent(matrixEvent: LimitedEvent): Promise<CallMembership> {
+        const membershipData: MembershipData = this.membershipDataFromMatrixEvent(matrixEvent);
+        const rtcBackendIdentity =
+            membershipData.kind === MembershipKind.RTC
+                ? await computeRtcIdentityRaw(
+                      membershipData.data.member.user_id,
+                      membershipData.data.member.device_id,
+                      membershipData.data.member.id,
+                  )
+                : `${matrixEvent.getSender()}:${membershipData.data.device_id}`;
+        return new CallMembership(matrixEvent, membershipData, rtcBackendIdentity);
     }
-    if (
-        data.foci_preferred !== undefined &&
-        !(
-            Array.isArray(data.foci_preferred) &&
-            data.foci_preferred.every(
-                (f: Transport) => typeof f === "object" && f !== null && typeof f.type === "string",
-            )
-        )
-    ) {
-        errors.push(prefix + "foci_preferred must be an array of transport objects");
-    }
-    // optional parameters
-    if (data.created_ts !== undefined && typeof data.created_ts !== "number") {
-        errors.push(prefix + "created_ts must be number");
-    }
-
-    // application specific data (we first need to check if they exist)
-    if (data.scope !== undefined && typeof data.scope !== "string") errors.push(prefix + "scope must be string");
-
-    if (data["m.call.intent"] !== undefined && typeof data["m.call.intent"] !== "string") {
-        errors.push(prefix + "m.call.intent must be a string");
-    }
-
-    return errors.length === 0;
-};
 
-type MembershipData = { kind: "rtc"; data: RtcMembershipData } | { kind: "session"; data: SessionMembershipData };
-// TODO: Rename to RtcMembership once we removed the legacy SessionMembership from this file.
-export class CallMembership {
     public static equal(a?: CallMembership, b?: CallMembership): boolean {
         return deepCompare(a?.membershipData, b?.membershipData);
     }
 
-    private logger?: Logger;
+    private logger: Logger;
+
     /** The parsed data from the Matrix event.
      * To access checked eventId and sender from the matrixEvent.
      * Class construction will fail if these values cannot get obtained. */
-    private readonly matrixEventData: { eventId: string; sender: string; ts: number };
+    private readonly matrixEventData: { eventId: string; sender: string };
 
+    /**
+     * Use `parseFromEvent`.
+     * Constructor should only be used by tests.
+     * @private
+     * @param matrixEvent
+     * @param membershipData
+     * @param rtcBackendIdentity
+     */
     public constructor(
-        /** The required parts of the Matrix event that this membership is based on */
-        matrixEvent: Pick<MatrixEvent, "getId" | "getSender" | "getTs">,
-
-        /**
-         * The type checked membership data {data: (content of the matrix event), kind: (type hint)}
-         *
-         */
+        /** The Matrix event that this membership is based on */
+        private readonly matrixEvent: LimitedEvent,
         private readonly membershipData: MembershipData,
-
-        /**
-         *
-         * Anonymized identity to use with the RTC backend.
-         *
-         * The rtcBackendIdentity is a hashed version of all the identity parts:
-         * `sha256(${this.userId}|${this.deviceId}|${this.memberId})`
-         *
-         * It is used to anonymize the identity of the user in the RTC backend.
-         */
         public readonly rtcBackendIdentity: string,
-        /**
-         * The constructor will automatically create a properly tagged child logger instance.
-         */
-        logger?: Logger,
     ) {
-        const [eventId, sender, ts] = [matrixEvent.getId(), matrixEvent.getSender(), matrixEvent.getTs()];
-        if (eventId === undefined) throw new Error("parentEvent is missing eventId field");
-        if (sender === undefined) throw new Error("parentEvent is missing sender field");
-
-        this.matrixEventData = { eventId, sender, ts };
-
-        this.logger = logger?.getChild(`[CallMembership ${sender}:${this.deviceId}]`);
-    }
-
-    /**
-     * sha256(`${this.userId}|${this.deviceId}|${this.memberId}`) for sticky events (kind = rtc)
-     * `${this.userId}:${this.deviceId}` for state events (kind = session)
-     */
-    public static async computeRtcBackendIdentity(
-        matrixEvent: Pick<MatrixEvent, "getSender">,
-        membershipData: MembershipData,
-    ): Promise<string> {
-        const { kind, data } = membershipData;
-        switch (kind) {
-            case "rtc": {
-                return CallMembership.computeRtcIdentityRaw(data.member.user_id, data.member.device_id, data.member.id);
-            }
-            case "session":
-                return `${matrixEvent.getSender()}:${data.device_id}`;
-        }
-    }
-
-    public static async computeRtcIdentityRaw(userId: string, deviceId: string, memberId: string): Promise<string> {
-        return encodeUnpaddedBase64(await sha256(`${userId}|${deviceId}|${memberId}`));
-    }
-
-    public static membershipDataFromMatrixEvent(matrixEvent: MatrixEvent): MembershipData {
-        const [eventId, sender, content] = [matrixEvent.getId(), matrixEvent.getSender(), matrixEvent.getContent()];
+        const eventId = matrixEvent.getId();
+        const sender = matrixEvent.getSender();
 
         if (eventId === undefined) throw new Error("parentEvent is missing eventId field");
         if (sender === undefined) throw new Error("parentEvent is missing sender field");
 
-        const sessionErrors: string[] = [];
-        const rtcErrors: string[] = [];
-        if (checkSessionsMembershipData(content, sessionErrors)) {
-            return { kind: "session", data: content };
-        } else if (checkRtcMembershipData(content, rtcErrors, sender)) {
-            return { kind: "rtc", data: content };
-        } else {
-            const details =
-                sessionErrors.length < rtcErrors.length
-                    ? `Does not match MSC4143 m.call.member:\n${sessionErrors.join("\n")}\n\n`
-                    : `Does not match MSC4143 m.rtc.member:\n${rtcErrors.join("\n")}\n\n`;
-            const json = "\nevent:\n" + JSON.stringify(content).replaceAll('"', "'");
-            throw Error(`unknown CallMembership data.\n` + details + json);
-        }
+        this.logger = logger.getChild(`[CallMembership ${sender}:${this.deviceId}]`);
+        this.matrixEventData = { eventId, sender };
     }
 
     /** @deprecated use userId instead */
     public get sender(): string {
         return this.userId;
     }
+
     public get userId(): string {
         const { kind, data } = this.membershipData;
         switch (kind) {
-            case "rtc":
+            case MembershipKind.RTC:
                 return data.member.user_id;
-            case "session":
+            case MembershipKind.Session:
             default:
                 return this.matrixEventData.sender;
         }
@@ -374,11 +165,11 @@ export class CallMembership {
         const { kind, data } = this.membershipData;
         if (data.application === "m.call") {
             switch (kind) {
-                case "rtc":
+                case MembershipKind.RTC:
                     return data.slot_id;
-                case "session":
+                case MembershipKind.Session:
                 default: {
-                    const [application, id] = [this.application, data.call_id];
+                    const [application, id] = [data.application, data.call_id];
 
                     // INFO_SLOT_ID_LEGACY_CASE  (search for all occurances of this INFO to get the full picture)
                     // The spec got changed to use `"ROOM"` instead of `""` empyt string for the implicit default call.
@@ -400,7 +191,7 @@ export class CallMembership {
                     } else {
                         compatibilityAdaptedId = id;
                     }
-                    return slotDescriptionToId({
+                    return computeSlotId({
                         application,
                         id: compatibilityAdaptedId,
                     });
@@ -412,89 +203,82 @@ export class CallMembership {
         // This is what the function should look like for any other application that did not
         // go through a `""`=> `"ROOM"` rename
         switch (kind) {
-            case "rtc":
+            case MembershipKind.RTC:
                 return data.slot_id;
-            case "session":
-            default: {
-                const [application, id] = [this.application, data.call_id];
-                return slotDescriptionToId({ application, id });
-            }
+            case MembershipKind.Session:
+            default:
+                return computeSlotId({ application: data.application, id: data.call_id });
         }
     }
 
     public get deviceId(): string {
         const { kind, data } = this.membershipData;
         switch (kind) {
-            case "rtc":
+            case MembershipKind.RTC:
                 return data.member.device_id;
-            case "session":
+            case MembershipKind.Session:
             default:
                 return data.device_id;
         }
     }
 
     public get callIntent(): RTCCallIntent | undefined {
-        const { kind, data } = this.membershipData;
-        switch (kind) {
-            case "rtc": {
-                const intent = data.application["m.call.intent"];
-                if (typeof intent === "string") {
-                    return intent;
-                }
-                this.logger?.warn("RTC membership has invalid m.call.intent");
-                return undefined;
-            }
-            case "session":
-            default:
-                return data["m.call.intent"];
+        const intent = this.applicationData["m.call.intent"];
+        if (typeof intent === "string") {
+            return intent;
         }
+        this.logger.warn("RTC membership has invalid m.call.intent");
+        return undefined;
     }
 
     /**
      * Parsed `slot_id` (format `{application}#{id}`) into its components (application and id).
      */
     public get slotDescription(): SlotDescription {
+        const { kind, data } = this.membershipData;
+        if (kind === MembershipKind.RTC) {
+            const id = data.slot_id.slice(`${data.application.type}#`.length);
+            return { application: data.application.type, id };
+        }
         return slotIdToDescription(this.slotId);
     }
 
+    /**
+     * The application `type`.
+     * @deprecated Use @see applicationData
+     */
     public get application(): string {
-        const { kind, data } = this.membershipData;
-        switch (kind) {
-            case "rtc":
-                return data.application.type;
-            case "session":
-            default:
-                return data.application;
-        }
+        return this.applicationData.type;
     }
+
+    /**
+     * Information about the application being used for the RTC session.
+     * May contain extra keys specific to the application.
+     */
     public get applicationData(): { type: string; [key: string]: unknown } {
         const { kind, data } = this.membershipData;
         switch (kind) {
-            case "rtc":
+            case MembershipKind.RTC:
                 return data.application;
-            case "session":
+            case MembershipKind.Session:
             default:
+                // SessionData does not have application data as such. We return specific
+                // properties in use by other getters in this class, for compatibility.
                 return { "type": data.application, "m.call.intent": data["m.call.intent"] };
         }
     }
 
     /** @deprecated scope is not used and will be removed in future versions. replaced by application specific types.*/
-    public get scope(): CallScope | undefined {
+    public get scope(): SessionMembershipData["scope"] | undefined {
         const { kind, data } = this.membershipData;
         switch (kind) {
-            case "rtc":
+            case MembershipKind.RTC:
                 return undefined;
-            case "session":
+            case MembershipKind.Session:
             default:
                 return data.scope;
         }
     }
-    /**
-     * @deprecated renamed to `memberId`
-     */
-    public get membershipID(): string {
-        return this.memberId;
-    }
 
     /**
      * This computes the membership ID for the membership.
@@ -519,25 +303,33 @@ export class CallMembership {
             case "rtc":
                 return data.member.id;
             case "session":
-            default:
                 return (
                     // best case we have a client already publishing the right custom membershipId
                     data.membershipID ??
                     // alternativly we use the hard coded jwt id defuatl value (used until version 0.16.0)
                     `${this.matrixEventData.sender}:${data.device_id}`
                 );
+            default:
+                throw Error("Not possible to get memberID without knowing the membership event kind");
         }
     }
 
+    /**
+     * @deprecated renamed to `memberId`
+     */
+    public get membershipID(): string {
+        return this.memberId;
+    }
+
     public createdTs(): number {
         const { kind, data } = this.membershipData;
         switch (kind) {
-            case "rtc":
+            case MembershipKind.RTC:
                 // TODO we need to read the referenced (relation) event if available to get the real created_ts
-                return this.matrixEventData.ts;
-            case "session":
+                return this.matrixEvent.getTs();
+            case MembershipKind.Session:
             default:
-                return data.created_ts ?? this.matrixEventData.ts;
+                return data.created_ts ?? this.matrixEvent.getTs();
         }
     }
 
@@ -548,9 +340,9 @@ export class CallMembership {
     public getAbsoluteExpiry(): number | undefined {
         const { kind, data } = this.membershipData;
         switch (kind) {
-            case "rtc":
+            case MembershipKind.RTC:
                 return undefined;
-            case "session":
+            case MembershipKind.Session:
             default:
                 // TODO: calculate this from the MatrixRTCSession join configuration directly
                 return this.createdTs() + (data.expires ?? DEFAULT_EXPIRE_DURATION);
@@ -559,19 +351,20 @@ export class CallMembership {
 
     /**
      * @returns The number of milliseconds until the membership expires or undefined if applicable
+     * @deprecated Not used by RTC events.
      */
     public getMsUntilExpiry(): number | undefined {
         const { kind } = this.membershipData;
-        switch (kind) {
-            case "rtc":
-                return undefined;
-            case "session":
-            default:
+        if (kind === MembershipKind.Session) {
+            const absExpiry = this.getAbsoluteExpiry();
+            if (absExpiry) {
                 // Assume that local clock is sufficiently in sync with other clocks in the distributed system.
                 // We used to try and adjust for the local clock being skewed, but there are cases where this is not accurate.
                 // The current implementation allows for the local clock to be -infinity to +MatrixRTCSession.MEMBERSHIP_EXPIRY_TIME/2
-                return this.getAbsoluteExpiry()! - Date.now();
+                return absExpiry - Date.now();
+            }
         }
+        return undefined;
     }
 
     /**
@@ -580,9 +373,9 @@ export class CallMembership {
     public isExpired(): boolean {
         const { kind } = this.membershipData;
         switch (kind) {
-            case "rtc":
+            case MembershipKind.RTC:
                 return false;
-            case "session":
+            case MembershipKind.Session:
             default:
                 return this.getMsUntilExpiry()! <= 0;
         }
@@ -608,30 +401,26 @@ export class CallMembership {
     public getTransport(oldestMembership: CallMembership): Transport | undefined {
         const { kind, data } = this.membershipData;
         switch (kind) {
-            case "rtc":
+            case MembershipKind.RTC:
                 return data.rtc_transports[0];
-            case "session":
+            case MembershipKind.Session:
                 switch (data.focus_active.focus_selection) {
-                    case "multi_sfu":
-                        return data.foci_preferred[0];
                     case "oldest_membership":
                         if (CallMembership.equal(this, oldestMembership)) return data.foci_preferred[0];
                         if (oldestMembership !== undefined) return oldestMembership.getTransport(oldestMembership);
                         break;
+                    case "multi_sfu":
+                        return data.foci_preferred[0];
+                    default:
+                        // `focus_selection` not understood.
+                        return undefined;
                 }
+                break;
+            default:
+                return undefined;
         }
-        return undefined;
     }
 
-    /**
-     * The focus_active filed of the session membership (m.call.member).
-     * @deprecated focus_active is not used and will be removed in future versions.
-     */
-    public getFocusActive(): LivekitFocusSelection | undefined {
-        const { kind, data } = this.membershipData;
-        if (kind === "session") return data.focus_active;
-        return undefined;
-    }
     /**
      * The value of the `rtc_transports` field for RTC memberships (m.rtc.member).
      * Or the value of the `foci_preferred` field for legacy session memberships (m.call.member).
@@ -639,14 +428,11 @@ export class CallMembership {
     public get transports(): Transport[] {
         const { kind, data } = this.membershipData;
         switch (kind) {
-            case "rtc":
+            case MembershipKind.RTC:
                 return data.rtc_transports;
-            case "session":
+            case MembershipKind.Session:
             default:
                 return data.foci_preferred;
         }
     }
-    public get kind(): MembershipData["kind"] {
-        return this.membershipData.kind;
-    }
 }