@whereby.com/core 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,15 +1,16 @@
 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 adapterRaw from 'webrtc-adapter';
 import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
 import { d as debounce } from './debounce-B-cWYxqK.js';
+import { v4 as v4$1 } from 'uuid';
 import SDPUtils from 'sdp';
 import * as sdpTransform from 'sdp-transform';
-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 { Chrome111 } from 'mediasoup-client/lib/handlers/Chrome111.js';
 import nodeBtoa from 'btoa';
 import axios from 'axios';
 
@@ -42,6 +43,7 @@ const createReactor = (selectors, callback) => {
 };
 
 const initialState$c = {
+    isNodeSdk: false,
     wantsToJoin: false,
     roomName: null,
     roomKey: null,
@@ -75,6 +77,7 @@ 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 selectAppIsNodeSdk = (state) => state.app.isNodeSdk;
 
 function createSignalEventAction(name) {
     return createAction(`signalConnection/event/${name}`);
@@ -386,7 +389,7 @@ const PROTOCOL_EVENTS = {
     MEDIA_QUALITY_CHANGED: "media_quality_changed",
 };
 
-const logger$9 = new Logger();
+const logger$8 = new Logger();
 
 class ReconnectManager extends EventEmitter {
     constructor(socket) {
@@ -501,7 +504,7 @@ class ReconnectManager extends EventEmitter {
 
                 client.mergeWithOldClientState = true;
             } catch (error) {
-                logger$9.error("Failed to evaluate if we should merge client state %o", error);
+                logger$8.error("Failed to evaluate if we should merge client state %o", error);
                 this.metrics.evaluationFailed++;
             }
         });
@@ -538,7 +541,7 @@ class ReconnectManager extends EventEmitter {
         const client = this._clients[clientId];
 
         if (!client) {
-            logger$9.warn(`client ${clientId} not found`);
+            logger$8.warn(`client ${clientId} not found`);
             return;
         }
 
@@ -708,6 +711,8 @@ class ReconnectManager extends EventEmitter {
     }
 }
 
+const adapter$6 = adapterRaw.default ?? adapterRaw;
+
 const DEFAULT_SOCKET_PATH = "/protocol/socket.io/v4";
 
 const NOOP_KEEPALIVE_INTERVAL = 2000;
@@ -737,7 +742,7 @@ class ServerSocket {
                 // safari doesn't support cross doamin cookies making load-balancer stickiness not work
                 // and if socket.io reconnects to another signal instance with polling it will fail
                 // remove if we move signal to a whereby.com subdomain
-                if (adapter.browserDetails.browser !== "safari") delete this._wasConnectedUsingWebsocket;
+                if (adapter$6.browserDetails.browser !== "safari") delete this._wasConnectedUsingWebsocket;
             } else {
                 this._socket.io.opts.transports = ["websocket", "polling"];
             }
@@ -1108,7 +1113,9 @@ const selectCloudRecordingStartedAt = (state) => state.cloudRecording.startedAt;
 const selectCloudRecordingError = (state) => state.cloudRecording.error;
 const selectIsCloudRecording = (state) => state.cloudRecording.isRecording;
 
-const isSafari = adapter.browserDetails.browser === "safari";
+const adapter$5 = adapterRaw.default ?? adapterRaw;
+
+const isSafari = adapter$5.browserDetails.browser === "safari";
 
 // Expects format 640x360@25, returns [width, height, fps]
 const parseResolution = (res) => res.split(/[^\d]/g).map((n) => parseInt(n, 10));
@@ -1119,7 +1126,6 @@ const parseResolution = (res) => res.split(/[^\d]/g).map((n) => parseInt(n, 10))
 function getMediaConstraints({
     disableAEC,
     disableAGC,
-    fps24,
     hd,
     lax,
     lowDataMode,
@@ -1130,7 +1136,6 @@ function getMediaConstraints({
 }) {
     let HIGH_HEIGHT = 480;
     let LOW_HEIGHT = 240;
-    let NON_STANDARD_FPS = 0;
 
     if (hd) {
         // respect user choice, but default to HD for pro, and SD for free
@@ -1145,18 +1150,14 @@ function getMediaConstraints({
         }
     }
 
-    // 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,
-            ...(NON_STANDARD_FPS && { frameRate: NON_STANDARD_FPS }),
+            // Set a lower frame rate (15fps) for low data, but only for non-simulcast.
+            // Otherwise use 24fps to increase quality/bandwidth.
+            frameRate: lowDataMode && !simulcast ? 15 : 24,
         },
     };
     if (lax) {
@@ -1289,7 +1290,7 @@ var assert_1 = assert;
 
 var assert$1 = /*@__PURE__*/getDefaultExportFromCjs(assert_1);
 
-const logger$8 = new Logger();
+const logger$7 = new Logger();
 
 const isMobile = /mobi/i.test(navigator.userAgent);
 
@@ -1310,7 +1311,7 @@ function getUserMedia(constraints) {
 
     return navigator.mediaDevices.getUserMedia(constraints).catch((error) => {
         const message = `${error}, ${JSON.stringify(constraints, null, 2)}`;
-        logger$8.error(`getUserMedia ${message}`);
+        logger$7.error(`getUserMedia ${message}`);
         throw error;
     });
 }
@@ -1496,7 +1497,7 @@ async function getStream(constraintOpt, { replaceStream, fallback = true } = {})
                         getConstraints({ ...constraintOpt, options: { ...constraintOpt.options, lax: true } })
                     );
                 } catch (e2) {
-                    logger$8.warn(`Tried getting stream again with laxer constraints, but failed: ${"" + e2}`);
+                    logger$7.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();
@@ -1505,7 +1506,7 @@ async function getStream(constraintOpt, { replaceStream, fallback = true } = {})
                     try {
                         stream = await getUserMedia(getConstraints({ ...constraintOpt, [problemWith]: null }));
                     } catch (e2) {
-                        logger$8.warn(`Re-tried ${problemWith} with no constraints, but failed: ${"" + e2}`);
+                        logger$7.warn(`Re-tried ${problemWith} with no constraints, but failed: ${"" + e2}`);
                     }
                 }
                 if (!stream) {
@@ -1516,7 +1517,7 @@ async function getStream(constraintOpt, { replaceStream, fallback = true } = {})
                         try {
                             stream = await getUserMedia(getConstraints({ ...constraintOpt, [kind]: false }));
                         } catch (e2) {
-                            logger$8.warn(`Re-tried without ${kind}, but failed: ${"" + e2}`);
+                            logger$7.warn(`Re-tried without ${kind}, but failed: ${"" + e2}`);
                         }
                         if (stream) break;
                     }
@@ -1972,8 +1973,8 @@ const selectIsLocalMediaStarting = createSelector(selectLocalMediaStatus, (statu
 const selectCameraDevices = createSelector(selectLocalMediaDevices, selectBusyDeviceIds, (devices, busyDeviceIds) => devices.filter((d) => d.kind === "videoinput").filter((d) => !busyDeviceIds.includes(d.deviceId)));
 const selectMicrophoneDevices = createSelector(selectLocalMediaDevices, selectBusyDeviceIds, (devices, busyDeviceIds) => devices.filter((d) => d.kind === "audioinput").filter((d) => !busyDeviceIds.includes(d.deviceId)));
 const selectSpeakerDevices = createSelector(selectLocalMediaDevices, (devices) => devices.filter((d) => d.kind === "audiooutput"));
-const selectLocalMediaShouldStartWithOptions = createSelector(selectAppWantsToJoin, selectLocalMediaStatus, selectLocalMediaOptions, (appWantsToJoin, localMediaStatus, localMediaOptions) => {
-    if (appWantsToJoin && localMediaStatus === "" && localMediaOptions) {
+const selectLocalMediaShouldStartWithOptions = createSelector(selectAppWantsToJoin, selectLocalMediaStatus, selectLocalMediaOptions, selectAppIsNodeSdk, (appWantsToJoin, localMediaStatus, localMediaOptions, isNodeSdk) => {
+    if (appWantsToJoin && localMediaStatus === "" && !isNodeSdk && localMediaOptions) {
         return localMediaOptions;
     }
 });
@@ -2494,6 +2495,9 @@ const roomConnectionSlice = createSlice({
             if (error === "room_locked" && isLocked) {
                 return Object.assign(Object.assign({}, state), { status: "room_locked" });
             }
+            if (error) {
+                return Object.assign(Object.assign({}, state), { status: "disconnected", error });
+            }
             return Object.assign(Object.assign({}, state), { status: "connected", session: (_b = (_a = action.payload.room) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : null });
         });
         builder.addCase(signalEvents.newClient, (state, action) => {
@@ -2581,8 +2585,15 @@ 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" &&
+const selectRoomConnectionError = (state) => state.roomConnection.error;
+const selectShouldConnectRoom = createSelector([
+    selectOrganizationId,
+    selectRoomConnectionStatus,
+    selectSignalConnectionDeviceIdentified,
+    selectLocalMediaStatus,
+    selectAppIsNodeSdk,
+], (hasOrganizationIdFetched, roomConnectionStatus, signalConnectionDeviceIdentified, localMediaStatus, isNodeSdk) => {
+    if ((localMediaStatus === "started" || isNodeSdk) &&
         signalConnectionDeviceIdentified &&
         !!hasOrganizationIdFetched &&
         ["initializing", "reconnect"].includes(roomConnectionStatus)) {
@@ -2614,161 +2625,594 @@ startAppListening({
     },
 });
 
-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",
-};
-
-const CAMERA_STREAM_ID$2 = "0";
-
-const STREAM_TYPES = {
-    CAMERA: "camera",
-    SCREEN_SHARE: "screen_share",
-};
-
-class RtcStream {
-    constructor(id, type) {
-        assert$1.notEqual(id, undefined, "id is required");
-        assert$1.notEqual(type, undefined, "type is required");
-
-        this.id = "" + id;
-        this.type = type;
-
-        this.isEnabled = true;
-        this.hasSupportForAutoSuperSize = false;
-        this.isAudioEnabled = true;
-        this.isVideoEnabled = true;
-        this.status = TYPES.CONNECTING;
-    }
+// transforms a maplike to an object. Mostly for getStats +
+// JSON.parse(JSON.stringify())
+function map2obj(m) {
+  if (!m.entries) {
+    return m;
+  }
+  var o = {};
+  m.forEach(function(v, k) {
+    o[k] = v;
+  });
+  return o;
+}
 
-    setup(stream) {
-        this.stream = stream;
-        this.streamId = stream.id;
-        this.setVideoEnabled(this.isVideoEnabled && stream.getVideoTracks().length > 0);
-        this.setAudioEnabled(this.isAudioEnabled && stream.getAudioTracks().length > 0);
-        return this;
+// apply a delta compression to the stats report. Reduces size by ~90%.
+// To reduce further, report keys could be compressed.
+function deltaCompression(oldStats, newStats) {
+  newStats = JSON.parse(JSON.stringify(newStats));
+  Object.keys(newStats).forEach(function(id) {
+    var report = newStats[id];
+    delete report.id;
+    if (!oldStats[id]) {
+      return;
     }
+    Object.keys(report).forEach(function(name) {
+      if (report[name] === oldStats[id][name]) {
+        delete newStats[id][name];
+      }
+      if (Object.keys(report).length === 0) {
+        delete newStats[id];
+      } else if (Object.keys(report).length === 1 && report.timestamp) {
+        delete newStats[id];
+      }
+    });
+  });
 
-    setStatus(status) {
-        this.status = status;
-        return this;
+  var timestamp = -Infinity;
+  Object.keys(newStats).forEach(function(id) {
+    var report = newStats[id];
+    if (report.timestamp > timestamp) {
+      timestamp = report.timestamp;
     }
-
-    setVideoEnabled(isEnabled) {
-        this.isVideoEnabled = isEnabled;
-        if (!this.stream) {
-            return;
-        }
-        this.stream.getVideoTracks().forEach((track) => {
-            track.enabled = isEnabled;
-        });
+  });
+  Object.keys(newStats).forEach(function(id) {
+    var report = newStats[id];
+    if (report.timestamp === timestamp) {
+      report.timestamp = 0;
     }
+  });
+  newStats.timestamp = timestamp;
+  return newStats;
+}
 
-    setAudioEnabled(isEnabled) {
-        this.isAudioEnabled = isEnabled;
-        if (!this.stream) {
-            return;
-        }
-        this.stream.getAudioTracks().forEach((track) => {
-            track.enabled = isEnabled;
-        });
-    }
+function dumpStream(stream) {
+  return {
+    id: stream.id,
+    tracks: stream.getTracks().map(function(track) {
+      return {
+        id: track.id,                 // unique identifier (GUID) for the track
+        kind: track.kind,             // `audio` or `video`
+        label: track.label,           // identified the track source
+        enabled: track.enabled,       // application can control it
+        muted: track.muted,           // application cannot control it (read-only)
+        readyState: track.readyState, // `live` or `ended`
+      };
+    }),
+  };
+}
 
-    static getCameraId() {
-        return CAMERA_STREAM_ID$2;
+/*
+function filterBoringStats(results) {
+  Object.keys(results).forEach(function(id) {
+    switch (results[id].type) {
+      case 'certificate':
+      case 'codec':
+        delete results[id];
+        break;
+      default:
+        // noop
     }
+  });
+  return results;
+}
 
-    static getTypeFromId(id) {
-        assert$1.notEqual(id, undefined, "id is required");
-
-        const streamId = "" + id;
-        return streamId === CAMERA_STREAM_ID$2 ? STREAM_TYPES.CAMERA : STREAM_TYPES.SCREEN_SHARE;
-    }
+function removeTimestamps(results) {
+  // FIXME: does not work in FF since the timestamp can't be deleted.
+  Object.keys(results).forEach(function(id) {
+    delete results[id].timestamp;
+  });
+  return results;
 }
+*/
 
-/**
- * Detect mic issue which seems to happen on OSX when the computer is woken up and sleeping
- * frequently. A browser restart fixes this.
- *
- * Should be called after the connection has been up for a while.
- *
- * @see Bug report {@link https://bugs.chromium.org/p/webrtc/issues/detail?id=4799}
- */
-function detectMicrophoneNotWorking(pc) {
-    if (
-        adapter.browserDetails.browser !== "chrome" ||
-        adapter.browserDetails.browser < 58 || // legacy getStats is no longer supported.
-        pc.signalingState === "closed"
-    ) {
-        return Promise.resolve(false);
+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;
     }
-    const sendingAudio = pc.getSenders().some((sender) => sender.track && sender.track.kind === "audio");
-    const receivingAudio = pc.getReceivers().some((receiver) => receiver.track && receiver.track.kind === "audio");
-    return pc.getStats(null).then((result) => {
-        let microphoneFailed = false;
-        result.forEach((report) => {
-            if (
-                report.type === "outbound-rtp" &&
-                (report.kind === "audio" || report.mediaType === "audio") &&
-                sendingAudio
-            ) {
-                if (report.bytesSent === 0) {
-                    microphoneFailed = "outbound";
-                }
-            } else if (
-                report.type === "inbound-rtp" &&
-                (report.kind === "audio" || report.mediaType === "audio") &&
-                receivingAudio
-            ) {
-                if (report.bytesReceived === 0) {
-                    microphoneFailed = "inbound";
-                }
-            }
-        });
-        return microphoneFailed;
-    });
-}
+    if (prefix === 'webkit' && isEdge) {
+      // dont wrap webkitRTCPeerconnection in Edge.
+      return;
+    }
+    var origPeerConnection = window[prefix + 'RTCPeerConnection'];
+    var peerconnection = function(config, constraints) {
+      var pc = new origPeerConnection(config, constraints);
+      var id = 'PC_' + peerconnectioncounter++;
+      pc.__rtcStatsId = id;
 
-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",
-};
+      if (!config) {
+        config = { nullConfig: true };
+      }
 
-const logger$7 = new Logger();
+      config = JSON.parse(JSON.stringify(config)); // deepcopy
+      // don't log credentials
+      ((config && config.iceServers) || []).forEach(function(server) {
+        delete server.credential;
+      });
 
-const browserName$3 = adapter.browserDetails.browser;
-const browserVersion$1 = adapter.browserDetails.version;
+      if (isFirefox) {
+        config.browserType = 'moz';
+      } else if (isEdge) {
+        config.browserType = 'edge';
+      } else {
+        config.browserType = 'webkit';
+      }
 
-function setCodecPreferenceSDP(sdp, vp9On, redOn) {
-    try {
-        const sdpObject = sdpTransform.parse(sdp);
-        if (Array.isArray(sdpObject?.media)) {
-            //audio
+      trace('create', id, config);
+      // TODO: do we want to log constraints here? They are chrome-proprietary.
+      // http://stackoverflow.com/questions/31003928/what-do-each-of-these-experimental-goog-rtcpeerconnectionconstraints-do
+      if (constraints) {
+        trace('constraints', id, constraints);
+      }
+
+      pc.addEventListener('icecandidate', function(e) {
+        trace('onicecandidate', id, e.candidate);
+      });
+      pc.addEventListener('addstream', function(e) {
+        trace('onaddstream', id, e.stream.id + ' ' + e.stream.getTracks().map(function(t) { return t.kind + ':' + t.id; }));
+      });
+      pc.addEventListener('track', function(e) {
+        trace('ontrack', id, e.track.kind + ':' + e.track.id + ' ' + e.streams.map(function(stream) { return 'stream:' + stream.id; }));
+      });
+      pc.addEventListener('removestream', function(e) {
+        trace('onremovestream', id, e.stream.id + ' ' + e.stream.getTracks().map(function(t) { return t.kind + ':' + t.id; }));
+      });
+      pc.addEventListener('signalingstatechange', function() {
+        trace('onsignalingstatechange', id, pc.signalingState);
+      });
+      pc.addEventListener('iceconnectionstatechange', function() {
+        trace('oniceconnectionstatechange', id, pc.iceConnectionState);
+      });
+      pc.addEventListener('icegatheringstatechange', function() {
+        trace('onicegatheringstatechange', id, pc.iceGatheringState);
+      });
+      pc.addEventListener('connectionstatechange', function() {
+        trace('onconnectionstatechange', id, pc.connectionState);
+      });
+      pc.addEventListener('negotiationneeded', function() {
+        trace('onnegotiationneeded', id, undefined);
+      });
+      pc.addEventListener('datachannel', function(event) {
+        trace('ondatachannel', id, [event.channel.id, event.channel.label]);
+      });
+
+      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(prevById[id] || {}, now));
+          prevById[id] = base;
+        });
+      };
+      // TODO: do we want one big interval and all peerconnections
+      //    queried in that or one setInterval per PC?
+      //    we have to collect results anyway so...
+      if (!isEdge && getStatsInterval) {
+        var interval = window.setInterval(function() {
+          if (pc.signalingState === 'closed') {
+            window.clearInterval(interval);
+            return;
+          }
+          getStats();
+        }, getStatsInterval);
+      }
+      if (!isEdge) {
+        pc.addEventListener('connectionstatechange', function() {
+          if (pc.connectionState === 'connected' || pc.connectionState === 'failed') {
+            getStats();
+          }
+        });
+      }
+      return pc;
+    };
+
+    ['createDataChannel', 'close'].forEach(function(method) {
+      var nativeMethod = origPeerConnection.prototype[method];
+      if (nativeMethod) {
+        origPeerConnection.prototype[method] = function() {
+          trace(method, this.__rtcStatsId, arguments);
+          return nativeMethod.apply(this, arguments);
+        };
+      }
+    });
+
+    ['addStream', 'removeStream'].forEach(function(method) {
+      var nativeMethod = origPeerConnection.prototype[method];
+      if (nativeMethod) {
+        origPeerConnection.prototype[method] = function() {
+          var stream = arguments[0];
+          var streamInfo = stream.getTracks().map(function(t) {
+            return t.kind + ':' + t.id;
+          }).join(',');
+
+          trace(method, this.__rtcStatsId, stream.id + ' ' + streamInfo);
+          return nativeMethod.apply(this, arguments);
+        };
+      }
+    });
+
+    ['addTrack'].forEach(function(method) {
+      var nativeMethod = origPeerConnection.prototype[method];
+      if (nativeMethod) {
+        origPeerConnection.prototype[method] = function() {
+          var track = arguments[0];
+          var streams = [].slice.call(arguments, 1);
+          trace(method, this.__rtcStatsId, track.kind + ':' + track.id + ' ' + (streams.map(function(s) { return 'stream:' + s.id; }).join(';') || '-'));
+          return nativeMethod.apply(this, arguments);
+        };
+      }
+    });
+
+    ['removeTrack'].forEach(function(method) {
+      var nativeMethod = origPeerConnection.prototype[method];
+      if (nativeMethod) {
+        origPeerConnection.prototype[method] = function() {
+          var track = arguments[0].track;
+          trace(method, this.__rtcStatsId, track ? track.kind + ':' + track.id : 'null');
+          return nativeMethod.apply(this, arguments);
+        };
+      }
+    });
+
+    ['createOffer', 'createAnswer'].forEach(function(method) {
+      var nativeMethod = origPeerConnection.prototype[method];
+      if (nativeMethod) {
+        origPeerConnection.prototype[method] = function() {
+          var rtcStatsId = this.__rtcStatsId;
+          var args = arguments;
+          var opts;
+          if (arguments.length === 1 && typeof arguments[0] === 'object') {
+            opts = arguments[0];
+          } else if (arguments.length === 3 && typeof arguments[2] === 'object') {
+            opts = arguments[2];
+          }
+          trace(method, this.__rtcStatsId, opts);
+          return nativeMethod.apply(this, opts ? [opts] : undefined)
+          .then(function(description) {
+            trace(method + 'OnSuccess', rtcStatsId, description);
+            if (args.length > 0 && typeof args[0] === 'function') {
+              args[0].apply(null, [description]);
+              return undefined;
+            }
+            return description;
+          }, function(err) {
+            trace(method + 'OnFailure', rtcStatsId, err.toString());
+            if (args.length > 1 && typeof args[1] === 'function') {
+              args[1].apply(null, [err]);
+              return;
+            }
+            throw err;
+          });
+        };
+      }
+    });
+
+    ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate'].forEach(function(method) {
+      var nativeMethod = origPeerConnection.prototype[method];
+      if (nativeMethod) {
+        origPeerConnection.prototype[method] = function() {
+          var rtcStatsId = this.__rtcStatsId;
+          var args = arguments;
+          trace(method, this.__rtcStatsId, args[0]);
+          return nativeMethod.apply(this, [args[0]])
+          .then(function() {
+            trace(method + 'OnSuccess', rtcStatsId, undefined);
+            if (args.length >= 2 && typeof args[1] === 'function') {
+              args[1].apply(null, []);
+              return undefined;
+            }
+            return undefined;
+          }, function(err) {
+            trace(method + 'OnFailure', rtcStatsId, err.toString());
+            if (args.length >= 3 && typeof args[2] === 'function') {
+              args[2].apply(null, [err]);
+              return undefined;
+            }
+            throw err;
+          });
+        };
+      }
+    });
+
+    // wrap static methods. Currently just generateCertificate.
+    if (origPeerConnection.generateCertificate) {
+      Object.defineProperty(peerconnection, 'generateCertificate', {
+        get: function() {
+          return arguments.length ?
+              origPeerConnection.generateCertificate.apply(null, arguments)
+              : origPeerConnection.generateCertificate;
+        },
+      });
+    }
+    window[prefix + 'RTCPeerConnection'] = peerconnection;
+    window[prefix + 'RTCPeerConnection'].prototype = origPeerConnection.prototype;
+  });
+
+  // getUserMedia wrappers
+  prefixesToWrap.forEach(function(prefix) {
+    var name = prefix + (prefix.length ? 'GetUserMedia' : 'getUserMedia');
+    if (!navigator[name]) {
+      return;
+    }
+    var origGetUserMedia = navigator[name].bind(navigator);
+    var gum = function() {
+      trace('getUserMedia', null, arguments[0]);
+      var cb = arguments[1];
+      var eb = arguments[2];
+      origGetUserMedia(arguments[0],
+        function(stream) {
+          // we log the stream id, track ids and tracks readystate since that is ended GUM fails
+          // to acquire the cam (in chrome)
+          trace('getUserMediaOnSuccess', null, dumpStream(stream));
+          if (cb) {
+            cb(stream);
+          }
+        },
+        function(err) {
+          trace('getUserMediaOnFailure', null, err.name);
+          if (eb) {
+            eb(err);
+          }
+        }
+      );
+    };
+    navigator[name] = gum.bind(navigator);
+  });
+
+  if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
+    var origGetUserMedia = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
+    var gum = function() {
+      trace('navigator.mediaDevices.getUserMedia', null, arguments[0]);
+      return origGetUserMedia.apply(navigator.mediaDevices, arguments)
+      .then(function(stream) {
+        trace('navigator.mediaDevices.getUserMediaOnSuccess', null, dumpStream(stream));
+        return stream;
+      }, function(err) {
+        trace('navigator.mediaDevices.getUserMediaOnFailure', null, err.name);
+        return Promise.reject(err);
+      });
+    };
+    navigator.mediaDevices.getUserMedia = gum.bind(navigator.mediaDevices);
+  }
+
+  // getDisplayMedia
+  if (navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia) {
+    var origGetDisplayMedia = navigator.mediaDevices.getDisplayMedia.bind(navigator.mediaDevices);
+    var gdm = function() {
+      trace('navigator.mediaDevices.getDisplayMedia', null, arguments[0]);
+      return origGetDisplayMedia.apply(navigator.mediaDevices, arguments)
+      .then(function(stream) {
+        trace('navigator.mediaDevices.getDisplayMediaOnSuccess', null, dumpStream(stream));
+        return stream;
+      }, function(err) {
+        trace('navigator.mediaDevices.getDisplayMediaOnFailure', null, err.name);
+        return Promise.reject(err);
+      });
+    };
+    navigator.mediaDevices.getDisplayMedia = gdm.bind(navigator.mediaDevices);
+  }
+
+  // TODO: are there events defined on MST that would allow us to listen when enabled was set?
+  //    no :-(
+  /*
+  Object.defineProperty(MediaStreamTrack.prototype, 'enabled', {
+    set: function(value) {
+      trace('MediaStreamTrackEnable', this, value);
+    }
+  });
+  */
+
+  return {
+    resetDelta() {
+      prevById = {};
+    }
+  }
+
+};
+
+var rtcstats$1 = /*@__PURE__*/getDefaultExportFromCjs(rtcstats);
+
+// ensure adapter is loaded first.
+
+adapterRaw.default ?? adapterRaw; // eslint-disable-line no-unused-vars
+
+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$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 = [];
+    let ws;
+    let organizationId;
+    let clientId;
+    let displayName;
+    let userRole;
+    let roomSessionId;
+    let connectionShouldBeOpen;
+    let connectionAttempt = 0;
+    let hasPassedOnRoomSessionId = false;
+    let getStatsBufferUsed = 0;
+
+    const connection = {
+        connected: false,
+        trace: (...args) => {
+            args.push(Date.now());
+
+            if (args[0] === "customEvent" && args[2].type === "roomSessionId") {
+                const oldRoomSessionIdValue = roomSessionId && roomSessionId[2].value.roomSessionId;
+                const newRoomSessionIdValue = args[2].value.roomSessionId;
+                roomSessionId = args;
+
+                if (
+                    hasPassedOnRoomSessionId &&
+                    newRoomSessionIdValue &&
+                    newRoomSessionIdValue !== oldRoomSessionIdValue
+                ) {
+                    // roomSessionId was already sent. It may have been reset to null, but anything after should be part of the same
+                    // session. Now it is something else, and we force a reconnect to start a new session
+                    if (ws) {
+                        ws.close();
+                        return;
+                    }
+                }
+                if (newRoomSessionIdValue) hasPassedOnRoomSessionId = true;
+            } else if (args[0] === "customEvent" && args[2].type === "clientId") {
+                clientId = args;
+            } else if (args[0] === "customEvent" && args[2].type === "organizationId") {
+                organizationId = args;
+            } else if (args[0] === "customEvent" && args[2].type === "displayName") {
+                displayName = args;
+            } else if (args[0] === "customEvent" && args[2].type === "userRole") {
+                userRole = args;
+            }
+
+            if (ws.readyState === WebSocket.OPEN) {
+                connectionAttempt = 0;
+                ws.send(JSON.stringify(args));
+            } 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);
+            }
+
+            // reconnect when closed by anything else than client
+            if (ws.readyState === WebSocket.CLOSED && connectionShouldBeOpen) {
+                setTimeout(() => {
+                    if (ws.readyState === WebSocket.CLOSED && connectionShouldBeOpen) {
+                        connection.connect();
+                    }
+                }, 1000 * connectionAttempt);
+            }
+        },
+        close: () => {
+            connectionShouldBeOpen = false;
+            if (ws) {
+                ws.close();
+            }
+        },
+        connect: () => {
+            connectionShouldBeOpen = true;
+            connectionAttempt += 1;
+            if (ws) {
+                ws.close();
+            }
+            connection.connected = true;
+            ws = new WebSocket(wsURL + window.location.pathname, RTCSTATS_PROTOCOL_VERSION);
+
+            ws.onerror = (e) => {
+                connection.connected = false;
+                logger.warn(`[RTCSTATS] WebSocket error`, e);
+            };
+            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
+                clientInfo.connectionNumber++;
+                ws.send(JSON.stringify(["clientInfo", null, clientInfo]));
+
+                if (organizationId) {
+                    ws.send(JSON.stringify(organizationId));
+                }
+
+                if (clientId) {
+                    ws.send(JSON.stringify(clientId));
+                }
+
+                if (roomSessionId) {
+                    ws.send(JSON.stringify(roomSessionId));
+                }
+                if (displayName) {
+                    ws.send(JSON.stringify(displayName));
+                }
+                if (userRole) {
+                    ws.send(JSON.stringify(userRole));
+                }
+
+                // send buffered events
+                while (buffer.length) {
+                    ws.send(JSON.stringify(buffer.shift()));
+                }
+                getStatsBufferUsed = 0;
+            };
+        },
+    };
+    connection.connect();
+    return connection;
+}
+
+const server = rtcStatsConnection("wss://rtcstats.srv.whereby.com" );
+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) => {
+        server.trace("customEvent", null, {
+            type,
+            value,
+        });
+    },
+    sendAudioMuted: (muted) => {
+        rtcStats.sendEvent("audio_muted", { muted });
+    },
+    sendVideoMuted: (muted) => {
+        rtcStats.sendEvent("video_muted", { muted });
+    },
+    server,
+};
+
+const adapter$4 = adapterRaw.default ?? adapterRaw;
+const logger$6 = new Logger();
+
+const browserName$2 = adapter$4.browserDetails.browser;
+const browserVersion$1 = adapter$4.browserDetails.version;
+
+function setCodecPreferenceSDP(sdp, vp9On, redOn) {
+    try {
+        const sdpObject = sdpTransform.parse(sdp);
+        if (Array.isArray(sdpObject?.media)) {
+            //audio
             const mediaAudio = sdpObject.media.find((m) => m.type === "audio");
             if (Array.isArray(mediaAudio?.rtp)) {
                 const rtp = mediaAudio.rtp;
@@ -2802,7 +3246,7 @@ function setCodecPreferenceSDP(sdp, vp9On, redOn) {
         const newSdp = sdpTransform.write(sdpObject);
         return newSdp;
     } catch (error) {
-        logger$7.error("setCodecPreferenceSDP error:", error);
+        logger$6.error("setCodecPreferenceSDP error:", error);
     }
 }
 
@@ -2855,7 +3299,7 @@ function replaceSSRCs(currentDescription, newDescription) {
 // https://bugzilla.mozilla.org/show_bug.cgi?id=1478685
 // filter out the mid rtp header extension
 function filterMidExtension(sdp) {
-    if (browserName$3 !== "safari" && (browserName$3 !== "firefox" || browserVersion$1 >= 63 || browserVersion$1 === 60)) {
+    if (browserName$2 !== "safari" && (browserName$2 !== "firefox" || browserVersion$1 >= 63 || browserVersion$1 === 60)) {
         return sdp;
     }
     return (
@@ -2876,7 +3320,7 @@ function filterMidExtension(sdp) {
 // https://bugzilla.mozilla.org/show_bug.cgi?id=1534673
 // Filter out a:msid-semantic header
 function filterMsidSemantic(sdp) {
-    if (browserName$3 !== "firefox") {
+    if (browserName$2 !== "firefox") {
         return sdp;
     }
     return (
@@ -2886,6 +3330,52 @@ function filterMsidSemantic(sdp) {
     );
 }
 
+// add SDP RTP header extension mapping
+function addExtMap(sdp, extmapUri, modifyAudio = false, modifyVideo = false) {
+    try {
+        const sdpObj = sdpTransform.parse(sdp);
+
+        // in case session level extmaps we skip modification
+        // TODO: handle it more properly
+        if (sdpObj?.ext?.length > 0) {
+            return sdp;
+        }
+
+        // if sdp string is faulty, and lib can't parse any m= lines we return it unmodified.
+        if (sdpObj?.media.length < 1) return sdp;
+
+        const allHeaderExtensions = sdpObj?.media.flatMap((section) => section.ext || []);
+        const extmapId =
+            allHeaderExtensions.find((ext) => ext.uri === extmapUri)?.value ||
+            [...new Set([0, 15, ...allHeaderExtensions.map((ext) => ext.value)])]
+                .sort((a, b) => a - b)
+                .find((n, i, arr) => n + 1 !== arr[i + 1]) + 1;
+
+        sdpObj.media.forEach((mediaSection) => {
+            if ((modifyAudio && mediaSection.type === "audio") || (modifyVideo && mediaSection.type === "video")) {
+                if (!mediaSection.ext?.find((e) => e.uri === extmapUri)) {
+                    if (Array.isArray(mediaSection.ext)) {
+                        mediaSection["ext"].push({ value: extmapId, uri: extmapUri });
+                    } else {
+                        mediaSection["ext"] = [{ value: extmapId, uri: extmapUri }];
+                    }
+                }
+            }
+        });
+        return sdpTransform.write(sdpObj);
+    } catch (error) {
+        console.error("Error during addAbsCaptureTimeExtMap: ", error);
+    }
+    return sdp;
+}
+
+// Add SDP RTP header extension mapping to abs-capture-time
+// a=extmap:9 http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time
+function addAbsCaptureTimeExtMap(sdp) {
+    const absCaptureTimeUri = "http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time";
+    return addExtMap(sdp, absCaptureTimeUri, true, true);
+}
+
 function isRelayed(pc) {
     return pc.getStats(null).then((result) => {
         let localCandidateType;
@@ -2949,7 +3439,8 @@ const MAXIMUM_TURN_BANDWIDTH_UNLIMITED = -1; // kbps;
 
 const MEDIA_JITTER_BUFFER_TARGET = 400; // milliseconds;
 
-const logger$6 = new Logger();
+const adapter$3 = adapterRaw.default ?? adapterRaw;
+const logger$5 = new Logger();
 
 class Session {
     constructor({ peerConnectionId, bandwidth, maximumTurnBandwidth, deprioritizeH264Encoding }) {
@@ -3124,7 +3615,7 @@ class Session {
                 return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
             },
             (e) => {
-                logger$6.warn("Could not set remote description from remote answer: ", e);
+                logger$5.warn("Could not set remote description from remote answer: ", e);
             }
         );
     }
@@ -3140,12 +3631,12 @@ class Session {
             if (this.pc.signalingState === "closed") {
                 return;
             }
-            if (adapter.browserDetails.browser === "safari" && candidate && candidate.candidate === "") {
+            if (adapter$3.browserDetails.browser === "safari" && candidate && candidate.candidate === "") {
                 // filter due to https://github.com/webrtcHacks/adapter/issues/863
                 return;
             }
             this.pc.addIceCandidate(candidate).catch((e) => {
-                logger$6.warn("Failed to add ICE candidate ('%s'): %s", candidate ? candidate.candidate : null, e);
+                logger$5.warn("Failed to add ICE candidate ('%s'): %s", candidate ? candidate.candidate : null, e);
             });
         });
     }
@@ -3167,7 +3658,7 @@ class Session {
             // do not handle state change events when we close the connection explicitly
             pc.close();
         } catch (e) {
-            logger$6.warn("failures during close of session", e);
+            logger$5.warn("failures during close of session", e);
             // we're not interested in errors from RTCPeerConnection.close()
         }
     }
@@ -3183,7 +3674,7 @@ class Session {
         const senders = pc.getSenders();
         function dbg(msg) {
             const tr = (t) => t && `id:${t.id},kind:${t.kind},state:${t.readyState}`;
-            logger$6.warn(
+            logger$5.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]))}`
@@ -3317,687 +3808,568 @@ class Session {
         });
     }
 
-    // no-signaling negotiation of bandwidth. Peer is NOT informed.
-    // Prefers using RTCRtpSender.setParameters if possible.
-    changeBandwidth(bandwidth) {
-        // don't renegotiate if bandwidth is already set.
-        if (bandwidth === this.bandwidth) {
-            return;
-        }
+    // no-signaling negotiation of bandwidth. Peer is NOT informed.
+    // Prefers using RTCRtpSender.setParameters if possible.
+    changeBandwidth(bandwidth) {
+        // don't renegotiate if bandwidth is already set.
+        if (bandwidth === this.bandwidth) {
+            return;
+        }
+
+        if (!this.canModifyPeerConnection()) {
+            this.pending.push(() => this.changeBandwidth(bandwidth));
+            return;
+        }
+
+        this.bandwidth = bandwidth;
+        if (!this.pc.localDescription || this.pc.localDescription.type === "") {
+            return;
+        }
+
+        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";
+            });
+    }
+}
+
+const adapter$2 = adapterRaw.default ?? adapterRaw;
+
+/**
+ * Detect mic issue which seems to happen on OSX when the computer is woken up and sleeping
+ * frequently. A browser restart fixes this.
+ *
+ * Should be called after the connection has been up for a while.
+ *
+ * @see Bug report {@link https://bugs.chromium.org/p/webrtc/issues/detail?id=4799}
+ */
+function detectMicrophoneNotWorking(pc) {
+    if (
+        adapter$2.browserDetails.browser !== "chrome" ||
+        adapter$2.browserDetails.browser < 58 || // legacy getStats is no longer supported.
+        pc.signalingState === "closed"
+    ) {
+        return Promise.resolve(false);
+    }
+    const sendingAudio = pc.getSenders().some((sender) => sender.track && sender.track.kind === "audio");
+    const receivingAudio = pc.getReceivers().some((receiver) => receiver.track && receiver.track.kind === "audio");
+    return pc.getStats(null).then((result) => {
+        let microphoneFailed = false;
+        result.forEach((report) => {
+            if (
+                report.type === "outbound-rtp" &&
+                (report.kind === "audio" || report.mediaType === "audio") &&
+                sendingAudio
+            ) {
+                if (report.bytesSent === 0) {
+                    microphoneFailed = "outbound";
+                }
+            } else if (
+                report.type === "inbound-rtp" &&
+                (report.kind === "audio" || report.mediaType === "audio") &&
+                receivingAudio
+            ) {
+                if (report.bytesReceived === 0) {
+                    microphoneFailed = "inbound";
+                }
+            }
+        });
+        return microphoneFailed;
+    });
+}
+
+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",
+};
+
+const CAMERA_STREAM_ID$1 = "0";
+
+const STREAM_TYPES = {
+    CAMERA: "camera",
+    SCREEN_SHARE: "screen_share",
+};
+
+class RtcStream {
+    constructor(id, type) {
+        assert$1.notEqual(id, undefined, "id is required");
+        assert$1.notEqual(type, undefined, "type is required");
+
+        this.id = "" + id;
+        this.type = type;
+
+        this.isEnabled = true;
+        this.hasSupportForAutoSuperSize = false;
+        this.isAudioEnabled = true;
+        this.isVideoEnabled = true;
+        this.status = TYPES.CONNECTING;
+    }
+
+    setup(stream) {
+        this.stream = stream;
+        this.streamId = stream.id;
+        this.setVideoEnabled(this.isVideoEnabled && stream.getVideoTracks().length > 0);
+        this.setAudioEnabled(this.isAudioEnabled && stream.getAudioTracks().length > 0);
+        return this;
+    }
+
+    setStatus(status) {
+        this.status = status;
+        return this;
+    }
 
-        if (!this.canModifyPeerConnection()) {
-            this.pending.push(() => this.changeBandwidth(bandwidth));
+    setVideoEnabled(isEnabled) {
+        this.isVideoEnabled = isEnabled;
+        if (!this.stream) {
             return;
         }
+        this.stream.getVideoTracks().forEach((track) => {
+            track.enabled = isEnabled;
+        });
+    }
 
-        this.bandwidth = bandwidth;
-        if (!this.pc.localDescription || this.pc.localDescription.type === "") {
+    setAudioEnabled(isEnabled) {
+        this.isAudioEnabled = isEnabled;
+        if (!this.stream) {
             return;
         }
+        this.stream.getAudioTracks().forEach((track) => {
+            track.enabled = isEnabled;
+        });
+    }
 
-        setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
+    static getCameraId() {
+        return CAMERA_STREAM_ID$1;
     }
 
-    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";
-            });
+    static getTypeFromId(id) {
+        assert$1.notEqual(id, undefined, "id is required");
+
+        const streamId = "" + id;
+        return streamId === CAMERA_STREAM_ID$1 ? STREAM_TYPES.CAMERA : STREAM_TYPES.SCREEN_SHARE;
     }
 }
 
-// transforms a maplike to an object. Mostly for getStats +
-// JSON.parse(JSON.stringify())
-function map2obj(m) {
-  if (!m.entries) {
-    return m;
-  }
-  var o = {};
-  m.forEach(function(v, k) {
-    o[k] = v;
-  });
-  return o;
-}
+const lowPixelCount = 320 * 180;
+const lowBitratePerPixel = 150000 / lowPixelCount;
+const highPixelCount = 1280 * 720;
+const highBitratePerPixel = 1000000 / highPixelCount;
+const bitrateChangePerPixel = (highBitratePerPixel - lowBitratePerPixel) / (highPixelCount - lowPixelCount);
 
-// apply a delta compression to the stats report. Reduces size by ~90%.
-// To reduce further, report keys could be compressed.
-function deltaCompression(oldStats, newStats) {
-  newStats = JSON.parse(JSON.stringify(newStats));
-  Object.keys(newStats).forEach(function(id) {
-    var report = newStats[id];
-    delete report.id;
-    if (!oldStats[id]) {
-      return;
-    }
-    Object.keys(report).forEach(function(name) {
-      if (report[name] === oldStats[id][name]) {
-        delete newStats[id][name];
-      }
-      if (Object.keys(report).length === 0) {
-        delete newStats[id];
-      } else if (Object.keys(report).length === 1 && report.timestamp) {
-        delete newStats[id];
-      }
-    });
-  });
+// calculates a bitrate for a given resolution+frameRate
+function getOptimalBitrate(width, height, frameRate) {
+    let targetPixelCount = width * height;
+    if (targetPixelCount < lowPixelCount) targetPixelCount = lowPixelCount;
+    if (targetPixelCount > highPixelCount) targetPixelCount = highPixelCount;
 
-  var timestamp = -Infinity;
-  Object.keys(newStats).forEach(function(id) {
-    var report = newStats[id];
-    if (report.timestamp > timestamp) {
-      timestamp = report.timestamp;
-    }
-  });
-  Object.keys(newStats).forEach(function(id) {
-    var report = newStats[id];
-    if (report.timestamp === timestamp) {
-      report.timestamp = 0;
+    let targetBitratePerPixel = lowBitratePerPixel;
+    if (targetPixelCount > highPixelCount) targetBitratePerPixel = highBitratePerPixel;
+    else if (targetPixelCount > lowPixelCount) {
+        targetBitratePerPixel += (targetPixelCount - lowPixelCount) * bitrateChangePerPixel;
     }
-  });
-  newStats.timestamp = timestamp;
-  return newStats;
-}
 
-function dumpStream(stream) {
-  return {
-    id: stream.id,
-    tracks: stream.getTracks().map(function(track) {
-      return {
-        id: track.id,                 // unique identifier (GUID) for the track
-        kind: track.kind,             // `audio` or `video`
-        label: track.label,           // identified the track source
-        enabled: track.enabled,       // application can control it
-        muted: track.muted,           // application cannot control it (read-only)
-        readyState: track.readyState, // `live` or `ended`
-      };
-    }),
-  };
-}
+    // we use the actual resolution for the target bitrate
+    let targetBitrate = width * height * targetBitratePerPixel;
 
-/*
-function filterBoringStats(results) {
-  Object.keys(results).forEach(function(id) {
-    switch (results[id].type) {
-      case 'certificate':
-      case 'codec':
-        delete results[id];
-        break;
-      default:
-        // noop
-    }
-  });
-  return results;
-}
+    // adjust bitrate down a bit if reduced framerate
+    if (frameRate <= 15) targetBitrate = targetBitrate * 0.7;
+    else if (frameRate <= 24) targetBitrate = targetBitrate * 0.9;
 
-function removeTimestamps(results) {
-  // FIXME: does not work in FF since the timestamp can't be deleted.
-  Object.keys(results).forEach(function(id) {
-    delete results[id].timestamp;
-  });
-  return results;
+    return targetBitrate;
 }
-*/
 
-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;
-    }
-    if (prefix === 'webkit' && isEdge) {
-      // dont wrap webkitRTCPeerconnection in Edge.
-      return;
-    }
-    var origPeerConnection = window[prefix + 'RTCPeerConnection'];
-    var peerconnection = function(config, constraints) {
-      var pc = new origPeerConnection(config, constraints);
-      var id = 'PC_' + peerconnectioncounter++;
-      pc.__rtcStatsId = id;
+// 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:]";
 
-      if (!config) {
-        config = { nullConfig: true };
-      }
+const boundry = (options) =>
+    options && options.includeBoundaries ? `(?:(?<=\\s|^)(?=${word})|(?<=${word})(?=\\s|$))` : "";
 
-      config = JSON.parse(JSON.stringify(config)); // deepcopy
-      // don't log credentials
-      ((config && config.iceServers) || []).forEach(function(server) {
-        delete server.credential;
-      });
+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}";
 
-      if (isFirefox) {
-        config.browserType = 'moz';
-      } else if (isEdge) {
-        config.browserType = 'edge';
-      } else {
-        config.browserType = 'webkit';
-      }
+const v6segment = "[a-fA-F\\d]{1,4}";
 
-      trace('create', id, config);
-      // TODO: do we want to log constraints here? They are chrome-proprietary.
-      // http://stackoverflow.com/questions/31003928/what-do-each-of-these-experimental-goog-rtcpeerconnectionconstraints-do
-      if (constraints) {
-        trace('constraints', id, constraints);
-      }
+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();
 
-      pc.addEventListener('icecandidate', function(e) {
-        trace('onicecandidate', id, e.candidate);
-      });
-      pc.addEventListener('addstream', function(e) {
-        trace('onaddstream', id, e.stream.id + ' ' + e.stream.getTracks().map(function(t) { return t.kind + ':' + t.id; }));
-      });
-      pc.addEventListener('track', function(e) {
-        trace('ontrack', id, e.track.kind + ':' + e.track.id + ' ' + e.streams.map(function(stream) { return 'stream:' + stream.id; }));
-      });
-      pc.addEventListener('removestream', function(e) {
-        trace('onremovestream', id, e.stream.id + ' ' + e.stream.getTracks().map(function(t) { return t.kind + ':' + t.id; }));
-      });
-      pc.addEventListener('signalingstatechange', function() {
-        trace('onsignalingstatechange', id, pc.signalingState);
-      });
-      pc.addEventListener('iceconnectionstatechange', function() {
-        trace('oniceconnectionstatechange', id, pc.iceConnectionState);
-      });
-      pc.addEventListener('icegatheringstatechange', function() {
-        trace('onicegatheringstatechange', id, pc.iceGatheringState);
-      });
-      pc.addEventListener('connectionstatechange', function() {
-        trace('onconnectionstatechange', id, pc.connectionState);
-      });
-      pc.addEventListener('negotiationneeded', function() {
-        trace('onnegotiationneeded', id, undefined);
-      });
-      pc.addEventListener('datachannel', function(event) {
-        trace('ondatachannel', id, [event.channel.id, event.channel.label]);
-      });
+// 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"
+          );
 
-      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(prevById[id] || {}, now));
-          prevById[id] = base;
-        });
-      };
-      // TODO: do we want one big interval and all peerconnections
-      //    queried in that or one setInterval per PC?
-      //    we have to collect results anyway so...
-      if (!isEdge && getStatsInterval) {
-        var interval = window.setInterval(function() {
-          if (pc.signalingState === 'closed') {
-            window.clearInterval(interval);
-            return;
-          }
-          getStats();
-        }, getStatsInterval);
-      }
-      if (!isEdge) {
-        pc.addEventListener('connectionstatechange', function() {
-          if (pc.connectionState === 'connected' || pc.connectionState === 'failed') {
-            getStats();
-          }
-        });
-      }
-      return pc;
-    };
+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");
 
-    ['createDataChannel', 'close'].forEach(function(method) {
-      var nativeMethod = origPeerConnection.prototype[method];
-      if (nativeMethod) {
-        origPeerConnection.prototype[method] = function() {
-          trace(method, this.__rtcStatsId, arguments);
-          return nativeMethod.apply(this, arguments);
-        };
-      }
-    });
+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",
+};
 
-    ['addStream', 'removeStream'].forEach(function(method) {
-      var nativeMethod = origPeerConnection.prototype[method];
-      if (nativeMethod) {
-        origPeerConnection.prototype[method] = function() {
-          var stream = arguments[0];
-          var streamInfo = stream.getTracks().map(function(t) {
-            return t.kind + ':' + t.id;
-          }).join(',');
+const adapter$1 = adapterRaw.default ?? adapterRaw;
+const logger$4 = new Logger();
 
-          trace(method, this.__rtcStatsId, stream.id + ' ' + streamInfo);
-          return nativeMethod.apply(this, arguments);
-        };
-      }
-    });
+const ICE_PUBLIC_IP_GATHERING_TIMEOUT = 3 * 1000;
+const CAMERA_STREAM_ID = RtcStream.getCameraId();
+const browserName$1 = adapter$1.browserDetails.browser;
+const browserVersion = adapter$1.browserDetails.version;
 
-    ['addTrack'].forEach(function(method) {
-      var nativeMethod = origPeerConnection.prototype[method];
-      if (nativeMethod) {
-        origPeerConnection.prototype[method] = function() {
-          var track = arguments[0];
-          var streams = [].slice.call(arguments, 1);
-          trace(method, this.__rtcStatsId, track.kind + ':' + track.id + ' ' + (streams.map(function(s) { return 'stream:' + s.id; }).join(';') || '-'));
-          return nativeMethod.apply(this, arguments);
-        };
-      }
-    });
+if (browserName$1 === "firefox") {
+    adapter$1.browserShim.shimGetDisplayMedia(window, "screen");
+}
 
-    ['removeTrack'].forEach(function(method) {
-      var nativeMethod = origPeerConnection.prototype[method];
-      if (nativeMethod) {
-        origPeerConnection.prototype[method] = function() {
-          var track = arguments[0].track;
-          trace(method, this.__rtcStatsId, track ? track.kind + ':' + track.id : 'null');
-          return nativeMethod.apply(this, arguments);
-        };
-      }
+let unloading$1 = false;
+if (browserName$1 === "chrome") {
+    window.document.addEventListener("beforeunload", () => {
+        unloading$1 = true;
     });
+}
 
-    ['createOffer', 'createAnswer'].forEach(function(method) {
-      var nativeMethod = origPeerConnection.prototype[method];
-      if (nativeMethod) {
-        origPeerConnection.prototype[method] = function() {
-          var rtcStatsId = this.__rtcStatsId;
-          var args = arguments;
-          var opts;
-          if (arguments.length === 1 && typeof arguments[0] === 'object') {
-            opts = arguments[0];
-          } else if (arguments.length === 3 && typeof arguments[2] === 'object') {
-            opts = arguments[2];
-          }
-          trace(method, this.__rtcStatsId, opts);
-          return nativeMethod.apply(this, opts ? [opts] : undefined)
-          .then(function(description) {
-            trace(method + 'OnSuccess', rtcStatsId, description);
-            if (args.length > 0 && typeof args[0] === 'function') {
-              args[0].apply(null, [description]);
-              return undefined;
-            }
-            return description;
-          }, function(err) {
-            trace(method + 'OnFailure', rtcStatsId, err.toString());
-            if (args.length > 1 && typeof args[1] === 'function') {
-              args[1].apply(null, [err]);
-              return;
-            }
-            throw err;
-          });
-        };
-      }
-    });
+class P2pRtcManager {
+    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");
+        assert$1.ok(serverSocket instanceof ServerSocket, "serverSocket is required");
+        assert$1.ok(webrtcProvider, "webrtcProvider is required");
 
-    ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate'].forEach(function(method) {
-      var nativeMethod = origPeerConnection.prototype[method];
-      if (nativeMethod) {
-        origPeerConnection.prototype[method] = function() {
-          var rtcStatsId = this.__rtcStatsId;
-          var args = arguments;
-          trace(method, this.__rtcStatsId, args[0]);
-          return nativeMethod.apply(this, [args[0]])
-          .then(function() {
-            trace(method + 'OnSuccess', rtcStatsId, undefined);
-            if (args.length >= 2 && typeof args[1] === 'function') {
-              args[1].apply(null, []);
-              return undefined;
-            }
-            return undefined;
-          }, function(err) {
-            trace(method + 'OnFailure', rtcStatsId, err.toString());
-            if (args.length >= 3 && typeof args[2] === 'function') {
-              args[2].apply(null, [err]);
-              return undefined;
-            }
-            throw err;
-          });
-        };
-      }
-    });
+        const { name, session, iceServers, sfuServer, mediaserverConfigTtlSeconds } = room;
 
-    // wrap static methods. Currently just generateCertificate.
-    if (origPeerConnection.generateCertificate) {
-      Object.defineProperty(peerconnection, 'generateCertificate', {
-        get: function() {
-          return arguments.length ?
-              origPeerConnection.generateCertificate.apply(null, arguments)
-              : origPeerConnection.generateCertificate;
-        },
-      });
-    }
-    window[prefix + 'RTCPeerConnection'] = peerconnection;
-    window[prefix + 'RTCPeerConnection'].prototype = origPeerConnection.prototype;
-  });
+        this._selfId = selfId;
+        this._roomName = name;
+        this._roomSessionId = session && session.id;
+        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._isAudioOnlyMode = false;
 
-  // getUserMedia wrappers
-  prefixesToWrap.forEach(function(prefix) {
-    var name = prefix + (prefix.length ? 'GetUserMedia' : 'getUserMedia');
-    if (!navigator[name]) {
-      return;
-    }
-    var origGetUserMedia = navigator[name].bind(navigator);
-    var gum = function() {
-      trace('getUserMedia', null, arguments[0]);
-      var cb = arguments[1];
-      var eb = arguments[2];
-      origGetUserMedia(arguments[0],
-        function(stream) {
-          // we log the stream id, track ids and tracks readystate since that is ended GUM fails
-          // to acquire the cam (in chrome)
-          trace('getUserMediaOnSuccess', null, dumpStream(stream));
-          if (cb) {
-            cb(stream);
-          }
-        },
-        function(err) {
-          trace('getUserMediaOnFailure', null, err.name);
-          if (eb) {
-            eb(err);
-          }
-        }
-      );
-    };
-    navigator[name] = gum.bind(navigator);
-  });
+        this.offerOptions = { offerToReceiveAudio: true, offerToReceiveVideo: true };
+        this._pendingActionsForConnectedPeerConnections = [];
 
-  if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
-    var origGetUserMedia = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
-    var gum = function() {
-      trace('navigator.mediaDevices.getUserMedia', null, arguments[0]);
-      return origGetUserMedia.apply(navigator.mediaDevices, arguments)
-      .then(function(stream) {
-        trace('navigator.mediaDevices.getUserMediaOnSuccess', null, dumpStream(stream));
-        return stream;
-      }, function(err) {
-        trace('navigator.mediaDevices.getUserMediaOnFailure', null, err.name);
-        return Promise.reject(err);
-      });
-    };
-    navigator.mediaDevices.getUserMedia = gum.bind(navigator.mediaDevices);
-  }
+        this._audioTrackOnEnded = () => {
+            // There are a couple of reasons the microphone could stop working.
+            // One of them is getting unplugged. The other is the Chrome audio
+            // process crashing. The third is the tab being closed.
+            // https://bugs.chromium.org/p/chromium/issues/detail?id=1050008
+            rtcStats.sendEvent("audio_ended", { unloading: unloading$1 });
+            this._emit(rtcManagerEvents.MICROPHONE_STOPPED_WORKING, {});
+        };
+
+        this._updateAndScheduleMediaServersRefresh({
+            sfuServer,
+            iceServers: iceServers.iceServers || [],
+            mediaserverConfigTtlSeconds,
+        });
 
-  // getDisplayMedia
-  if (navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia) {
-    var origGetDisplayMedia = navigator.mediaDevices.getDisplayMedia.bind(navigator.mediaDevices);
-    var gdm = function() {
-      trace('navigator.mediaDevices.getDisplayMedia', null, arguments[0]);
-      return origGetDisplayMedia.apply(navigator.mediaDevices, arguments)
-      .then(function(stream) {
-        trace('navigator.mediaDevices.getDisplayMediaOnSuccess', null, dumpStream(stream));
-        return stream;
-      }, function(err) {
-        trace('navigator.mediaDevices.getDisplayMediaOnFailure', null, err.name);
-        return Promise.reject(err);
-      });
-    };
-    navigator.mediaDevices.getDisplayMedia = gdm.bind(navigator.mediaDevices);
-  }
+        this.totalSessionsCreated = 0;
+    }
 
-  // TODO: are there events defined on MST that would allow us to listen when enabled was set?
-  //    no :-(
-  /*
-  Object.defineProperty(MediaStreamTrack.prototype, 'enabled', {
-    set: function(value) {
-      trace('MediaStreamTrackEnable', this, value);
+    numberOfPeerconnections() {
+        return Object.keys(this.peerConnections).length;
     }
-  });
-  */
 
-  return {
-    resetDelta() {
-      prevById = {};
+    isInitializedWith({ selfId, roomName, isSfu }) {
+        return this._selfId === selfId && this._roomName === roomName && isSfu === !!this._sfuServer;
     }
-  }
 
-};
+    supportsScreenShareAudio() {
+        return true;
+    }
 
-var rtcstats$1 = /*@__PURE__*/getDefaultExportFromCjs(rtcstats);
+    maybeRestrictRelayBandwidth(session) {
+        session.maybeRestrictRelayBandwidth();
+    }
 
-// ensure adapter is loaded first.
+    addNewStream(streamId, stream) {
+        if (stream === this.localStreams[streamId]) {
+            // this can happen after reconnect. We do not want to add the stream to the
+            // peerconnection again.
+            return;
+        }
 
-const RTCSTATS_PROTOCOL_VERSION = "1.0";
+        this._addLocalStream(streamId, stream);
 
-// 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;
+        if (streamId === CAMERA_STREAM_ID) {
+            this._addStreamToPeerConnections(stream);
+            const [audioTrack] = stream.getAudioTracks();
+            if (audioTrack) {
+                this._startMonitoringAudioTrack(audioTrack);
+            }
 
-const clientInfo = {
-    id: v4$1(), // shared id across rtcstats reconnects
-    connectionNumber: 0,
-};
+            // This should not be needed, but checking nonetheless
+            if (this._localStreamDeregisterFunction) {
+                this._localStreamDeregisterFunction();
+                this._localStreamDeregisterFunction = null;
+            }
 
-const noop = () => {};
-let resetDelta = noop;
+            const localStreamHandler = (e) => {
+                const { enable, track } = e.detail;
+                this._handleStopOrResumeVideo({ enable, track });
+            };
 
-// Inlined version of rtcstats/trace-ws with improved disconnect handling.
-function rtcStatsConnection(wsURL, logger = console) {
-    const buffer = [];
-    let ws;
-    let organizationId;
-    let clientId;
-    let displayName;
-    let userRole;
-    let roomSessionId;
-    let connectionShouldBeOpen;
-    let connectionAttempt = 0;
-    let hasPassedOnRoomSessionId = false;
-    let getStatsBufferUsed = 0;
+            stream.addEventListener("stopresumevideo", localStreamHandler);
+            this._localStreamDeregisterFunction = () => {
+                stream.removeEventListener("stopresumevideo", localStreamHandler);
+            };
 
-    const connection = {
-        connected: false,
-        trace: (...args) => {
-            args.push(Date.now());
+            return;
+        }
 
-            if (args[0] === "customEvent" && args[2].type === "roomSessionId") {
-                const oldRoomSessionIdValue = roomSessionId && roomSessionId[2].value.roomSessionId;
-                const newRoomSessionIdValue = args[2].value.roomSessionId;
-                roomSessionId = args;
+        // at this point it is clearly a screensharing stream.
+        this._screenshareVideoTrackIds.push(stream.getVideoTracks()[0].id);
+        this._shareScreen(streamId, stream);
+        return;
+    }
 
-                if (
-                    hasPassedOnRoomSessionId &&
-                    newRoomSessionIdValue &&
-                    newRoomSessionIdValue !== oldRoomSessionIdValue
-                ) {
-                    // roomSessionId was already sent. It may have been reset to null, but anything after should be part of the same
-                    // session. Now it is something else, and we force a reconnect to start a new session
-                    if (ws) {
-                        ws.close();
-                        return;
-                    }
-                }
-                if (newRoomSessionIdValue) hasPassedOnRoomSessionId = true;
-            } else if (args[0] === "customEvent" && args[2].type === "clientId") {
-                clientId = args;
-            } else if (args[0] === "customEvent" && args[2].type === "organizationId") {
-                organizationId = args;
-            } else if (args[0] === "customEvent" && args[2].type === "displayName") {
-                displayName = args;
-            } else if (args[0] === "customEvent" && args[2].type === "userRole") {
-                userRole = args;
-            }
+    replaceTrack(oldTrack, newTrack) {
+        if (oldTrack && oldTrack.kind === "audio") {
+            this._stopMonitoringAudioTrack(oldTrack);
+        }
+        if (newTrack && newTrack.kind === "audio") {
+            this._startMonitoringAudioTrack(newTrack);
+        }
+        return this._replaceTrackToPeerConnections(oldTrack, newTrack);
+    }
 
-            if (ws.readyState === WebSocket.OPEN) {
-                connectionAttempt = 0;
-                ws.send(JSON.stringify(args));
-            } 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);
-            }
+    accept({ clientId, shouldAddLocalVideo }) {
+        return this.acceptNewStream({ streamId: clientId, clientId, shouldAddLocalVideo });
+    }
 
-            // reconnect when closed by anything else than client
-            if (ws.readyState === WebSocket.CLOSED && connectionShouldBeOpen) {
-                setTimeout(() => {
-                    if (ws.readyState === WebSocket.CLOSED && connectionShouldBeOpen) {
-                        connection.connect();
-                    }
-                }, 1000 * connectionAttempt);
-            }
-        },
-        close: () => {
-            connectionShouldBeOpen = false;
-            if (ws) {
-                ws.close();
-            }
-        },
-        connect: () => {
-            connectionShouldBeOpen = true;
-            connectionAttempt += 1;
-            if (ws) {
-                ws.close();
-            }
-            connection.connected = true;
-            ws = new WebSocket(wsURL + window.location.pathname, RTCSTATS_PROTOCOL_VERSION);
+    disconnectAll() {
+        Object.keys(this.peerConnections).forEach((peerConnectionId) => {
+            this.disconnect(peerConnectionId);
+        });
+        this.peerConnections = {};
+        this._socketListenerDeregisterFunctions.forEach((func) => {
+            func();
+        });
+        this._socketListenerDeregisterFunctions = [];
 
-            ws.onerror = (e) => {
-                connection.connected = false;
-                logger.warn(`[RTCSTATS] WebSocket error`, e);
-            };
-            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
-                clientInfo.connectionNumber++;
-                ws.send(JSON.stringify(["clientInfo", null, clientInfo]));
+        if (this._localStreamDeregisterFunction) {
+            this._localStreamDeregisterFunction();
+            this._localStreamDeregisterFunction = null;
+        }
+    }
 
-                if (organizationId) {
-                    ws.send(JSON.stringify(organizationId));
+    /* the Chrome audio process crashed (probably?)
+     * try to fix it. Constraints are the audio device constraints
+     * used in getUserMedia.
+     */
+    fixChromeAudio(constraints) {
+        if (browserName$1 !== "chrome") {
+            return;
+        }
+        const localStream = this._getLocalCameraStream();
+        const audioTrack = localStream.getAudioTracks()[0];
+        if (!audioTrack || audioTrack.readyState !== "ended") {
+            return;
+        }
+        return navigator.mediaDevices.getUserMedia({ audio: constraints }).then((stream) => {
+            const track = stream.getAudioTracks()[0];
+            track.enabled = audioTrack.enabled; // retain mute state and don't accidentally unmute.
+            localStream.removeTrack(audioTrack); // remove the old track.
+            localStream.addTrack(track); // add the new track.
+            return this.replaceTrack(audioTrack, track);
+        });
+    }
+
+    setupSocketListeners() {
+        this._socketListenerDeregisterFunctions = [
+            () => this._clearMediaServersRefresh(),
+
+            this._serverSocket.on(PROTOCOL_RESPONSES.MEDIASERVER_CONFIG, (data) => {
+                if (data.error) {
+                    logger$4.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
+                    return;
                 }
+                this._updateAndScheduleMediaServersRefresh(data);
+            }),
 
-                if (clientId) {
-                    ws.send(JSON.stringify(clientId));
+            this._serverSocket.on(RELAY_MESSAGES.READY_TO_RECEIVE_OFFER, (data) => {
+                this._connect(data.clientId);
+            }),
+
+            this._serverSocket.on(RELAY_MESSAGES.ICE_CANDIDATE, (data) => {
+                const session = this._getSession(data.clientId);
+                if (!session) {
+                    logger$4.warn("No RTCPeerConnection on ICE_CANDIDATE", data);
+                    return;
+                }
+                session.addIceCandidate(data.message);
+            }),
+
+            this._serverSocket.on(RELAY_MESSAGES.ICE_END_OF_CANDIDATES, (data) => {
+                const session = this._getSession(data.clientId);
+                if (!session) {
+                    logger$4.warn("No RTCPeerConnection on ICE_END_OF_CANDIDATES", data);
+                    return;
                 }
+                session.addIceCandidate(null);
+            }),
 
-                if (roomSessionId) {
-                    ws.send(JSON.stringify(roomSessionId));
-                }
-                if (displayName) {
-                    ws.send(JSON.stringify(displayName));
-                }
-                if (userRole) {
-                    ws.send(JSON.stringify(userRole));
+            // when a new SDP offer is received from another client
+            this._serverSocket.on(RELAY_MESSAGES.SDP_OFFER, (data) => {
+                const session = this._getSession(data.clientId);
+                if (!session) {
+                    logger$4.warn("No RTCPeerConnection on SDP_OFFER", data);
+                    return;
                 }
+                const offer = this._transformIncomingSdp(data.message, session.pc);
+                session.handleOffer(offer).then((answer) => {
+                    this._emitServerEvent(RELAY_MESSAGES.SDP_ANSWER, {
+                        receiverId: data.clientId,
+                        message: this._transformOutgoingSdp(answer),
+                    });
+                });
+            }),
 
-                // send buffered events
-                while (buffer.length) {
-                    ws.send(JSON.stringify(buffer.shift()));
+            // when a new SDP answer is received from another client
+            this._serverSocket.on(RELAY_MESSAGES.SDP_ANSWER, (data) => {
+                const session = this._getSession(data.clientId);
+                if (!session) {
+                    logger$4.warn("No RTCPeerConnection on SDP_ANSWER", data);
+                    return;
                 }
-                getStatsBufferUsed = 0;
-            };
-        },
-    };
-    connection.connect();
-    return connection;
-}
+                const answer = this._transformIncomingSdp(data.message, session.pc);
+                session.handleAnswer(answer);
+            }),
 
-const server = rtcStatsConnection("wss://rtcstats.srv.whereby.com" );
-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;
+            // 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 rtcStats = {
-    sendEvent: (type, value) => {
-        server.trace("customEvent", null, {
-            type,
-            value,
-        });
-    },
-    sendAudioMuted: (muted) => {
-        rtcStats.sendEvent("audio_muted", { muted });
-    },
-    sendVideoMuted: (muted) => {
-        rtcStats.sendEvent("video_muted", { muted });
-    },
-    server,
-};
+                const screenShareStreamId = Object.keys(this.localStreams).find((id) => id !== CAMERA_STREAM_ID);
+                if (!screenShareStreamId) {
+                    return;
+                }
 
-const logger$5 = new Logger();
+                const screenshareStream = this.localStreams[screenShareStreamId];
+                if (!screenshareStream) {
+                    logger$4.warn("screenshare stream %s not found", screenShareStreamId);
+                    return;
+                }
 
-const CAMERA_STREAM_ID$1 = RtcStream.getCameraId();
-const browserName$2 = adapter.browserDetails.browser;
-const browserVersion = adapter.browserDetails.version;
+                const hasAudioTrack = screenshareStream.getAudioTracks().length > 0;
 
-if (browserName$2 === "firefox") {
-    adapter.browserShim.shimGetDisplayMedia(window, "screen");
-}
+                this._emitServerEvent(PROTOCOL_REQUESTS.START_SCREENSHARE, {
+                    streamId: screenShareStreamId,
+                    hasAudioTrack,
+                });
+            }),
+        ];
+    }
 
-let unloading$1 = false;
-if (browserName$2 === "chrome") {
-    window.document.addEventListener("beforeunload", () => {
-        unloading$1 = true;
-    });
-}
+    sendAudioMutedStats(muted) {
+        rtcStats.sendEvent("audio_muted", { muted });
+    }
 
-class BaseRtcManager {
-    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");
-        assert$1.ok(serverSocket instanceof ServerSocket, "serverSocket is required");
-        assert$1.ok(webrtcProvider, "webrtcProvider is required");
+    sendVideoMutedStats(muted) {
+        rtcStats.sendEvent("video_muted", { muted });
+    }
 
-        const { name, session, iceServers, sfuServer, mediaserverConfigTtlSeconds } = room;
+    sendStatsCustomEvent(eventName, data) {
+        rtcStats.sendEvent(eventName, data);
+    }
 
-        this._selfId = selfId;
-        this._roomName = name;
-        this._roomSessionId = session && session.id;
-        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._isAudioOnlyMode = false;
+    rtcStatsDisconnect() {
+        rtcStats.server.close();
+    }
 
-        this.offerOptions = { offerToReceiveAudio: true, offerToReceiveVideo: true };
-        this._pendingActionsForConnectedPeerConnections = [];
+    rtcStatsReconnect() {
+        if (!rtcStats.server.connected) {
+            rtcStats.server.connect();
+        }
+    }
 
-        this._audioTrackOnEnded = () => {
-            // There are a couple of reasons the microphone could stop working.
-            // One of them is getting unplugged. The other is the Chrome audio
-            // process crashing. The third is the tab being closed.
-            // https://bugs.chromium.org/p/chromium/issues/detail?id=1050008
-            rtcStats.sendEvent("audio_ended", { unloading: unloading$1 });
-            this._emit(rtcManagerEvents.MICROPHONE_STOPPED_WORKING, {});
-        };
+    setAudioOnly(audioOnly) {
+        this._isAudioOnlyMode = audioOnly;
 
-        this._updateAndScheduleMediaServersRefresh({
-            sfuServer,
-            iceServers: iceServers.iceServers || [],
-            mediaserverConfigTtlSeconds,
+        this._forEachPeerConnection((session) => {
+            if (session.hasConnectedPeerConnection()) {
+                this._withForcedRenegotiation(session, () =>
+                    session.setAudioOnly(this._isAudioOnlyMode, this._screenshareVideoTrackIds)
+                );
+            }
         });
-
-        this.totalSessionsCreated = 0;
     }
 
-    numberOfPeerconnections() {
-        return Object.keys(this.peerConnections).length;
+    setRemoteScreenshareVideoTrackIds(remoteScreenshareVideoTrackIds = []) {
+        const localScreenshareStream = this._getFirstLocalNonCameraStream();
+
+        this._screenshareVideoTrackIds = [
+            ...(localScreenshareStream?.track ? [localScreenshareStream.track.id] : []),
+            ...remoteScreenshareVideoTrackIds,
+        ];
     }
 
-    numberOfRemotePeers() {
-        return Object.values(this.peerConnections).filter((session) => session.clientId !== this._selfId).length;
+    setRoomSessionId(roomSessionId) {
+        this._roomSessionId = roomSessionId;
     }
 
     _setConnectionStatus(session, newStatus, clientId) {
@@ -4040,7 +4412,7 @@ class BaseRtcManager {
                 receiver.playoutDelayHint = MEDIA_JITTER_BUFFER_TARGET / 1000; // seconds
             });
         } catch (error) {
-            logger$5.error("Error during setting jitter buffer target:", error);
+            logger$4.error("Error during setting jitter buffer target:", error);
         }
     }
 
@@ -4052,14 +4424,6 @@ class BaseRtcManager {
         this._emitter.emit(eventName, data);
     }
 
-    isInitializedWith({ selfId, roomName, isSfu }) {
-        return this._selfId === selfId && this._roomName === roomName && isSfu === !!this._sfuServer;
-    }
-
-    supportsScreenShareAudio() {
-        return true;
-    }
-
     _addEnabledLocalStreamId(streamId) {
         this.enabledLocalStreamIds.push(streamId);
     }
@@ -4085,7 +4449,7 @@ class BaseRtcManager {
             // Some macs + ios devices have troubles using h264 encoder since safari 14
             // this will make them encode VP8 instead if available
             const deprioritizeH264Encoding =
-                browserName$2 === "safari" && browserVersion >= 14 && this._features.deprioritizeH264OnSafari;
+                browserName$1 === "safari" && browserVersion >= 14 && this._features.deprioritizeH264OnSafari;
 
             this.peerConnections[peerConnectionId] = session = new Session({
                 peerConnectionId,
@@ -4102,11 +4466,11 @@ class BaseRtcManager {
     }
 
     _getLocalCameraStream() {
-        return this.localStreams[CAMERA_STREAM_ID$1];
+        return this.localStreams[CAMERA_STREAM_ID];
     }
 
     _getNonLocalCameraStreamIds() {
-        return Object.keys(this.localStreams).filter((streamId) => streamId !== CAMERA_STREAM_ID$1);
+        return Object.keys(this.localStreams).filter((streamId) => streamId !== CAMERA_STREAM_ID);
     }
 
     _isScreensharingLocally() {
@@ -4135,7 +4499,7 @@ class BaseRtcManager {
         }
         const session = this._getOrCreateSession(peerConnectionId, initialBandwidth);
         const constraints = { optional: [] };
-        if (browserName$2 === "chrome") {
+        if (browserName$1 === "chrome") {
             constraints.optional.push({
                 googCpuOveruseDetection: true,
             });
@@ -4179,7 +4543,7 @@ class BaseRtcManager {
             }
         }
 
-        if (browserName$2 === "chrome") {
+        if (browserName$1 === "chrome") {
             peerConnectionConfig.sdpSemantics = "unified-plan";
         }
 
@@ -4246,7 +4610,7 @@ class BaseRtcManager {
                     if (
                         !session.wasEverConnected &&
                         (pc.iceConnectionState.match(/connected|completed/) ||
-                            (browserName$2 === "chrome" && pc.localDescription && pc.localDescription.type === "answer"))
+                            (browserName$1 === "chrome" && pc.localDescription && pc.localDescription.type === "answer"))
                     ) {
                         session.wasEverConnected = true;
                         if (this._features.bandwidth !== "false") {
@@ -4324,7 +4688,7 @@ class BaseRtcManager {
             }
         };
 
-        const localCameraStream = this.localStreams[CAMERA_STREAM_ID$1];
+        const localCameraStream = this.localStreams[CAMERA_STREAM_ID];
         if (shouldAddLocalVideo && localCameraStream) {
             session.addStream(localCameraStream);
         }
@@ -4333,7 +4697,7 @@ class BaseRtcManager {
         // added in a separate session/peerConnection by SfuV2RtcManager
         if (shouldAddLocalVideo) {
             Object.keys(this.localStreams).forEach((id) => {
-                if (id === CAMERA_STREAM_ID$1) {
+                if (id === CAMERA_STREAM_ID) {
                     return;
                 }
                 const screenshareStream = this.localStreams[id];
@@ -4361,7 +4725,7 @@ class BaseRtcManager {
     _cleanup(peerConnectionId) {
         const session = this._getSession(peerConnectionId);
         if (!session) {
-            logger$5.warn("No RTCPeerConnection in RTCManager.disconnect()", peerConnectionId);
+            logger$4.warn("No RTCPeerConnection in RTCManager.disconnect()", peerConnectionId);
             return;
         }
         session.close();
@@ -4369,8 +4733,7 @@ class BaseRtcManager {
     }
 
     _forEachPeerConnection(func) {
-        Object.keys(this.peerConnections).forEach((peerConnectionId) => {
-            const peerConnection = this.peerConnections[peerConnectionId];
+        Object.values(this.peerConnections).forEach((peerConnection) => {
             func(peerConnection);
         });
     }
@@ -4391,10 +4754,10 @@ class BaseRtcManager {
         const promises = [];
         this._forEachPeerConnection((session) => {
             if (!session.hasConnectedPeerConnection()) {
-                logger$5.info("Session doesn't have a connected PeerConnection, adding pending action!");
+                logger$4.info("Session doesn't have a connected PeerConnection, adding pending action!");
                 const pendingActions = this._pendingActionsForConnectedPeerConnections;
                 if (!pendingActions) {
-                    logger$5.warn(
+                    logger$4.warn(
                         `No pending action is created to repalce track, because the pending actions array is null`
                     );
                     return;
@@ -4403,7 +4766,7 @@ class BaseRtcManager {
                     const action = () => {
                         const replacedTrackPromise = session.replaceTrack(oldTrack, newTrack);
                         if (!replacedTrackPromise) {
-                            logger$5.error("replaceTrack returned false!");
+                            logger$4.error("replaceTrack returned false!");
                             reject(`ReplaceTrack returned false`);
                             return;
                         }
@@ -4416,7 +4779,7 @@ class BaseRtcManager {
             }
             const replacedTrackResult = session.replaceTrack(oldTrack, newTrack);
             if (!replacedTrackResult) {
-                logger$5.error("replaceTrack returned false!");
+                logger$4.error("replaceTrack returned false!");
                 return;
             }
             promises.push(replacedTrackResult);
@@ -4424,138 +4787,26 @@ class BaseRtcManager {
         return Promise.all(promises);
     }
 
-    _removeStreamFromPeerConnections(stream) {
-        this._forEachPeerConnection((session) => {
-            this._withForcedRenegotiation(session, () => session.removeStream(stream));
-        });
-    }
-
-    _removeTrackFromPeerConnections(track) {
-        this._forEachPeerConnection((session) => {
-            this._withForcedRenegotiation(session, () => session.removeTrack(track));
-        });
-    }
-
-    _addLocalStream(streamId, stream) {
-        this._addEnabledLocalStreamId(streamId);
-        this.localStreams[streamId] = stream;
-    }
-
-    _removeLocalStream(streamId) {
-        delete this.localStreams[streamId];
-        this._deleteEnabledLocalStreamId(streamId);
-    }
-
-    maybeRestrictRelayBandwidth(session) {
-        session.maybeRestrictRelayBandwidth();
-    }
-
-    addNewStream(streamId, stream) {
-        if (stream === this.localStreams[streamId]) {
-            // this can happen after reconnect. We do not want to add the stream to the
-            // peerconnection again.
-            return;
-        }
-
-        this._addLocalStream(streamId, stream);
-
-        if (streamId === CAMERA_STREAM_ID$1) {
-            this._addStreamToPeerConnections(stream);
-            const [audioTrack] = stream.getAudioTracks();
-            if (audioTrack) {
-                this._startMonitoringAudioTrack(audioTrack);
-            }
-
-            // This should not be needed, but checking nonetheless
-            if (this._localStreamDeregisterFunction) {
-                this._localStreamDeregisterFunction();
-                this._localStreamDeregisterFunction = null;
-            }
-
-            const localStreamHandler = (e) => {
-                const { enable, track } = e.detail;
-                this._handleStopOrResumeVideo({ enable, track });
-            };
-
-            stream.addEventListener("stopresumevideo", localStreamHandler);
-            this._localStreamDeregisterFunction = () => {
-                stream.removeEventListener("stopresumevideo", localStreamHandler);
-            };
-
-            return;
-        }
-
-        // at this point it is clearly a screensharing stream.
-        this._screenshareVideoTrackIds.push(stream.getVideoTracks()[0].id);
-        this._shareScreen(streamId, stream);
-        return;
-    }
-
-    removeStream(streamId, stream) {
-        // essentially we only ever remove screensharing streams.
-        // SFU and P2P provide their own ways of doing this.
-        this._removeLocalStream(streamId, stream);
-    }
-
-    replaceTrack(oldTrack, newTrack) {
-        if (oldTrack && oldTrack.kind === "audio") {
-            this._stopMonitoringAudioTrack(oldTrack);
-        }
-        if (newTrack && newTrack.kind === "audio") {
-            this._startMonitoringAudioTrack(newTrack);
-        }
-        return this._replaceTrackToPeerConnections(oldTrack, newTrack);
-    }
-
-    accept({ clientId, shouldAddLocalVideo }) {
-        return this.acceptNewStream({ streamId: clientId, clientId, shouldAddLocalVideo });
-    }
-
-    disconnectAll() {
-        Object.keys(this.peerConnections).forEach((peerConnectionId) => {
-            this.disconnect(peerConnectionId);
-        });
-        this.peerConnections = {};
-        this._socketListenerDeregisterFunctions.forEach((func) => {
-            func();
+    _removeStreamFromPeerConnections(stream) {
+        this._forEachPeerConnection((session) => {
+            this._withForcedRenegotiation(session, () => session.removeStream(stream));
         });
-        this._socketListenerDeregisterFunctions = [];
-
-        if (this._localStreamDeregisterFunction) {
-            this._localStreamDeregisterFunction();
-            this._localStreamDeregisterFunction = null;
-        }
     }
 
-    // the user has muted/unmuted the audio track on the local stream.
-    stopOrResumeAudio(/*localStream, enable*/) {}
-
-    // the user has muted/unmuted the video track on the local stream.
-    stopOrResumeVideo(/*localStream, enable*/) {}
+    _removeTrackFromPeerConnections(track) {
+        this._forEachPeerConnection((session) => {
+            this._withForcedRenegotiation(session, () => session.removeTrack(track));
+        });
+    }
 
-    // handle the rtc side-effects of ^
-    _handleStopOrResumeVideo(/* { localStream, enable, track } */) {}
+    _addLocalStream(streamId, stream) {
+        this._addEnabledLocalStreamId(streamId);
+        this.localStreams[streamId] = stream;
+    }
 
-    /* the Chrome audio process crashed (probably?)
-     * try to fix it. Constraints are the audio device constraints
-     * used in getUserMedia.
-     */
-    fixChromeAudio(constraints) {
-        if (browserName$2 !== "chrome") {
-            return;
-        }
-        const localStream = this._getLocalCameraStream();
-        const audioTrack = localStream.getAudioTracks()[0];
-        if (!audioTrack || audioTrack.readyState !== "ended") {
-            return;
-        }
-        return navigator.mediaDevices.getUserMedia({ audio: constraints }).then((stream) => {
-            const track = stream.getAudioTracks()[0];
-            track.enabled = audioTrack.enabled; // retain mute state and don't accidentally unmute.
-            localStream.removeTrack(audioTrack); // remove the old track.
-            localStream.addTrack(track); // add the new track.
-            return this.replaceTrack(audioTrack, track);
-        });
+    _removeLocalStream(streamId) {
+        delete this.localStreams[streamId];
+        this._deleteEnabledLocalStreamId(streamId);
     }
 
     _updateAndScheduleMediaServersRefresh({ iceServers, sfuServer, mediaserverConfigTtlSeconds }) {
@@ -4579,114 +4830,6 @@ class BaseRtcManager {
         this._fetchMediaServersTimer = null;
     }
 
-    setupSocketListeners() {
-        this._socketListenerDeregisterFunctions = [
-            () => this._clearMediaServersRefresh(),
-
-            this._serverSocket.on(PROTOCOL_RESPONSES.MEDIASERVER_CONFIG, (data) => {
-                if (data.error) {
-                    logger$5.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
-                    return;
-                }
-                this._updateAndScheduleMediaServersRefresh(data);
-            }),
-
-            this._serverSocket.on(RELAY_MESSAGES.READY_TO_RECEIVE_OFFER, (data) => {
-                this._connect(data.clientId);
-            }),
-
-            this._serverSocket.on(RELAY_MESSAGES.ICE_CANDIDATE, (data) => {
-                const session = this._getSession(data.clientId);
-                if (!session) {
-                    logger$5.warn("No RTCPeerConnection on ICE_CANDIDATE", data);
-                    return;
-                }
-                session.addIceCandidate(data.message);
-            }),
-
-            this._serverSocket.on(RELAY_MESSAGES.ICE_END_OF_CANDIDATES, (data) => {
-                const session = this._getSession(data.clientId);
-                if (!session) {
-                    logger$5.warn("No RTCPeerConnection on ICE_END_OF_CANDIDATES", data);
-                    return;
-                }
-                session.addIceCandidate(null);
-            }),
-
-            // when a new SDP offer is received from another client
-            this._serverSocket.on(RELAY_MESSAGES.SDP_OFFER, (data) => {
-                const session = this._getSession(data.clientId);
-                if (!session) {
-                    logger$5.warn("No RTCPeerConnection on SDP_OFFER", data);
-                    return;
-                }
-                const offer = this._transformIncomingSdp(data.message, session.pc);
-                session.handleOffer(offer).then((answer) => {
-                    this._emitServerEvent(RELAY_MESSAGES.SDP_ANSWER, {
-                        receiverId: data.clientId,
-                        message: this._transformOutgoingSdp(answer),
-                    });
-                });
-            }),
-
-            // when a new SDP answer is received from another client
-            this._serverSocket.on(RELAY_MESSAGES.SDP_ANSWER, (data) => {
-                const session = this._getSession(data.clientId);
-                if (!session) {
-                    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,
-                });
-            }),
-        ];
-    }
-
-    sendAudioMutedStats(muted) {
-        rtcStats.sendEvent("audio_muted", { muted });
-    }
-
-    sendVideoMutedStats(muted) {
-        rtcStats.sendEvent("video_muted", { muted });
-    }
-
-    sendStatsCustomEvent(eventName, data) {
-        rtcStats.sendEvent(eventName, data);
-    }
-
-    rtcStatsDisconnect() {
-        rtcStats.server.close();
-    }
-
-    rtcStatsReconnect() {
-        if (!rtcStats.server.connected) {
-            rtcStats.server.connect();
-        }
-    }
-
     _startMonitoringAudioTrack(track) {
         track.addEventListener("ended", this._audioTrackOnEnded);
     }
@@ -4694,113 +4837,6 @@ class BaseRtcManager {
     _stopMonitoringAudioTrack(track) {
         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;
-    }
-}
-
-const lowPixelCount = 320 * 180;
-const lowBitratePerPixel = 150000 / lowPixelCount;
-const highPixelCount = 1280 * 720;
-const highBitratePerPixel = 1000000 / highPixelCount;
-const bitrateChangePerPixel = (highBitratePerPixel - lowBitratePerPixel) / (highPixelCount - lowPixelCount);
-
-// calculates a bitrate for a given resolution+frameRate
-function getOptimalBitrate(width, height, frameRate) {
-    let targetPixelCount = width * height;
-    if (targetPixelCount < lowPixelCount) targetPixelCount = lowPixelCount;
-    if (targetPixelCount > highPixelCount) targetPixelCount = highPixelCount;
-
-    let targetBitratePerPixel = lowBitratePerPixel;
-    if (targetPixelCount > highPixelCount) targetBitratePerPixel = highBitratePerPixel;
-    else if (targetPixelCount > lowPixelCount) {
-        targetBitratePerPixel += (targetPixelCount - lowPixelCount) * bitrateChangePerPixel;
-    }
-
-    // we use the actual resolution for the target bitrate
-    let targetBitrate = width * height * targetBitratePerPixel;
-
-    // adjust bitrate down a bit if reduced framerate
-    if (frameRate <= 15) targetBitrate = targetBitrate * 0.7;
-    else if (frameRate <= 24) targetBitrate = targetBitrate * 0.9;
-
-    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;
-
-class P2pRtcManager extends BaseRtcManager {
     _connect(clientId) {
         this.rtcStatsReconnect();
         const shouldAddLocalVideo = true;
@@ -4908,15 +4944,16 @@ class P2pRtcManager extends BaseRtcManager {
         }
         session.isOperationPending = true;
 
-        const { vp9On, av1On, redOn } = this._features;
+        const { vp9On, av1On, redOn, rtpAbsCaptureTimeOn } = this._features;
 
         // Set codec preferences to video transceivers
         if (vp9On || av1On || redOn) {
             this._setCodecPreferences(pc, vp9On, av1On, redOn);
         }
-
         pc.createOffer(constraints || this.offerOptions)
             .then((offer) => {
+                // Add https://webrtc.googlesource.com/src/+/refs/heads/main/docs/native-code/rtp-hdrext/abs-capture-time
+                if (rtpAbsCaptureTimeOn) offer.sdp = addAbsCaptureTimeExtMap(offer.sdp);
                 // SDP munging workaround for Firefox, because it doesn't support setCodecPreferences()
                 // Only vp9 because FF does not support AV1 yet
                 if ((vp9On || redOn) && browserName$1 === "firefox") {
@@ -5275,7 +5312,7 @@ class P2pRtcManager extends BaseRtcManager {
     }
 
     removeStream(streamId, stream, requestedByClientId) {
-        super.removeStream(streamId, stream);
+        this._removeLocalStream(streamId, stream);
         this._removeStreamFromPeerConnections(stream);
         this._wasScreenSharing = false;
         this._emitServerEvent(PROTOCOL_REQUESTS.STOP_SCREENSHARE, { streamId, requestedByClientId });
@@ -6173,6 +6210,7 @@ class VegaMediaQualityMonitor extends EventEmitter {
     }
 }
 
+const adapter = adapterRaw.default ?? adapterRaw;
 const logger = new Logger();
 
 const browserName = adapter.browserDetails.browser;
@@ -7983,6 +8021,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;
     }
@@ -8008,6 +8047,7 @@ const doConnectRtc = createAppThunk(() => (dispatch, getState) => {
             vp9On: false,
             h264On: false,
             simulcastScreenshareOn: false,
+            deviceHandlerFactory: isNodeSdk ? Chrome111.createFactory() : undefined,
         },
     });
     dispatch(rtcDispatcherCreated(rtcManagerDispatcher));
@@ -9464,7 +9504,7 @@ class LocalParticipant extends RoomParticipant {
     }
 }
 
-const sdkVersion = "0.3.0";
+const sdkVersion = "0.5.0";
 
 const defaultSubdomainPattern = /^(?:([^.]+)[.])?((:?[^.]+[.]){1,}[^.]+)$/;
 const localstackPattern = /^(?:([^.]+)-)?(ip-[^.]*[.](?:hereby[.]dev|rfc1918[.]disappear[.]at)(?::\d+|))$/;
@@ -9536,4 +9576,4 @@ function createServices() {
     };
 }
 
-export { ApiClient, Credentials, CredentialsService, LocalParticipant, OrganizationApiClient, OrganizationService, OrganizationServiceCache, RoomService, addAppListener, appLeft, appSlice, chatSlice, cloudRecordingSlice, createAppAsyncThunk, createAppThunk, createReactor, createServices, createStore, createWebRtcEmitter, deviceBusy, deviceCredentialsSlice, deviceIdentified, deviceIdentifying, doAcceptWaitingParticipant, doAppJoin, doConnectRoom, doConnectRtc, doDisconnectRtc, doEnableAudio, doEnableVideo, doGetDeviceCredentials, doHandleAcceptStreams, doHandleStreamingStarted, doHandleStreamingStopped, doKnockRoom, doOrganizationFetch, doRejectWaitingParticipant, doRtcAnalyticsCustomEventsInitialize, doRtcManagerCreated, doRtcManagerInitialize, doRtcReportStreamResolution, doSendChatMessage, doSetDevice, doSetDisplayName, doSetLocalParticipant, doSignalDisconnect, doSignalIdentifyDevice, doSignalReconnect, doSignalSocketConnect, doStartCloudRecording, doStartLocalMedia, doStartScreenshare, doStopCloudRecording, doStopLocalMedia, doStopScreenshare, doSwitchLocalStream, doToggleCamera, doUpdateDeviceList, initialCloudRecordingState, initialLocalMediaState, isAcceptingStreams, listenerMiddleware, localMediaSlice, localMediaStopped, localParticipantSlice, localScreenshareSlice, localStreamMetadataUpdated, observeStore, organizationSlice, participantStreamAdded, participantStreamIdAdded, recordingRequestStarted, remoteParticipantsSlice, resolutionReported, roomConnectionSlice, rootReducer, rtcAnalyticsCustomEvents, rtcAnalyticsSlice, rtcConnectionSlice, rtcDisconnected, rtcDispatcherCreated, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, sdkVersion, selectAppDisplayName, selectAppExternalId, selectAppRaw, selectAppRoomKey, selectAppRoomName, selectAppRoomUrl, selectAppSdkVersion, selectAppWantsToJoin, selectBusyDeviceIds, selectCameraDeviceError, selectCameraDevices, selectChatMessages, selectChatRaw, selectCloudRecordingError, selectCloudRecordingRaw, selectCloudRecordingStartedAt, selectCloudRecordingStatus, selectCurrentCameraDeviceId, selectCurrentMicrophoneDeviceId, selectDeviceCredentialsRaw, selectDeviceId, selectHasFetchedDeviceCredentials, selectIsAcceptingStreams, selectIsCameraEnabled, selectIsCloudRecording, selectIsLocalMediaStarting, selectIsMicrophoneEnabled, selectIsSettingCameraDevice, selectIsSettingMicrophoneDevice, selectIsToggleCamera, selectLocalMediaConstraintsOptions, selectLocalMediaDevices, selectLocalMediaIsSwitchingStream, selectLocalMediaOptions, selectLocalMediaOwnsStream, selectLocalMediaRaw, selectLocalMediaShouldStartWithOptions, selectLocalMediaShouldStop, selectLocalMediaStartError, selectLocalMediaStatus, selectLocalMediaStream, selectLocalParticipantIsScreenSharing, selectLocalParticipantRaw, selectLocalParticipantRole, selectLocalScreenshareRaw, selectLocalScreenshareStatus, selectLocalScreenshareStream, selectMicrophoneDeviceError, selectMicrophoneDevices, selectOrganizationId, selectOrganizationRaw, selectRemoteParticipants, selectRemoteParticipantsRaw, selectRoomConnectionRaw, selectRoomConnectionSession, selectRoomConnectionSessionId, selectRoomConnectionStatus, selectRtcConnectionRaw, selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectRtcManager, selectRtcManagerInitialized, selectRtcStatus, selectScreenshares, selectSelfId, selectShouldConnectRoom, selectShouldConnectRtc, selectShouldConnectSignal, selectShouldDisconnectRtc, selectShouldFetchDeviceCredentials, selectShouldFetchOrganization, selectShouldIdentifyDevice, selectShouldInitializeRtc, selectSignalConnectionDeviceIdentified, selectSignalConnectionRaw, selectSignalConnectionSocket, selectSignalIsIdentifyingDevice, selectSignalStatus, selectSpeakerDevices, selectStreamingRaw, selectStreamsToAccept, selectWaitingParticipants, selectWaitingParticipantsRaw, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, setLocalMediaOptions, setLocalMediaStream, setRoomKey, signalConnectionSlice, socketConnected, socketConnecting, socketDisconnected, socketReconnecting, startAppListening, stopScreenshare, streamStatusUpdated, streamingSlice, toggleCameraEnabled, toggleMicrophoneEnabled, updateReportedValues, waitingParticipantsSlice };
+export { ApiClient, Credentials, CredentialsService, LocalParticipant, OrganizationApiClient, OrganizationService, OrganizationServiceCache, RoomService, addAppListener, appLeft, appSlice, chatSlice, cloudRecordingSlice, createAppAsyncThunk, createAppThunk, createReactor, createServices, createStore, createWebRtcEmitter, deviceBusy, deviceCredentialsSlice, deviceIdentified, deviceIdentifying, doAcceptWaitingParticipant, doAppJoin, doConnectRoom, doConnectRtc, doDisconnectRtc, doEnableAudio, doEnableVideo, doGetDeviceCredentials, doHandleAcceptStreams, doHandleStreamingStarted, doHandleStreamingStopped, doKnockRoom, doOrganizationFetch, doRejectWaitingParticipant, doRtcAnalyticsCustomEventsInitialize, doRtcManagerCreated, doRtcManagerInitialize, doRtcReportStreamResolution, doSendChatMessage, doSetDevice, doSetDisplayName, doSetLocalParticipant, doSignalDisconnect, doSignalIdentifyDevice, doSignalReconnect, doSignalSocketConnect, doStartCloudRecording, doStartLocalMedia, doStartScreenshare, doStopCloudRecording, doStopLocalMedia, doStopScreenshare, doSwitchLocalStream, doToggleCamera, doUpdateDeviceList, initialCloudRecordingState, initialLocalMediaState, isAcceptingStreams, listenerMiddleware, localMediaSlice, localMediaStopped, localParticipantSlice, localScreenshareSlice, localStreamMetadataUpdated, observeStore, organizationSlice, participantStreamAdded, participantStreamIdAdded, recordingRequestStarted, remoteParticipantsSlice, resolutionReported, roomConnectionSlice, rootReducer, rtcAnalyticsCustomEvents, rtcAnalyticsSlice, rtcConnectionSlice, rtcDisconnected, rtcDispatcherCreated, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, sdkVersion, selectAppDisplayName, selectAppExternalId, selectAppIsNodeSdk, selectAppRaw, selectAppRoomKey, selectAppRoomName, selectAppRoomUrl, selectAppSdkVersion, selectAppWantsToJoin, selectBusyDeviceIds, selectCameraDeviceError, selectCameraDevices, selectChatMessages, selectChatRaw, selectCloudRecordingError, selectCloudRecordingRaw, selectCloudRecordingStartedAt, selectCloudRecordingStatus, selectCurrentCameraDeviceId, selectCurrentMicrophoneDeviceId, selectDeviceCredentialsRaw, selectDeviceId, selectHasFetchedDeviceCredentials, selectIsAcceptingStreams, selectIsCameraEnabled, selectIsCloudRecording, selectIsLocalMediaStarting, selectIsMicrophoneEnabled, selectIsSettingCameraDevice, selectIsSettingMicrophoneDevice, selectIsToggleCamera, selectLocalMediaConstraintsOptions, selectLocalMediaDevices, selectLocalMediaIsSwitchingStream, selectLocalMediaOptions, selectLocalMediaOwnsStream, selectLocalMediaRaw, selectLocalMediaShouldStartWithOptions, selectLocalMediaShouldStop, selectLocalMediaStartError, selectLocalMediaStatus, selectLocalMediaStream, selectLocalParticipantIsScreenSharing, selectLocalParticipantRaw, selectLocalParticipantRole, selectLocalScreenshareRaw, selectLocalScreenshareStatus, selectLocalScreenshareStream, selectMicrophoneDeviceError, selectMicrophoneDevices, selectOrganizationId, selectOrganizationRaw, selectRemoteParticipants, selectRemoteParticipantsRaw, selectRoomConnectionError, selectRoomConnectionRaw, selectRoomConnectionSession, selectRoomConnectionSessionId, selectRoomConnectionStatus, selectRtcConnectionRaw, selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectRtcManager, selectRtcManagerInitialized, selectRtcStatus, selectScreenshares, selectSelfId, selectShouldConnectRoom, selectShouldConnectRtc, selectShouldConnectSignal, selectShouldDisconnectRtc, selectShouldFetchDeviceCredentials, selectShouldFetchOrganization, selectShouldIdentifyDevice, selectShouldInitializeRtc, selectSignalConnectionDeviceIdentified, selectSignalConnectionRaw, selectSignalConnectionSocket, selectSignalIsIdentifyingDevice, selectSignalStatus, selectSpeakerDevices, selectStreamingRaw, selectStreamsToAccept, selectWaitingParticipants, selectWaitingParticipantsRaw, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, setLocalMediaOptions, setLocalMediaStream, setRoomKey, signalConnectionSlice, socketConnected, socketConnecting, socketDisconnected, socketReconnecting, startAppListening, stopScreenshare, streamStatusUpdated, streamingSlice, toggleCameraEnabled, toggleMicrophoneEnabled, updateReportedValues, waitingParticipantsSlice };