@whereby.com/media 1.4.2 → 1.5.1

package/dist/legacy-esm.js

@@ -10,6 +10,62 @@ import checkIp from 'check-ip';
 import validate from 'uuid-validate';
 import { io } from 'socket.io-client';
 
+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.
 
@@ -42,34 +98,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);
@@ -231,119 +259,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);
@@ -403,59 +346,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") {
@@ -466,20 +424,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;
@@ -507,10 +462,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") {
@@ -527,7 +480,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]) {
@@ -538,55 +491,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;
             }
         },
     };
@@ -4971,13 +4996,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/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@whereby.com/media",
     "description": "Media library for Whereby",
-    "version": "1.4.2",
+    "version": "1.5.1",
     "license": "MIT",
     "homepage": "https://github.com/whereby/sdk",
     "repository": {