@whereby.com/core 0.2.0-beta.0 → 0.2.0

package/dist/index.js

@@ -1,12 +1,15 @@
 import { createAsyncThunk, createListenerMiddleware, addListener, createSlice, createAction, createSelector, isAnyOf, combineReducers, configureStore } from '@reduxjs/toolkit';
 import { io } from 'socket.io-client';
 import adapter from 'webrtc-adapter';
-import { d as debounce } from './debounce-IlgXge5U.js';
+import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
+import { d as debounce } from './debounce-B-cWYxqK.js';
 import SDPUtils from 'sdp';
 import * as sdpTransform from 'sdp-transform';
-import { v4 } from 'uuid';
+import { v4 as v4$1 } from 'uuid';
+import { Address6 } from 'ip-address';
+import checkIp from 'check-ip';
+import validate from 'uuid-validate';
 import { detectDevice, Device } from 'mediasoup-client';
-import EventEmitter$1, { EventEmitter } from 'events';
 import nodeBtoa from 'btoa';
 import axios from 'axios';
 
@@ -184,13 +187,535 @@ createReactor([selectShouldFetchDeviceCredentials], ({ dispatch }, shouldFetchDe
     }
 });
 
+let peerConnections = [];
+let peerConnectionCounter = 0;
+const peerConnectionData = new WeakMap();
+
+const removePeerConnection = (pc) => {
+    peerConnections = peerConnections.filter((old) => old !== pc);
+};
+
+if (window.RTCPeerConnection) {
+    const OriginalRTCPeerConnection = window.RTCPeerConnection;
+    function PatchedRTCPeerConnection(rtcConfig) {
+        const pc = new OriginalRTCPeerConnection(rtcConfig);
+        peerConnections.push(pc);
+        peerConnectionData.set(pc, { index: peerConnectionCounter++ });
+        const onConnectionStateChange = () => {
+            if (pc.connectionState === "closed") {
+                removePeerConnection(pc);
+                pc.removeEventListener("connectionstatechange", onConnectionStateChange);
+            }
+        };
+        pc.addEventListener("connectionstatechange", onConnectionStateChange);
+        return pc;
+    }
+    PatchedRTCPeerConnection.prototype = OriginalRTCPeerConnection.prototype;
+    window.RTCPeerConnection = PatchedRTCPeerConnection;
+}
+
+const debugOn = new URLSearchParams(window.location.search).has("debug");
+
+class Logger {
+    constructor() {
+        this._isEnabled = debugOn;
+    }
+
+    isEnabled() {
+        return this._isEnabled;
+    }
+
+    enable() {
+        this._isEnabled = true;
+    }
+
+    disable() {
+        this._isEnabled = false;
+    }
+
+    info(...params) {
+        if (!this._isEnabled) {
+            return;
+        }
+        // eslint-disable-next-line no-console
+        return console.info(...params);
+    }
+
+    warn(...params) {
+        if (!this._isEnabled) {
+            return;
+        }
+        return console.warn(...params);
+    }
+
+    error(...params) {
+        if (!this._isEnabled) {
+            return;
+        }
+        return console.error(...params);
+    }
+
+    withDebugLogger(myDebugger = null) {
+        this._debugger = myDebugger;
+        return this;
+    }
+
+    debug(...params) {
+        if (!this._isEnabled || !this._debugger) {
+            return;
+        }
+        const suppliedParams = [];
+        params.forEach((param) => {
+            if (typeof param === "function") {
+                const suppliedParam = param();
+                suppliedParams.push(suppliedParam);
+            } else {
+                suppliedParams.push(param);
+            }
+        });
+        this._debugger.print(...suppliedParams);
+    }
+}
+
+let currentMonitor = null;
+
+const getUpdatedStats = () => currentMonitor?.getUpdatedStats();
+
+// Protocol enum used for the CLIENT (Make sure to keep it in sync with its server counterpart)
+
+// Requests: messages from the client to the server
+const PROTOCOL_REQUESTS = {
+    BLOCK_CLIENT: "block_client",
+    CLAIM_ROOM: "claim_room",
+    CLEAR_CHAT_HISTORY: "clear_chat_history",
+    ENABLE_AUDIO: "enable_audio",
+    ENABLE_VIDEO: "enable_video",
+    END_STREAM: "end_stream",
+    FETCH_MEDIASERVER_CONFIG: "fetch_mediaserver_config",
+    HANDLE_KNOCK: "handle_knock",
+    IDENTIFY_DEVICE: "identify_device",
+    INVITE_CLIENT_AS_MEMBER: "invite_client_as_member",
+    JOIN_ROOM: "join_room",
+    KICK_CLIENT: "kick_client",
+    KNOCK_ROOM: "knock_room",
+    LEAVE_ROOM: "leave_room",
+    SEND_CLIENT_METADATA: "send_client_metadata",
+    SET_LOCK: "set_lock",
+    SHARE_MEDIA: "share_media",
+    START_NEW_STREAM: "start_new_stream",
+    START_SCREENSHARE: "start_screenshare",
+    STOP_SCREENSHARE: "stop_screenshare",
+    START_URL_EMBED: "start_url_embed",
+    STOP_URL_EMBED: "stop_url_embed",
+    START_RECORDING: "start_recording",
+    STOP_RECORDING: "stop_recording",
+    SFU_TOKEN: "sfu_token",
+};
+
+// Responses: messages from the server to the client, in response to requests
+const PROTOCOL_RESPONSES = {
+    AUDIO_ENABLED: "audio_enabled",
+    BACKGROUND_IMAGE_CHANGED: "background_image_changed",
+    BLOCK_ADDED: "block_added",
+    BLOCK_REMOVED: "block_removed",
+    CHAT_HISTORY_CLEARED: "chat_history_cleared",
+    CLIENT_BLOCKED: "client_blocked",
+    CLIENT_INVITED_AS_MEMBER: "client_invited_as_member",
+    CLIENT_KICKED: "client_kicked",
+    CLIENT_LEFT: "client_left",
+    CLIENT_METADATA_RECEIVED: "client_metadata_received",
+    CLIENT_READY: "client_ready",
+    CLIENT_ROLE_CHANGED: "client_role_changed",
+    CLIENT_USER_ID_CHANGED: "client_user_id_changed",
+    CONTACTS_UPDATED: "contacts_updated",
+    DEVICE_IDENTIFIED: "device_identified",
+    ROOM_ROLES_UPDATED: "room_roles_updated",
+    KNOCK_HANDLED: "knock_handled",
+    KNOCK_PAGE_BACKGROUND_CHANGED: "knock_page_background_changed",
+    KNOCKER_LEFT: "knocker_left",
+    MEDIASERVER_CONFIG: "mediaserver_config",
+    MEDIA_SHARED: "media_shared",
+    MEMBER_INVITE: "member_invite",
+    NEW_CLIENT: "new_client",
+    NEW_STREAM_STARTED: "new_stream_started",
+    SCREENSHARE_STARTED: "screenshare_started",
+    SCREENSHARE_STOPPED: "screenshare_stopped",
+    OWNER_NOTIFIED: "owner_notified",
+    OWNERS_CHANGED: "owners_changed",
+    PLAY_CLIENT_STICKER: "play_client_sticker",
+    ROOM_INTEGRATION_ENABLED: "room_integration_enabled",
+    ROOM_INTEGRATION_DISABLED: "room_integration_disabled",
+    ROOM_JOINED: "room_joined",
+    ROOM_KNOCKED: "room_knocked",
+    ROOM_LEFT: "room_left",
+    ROOM_LOCKED: "room_locked",
+    ROOM_PERMISSIONS_CHANGED: "room_permissions_changed",
+    ROOM_LOGO_CHANGED: "room_logo_changed",
+    ROOM_TYPE_CHANGED: "room_type_changed",
+    ROOM_MODE_CHANGED: "room_mode_changed",
+    SOCKET_USER_ID_CHANGED: "socket_user_id_changed",
+    STICKERS_UNLOCKED: "stickers_unlocked",
+    STREAM_ENDED: "stream_ended",
+    URL_EMBED_STARTED: "url_embed_started",
+    URL_EMBED_STOPPED: "url_embed_stopped",
+    RECORDING_STARTED: "recording_started",
+    RECORDING_STOPPED: "recording_stopped",
+    USER_NOTIFIED: "user_notified",
+    VIDEO_ENABLED: "video_enabled",
+    CLIENT_UNABLE_TO_JOIN: "client_unable_to_join",
+};
+
+// Relays: messages between clients, relayed through the server
+const RELAY_MESSAGES = {
+    CHAT_MESSAGE: "chat_message",
+    CHAT_READ_STATE: "chat_read_state",
+    CHAT_STATE: "chat_state",
+    ICE_CANDIDATE: "ice_candidate",
+    ICE_END_OF_CANDIDATES: "ice_endofcandidates",
+    READY_TO_RECEIVE_OFFER: "ready_to_receive_offer",
+    REMOTE_CLIENT_MEDIA_REQUEST: "remote_client_media_request",
+    SDP_ANSWER: "sdp_answer",
+    SDP_OFFER: "sdp_offer",
+    VIDEO_STICKER: "video_sticker",
+};
+
+// Events: something happened that we want to let the client know about
+const PROTOCOL_EVENTS = {
+    PENDING_CLIENT_LEFT: "pending_client_left",
+    MEDIA_QUALITY_CHANGED: "media_quality_changed",
+};
+
+const logger$9 = new Logger();
+
+class ReconnectManager extends EventEmitter {
+    constructor(socket) {
+        super();
+        this._socket = socket;
+        this._clients = {};
+        this._signalDisconnectTime = undefined;
+        this.rtcManager = undefined;
+        this.metrics = {
+            roomJoinedLate: 0,
+            pendingClientCanceled: 0,
+            evaluationFailed: 0,
+            roomJoined: 0,
+        };
+
+        socket.on("disconnect", () => {
+            this._signalDisconnectTime = Date.now();
+        });
+
+        // We intercept these events and take responsiblity for forwarding them
+        socket.on(PROTOCOL_RESPONSES.ROOM_JOINED, (payload) => this._onRoomJoined(payload));
+        socket.on(PROTOCOL_RESPONSES.NEW_CLIENT, (payload) => this._onNewClient(payload));
+        socket.on(PROTOCOL_RESPONSES.CLIENT_LEFT, (payload) => this._onClientLeft(payload));
+
+        // We intercept these events and handle them without forwarding them
+        socket.on(PROTOCOL_EVENTS.PENDING_CLIENT_LEFT, (payload) => this._onPendingClientLeft(payload));
+
+        // We gather information from these events but they will also be forwarded
+        socket.on(PROTOCOL_RESPONSES.AUDIO_ENABLED, (payload) => this._onAudioEnabled(payload));
+        socket.on(PROTOCOL_RESPONSES.VIDEO_ENABLED, (payload) => this._onVideoEnabled(payload));
+        socket.on(PROTOCOL_RESPONSES.SCREENSHARE_STARTED, (payload) => this._onScreenshareChanged(payload, true));
+        socket.on(PROTOCOL_RESPONSES.SCREENSHARE_STOPPED, (payload) => this._onScreenshareChanged(payload, false));
+    }
+
+    async _onRoomJoined(payload) {
+        // We might have gotten an error
+        if (!payload.room?.clients) {
+            this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+            return;
+        }
+
+        if (!payload.selfId) {
+            this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+            return;
+        }
+
+        const myDeviceId = payload.room.clients.find((c) => payload.selfId === c.id)?.deviceId;
+        if (!myDeviceId) {
+            this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+            return;
+        }
+
+        // Try to remove our own pending client if this is a page reload
+        // Could also be a first normal room_joined which can never be glitch-free
+        if (!this._signalDisconnectTime) {
+            this._resetClientState(payload);
+            payload.room.clients = payload.room.clients.filter(
+                (c) => !(c.deviceId === myDeviceId && c.isPendingToLeave)
+            );
+            this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+            return;
+        }
+
+        // The threshold for trying glitch-free reconnect should be less than server-side configuration
+        const RECONNECT_THRESHOLD = payload.disconnectTimeout * 0.8;
+        const timeSinceDisconnect = Date.now() - this._signalDisconnectTime;
+        if (timeSinceDisconnect > RECONNECT_THRESHOLD) {
+            this._resetClientState(payload);
+            this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+            this.metrics.roomJoinedLate++;
+            return;
+        }
+
+        // At this point we want to try to attempt glitch-free reconnection experience
+
+        // Filter out our own pending client after page reload
+        payload.room.clients = payload.room.clients.filter((c) => !(c.deviceId === myDeviceId && c.isPendingToLeave));
+
+        const allStats = await getUpdatedStats();
+        payload.room.clients.forEach((client) => {
+            try {
+                if (client.id === payload.selfId) return;
+
+                // Maybe add client to state
+                if (!this._clients[client.id]) {
+                    this._addClientToState(client);
+                    return;
+                }
+                // Verify that rtcManager knows about the client
+                if (!this.rtcManager?.hasClient(client.id)) {
+                    return;
+                }
+
+                // Verify that the client state hasn't changed
+                if (
+                    this._hasClientStateChanged({
+                        clientId: client.id,
+                        webcam: client.isVideoEnabled,
+                        mic: client.isAudioEnabled,
+                        screenShare: client.streams.length > 1,
+                    })
+                ) {
+                    return;
+                }
+
+                if (this._wasClientSendingMedia(client.id)) {
+                    // Verify the client media is still flowing (not stopped from other end)
+                    if (!this._isClientMediaActive(allStats, client.id)) {
+                        return;
+                    }
+                }
+
+                client.mergeWithOldClientState = true;
+            } catch (error) {
+                logger$9.error("Failed to evaluate if we should merge client state %o", error);
+                this.metrics.evaluationFailed++;
+            }
+        });
+
+        // We will try to remove any remote client pending to leave
+        payload.room.clients.forEach((c) => {
+            if (c.isPendingToLeave) {
+                this._onPendingClientLeft({ clientId: c.id });
+            }
+        });
+
+        this.metrics.roomJoined++;
+        this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+    }
+
+    _onClientLeft(payload) {
+        const { clientId } = payload;
+        const client = this._clients[clientId];
+
+        // Remove client from state and clear timeout if client was pending to leave
+        if (client) {
+            clearTimeout(client.timeout);
+            delete this._clients[clientId];
+        }
+
+        // Old RTCManager only takes one argument, so rest is ignored.
+        this.rtcManager?.disconnect(clientId, /* activeBreakout */ null, payload.eventClaim);
+
+        this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, payload);
+    }
+
+    _onPendingClientLeft(payload) {
+        const { clientId } = payload;
+        const client = this._clients[clientId];
+
+        if (!client) {
+            logger$9.warn(`client ${clientId} not found`);
+            return;
+        }
+
+        // We've already started the check below, don't do it again
+        if (client.isPendingToLeave) {
+            return;
+        }
+
+        client.isPendingToLeave = true;
+        if (this._wasClientSendingMedia(clientId)) {
+            client.checkActiveMediaAttempts = 0;
+            this._abortIfNotActive(payload);
+        }
+    }
+
+    _onNewClient(payload) {
+        const {
+            client: { id: clientId, deviceId },
+        } = payload;
+
+        const client = this._clients[clientId];
+        if (client && client.isPendingToLeave) {
+            clearTimeout(client.timeoutHandler);
+            client.isPendingToLeave = false;
+            this.metrics.pendingClientCanceled++;
+            return;
+        }
+
+        this._getPendingClientsByDeviceId(deviceId).forEach((client) => {
+            clearTimeout(client.timeoutHandler);
+            client.isPendingToLeave = undefined;
+            this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, { clientId: client.clientId });
+        });
+
+        this._addClientToState(payload.client);
+        this.emit(PROTOCOL_RESPONSES.NEW_CLIENT, payload);
+    }
+
+    // Evaluate if we should send send client_left before getting it from signal-server
+    async _abortIfNotActive(payload) {
+        const { clientId } = payload;
+
+        let client = this._clients[clientId];
+        if (!client?.isPendingToLeave) return;
+
+        client.checkActiveMediaAttempts++;
+        if (client.checkActiveMediaAttempts > 3) {
+            return;
+        }
+
+        const stillActive = await this._checkIsActive(clientId);
+        if (stillActive) {
+            client.timeoutHandler = setTimeout(() => this._abortIfNotActive(payload), 500);
+            return;
+        }
+
+        client = this._clients[clientId];
+        if (client?.isPendingToLeave) {
+            clearTimeout(client.timeoutHandler);
+            delete this._clients[clientId];
+            this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, payload);
+        }
+    }
+
+    // Check if client is active
+    async _checkIsActive(clientId) {
+        const allStats = await getUpdatedStats();
+        return this._isClientMediaActive(allStats, clientId);
+    }
+
+    // Check if client has bitrates for all tracks
+    _isClientMediaActive(stats, clientId) {
+        const clientStats = stats?.[clientId];
+        let isActive = false;
+        if (clientStats) {
+            Object.entries(clientStats.tracks).forEach(([trackId, trackStats]) => {
+                if (trackId !== "probator")
+                    Object.values(trackStats.ssrcs).forEach((ssrcStats) => {
+                        if ((ssrcStats.bitrate || 0) > 0) isActive = true;
+                    });
+            });
+        }
+        return isActive;
+    }
+
+    _onAudioEnabled(payload) {
+        const { clientId, isAudioEnabled } = payload;
+        this._clients[clientId] = {
+            ...(this._clients[clientId] || {}),
+            isAudioEnabled,
+        };
+    }
+
+    _onVideoEnabled(payload) {
+        const { clientId, isVideoEnabled } = payload;
+        this._clients[clientId] = {
+            ...(this._clients[clientId] || {}),
+            isVideoEnabled,
+        };
+    }
+
+    _onScreenshareChanged(payload, action) {
+        const { clientId } = payload;
+        this._clients[clientId] = {
+            ...(this._clients[clientId] || {}),
+            isScreenshareEnabled: action,
+        };
+    }
+
+    _hasClientStateChanged({ clientId, webcam, mic, screenShare }) {
+        const state = this._clients[clientId];
+
+        if (!state) {
+            throw new Error(`Client ${clientId} not found in ReconnectManager state`);
+        }
+
+        if (webcam !== state.isVideoEnabled) {
+            return true;
+        }
+        if (mic !== state.isAudioEnabled) {
+            return true;
+        }
+        if (screenShare !== state.isScreenshareEnabled) {
+            return true;
+        }
+
+        return false;
+    }
+
+    _addClientToState(newClient) {
+        this._clients[newClient.id] = {
+            ...(this._clients[newClient.id] || {}),
+            isAudioEnabled: newClient.isAudioEnabled,
+            isVideoEnabled: newClient.isVideoEnabled,
+            isScreenshareEnabled: newClient.streams.length > 1,
+            deviceId: newClient.deviceId,
+            isPendingToLeave: newClient.isPendingToLeave,
+            clientId: newClient.id,
+        };
+    }
+
+    _wasClientSendingMedia(clientId) {
+        const client = this._clients[clientId];
+
+        if (!client) {
+            throw new Error(`Client ${clientId} not found in ReconnectManager state`);
+        }
+
+        return client.isAudioEnabled || client.isVideoEnabled || client.isScreenshareEnabled;
+    }
+
+    _getPendingClientsByDeviceId(deviceId) {
+        return Object.values(this._clients).filter((clientState) => {
+            return clientState.deviceId === deviceId && clientState.isPendingToLeave;
+        });
+    }
+
+    _resetClientState(payload) {
+        this._clients = {};
+        payload.room.clients.forEach((client) => {
+            if (client.id === payload.selfId) {
+                return;
+            } else {
+                this._addClientToState(client);
+            }
+        });
+    }
+}
+
 const DEFAULT_SOCKET_PATH = "/protocol/socket.io/v4";
 
+const NOOP_KEEPALIVE_INTERVAL = 2000;
+
 /**
  * Wrapper class that extends the Socket.IO client library.
  */
 class ServerSocket {
-    constructor(hostName, optionsOverrides) {
+    constructor(hostName, optionsOverrides, glitchFree) {
         this._socket = io(hostName, {
             path: DEFAULT_SOCKET_PATH,
             randomizationFactor: 0.5,
@@ -216,14 +741,41 @@ class ServerSocket {
                 this._socket.io.opts.transports = ["websocket", "polling"];
             }
         });
+
+        if (glitchFree) this._reconnectManager = new ReconnectManager(this._socket);
+
         this._socket.on("connect", () => {
             const transport = this.getTransport();
             if (transport === "websocket") {
                 this._wasConnectedUsingWebsocket = true;
+
+                // start noop keepalive loop to detect client side disconnects fast
+                if (!this.noopKeepaliveInterval)
+                    this.noopKeepaliveInterval = setInterval(() => {
+                        try {
+                            // send a noop message if it thinks it is connected (might not be)
+                            if (this._socket.connected) {
+                                this._socket.io.engine.sendPacket("noop");
+                            }
+                        } catch (ex) {}
+                    }, NOOP_KEEPALIVE_INTERVAL);
+            }
+        });
+
+        this._socket.on("disconnect", () => {
+            if (this.noopKeepaliveInterval) {
+                clearInterval(this.noopKeepaliveInterval);
+                this.noopKeepaliveInterval = null;
             }
         });
     }
 
+    setRtcManager(rtcManager) {
+        if (this._reconnectManager) {
+            this._reconnectManager.rtcManager = rtcManager;
+        }
+    }
+
     connect() {
         if (this.isConnected() || this.isConnecting()) {
             return;
@@ -282,6 +834,17 @@ class ServerSocket {
      * @returns {function} Function to deregister the listener.
      */
     on(eventName, handler) {
+        const relayableEvents = [
+            PROTOCOL_RESPONSES.ROOM_JOINED,
+            PROTOCOL_RESPONSES.CLIENT_LEFT,
+            PROTOCOL_RESPONSES.NEW_CLIENT,
+        ];
+
+        // Intercept certain events if glitch-free is enabled.
+        if (this._reconnectManager && relayableEvents.includes(eventName)) {
+            return this._interceptEvent(eventName, handler);
+        }
+
         this._socket.on(eventName, handler);
 
         return () => {
@@ -308,6 +871,23 @@ class ServerSocket {
     off(eventName, handler) {
         this._socket.off(eventName, handler);
     }
+
+    /**
+     * Intercept event and let ReconnectManager handle them.
+     */
+    _interceptEvent(eventName, handler) {
+        if (this._reconnectManager) {
+            this._reconnectManager.on(eventName, handler);
+        }
+
+        return () => {
+            if (this._reconnectManager) this._reconnectManager.removeListener(eventName, handler);
+        };
+    }
+
+    getGlitchFreeMetrics() {
+        return this._reconnectManager?.metrics;
+    }
 }
 
 function forwardSocketEvents(socket, dispatch) {
@@ -537,6 +1117,7 @@ const parseResolution = (res) => res.split(/[^\d]/g).map((n) => parseInt(n, 10))
 function getMediaConstraints({
     disableAEC,
     disableAGC,
+    fps24,
     hd,
     lax,
     lowDataMode,
@@ -547,7 +1128,7 @@ function getMediaConstraints({
 }) {
     let HIGH_HEIGHT = 480;
     let LOW_HEIGHT = 240;
-    let LOW_FPS = 15;
+    let NON_STANDARD_FPS = 0;
 
     if (hd) {
         // respect user choice, but default to HD for pro, and SD for free
@@ -560,15 +1141,20 @@ function getMediaConstraints({
         } else {
             LOW_HEIGHT = 360;
         }
-        LOW_FPS = 30; // we still use 30fps because of assumptions about temporal layers
     }
 
+    // Set framerate to 24 to increase quality/bandwidth
+    if (fps24) NON_STANDARD_FPS = 24;
+
+    // Set framerate for low data, but only for non-simulcast
+    if (lowDataMode && !simulcast) NON_STANDARD_FPS = 15;
+
     const constraints = {
         audio: { ...(preferredDeviceIds.audioId && { deviceId: preferredDeviceIds.audioId }) },
         video: {
             ...(preferredDeviceIds.videoId ? { deviceId: preferredDeviceIds.videoId } : { facingMode: "user" }),
             height: lowDataMode ? LOW_HEIGHT : HIGH_HEIGHT,
-            ...(lowDataMode && { frameRate: LOW_FPS }),
+            ...(NON_STANDARD_FPS && { frameRate: NON_STANDARD_FPS }),
         },
     };
     if (lax) {
@@ -701,6 +1287,8 @@ var assert_1 = assert;
 
 var assert$1 = /*@__PURE__*/getDefaultExportFromCjs(assert_1);
 
+const logger$8 = new Logger();
+
 const isMobile = /mobi/i.test(navigator.userAgent);
 
 class NoDevicesError extends Error {
@@ -720,7 +1308,7 @@ function getUserMedia(constraints) {
 
     return navigator.mediaDevices.getUserMedia(constraints).catch((error) => {
         const message = `${error}, ${JSON.stringify(constraints, null, 2)}`;
-        console.error(`getUserMedia ${message}`);
+        logger$8.error(`getUserMedia ${message}`);
         throw error;
     });
 }
@@ -906,7 +1494,7 @@ async function getStream(constraintOpt, { replaceStream, fallback = true } = {})
                         getConstraints({ ...constraintOpt, options: { ...constraintOpt.options, lax: true } })
                     );
                 } catch (e2) {
-                    console.warn(`Tried getting stream again with laxer constraints, but failed: ${"" + e2}`);
+                    logger$8.warn(`Tried getting stream again with laxer constraints, but failed: ${"" + e2}`);
                 }
                 // Message often hints at which was the problem, let's use that
                 const errMsg = ("" + e).toLowerCase();
@@ -915,7 +1503,7 @@ async function getStream(constraintOpt, { replaceStream, fallback = true } = {})
                     try {
                         stream = await getUserMedia(getConstraints({ ...constraintOpt, [problemWith]: null }));
                     } catch (e2) {
-                        console.warn(`Re-tried ${problemWith} with no constraints, but failed: ${"" + e2}`);
+                        logger$8.warn(`Re-tried ${problemWith} with no constraints, but failed: ${"" + e2}`);
                     }
                 }
                 if (!stream) {
@@ -926,7 +1514,7 @@ async function getStream(constraintOpt, { replaceStream, fallback = true } = {})
                         try {
                             stream = await getUserMedia(getConstraints({ ...constraintOpt, [kind]: false }));
                         } catch (e2) {
-                            console.warn(`Re-tried without ${kind}, but failed: ${"" + e2}`);
+                            logger$8.warn(`Re-tried without ${kind}, but failed: ${"" + e2}`);
                         }
                         if (stream) break;
                     }
@@ -1978,163 +2566,65 @@ const doConnectRoom = createAppThunk(() => (dispatch, getState) => {
         organizationId,
         roomKey,
         roomName,
-        selfId,
-        userAgent: `browser-sdk:${sdkVersion || "unknown"}`,
-        externalId,
-    });
-    dispatch(connectionStatusChanged("connecting"));
-});
-const selectRoomConnectionRaw = (state) => state.roomConnection;
-const selectRoomConnectionSession = (state) => state.roomConnection.session;
-const selectRoomConnectionSessionId = (state) => { var _a; return (_a = state.roomConnection.session) === null || _a === void 0 ? void 0 : _a.id; };
-const selectRoomConnectionStatus = (state) => state.roomConnection.status;
-const selectShouldConnectRoom = createSelector([selectOrganizationId, selectRoomConnectionStatus, selectSignalConnectionDeviceIdentified, selectLocalMediaStatus], (hasOrganizationIdFetched, roomConnectionStatus, signalConnectionDeviceIdentified, localMediaStatus) => {
-    if (localMediaStatus === "started" &&
-        signalConnectionDeviceIdentified &&
-        !!hasOrganizationIdFetched &&
-        ["initializing", "reconnect"].includes(roomConnectionStatus)) {
-        return true;
-    }
-    return false;
-});
-createReactor([selectShouldConnectRoom], ({ dispatch }, shouldConnectRoom) => {
-    if (shouldConnectRoom) {
-        dispatch(doConnectRoom());
-    }
-});
-startAppListening({
-    actionCreator: signalEvents.knockHandled,
-    effect: ({ payload }, { dispatch, getState }) => {
-        const { clientId, resolution } = payload;
-        const state = getState();
-        const selfId = selectSelfId(state);
-        if (clientId !== selfId) {
-            return;
-        }
-        if (resolution === "accepted") {
-            dispatch(setRoomKey(payload.metadata.roomKey));
-            dispatch(doConnectRoom());
-        }
-        else if (resolution === "rejected") {
-            dispatch(connectionStatusChanged("knock_rejected"));
-        }
-    },
-});
-
-const EVENTS = {
-    CLIENT_CONNECTION_STATUS_CHANGED: "client_connection_status_changed",
-    STREAM_ADDED: "stream_added",
-    RTC_MANAGER_CREATED: "rtc_manager_created",
-    RTC_MANAGER_DESTROYED: "rtc_manager_destroyed",
-    LOCAL_STREAM_TRACK_ADDED: "local_stream_track_added",
-    LOCAL_STREAM_TRACK_REMOVED: "local_stream_track_removed",
-    REMOTE_STREAM_TRACK_ADDED: "remote_stream_track_added",
-    REMOTE_STREAM_TRACK_REMOVED: "remote_stream_track_removed",
-};
-
-const TYPES = {
-    CONNECTING: "connecting",
-    CONNECTION_FAILED: "connection_failed",
-    CONNECTION_SUCCESSFUL: "connection_successful",
-    CONNECTION_DISCONNECTED: "connection_disconnected",
-};
-
-// Protocol enum used for the CLIENT (Make sure to keep it in sync with its server counterpart)
-
-// Requests: messages from the client to the server
-const PROTOCOL_REQUESTS = {
-    BLOCK_CLIENT: "block_client",
-    CLAIM_ROOM: "claim_room",
-    CLEAR_CHAT_HISTORY: "clear_chat_history",
-    ENABLE_AUDIO: "enable_audio",
-    ENABLE_VIDEO: "enable_video",
-    END_STREAM: "end_stream",
-    FETCH_MEDIASERVER_CONFIG: "fetch_mediaserver_config",
-    HANDLE_KNOCK: "handle_knock",
-    IDENTIFY_DEVICE: "identify_device",
-    INVITE_CLIENT_AS_MEMBER: "invite_client_as_member",
-    JOIN_ROOM: "join_room",
-    KICK_CLIENT: "kick_client",
-    KNOCK_ROOM: "knock_room",
-    LEAVE_ROOM: "leave_room",
-    SEND_CLIENT_METADATA: "send_client_metadata",
-    SET_LOCK: "set_lock",
-    SHARE_MEDIA: "share_media",
-    START_NEW_STREAM: "start_new_stream",
-    START_SCREENSHARE: "start_screenshare",
-    STOP_SCREENSHARE: "stop_screenshare",
-    START_URL_EMBED: "start_url_embed",
-    STOP_URL_EMBED: "stop_url_embed",
-    START_RECORDING: "start_recording",
-    STOP_RECORDING: "stop_recording",
-    SFU_TOKEN: "sfu_token",
-};
-
-// Responses: messages from the server to the client, in response to requests
-const PROTOCOL_RESPONSES = {
-    AUDIO_ENABLED: "audio_enabled",
-    BACKGROUND_IMAGE_CHANGED: "background_image_changed",
-    BLOCK_ADDED: "block_added",
-    BLOCK_REMOVED: "block_removed",
-    CHAT_HISTORY_CLEARED: "chat_history_cleared",
-    CLIENT_BLOCKED: "client_blocked",
-    CLIENT_INVITED_AS_MEMBER: "client_invited_as_member",
-    CLIENT_KICKED: "client_kicked",
-    CLIENT_LEFT: "client_left",
-    CLIENT_METADATA_RECEIVED: "client_metadata_received",
-    CLIENT_READY: "client_ready",
-    CLIENT_ROLE_CHANGED: "client_role_changed",
-    CLIENT_USER_ID_CHANGED: "client_user_id_changed",
-    CONTACTS_UPDATED: "contacts_updated",
-    DEVICE_IDENTIFIED: "device_identified",
-    ROOM_ROLES_UPDATED: "room_roles_updated",
-    KNOCK_HANDLED: "knock_handled",
-    KNOCK_PAGE_BACKGROUND_CHANGED: "knock_page_background_changed",
-    KNOCKER_LEFT: "knocker_left",
-    MEDIASERVER_CONFIG: "mediaserver_config",
-    MEDIA_SHARED: "media_shared",
-    MEMBER_INVITE: "member_invite",
-    NEW_CLIENT: "new_client",
-    NEW_STREAM_STARTED: "new_stream_started",
-    SCREENSHARE_STARTED: "screenshare_started",
-    SCREENSHARE_STOPPED: "screenshare_stopped",
-    OWNER_NOTIFIED: "owner_notified",
-    OWNERS_CHANGED: "owners_changed",
-    PLAY_CLIENT_STICKER: "play_client_sticker",
-    ROOM_INTEGRATION_ENABLED: "room_integration_enabled",
-    ROOM_INTEGRATION_DISABLED: "room_integration_disabled",
-    ROOM_JOINED: "room_joined",
-    ROOM_KNOCKED: "room_knocked",
-    ROOM_LEFT: "room_left",
-    ROOM_LOCKED: "room_locked",
-    ROOM_PERMISSIONS_CHANGED: "room_permissions_changed",
-    ROOM_LOGO_CHANGED: "room_logo_changed",
-    ROOM_TYPE_CHANGED: "room_type_changed",
-    ROOM_MODE_CHANGED: "room_mode_changed",
-    SOCKET_USER_ID_CHANGED: "socket_user_id_changed",
-    STICKERS_UNLOCKED: "stickers_unlocked",
-    STREAM_ENDED: "stream_ended",
-    URL_EMBED_STARTED: "url_embed_started",
-    URL_EMBED_STOPPED: "url_embed_stopped",
-    RECORDING_STARTED: "recording_started",
-    RECORDING_STOPPED: "recording_stopped",
-    USER_NOTIFIED: "user_notified",
-    VIDEO_ENABLED: "video_enabled",
-    CLIENT_UNABLE_TO_JOIN: "client_unable_to_join",
+        selfId,
+        userAgent: `browser-sdk:${sdkVersion || "unknown"}`,
+        externalId,
+    });
+    dispatch(connectionStatusChanged("connecting"));
+});
+const selectRoomConnectionRaw = (state) => state.roomConnection;
+const selectRoomConnectionSession = (state) => state.roomConnection.session;
+const selectRoomConnectionSessionId = (state) => { var _a; return (_a = state.roomConnection.session) === null || _a === void 0 ? void 0 : _a.id; };
+const selectRoomConnectionStatus = (state) => state.roomConnection.status;
+const selectShouldConnectRoom = createSelector([selectOrganizationId, selectRoomConnectionStatus, selectSignalConnectionDeviceIdentified, selectLocalMediaStatus], (hasOrganizationIdFetched, roomConnectionStatus, signalConnectionDeviceIdentified, localMediaStatus) => {
+    if (localMediaStatus === "started" &&
+        signalConnectionDeviceIdentified &&
+        !!hasOrganizationIdFetched &&
+        ["initializing", "reconnect"].includes(roomConnectionStatus)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectRoom], ({ dispatch }, shouldConnectRoom) => {
+    if (shouldConnectRoom) {
+        dispatch(doConnectRoom());
+    }
+});
+startAppListening({
+    actionCreator: signalEvents.knockHandled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { clientId, resolution } = payload;
+        const state = getState();
+        const selfId = selectSelfId(state);
+        if (clientId !== selfId) {
+            return;
+        }
+        if (resolution === "accepted") {
+            dispatch(setRoomKey(payload.metadata.roomKey));
+            dispatch(doConnectRoom());
+        }
+        else if (resolution === "rejected") {
+            dispatch(connectionStatusChanged("knock_rejected"));
+        }
+    },
+});
+
+const EVENTS = {
+    CLIENT_CONNECTION_STATUS_CHANGED: "client_connection_status_changed",
+    STREAM_ADDED: "stream_added",
+    RTC_MANAGER_CREATED: "rtc_manager_created",
+    RTC_MANAGER_DESTROYED: "rtc_manager_destroyed",
+    LOCAL_STREAM_TRACK_ADDED: "local_stream_track_added",
+    LOCAL_STREAM_TRACK_REMOVED: "local_stream_track_removed",
+    REMOTE_STREAM_TRACK_ADDED: "remote_stream_track_added",
+    REMOTE_STREAM_TRACK_REMOVED: "remote_stream_track_removed",
 };
 
-// Relays: messages between clients, relayed through the server
-const RELAY_MESSAGES = {
-    CHAT_MESSAGE: "chat_message",
-    CHAT_READ_STATE: "chat_read_state",
-    CHAT_STATE: "chat_state",
-    ICE_CANDIDATE: "ice_candidate",
-    ICE_END_OF_CANDIDATES: "ice_endofcandidates",
-    READY_TO_RECEIVE_OFFER: "ready_to_receive_offer",
-    REMOTE_CLIENT_MEDIA_REQUEST: "remote_client_media_request",
-    SDP_ANSWER: "sdp_answer",
-    SDP_OFFER: "sdp_offer",
-    VIDEO_STICKER: "video_sticker",
+const TYPES = {
+    CONNECTING: "connecting",
+    CONNECTION_FAILED: "connection_failed",
+    CONNECTION_SUCCESSFUL: "connection_successful",
+    CONNECTION_DISCONNECTED: "connection_disconnected",
 };
 
 const CAMERA_STREAM_ID$2 = "0";
@@ -2250,13 +2740,22 @@ function detectMicrophoneNotWorking(pc) {
 var rtcManagerEvents = {
     CAMERA_NOT_WORKING: "camera_not_working",
     CONNECTION_BLOCKED_BY_NETWORK: "connection_blocked_by_network",
+    ICE_IPV6_SEEN: "ice_ipv6_seen",
+    ICE_MDNS_SEEN: "ice_mdns_seen",
+    ICE_NO_PUBLIC_IP_GATHERED: "ice_no_public_ip_gathered",
+    ICE_NO_PUBLIC_IP_GATHERED_3SEC: "ice_no_public_ip_gathered_3sec",
+    ICE_RESTART: "ice_restart",
     MICROPHONE_NOT_WORKING: "microphone_not_working",
     MICROPHONE_STOPPED_WORKING: "microphone_stopped_working",
+    NEW_PC: "new_pc",
+    SFU_CONNECTION_OPEN: "sfu_connection_open",
     SFU_CONNECTION_CLOSED: "sfu_connection_closed",
     COLOCATION_SPEAKER: "colocation_speaker",
     DOMINANT_SPEAKER: "dominant_speaker",
 };
 
+const logger$7 = new Logger();
+
 const browserName$3 = adapter.browserDetails.browser;
 const browserVersion$1 = adapter.browserDetails.version;
 
@@ -2298,8 +2797,7 @@ function setCodecPreferenceSDP(sdp, vp9On, redOn) {
         const newSdp = sdpTransform.write(sdpObject);
         return newSdp;
     } catch (error) {
-        // eslint-disable-next-line no-console
-        console.log("setCodecPreferenceSDP error:", error);
+        logger$7.error("setCodecPreferenceSDP error:", error);
     }
 }
 
@@ -2446,10 +2944,19 @@ const MAXIMUM_TURN_BANDWIDTH_UNLIMITED = -1; // kbps;
 
 const MEDIA_JITTER_BUFFER_TARGET = 400; // milliseconds;
 
+const logger$6 = new Logger();
+
 class Session {
-    constructor({ peerConnectionId, bandwidth, maximumTurnBandwidth, deprioritizeH264Encoding, logger = console }) {
+    constructor({ peerConnectionId, bandwidth, maximumTurnBandwidth, deprioritizeH264Encoding }) {
         this.peerConnectionId = peerConnectionId;
         this.relayCandidateSeen = false;
+        this.serverReflexiveCandidateSeen = false;
+        this.publicHostCandidateSeen = false;
+        this.ipv6HostCandidateSeen = false;
+        this.ipv6HostCandidateTeredoSeen = false;
+        this.ipv6HostCandidate6to4Seen = false;
+        this.mdnsHostCandidateSeen = false;
+
         this.pc = null;
         this.wasEverConnected = false;
         this.connectionStatus = null;
@@ -2469,7 +2976,6 @@ class Session {
         });
         this.offerOptions = { offerToReceiveAudio: true, offerToReceiveVideo: true };
         this._deprioritizeH264Encoding = deprioritizeH264Encoding;
-        this._logger = logger;
     }
 
     setAndGetPeerConnection({ clientId, constraints, peerConnectionConfig, shouldAddLocalVideo }) {
@@ -2613,7 +3119,7 @@ class Session {
                 return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
             },
             (e) => {
-                this._logger.warn("Could not set remote description from remote answer: ", e);
+                logger$6.warn("Could not set remote description from remote answer: ", e);
             }
         );
     }
@@ -2634,7 +3140,7 @@ class Session {
                 return;
             }
             this.pc.addIceCandidate(candidate).catch((e) => {
-                this._logger.warn("Failed to add ICE candidate ('%s'): %s", candidate ? candidate.candidate : null, e);
+                logger$6.warn("Failed to add ICE candidate ('%s'): %s", candidate ? candidate.candidate : null, e);
             });
         });
     }
@@ -2656,7 +3162,7 @@ class Session {
             // do not handle state change events when we close the connection explicitly
             pc.close();
         } catch (e) {
-            console.warn("failures during close of session", e);
+            logger$6.warn("failures during close of session", e);
             // we're not interested in errors from RTCPeerConnection.close()
         }
     }
@@ -2672,7 +3178,7 @@ class Session {
         const senders = pc.getSenders();
         function dbg(msg) {
             const tr = (t) => t && `id:${t.id},kind:${t.kind},state:${t.readyState}`;
-            this._logger.warn(
+            logger$6.warn(
                 `${msg}. newTrack:${tr(newTrack)}, oldTrack:${tr(oldTrack)}, sender tracks: ${JSON.stringify(
                     senders.map((s) => `s ${tr(s.track)}`)
                 )}, sender first codecs: ${JSON.stringify(senders.map((s) => (s.getParameters().codecs || [])[0]))}`
@@ -2826,6 +3332,21 @@ class Session {
 
         setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
     }
+
+    setAudioOnly(enable, excludedTrackIds = []) {
+        this.pc
+            .getTransceivers()
+            .filter(
+                (videoTransceiver) =>
+                    videoTransceiver?.direction !== "recvonly" &&
+                    videoTransceiver?.receiver?.track?.kind === "video" &&
+                    !excludedTrackIds.includes(videoTransceiver?.receiver?.track?.id) &&
+                    !excludedTrackIds.includes(videoTransceiver?.sender?.track?.id)
+            )
+            .forEach((videoTransceiver) => {
+                videoTransceiver.direction = enable ? "sendonly" : "sendrecv";
+            });
+    }
 }
 
 // transforms a maplike to an object. Mostly for getStats +
@@ -2924,6 +3445,8 @@ var rtcstats = function(trace, getStatsInterval, prefixesToWrap) {
   var peerconnectioncounter = 0;
   var isFirefox = !!window.mozRTCPeerConnection;
   var isEdge = !!window.RTCIceGatherer;
+  var prevById = {};
+  
   prefixesToWrap.forEach(function(prefix) {
     if (!window[prefix + 'RTCPeerConnection']) {
       return;
@@ -2994,13 +3517,12 @@ var rtcstats = function(trace, getStatsInterval, prefixesToWrap) {
         trace('ondatachannel', id, [event.channel.id, event.channel.label]);
       });
 
-      var prev = {};
       var getStats = function() {
         pc.getStats(null).then(function(res) {
           var now = map2obj(res);
           var base = JSON.parse(JSON.stringify(now)); // our new prev
-          trace('getstats', id, deltaCompression(prev, now));
-          prev = base;
+          trace('getstats', id, deltaCompression(prevById[id] || {}, now));
+          prevById[id] = base;
         });
       };
       // TODO: do we want one big interval and all peerconnections
@@ -3220,6 +3742,13 @@ var rtcstats = function(trace, getStatsInterval, prefixesToWrap) {
     }
   });
   */
+
+  return {
+    resetDelta() {
+      prevById = {};
+    }
+  }
+
 };
 
 var rtcstats$1 = /*@__PURE__*/getDefaultExportFromCjs(rtcstats);
@@ -3228,11 +3757,18 @@ var rtcstats$1 = /*@__PURE__*/getDefaultExportFromCjs(rtcstats);
 
 const RTCSTATS_PROTOCOL_VERSION = "1.0";
 
+// when not connected we need to buffer at least a few getstats reports
+// as they are delta compressed and we need the initial properties
+const GETSTATS_BUFFER_SIZE = 20;
+
 const clientInfo = {
-    id: v4(), // shared id across rtcstats reconnects
+    id: v4$1(), // shared id across rtcstats reconnects
     connectionNumber: 0,
 };
 
+const noop = () => {};
+let resetDelta = noop;
+
 // Inlined version of rtcstats/trace-ws with improved disconnect handling.
 function rtcStatsConnection(wsURL, logger = console) {
     const buffer = [];
@@ -3245,6 +3781,7 @@ function rtcStatsConnection(wsURL, logger = console) {
     let connectionShouldBeOpen;
     let connectionAttempt = 0;
     let hasPassedOnRoomSessionId = false;
+    let getStatsBufferUsed = 0;
 
     const connection = {
         connected: false,
@@ -3282,8 +3819,15 @@ function rtcStatsConnection(wsURL, logger = console) {
             if (ws.readyState === WebSocket.OPEN) {
                 connectionAttempt = 0;
                 ws.send(JSON.stringify(args));
-            } else if (args[0] !== "getstats" && !(args[0] === "customEvent" && args[2].type === "insightsStats")) {
-                // buffer all but stats when not connected
+            } else if (args[0] === "getstats") {
+                // only buffer getStats for a while
+                // we don't want this to pile up, but we need at least the initial reports
+                if (getStatsBufferUsed < GETSTATS_BUFFER_SIZE) {
+                    getStatsBufferUsed++;
+                    buffer.push(args);
+                }
+            } else if (args[0] === "customEvent" && args[2].type === "insightsStats") ; else {
+                // buffer everything else
                 buffer.push(args);
             }
 
@@ -3318,6 +3862,7 @@ function rtcStatsConnection(wsURL, logger = console) {
             ws.onclose = (e) => {
                 connection.connected = false;
                 logger.info(`[RTCSTATS] Closed ${e.code}`);
+                resetDelta();
             };
             ws.onopen = () => {
                 // send client info after each connection, so analysis tools can handle reconnections
@@ -3342,10 +3887,11 @@ function rtcStatsConnection(wsURL, logger = console) {
                     ws.send(JSON.stringify(userRole));
                 }
 
-                // send buffered events (non-getStats)
+                // send buffered events
                 while (buffer.length) {
                     ws.send(JSON.stringify(buffer.shift()));
                 }
+                getStatsBufferUsed = 0;
             };
         },
     };
@@ -3354,11 +3900,13 @@ function rtcStatsConnection(wsURL, logger = console) {
 }
 
 const server = rtcStatsConnection("wss://rtcstats.srv.whereby.com" );
-rtcstats$1(
+const stats = rtcstats$1(
     server.trace,
     10000, // query once every 10 seconds.
     [""] // only shim unprefixed RTCPeerConnecion.
 );
+// on node clients this function can be undefined
+resetDelta = stats?.resetDelta || noop;
 
 const rtcStats = {
     sendEvent: (type, value) => {
@@ -3376,6 +3924,8 @@ const rtcStats = {
     server,
 };
 
+const logger$5 = new Logger();
+
 const CAMERA_STREAM_ID$1 = RtcStream.getCameraId();
 const browserName$2 = adapter.browserDetails.browser;
 const browserVersion = adapter.browserDetails.version;
@@ -3392,7 +3942,7 @@ if (browserName$2 === "chrome") {
 }
 
 class BaseRtcManager {
-    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features, logger = console }) {
+    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features }) {
         assert$1.ok(selfId, "selfId is required");
         assert$1.ok(room, "room is required");
         assert$1.ok(emitter && emitter.emit, "emitter is required");
@@ -3407,13 +3957,14 @@ class BaseRtcManager {
         this.peerConnections = {};
         this.localStreams = {};
         this.enabledLocalStreamIds = [];
+        this._screenshareVideoTrackIds = [];
         this._socketListenerDeregisterFunctions = [];
         this._localStreamDeregisterFunction = null;
         this._emitter = emitter;
         this._serverSocket = serverSocket;
         this._webrtcProvider = webrtcProvider;
         this._features = features || {};
-        this._logger = logger;
+        this._isAudioOnlyMode = false;
 
         this.offerOptions = { offerToReceiveAudio: true, offerToReceiveVideo: true };
         this._pendingActionsForConnectedPeerConnections = [];
@@ -3432,6 +3983,8 @@ class BaseRtcManager {
             iceServers: iceServers.iceServers || [],
             mediaserverConfigTtlSeconds,
         });
+
+        this.totalSessionsCreated = 0;
     }
 
     numberOfPeerconnections() {
@@ -3482,7 +4035,7 @@ class BaseRtcManager {
                 receiver.playoutDelayHint = MEDIA_JITTER_BUFFER_TARGET / 1000; // seconds
             });
         } catch (error) {
-            this._logger.error("Error during setting jitter buffer target:", error);
+            logger$5.error("Error during setting jitter buffer target:", error);
         }
     }
 
@@ -3537,6 +4090,8 @@ class BaseRtcManager {
                     : MAXIMUM_TURN_BANDWIDTH,
                 deprioritizeH264Encoding,
             });
+
+            this.totalSessionsCreated++;
         }
         return session;
     }
@@ -3630,6 +4185,8 @@ class BaseRtcManager {
             clientId,
         });
 
+        setTimeout(() => this._emit(rtcManagerEvents.NEW_PC), 0);
+
         pc.ontrack = (event) => {
             const stream = event.streams[0];
             if (stream.id === "default" && stream.getAudioTracks().length === 0) {
@@ -3691,6 +4248,11 @@ class BaseRtcManager {
                             this.maybeRestrictRelayBandwidth(session);
                         }
                     }
+
+                    if (this._isAudioOnlyMode) {
+                        session.setAudioOnly(true, this._screenshareVideoTrackIds);
+                    }
+
                     session.registerConnected();
                     break;
                 case "disconnected":
@@ -3794,7 +4356,7 @@ class BaseRtcManager {
     _cleanup(peerConnectionId) {
         const session = this._getSession(peerConnectionId);
         if (!session) {
-            this._logger.warn("No RTCPeerConnection in RTCManager.disconnect()", peerConnectionId);
+            logger$5.warn("No RTCPeerConnection in RTCManager.disconnect()", peerConnectionId);
             return;
         }
         session.close();
@@ -3824,10 +4386,10 @@ class BaseRtcManager {
         const promises = [];
         this._forEachPeerConnection((session) => {
             if (!session.hasConnectedPeerConnection()) {
-                this._logger.log("Session doesn't have a connected PeerConnection, adding pending action!");
+                logger$5.info("Session doesn't have a connected PeerConnection, adding pending action!");
                 const pendingActions = this._pendingActionsForConnectedPeerConnections;
                 if (!pendingActions) {
-                    this._logger.warn(
+                    logger$5.warn(
                         `No pending action is created to repalce track, because the pending actions array is null`
                     );
                     return;
@@ -3836,7 +4398,7 @@ class BaseRtcManager {
                     const action = () => {
                         const replacedTrackPromise = session.replaceTrack(oldTrack, newTrack);
                         if (!replacedTrackPromise) {
-                            this._logger.error("replaceTrack returned false!");
+                            logger$5.error("replaceTrack returned false!");
                             reject(`ReplaceTrack returned false`);
                             return;
                         }
@@ -3849,7 +4411,7 @@ class BaseRtcManager {
             }
             const replacedTrackResult = session.replaceTrack(oldTrack, newTrack);
             if (!replacedTrackResult) {
-                this._logger.error("replaceTrack returned false!");
+                logger$5.error("replaceTrack returned false!");
                 return;
             }
             promises.push(replacedTrackResult);
@@ -3919,6 +4481,7 @@ class BaseRtcManager {
         }
 
         // at this point it is clearly a screensharing stream.
+        this._screenshareVideoTrackIds.push(stream.getVideoTracks()[0].id);
         this._shareScreen(streamId, stream);
         return;
     }
@@ -4017,7 +4580,7 @@ class BaseRtcManager {
 
             this._serverSocket.on(PROTOCOL_RESPONSES.MEDIASERVER_CONFIG, (data) => {
                 if (data.error) {
-                    this._logger.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
+                    logger$5.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
                     return;
                 }
                 this._updateAndScheduleMediaServersRefresh(data);
@@ -4030,7 +4593,7 @@ class BaseRtcManager {
             this._serverSocket.on(RELAY_MESSAGES.ICE_CANDIDATE, (data) => {
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    this._logger.warn("No RTCPeerConnection on ICE_CANDIDATE", data);
+                    logger$5.warn("No RTCPeerConnection on ICE_CANDIDATE", data);
                     return;
                 }
                 session.addIceCandidate(data.message);
@@ -4039,7 +4602,7 @@ class BaseRtcManager {
             this._serverSocket.on(RELAY_MESSAGES.ICE_END_OF_CANDIDATES, (data) => {
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    this._logger.warn("No RTCPeerConnection on ICE_END_OF_CANDIDATES", data);
+                    logger$5.warn("No RTCPeerConnection on ICE_END_OF_CANDIDATES", data);
                     return;
                 }
                 session.addIceCandidate(null);
@@ -4049,7 +4612,7 @@ class BaseRtcManager {
             this._serverSocket.on(RELAY_MESSAGES.SDP_OFFER, (data) => {
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    this._logger.warn("No RTCPeerConnection on SDP_OFFER", data);
+                    logger$5.warn("No RTCPeerConnection on SDP_OFFER", data);
                     return;
                 }
                 const offer = this._transformIncomingSdp(data.message, session.pc);
@@ -4065,12 +4628,35 @@ class BaseRtcManager {
             this._serverSocket.on(RELAY_MESSAGES.SDP_ANSWER, (data) => {
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    this._logger.warn("No RTCPeerConnection on SDP_ANSWER", data);
+                    logger$5.warn("No RTCPeerConnection on SDP_ANSWER", data);
                     return;
                 }
                 const answer = this._transformIncomingSdp(data.message, session.pc);
                 session.handleAnswer(answer);
             }),
+
+            // if this is a reconnect to signal-server during screen-share we must let signal-server know
+            this._serverSocket.on(PROTOCOL_RESPONSES.ROOM_JOINED, ({ room: { sfuServer: isSfu } }) => {
+                if (isSfu || !this._wasScreenSharing) return;
+
+                const screenShareStreamId = Object.keys(this.localStreams).find((id) => id !== CAMERA_STREAM_ID$1);
+                if (!screenShareStreamId) {
+                    return;
+                }
+
+                const screenshareStream = this.localStreams[screenShareStreamId];
+                if (!screenshareStream) {
+                    logger$5.warn("screenshare stream %s not found", screenShareStreamId);
+                    return;
+                }
+
+                const hasAudioTrack = screenshareStream.getAudioTracks().length > 0;
+
+                this._emitServerEvent(PROTOCOL_REQUESTS.START_SCREENSHARE, {
+                    streamId: screenShareStreamId,
+                    hasAudioTrack,
+                });
+            }),
         ];
     }
 
@@ -4104,6 +4690,27 @@ class BaseRtcManager {
         track.removeEventListener("ended", this._audioTrackOnEnded);
     }
 
+    setAudioOnly(audioOnly) {
+        this._isAudioOnlyMode = audioOnly;
+
+        this._forEachPeerConnection((session) => {
+            if (session.hasConnectedPeerConnection()) {
+                this._withForcedRenegotiation(session, () =>
+                    session.setAudioOnly(this._isAudioOnlyMode, this._screenshareVideoTrackIds)
+                );
+            }
+        });
+    }
+
+    setRemoteScreenshareVideoTrackIds(remoteScreenshareVideoTrackIds = []) {
+        const localScreenshareStream = this._getFirstLocalNonCameraStream();
+
+        this._screenshareVideoTrackIds = [
+            ...(localScreenshareStream?.track ? [localScreenshareStream.track.id] : []),
+            ...remoteScreenshareVideoTrackIds,
+        ];
+    }
+
     setRoomSessionId(roomSessionId) {
         this._roomSessionId = roomSessionId;
     }
@@ -4137,6 +4744,54 @@ function getOptimalBitrate(width, height, frameRate) {
     return targetBitrate;
 }
 
+// taken from https://github.com/sindresorhus/ip-regex ^5.0.0
+// inlined because it's import caused errors in browser-sdk when running tests
+const word = "[a-fA-F\\d:]";
+
+const boundry = (options) =>
+    options && options.includeBoundaries ? `(?:(?<=\\s|^)(?=${word})|(?<=${word})(?=\\s|$))` : "";
+
+const v4 = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
+
+const v6segment = "[a-fA-F\\d]{1,4}";
+
+const v6 = `
+(?:
+(?:${v6segment}:){7}(?:${v6segment}|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
+(?:${v6segment}:){6}(?:${v4}|:${v6segment}|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
+(?:${v6segment}:){5}(?::${v4}|(?::${v6segment}){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
+(?:${v6segment}:){4}(?:(?::${v6segment}){0,1}:${v4}|(?::${v6segment}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
+(?:${v6segment}:){3}(?:(?::${v6segment}){0,2}:${v4}|(?::${v6segment}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
+(?:${v6segment}:){2}(?:(?::${v6segment}){0,3}:${v4}|(?::${v6segment}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
+(?:${v6segment}:){1}(?:(?::${v6segment}){0,4}:${v4}|(?::${v6segment}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
+(?::(?:(?::${v6segment}){0,5}:${v4}|(?::${v6segment}){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
+)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1
+`
+    .replace(/\s*\/\/.*$/gm, "")
+    .replace(/\n/g, "")
+    .trim();
+
+// Pre-compile only the exact regexes because adding a global flag make regexes stateful
+const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
+const v4exact = new RegExp(`^${v4}$`);
+const v6exact = new RegExp(`^${v6}$`);
+
+const ipRegex = (options) =>
+    options && options.exact
+        ? v46Exact
+        : new RegExp(
+              `(?:${boundry(options)}${v4}${boundry(options)})|(?:${boundry(options)}${v6}${boundry(options)})`,
+              "g"
+          );
+
+ipRegex.v4 = (options) =>
+    options && options.exact ? v4exact : new RegExp(`${boundry(options)}${v4}${boundry(options)}`, "g");
+ipRegex.v6 = (options) =>
+    options && options.exact ? v6exact : new RegExp(`${boundry(options)}${v6}${boundry(options)}`, "g");
+
+const logger$4 = new Logger();
+
+const ICE_PUBLIC_IP_GATHERING_TIMEOUT = 3 * 1000;
 const CAMERA_STREAM_ID = RtcStream.getCameraId();
 const browserName$1 = adapter.browserDetails.browser;
 
@@ -4147,7 +4802,7 @@ class P2pRtcManager extends BaseRtcManager {
         let session = this._getSession(clientId);
         let bandwidth = (session && session.bandwidth) || 0;
         if (session) {
-            this._logger.warn("Replacing peer session", clientId);
+            logger$4.warn("Replacing peer session", clientId);
             this._cleanup(clientId);
         } else {
             bandwidth = this._changeBandwidthForAllClients(true);
@@ -4168,6 +4823,14 @@ class P2pRtcManager extends BaseRtcManager {
             // clean up some helpers.
             session.wasEverConnected = false;
             session.relayCandidateSeen = false;
+            session.serverReflexiveCandidateSeen = false;
+            session.publicHostCandidateSeen = false;
+            session.ipv6HostCandidateSeen = false;
+            this.ipv6HostCandidateTeredoSeen = false;
+            this.ipv6HostCandidate6to4Seen = false;
+            this.mdnsHostCandidateSeen = false;
+
+            this._emit(rtcManagerEvents.ICE_RESTART);
 
             this._negotiatePeerConnection(
                 clientId,
@@ -4222,13 +4885,13 @@ class P2pRtcManager extends BaseRtcManager {
                 videoTransceiver.setCodecPreferences(capabilities.codecs);
             });
         } catch (error) {
-            this._logger.error("Error during setting setCodecPreferences:", error);
+            logger$4.error("Error during setting setCodecPreferences:", error);
         }
     }
 
     _negotiatePeerConnection(clientId, session, constraints) {
         if (!session) {
-            this._logger.warn("No RTCPeerConnection in negotiatePeerConnection()", clientId);
+            logger$4.warn("No RTCPeerConnection in negotiatePeerConnection()", clientId);
             return;
         }
         const pc = session.pc;
@@ -4270,11 +4933,24 @@ class P2pRtcManager extends BaseRtcManager {
                     return;
                 }
                 pc.setLocalDescription(offer).catch((e) => {
-                    this._logger.warn("RTCPeerConnection.setLocalDescription() failed with local offer", e);
+                    logger$4.warn("RTCPeerConnection.setLocalDescription() failed with local offer", e);
+
+                    // we failed to create a valid offer so try having the other side create it, without looping
+                    if (this._features.reverseOfferOnFailure) {
+                        if (!this._lastReverseDirectionAttemptByClientId)
+                            this._lastReverseDirectionAttemptByClientId = {};
+                        if (
+                            !this._lastReverseDirectionAttemptByClientId[clientId] ||
+                            this._lastReverseDirectionAttemptByClientId[clientId] < Date.now() - 10000
+                        ) {
+                            this.acceptNewStream({ clientId, streamId: clientId, shouldAddLocalVideo: true });
+                            this._lastReverseDirectionAttemptByClientId[clientId] = Date.now();
+                        }
+                    }
                 });
             })
             .catch((e) => {
-                this._logger.warn("RTCPeerConnection.createOffer() failed to create local offer", e);
+                logger$4.warn("RTCPeerConnection.createOffer() failed to create local offer", e);
             });
     }
 
@@ -4310,7 +4986,7 @@ class P2pRtcManager extends BaseRtcManager {
         let bandwidth = this._features.bandwidth
             ? parseInt(this._features.bandwidth, 10)
             : {
-                  1: this._features.cap2pBitrate ? 1000 : 0,
+                  1: 0,
                   2: this._features.highP2PBandwidth ? 768 : 384,
                   3: this._features.highP2PBandwidth ? 512 : 256,
                   4: 192,
@@ -4376,9 +5052,73 @@ class P2pRtcManager extends BaseRtcManager {
             pc.addTrack(this._stoppedVideoTrack, localCameraStream);
         }
 
+        pc.onicegatheringstatechange = (event) => {
+            const connection = event.target;
+
+            switch (connection.iceGatheringState) {
+                case "gathering":
+                    if (this.icePublicIPGatheringTimeoutID) clearTimeout(this.icePublicIPGatheringTimeoutID);
+                    this.icePublicIPGatheringTimeoutID = setTimeout(() => {
+                        if (
+                            !session.publicHostCandidateSeen &&
+                            !session.relayCandidateSeen &&
+                            !session.serverReflexiveCandidateSeen
+                        ) {
+                            this._emit(rtcManagerEvents.ICE_NO_PUBLIC_IP_GATHERED_3SEC);
+                        }
+                    }, ICE_PUBLIC_IP_GATHERING_TIMEOUT);
+                    break;
+                case "complete":
+                    if (this.icePublicIPGatheringTimeoutID) clearTimeout(this.icePublicIPGatheringTimeoutID);
+                    this.icePublicIPGatheringTimeoutID = undefined;
+                    break;
+            }
+        };
+
         pc.onicecandidate = (event) => {
             if (event.candidate) {
-                session.relayCandidateSeen = session.relayCandidateSeen || event.candidate.type === "relay";
+                switch (event.candidate?.type) {
+                    case "host":
+                        const address = event?.candidate?.address;
+                        try {
+                            if (ipRegex.v4({ exact: true }).test(address)) {
+                                const ipv4 = checkIp(address);
+                                if (ipv4.isPublicIp) session.publicHostCandidateSeen = true;
+                            } else if (ipRegex.v6({ exact: true }).test(address.replace(/^\[(.*)\]/, "$1"))) {
+                                const ipv6 = new Address6(address.replace(/^\[(.*)\]/, "$1"));
+                                session.ipv6HostCandidateSeen = true;
+
+                                if (ipv6.getScope() === "Global") {
+                                    session.publicHostCandidateSeen = true;
+                                }
+                                if (ipv6.isTeredo()) {
+                                    session.ipv6HostCandidateTeredoSeen = true;
+                                }
+                                if (ipv6.is6to4()) {
+                                    session.ipv6HostCandidate6to4Seen = true;
+                                }
+                            } else {
+                                const uuidv4 = address.replace(/.local/, "");
+                                if (uuidv4 && validate(uuidv4, 4)) {
+                                    session.mdnsHostCandidateSeen = true;
+                                }
+                            }
+                        } catch (error) {
+                            logger$4.info("Error during parsing candidates! Error: ", { error });
+                        }
+                        break;
+                    case "srflx":
+                        if (!session.serverReflexiveCandidateSeen) {
+                            session.serverReflexiveCandidateSeen = true;
+                        }
+                        break;
+                    case "relay":
+                    case "relayed":
+                        if (!session.relayCandidateSeen) {
+                            session.relayCandidateSeen = true;
+                        }
+                        break;
+                }
                 this._emitServerEvent(RELAY_MESSAGES.ICE_CANDIDATE, {
                     receiverId: clientId,
                     message: event.candidate,
@@ -4387,6 +5127,20 @@ class P2pRtcManager extends BaseRtcManager {
                 this._emitServerEvent(RELAY_MESSAGES.ICE_END_OF_CANDIDATES, {
                     receiverId: clientId,
                 });
+                if (
+                    !session.publicHostCandidateSeen &&
+                    !session.relayCandidateSeen &&
+                    !session.serverReflexiveCandidateSeen
+                ) {
+                    this._emit(rtcManagerEvents.ICE_NO_PUBLIC_IP_GATHERED);
+                }
+                if (session.ipv6HostCandidateSeen) {
+                    this._emit(rtcManagerEvents.ICE_IPV6_SEEN, {
+                        teredoSeen: session.ipv6HostCandidateTeredoSeen,
+                        sixtofourSeen: session.ipv6HostCandidate6to4Seen,
+                    });
+                }
+                if (session.mdnsHostCandidateSeen) this._emit(rtcManagerEvents.ICE_MDNS_SEEN);
             }
         };
 
@@ -4413,7 +5167,7 @@ class P2pRtcManager extends BaseRtcManager {
         if (session) {
             // this will happen on a signal-server reconnect
             // before we tried an ice-restart here, now we recreate the session/pc
-            this._logger.warn("Replacing peer session", clientId);
+            logger$4.warn("Replacing peer session", clientId);
             this._cleanup(clientId); // will cleanup and delete session/pc
         } else {
             // we adjust bandwidth based on number of sessions/pcs
@@ -4511,14 +5265,20 @@ class P2pRtcManager extends BaseRtcManager {
             streamId,
             hasAudioTrack: !!stream.getAudioTracks().length,
         });
+        this._wasScreenSharing = true;
         this._addStreamToPeerConnections(stream);
     }
 
     removeStream(streamId, stream, requestedByClientId) {
         super.removeStream(streamId, stream);
         this._removeStreamFromPeerConnections(stream);
+        this._wasScreenSharing = false;
         this._emitServerEvent(PROTOCOL_REQUESTS.STOP_SCREENSHARE, { streamId, requestedByClientId });
     }
+
+    hasClient(clientId) {
+        return Object.keys(this.peerConnections).includes(clientId);
+    }
 }
 
 class SfuV2Parser {
@@ -4643,12 +5403,13 @@ class SfuV2Parser {
     }
 }
 
-class VegaConnection extends EventEmitter {
-    constructor(wsUrl, logger, protocol = "whereby-sfu#v4") {
+const logger$3 = new Logger();
+
+class VegaConnection extends EventEmitter$1 {
+    constructor(wsUrl, protocol = "whereby-sfu#v4") {
         super();
 
         this.wsUrl = wsUrl;
-        this.logger = logger;
         this.protocol = protocol;
 
         // This is the map of sent requests that are waiting for a response
@@ -4681,7 +5442,7 @@ class VegaConnection extends EventEmitter {
     }
 
     _onOpen() {
-        this.logger.log("VegaConnectionManager: Connected");
+        logger$3.info("Connected");
 
         this.emit("open");
     }
@@ -4689,7 +5450,7 @@ class VegaConnection extends EventEmitter {
     _onMessage(event) {
         const socketMessage = SfuV2Parser.parse(event.data);
 
-        this.logger.log("VegaConnectionManager: Received message", socketMessage);
+        logger$3.info("Received message", socketMessage);
 
         if (socketMessage?.response) {
             this._handleResponse(socketMessage);
@@ -4699,13 +5460,13 @@ class VegaConnection extends EventEmitter {
     }
 
     _onClose() {
-        this.logger.log("VegaConnectionManager: Disconnected");
+        logger$3.info("Disconnected");
 
         this._tearDown();
     }
 
     _onError(error) {
-        this.logger.log("VegaConnectionManager: Error", error);
+        logger$3.info("Error", error);
     }
 
     _handleResponse(socketMessage) {
@@ -5061,6 +5822,8 @@ const defaultParams = {
     outFormula: "score", // the out/score sent to SFU
 };
 
+const logger$2 = new Logger();
+
 function createMicAnalyser({ micTrack, params, onScoreUpdated }) {
     // todo: might need to reuse existing in PWA
     const audioCtx = new AudioContext();
@@ -5086,7 +5849,7 @@ function createMicAnalyser({ micTrack, params, onScoreUpdated }) {
                 track = stream.getAudioTracks()[0];
                 lastTrackWasOurs = true;
             } catch (ex) {
-                console.warn("unable to fetch new track for colocation speaker analysis, using current", ex);
+                logger$2.warn("unable to fetch new track for colocation speaker analysis, using current", ex);
             }
         }
 
@@ -5218,18 +5981,207 @@ const maybeTurnOnly = (transportConfig, features) => {
     }
 };
 
+const logger$1 = new Logger();
+
+const MEDIA_QUALITY = Object.freeze({
+    ok: "ok",
+    warning: "warning",
+    critical: "critical",
+});
+
+const MONITOR_INTERVAL = 600; // ms
+const TREND_HORIZON = 3; // number of monitor intervals needed for quality to change
+const WARNING_SCORE = 9;
+const CRITICAL_SCORE = 7;
+
+class VegaMediaQualityMonitor extends EventEmitter {
+    constructor() {
+        super();
+        this._clients = {};
+        this._producers = {};
+        this._startMonitor();
+    }
+
+    close() {
+        clearInterval(this._intervalHandle);
+        delete this._intervalHandle;
+        this._producers = {};
+        this._clients = {};
+    }
+
+    _startMonitor() {
+        this._intervalHandle = setInterval(() => {
+            Object.entries(this._producers).forEach(([clientId, producers]) => {
+                this._evaluateClient(clientId, producers);
+            });
+        }, MONITOR_INTERVAL);
+    }
+
+    _evaluateClient(clientId, producers) {
+        if (!this._clients[clientId]) {
+            this._clients[clientId] = {
+                audio: { currentQuality: MEDIA_QUALITY.ok, trend: [] },
+                video: { currentQuality: MEDIA_QUALITY.ok, trend: [] },
+            };
+        }
+
+        this._evaluateProducer(
+            clientId,
+            Object.values(producers).filter((p) => p.kind === "audio"),
+            "audio"
+        );
+        this._evaluateProducer(
+            clientId,
+            Object.values(producers).filter((p) => p.kind === "video"),
+            "video"
+        );
+    }
+
+    _evaluateProducer(clientId, producers, kind) {
+        if (producers.length === 0) {
+            return;
+        }
+
+        const avgScore = producers.reduce((prev, curr) => prev + curr.score, 0) / producers.length;
+        const newQuality = this._evaluateScore(avgScore);
+        const qualityChanged = this._updateTrend(newQuality, this._clients[clientId][kind]);
+        if (qualityChanged) {
+            this.emit(PROTOCOL_EVENTS.MEDIA_QUALITY_CHANGED, {
+                clientId,
+                kind,
+                quality: newQuality,
+            });
+        }
+    }
+
+    _updateTrend(newQuality, state) {
+        state.trend.push(newQuality);
+        if (state.trend.length > TREND_HORIZON) {
+            state.trend.shift();
+        }
+
+        if (newQuality !== state.currentQuality && state.trend.every((t) => t !== state.currentQuality)) {
+            state.currentQuality = newQuality;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    addProducer(clientId, producerId) {
+        if (!clientId || !producerId || !(typeof clientId === "string" && typeof producerId === "string")) {
+            logger$1.warn("Missing clientId or producerId");
+            return;
+        }
+
+        if (!this._producers[clientId]) {
+            this._producers[clientId] = {};
+        }
+
+        this._producers[clientId][producerId] = {};
+    }
+
+    removeProducer(clientId, producerId) {
+        delete this._producers[clientId][producerId];
+
+        if (Object.keys(this._producers[clientId]).length === 0) {
+            delete this._producers[clientId];
+        }
+    }
+
+    addConsumer(clientId, consumerId) {
+        if (!clientId || !consumerId) {
+            logger$1.warn("Missing clientId or consumerId");
+            return;
+        }
+
+        if (!this._producers[clientId]) {
+            this._producers[clientId] = {};
+        }
+
+        this._producers[clientId][consumerId] = {};
+    }
+
+    removeConsumer(clientId, consumerId) {
+        delete this._producers[clientId][consumerId];
+
+        if (Object.keys(this._producers[clientId]).length === 0) {
+            delete this._producers[clientId];
+        }
+    }
+
+    addProducerScore(clientId, producerId, kind, score) {
+        if (
+            !Array.isArray(score) ||
+            score.length === 0 ||
+            score.some((s) => !s || !s.hasOwnProperty("score") || typeof s.score !== "number" || isNaN(s.score))
+        ) {
+            logger$1.warn("Unexpected producer score format");
+            return;
+        }
+        this._producers[clientId][producerId] = { kind, score: this._calcAvgProducerScore(score.map((s) => s.score)) };
+    }
+
+    addConsumerScore(clientId, consumerId, kind, score) {
+        if (!score || !score.hasOwnProperty("producerScores") || !Array.isArray(score.producerScores)) {
+            logger$1.warn("Unexpected consumer score format");
+            return;
+        }
+        this._producers[clientId][consumerId] = { kind, score: this._calcAvgProducerScore(score.producerScores) };
+    }
+
+    _evaluateScore(score) {
+        if (score <= WARNING_SCORE && score > CRITICAL_SCORE) {
+            return MEDIA_QUALITY.warning;
+        } else if (score <= CRITICAL_SCORE && score > 0) {
+            return MEDIA_QUALITY.critical;
+        } else {
+            return MEDIA_QUALITY.ok;
+        }
+    }
+
+    _calcAvgProducerScore(scores) {
+        try {
+            if (!Array.isArray(scores) || scores.length === 0) {
+                return 0;
+            }
+
+            let totalScore = 0;
+            let divisor = 0;
+
+            scores.forEach((score) => {
+                if (score > 0) {
+                    totalScore += score;
+                    divisor++;
+                }
+            });
+
+            if (totalScore === 0 || divisor === 0) {
+                return 0;
+            } else {
+                return totalScore / divisor;
+            }
+        } catch (error) {
+            logger$1.error(error);
+            return 0;
+        }
+    }
+}
+
+const logger = new Logger();
+
 const browserName = adapter.browserDetails.browser;
 let unloading = false;
 
 const RESTARTICE_ERROR_RETRY_THRESHOLD_IN_MS = 3500;
 const RESTARTICE_ERROR_MAX_RETRY_COUNT = 5;
-const OUTBOUND_CAM_OUTBOUND_STREAM_ID = v4();
-const OUTBOUND_SCREEN_OUTBOUND_STREAM_ID = v4();
+const OUTBOUND_CAM_OUTBOUND_STREAM_ID = v4$1();
+const OUTBOUND_SCREEN_OUTBOUND_STREAM_ID = v4$1();
 
 if (browserName === "chrome") window.document.addEventListener("beforeunload", () => (unloading = true));
 
 class VegaRtcManager {
-    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features, eventClaim, logger = console }) {
+    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features, eventClaim, deviceHandlerFactory }) {
         assert$1.ok(selfId, "selfId is required");
         assert$1.ok(room, "room is required");
         assert$1.ok(emitter && emitter.emit, "emitter is required");
@@ -5246,14 +6198,18 @@ class VegaRtcManager {
         this._webrtcProvider = webrtcProvider;
         this._features = features || {};
         this._eventClaim = eventClaim;
-        this._logger = logger;
 
         this._vegaConnection = null;
 
         this._micAnalyser = null;
         this._micAnalyserDebugger = null;
 
-        this._mediasoupDevice = new Device({ handlerName: getHandler() });
+        if (deviceHandlerFactory) {
+            this._mediasoupDevice = new Device({ handlerFactory: deviceHandlerFactory });
+        } else {
+            this._mediasoupDevice = new Device({ handlerName: getHandler() });
+        }
+
         this._routerRtpCapabilities = null;
 
         this._sendTransport = null;
@@ -5316,6 +6272,11 @@ class VegaRtcManager {
         // Retry if connection closed until disconnectAll called;
         this._reconnect = true;
         this._reconnectTimeOut = null;
+
+        this._qualityMonitor = new VegaMediaQualityMonitor();
+        this._qualityMonitor.on(PROTOCOL_EVENTS.MEDIA_QUALITY_CHANGED, (payload) => {
+            this._emitToPWA(PROTOCOL_EVENTS.MEDIA_QUALITY_CHANGED, payload);
+        });
     }
 
     _updateAndScheduleMediaServersRefresh({ iceServers, sfuServer, mediaserverConfigTtlSeconds }) {
@@ -5348,7 +6309,7 @@ class VegaRtcManager {
 
             this._serverSocket.on(PROTOCOL_RESPONSES.MEDIASERVER_CONFIG, (data) => {
                 if (data.error) {
-                    this._logger.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
+                    logger.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
                     return;
                 }
                 this._updateAndScheduleMediaServersRefresh(data);
@@ -5380,14 +6341,14 @@ class VegaRtcManager {
         const queryString = searchParams.toString();
         const wsUrl = `wss://${host}?${queryString}`;
 
-        this._vegaConnection = new VegaConnection(wsUrl, this._logger);
+        this._vegaConnection = new VegaConnection(wsUrl);
         this._vegaConnection.on("open", () => this._join());
         this._vegaConnection.on("close", () => this._onClose());
         this._vegaConnection.on("message", (message) => this._onMessage(message));
     }
 
     _onClose() {
-        this._logger.debug("_onClose()");
+        logger.info("_onClose()");
 
         // These will clean up any and all producers/consumers
         this._sendTransport?.close();
@@ -5400,10 +6361,14 @@ class VegaRtcManager {
         if (this._reconnect) {
             this._reconnectTimeOut = setTimeout(() => this._connect(), 1000);
         }
+
+        this._qualityMonitor.close();
+        this._emitToPWA(rtcManagerEvents.SFU_CONNECTION_CLOSED);
     }
 
     async _join() {
-        this._logger.debug("join()");
+        logger.info("join()");
+        this._emitToPWA(rtcManagerEvents.SFU_CONNECTION_OPEN);
 
         try {
             // We need to always do this, as this triggers the join logic on the SFU
@@ -5437,7 +6402,7 @@ class VegaRtcManager {
 
             await Promise.all(mediaPromises);
         } catch (error) {
-            this._logger.error("_join() [error:%o]", error);
+            logger.error("_join() [error:%o]", error);
             // TODO: handle this error, rejoin?
         }
     }
@@ -5468,7 +6433,7 @@ class VegaRtcManager {
 
         const transport = this._mediasoupDevice[creator](transportOptions);
         const onConnectionStateListener = async (connectionState) => {
-            this._logger.debug(`Transport ConnectionStateChanged ${connectionState}`);
+            logger.info(`Transport ConnectionStateChanged ${connectionState}`);
             if (connectionState !== "disconnected" && connectionState !== "failed") {
                 return;
             }
@@ -5542,17 +6507,17 @@ class VegaRtcManager {
 
     async _restartIce(transport, retried = 0) {
         if (!transport || !("closed" in transport) || !("connectionState" in transport)) {
-            this._logger.debug("_restartIce: No transport or property closed or connectionState!");
+            logger.info("_restartIce: No transport or property closed or connectionState!");
             return;
         }
 
         if (transport.closed) {
-            this._logger.debug("_restartIce: Transport is closed!");
+            logger.info("_restartIce: Transport is closed!");
             return;
         }
 
         if (transport.connectionState !== "disconnected" && transport.connectionState !== "failed") {
-            this._logger.debug("_restartIce: Connection is healthy ICE restart no loneger needed!");
+            logger.info("_restartIce: Connection is healthy ICE restart no loneger needed!");
             return;
         }
 
@@ -5565,24 +6530,24 @@ class VegaRtcManager {
         transport.appData.iceRestartStarted = now;
 
         if (RESTARTICE_ERROR_MAX_RETRY_COUNT <= retried) {
-            this._logger.debug("_restartIce: Reached restart ICE  maximum retry count!");
+            logger.info("_restartIce: Reached restart ICE  maximum retry count!");
             return;
         }
 
         if (!this._vegaConnection) {
-            this._logger.debug(`_restartIce: Connection is undefined`);
+            logger.info(`_restartIce: Connection is undefined`);
             return;
         }
         const { iceParameters } = await this._vegaConnection.request("restartIce", { transportId: transport.id });
 
-        this._logger.debug("_restartIce: ICE restart iceParameters received from SFU: ", iceParameters);
+        logger.info("_restartIce: ICE restart iceParameters received from SFU: ", iceParameters);
         const error = await transport
             .restartIce({ iceParameters })
             .then(() => null)
             .catch((err) => err);
 
         if (error) {
-            this._logger.error(`_restartIce: ICE restart failed: ${error}`);
+            logger.error(`_restartIce: ICE restart failed: ${error}`);
             switch (error.message) {
                 case "missing transportId":
                 case "no such transport":
@@ -5618,7 +6583,7 @@ class VegaRtcManager {
     }
 
     async _internalSendMic() {
-        this._logger.debug("_internalSendMic()");
+        logger.info("_internalSendMic()");
 
         this._micProducerPromise = (async () => {
             try {
@@ -5647,21 +6612,23 @@ class VegaRtcManager {
                 currentPaused ? producer.pause() : producer.resume();
 
                 this._micProducer = producer;
+                this._qualityMonitor.addProducer(this._selfId, producer.id);
 
                 producer.observer.once("close", () => {
-                    this._logger.debug('micProducer "close" event');
+                    logger.info('micProducer "close" event');
 
                     if (producer.appData.localClosed)
                         this._vegaConnection?.message("closeProducers", { producerIds: [producer.id] });
 
                     this._micProducer = null;
                     this._micProducerPromise = null;
+                    this._qualityMonitor.removeProducer(this._selfId, producer.id);
                 });
 
                 if (this._micTrack !== this._micProducer.track) await this._replaceMicTrack();
                 if (this._micPaused !== this._micProducer.paused) this._pauseResumeMic();
             } catch (error) {
-                this._logger.error("micProducer failed:%o", error);
+                logger.error("micProducer failed:%o", error);
             } finally {
                 this._micProducerPromise = null;
 
@@ -5675,7 +6642,7 @@ class VegaRtcManager {
     }
 
     async _internalSetupMicScore() {
-        this._logger.debug("_internalSetupMicScore()");
+        logger.info("_internalSetupMicScore()");
 
         this._micScoreProducerPromise = (async () => {
             try {
@@ -5698,7 +6665,7 @@ class VegaRtcManager {
                 this._micScoreProducer = producer;
 
                 producer.observer.once("close", () => {
-                    this._logger.debug('micScoreProducer "close" event');
+                    logger.info('micScoreProducer "close" event');
                     if (producer.appData.localClosed) {
                         this._vegaConnection?.message("closeDataProducers", { dataProducerIds: [producer.id] });
                     }
@@ -5707,7 +6674,7 @@ class VegaRtcManager {
                     this._micScoreProducerPromise = null;
                 });
             } catch (error) {
-                this._logger.error("micScoreProducer failed:%o", error);
+                logger.error("micScoreProducer failed:%o", error);
             } finally {
                 this._micScoreProducerPromise = null;
 
@@ -5725,7 +6692,7 @@ class VegaRtcManager {
     }
 
     async _replaceMicTrack() {
-        this._logger.debug("_replaceMicTrack()");
+        logger.info("_replaceMicTrack()");
 
         if (!this._micTrack || !this._micProducer || this._micProducer.closed) return;
 
@@ -5741,7 +6708,7 @@ class VegaRtcManager {
     }
 
     _pauseResumeMic() {
-        this._logger.debug("_pauseResumeMic()");
+        logger.info("_pauseResumeMic()");
 
         if (!this._micProducer || this._micProducer.closed) return;
 
@@ -5768,7 +6735,7 @@ class VegaRtcManager {
     }
 
     async _sendMic(track) {
-        this._logger.debug("_sendMic() [track:%o]", track);
+        logger.info("_sendMic() [track:%o]", track);
 
         this._micTrack = track;
 
@@ -5800,7 +6767,7 @@ class VegaRtcManager {
             try {
                 this._micScoreProducer.send(JSON.stringify({ score }));
             } catch (ex) {
-                console.error("_sendMicScore failed [error:%o]", ex);
+                logger.error("_sendMicScore failed [error:%o]", ex);
             }
             return;
         }
@@ -5812,7 +6779,7 @@ class VegaRtcManager {
     }
 
     async _internalSendWebcam() {
-        this._logger.debug("_internalSendWebcam()");
+        logger.info("_internalSendWebcam()");
 
         this._webcamProducerPromise = (async () => {
             try {
@@ -5841,21 +6808,23 @@ class VegaRtcManager {
                 currentPaused ? producer.pause() : producer.resume();
 
                 this._webcamProducer = producer;
+                this._qualityMonitor.addProducer(this._selfId, producer.id);
                 producer.observer.once("close", () => {
-                    this._logger.debug('webcamProducer "close" event');
+                    logger.info('webcamProducer "close" event');
 
                     if (producer.appData.localClosed)
                         this._vegaConnection?.message("closeProducers", { producerIds: [producer.id] });
 
                     this._webcamProducer = null;
                     this._webcamProducerPromise = null;
+                    this._qualityMonitor.removeProducer(this._selfId, producer.id);
                 });
 
                 // Has someone replaced the track?
                 if (this._webcamTrack !== this._webcamProducer.track) await this._replaceWebcamTrack();
                 if (this._webcamPaused !== this._webcamProducer.paused) this._pauseResumeWebcam();
             } catch (error) {
-                this._logger.error("webcamProducer failed:%o", error);
+                logger.error("webcamProducer failed:%o", error);
             } finally {
                 this._webcamProducerPromise = null;
 
@@ -5869,7 +6838,7 @@ class VegaRtcManager {
     }
 
     async _replaceWebcamTrack() {
-        this._logger.debug("_replaceWebcamTrack()");
+        logger.info("_replaceWebcamTrack()");
 
         if (!this._webcamTrack || !this._webcamProducer || this._webcamProducer.closed) return;
 
@@ -5880,7 +6849,7 @@ class VegaRtcManager {
     }
 
     _pauseResumeWebcam() {
-        this._logger.debug("_pauseResumeWebcam()");
+        logger.info("_pauseResumeWebcam()");
 
         if (!this._webcamProducer || this._webcamProducer.closed) return;
 
@@ -5904,7 +6873,7 @@ class VegaRtcManager {
     }
 
     async _sendWebcam(track) {
-        this._logger.debug("_sendWebcam() [track:%o]", track);
+        logger.info("_sendWebcam() [track:%o]", track);
 
         this._webcamTrack = track;
 
@@ -5918,7 +6887,7 @@ class VegaRtcManager {
     }
 
     async _internalSendScreenVideo() {
-        this._logger.debug("_internalSendScreenVideo()");
+        logger.info("_internalSendScreenVideo()");
 
         this._screenVideoProducerPromise = (async () => {
             try {
@@ -5943,20 +6912,22 @@ class VegaRtcManager {
                 });
 
                 this._screenVideoProducer = producer;
+                this._qualityMonitor.addProducer(this._selfId, producer.id);
                 producer.observer.once("close", () => {
-                    this._logger.debug('screenVideoProducer "close" event');
+                    logger.info('screenVideoProducer "close" event');
 
                     if (producer.appData.localClosed)
                         this._vegaConnection?.message("closeProducers", { producerIds: [producer.id] });
 
                     this._screenVideoProducer = null;
                     this._screenVideoProducerPromise = null;
+                    this._qualityMonitor.removeProducer(this._selfId, producer.id);
                 });
 
                 // Has someone replaced the track?
                 if (this._screenVideoTrack !== this._screenVideoProducer.track) await this._replaceScreenVideoTrack();
             } catch (error) {
-                this._logger.error("screenVideoProducer failed:%o", error);
+                logger.error("screenVideoProducer failed:%o", error);
             } finally {
                 this._screenVideoProducerPromise = null;
 
@@ -5970,7 +6941,7 @@ class VegaRtcManager {
     }
 
     async _replaceScreenVideoTrack() {
-        this._logger.debug("_replaceScreenVideoTrack()");
+        logger.info("_replaceScreenVideoTrack()");
 
         if (!this._screenVideoTrack || !this._screenVideoProducer || this._screenVideoProducer.closed) return;
 
@@ -5981,7 +6952,7 @@ class VegaRtcManager {
     }
 
     async _sendScreenVideo(track) {
-        this._logger.debug("_sendScreenVideo() [track:%o]", track);
+        logger.info("_sendScreenVideo() [track:%o]", track);
 
         this._screenVideoTrack = track;
 
@@ -5995,7 +6966,7 @@ class VegaRtcManager {
     }
 
     async _internalSendScreenAudio() {
-        this._logger.debug("_internalSendScreenAudio()");
+        logger.info("_internalSendScreenAudio()");
 
         this._screenAudioProducerPromise = (async () => {
             try {
@@ -6020,20 +6991,22 @@ class VegaRtcManager {
                 });
 
                 this._screenAudioProducer = producer;
+                this._qualityMonitor.addProducer(this._selfId, producer.id);
                 producer.observer.once("close", () => {
-                    this._logger.debug('screenAudioProducer "close" event');
+                    logger.info('screenAudioProducer "close" event');
 
                     if (producer.appData.localClosed)
                         this._vegaConnection?.message("closeProducers", { producerIds: [producer.id] });
 
                     this._screenAudioProducer = null;
                     this._screenAudioProducerPromise = null;
+                    this._qualityMonitor.removeProducer(this._selfId, producer.id);
                 });
 
                 // Has someone replaced the track?
                 if (this._screenAudioTrack !== this._screenAudioProducer.track) await this._replaceScreenAudioTrack();
             } catch (error) {
-                this._logger.error("screenAudioProducer failed:%o", error);
+                logger.error("screenAudioProducer failed:%o", error);
             } finally {
                 this._screenAudioProducerPromise = null;
 
@@ -6047,7 +7020,7 @@ class VegaRtcManager {
     }
 
     async _replaceScreenAudioTrack() {
-        this._logger.debug("_replaceScreenAudioTrack()");
+        logger.info("_replaceScreenAudioTrack()");
 
         if (!this._screenAudioTrack || !this._screenAudioProducer || this._screenAudioProducer.closed) return;
 
@@ -6058,7 +7031,7 @@ class VegaRtcManager {
     }
 
     async _sendScreenAudio(track) {
-        this._logger.debug("_sendScreenAudio() [track:%o]", track);
+        logger.info("_sendScreenAudio() [track:%o]", track);
 
         this._screenAudioTrack = track;
 
@@ -6072,7 +7045,7 @@ class VegaRtcManager {
     }
 
     _stopProducer(producer) {
-        this._logger.debug("_stopProducer()");
+        logger.info("_stopProducer()");
 
         if (!producer || producer.closed) return;
 
@@ -6127,6 +7100,18 @@ class VegaRtcManager {
         rtcStats.sendEvent("colocation_changed", { colocation });
     }
 
+    /**
+     * This sends a signal to the SFU to pause all incoming video streams to the client.
+     *
+     * @param {boolean} audioOnly
+     */
+    setAudioOnly(audioOnly) {
+        this._vegaConnection?.message(audioOnly ? "enableAudioOnly" : "disableAudioOnly");
+    }
+
+    // the track ids send by signal server for remote-initiated screenshares
+    setRemoteScreenshareVideoTrackIds(/*remoteScreenshareVideoTrackIds*/) {}
+
     /**
      * The unique identifier for this room session.
      *
@@ -6146,7 +7131,7 @@ class VegaRtcManager {
      * @param {string} eventClaim
      */
     disconnect(clientIdOrStreamId, _activeBreakout, eventClaim) {
-        this._logger.debug("disconnect() [clientIdOrStreamId:%s, eventClaim:%s]", clientIdOrStreamId, eventClaim);
+        logger.info("disconnect() [clientIdOrStreamId:%s, eventClaim:%s]", clientIdOrStreamId, eventClaim);
 
         if (this._clientStates.has(clientIdOrStreamId)) {
             // In this case this is a disconnect from an actual client, not just a screen share.
@@ -6204,7 +7189,7 @@ class VegaRtcManager {
      * @param {string} requestedByClientId
      */
     removeStream(streamId, _stream, requestedByClientId) {
-        this._logger.debug("removeStream() [streamId:%s, requestedByClientId:%s]", streamId, requestedByClientId);
+        logger.info("removeStream() [streamId:%s, requestedByClientId:%s]", streamId, requestedByClientId);
 
         this._emitToSignal(PROTOCOL_REQUESTS.STOP_SCREENSHARE, {
             streamId: OUTBOUND_SCREEN_OUTBOUND_STREAM_ID,
@@ -6308,7 +7293,7 @@ class VegaRtcManager {
      * @param {boolean} enabled
      */
     stopOrResumeAudio(stream, enabled) {
-        this._logger.debug("stopOrResumeAudio() [enabled:%s]", enabled);
+        logger.info("stopOrResumeAudio() [enabled:%s]", enabled);
 
         this._micPaused = !enabled;
 
@@ -6334,7 +7319,7 @@ class VegaRtcManager {
      * @param {boolean} enabled
      */
     stopOrResumeVideo(localStream, enable) {
-        this._logger.debug("stopOrResumeVideo() [enable:%s]", enable);
+        logger.info("stopOrResumeVideo() [enable:%s]", enable);
 
         this._webcamPaused = !enable;
 
@@ -6397,7 +7382,7 @@ class VegaRtcManager {
      * }} streamOptions
      */
     acceptNewStream({ streamId, clientId }) {
-        this._logger.debug("acceptNewStream()", { streamId, clientId });
+        logger.info("acceptNewStream()", { streamId, clientId });
 
         // make sure we have rtcStats connection
         this.rtcStatsReconnect();
@@ -6428,7 +7413,7 @@ class VegaRtcManager {
      * }} size
      */
     updateStreamResolution(streamId, _ignored, { width, height }) {
-        this._logger.debug("updateStreamResolution()", { streamId, width, height });
+        logger.info("updateStreamResolution()", { streamId, width, height });
 
         const consumerId = this._streamIdToVideoConsumerId.get(streamId);
         const consumer = this._consumers.get(consumerId);
@@ -6561,18 +7546,22 @@ class VegaRtcManager {
                         return this._onDataConsumerClosed(data);
                     case "dominantSpeaker":
                         return this._onDominantSpeaker(data);
+                    case "consumerScore":
+                        return this._onConsumerScore(data);
+                    case "producerScore":
+                        return this._onProducerScore(data);
                     default:
-                        this._logger.debug(`unknown message method "${method}"`);
+                        logger.info(`unknown message method "${method}"`);
                         return;
                 }
             })
             .catch((error) => {
-                console.error('"message" failed [error:%o]', error);
+                logger.error('"message" failed [error:%o]', error);
             });
     }
 
     async _onConsumerReady(options) {
-        this._logger.debug("_onConsumerReady()", { id: options.id, producerId: options.producerId });
+        logger.info("_onConsumerReady()", { id: options.id, producerId: options.producerId });
 
         const consumer = await this._receiveTransport.consume(options);
 
@@ -6581,8 +7570,10 @@ class VegaRtcManager {
         consumer.appData.spatialLayer = 2;
 
         this._consumers.set(consumer.id, consumer);
+        this._qualityMonitor.addConsumer(consumer.appData.sourceClientId, consumer.id);
         consumer.observer.once("close", () => {
             this._consumers.delete(consumer.id);
+            this._qualityMonitor.removeConsumer(consumer.appData.sourceClientId, consumer.id);
 
             this._consumerClosedCleanup(consumer);
         });
@@ -6593,7 +7584,7 @@ class VegaRtcManager {
                 // Legacy Chrome API
                 consumer.rtpReceiver.playoutDelayHint = MEDIA_JITTER_BUFFER_TARGET / 1000; // seconds
             } catch (error) {
-                this._logger.error("Error during setting jitter buffer target:", error);
+                logger.error("Error during setting jitter buffer target:", error);
             }
         }
 
@@ -6626,13 +7617,13 @@ class VegaRtcManager {
     }
 
     async _onConsumerClosed({ consumerId, reason }) {
-        this._logger.debug("_onConsumerClosed()", { consumerId, reason });
+        logger.info("_onConsumerClosed()", { consumerId, reason });
 
         this._consumers.get(consumerId)?.close();
     }
 
     _onConsumerPaused({ consumerId }) {
-        this._logger.debug("_onConsumerPaused()", { consumerId });
+        logger.info("_onConsumerPaused()", { consumerId });
 
         const consumer = this._consumers.get(consumerId);
 
@@ -6643,7 +7634,7 @@ class VegaRtcManager {
     }
 
     _onConsumerResumed({ consumerId }) {
-        this._logger.debug("_onConsumerResumed()", { consumerId });
+        logger.info("_onConsumerResumed()", { consumerId });
 
         const consumer = this._consumers.get(consumerId);
 
@@ -6656,8 +7647,30 @@ class VegaRtcManager {
         }
     }
 
+    _onConsumerScore({ consumerId, kind, score }) {
+        logger.info("_onConsumerScore()", { consumerId, kind, score });
+        const {
+            appData: { sourceClientId },
+        } = this._consumers.get(consumerId) || { appData: {} };
+
+        if (sourceClientId) {
+            this._qualityMonitor.addConsumerScore(sourceClientId, consumerId, kind, score);
+        }
+    }
+
+    _onProducerScore({ producerId, kind, score }) {
+        logger.info("_onProducerScore()", { producerId, kind, score });
+        [this._micProducer, this._webcamProducer, this._screenVideoProducer, this._screenAudioProducer].forEach(
+            (producer) => {
+                if (producer?.id === producerId) {
+                    this._qualityMonitor.addProducerScore(this._selfId, producerId, kind, score);
+                }
+            }
+        );
+    }
+
     async _onDataConsumerReady(options) {
-        this._logger.debug("_onDataConsumerReady()", { id: options.id, producerId: options.producerId });
+        logger.info("_onDataConsumerReady()", { id: options.id, producerId: options.producerId });
         const consumer = await this._receiveTransport.consumeData(options);
 
         this._dataConsumers.set(consumer.id, consumer);
@@ -6683,7 +7696,7 @@ class VegaRtcManager {
     }
 
     async _onDataConsumerClosed({ dataConsumerId, reason }) {
-        this._logger.debug("_onDataConsumerClosed()", { dataConsumerId, reason });
+        logger.info("_onDataConsumerClosed()", { dataConsumerId, reason });
         const consumer = this._dataConsumers.get(dataConsumerId);
         consumer?.close();
     }
@@ -6739,7 +7752,7 @@ class VegaRtcManager {
         } = clientState;
 
         // Need to pause/resume any consumers that are part of a stream that has been
-        // accepted or dosconnected by the PWA
+        // accepted or disconnected by the PWA
         const toPauseConsumers = [];
         const toResumeConsumers = [];
 
@@ -6841,6 +7854,10 @@ class VegaRtcManager {
     setMicAnalyserParams(params) {
         this._micAnalyser?.setParams(params);
     }
+
+    hasClient(clientId) {
+        return this._clientStates.has(clientId);
+    }
 }
 
 class RtcManagerDispatcher {
@@ -6849,7 +7866,16 @@ class RtcManagerDispatcher {
         this.currentManager = null;
         serverSocket.on(PROTOCOL_RESPONSES.ROOM_JOINED, ({ room, selfId, error, eventClaim }) => {
             if (error) return; // ignore error responses which lack room
-            const config = { selfId, room, emitter, serverSocket, webrtcProvider, features, eventClaim };
+            const config = {
+                selfId,
+                room,
+                emitter,
+                serverSocket,
+                webrtcProvider,
+                features,
+                eventClaim,
+                deviceHandlerFactory: features?.deviceHandlerFactory,
+            };
             const isSfu = !!room.sfuServer;
             if (this.currentManager) {
                 if (this.currentManager.isInitializedWith({ selfId, roomName: room.name, isSfu })) {
@@ -6870,6 +7896,7 @@ class RtcManagerDispatcher {
             rtcManager.setupSocketListeners();
             emitter.emit(EVENTS.RTC_MANAGER_CREATED, { rtcManager });
             this.currentManager = rtcManager;
+            serverSocket.setRtcManager(rtcManager);
         });
     }
 
@@ -7794,7 +8821,7 @@ var localStorage$1 = localStorage;
 const events = {
     CREDENTIALS_SAVED: "credentials_saved",
 };
-class CredentialsService extends EventEmitter$1 {
+class CredentialsService extends EventEmitter {
     constructor({ deviceService, credentialsStore, }) {
         super();
         this._deviceService = deviceService;
@@ -8432,7 +9459,7 @@ class LocalParticipant extends RoomParticipant {
     }
 }
 
-const sdkVersion = "0.2.0-beta.0";
+const sdkVersion = "0.2.0";
 
 const defaultSubdomainPattern = /^(?:([^.]+)[.])?((:?[^.]+[.]){1,}[^.]+)$/;
 const localstackPattern = /^(?:([^.]+)-)?(ip-[^.]*[.](?:hereby[.]dev|rfc1918[.]disappear[.]at)(?::\d+|))$/;