@whereby.com/browser-sdk 2.1.0-beta2 → 2.1.0-beta3

package/dist/react/index.esm.js

@@ -3,11 +3,15 @@ import { useState, useEffect, useCallback } from 'react';
 import { createListenerMiddleware, createSlice, createAsyncThunk, createAction, createSelector, isAnyOf, combineReducers, configureStore } from '@reduxjs/toolkit';
 import { io } from 'socket.io-client';
 import adapter from 'webrtc-adapter';
+import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
 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 { Chrome111 } from 'mediasoup-client/lib/handlers/Chrome111';
 import nodeBtoa from 'btoa';
 import axios from 'axios';
 
@@ -173,6 +177,7 @@ const initialState$g = {
     displayName: null,
     sdkVersion: null,
     externalId: null,
+    isNodeSdk: typeof process !== "undefined" && process.release.name === "node",
 };
 const appSlice = createSlice({
     name: "app",
@@ -200,7 +205,8 @@ const selectAppRoomUrl = (state) => state.app.roomUrl;
 const selectAppRoomKey = (state) => state.app.roomKey;
 const selectAppDisplayName = (state) => state.app.displayName;
 const selectAppSdkVersion = (state) => state.app.sdkVersion;
-const selectAppExternalId = (state) => state.app.externalId;
+const selectAppExternalId = (state) => state.app.externalId;
+const selectAppIsNodeSdk = (state) => state.app.isNodeSdk;
 
 function createAppAsyncThunk(typePrefix, payloadCreator) {
     return createAsyncThunk(typePrefix, payloadCreator);
@@ -285,13 +291,461 @@ 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;
+}
+
+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",
+};
+
+class ReconnectManager extends EventEmitter {
+    constructor(socket, logger = console) {
+        super();
+        this._socket = socket;
+        this._logger = logger;
+        this._clients = {};
+        this._signalDisconnectTime = undefined;
+        this.rtcManager = undefined;
+
+        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);
+            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) {
+                this._logger.error("Failed to evaluate if we should merge client state %o", error);
+            }
+        });
+
+        // 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.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) {
+            this._logger.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;
+            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,
@@ -317,12 +771,39 @@ 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() {
@@ -383,6 +864,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 () => {
@@ -409,6 +901,19 @@ 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);
+        };
+    }
 }
 
 function forwardSocketEvents(socket, dispatch) {
@@ -652,6 +1157,7 @@ const parseResolution = (res) => res.split(/[^\d]/g).map((n) => parseInt(n, 10))
 function getMediaConstraints({
     disableAEC,
     disableAGC,
+    fps24,
     hd,
     lax,
     lowDataMode,
@@ -662,7 +1168,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
@@ -675,15 +1181,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) {
@@ -1519,7 +2030,10 @@ const selectSpeakerDevices = createSelector(selectLocalMediaDevices, (devices) =
  * Reactors
  */
 // Start localMedia unless started when roomConnection is wanted
-const selectLocalMediaShouldStartWithOptions = createSelector(selectAppWantsToJoin, selectLocalMediaStatus, selectLocalMediaOptions, (appWantsToJoin, localMediaStatus, localMediaOptions) => {
+const selectLocalMediaShouldStartWithOptions = createSelector(selectAppWantsToJoin, selectLocalMediaStatus, selectLocalMediaOptions, selectAppIsNodeSdk, (appWantsToJoin, localMediaStatus, localMediaOptions, isNodeSdk) => {
+    if (isNodeSdk) {
+        return;
+    }
     if (appWantsToJoin && localMediaStatus === "" && localMediaOptions) {
         return localMediaOptions;
     }
@@ -2155,8 +2669,14 @@ const selectRoomConnectionStatus = (state) => state.roomConnection.status;
 /**
  * Reactors
  */
-const selectShouldConnectRoom = createSelector([selectOrganizationId, selectRoomConnectionStatus, selectSignalConnectionDeviceIdentified, selectLocalMediaStatus], (hasOrganizationIdFetched, roomConnectionStatus, signalConnectionDeviceIdentified, localMediaStatus) => {
-    if (localMediaStatus === "started" &&
+const selectShouldConnectRoom = createSelector([
+    selectOrganizationId,
+    selectRoomConnectionStatus,
+    selectSignalConnectionDeviceIdentified,
+    selectLocalMediaStatus,
+    selectAppIsNodeSdk,
+], (hasOrganizationIdFetched, roomConnectionStatus, signalConnectionDeviceIdentified, localMediaStatus, isNodeSdk) => {
+    if ((localMediaStatus === "started" || isNodeSdk) && // the node SDK doesn't use LocalMedia, so we can join without
         signalConnectionDeviceIdentified &&
         !!hasOrganizationIdFetched &&
         ["initializing", "reconnect"].includes(roomConnectionStatus)) {
@@ -2183,125 +2703,27 @@ startAppListening({
             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",
-};
+            dispatch(connectionStatusChanged("knock_rejected"));
+        }
+    },
+});
 
-// 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",
+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";
@@ -2417,8 +2839,14 @@ 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_CLOSED: "sfu_connection_closed",
     COLOCATION_SPEAKER: "colocation_speaker",
     DOMINANT_SPEAKER: "dominant_speaker",
@@ -2617,6 +3045,13 @@ class Session {
     constructor({ peerConnectionId, bandwidth, maximumTurnBandwidth, deprioritizeH264Encoding, logger = console }) {
         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;
@@ -2993,6 +3428,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 +
@@ -3091,6 +3541,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;
@@ -3161,13 +3613,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
@@ -3387,6 +3838,13 @@ var rtcstats = function(trace, getStatsInterval, prefixesToWrap) {
     }
   });
   */
+
+  return {
+    resetDelta() {
+      prevById = {};
+    }
+  }
+
 };
 
 var rtcstats$1 = /*@__PURE__*/getDefaultExportFromCjs(rtcstats);
@@ -3395,11 +3853,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 = [];
@@ -3412,6 +3877,7 @@ function rtcStatsConnection(wsURL, logger = console) {
     let connectionShouldBeOpen;
     let connectionAttempt = 0;
     let hasPassedOnRoomSessionId = false;
+    let getStatsBufferUsed = 0;
 
     const connection = {
         connected: false,
@@ -3449,8 +3915,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);
             }
 
@@ -3485,6 +3958,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
@@ -3509,10 +3983,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;
             };
         },
     };
@@ -3521,11 +3996,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) => {
@@ -3574,6 +4051,7 @@ class BaseRtcManager {
         this.peerConnections = {};
         this.localStreams = {};
         this.enabledLocalStreamIds = [];
+        this._screenshareVideoTrackIds = [];
         this._socketListenerDeregisterFunctions = [];
         this._localStreamDeregisterFunction = null;
         this._emitter = emitter;
@@ -3581,6 +4059,7 @@ class BaseRtcManager {
         this._webrtcProvider = webrtcProvider;
         this._features = features || {};
         this._logger = logger;
+        this._isAudioOnlyMode = false;
 
         this.offerOptions = { offerToReceiveAudio: true, offerToReceiveVideo: true };
         this._pendingActionsForConnectedPeerConnections = [];
@@ -3797,6 +4276,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) {
@@ -3858,6 +4339,11 @@ class BaseRtcManager {
                             this.maybeRestrictRelayBandwidth(session);
                         }
                     }
+
+                    if (this._isAudioOnlyMode) {
+                        session.setAudioOnly(true, this._screenshareVideoTrackIds);
+                    }
+
                     session.registerConnected();
                     break;
                 case "disconnected":
@@ -4086,6 +4572,7 @@ class BaseRtcManager {
         }
 
         // at this point it is clearly a screensharing stream.
+        this._screenshareVideoTrackIds.push(stream.getVideoTracks()[0].id);
         this._shareScreen(streamId, stream);
         return;
     }
@@ -4238,6 +4725,29 @@ class BaseRtcManager {
                 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) {
+                    this._logger.warn(`screenshare stream ${screenShareStreamId} not found`);
+                    return;
+                }
+
+                const hasAudioTrack = screenshareStream.getAudioTracks().length > 0;
+
+                this._emitServerEvent(PROTOCOL_REQUESTS.START_SCREENSHARE, {
+                    streamId: screenShareStreamId,
+                    hasAudioTrack,
+                });
+            }),
         ];
     }
 
@@ -4271,6 +4781,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;
     }
@@ -4304,6 +4835,52 @@ 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 ICE_PUBLIC_IP_GATHERING_TIMEOUT = 3 * 1000;
 const CAMERA_STREAM_ID = RtcStream.getCameraId();
 const browserName$1 = adapter.browserDetails.browser;
 
@@ -4335,6 +4912,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,
@@ -4477,7 +5062,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,
@@ -4543,9 +5128,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) {
+                            this._logger.debug("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,
@@ -4554,6 +5203,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);
             }
         };
 
@@ -4678,14 +5341,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 {
@@ -4810,7 +5479,7 @@ class SfuV2Parser {
     }
 }
 
-class VegaConnection extends EventEmitter {
+class VegaConnection extends EventEmitter$1 {
     constructor(wsUrl, logger, protocol = "whereby-sfu#v4") {
         super();
 
@@ -5385,18 +6054,214 @@ const maybeTurnOnly = (transportConfig, features) => {
     }
 };
 
+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({ logger }) {
+        super();
+        this._logger = logger;
+        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")) {
+            this._logger.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) {
+            this._logger.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))
+        ) {
+            this._logger.warn("VegaMediaQualityMonitor.addProducerScore(): 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)) {
+            this._logger.warn("VegaMediaQualityMonitor.addConsumerScore(): 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) {
+            this._logger.error(error);
+            return 0;
+        }
+    }
+}
+
 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,
+        logger = console,
+        deviceHandlerFactory,
+    }) {
         assert$1.ok(selfId, "selfId is required");
         assert$1.ok(room, "room is required");
         assert$1.ok(emitter && emitter.emit, "emitter is required");
@@ -5420,7 +6285,12 @@ class VegaRtcManager {
         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;
@@ -5483,6 +6353,11 @@ class VegaRtcManager {
         // Retry if connection closed until disconnectAll called;
         this._reconnect = true;
         this._reconnectTimeOut = null;
+
+        this._qualityMonitor = new VegaMediaQualityMonitor({ logger: this._logger });
+        this._qualityMonitor.on(PROTOCOL_EVENTS.MEDIA_QUALITY_CHANGED, (payload) => {
+            this._emitToPWA(PROTOCOL_EVENTS.MEDIA_QUALITY_CHANGED, payload);
+        });
     }
 
     _updateAndScheduleMediaServersRefresh({ iceServers, sfuServer, mediaserverConfigTtlSeconds }) {
@@ -5567,6 +6442,8 @@ class VegaRtcManager {
         if (this._reconnect) {
             this._reconnectTimeOut = setTimeout(() => this._connect(), 1000);
         }
+
+        this._qualityMonitor.close();
     }
 
     async _join() {
@@ -5814,6 +6691,7 @@ 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');
@@ -5823,6 +6701,7 @@ class VegaRtcManager {
 
                     this._micProducer = null;
                     this._micProducerPromise = null;
+                    this._qualityMonitor.removeProducer(this._selfId, producer.id);
                 });
 
                 if (this._micTrack !== this._micProducer.track) await this._replaceMicTrack();
@@ -6008,6 +6887,7 @@ 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');
 
@@ -6016,6 +6896,7 @@ class VegaRtcManager {
 
                     this._webcamProducer = null;
                     this._webcamProducerPromise = null;
+                    this._qualityMonitor.removeProducer(this._selfId, producer.id);
                 });
 
                 // Has someone replaced the track?
@@ -6110,6 +6991,7 @@ class VegaRtcManager {
                 });
 
                 this._screenVideoProducer = producer;
+                this._qualityMonitor.addProducer(this._selfId, producer.id);
                 producer.observer.once("close", () => {
                     this._logger.debug('screenVideoProducer "close" event');
 
@@ -6118,6 +7000,7 @@ class VegaRtcManager {
 
                     this._screenVideoProducer = null;
                     this._screenVideoProducerPromise = null;
+                    this._qualityMonitor.removeProducer(this._selfId, producer.id);
                 });
 
                 // Has someone replaced the track?
@@ -6187,6 +7070,7 @@ class VegaRtcManager {
                 });
 
                 this._screenAudioProducer = producer;
+                this._qualityMonitor.addProducer(this._selfId, producer.id);
                 producer.observer.once("close", () => {
                     this._logger.debug('screenAudioProducer "close" event');
 
@@ -6195,6 +7079,7 @@ class VegaRtcManager {
 
                     this._screenAudioProducer = null;
                     this._screenAudioProducerPromise = null;
+                    this._qualityMonitor.removeProducer(this._selfId, producer.id);
                 });
 
                 // Has someone replaced the track?
@@ -6294,6 +7179,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.
      *
@@ -6728,6 +7625,10 @@ 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}"`);
                         return;
@@ -6748,8 +7649,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);
         });
@@ -6823,6 +7726,28 @@ class VegaRtcManager {
         }
     }
 
+    _onConsumerScore({ consumerId, kind, score }) {
+        this._logger.debug("_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 }) {
+        this._logger.debug("_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 });
         const consumer = await this._receiveTransport.consumeData(options);
@@ -6906,7 +7831,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 = [];
 
@@ -7008,6 +7933,10 @@ class VegaRtcManager {
     setMicAnalyserParams(params) {
         this._micAnalyser?.setParams(params);
     }
+
+    hasClient(clientId) {
+        return this._clientStates.has(clientId);
+    }
 }
 
 class RtcManagerDispatcher {
@@ -7016,7 +7945,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 })) {
@@ -7037,6 +7975,7 @@ class RtcManagerDispatcher {
             rtcManager.setupSocketListeners();
             emitter.emit(EVENTS.RTC_MANAGER_CREATED, { rtcManager });
             this.currentManager = rtcManager;
+            serverSocket.setRtcManager(rtcManager);
         });
     }
 
@@ -7121,6 +8060,7 @@ const doConnectRtc = createAppThunk(() => (dispatch, getState) => {
     const dispatcher = selectRtcConnectionRaw(state).rtcManagerDispatcher;
     const isCameraEnabled = selectIsCameraEnabled(state);
     const isMicrophoneEnabled = selectIsMicrophoneEnabled(state);
+    const isNodeSdk = selectAppIsNodeSdk(state);
     if (dispatcher) {
         return;
     }
@@ -7146,6 +8086,7 @@ const doConnectRtc = createAppThunk(() => (dispatch, getState) => {
             vp9On: false,
             h264On: false,
             simulcastScreenshareOn: false,
+            deviceHandlerFactory: isNodeSdk ? Chrome111.createFactory() : undefined,
         },
     });
     dispatch(rtcDispatcherCreated(rtcManagerDispatcher));
@@ -8200,7 +9141,7 @@ var localStorage$1 = localStorage;
 const events = {
     CREDENTIALS_SAVED: "credentials_saved",
 };
-class CredentialsService extends EventEmitter$1 {
+class CredentialsService extends EventEmitter {
     /**
      * Service to manage Whereby's Rest API credentials.
      *
@@ -8690,7 +9631,7 @@ const selectRoomConnectionState = createSelector(selectChatMessages, selectCloud
     return state;
 });
 
-const sdkVersion = "2.1.0-beta2";
+const sdkVersion = "2.1.0-beta3";
 
 const initialState$1 = {
     chatMessages: [],