@unwanted/matrix-sdk-mini 34.12.0-1

package/src/logger.ts

@@ -0,0 +1,185 @@
+/*
+Copyright 2018 André Jaenisch
+Copyright 2019, 2021 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.
+*/
+
+import loglevel from "loglevel";
+
+/** Logger interface used within the js-sdk codebase */
+export interface Logger extends BaseLogger {
+    /**
+     * Create a child logger.
+     *
+     * @param namespace - name to add to the current logger to generate the child. Some implementations of `Logger`
+     *    use this as a prefix; others use a different mechanism.
+     */
+    getChild(namespace: string): Logger;
+}
+
+/** The basic interface for a logger which doesn't support children */
+export interface BaseLogger {
+    /**
+     * Output trace message to the logger, with stack trace.
+     *
+     * @param msg - Data to log.
+     */
+    trace(...msg: any[]): void;
+
+    /**
+     * Output debug message to the logger.
+     *
+     * @param msg - Data to log.
+     */
+    debug(...msg: any[]): void;
+
+    /**
+     * Output info message to the logger.
+     *
+     * @param msg - Data to log.
+     */
+    info(...msg: any[]): void;
+
+    /**
+     * Output warn message to the logger.
+     *
+     * @param msg - Data to log.
+     */
+    warn(...msg: any[]): void;
+
+    /**
+     * Output error message to the logger.
+     *
+     * @param msg - Data to log.
+     */
+    error(...msg: any[]): void;
+}
+
+// This is to demonstrate, that you can use any namespace you want.
+// Namespaces allow you to turn on/off the logging for specific parts of the
+// application.
+// An idea would be to control this via an environment variable (on Node.js).
+// See https://www.npmjs.com/package/debug to see how this could be implemented
+// Part of #332 is introducing a logging library in the first place.
+const DEFAULT_NAMESPACE = "matrix";
+
+// because rageshakes in react-sdk hijack the console log, also at module load time,
+// initializing the logger here races with the initialization of rageshakes.
+// to avoid the issue, we override the methodFactory of loglevel that binds to the
+// console methods at initialization time by a factory that looks up the console methods
+// when logging so we always get the current value of console methods.
+loglevel.methodFactory = function (methodName, logLevel, loggerName) {
+    return function (this: PrefixedLogger, ...args): void {
+        /* eslint-disable @typescript-eslint/no-invalid-this */
+        if (this.prefix) {
+            args.unshift(this.prefix);
+        }
+        /* eslint-enable @typescript-eslint/no-invalid-this */
+        const supportedByConsole =
+            methodName === "error" ||
+            methodName === "warn" ||
+            methodName === "trace" ||
+            methodName === "info" ||
+            methodName === "debug";
+        /* eslint-disable no-console */
+        if (supportedByConsole) {
+            return console[methodName](...args);
+        } else {
+            return console.log(...args);
+        }
+        /* eslint-enable no-console */
+    };
+};
+
+/**
+ * Implementation of {@link Logger} based on `loglevel`.
+ *
+ * @deprecated this shouldn't be public; prefer {@link Logger}.
+ */
+export interface PrefixedLogger extends loglevel.Logger, Logger {
+    /** @deprecated prefer {@link Logger.getChild} */
+    withPrefix: (prefix: string) => PrefixedLogger;
+
+    /** @deprecated internal property */
+    prefix: string;
+}
+
+/** Internal utility function to turn a `loglevel.Logger` into a `PrefixedLogger` */
+function extendLogger(logger: loglevel.Logger): void {
+    const prefixedLogger = <PrefixedLogger>logger;
+    prefixedLogger.getChild = prefixedLogger.withPrefix = function (prefix: string): PrefixedLogger {
+        const existingPrefix = this.prefix || "";
+        return getPrefixedLogger(existingPrefix + prefix);
+    };
+}
+
+function getPrefixedLogger(prefix: string): PrefixedLogger {
+    const prefixLogger = loglevel.getLogger(`${DEFAULT_NAMESPACE}-${prefix}`) as PrefixedLogger;
+    if (prefixLogger.prefix !== prefix) {
+        // Only do this setup work the first time through, as loggers are saved by name.
+        extendLogger(prefixLogger);
+        prefixLogger.prefix = prefix;
+        prefixLogger.setLevel(loglevel.levels.DEBUG, false);
+    }
+    return prefixLogger;
+}
+
+/**
+ * Drop-in replacement for `console` using {@link https://www.npmjs.com/package/loglevel|loglevel}.
+ * Can be tailored down to specific use cases if needed.
+ */
+export const logger = loglevel.getLogger(DEFAULT_NAMESPACE) as PrefixedLogger;
+logger.setLevel(loglevel.levels.DEBUG, false);
+extendLogger(logger);
+
+/**
+ * A "span" for grouping related log lines together.
+ *
+ * The current implementation just adds the name at the start of each log line.
+ *
+ * This offers a lighter-weight alternative to 'child' loggers returned by {@link Logger#getChild}. In particular,
+ * it's not possible to apply individual filters to the LogSpan such as setting the verbosity level. On the other hand,
+ * no reference to the LogSpan is retained in the logging framework, so it is safe to make lots of them over the course
+ * of an application's life and just drop references to them when the job is done.
+ */
+export class LogSpan implements BaseLogger {
+    private readonly name;
+
+    public constructor(
+        private readonly parent: BaseLogger,
+        name: string,
+    ) {
+        this.name = name + ":";
+    }
+
+    public trace(...msg: any[]): void {
+        this.parent.trace(this.name, ...msg);
+    }
+
+    public debug(...msg: any[]): void {
+        this.parent.debug(this.name, ...msg);
+    }
+
+    public info(...msg: any[]): void {
+        this.parent.info(this.name, ...msg);
+    }
+
+    public warn(...msg: any[]): void {
+        this.parent.warn(this.name, ...msg);
+    }
+
+    public error(...msg: any[]): void {
+        this.parent.error(this.name, ...msg);
+    }
+}

package/src/matrix.ts

@@ -0,0 +1,177 @@
+/*
+Copyright 2015-2022 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.
+*/
+
+import { WidgetApi } from "matrix-widget-api";
+
+import { MemoryCryptoStore } from "./crypto/store/memory-crypto-store.ts";
+import { MemoryStore } from "./store/memory.ts";
+import { MatrixScheduler } from "./scheduler.ts";
+import { MatrixClient, ICreateClientOpts } from "./client.ts";
+import { RoomWidgetClient, ICapabilities } from "./embedded.ts";
+import { CryptoStore } from "./crypto/store/base.ts";
+
+export * from "./client.ts";
+export * from "./serverCapabilities.ts";
+export * from "./embedded.ts";
+export * from "./http-api/index.ts";
+export * from "./autodiscovery.ts";
+export * from "./sync-accumulator.ts";
+export * from "./errors.ts";
+export * from "./base64.ts";
+export * from "./models/beacon.ts";
+export * from "./models/event.ts";
+export * from "./models/room.ts";
+export * from "./models/event-timeline.ts";
+export * from "./models/event-timeline-set.ts";
+export * from "./models/poll.ts";
+export * from "./models/room-member.ts";
+export * from "./models/room-state.ts";
+export * from "./models/thread.ts";
+export * from "./models/typed-event-emitter.ts";
+export * from "./models/user.ts";
+export * from "./models/device.ts";
+export * from "./models/search-result.ts";
+export * from "./oidc/index.ts";
+export * from "./scheduler.ts";
+export * from "./filter.ts";
+export * from "./timeline-window.ts";
+export * from "./interactive-auth.ts";
+export * from "./service-types.ts";
+export * from "./store/memory.ts";
+export * from "./store/indexeddb.ts";
+export * from "./crypto/store/memory-crypto-store.ts";
+export * from "./crypto/store/localStorage-crypto-store.ts";
+export * from "./crypto/store/indexeddb-crypto-store.ts";
+export type { OutgoingRoomKeyRequest } from "./crypto/store/base.ts";
+export * from "./content-repo.ts";
+export type * from "./@types/common.ts";
+export type * from "./@types/uia.ts";
+export * from "./@types/event.ts";
+export * from "./@types/PushRules.ts";
+export * from "./@types/partials.ts";
+export * from "./@types/requests.ts";
+export * from "./@types/search.ts";
+export * from "./@types/beacon.ts";
+export * from "./@types/topic.ts";
+export * from "./@types/location.ts";
+export * from "./@types/threepids.ts";
+export * from "./@types/auth.ts";
+export * from "./@types/polls.ts";
+export type * from "./@types/local_notifications.ts";
+export type * from "./@types/registration.ts";
+export * from "./@types/read_receipts.ts";
+export type * from "./@types/crypto.ts";
+export * from "./@types/extensible_events.ts";
+export type * from "./@types/IIdentityServerProvider.ts";
+export * from "./@types/membership.ts";
+export * from "./models/room-summary.ts";
+export * from "./models/event-status.ts";
+export type { RoomSummary } from "./client.ts";
+export * as ContentHelpers from "./content-helpers.ts";
+export * as SecretStorage from "./secret-storage.ts";
+export type { ICryptoCallbacks } from "./crypto/index.ts"; // used to be located here
+export { createNewMatrixCall, CallEvent } from "./webrtc/call.ts";
+export type { MatrixCall } from "./webrtc/call.ts";
+export {
+    GroupCall,
+    GroupCallEvent,
+    GroupCallIntent,
+    GroupCallState,
+    GroupCallType,
+    GroupCallStatsReportEvent,
+} from "./webrtc/groupCall.ts";
+
+export {
+    /** @deprecated Use {@link Crypto.CryptoEvent} instead */
+    CryptoEvent,
+} from "./crypto/index.ts";
+export { SyncState, SetPresence } from "./sync.ts";
+export type { ISyncStateData as SyncStateData } from "./sync.ts";
+export { SlidingSyncEvent } from "./sliding-sync.ts";
+export { MediaHandlerEvent } from "./webrtc/mediaHandler.ts";
+export { CallFeedEvent } from "./webrtc/callFeed.ts";
+export { StatsReport } from "./webrtc/stats/statsReport.ts";
+export { Relations, RelationsEvent } from "./models/relations.ts";
+export { TypedEventEmitter } from "./models/typed-event-emitter.ts";
+export { LocalStorageErrors } from "./store/local-storage-events-emitter.ts";
+export { IdentityProviderBrand, SSOAction } from "./@types/auth.ts";
+export type { ISSOFlow as SSOFlow, LoginFlow } from "./@types/auth.ts";
+export type { IHierarchyRelation as HierarchyRelation, IHierarchyRoom as HierarchyRoom } from "./@types/spaces.ts";
+export { LocationAssetType } from "./@types/location.ts";
+
+/** @deprecated Backwards-compatibility re-export. Import from `crypto-api` directly. */
+export * as Crypto from "./crypto-api/index.ts";
+
+let cryptoStoreFactory = (): CryptoStore => new MemoryCryptoStore();
+
+/**
+ * Configure a different factory to be used for creating crypto stores
+ *
+ * @param fac - a function which will return a new `CryptoStore`
+ */
+export function setCryptoStoreFactory(fac: () => CryptoStore): void {
+    cryptoStoreFactory = fac;
+}
+
+function amendClientOpts(opts: ICreateClientOpts): ICreateClientOpts {
+    opts.store =
+        opts.store ??
+        new MemoryStore({
+            localStorage: globalThis.localStorage,
+        });
+    opts.scheduler = opts.scheduler ?? new MatrixScheduler();
+    opts.cryptoStore = opts.cryptoStore ?? cryptoStoreFactory();
+
+    return opts;
+}
+
+/**
+ * Construct a Matrix Client. Similar to {@link MatrixClient}
+ * except that the 'request', 'store' and 'scheduler' dependencies are satisfied.
+ * @param opts - The configuration options for this client. These configuration
+ * options will be passed directly to {@link MatrixClient}.
+ *
+ * @returns A new matrix client.
+ * @see {@link MatrixClient} for the full list of options for
+ * `opts`.
+ */
+export function createClient(opts: ICreateClientOpts): MatrixClient {
+    return new MatrixClient(amendClientOpts(opts));
+}
+
+/**
+ * Construct a Matrix Client that works in a widget.
+ * This client has a subset of features compared to a full client.
+ * It uses the widget-api to communicate with matrix. (widget \<-\> client \<-\> homeserver)
+ * @returns A new matrix client with a subset of features.
+ * @param opts - The configuration options for this client. These configuration
+ * options will be passed directly to {@link MatrixClient}.
+ * @param widgetApi - The widget api to use for communication.
+ * @param capabilities - The capabilities the widget client will request.
+ * @param roomId - The room id the widget is associated with.
+ * @param sendContentLoaded - Whether to send a content loaded widget action immediately after initial setup.
+ *   Set to `false` if the widget uses `waitForIFrameLoad=true` (in this case the client does not expect a content loaded action at all),
+ *   or if the the widget wants to send the `ContentLoaded` action at a later point in time after the initial setup.
+ */
+export function createRoomWidgetClient(
+    widgetApi: WidgetApi,
+    capabilities: ICapabilities,
+    roomId: string,
+    opts: ICreateClientOpts,
+    sendContentLoaded = true,
+): MatrixClient {
+    return new RoomWidgetClient(widgetApi, capabilities, roomId, amendClientOpts(opts), sendContentLoaded);
+}

package/src/matrixrtc/CallMembership.ts

@@ -0,0 +1,247 @@
+/*
+Copyright 2023 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.
+*/
+
+import { EitherAnd } from "matrix-events-sdk/lib/types";
+
+import { MatrixEvent } from "../matrix.ts";
+import { deepCompare } from "../utils.ts";
+import { Focus } from "./focus.ts";
+import { isLivekitFocusActive } from "./LivekitFocus.ts";
+
+type CallScope = "m.room" | "m.user";
+// Represents an entry in the memberships section of an m.call.member event as it is on the wire
+
+// There are two different data interfaces. One for the Legacy types and one compliant with MSC4143
+
+// MSC4143 (MatrixRTC) session membership data
+
+export type SessionMembershipData = {
+    application: string;
+    call_id: string;
+    device_id: string;
+
+    focus_active: Focus;
+    foci_preferred: Focus[];
+    created_ts?: number;
+
+    // Application specific data
+    scope?: CallScope;
+};
+
+export const isSessionMembershipData = (data: CallMembershipData): data is SessionMembershipData =>
+    "focus_active" in data;
+
+const checkSessionsMembershipData = (data: any, errors: string[]): data is SessionMembershipData => {
+    const prefix = "Malformed session membership event: ";
+    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 (!Array.isArray(data.foci_preferred)) errors.push(prefix + "foci_preferred must be an array");
+    // optional parameters
+    if (data.created_ts && 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 && typeof data.scope !== "string") errors.push(prefix + "scope must be string");
+    return errors.length === 0;
+};
+
+// Legacy session membership data
+
+export type CallMembershipDataLegacy = {
+    application: string;
+    call_id: string;
+    scope: CallScope;
+    device_id: string;
+    membershipID: string;
+    created_ts?: number;
+    foci_active?: Focus[];
+} & EitherAnd<{ expires: number }, { expires_ts: number }>;
+
+export const isLegacyCallMembershipData = (data: CallMembershipData): data is CallMembershipDataLegacy =>
+    "membershipID" in data;
+
+const checkCallMembershipDataLegacy = (data: any, errors: string[]): data is CallMembershipDataLegacy => {
+    const prefix = "Malformed legacy rtc membership event: ";
+    if (!("expires" in data || "expires_ts" in data)) {
+        errors.push(prefix + "expires_ts or expires must be present");
+    }
+    if ("expires" in data) {
+        if (typeof data.expires !== "number") {
+            errors.push(prefix + "expires must be numeric");
+        }
+    }
+    if ("expires_ts" in data) {
+        if (typeof data.expires_ts !== "number") {
+            errors.push(prefix + "expires_ts must be numeric");
+        }
+    }
+
+    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.membershipID !== "string") errors.push(prefix + "membershipID must be a string");
+    // optional elements
+    if (data.created_ts && 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 && typeof data.scope !== "string") errors.push(prefix + "scope must be string");
+    return errors.length === 0;
+};
+
+export type CallMembershipData = CallMembershipDataLegacy | SessionMembershipData;
+
+export class CallMembership {
+    public static equal(a: CallMembership, b: CallMembership): boolean {
+        return deepCompare(a.membershipData, b.membershipData);
+    }
+    private membershipData: CallMembershipData;
+
+    public constructor(
+        private parentEvent: MatrixEvent,
+        data: any,
+    ) {
+        const sessionErrors: string[] = [];
+        const legacyErrors: string[] = [];
+        if (!checkSessionsMembershipData(data, sessionErrors) && !checkCallMembershipDataLegacy(data, legacyErrors)) {
+            throw Error(
+                `unknown CallMembership data. Does not match legacy call.member (${legacyErrors.join(" & ")}) events nor MSC4143 (${sessionErrors.join(" & ")})`,
+            );
+        } else {
+            this.membershipData = data;
+        }
+    }
+
+    public get sender(): string | undefined {
+        return this.parentEvent.getSender();
+    }
+
+    public get eventId(): string | undefined {
+        return this.parentEvent.getId();
+    }
+
+    public get callId(): string {
+        return this.membershipData.call_id;
+    }
+
+    public get deviceId(): string {
+        return this.membershipData.device_id;
+    }
+
+    public get application(): string | undefined {
+        return this.membershipData.application;
+    }
+
+    public get scope(): CallScope | undefined {
+        return this.membershipData.scope;
+    }
+
+    public get membershipID(): string {
+        if (isLegacyCallMembershipData(this.membershipData)) return this.membershipData.membershipID;
+        // the createdTs behaves equivalent to the membershipID.
+        // we only need the field for the legacy member envents where we needed to update them
+        // synapse ignores sending state events if they have the same content.
+        else return this.createdTs().toString();
+    }
+
+    public createdTs(): number {
+        return this.membershipData.created_ts ?? this.parentEvent.getTs();
+    }
+
+    /**
+     * Gets the absolute expiry time of the membership if applicable to this membership type.
+     * @returns The absolute expiry time of the membership as a unix timestamp in milliseconds or undefined if not applicable
+     */
+    public getAbsoluteExpiry(): number | undefined {
+        // if the membership is not a legacy membership, we assume it is MSC4143
+        if (!isLegacyCallMembershipData(this.membershipData)) return undefined;
+
+        if ("expires" in this.membershipData) {
+            // we know createdTs exists since we already do the isLegacyCallMembershipData check
+            return this.createdTs() + this.membershipData.expires;
+        } else {
+            // We know it exists because we checked for this in the constructor.
+            return this.membershipData.expires_ts;
+        }
+    }
+
+    /**
+     * Gets the expiry time of the event, converted into the device's local time.
+     * @deprecated This function has been observed returning bad data and is no longer used by MatrixRTC.
+     * @returns The local expiry time of the membership as a unix timestamp in milliseconds or undefined if not applicable
+     */
+    public getLocalExpiry(): number | undefined {
+        // if the membership is not a legacy membership, we assume it is MSC4143
+        if (!isLegacyCallMembershipData(this.membershipData)) return undefined;
+
+        if ("expires" in this.membershipData) {
+            // we know createdTs exists since we already do the isLegacyCallMembershipData check
+            const relativeCreationTime = this.parentEvent.getTs() - this.createdTs();
+
+            const localCreationTs = this.parentEvent.localTimestamp - relativeCreationTime;
+
+            return localCreationTs + this.membershipData.expires;
+        } else {
+            // With expires_ts we cannot convert to local time.
+            // TODO: Check the server timestamp and compute a diff to local time.
+            return this.membershipData.expires_ts;
+        }
+    }
+
+    /**
+     * @returns The number of milliseconds until the membership expires or undefined if applicable
+     */
+    public getMsUntilExpiry(): number | undefined {
+        if (isLegacyCallMembershipData(this.membershipData)) {
+            // 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();
+        }
+
+        // Assumed to be MSC4143
+        return undefined;
+    }
+
+    /**
+     * @returns true if the membership has expired, otherwise false
+     */
+    public isExpired(): boolean {
+        if (isLegacyCallMembershipData(this.membershipData)) return this.getMsUntilExpiry()! <= 0;
+
+        // MSC4143 events expire by being updated. So if the event exists, its not expired.
+        return false;
+    }
+
+    public getPreferredFoci(): Focus[] {
+        // To support both, the new and the old MatrixRTC memberships have two cases based
+        // on the availablitiy of `foci_preferred`
+        if (isLegacyCallMembershipData(this.membershipData)) return this.membershipData.foci_active ?? [];
+
+        // MSC4143 style membership
+        return this.membershipData.foci_preferred;
+    }
+
+    public getFocusSelection(): string | undefined {
+        if (isLegacyCallMembershipData(this.membershipData)) {
+            return "oldest_membership";
+        } else {
+            const focusActive = this.membershipData.focus_active;
+            if (isLivekitFocusActive(focusActive)) {
+                return focusActive.focus_selection;
+            }
+        }
+    }
+}

package/src/matrixrtc/LivekitFocus.ts

@@ -0,0 +1,39 @@
+/*
+Copyright 2023 New Vector Ltd
+
+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.
+*/
+
+import { Focus } from "./focus.ts";
+
+export interface LivekitFocusConfig extends Focus {
+    type: "livekit";
+    livekit_service_url: string;
+}
+
+export const isLivekitFocusConfig = (object: any): object is LivekitFocusConfig =>
+    object.type === "livekit" && "livekit_service_url" in object;
+
+export interface LivekitFocus extends LivekitFocusConfig {
+    livekit_alias: string;
+}
+
+export const isLivekitFocus = (object: any): object is LivekitFocus =>
+    isLivekitFocusConfig(object) && "livekit_alias" in object;
+
+export interface LivekitFocusActive extends Focus {
+    type: "livekit";
+    focus_selection: "oldest_membership";
+}
+export const isLivekitFocusActive = (object: any): object is LivekitFocusActive =>
+    object.type === "livekit" && "focus_selection" in object;