@whereby.com/media 1.4.2 → 1.5.1

package/dist/index.cjs

@@ -31,6 +31,62 @@ function _interopNamespaceDefault(e) {
 
 var sdpTransform__namespace = /*#__PURE__*/_interopNamespaceDefault(sdpTransform);
 
+const debugOn = process.env.NODE_ENV === "development" || new URLSearchParams(window.location.search).has("debug");
+class Logger {
+    constructor() {
+        this._isEnabled = false;
+        this._debugger = null;
+        this._isEnabled = debugOn;
+    }
+    isEnabled() {
+        return this._isEnabled;
+    }
+    enable() {
+        this._isEnabled = true;
+    }
+    disable() {
+        this._isEnabled = false;
+    }
+    info(...params) {
+        if (!this._isEnabled) {
+            return;
+        }
+        return console.info(...params);
+    }
+    warn(...params) {
+        if (!this._isEnabled) {
+            return;
+        }
+        return console.warn(...params);
+    }
+    error(...params) {
+        if (!this._isEnabled) {
+            return;
+        }
+        return console.error(...params);
+    }
+    withDebugLogger(myDebugger = null) {
+        this._debugger = myDebugger;
+        return this;
+    }
+    debug(...params) {
+        if (!this._isEnabled || !this._debugger) {
+            return;
+        }
+        const suppliedParams = [];
+        params.forEach((param) => {
+            if (typeof param === "function") {
+                const suppliedParam = param();
+                suppliedParams.push(suppliedParam);
+            }
+            else {
+                suppliedParams.push(param);
+            }
+        });
+        this._debugger.print(...suppliedParams);
+    }
+}
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -63,34 +119,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-let peerConnections = [];
-let peerConnectionCounter = 0;
-const peerConnectionData = new WeakMap();
-const removePeerConnection = (pc) => {
-    peerConnections = peerConnections.filter((old) => old !== pc);
-};
-if (window.RTCPeerConnection) {
-    const OriginalRTCPeerConnection = window.RTCPeerConnection;
-    function PatchedRTCPeerConnection(rtcConfig) {
-        const pc = new OriginalRTCPeerConnection(rtcConfig);
-        peerConnections.push(pc);
-        peerConnectionData.set(pc, { index: peerConnectionCounter++ });
-        const onConnectionStateChange = () => {
-            if (pc.connectionState === "closed") {
-                removePeerConnection(pc);
-                pc.removeEventListener("connectionstatechange", onConnectionStateChange);
-            }
-        };
-        pc.addEventListener("connectionstatechange", onConnectionStateChange);
-        return pc;
-    }
-    PatchedRTCPeerConnection.prototype = OriginalRTCPeerConnection.prototype;
-    window.RTCPeerConnection = PatchedRTCPeerConnection;
-}
-const getCurrentPeerConnections = () => peerConnections;
-const getPeerConnectionIndex = (pc) => { var _a; return (_a = peerConnectionData.get(pc)) === null || _a === void 0 ? void 0 : _a.index; };
-const setPeerConnectionsForTests = (pcs) => (peerConnections = pcs);
-
 function captureCandidatePairInfoMetrics(cpMetrics, currentCptats, prevCptats, timeDiff, report) {
     const bytesReceivedDiff = currentCptats.bytesReceived - ((prevCptats === null || prevCptats === void 0 ? void 0 : prevCptats.bytesReceived) || 0);
     const bytesSentDiff = currentCptats.bytesSent - ((prevCptats === null || prevCptats === void 0 ? void 0 : prevCptats.bytesSent) || 0);
@@ -252,119 +280,34 @@ function captureVideoSsrcMetrics(ssrcMetrics, currentSsrcStats, prevSsrcStats, t
     }
 }
 
-const debugOn = process.env.NODE_ENV === "development" || new URLSearchParams(window.location.search).has("debug");
-class Logger {
-    constructor() {
-        this._isEnabled = false;
-        this._debugger = null;
-        this._isEnabled = debugOn;
-    }
-    isEnabled() {
-        return this._isEnabled;
-    }
-    enable() {
-        this._isEnabled = true;
-    }
-    disable() {
-        this._isEnabled = false;
-    }
-    info(...params) {
-        if (!this._isEnabled) {
-            return;
-        }
-        return console.info(...params);
-    }
-    warn(...params) {
-        if (!this._isEnabled) {
-            return;
-        }
-        return console.warn(...params);
-    }
-    error(...params) {
-        if (!this._isEnabled) {
-            return;
-        }
-        return console.error(...params);
-    }
-    withDebugLogger(myDebugger = null) {
-        this._debugger = myDebugger;
-        return this;
-    }
-    debug(...params) {
-        if (!this._isEnabled || !this._debugger) {
-            return;
-        }
-        const suppliedParams = [];
-        params.forEach((param) => {
-            if (typeof param === "function") {
-                const suppliedParam = param();
-                suppliedParams.push(suppliedParam);
-            }
-            else {
-                suppliedParams.push(param);
+let peerConnections = [];
+let peerConnectionCounter = 0;
+const peerConnectionData = new WeakMap();
+const removePeerConnection = (pc) => {
+    peerConnections = peerConnections.filter((old) => old !== pc);
+};
+if (window.RTCPeerConnection) {
+    const OriginalRTCPeerConnection = window.RTCPeerConnection;
+    function PatchedRTCPeerConnection(rtcConfig) {
+        const pc = new OriginalRTCPeerConnection(rtcConfig);
+        peerConnections.push(pc);
+        peerConnectionData.set(pc, { index: peerConnectionCounter++ });
+        const onConnectionStateChange = () => {
+            if (pc.connectionState === "closed") {
+                removePeerConnection(pc);
+                pc.removeEventListener("connectionstatechange", onConnectionStateChange);
             }
-        });
-        this._debugger.print(...suppliedParams);
+        };
+        pc.addEventListener("connectionstatechange", onConnectionStateChange);
+        return pc;
     }
+    PatchedRTCPeerConnection.prototype = OriginalRTCPeerConnection.prototype;
+    window.RTCPeerConnection = PatchedRTCPeerConnection;
 }
+const getCurrentPeerConnections = () => peerConnections;
+const getPeerConnectionIndex = (pc) => { var _a; return (_a = peerConnectionData.get(pc)) === null || _a === void 0 ? void 0 : _a.index; };
+const setPeerConnectionsForTests = (pcs) => (peerConnections = pcs);
 
-const logger$a = new Logger();
-const STATS_INTERVAL = 2000;
-let getClients = () => [];
-const setClientProvider = (provider) => (getClients = provider);
-const statsByView = {};
-const getStats = () => {
-    return Object.assign({}, statsByView);
-};
-let subscriptions$1 = [];
-let currentMonitor = null;
-const getUpdatedStats = () => currentMonitor === null || currentMonitor === void 0 ? void 0 : currentMonitor.getUpdatedStats();
-const getOrCreateSsrcMetricsContainer = (time, pcIndex, clientId, trackId, ssrc) => {
-    let viewStats = statsByView[clientId];
-    if (!viewStats) {
-        viewStats = { tracks: {}, startTime: time, updated: time };
-        statsByView[clientId] = viewStats;
-    }
-    viewStats.updated = time;
-    let trackStats = viewStats.tracks[trackId];
-    if (!trackStats) {
-        trackStats = { ssrcs: {}, startTime: time, updated: time };
-        viewStats.tracks[trackId] = trackStats;
-    }
-    trackStats.updated = time;
-    let ssrcStats = trackStats.ssrcs[ssrc];
-    if (!ssrcStats) {
-        ssrcStats = {
-            startTime: time,
-            updated: time,
-            pcIndex,
-        };
-        trackStats.ssrcs[ssrc] = ssrcStats;
-    }
-    ssrcStats.updated = time;
-    return ssrcStats;
-};
-const removeNonUpdatedStats = (time) => {
-    Object.entries(statsByView).forEach(([viewId, viewStats]) => {
-        if (viewStats.updated < time) {
-            delete statsByView[viewId];
-        }
-        else {
-            Object.entries(viewStats.tracks).forEach(([trackId, trackStats]) => {
-                if (trackStats.updated < time) {
-                    delete viewStats.tracks[trackId];
-                }
-                else {
-                    Object.entries(trackStats.ssrcs).forEach(([ssrc, ssrcStats]) => {
-                        if (ssrcStats.updated < time) {
-                            delete trackStats.ssrcs[ssrc];
-                        }
-                    });
-                }
-            });
-        }
-    });
-};
 const pcDataByPc = new WeakMap();
 const getPeerConnectionsWithStatsReports = () => Promise.all(getCurrentPeerConnections().map((pc) => __awaiter(void 0, void 0, void 0, function* () {
     let pcData = pcDataByPc.get(pc);
@@ -424,59 +367,74 @@ const getPeerConnectionsWithStatsReports = () => Promise.all(getCurrentPeerConne
         return [pc, [], pcData];
     }
 })));
-let originTrialActivated = false;
-function activateComputePressureOriginTrial() {
-    if (originTrialActivated)
-        return;
-    const otMeta = document.createElement("meta");
-    otMeta.httpEquiv = "origin-trial";
-    if (/hereby\.dev/.test(document.location.hostname)) {
-        otMeta.content =
-            "AkSNPHJw6EK08X0QU7kORnK9NABzRLAC7dqfXOwk5JwFAQG4Ey7WxLXxsnhieCgC1QHUdevE2EFICy7uBGDANwUAAABqeyJvcmlnaW4iOiJodHRwczovL2hlcmVieS5kZXY6NDQ0MyIsImZlYXR1cmUiOiJDb21wdXRlUHJlc3N1cmVfdjIiLCJleHBpcnkiOjE3MTY5NDA3OTksImlzU3ViZG9tYWluIjp0cnVlfQ==";
+
+const getOrCreateSsrcMetricsContainer = (statsByView, time, pcIndex, clientId, trackId, ssrc) => {
+    let viewStats = statsByView[clientId];
+    if (!viewStats) {
+        viewStats = { tracks: {}, startTime: time, updated: time };
+        statsByView[clientId] = viewStats;
     }
-    else {
-        otMeta.content =
-            "Asc2wu8KpSx648i932NICteQDFcB05yl2QUUSHD7AQo8JGP2Fp6FF91TvYVJBsKGzLMH349rysPw5q9tqPC/PAUAAABqeyJvcmlnaW4iOiJodHRwczovL3doZXJlYnkuY29tOjQ0MyIsImZlYXR1cmUiOiJDb21wdXRlUHJlc3N1cmVfdjIiLCJleHBpcnkiOjE3MTY5NDA3OTksImlzU3ViZG9tYWluIjp0cnVlfQ==";
+    viewStats.updated = time;
+    let trackStats = viewStats.tracks[trackId];
+    if (!trackStats) {
+        trackStats = { ssrcs: {}, startTime: time, updated: time };
+        viewStats.tracks[trackId] = trackStats;
     }
-    document.head.append(otMeta);
-    originTrialActivated = true;
-}
-function startStatsMonitor({ interval }) {
-    let nextTimeout = 0;
-    activateComputePressureOriginTrial();
-    let pressureObserver;
-    let lastPressureObserverRecord;
-    try {
-        if ("PressureObserver" in window) {
-            pressureObserver = new window.PressureObserver((records) => (lastPressureObserverRecord = records.pop()), {
-                sampleRate: 1,
+    trackStats.updated = time;
+    let ssrcStats = trackStats.ssrcs[ssrc];
+    if (!ssrcStats) {
+        ssrcStats = {
+            startTime: time,
+            updated: time,
+            pcIndex,
+        };
+        trackStats.ssrcs[ssrc] = ssrcStats;
+    }
+    ssrcStats.updated = time;
+    return ssrcStats;
+};
+const removeNonUpdatedStats = (statsByView, time) => {
+    Object.entries(statsByView).forEach(([viewId, viewStats]) => {
+        if (viewStats.updated < time) {
+            delete statsByView[viewId];
+        }
+        else {
+            Object.entries(viewStats.tracks).forEach(([trackId, trackStats]) => {
+                if (trackStats.updated < time) {
+                    delete viewStats.tracks[trackId];
+                }
+                else {
+                    Object.entries(trackStats.ssrcs).forEach(([ssrc, ssrcStats]) => {
+                        if (ssrcStats.updated < time) {
+                            delete trackStats.ssrcs[ssrc];
+                        }
+                    });
+                }
             });
-            pressureObserver.observe("cpu");
         }
-    }
-    catch (ex) {
-        logger$a.warn("Failed to observe CPU pressure", ex);
-    }
-    let lastUpdateTime = 0;
-    const collectStats = (immediate) => __awaiter(this, void 0, void 0, function* () {
+    });
+};
+function collectStats(state, { logger, interval }, immediate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const collectStatsBound = collectStats.bind(null, state, { interval, logger });
         try {
-            const clients = getClients();
+            const clients = state.getClients();
             const defaultClient = clients.find((c) => c.isLocalClient && !c.isPresentation) || { id: "unknown" };
-            let defaultViewStats = statsByView[defaultClient.id];
+            let defaultViewStats = state.statsByView[defaultClient.id];
             if (!defaultViewStats) {
                 defaultViewStats = { tracks: {}, candidatePairs: {}, pressure: null };
-                statsByView[defaultClient.id] = defaultViewStats;
+                state.statsByView[defaultClient.id] = defaultViewStats;
             }
-            defaultViewStats.pressure = lastPressureObserverRecord;
-            const timeSinceLastUpdate = Date.now() - lastUpdateTime;
+            defaultViewStats.pressure = state.lastPressureObserverRecord;
+            const timeSinceLastUpdate = Date.now() - state.lastUpdateTime;
             if (timeSinceLastUpdate < 400) {
                 if (immediate)
-                    return statsByView;
-                subscriptions$1.forEach((subscription) => { var _a; return (_a = subscription.onUpdatedStats) === null || _a === void 0 ? void 0 : _a.call(subscription, statsByView, clients); });
-                nextTimeout = setTimeout(collectStats, interval || STATS_INTERVAL);
+                    return state.statsByView;
+                state.subscriptions.forEach((subscription) => { var _a; return (_a = subscription.onUpdatedStats) === null || _a === void 0 ? void 0 : _a.call(subscription, state.statsByView, clients); });
+                state.nextTimeout = setTimeout(collectStatsBound, interval);
                 return;
             }
-            lastUpdateTime = Date.now();
+            state.lastUpdateTime = Date.now();
             (yield getPeerConnectionsWithStatsReports()).forEach(([pc, report, pcData]) => {
                 const pcIndex = getPeerConnectionIndex(pc);
                 if (pc.connectionState === "closed") {
@@ -487,20 +445,17 @@ function startStatsMonitor({ interval }) {
                 pcData.currentSSRCs = {};
                 report.forEach((currentRtcStats) => {
                     var _a, _b;
-                    if (currentRtcStats.type === "candidate-pair" &&
-                        /inprogress|succeeded/.test(currentRtcStats.state)) {
+                    if (currentRtcStats.type === "candidate-pair" && /inprogress|succeeded/.test(currentRtcStats.state)) {
                         const prevRtcStats = (_a = pcData._oldReport) === null || _a === void 0 ? void 0 : _a.get(currentRtcStats.id);
-                        const timeDiff = prevRtcStats
-                            ? currentRtcStats.timestamp - prevRtcStats.timestamp
-                            : STATS_INTERVAL;
+                        const timeDiff = prevRtcStats ? currentRtcStats.timestamp - prevRtcStats.timestamp : interval;
                         const cpId = pcIndex + ":" + currentRtcStats.id;
                         let cpMetrics = defaultViewStats.candidatePairs[cpId];
                         if (!cpMetrics) {
-                            cpMetrics = { startTime: lastUpdateTime, id: cpId };
+                            cpMetrics = { startTime: state.lastUpdateTime, id: cpId };
                             defaultViewStats.candidatePairs[cpId] = cpMetrics;
                         }
                         captureCandidatePairInfoMetrics(cpMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
-                        cpMetrics.lastRtcStatsTime = lastUpdateTime;
+                        cpMetrics.lastRtcStatsTime = state.lastUpdateTime;
                     }
                     if (currentRtcStats.type === "inbound-rtp" || currentRtcStats.type === "outbound-rtp") {
                         const kind = currentRtcStats.mediaType || currentRtcStats.kind;
@@ -528,10 +483,8 @@ function startStatsMonitor({ interval }) {
                                 prevRtcStats = null;
                             }
                         }
-                        const timeDiff = prevRtcStats
-                            ? currentRtcStats.timestamp - prevRtcStats.timestamp
-                            : STATS_INTERVAL;
-                        const ssrcMetrics = getOrCreateSsrcMetricsContainer(lastUpdateTime, pcIndex, client.id, trackId, ssrc);
+                        const timeDiff = prevRtcStats ? currentRtcStats.timestamp - prevRtcStats.timestamp : interval;
+                        const ssrcMetrics = getOrCreateSsrcMetricsContainer(state.statsByView, state.lastUpdateTime, pcIndex, client.id, trackId, ssrc);
                         captureSsrcInfo(ssrcMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
                         captureCommonSsrcMetrics(ssrcMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
                         if (kind === "video") {
@@ -548,7 +501,7 @@ function startStatsMonitor({ interval }) {
                     .forEach((ssrc) => {
                     const clientId = pcData.previousSSRCs[ssrc];
                     if (clientId) {
-                        const clientView = statsByView[clientId];
+                        const clientView = state.statsByView[clientId];
                         if (clientView) {
                             Object.values(clientView.tracks).forEach((trackStats) => {
                                 if (trackStats.ssrcs[ssrc]) {
@@ -559,55 +512,127 @@ function startStatsMonitor({ interval }) {
                     }
                 });
             });
-            removeNonUpdatedStats(lastUpdateTime);
+            removeNonUpdatedStats(state.statsByView, state.lastUpdateTime);
             Object.entries(defaultViewStats.candidatePairs).forEach(([cpKey, cp]) => {
-                const active = cp.lastRtcStatsTime === lastUpdateTime;
+                const active = cp.lastRtcStatsTime === state.lastUpdateTime;
                 cp.active = active;
                 if (!active) {
                     cp.state = "old/inactive";
                     if (!cp.inactiveFromTime)
-                        cp.inactiveFromTime = lastUpdateTime;
+                        cp.inactiveFromTime = state.lastUpdateTime;
                     else {
-                        if (lastUpdateTime - cp.inactiveFromTime > 4000) {
+                        if (state.lastUpdateTime - cp.inactiveFromTime > 4000) {
                             delete defaultViewStats.candidatePairs[cpKey];
                         }
                     }
                 }
             });
             if (immediate) {
-                return statsByView;
+                return state.statsByView;
             }
             else {
-                subscriptions$1.forEach((subscription) => { var _a; return (_a = subscription.onUpdatedStats) === null || _a === void 0 ? void 0 : _a.call(subscription, statsByView, clients); });
+                state.subscriptions.forEach((subscription) => { var _a; return (_a = subscription.onUpdatedStats) === null || _a === void 0 ? void 0 : _a.call(subscription, state.statsByView, clients); });
             }
         }
         catch (ex) {
-            logger$a.warn(ex);
+            logger.warn(ex);
         }
-        nextTimeout = setTimeout(collectStats, interval || STATS_INTERVAL);
+        state.nextTimeout = setTimeout(collectStatsBound, interval);
     });
-    setTimeout(collectStats, interval || STATS_INTERVAL);
-    return {
-        stop: () => {
-            clearTimeout(nextTimeout);
-            if (pressureObserver)
-                pressureObserver.unobserve("cpu");
+}
+
+const REGISTERED_TRIALS = {};
+function registerOriginTrials(trials, registeredTrials = REGISTERED_TRIALS, document = window.document) {
+    trials.forEach(({ hostnamePattern, token }) => {
+        const key = `${hostnamePattern}-${token}`;
+        if (registeredTrials[key]) {
+            return;
+        }
+        if (hostnamePattern.test(document.location.hostname)) {
+            const otMeta = document.createElement("meta");
+            otMeta.httpEquiv = "origin-trial";
+            otMeta.content = token;
+            document.head.append(otMeta);
+            registeredTrials[key] = true;
+        }
+    });
+}
+
+const CPU_OBSERVER_OPTIONS = {
+    sampleRate: 1,
+    originTrials: [
+        {
+            hostnamePattern: /hereby\.dev/,
+            token: "AkSNPHJw6EK08X0QU7kORnK9NABzRLAC7dqfXOwk5JwFAQG4Ey7WxLXxsnhieCgC1QHUdevE2EFICy7uBGDANwUAAABqeyJvcmlnaW4iOiJodHRwczovL2hlcmVieS5kZXY6NDQ0MyIsImZlYXR1cmUiOiJDb21wdXRlUHJlc3N1cmVfdjIiLCJleHBpcnkiOjE3MTY5NDA3OTksImlzU3ViZG9tYWluIjp0cnVlfQ==",
+        },
+        {
+            hostnamePattern: /whereby\.com/,
+            token: "Asc2wu8KpSx648i932NICteQDFcB05yl2QUUSHD7AQo8JGP2Fp6FF91TvYVJBsKGzLMH349rysPw5q9tqPC/PAUAAABqeyJvcmlnaW4iOiJodHRwczovL3doZXJlYnkuY29tOjQ0MyIsImZlYXR1cmUiOiJDb21wdXRlUHJlc3N1cmVfdjIiLCJleHBpcnkiOjE3MTY5NDA3OTksImlzU3ViZG9tYWluIjp0cnVlfQ==",
         },
+    ],
+};
+function startCpuObserver(cb, { sampleRate, originTrials } = CPU_OBSERVER_OPTIONS, window = globalThis.window) {
+    registerOriginTrials(originTrials);
+    let pressureObserver;
+    if ("PressureObserver" in window) {
+        pressureObserver = new window.PressureObserver(cb, { sampleRate });
+        pressureObserver.observe("cpu", { sampleInterval: sampleRate * 1000 });
+        return {
+            stop: () => {
+                pressureObserver.unobserve("cpu");
+            },
+        };
+    }
+}
+
+const STATE = {
+    currentMonitor: null,
+    getClients: () => [],
+    lastUpdateTime: 0,
+    statsByView: {},
+    subscriptions: [],
+};
+const OPTIONS = {
+    interval: 2000,
+    logger: new Logger(),
+};
+const getStats = () => {
+    return Object.assign({}, STATE.statsByView);
+};
+const getUpdatedStats = () => { var _a; return (_a = STATE.currentMonitor) === null || _a === void 0 ? void 0 : _a.getUpdatedStats(); };
+const setClientProvider = (provider) => (STATE.getClients = provider);
+function startStatsMonitor(state, { interval, logger }) {
+    const collectStatsBound = collectStats.bind(null, state, { interval, logger });
+    let cpuObserver;
+    try {
+        cpuObserver = startCpuObserver((records) => (state.lastPressureObserverRecord = records.pop()));
+    }
+    catch (ex) {
+        logger.warn("Failed to observe CPU pressure", ex);
+    }
+    setTimeout(collectStatsBound, interval);
+    return {
         getUpdatedStats: () => {
-            return collectStats(true);
+            return collectStatsBound(true);
+        },
+        stop: () => {
+            clearTimeout(state.nextTimeout);
+            if (cpuObserver)
+                cpuObserver.stop();
         },
     };
 }
-function subscribeStats(subscription) {
-    subscriptions$1.push(subscription);
-    if (!currentMonitor)
-        currentMonitor = startStatsMonitor({});
+function subscribeStats(subscription, options = OPTIONS, state = STATE) {
+    state.subscriptions.push(subscription);
+    if (!state.currentMonitor)
+        state.currentMonitor = startStatsMonitor(state, options);
     return {
         stop() {
-            subscriptions$1 = subscriptions$1.filter((s) => s !== subscription);
-            if (!subscriptions$1.length) {
-                currentMonitor === null || currentMonitor === void 0 ? void 0 : currentMonitor.stop();
-                currentMonitor = null;
+            var _a;
+            state.subscriptions = state.subscriptions.filter((s) => s !== subscription);
+            if (!state.subscriptions.length) {
+                (_a = state.currentMonitor) === null || _a === void 0 ? void 0 : _a.stop();
+                state.currentMonitor = null;
             }
         },
     };
@@ -4992,13 +5017,9 @@ class VegaRtcManager {
     }
     _connect() {
         const host = this._features.sfuServerOverrideHost || [this._sfuServer.url];
-        const searchParams = new URLSearchParams({
-            clientId: this._selfId,
-            organizationId: this._room.organizationId,
-            roomName: this._room.name,
-            eventClaim: this._room.isClaimed ? this._eventClaim : null,
-            lowBw: "true",
-        });
+        const searchParams = new URLSearchParams(Object.assign({ clientId: this._selfId, organizationId: this._room.organizationId, roomName: this._room.name, eventClaim: this._room.isClaimed ? this._eventClaim : null, lowBw: "true" }, Object.keys(this._features || {})
+            .filter((featureKey) => this._features[featureKey] && /^sfu/.test(featureKey))
+            .reduce((prev, current) => (Object.assign(Object.assign({}, prev), { [current]: this._features[current] })), {})));
         const queryString = searchParams.toString();
         const wsUrl = `wss://${host}?${queryString}`;
         this._vegaConnection = new VegaConnection(wsUrl);

package/dist/index.d.cts

@@ -16,10 +16,45 @@ declare function startPerformanceMonitor({ onMetricsUpdated, onTerminated, isHid
     updateHidden: () => void;
 };
 
-declare const setClientProvider: (provider: any) => any;
+declare class Logger {
+    _isEnabled: boolean;
+    _debugger: any;
+    constructor();
+    isEnabled(): boolean;
+    enable(): void;
+    disable(): void;
+    info(...params: any[]): void;
+    warn(...params: any[]): void;
+    error(...params: any[]): void;
+    withDebugLogger(myDebugger?: null): this;
+    debug(...params: any[]): void;
+}
+
+interface StatsMonitor {
+    getUpdatedStats: () => any;
+    stop: () => void;
+}
+interface StatsSubscription {
+    onUpdatedStats: (statsByView: any, clients: any) => void;
+}
+interface StatsMonitorState {
+    currentMonitor: StatsMonitor | null;
+    getClients: () => any[];
+    lastPressureObserverRecord?: any;
+    lastUpdateTime: number;
+    nextTimeout?: NodeJS.Timeout;
+    pressureObserver?: any;
+    statsByView: any;
+    subscriptions: StatsSubscription[];
+}
+interface StatsMonitorOptions {
+    interval: number;
+    logger: Pick<Logger, "debug" | "error" | "info" | "warn">;
+}
 declare const getStats: () => any;
 declare const getUpdatedStats: () => any;
-declare function subscribeStats(subscription: any): {
+declare const setClientProvider: (provider: any) => any;
+declare function subscribeStats(subscription: StatsSubscription, options?: StatsMonitorOptions, state?: StatsMonitorState): {
     stop(): void;
 };
 
@@ -429,20 +464,6 @@ declare const ipRegex: {
     }): RegExp;
 };
 
-declare class Logger {
-    _isEnabled: boolean;
-    _debugger: any;
-    constructor();
-    isEnabled(): boolean;
-    enable(): void;
-    disable(): void;
-    info(...params: any[]): void;
-    warn(...params: any[]): void;
-    error(...params: any[]): void;
-    withDebugLogger(myDebugger?: null): this;
-    debug(...params: any[]): void;
-}
-
 declare const getMediaSettings: (kind: string, isScreenShare: boolean, features: any) => {
     encodings: {}[];
 };
@@ -1359,4 +1380,4 @@ declare class RtcStream {
     static getTypeFromId(id: string): string;
 }
 
-export { type AddSpotlightRequest, type AudioEnableRequest, type AudioEnableRequestedEvent, type AudioEnabledEvent, BandwidthTester, type ChatMessage, type ClientKickedEvent, type ClientLeftEvent, type ClientMetadataPayload, type ClientMetadataReceivedEvent, type ClientRole, type CloudRecordingStartedEvent, type Credentials, EVENTS, type GetConstraintsOptions, type GetDeviceDataResult, type GetMediaConstraintsOptions, type GetStreamOptions, type GetStreamResult, type GetUpdatedDevicesResult, type IdentifyDeviceRequest, type JoinRoomRequest, KNOCK_MESSAGES, KalmanFilter, type KnockAcceptedEvent, type KnockRejectedEvent, type KnockRoomRequest, type KnockerLeftEvent, Logger, MAXIMUM_TURN_BANDWIDTH, MAXIMUM_TURN_BANDWIDTH_UNLIMITED, MEDIA_JITTER_BUFFER_TARGET, type NewClientEvent, NoDevicesError, P2pRtcManager, PROTOCOL_ERRORS, PROTOCOL_EVENTS, PROTOCOL_REQUESTS, PROTOCOL_RESPONSES, RELAY_MESSAGES, ReconnectManager, type RemoveSpotlightRequest, type RoleName, type RoomJoinedEvent, type RoomKnockedEvent, type RoomLockedEvent, type RoomSessionEndedEvent, type RtcClientConnectionStatusChangedPayload, RtcEventNames, type RtcEvents, type RtcLocalStreamTrackAddedPayload, type RtcLocalStreamTrackRemovedPayload, type RtcManager, type RtcManagerCreatedPayload, RtcManagerDispatcher, RtcStream, type RtcStreamAddedPayload, STREAM_TYPES, type ScreenshareStartedEvent, type ScreenshareStoppedEvent, type SendClientMetadataRequest, ServerSocket, Session, SfuV2Parser, type SignalClient, type SignalEvents, type SignalKnocker, type SignalRequests, type SocketConf, type SocketManager, type Spotlight, type SpotlightAddedEvent, type SpotlightRemovedEvent, TYPES, VegaConnection, VegaMediaQualityMonitor, VegaRtcManager, type VideoEnabledEvent, addAbsCaptureTimeExtMap, addExtMap, assert, buildDeviceList, calculateStd, captureAudioSsrcMetrics, captureCandidatePairInfoMetrics, captureCommonSsrcMetrics, captureSsrcInfo, captureVideoSsrcMetrics, changeMediaDirection, compareLocalDevices, createACFCalculator, createMicAnalyser, createWorker, deprioritizeH264, detectMicrophoneNotWorking, enumerate, filterMidExtension, filterMsidSemantic, fromLocation, generateByteString, getConstraints, getCurrentPeerConnections, getDeviceData, getDisplayMedia, getHandler, getIssuesAndMetrics, getMediaConstraints, getMediaSettings, getOptimalBitrate, getPeerConnectionIndex, getStats, getStream, getStream2, getUpdatedDevices, getUpdatedStats, getUserMedia, hasGetDisplayMedia, ipRegex, isMobile, isRelayed, maybeRejectNoH264, maybeTurnOnly, modifyMediaCapabilities, removePeerConnection, replaceSSRCs, replaceTracksInStream, _default as rtcManagerEvents, rtcStats, setClientProvider, setCodecPreferenceSDP, setPeerConnectionsForTests, setVideoBandwidthUsingSetParameters, standardDeviation, startPerformanceMonitor, stopStreamTracks, subscribeIssues, subscribeStats, variance };
+export { type AddSpotlightRequest, type AudioEnableRequest, type AudioEnableRequestedEvent, type AudioEnabledEvent, BandwidthTester, type ChatMessage, type ClientKickedEvent, type ClientLeftEvent, type ClientMetadataPayload, type ClientMetadataReceivedEvent, type ClientRole, type CloudRecordingStartedEvent, type Credentials, EVENTS, type GetConstraintsOptions, type GetDeviceDataResult, type GetMediaConstraintsOptions, type GetStreamOptions, type GetStreamResult, type GetUpdatedDevicesResult, type IdentifyDeviceRequest, type JoinRoomRequest, KNOCK_MESSAGES, KalmanFilter, type KnockAcceptedEvent, type KnockRejectedEvent, type KnockRoomRequest, type KnockerLeftEvent, Logger, MAXIMUM_TURN_BANDWIDTH, MAXIMUM_TURN_BANDWIDTH_UNLIMITED, MEDIA_JITTER_BUFFER_TARGET, type NewClientEvent, NoDevicesError, P2pRtcManager, PROTOCOL_ERRORS, PROTOCOL_EVENTS, PROTOCOL_REQUESTS, PROTOCOL_RESPONSES, RELAY_MESSAGES, ReconnectManager, type RemoveSpotlightRequest, type RoleName, type RoomJoinedEvent, type RoomKnockedEvent, type RoomLockedEvent, type RoomSessionEndedEvent, type RtcClientConnectionStatusChangedPayload, RtcEventNames, type RtcEvents, type RtcLocalStreamTrackAddedPayload, type RtcLocalStreamTrackRemovedPayload, type RtcManager, type RtcManagerCreatedPayload, RtcManagerDispatcher, RtcStream, type RtcStreamAddedPayload, STREAM_TYPES, type ScreenshareStartedEvent, type ScreenshareStoppedEvent, type SendClientMetadataRequest, ServerSocket, Session, SfuV2Parser, type SignalClient, type SignalEvents, type SignalKnocker, type SignalRequests, type SocketConf, type SocketManager, type Spotlight, type SpotlightAddedEvent, type SpotlightRemovedEvent, type StatsMonitorOptions, type StatsMonitorState, TYPES, VegaConnection, VegaMediaQualityMonitor, VegaRtcManager, type VideoEnabledEvent, addAbsCaptureTimeExtMap, addExtMap, assert, buildDeviceList, calculateStd, captureAudioSsrcMetrics, captureCandidatePairInfoMetrics, captureCommonSsrcMetrics, captureSsrcInfo, captureVideoSsrcMetrics, changeMediaDirection, compareLocalDevices, createACFCalculator, createMicAnalyser, createWorker, deprioritizeH264, detectMicrophoneNotWorking, enumerate, filterMidExtension, filterMsidSemantic, fromLocation, generateByteString, getConstraints, getCurrentPeerConnections, getDeviceData, getDisplayMedia, getHandler, getIssuesAndMetrics, getMediaConstraints, getMediaSettings, getOptimalBitrate, getPeerConnectionIndex, getStats, getStream, getStream2, getUpdatedDevices, getUpdatedStats, getUserMedia, hasGetDisplayMedia, ipRegex, isMobile, isRelayed, maybeRejectNoH264, maybeTurnOnly, modifyMediaCapabilities, removePeerConnection, replaceSSRCs, replaceTracksInStream, _default as rtcManagerEvents, rtcStats, setClientProvider, setCodecPreferenceSDP, setPeerConnectionsForTests, setVideoBandwidthUsingSetParameters, standardDeviation, startPerformanceMonitor, stopStreamTracks, subscribeIssues, subscribeStats, variance };