@appsocom/react-native 0.0.0-stage → 0.5.0

package/dist/core/room.js

@@ -0,0 +1,1236 @@
+/**
+ * A Room for React Native (and anything else with standard WebRTC objects but
+ * no DOM). Same room protocol, events and method names as the web Room in
+ * @appsocom/client, so the @appsocom/react hooks work with both.
+ *
+ * Not available here (web only): screen sharing, background blur, noise
+ * suppression (use the OS voice processing), end-to-end encryption.
+ */
+import { Emitter } from "@appsocom/client/emitter";
+import { SPEAKER, SpeakerTracker, VoiceActivity } from "@appsocom/client/speaker";
+import { CAMERA_SIMULCAST, bytesFromStats, cameraEncodings, connectionQualityFromSample, initialAdaptiveState, initialFallbackState, initialUsageMeter, minQuality, nextFallbackState, nextUsage, sampleFromStats, micBitrateCap, videoAllowList, } from "@appsocom/client/adaptive";
+import { CloseCodes, canPublishAny, claimsPermissions, claimsRole, pickLayer, resolveDataSaver, } from "@appsocom/protocol";
+import { SfuSession } from "./session.js";
+export const TOKEN_HEADER = "X-SfuKit-Token";
+const QUALITY_TO_LAYER = { high: "f", medium: "h", low: "q" };
+const PULL_KINDS = ["audio", "video", "screenVideo", "screenAudio"];
+const PING_MS = 25_000;
+const STATS_MS = 2000;
+const LEVEL_MS = 150;
+/** Join a room from React Native. Resolves once you're in. */
+export async function joinNativeRoom(options) {
+    const room = new NativeRoom(options);
+    await room._start();
+    return room;
+}
+export class NativeRoom extends Emitter {
+    roomId;
+    userId;
+    role;
+    permissions;
+    self = null;
+    connectionState = "connecting";
+    roomState = { locked: false, chat: true, spotlight: [], waitingRoom: false, breakouts: [] };
+    waiting = [];
+    chat = [];
+    recording = null;
+    #opts;
+    #webrtc;
+    #token;
+    #ws = null;
+    #left = false;
+    #attempt = 0;
+    #signalLostAt = null;
+    #reconnectTimer = null;
+    #pingTimer = null;
+    #statsTimer = null;
+    #levelTimer = null;
+    #iceServers = [];
+    #session = null;
+    #sessionGen = 0;
+    #remotes = new Map();
+    #local = { mic: null, camera: null };
+    #senders = {};
+    #announced = {};
+    #wanted;
+    #localState = { micOn: false, cameraOn: false, screenOn: false };
+    #customState;
+    #facing;
+    #vad = new VoiceActivity();
+    #speakers = new SpeakerTracker();
+    #lastLevelSentAt = 0;
+    #qualities = new Map();
+    #myQuality = null;
+    #statsCursor = null;
+    #handsKey = "";
+    #audioOnly = false;
+    #cameraBeforeAudioOnly = true;
+    #saver = resolveDataSaver("off");
+    #fallback = initialFallbackState();
+    #fallbackOn = true;
+    #recentSpeakers = [];
+    #videoAllow = null;
+    #usage = initialUsageMeter(Date.now());
+    #cameraLayers = ["f", "h", "q"];
+    /** @internal use joinNativeRoom() */
+    constructor(options) {
+        super();
+        const webrtc = options.webrtc ?? defaultWebRTC();
+        if (!webrtc)
+            throw new Error("No WebRTC implementation: pass options.webrtc (react-native-webrtc)");
+        this.#webrtc = webrtc;
+        this.#opts = { ...options, url: options.url.replace(/\/+$/, "") };
+        this.#token = options.token;
+        const claims = decodeClaims(options.token);
+        if (claims.e2ee) {
+            throw new Error("This room requires end-to-end encryption, which the React Native client doesn't support yet");
+        }
+        this.roomId = claims.room;
+        this.userId = claims.sub;
+        this.role = claimsRole(claims);
+        this.permissions = claimsPermissions(claims);
+        this.#wanted = { mic: options.audio ?? true, camera: options.video ?? true };
+        this.#facing = options.facingMode ?? "user";
+        this.#saver = resolveDataSaver(options.dataSaver ?? claims.ds ?? "off");
+        this.#cameraBeforeAudioOnly = this.#wanted.camera;
+        if (this.#saver.settings.audioOnly)
+            this.#wanted.camera = false;
+        this.#fallbackOn = options.audioFallback !== false;
+        this.#localState = { ...this.#localState, ...this.#lowBandwidthState() };
+    }
+    // ---------------- state ----------------
+    get participants() {
+        return [...this.#remotes.values()].map((r) => r.participant);
+    }
+    get localState() {
+        return { ...this.#localState };
+    }
+    get canPublish() {
+        return canPublishAny(this.permissions);
+    }
+    get metadata() {
+        return this.roomState.metadata;
+    }
+    get raisedHands() {
+        const all = this.self ? [this.self, ...this.participants] : this.participants;
+        return all.filter((p) => p.handRaisedAt != null).sort((a, b) => a.handRaisedAt - b.handRaisedAt);
+    }
+    get agents() {
+        return this.participants.filter((p) => p.kind === "agent");
+    }
+    get activeSpeakers() {
+        return this.#speakers.active(Date.now());
+    }
+    /** Audio only by choice: setAudioOnly(true) or the "audio" data saver. See also audioFallback. */
+    get audioOnly() {
+        return this.#chosenAudioOnly();
+    }
+    /** True while your connection has fallen back to audio only. */
+    get audioFallback() {
+        return this.#fallback.active;
+    }
+    get dataSaver() {
+        return { mode: this.#saver.mode, settings: { ...this.#saver.settings } };
+    }
+    /** Media data used in this call so far, current rates and MB per hour. */
+    get dataUsage() {
+        return { ...this.#usage.usage };
+    }
+    getConnectionQuality(participantId) {
+        if (participantId === this.self?.id)
+            return this.#myQuality ?? undefined;
+        return this.#qualities.get(participantId);
+    }
+    getTrack(participantId, kind) {
+        return this.#remotes.get(participantId)?.tracks[kind];
+    }
+    /** Your camera preview (null while off). Screen sharing isn't available on React Native. */
+    getLocalTrack(kind) {
+        return kind === "video" && this.#localState.cameraOn ? this.#local.camera : null;
+    }
+    // ---------------- your devices ----------------
+    toggleMic() {
+        this.setMic(!this.#localState.micOn);
+    }
+    setMic(on) {
+        this.#wanted.mic = on;
+        void this.#applyMic();
+    }
+    toggleCamera() {
+        this.setCamera(!this.#localState.cameraOn);
+    }
+    setCamera(on) {
+        this.#wanted.camera = on;
+        void this.#applyCamera();
+    }
+    /** Flip between the front and back camera. */
+    switchCamera() {
+        this.#facing = this.#facing === "user" ? "environment" : "user";
+        const t = this.#local.camera;
+        if (t?._switchCamera) {
+            t._switchCamera(); // react-native-webrtc: switches in place
+            return;
+        }
+        if (this.#local.camera) {
+            // Elsewhere: reopen the camera with the other facing mode.
+            const old = this.#local.camera;
+            this.#local.camera = null;
+            old.stop();
+            void this.#applyCamera();
+        }
+    }
+    /** Pick a specific mic/camera by device. */
+    setMicDevice(device) {
+        this.#micDeviceId = device.deviceId;
+        if (this.#local.mic) {
+            this.#local.mic.stop();
+            this.#local.mic = null;
+            void this.#applyMic();
+        }
+    }
+    setCameraDevice(device) {
+        this.#cameraDeviceId = device.deviceId;
+        if (this.#local.camera) {
+            this.#local.camera.stop();
+            this.#local.camera = null;
+            void this.#applyCamera();
+        }
+    }
+    #micDeviceId;
+    #cameraDeviceId;
+    setCustomState(custom) {
+        this.#customState = custom;
+        this.#send({ type: "state", state: { custom } });
+    }
+    // ---------------- moderation & classroom (same as the web Room) ----------------
+    #mod() {
+        if (!this.permissions.moderate)
+            throw new Error("not allowed to moderate");
+    }
+    setPermissions(userId, permissions) {
+        this.#mod();
+        this.#send({ type: "set-permissions", userId, permissions });
+    }
+    mute(userId, devices = ["mic"], options = {}) {
+        this.#mod();
+        this.#send({ type: "mute", userId, devices, ...(options.lock ? { lock: true } : {}) });
+    }
+    muteAll(devices = ["mic"], options = {}) {
+        this.mute("*", devices, options);
+    }
+    stopScreenShare(userId) {
+        this.mute(userId, ["screen"]);
+    }
+    remove(userId, options = {}) {
+        this.#mod();
+        this.#send({ type: "remove", userId, ...(options.ban ? { ban: true } : {}) });
+    }
+    raiseHand() {
+        this.#send({ type: "hand", raised: true });
+    }
+    lowerHand(userId) {
+        if (!userId || userId === this.userId)
+            this.#send({ type: "hand", raised: false });
+        else
+            this.#send({ type: "lower-hand", userId });
+    }
+    lowerAllHands() {
+        this.lowerHand("*");
+    }
+    sendChat(text, options = {}) {
+        this.#send({ type: "chat", text, ...(options.to ? { to: options.to } : {}), ...(options.everywhere ? { everywhere: true } : {}) });
+    }
+    deleteChat(id) {
+        this.#send({ type: "chat-delete", id });
+    }
+    setChatEnabled(enabled) {
+        this.#mod();
+        this.#send({ type: "room", chat: enabled });
+    }
+    setSpotlight(userIds) {
+        this.#mod();
+        this.#send({ type: "room", spotlight: userIds });
+    }
+    setWaitingRoom(on) {
+        this.#mod();
+        this.#send({ type: "room", waitingRoom: on });
+    }
+    lockRoom(locked = true) {
+        this.#mod();
+        this.#send({ type: "room", locked });
+    }
+    admit(userId) {
+        this.#mod();
+        this.#send({ type: "admit", userId });
+    }
+    deny(userId) {
+        this.#mod();
+        this.#send({ type: "deny", userId });
+    }
+    startRecording(options = {}) {
+        this.#mod();
+        this.#send({ type: "start-recording", video: options.video === true });
+    }
+    stopRecording() {
+        this.#mod();
+        this.#send({ type: "stop-recording" });
+    }
+    sendToAgent(agentId, text) {
+        this.#send({ type: "agent-text", agentId, text });
+    }
+    /** App message to everyone else (room.on("message") on their side). */
+    send(data) {
+        this.#send({ type: "broadcast", data });
+    }
+    updateToken(token) {
+        const c = decodeClaims(token);
+        if (c.room !== this.roomId || c.sub !== this.userId)
+            throw new Error("new token is for a different room or user");
+        this.#token = token;
+        this.#send({ type: "token", token }); // the room keeps this connection past the old expiry
+    }
+    // ---------------- what you receive ----------------
+    setSubscribed(participantId, kinds, on) {
+        const r = this.#remotes.get(participantId);
+        if (!r)
+            return;
+        for (const k of Array.isArray(kinds) ? kinds : [kinds])
+            r.subscribed[k] = on;
+        this.#syncPulls(r);
+    }
+    isSubscribed(participantId, kind) {
+        const r = this.#remotes.get(participantId);
+        return !!r && this.#wants(r, kind);
+    }
+    /** "high" | "medium" | "low" | "off" video from one participant. */
+    setVideoQuality(participantId, quality) {
+        const r = this.#remotes.get(participantId);
+        if (!r || r.quality === quality)
+            return;
+        r.quality = quality;
+        this.#applyQuality(r);
+    }
+    /** Stop everyone's camera video (and your own camera); screen shares still come through. */
+    setAudioOnly(on) {
+        if (on === this.#audioOnly)
+            return;
+        const before = this.#chosenAudioOnly();
+        this.#audioOnly = on;
+        this.#afterAudioOnlyChange(before);
+    }
+    /**
+     * Data saver for costly or weak mobile data: "off", "low", "minimal",
+     * "audio", or custom settings like `{ base: "low", activeSpeakerVideo: 2 }`.
+     */
+    setDataSaver(input) {
+        const next = resolveDataSaver(input);
+        if (this.#left)
+            return;
+        const before = this.#chosenAudioOnly();
+        this.#saver = next;
+        this.#afterAudioOnlyChange(before);
+        this.emit("data-saver", next.mode, { ...next.settings });
+    }
+    /** Turn the audio-first fallback on or off; off while active brings video back now. */
+    setAudioFallback(enabled) {
+        this.#fallbackOn = enabled;
+        if (!enabled && this.#fallback.active) {
+            this.#fallback = { ...this.#fallback, active: false, good: 0, lastRecoveredAt: Date.now() };
+            this.#afterFallbackChange();
+        }
+    }
+    // ---------------- low bandwidth ----------------
+    #chosenAudioOnly() {
+        return this.#audioOnly || this.#saver.settings.audioOnly;
+    }
+    #afterAudioOnlyChange(before) {
+        const now = this.#chosenAudioOnly();
+        if (now && !before) {
+            this.#cameraBeforeAudioOnly = this.#wanted.camera;
+            this.setCamera(false);
+        }
+        else if (!now && before && this.#cameraBeforeAudioOnly) {
+            this.setCamera(true);
+        }
+        this.#refreshVideoAllow(false);
+        this.#applyAllQualities();
+        void this.#applySendParams();
+        this.#sendLowBandwidthState();
+    }
+    #afterFallbackChange() {
+        this.#applyAllQualities();
+        void this.#applySendParams();
+        this.#sendLowBandwidthState();
+        this.emit("audio-fallback", this.#fallback.active);
+    }
+    #lowBandwidthState() {
+        return {
+            audioOnly: this.#chosenAudioOnly() || this.#fallback.active,
+            audioFallback: this.#fallback.active,
+            dataSaver: this.#saver.mode === "custom" ? "low" : this.#saver.mode,
+        };
+    }
+    #sendLowBandwidthState() {
+        const next = this.#lowBandwidthState();
+        const cur = this.#localState;
+        if (cur.audioOnly === next.audioOnly && cur.audioFallback === next.audioFallback && cur.dataSaver === next.dataSaver)
+            return;
+        this.#localState = { ...cur, ...next };
+        this.#send({ type: "state", state: next });
+        this.emit("local-state", this.localState);
+    }
+    #effectiveQuality(r) {
+        if (this.#chosenAudioOnly() || this.#fallback.active)
+            return "off";
+        if (this.#videoAllow && !this.#videoAllow.has(r.participant.id))
+            return "off";
+        return minQuality(r.quality, this.#saver.settings.maxReceiveQuality);
+    }
+    #applyQuality(r) {
+        const next = this.#effectiveQuality(r);
+        const prev = r.effective;
+        if (next === prev)
+            return this.#syncPulls(r);
+        r.effective = next;
+        const pulled = r.pulled.video;
+        if (next !== "off" && prev !== "off" && pulled && r.participant.tracks.video?.layers?.length) {
+            void this.#session?.setLayer(pulled.mid, pulled.ref, pickLayer(QUALITY_TO_LAYER[next], r.participant.tracks.video.layers)).catch(() => { });
+        }
+        this.#syncPulls(r);
+        if ((prev === "off") !== (next === "off") && r.participant.tracks.video)
+            this.emit("video-paused", r.participant, next === "off");
+        this.emit("video-quality", r.participant, next);
+    }
+    #applyAllQualities() {
+        for (const r of this.#remotes.values())
+            this.#applyQuality(r);
+    }
+    #refreshVideoAllow(apply = true) {
+        const present = [...this.#remotes.keys()];
+        const spot = new Set(this.roomState.spotlight ?? []);
+        const always = [...this.#remotes.values()].filter((r) => spot.has(r.participant.userId)).map((r) => r.participant.id);
+        this.#recentSpeakers = this.#recentSpeakers.filter((id) => this.#remotes.has(id));
+        const next = videoAllowList(this.#saver.settings.activeSpeakerVideo, this.#recentSpeakers, present, always);
+        const prev = this.#videoAllow;
+        const same = next === prev || (!!next && !!prev && next.size === prev.size && [...next].every((id) => prev.has(id)));
+        this.#videoAllow = next;
+        if (!same && apply)
+            this.#applyAllQualities();
+        return !same;
+    }
+    /** Camera layers/bitrate/pause and mic bitrate, from the data saver and fallback. */
+    async #applySendParams() {
+        const s = this.#saver.settings;
+        const cam = this.#senders.camera;
+        if (cam) {
+            try {
+                const params = cam.sender.getParameters();
+                const encs = params.encodings ?? [];
+                const simulcast = encs.length > 1;
+                const sending = !this.#fallback.active && !s.audioOnly && s.maxSendHeight !== 0;
+                const height = this.#local.camera?.getSettings?.().height ?? 720;
+                const rids = encs.map((e) => e.rid).filter((r) => r === "f" || r === "h" || r === "q");
+                const { encodings, layers } = cameraEncodings(simulcast, s, sending, height, simulcast ? rids : undefined);
+                params.encodings = encs.map((e, i) => {
+                    const want = (simulcast ? encodings.find((x) => x.rid === e.rid) : encodings[0]) ?? encodings[i] ?? {};
+                    const out = { ...e, active: want.active ?? true };
+                    for (const k of ["maxBitrate", "maxFramerate", "scaleResolutionDownBy"]) {
+                        if (want[k] !== undefined)
+                            out[k] = want[k];
+                        else
+                            delete out[k];
+                    }
+                    return out;
+                });
+                await cam.sender.setParameters(params);
+                if (simulcast && layers.join() !== this.#cameraLayers.join()) {
+                    this.#cameraLayers = layers;
+                    const v = this.#announced.video;
+                    if (v) {
+                        v.layers = [...layers];
+                        this.#send({ type: "tracks", tracks: { video: v } });
+                    }
+                }
+                const paused = !sending;
+                if (!!this.#localState.videoPaused !== paused) {
+                    this.#localState = { ...this.#localState, videoPaused: paused };
+                    this.#send({ type: "state", state: { videoPaused: paused } });
+                    this.emit("video-paused", null, paused);
+                    this.emit("local-state", this.localState);
+                }
+            }
+            catch {
+                /* not supported by this WebRTC build */
+            }
+        }
+        const mic = this.#senders.mic;
+        if (mic) {
+            try {
+                const params = mic.sender.getParameters();
+                const cap = micBitrateCap(s.maxAudioBitrate, this.#fallback.active);
+                params.encodings = (params.encodings?.length ? params.encodings : [{}]).map((e) => {
+                    const out = { ...e };
+                    if (cap > 0)
+                        out.maxBitrate = cap;
+                    else
+                        delete out.maxBitrate;
+                    return out;
+                });
+                await mic.sender.setParameters(params);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    // ---------------- leave ----------------
+    leave(reason = "left") {
+        if (this.#left)
+            return;
+        this.#left = true;
+        for (const t of [this.#reconnectTimer, this.#pingTimer, this.#statsTimer, this.#levelTimer]) {
+            if (t)
+                clearTimeout(t);
+        }
+        if (this.#pingTimer)
+            clearInterval(this.#pingTimer);
+        if (this.#statsTimer)
+            clearInterval(this.#statsTimer);
+        if (this.#levelTimer)
+            clearInterval(this.#levelTimer);
+        try {
+            this.#ws?.close(1000, "leaving");
+        }
+        catch {
+            /* ignore */
+        }
+        this.#ws = null;
+        for (const id of [...this.#remotes.keys()])
+            this.#removeRemote(id);
+        this.#local.mic?.stop();
+        this.#local.camera?.stop();
+        this.#local = { mic: null, camera: null };
+        this.#session?.destroy();
+        this.#session = null;
+        this.#setConnection("disconnected");
+        this.emit("left", reason);
+        this.removeAllListeners();
+    }
+    // ---------------- startup ----------------
+    /** @internal */
+    async _start() {
+        await new Promise((resolve, reject) => {
+            let timer = null;
+            const arm = () => {
+                timer = setTimeout(() => {
+                    reject(new Error("timed out joining room"));
+                    this.leave("join-timeout");
+                }, this.#opts.joinTimeoutMs ?? 15000);
+            };
+            arm();
+            this.#connect({
+                onWelcome: () => {
+                    if (timer)
+                        clearTimeout(timer);
+                    resolve();
+                },
+                onFatal: (reason) => {
+                    if (timer)
+                        clearTimeout(timer);
+                    reject(new Error(reason));
+                },
+                onWaiting: () => {
+                    if (timer)
+                        clearTimeout(timer); // no timeout while waiting to be admitted
+                    this.#opts.onWaiting?.();
+                    this.emit("waiting");
+                },
+            });
+        });
+        this.#iceServers = this.#opts.iceServers ?? (await this.#fetchIceServers());
+        if (this.#left)
+            return;
+        await this.#newSession();
+        this.#levelTimer = setInterval(() => void this.#measureLevel(), LEVEL_MS);
+        this.#statsTimer = setInterval(() => void this.#measureLink(), STATS_MS);
+    }
+    #headers = () => ({ [TOKEN_HEADER]: this.#token });
+    async #fetchIceServers() {
+        try {
+            const f = this.#opts.fetch ?? fetch;
+            const res = await f(`${this.#opts.url}/partytracks/generate-ice-servers`, { headers: this.#headers() });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            const body = (await res.json());
+            if (Array.isArray(body.iceServers) && body.iceServers.length)
+                return body.iceServers;
+            throw new Error("no ICE servers in response");
+        }
+        catch (err) {
+            this.emit("error", new Error(`Could not load ICE servers, using public STUN only (${String(err)})`));
+            return [{ urls: ["stun:stun.cloudflare.com:3478"] }];
+        }
+    }
+    /** Create (or replace, after a failure) the media session; re-publish and re-pull everything. */
+    async #newSession() {
+        const gen = ++this.#sessionGen;
+        this.#session?.destroy();
+        const s = new SfuSession(`${this.#opts.url}/partytracks`, this.#headers, this.#iceServers, this.#webrtc, this.#opts.fetch);
+        this.#session = s;
+        s.on("state", (st) => this.emit("media-connection", st));
+        s.on("failed", (why) => {
+            if (this.#left || gen !== this.#sessionGen)
+                return;
+            this.emit("error", new Error(`Media connection lost (${why}), reconnecting`));
+            if (this.connectionState === "connected")
+                this.#setConnection("reconnecting");
+            setTimeout(() => {
+                if (!this.#left && gen === this.#sessionGen)
+                    void this.#newSession().then(() => this.#ws && this.#setConnection("connected"));
+            }, 1000);
+        });
+        try {
+            await s.start();
+        }
+        catch (err) {
+            if (gen !== this.#sessionGen || this.#left)
+                return;
+            this.emit("error", err instanceof Error ? err : new Error(String(err)));
+            setTimeout(() => !this.#left && gen === this.#sessionGen && void this.#newSession(), 3000);
+            return;
+        }
+        if (gen !== this.#sessionGen || this.#left)
+            return;
+        this.#senders = {};
+        this.#announced = {};
+        for (const r of this.#remotes.values()) {
+            r.pulled = {};
+            r.pulling = {};
+        }
+        await Promise.all([this.#applyMic(), this.#applyCamera()]);
+        for (const r of this.#remotes.values())
+            this.#syncPulls(r);
+    }
+    // ---------------- publishing ----------------
+    async #applyMic() {
+        const allowed = this.permissions.mic;
+        const want = this.#wanted.mic && allowed;
+        if (!allowed && this.#local.mic) {
+            await this.#unpublish("mic");
+        }
+        if (want && !this.#local.mic) {
+            try {
+                const stream = await this.#webrtc.mediaDevices.getUserMedia({
+                    audio: this.#micDeviceId ? { deviceId: { exact: this.#micDeviceId } } : true,
+                    video: false,
+                });
+                if (this.#left)
+                    return stream.getTracks().forEach((t) => t.stop());
+                this.#local.mic = stream.getAudioTracks()[0] ?? null;
+            }
+            catch (err) {
+                this.#wanted.mic = false;
+                this.emit("error", new Error(`Could not start the microphone (${errText(err)})`));
+            }
+        }
+        if (this.#local.mic)
+            this.#local.mic.enabled = want;
+        if (allowed && this.#local.mic && this.#session && !this.#senders.mic) {
+            await this.#publish("mic", this.#local.mic);
+        }
+        else if (this.#senders.mic && this.#local.mic && this.#senders.mic.sender.track !== this.#local.mic) {
+            await this.#senders.mic.sender.replaceTrack(this.#local.mic);
+        }
+        this.#setLocal({ micOn: want && !!this.#local.mic });
+    }
+    async #applyCamera() {
+        const allowed = this.permissions.camera;
+        const want = this.#wanted.camera && allowed;
+        if (!allowed && (this.#local.camera || this.#senders.camera)) {
+            await this.#unpublish("camera");
+        }
+        if (want && !this.#local.camera) {
+            try {
+                const stream = await this.#webrtc.mediaDevices.getUserMedia({
+                    audio: false,
+                    video: this.#cameraDeviceId
+                        ? { deviceId: { exact: this.#cameraDeviceId }, width: { ideal: 1280 }, height: { ideal: 720 } }
+                        : { facingMode: this.#facing, width: { ideal: 1280 }, height: { ideal: 720 }, frameRate: { ideal: 30 } },
+                });
+                if (this.#left || !this.#wanted.camera)
+                    return stream.getTracks().forEach((t) => t.stop());
+                this.#local.camera = stream.getVideoTracks()[0] ?? null;
+            }
+            catch (err) {
+                this.#wanted.camera = false;
+                this.emit("error", new Error(`Could not start the camera (${errText(err)})`));
+            }
+        }
+        if (!want && this.#local.camera) {
+            // Camera off: stop capturing (camera light off), keep the track slot published.
+            this.#local.camera.stop();
+            this.#local.camera = null;
+            await this.#senders.camera?.sender.replaceTrack(null).catch(() => { });
+        }
+        if (want && this.#local.camera && this.#session) {
+            if (!this.#senders.camera)
+                await this.#publish("camera", this.#local.camera);
+            else if (this.#senders.camera.sender.track !== this.#local.camera)
+                await this.#senders.camera.sender.replaceTrack(this.#local.camera);
+        }
+        const on = want && !!this.#local.camera;
+        this.#setLocal({ cameraOn: on });
+        this.emit("local-track", "video", on ? this.#local.camera : null);
+    }
+    async #publish(group, track) {
+        const s = this.#session;
+        if (!s)
+            return;
+        const kind = group === "mic" ? "audio" : "video";
+        const simulcast = group === "camera" && this.#opts.simulcast !== false;
+        try {
+            const { trackName, transceiver } = await s.push(track, randomId(), simulcast ? CAMERA_SIMULCAST : undefined);
+            if (s !== this.#session)
+                return;
+            this.#senders[group] = transceiver;
+            const usedSimulcast = simulcast && (transceiver.sender.getParameters().encodings?.length ?? 0) > 1;
+            if (usedSimulcast)
+                this.#cameraLayers = ["f", "h", "q"];
+            const meta = {
+                location: "remote",
+                trackName,
+                sessionId: s.sessionId,
+                ...(usedSimulcast ? { layers: ["f", "h", "q"] } : {}),
+            };
+            // Data saver / fallback: fewer layers, caps, pause. Announce after that.
+            const limited = this.#saver.mode !== "off" || this.#fallback.active;
+            if (limited) {
+                await this.#applySendParams();
+                if (usedSimulcast)
+                    meta.layers = [...this.#cameraLayers];
+            }
+            this.#announced[kind] = meta;
+            this.#send({ type: "tracks", tracks: { [kind]: meta } });
+        }
+        catch (err) {
+            this.emit("error", new Error(`Could not publish the ${group === "mic" ? "microphone" : "camera"} (${errText(err)})`));
+        }
+    }
+    async #unpublish(group) {
+        const kind = group === "mic" ? "audio" : "video";
+        const tr = this.#senders[group];
+        delete this.#senders[group];
+        this.#local[group]?.stop();
+        this.#local[group] = null;
+        delete this.#announced[kind];
+        this.#send({ type: "tracks", tracks: { [kind]: null } });
+        if (tr?.mid)
+            await this.#session?.close([tr.mid]).catch(() => { });
+        if (group === "camera")
+            this.emit("local-track", "video", null);
+    }
+    #setLocal(patch) {
+        const next = { ...this.#localState, ...patch, custom: this.#customState };
+        if (JSON.stringify(next) === JSON.stringify(this.#localState))
+            return;
+        this.#localState = next;
+        const { micOn, cameraOn, screenOn } = next;
+        this.#send({ type: "state", state: { micOn, cameraOn, screenOn } });
+        this.emit("local-state", this.localState);
+    }
+    #applyPermissions(next) {
+        const prev = this.permissions;
+        this.permissions = { ...next };
+        if (JSON.stringify(prev) === JSON.stringify(next))
+            return;
+        if (this.#session) {
+            if (prev.mic !== next.mic)
+                void this.#applyMic();
+            if (prev.camera !== next.camera)
+                void this.#applyCamera();
+        }
+        this.emit("permissions", this.permissions, prev);
+    }
+    // ---------------- receiving ----------------
+    #wants(r, kind) {
+        const explicit = r.subscribed[kind];
+        if (explicit !== undefined)
+            return explicit;
+        const auto = this.#opts.autoSubscribe ?? true;
+        const isVideo = kind === "video" || kind === "screenVideo";
+        if (auto === false)
+            return false;
+        if (auto !== true && (isVideo ? auto.video === false : auto.audio === false))
+            return false;
+        if (kind === "video" && r.effective === "off")
+            return false;
+        if (kind === "screenVideo" && this.#fallback.active)
+            return false;
+        return true;
+    }
+    #syncPulls(r) {
+        const s = this.#session;
+        if (!s || !s.sessionId)
+            return;
+        for (const kind of PULL_KINDS) {
+            const meta = r.participant.tracks[kind];
+            const key = meta?.sessionId && meta.trackName ? `${meta.sessionId}/${meta.trackName}` : null;
+            const want = !!key && this.#wants(r, kind);
+            const current = r.pulled[kind];
+            if (current && (!want || current.key !== key))
+                this.#stopPull(r, kind);
+            if (want && key && !r.pulled[kind] && r.pulling[kind] !== key) {
+                r.pulling[kind] = key;
+                const ref = { sessionId: meta.sessionId, trackName: meta.trackName };
+                const rid = kind === "video" && meta.layers?.length && r.effective !== "off" ? pickLayer(QUALITY_TO_LAYER[r.effective], meta.layers) : undefined;
+                s.pull({ ...ref, ...(rid ? { preferredRid: rid } : {}) }).then(({ track, mid }) => {
+                    if (s !== this.#session || this.#remotes.get(r.participant.id) !== r || r.pulling[kind] !== key) {
+                        void s.close([mid]).catch(() => { });
+                        return;
+                    }
+                    delete r.pulling[kind];
+                    r.pulled[kind] = { key, mid, ref };
+                    r.tracks[kind] = track;
+                    this.emit("track", r.participant, kind, track);
+                    // Things may have changed while pulling.
+                    this.#syncPulls(r);
+                }, (err) => {
+                    if (r.pulling[kind] === key)
+                        delete r.pulling[kind];
+                    if (s === this.#session && !this.#left)
+                        this.emit("error", new Error(`Could not receive ${kind} from ${r.participant.name} (${err.message})`));
+                });
+            }
+        }
+    }
+    #stopPull(r, kind) {
+        const p = r.pulled[kind];
+        delete r.pulled[kind];
+        delete r.pulling[kind];
+        const had = !!r.tracks[kind];
+        delete r.tracks[kind];
+        if (p)
+            void this.#session?.close([p.mid]).catch(() => { });
+        if (had)
+            this.emit("track-removed", r.participant, kind);
+    }
+    #upsertRemote(p, isNew) {
+        let r = this.#remotes.get(p.id);
+        const prevLayers = r?.participant.tracks.video?.layers?.join();
+        if (!r) {
+            r = { participant: p, pulled: {}, pulling: {}, tracks: {}, subscribed: {}, quality: "high", effective: "high" };
+            this.#remotes.set(p.id, r);
+            r.participant = p;
+            const changed = this.#refreshVideoAllow(false);
+            r.effective = this.#effectiveQuality(r);
+            if (changed)
+                this.#applyAllQualities();
+        }
+        r.participant = p;
+        // A publisher on a data saver announced different layers: ask for one it sends.
+        const pulled = r.pulled.video;
+        if (pulled && r.effective !== "off" && p.tracks.video?.layers?.length && p.tracks.video.layers.join() !== prevLayers) {
+            void this.#session?.setLayer(pulled.mid, pulled.ref, pickLayer(QUALITY_TO_LAYER[r.effective], p.tracks.video.layers)).catch(() => { });
+        }
+        const q = p.state.connectionQuality;
+        if (q && this.#qualities.get(p.id) !== q) {
+            this.#qualities.set(p.id, q);
+            this.emit("connection-quality", p.id, q);
+        }
+        this.emit(isNew ? "participant-joined" : "participant-updated", p);
+        this.#syncPulls(r);
+    }
+    #removeRemote(id) {
+        const r = this.#remotes.get(id);
+        if (!r)
+            return;
+        for (const kind of PULL_KINDS)
+            if (r.pulled[kind] || r.tracks[kind])
+                this.#stopPull(r, kind);
+        this.#remotes.delete(id);
+        this.#qualities.delete(id);
+        this.#speakers.remove(id);
+        this.#refreshVideoAllow();
+        this.emit("participant-left", r.participant);
+    }
+    #reconcile(list) {
+        const ids = new Set(list.map((p) => p.id));
+        for (const id of [...this.#remotes.keys()])
+            if (!ids.has(id))
+                this.#removeRemote(id);
+        for (const p of list)
+            this.#upsertRemote(p, !this.#remotes.has(p.id));
+    }
+    // ---------------- speaking & quality (from WebRTC stats; no Web Audio on React Native) ----------------
+    async #measureLevel() {
+        const s = this.#session;
+        if (!s?.pc || this.#left || !this.self)
+            return;
+        let level = 0;
+        if (this.#localState.micOn) {
+            try {
+                const stats = await s.getStats();
+                stats.forEach((st) => {
+                    if (st.type === "media-source" && st.kind === "audio" && typeof st.audioLevel === "number")
+                        level = Math.max(level, st.audioLevel);
+                });
+            }
+            catch {
+                return;
+            }
+        }
+        const now = Date.now();
+        const flipped = this.#vad.update(level, now);
+        if (this.#vad.speaking && (flipped || now - this.#lastLevelSentAt >= SPEAKER.sendEveryMs)) {
+            const shared = Math.max(level, 0.01);
+            this.#send({ type: "speaking", level: shared });
+            this.#lastLevelSentAt = now;
+            this.#speakers.set(this.self.id, shared, now);
+        }
+        else if (flipped && !this.#vad.speaking) {
+            this.#send({ type: "speaking", level: 0 });
+            this.#speakers.set(this.self.id, 0, now);
+        }
+        this.#emitSpeakers();
+    }
+    #emitSpeakers() {
+        const changed = this.#speakers.changed(Date.now());
+        if (!changed)
+            return;
+        this.emit("active-speakers", changed);
+        if (this.#saver.settings.activeSpeakerVideo > 0) {
+            const talking = changed.filter((id) => this.#remotes.has(id));
+            if (talking.length) {
+                this.#recentSpeakers = [...talking, ...this.#recentSpeakers.filter((id) => !talking.includes(id))].slice(0, 16);
+                this.#refreshVideoAllow();
+            }
+        }
+    }
+    async #measureLink() {
+        const s = this.#session;
+        if (!s?.pc || this.#left || s.pc.connectionState !== "connected")
+            return;
+        try {
+            const report = await s.getStats();
+            const bytes = bytesFromStats(report);
+            if (bytes) {
+                this.#usage = nextUsage(this.#usage, bytes, Date.now());
+                this.emit("data-usage", this.dataUsage);
+            }
+            const first = this.#statsCursor === null;
+            const { sample, cursor } = sampleFromStats(report, this.#statsCursor);
+            this.#statsCursor = cursor;
+            if (!first && this.#fallbackOn) {
+                const was = this.#fallback.active;
+                // No adaptive steps on React Native: only severe samples count.
+                this.#fallback = nextFallbackState(this.#fallback, sample, initialAdaptiveState(), Date.now());
+                if (this.#fallback.active !== was)
+                    this.#afterFallbackChange();
+            }
+            const q = connectionQualityFromSample(sample);
+            if (q !== this.#myQuality) {
+                this.#myQuality = q;
+                this.#localState = { ...this.#localState, connectionQuality: q };
+                this.#send({ type: "state", state: { connectionQuality: q } });
+                if (this.self)
+                    this.emit("connection-quality", this.self.id, q);
+            }
+        }
+        catch {
+            /* stats not available yet */
+        }
+    }
+    // ---------------- room WebSocket ----------------
+    #connect(hooks) {
+        const WS = this.#opts.WebSocket ?? WebSocket;
+        const url = this.#opts.url.replace(/^http/, "ws") +
+            `/rooms/${encodeURIComponent(this.roomId)}/ws?token=${encodeURIComponent(this.#token)}`;
+        const ws = new WS(url);
+        this.#ws = ws;
+        let welcomed = false;
+        ws.onmessage = (ev) => {
+            let msg;
+            try {
+                msg = JSON.parse(String(ev.data));
+            }
+            catch {
+                return;
+            }
+            try {
+                if (msg.type === "welcome") {
+                    welcomed = true;
+                    this.#onWelcome(msg);
+                    hooks?.onWelcome();
+                }
+                else if (msg.type === "waiting") {
+                    hooks?.onWaiting();
+                }
+                else if (msg.type === "bye") {
+                    const fatal = closeReason(msg.code) ?? "closed-by-server";
+                    this.#ws = null;
+                    try {
+                        ws.close();
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    hooks?.onFatal(fatal);
+                    this.leave(fatal);
+                }
+                else
+                    this.#handle(msg);
+            }
+            catch (err) {
+                this.emit("error", err instanceof Error ? err : new Error(String(err)));
+            }
+        };
+        ws.onclose = (ev) => {
+            if (this.#pingTimer)
+                clearInterval(this.#pingTimer);
+            if (this.#left || ws !== this.#ws)
+                return;
+            const fatal = closeReason(ev.code);
+            if (fatal) {
+                hooks?.onFatal(fatal);
+                return this.leave(fatal);
+            }
+            if (!welcomed && hooks) {
+                hooks.onFatal("could not connect to room");
+                return this.leave("connect-failed");
+            }
+            this.#signalLostAt ??= Date.now();
+            const limit = this.#opts.reconnectTimeoutMs ?? 120_000;
+            if (this.#opts.reconnect === false || Date.now() - this.#signalLostAt > limit)
+                return this.leave("connection-lost");
+            this.#setConnection("reconnecting");
+            const delay = Math.min(500 * 2 ** this.#attempt, 8000);
+            this.#attempt++;
+            this.#reconnectTimer = setTimeout(() => this.#connect(), delay);
+        };
+    }
+    #onWelcome(msg) {
+        this.#attempt = 0;
+        this.#signalLostAt = null;
+        this.self = msg.self;
+        this.emit("self", msg.self);
+        this.#applyRole(msg.self.role);
+        if (msg.self.permissions)
+            this.#applyPermissions(msg.self.permissions);
+        this.#setRoomState(msg.room);
+        if (msg.recording !== undefined)
+            this.#setRecording(msg.recording ?? null);
+        this.#reconcile(msg.participants);
+        this.#checkHands();
+        // Re-announce after a reconnect.
+        if (Object.keys(this.#announced).length)
+            this.#send({ type: "tracks", tracks: this.#announced });
+        this.#send({ type: "state", state: { ...this.#localState, custom: this.#customState } });
+        this.#setConnection("connected");
+        if (this.#pingTimer)
+            clearInterval(this.#pingTimer);
+        this.#pingTimer = setInterval(() => this.#send({ type: "ping" }), PING_MS);
+    }
+    #handle(msg) {
+        switch (msg.type) {
+            case "participant-joined":
+                this.#upsertRemote(msg.participant, true);
+                this.#checkHands();
+                break;
+            case "participant-updated":
+                this.#upsertRemote(msg.participant, false);
+                this.#checkHands();
+                break;
+            case "participant-left":
+                this.#removeRemote(msg.id);
+                this.#checkHands();
+                this.#emitSpeakers();
+                break;
+            case "self-updated":
+                this.self = msg.self;
+                this.emit("self", msg.self);
+                this.#checkHands();
+                this.#applyRole(msg.self.role);
+                this.#applyPermissions(msg.self.permissions);
+                break;
+            case "chat":
+                this.#addChat(msg.message);
+                break;
+            case "chat-history":
+                for (const m of msg.messages)
+                    this.#addChat(m);
+                break;
+            case "chat-deleted":
+                if (this.chat.some((m) => m.id === msg.id)) {
+                    this.chat = this.chat.filter((m) => m.id !== msg.id);
+                    this.emit("chat-deleted", msg.id);
+                }
+                break;
+            case "group-changed":
+                if (this.self)
+                    this.self = { ...this.self, group: msg.group };
+                this.#reconcile(msg.participants);
+                this.#checkHands();
+                this.emit("group-changed", msg.group);
+                break;
+            case "waiting-list":
+                this.waiting = msg.waiting;
+                this.emit("waiting-list", msg.waiting);
+                break;
+            case "room-updated":
+                this.#setRoomState(msg.room);
+                break;
+            case "muted":
+                for (const d of msg.devices) {
+                    if (d === "mic")
+                        this.setMic(false);
+                    else if (d === "camera")
+                        this.setCamera(false);
+                }
+                this.emit("muted", msg.devices, msg.by ? this.#remotes.get(msg.by)?.participant : undefined);
+                break;
+            case "broadcast":
+                this.emit("message", msg.data, this.#remotes.get(msg.from)?.participant);
+                break;
+            case "speaking":
+                this.#speakers.set(msg.from, msg.level, Date.now());
+                this.#emitSpeakers();
+                break;
+            case "recording":
+                this.#setRecording(msg.recording);
+                break;
+            case "transcript":
+                this.emit("transcript", msg.segment);
+                break;
+            case "error":
+                this.emit("error", new Error(msg.message));
+                break;
+            default:
+                break;
+        }
+    }
+    #applyRole(role) {
+        if (!role || role === this.role)
+            return;
+        const prev = this.role;
+        this.role = role;
+        this.emit("role", role, prev);
+    }
+    #setRoomState(state) {
+        if (JSON.stringify(state) === JSON.stringify(this.roomState))
+            return;
+        const spotChanged = JSON.stringify(state.spotlight ?? []) !== JSON.stringify(this.roomState.spotlight ?? []);
+        this.roomState = { ...state };
+        if (spotChanged)
+            this.#refreshVideoAllow();
+        this.emit("room-state", this.roomState);
+    }
+    #setRecording(rec) {
+        if (JSON.stringify(rec) === JSON.stringify(this.recording))
+            return;
+        this.recording = rec;
+        this.emit("recording", rec);
+    }
+    #addChat(m) {
+        if (this.chat.some((x) => x.id === m.id))
+            return;
+        this.chat.push(m);
+        this.chat.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+        if (this.chat.length > 200)
+            this.chat.splice(0, this.chat.length - 200);
+        this.emit("chat", m);
+    }
+    #checkHands() {
+        const list = this.raisedHands;
+        const key = list.map((p) => `${p.id}@${p.handRaisedAt}`).join(",");
+        if (key === this.#handsKey)
+            return;
+        this.#handsKey = key;
+        this.emit("hands", list);
+    }
+    #send(msg) {
+        if (this.#ws && this.#ws.readyState === 1)
+            this.#ws.send(JSON.stringify(msg));
+    }
+    #setConnection(state) {
+        if (this.connectionState === state)
+            return;
+        this.connectionState = state;
+        this.emit("connection", state);
+    }
+}
+// ---------------- helpers ----------------
+function defaultWebRTC() {
+    const g = globalThis;
+    if (!g.RTCPeerConnection || !g.MediaStream || !g.navigator?.mediaDevices)
+        return null;
+    return { RTCPeerConnection: g.RTCPeerConnection, MediaStream: g.MediaStream, mediaDevices: g.navigator.mediaDevices };
+}
+function randomId() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    return "t-" + Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 12);
+}
+function errText(err) {
+    return err instanceof Error ? `${err.name}${err.message ? ": " + err.message : ""}` : String(err);
+}
+/** Read (not verify) the claims in a join token. Works without atob/TextDecoder. */
+export function decodeClaims(token) {
+    const part = token.split(".")[1];
+    if (!part)
+        throw new Error("invalid join token");
+    const b64 = part.replace(/-/g, "+").replace(/_/g, "/");
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    const bytes = [];
+    let buf = 0;
+    let bits = 0;
+    for (const ch of b64) {
+        const v = chars.indexOf(ch);
+        if (v < 0)
+            continue;
+        buf = (buf << 6) | v;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            bytes.push((buf >> bits) & 0xff);
+        }
+    }
+    // UTF-8 decode.
+    let json = "";
+    for (let i = 0; i < bytes.length;) {
+        const b = bytes[i++];
+        let cp;
+        if (b < 0x80)
+            cp = b;
+        else if (b < 0xe0)
+            cp = ((b & 0x1f) << 6) | (bytes[i++] & 0x3f);
+        else if (b < 0xf0)
+            cp = ((b & 0x0f) << 12) | ((bytes[i++] & 0x3f) << 6) | (bytes[i++] & 0x3f);
+        else
+            cp = ((b & 0x07) << 18) | ((bytes[i++] & 0x3f) << 12) | ((bytes[i++] & 0x3f) << 6) | (bytes[i++] & 0x3f);
+        json += String.fromCodePoint(cp);
+    }
+    const claims = JSON.parse(json);
+    if (!claims.room || !claims.sub)
+        throw new Error("invalid join token");
+    return claims;
+}
+function closeReason(code) {
+    switch (code) {
+        case CloseCodes.Kicked:
+            return "kicked";
+        case CloseCodes.RoomFull:
+            return "room-full";
+        case CloseCodes.Unauthorized:
+            return "unauthorized";
+        case CloseCodes.RoomClosed:
+            return "room-closed";
+        case CloseCodes.RoomLocked:
+            return "room-locked";
+        case CloseCodes.Denied:
+            return "denied";
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=room.js.map