@whereby.com/media 1.17.10 → 1.17.11

package/dist/index.cjs

@@ -8,8 +8,20 @@ var sdpTransform = require('sdp-transform');
 var ipAddress = require('ip-address');
 var checkIp = require('check-ip');
 var validate = require('uuid-validate');
-var mediasoupClient = require('mediasoup-client');
 var EventEmitter = require('events');
+var mediasoupClient = require('mediasoup-client');
+var uaParserJs = require('ua-parser-js');
+var Logger$1 = require('mediasoup-client/lib/Logger');
+var utils = require('mediasoup-client/lib/utils');
+var ortc = require('mediasoup-client/lib/ortc');
+var sdpCommonUtils = require('mediasoup-client/lib/handlers/sdp/commonUtils');
+var sdpUnifiedPlanUtils = require('mediasoup-client/lib/handlers/sdp/unifiedPlanUtils');
+var ortcUtils = require('mediasoup-client/lib/handlers/ortc/utils');
+var errors = require('mediasoup-client/lib/errors');
+var HandlerInterface = require('mediasoup-client/lib/handlers/HandlerInterface');
+var RemoteSdp = require('mediasoup-client/lib/handlers/sdp/RemoteSdp');
+var scalabilityModes = require('mediasoup-client/lib/scalabilityModes');
+var Safari12_js = require('mediasoup-client/lib/handlers/Safari12.js');
 var socket_ioClient = require('socket.io-client');
 
 function _interopNamespaceDefault(e) {
@@ -30,6 +42,11 @@ function _interopNamespaceDefault(e) {
 }
 
 var sdpTransform__namespace = /*#__PURE__*/_interopNamespaceDefault(sdpTransform);
+var utils__namespace = /*#__PURE__*/_interopNamespaceDefault(utils);
+var ortc__namespace = /*#__PURE__*/_interopNamespaceDefault(ortc);
+var sdpCommonUtils__namespace = /*#__PURE__*/_interopNamespaceDefault(sdpCommonUtils);
+var sdpUnifiedPlanUtils__namespace = /*#__PURE__*/_interopNamespaceDefault(sdpUnifiedPlanUtils);
+var ortcUtils__namespace = /*#__PURE__*/_interopNamespaceDefault(ortcUtils);
 
 const debugOn = process.env.NODE_ENV === "development" || new URLSearchParams(window.location.search).has("debug");
 class Logger {
@@ -852,7 +869,7 @@ function subscribeStats(subscription, options = OPTIONS, state = STATE) {
 
 var _a$6;
 const adapter$6 = (_a$6 = adapterRaw.default) !== null && _a$6 !== void 0 ? _a$6 : adapterRaw;
-const logger$a = new Logger();
+const logger$b = new Logger();
 const browserName$2 = adapter$6.browserDetails.browser;
 const browserVersion$1 = adapter$6.browserDetails.version;
 function setCodecPreferenceSDP(sdp, vp9On, redOn) {
@@ -893,7 +910,7 @@ function setCodecPreferenceSDP(sdp, vp9On, redOn) {
         return newSdp;
     }
     catch (error) {
-        logger$a.error("setCodecPreferenceSDP error:", error);
+        logger$b.error("setCodecPreferenceSDP error:", error);
     }
 }
 function cleanSdp(sdp) {
@@ -1102,7 +1119,7 @@ const MEDIA_JITTER_BUFFER_TARGET = 400;
 
 var _a$5;
 const adapter$5 = (_a$5 = adapterRaw.default) !== null && _a$5 !== void 0 ? _a$5 : adapterRaw;
-const logger$9 = new Logger();
+const logger$a = new Logger();
 class Session {
     constructor({ peerConnectionId, bandwidth, maximumTurnBandwidth, deprioritizeH264Encoding, }) {
         this.peerConnectionId = peerConnectionId;
@@ -1247,7 +1264,7 @@ class Session {
         return this._setRemoteDescription(desc).then(() => {
             return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
         }, (e) => {
-            logger$9.warn("Could not set remote description from remote answer: ", e);
+            logger$a.warn("Could not set remote description from remote answer: ", e);
         });
     }
     addIceCandidate(candidate) {
@@ -1263,7 +1280,7 @@ class Session {
                 return;
             }
             this.pc.addIceCandidate(candidate).catch((e) => {
-                logger$9.warn("Failed to add ICE candidate ('%s'): %s", candidate ? candidate.candidate : null, e);
+                logger$a.warn("Failed to add ICE candidate ('%s'): %s", candidate ? candidate.candidate : null, e);
             });
         });
     }
@@ -1282,7 +1299,7 @@ class Session {
             pc.close();
         }
         catch (e) {
-            logger$9.warn("failures during close of session", e);
+            logger$a.warn("failures during close of session", e);
         }
     }
     hasConnectedPeerConnection() {
@@ -1735,7 +1752,7 @@ var rtcManagerEvents = {
 
 var _a$3, _b;
 const adapter$3 = (_a$3 = adapterRaw.default) !== null && _a$3 !== void 0 ? _a$3 : adapterRaw;
-const logger$8 = new Logger();
+const logger$9 = new Logger();
 const ICE_PUBLIC_IP_GATHERING_TIMEOUT = 3 * 1000;
 const CAMERA_STREAM_ID = RtcStream.getCameraId();
 const browserName$1 = adapter$3.browserDetails.browser;
@@ -1885,7 +1902,7 @@ class P2pRtcManager {
             () => this._clearMediaServersRefresh(),
             this._serverSocket.on(PROTOCOL_RESPONSES.MEDIASERVER_CONFIG, (data) => {
                 if (data.error) {
-                    logger$8.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
+                    logger$9.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
                     return;
                 }
                 this._updateAndScheduleMediaServersRefresh(data);
@@ -1896,7 +1913,7 @@ class P2pRtcManager {
             this._serverSocket.on(RELAY_MESSAGES.ICE_CANDIDATE, (data) => {
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    logger$8.warn("No RTCPeerConnection on ICE_CANDIDATE", data);
+                    logger$9.warn("No RTCPeerConnection on ICE_CANDIDATE", data);
                     return;
                 }
                 session.addIceCandidate(data.message);
@@ -1904,7 +1921,7 @@ class P2pRtcManager {
             this._serverSocket.on(RELAY_MESSAGES.ICE_END_OF_CANDIDATES, (data) => {
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    logger$8.warn("No RTCPeerConnection on ICE_END_OF_CANDIDATES", data);
+                    logger$9.warn("No RTCPeerConnection on ICE_END_OF_CANDIDATES", data);
                     return;
                 }
                 session.addIceCandidate(null);
@@ -1913,7 +1930,7 @@ class P2pRtcManager {
                 var _a, _b;
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    logger$8.warn("No RTCPeerConnection on SDP_OFFER", data);
+                    logger$9.warn("No RTCPeerConnection on SDP_OFFER", data);
                     return;
                 }
                 const offer = this._transformIncomingSdp(data.message, session.pc);
@@ -1932,7 +1949,7 @@ class P2pRtcManager {
                 var _a, _b;
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    logger$8.warn("No RTCPeerConnection on SDP_ANSWER", data);
+                    logger$9.warn("No RTCPeerConnection on SDP_ANSWER", data);
                     return;
                 }
                 const answer = this._transformIncomingSdp(data.message, session.pc);
@@ -1949,7 +1966,7 @@ class P2pRtcManager {
                 }
                 const screenshareStream = this.localStreams[screenShareStreamId];
                 if (!screenshareStream) {
-                    logger$8.warn("screenshare stream %s not found", screenShareStreamId);
+                    logger$9.warn("screenshare stream %s not found", screenShareStreamId);
                     return;
                 }
                 const hasAudioTrack = screenshareStream.getAudioTracks().length > 0;
@@ -2026,7 +2043,7 @@ class P2pRtcManager {
             });
         }
         catch (error) {
-            logger$8.error("Error during setting jitter buffer target:", error);
+            logger$9.error("Error during setting jitter buffer target:", error);
         }
     }
     _emitServerEvent(eventName, data, callback) {
@@ -2289,7 +2306,7 @@ class P2pRtcManager {
     _cleanup(peerConnectionId) {
         const session = this._getSession(peerConnectionId);
         if (!session) {
-            logger$8.warn("No RTCPeerConnection in RTCManager.disconnect()", peerConnectionId);
+            logger$9.warn("No RTCPeerConnection in RTCManager.disconnect()", peerConnectionId);
             return;
         }
         session.close();
@@ -2314,17 +2331,17 @@ class P2pRtcManager {
         const promises = [];
         this._forEachPeerConnection((session) => {
             if (!session.hasConnectedPeerConnection()) {
-                logger$8.info("Session doesn't have a connected PeerConnection, adding pending action!");
+                logger$9.info("Session doesn't have a connected PeerConnection, adding pending action!");
                 const pendingActions = this._pendingActionsForConnectedPeerConnections;
                 if (!pendingActions) {
-                    logger$8.warn(`No pending action is created to replace track, because the pending actions array is null`);
+                    logger$9.warn(`No pending action is created to replace track, because the pending actions array is null`);
                     return;
                 }
                 const promise = new Promise((resolve, reject) => {
                     const action = () => {
                         const replacedTrackPromise = session.replaceTrack(oldTrack, newTrack);
                         if (!replacedTrackPromise) {
-                            logger$8.error("replaceTrack returned false!");
+                            logger$9.error("replaceTrack returned false!");
                             reject(`ReplaceTrack returned false`);
                             return;
                         }
@@ -2337,7 +2354,7 @@ class P2pRtcManager {
             }
             const replacedTrackResult = session.replaceTrack(oldTrack, newTrack);
             if (!replacedTrackResult) {
-                logger$8.error("replaceTrack returned false!");
+                logger$9.error("replaceTrack returned false!");
                 return;
             }
             promises.push(replacedTrackResult);
@@ -2398,7 +2415,7 @@ class P2pRtcManager {
         let session = this._getSession(clientId);
         let initialBandwidth = (session && session.bandwidth) || 0;
         if (session) {
-            logger$8.warn("Replacing peer session", clientId);
+            logger$9.warn("Replacing peer session", clientId);
             this._cleanup(clientId);
         }
         else {
@@ -2473,12 +2490,12 @@ class P2pRtcManager {
             });
         }
         catch (error) {
-            logger$8.error("Error during setting setCodecPreferences:", error);
+            logger$9.error("Error during setting setCodecPreferences:", error);
         }
     }
     _negotiatePeerConnection(clientId, session, constraints) {
         if (!session) {
-            logger$8.warn("No RTCPeerConnection in negotiatePeerConnection()", clientId);
+            logger$9.warn("No RTCPeerConnection in negotiatePeerConnection()", clientId);
             return;
         }
         const pc = session.pc;
@@ -2504,7 +2521,7 @@ class P2pRtcManager {
                 offer.sdp = cleanSdp(offer.sdp);
             pc.setLocalDescription(offer)
                 .catch((e) => {
-                logger$8.warn("RTCPeerConnection.setLocalDescription() failed with local offer", e);
+                logger$9.warn("RTCPeerConnection.setLocalDescription() failed with local offer", e);
                 this._emit(rtcManagerEvents.PC_SLD_FAILURE, e);
                 throw e;
             })
@@ -2516,7 +2533,7 @@ class P2pRtcManager {
             });
         })
             .catch((e) => {
-            logger$8.warn("RTCPeerConnection.createOffer() failed to create local offer", e);
+            logger$9.warn("RTCPeerConnection.createOffer() failed to create local offer", e);
         });
     }
     _withForcedRenegotiation(session, action) {
@@ -2647,7 +2664,7 @@ class P2pRtcManager {
                             }
                         }
                         catch (error) {
-                            logger$8.info("Error during parsing candidates! Error: ", { error });
+                            logger$9.info("Error during parsing candidates! Error: ", { error });
                         }
                         break;
                     case "srflx":
@@ -2703,7 +2720,7 @@ class P2pRtcManager {
         }
         let initialBandwidth = (session && session.bandwidth) || 0;
         if (session) {
-            logger$8.warn("Replacing peer session", clientId);
+            logger$9.warn("Replacing peer session", clientId);
             this._cleanup(clientId);
         }
         else {
@@ -2912,7 +2929,7 @@ class SfuV2Parser {
     }
 }
 
-const logger$7 = new Logger();
+const logger$8 = new Logger();
 class VegaConnection extends EventEmitter.EventEmitter {
     constructor(wsUrl, protocol = "whereby-sfu#v4") {
         super();
@@ -2945,12 +2962,12 @@ class VegaConnection extends EventEmitter.EventEmitter {
         (_a = this.socket) === null || _a === void 0 ? void 0 : _a.close();
     }
     _onOpen() {
-        logger$7.info("Connected");
+        logger$8.info("Connected");
         this.emit("open");
     }
     _onMessage(event) {
         const socketMessage = SfuV2Parser.parse(event.data);
-        logger$7.info("Received message", socketMessage);
+        logger$8.info("Received message", socketMessage);
         if (socketMessage === null || socketMessage === void 0 ? void 0 : socketMessage.response) {
             this._handleResponse(socketMessage);
         }
@@ -2959,11 +2976,11 @@ class VegaConnection extends EventEmitter.EventEmitter {
         }
     }
     _onClose() {
-        logger$7.info("Disconnected");
+        logger$8.info("Disconnected");
         this._tearDown();
     }
     _onError(error) {
-        logger$7.info("Error", error);
+        logger$8.info("Error", error);
     }
     _handleResponse(socketMessage) {
         const sent = this.sents.get(socketMessage.id);
@@ -3129,7 +3146,7 @@ const defaultParams = {
     scoreFormula: "300 * bands[1].avg / Math.max(bands[1].avg + bands[0].avg, 0.01)",
     outFormula: "score",
 };
-const logger$6 = new Logger();
+const logger$7 = new Logger();
 function createMicAnalyser({ micTrack, params, onScoreUpdated, }) {
     const audioCtx = new AudioContext();
     let analyser = null;
@@ -3151,7 +3168,7 @@ function createMicAnalyser({ micTrack, params, onScoreUpdated, }) {
                 lastTrackWasOurs = true;
             }
             catch (ex) {
-                logger$6.warn("unable to fetch new track for colocation speaker analysis, using current", ex);
+                logger$7.warn("unable to fetch new track for colocation speaker analysis, using current", ex);
             }
         }
         lastTrack = track;
@@ -3238,7 +3255,7 @@ function createMicAnalyser({ micTrack, params, onScoreUpdated, }) {
     };
 }
 
-const logger$5 = new Logger();
+const logger$6 = new Logger();
 const MEDIA_QUALITY = Object.freeze({
     ok: "ok",
     warning: "warning",
@@ -3308,7 +3325,7 @@ class VegaMediaQualityMonitor extends EventEmitter {
     }
     addProducer(clientId, producerId) {
         if (!clientId || !producerId || !(typeof clientId === "string" && typeof producerId === "string")) {
-            logger$5.warn("Missing clientId or producerId");
+            logger$6.warn("Missing clientId or producerId");
             return;
         }
         if (!this._producers[clientId]) {
@@ -3324,7 +3341,7 @@ class VegaMediaQualityMonitor extends EventEmitter {
     }
     addConsumer(clientId, consumerId) {
         if (!clientId || !consumerId) {
-            logger$5.warn("Missing clientId or consumerId");
+            logger$6.warn("Missing clientId or consumerId");
             return;
         }
         if (!this._producers[clientId]) {
@@ -3342,14 +3359,14 @@ class VegaMediaQualityMonitor extends EventEmitter {
         if (!Array.isArray(score) ||
             score.length === 0 ||
             score.some((s) => !s || !s.hasOwnProperty("score") || typeof s.score !== "number" || isNaN(s.score))) {
-            logger$5.warn("Unexpected producer score format");
+            logger$6.warn("Unexpected producer score format");
             return;
         }
         this._producers[clientId][producerId] = { kind, score: this._calcAvgProducerScore(score.map((s) => s.score)) };
     }
     addConsumerScore(clientId, consumerId, kind, score) {
         if (!score || !score.hasOwnProperty("producerScores") || !Array.isArray(score.producerScores)) {
-            logger$5.warn("Unexpected consumer score format");
+            logger$6.warn("Unexpected consumer score format");
             return;
         }
         this._producers[clientId][consumerId] = { kind, score: this._calcAvgProducerScore(score.producerScores) };
@@ -3386,7 +3403,7 @@ class VegaMediaQualityMonitor extends EventEmitter {
             }
         }
         catch (error) {
-            logger$5.error(error);
+            logger$6.error(error);
             return 0;
         }
     }
@@ -3495,11 +3512,704 @@ const modifyMediaCapabilities = (routerRtpCapabilities, features) => {
     }
 };
 
-const getHandler = () => {
-    let handlerName = mediasoupClient.detectDevice() || (/applecoremedia|applewebkit|safari/i.test(navigator.userAgent) ? "Safari12" : undefined);
+const logger$5 = new Logger$1.Logger("Safari17");
+const NAME = "Safari17";
+const SCTP_NUM_STREAMS = { OS: 1024, MIS: 1024 };
+class Safari17 extends HandlerInterface.HandlerInterface {
+    static createFactory() {
+        return () => new Safari17();
+    }
+    constructor() {
+        super();
+        this._closed = false;
+        this._mapMidTransceiver = new Map();
+        this._sendStream = new MediaStream();
+        this._hasDataChannelMediaSection = false;
+        this._nextSendSctpStreamId = 0;
+        this._transportReady = false;
+    }
+    get name() {
+        return NAME;
+    }
+    close() {
+        logger$5.debug("close()");
+        if (this._closed) {
+            return;
+        }
+        this._closed = true;
+        if (this._pc) {
+            try {
+                this._pc.close();
+            }
+            catch (error) { }
+        }
+        this.emit("@close");
+    }
+    getNativeRtpCapabilities() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger$5.debug("getNativeRtpCapabilities()");
+            const pc = new RTCPeerConnection({
+                iceServers: [],
+                iceTransportPolicy: "all",
+                bundlePolicy: "max-bundle",
+                rtcpMuxPolicy: "require",
+            });
+            try {
+                pc.addTransceiver("audio");
+                pc.addTransceiver("video");
+                const offer = yield pc.createOffer();
+                try {
+                    pc.close();
+                }
+                catch (error) { }
+                const sdpObject = sdpTransform__namespace.parse(offer.sdp);
+                const nativeRtpCapabilities = sdpCommonUtils__namespace.extractRtpCapabilities({
+                    sdpObject,
+                });
+                ortcUtils__namespace.addNackSuppportForOpus(nativeRtpCapabilities);
+                return nativeRtpCapabilities;
+            }
+            catch (error) {
+                try {
+                    pc.close();
+                }
+                catch (error2) { }
+                throw error;
+            }
+        });
+    }
+    getNativeSctpCapabilities() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger$5.debug("getNativeSctpCapabilities()");
+            return {
+                numStreams: SCTP_NUM_STREAMS,
+            };
+        });
+    }
+    run({ direction, iceParameters, iceCandidates, dtlsParameters, sctpParameters, iceServers, iceTransportPolicy, additionalSettings, proprietaryConstraints, extendedRtpCapabilities, }) {
+        this.assertNotClosed();
+        logger$5.debug("run()");
+        this._direction = direction;
+        this._remoteSdp = new RemoteSdp.RemoteSdp({
+            iceParameters,
+            iceCandidates,
+            dtlsParameters,
+            sctpParameters,
+        });
+        this._sendingRtpParametersByKind = {
+            audio: ortc__namespace.getSendingRtpParameters("audio", extendedRtpCapabilities),
+            video: ortc__namespace.getSendingRtpParameters("video", extendedRtpCapabilities),
+        };
+        this._sendingRemoteRtpParametersByKind = {
+            audio: ortc__namespace.getSendingRemoteRtpParameters("audio", extendedRtpCapabilities),
+            video: ortc__namespace.getSendingRemoteRtpParameters("video", extendedRtpCapabilities),
+        };
+        if (dtlsParameters.role && dtlsParameters.role !== "auto") {
+            this._forcedLocalDtlsRole = dtlsParameters.role === "server" ? "client" : "server";
+        }
+        this._pc = new RTCPeerConnection(Object.assign({ iceServers: iceServers !== null && iceServers !== void 0 ? iceServers : [], iceTransportPolicy: iceTransportPolicy !== null && iceTransportPolicy !== void 0 ? iceTransportPolicy : "all", bundlePolicy: "max-bundle", rtcpMuxPolicy: "require" }, additionalSettings), proprietaryConstraints);
+        this._pc.addEventListener("icegatheringstatechange", () => {
+            this.emit("@icegatheringstatechange", this._pc.iceGatheringState);
+        });
+        if (this._pc.connectionState) {
+            this._pc.addEventListener("connectionstatechange", () => {
+                this.emit("@connectionstatechange", this._pc.connectionState);
+            });
+        }
+        else {
+            this._pc.addEventListener("iceconnectionstatechange", () => {
+                logger$5.warn("run() | pc.connectionState not supported, using pc.iceConnectionState");
+                switch (this._pc.iceConnectionState) {
+                    case "checking": {
+                        this.emit("@connectionstatechange", "connecting");
+                        break;
+                    }
+                    case "connected":
+                    case "completed": {
+                        this.emit("@connectionstatechange", "connected");
+                        break;
+                    }
+                    case "failed": {
+                        this.emit("@connectionstatechange", "failed");
+                        break;
+                    }
+                    case "disconnected": {
+                        this.emit("@connectionstatechange", "disconnected");
+                        break;
+                    }
+                    case "closed": {
+                        this.emit("@connectionstatechange", "closed");
+                        break;
+                    }
+                }
+            });
+        }
+    }
+    updateIceServers(iceServers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            logger$5.debug("updateIceServers()");
+            const configuration = this._pc.getConfiguration();
+            configuration.iceServers = iceServers;
+            this._pc.setConfiguration(configuration);
+        });
+    }
+    restartIce(iceParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            logger$5.debug("restartIce()");
+            this._remoteSdp.updateIceParameters(iceParameters);
+            if (!this._transportReady) {
+                return;
+            }
+            if (this._direction === "send") {
+                const offer = yield this._pc.createOffer({ iceRestart: true });
+                logger$5.debug("restartIce() | calling pc.setLocalDescription() [offer:%o]", offer);
+                yield this._pc.setLocalDescription(offer);
+                const answer = { type: "answer", sdp: this._remoteSdp.getSdp() };
+                logger$5.debug("restartIce() | calling pc.setRemoteDescription() [answer:%o]", answer);
+                yield this._pc.setRemoteDescription(answer);
+            }
+            else {
+                const offer = { type: "offer", sdp: this._remoteSdp.getSdp() };
+                logger$5.debug("restartIce() | calling pc.setRemoteDescription() [offer:%o]", offer);
+                yield this._pc.setRemoteDescription(offer);
+                const answer = yield this._pc.createAnswer();
+                logger$5.debug("restartIce() | calling pc.setLocalDescription() [answer:%o]", answer);
+                yield this._pc.setLocalDescription(answer);
+            }
+        });
+    }
+    getTransportStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            return this._pc.getStats();
+        });
+    }
+    send({ track, encodings, codecOptions, codec, onRtpSender }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertSendDirection();
+            logger$5.debug("send() [kind:%s, track.id:%s]", track.kind, track.id);
+            const sendingRtpParameters = utils__namespace.clone(this._sendingRtpParametersByKind[track.kind]);
+            sendingRtpParameters.codecs = ortc__namespace.reduceCodecs(sendingRtpParameters.codecs, codec);
+            if (encodings && encodings.length > 1) {
+                let maxTemporalLayers = 1;
+                for (const encoding of encodings) {
+                    const temporalLayers = encoding.scalabilityMode
+                        ? scalabilityModes.parse(encoding.scalabilityMode).temporalLayers
+                        : 3;
+                    if (temporalLayers > maxTemporalLayers) {
+                        maxTemporalLayers = temporalLayers;
+                    }
+                }
+                encodings.forEach((encoding, idx) => {
+                    encoding.rid = `r${idx}`;
+                    encoding.scalabilityMode = `L1T${maxTemporalLayers}`;
+                });
+            }
+            const sendingRemoteRtpParameters = utils__namespace.clone(this._sendingRemoteRtpParametersByKind[track.kind]);
+            sendingRemoteRtpParameters.codecs = ortc__namespace.reduceCodecs(sendingRemoteRtpParameters.codecs, codec);
+            const mediaSectionIdx = this._remoteSdp.getNextMediaSectionIdx();
+            const transceiver = this._pc.addTransceiver(track, {
+                direction: "sendonly",
+                streams: [this._sendStream],
+                sendEncodings: encodings,
+            });
+            if (onRtpSender) {
+                onRtpSender(transceiver.sender);
+            }
+            const offer = yield this._pc.createOffer();
+            let localSdpObject = sdpTransform__namespace.parse(offer.sdp);
+            if (!this._transportReady) {
+                yield this.setupTransport({
+                    localDtlsRole: (_a = this._forcedLocalDtlsRole) !== null && _a !== void 0 ? _a : "client",
+                    localSdpObject,
+                });
+            }
+            const layers = scalabilityModes.parse((encodings !== null && encodings !== void 0 ? encodings : [{}])[0].scalabilityMode);
+            logger$5.debug("send() | calling pc.setLocalDescription() [offer:%o]", offer);
+            yield this._pc.setLocalDescription(offer);
+            const localId = transceiver.mid;
+            sendingRtpParameters.mid = localId;
+            localSdpObject = sdpTransform__namespace.parse(this._pc.localDescription.sdp);
+            const offerMediaObject = localSdpObject.media[mediaSectionIdx.idx];
+            sendingRtpParameters.rtcp.cname = sdpCommonUtils__namespace.getCname({
+                offerMediaObject,
+            });
+            if (!encodings) {
+                sendingRtpParameters.encodings = sdpUnifiedPlanUtils__namespace.getRtpEncodings({
+                    offerMediaObject,
+                });
+            }
+            else if (encodings.length === 1) {
+                const newEncodings = sdpUnifiedPlanUtils__namespace.getRtpEncodings({
+                    offerMediaObject,
+                });
+                Object.assign(newEncodings[0], encodings[0]);
+                sendingRtpParameters.encodings = newEncodings;
+            }
+            else {
+                sendingRtpParameters.encodings = encodings;
+            }
+            if (sendingRtpParameters.encodings.length > 1 &&
+                (sendingRtpParameters.codecs[0].mimeType.toLowerCase() === "video/vp8" ||
+                    sendingRtpParameters.codecs[0].mimeType.toLowerCase() === "video/h264")) {
+                for (const encoding of sendingRtpParameters.encodings) {
+                    if (encoding.scalabilityMode) {
+                        encoding.scalabilityMode = `L1T${layers.temporalLayers}`;
+                    }
+                    else {
+                        encoding.scalabilityMode = "L1T3";
+                    }
+                }
+            }
+            this._remoteSdp.send({
+                offerMediaObject,
+                reuseMid: mediaSectionIdx.reuseMid,
+                offerRtpParameters: sendingRtpParameters,
+                answerRtpParameters: sendingRemoteRtpParameters,
+                codecOptions,
+            });
+            const answer = { type: "answer", sdp: this._remoteSdp.getSdp() };
+            logger$5.debug("send() | calling pc.setRemoteDescription() [answer:%o]", answer);
+            yield this._pc.setRemoteDescription(answer);
+            this._mapMidTransceiver.set(localId, transceiver);
+            return {
+                localId,
+                rtpParameters: sendingRtpParameters,
+                rtpSender: transceiver.sender,
+            };
+        });
+    }
+    stopSending(localId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertSendDirection();
+            if (this._closed) {
+                return;
+            }
+            logger$5.debug("stopSending() [localId:%s]", localId);
+            const transceiver = this._mapMidTransceiver.get(localId);
+            if (!transceiver) {
+                throw new Error("associated RTCRtpTransceiver not found");
+            }
+            void transceiver.sender.replaceTrack(null);
+            this._pc.removeTrack(transceiver.sender);
+            const mediaSectionClosed = this._remoteSdp.closeMediaSection(transceiver.mid);
+            if (mediaSectionClosed) {
+                try {
+                    transceiver.stop();
+                }
+                catch (error) { }
+            }
+            const offer = yield this._pc.createOffer();
+            logger$5.debug("stopSending() | calling pc.setLocalDescription() [offer:%o]", offer);
+            yield this._pc.setLocalDescription(offer);
+            const answer = { type: "answer", sdp: this._remoteSdp.getSdp() };
+            logger$5.debug("stopSending() | calling pc.setRemoteDescription() [answer:%o]", answer);
+            yield this._pc.setRemoteDescription(answer);
+            this._mapMidTransceiver.delete(localId);
+        });
+    }
+    pauseSending(localId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertSendDirection();
+            logger$5.debug("pauseSending() [localId:%s]", localId);
+            const transceiver = this._mapMidTransceiver.get(localId);
+            if (!transceiver) {
+                throw new Error("associated RTCRtpTransceiver not found");
+            }
+            transceiver.direction = "inactive";
+            this._remoteSdp.pauseMediaSection(localId);
+            const offer = yield this._pc.createOffer();
+            logger$5.debug("pauseSending() | calling pc.setLocalDescription() [offer:%o]", offer);
+            yield this._pc.setLocalDescription(offer);
+            const answer = { type: "answer", sdp: this._remoteSdp.getSdp() };
+            logger$5.debug("pauseSending() | calling pc.setRemoteDescription() [answer:%o]", answer);
+            yield this._pc.setRemoteDescription(answer);
+        });
+    }
+    resumeSending(localId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertSendDirection();
+            logger$5.debug("resumeSending() [localId:%s]", localId);
+            const transceiver = this._mapMidTransceiver.get(localId);
+            if (!transceiver) {
+                throw new Error("associated RTCRtpTransceiver not found");
+            }
+            transceiver.direction = "sendonly";
+            this._remoteSdp.resumeSendingMediaSection(localId);
+            const offer = yield this._pc.createOffer();
+            logger$5.debug("resumeSending() | calling pc.setLocalDescription() [offer:%o]", offer);
+            yield this._pc.setLocalDescription(offer);
+            const answer = { type: "answer", sdp: this._remoteSdp.getSdp() };
+            logger$5.debug("resumeSending() | calling pc.setRemoteDescription() [answer:%o]", answer);
+            yield this._pc.setRemoteDescription(answer);
+        });
+    }
+    replaceTrack(localId, track) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertSendDirection();
+            if (track) {
+                logger$5.debug("replaceTrack() [localId:%s, track.id:%s]", localId, track.id);
+            }
+            else {
+                logger$5.debug("replaceTrack() [localId:%s, no track]", localId);
+            }
+            const transceiver = this._mapMidTransceiver.get(localId);
+            if (!transceiver) {
+                throw new Error("associated RTCRtpTransceiver not found");
+            }
+            yield transceiver.sender.replaceTrack(track);
+        });
+    }
+    setMaxSpatialLayer(localId, spatialLayer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertSendDirection();
+            logger$5.debug("setMaxSpatialLayer() [localId:%s, spatialLayer:%s]", localId, spatialLayer);
+            const transceiver = this._mapMidTransceiver.get(localId);
+            if (!transceiver) {
+                throw new Error("associated RTCRtpTransceiver not found");
+            }
+            const parameters = transceiver.sender.getParameters();
+            parameters.encodings.forEach((encoding, idx) => {
+                if (idx <= spatialLayer) {
+                    encoding.active = true;
+                }
+                else {
+                    encoding.active = false;
+                }
+            });
+            yield transceiver.sender.setParameters(parameters);
+            this._remoteSdp.muxMediaSectionSimulcast(localId, parameters.encodings);
+            const offer = yield this._pc.createOffer();
+            logger$5.debug("setMaxSpatialLayer() | calling pc.setLocalDescription() [offer:%o]", offer);
+            yield this._pc.setLocalDescription(offer);
+            const answer = { type: "answer", sdp: this._remoteSdp.getSdp() };
+            logger$5.debug("setMaxSpatialLayer() | calling pc.setRemoteDescription() [answer:%o]", answer);
+            yield this._pc.setRemoteDescription(answer);
+        });
+    }
+    setRtpEncodingParameters(localId, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertSendDirection();
+            logger$5.debug("setRtpEncodingParameters() [localId:%s, params:%o]", localId, params);
+            const transceiver = this._mapMidTransceiver.get(localId);
+            if (!transceiver) {
+                throw new Error("associated RTCRtpTransceiver not found");
+            }
+            const parameters = transceiver.sender.getParameters();
+            parameters.encodings.forEach((encoding, idx) => {
+                parameters.encodings[idx] = Object.assign(Object.assign({}, encoding), params);
+            });
+            yield transceiver.sender.setParameters(parameters);
+            this._remoteSdp.muxMediaSectionSimulcast(localId, parameters.encodings);
+            const offer = yield this._pc.createOffer();
+            logger$5.debug("setRtpEncodingParameters() | calling pc.setLocalDescription() [offer:%o]", offer);
+            yield this._pc.setLocalDescription(offer);
+            const answer = { type: "answer", sdp: this._remoteSdp.getSdp() };
+            logger$5.debug("setRtpEncodingParameters() | calling pc.setRemoteDescription() [answer:%o]", answer);
+            yield this._pc.setRemoteDescription(answer);
+        });
+    }
+    getSenderStats(localId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertSendDirection();
+            const transceiver = this._mapMidTransceiver.get(localId);
+            if (!transceiver) {
+                throw new Error("associated RTCRtpTransceiver not found");
+            }
+            return transceiver.sender.getStats();
+        });
+    }
+    sendDataChannel({ ordered, maxPacketLifeTime, maxRetransmits, label, protocol, }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertSendDirection();
+            const options = {
+                negotiated: true,
+                id: this._nextSendSctpStreamId,
+                ordered,
+                maxPacketLifeTime,
+                maxRetransmits,
+                protocol,
+            };
+            logger$5.debug("sendDataChannel() [options:%o]", options);
+            const dataChannel = this._pc.createDataChannel(label, options);
+            this._nextSendSctpStreamId = ++this._nextSendSctpStreamId % SCTP_NUM_STREAMS.MIS;
+            if (!this._hasDataChannelMediaSection) {
+                const offer = yield this._pc.createOffer();
+                const localSdpObject = sdpTransform__namespace.parse(offer.sdp);
+                const offerMediaObject = localSdpObject.media.find((m) => m.type === "application");
+                if (!this._transportReady) {
+                    yield this.setupTransport({
+                        localDtlsRole: (_a = this._forcedLocalDtlsRole) !== null && _a !== void 0 ? _a : "client",
+                        localSdpObject,
+                    });
+                }
+                logger$5.debug("sendDataChannel() | calling pc.setLocalDescription() [offer:%o]", offer);
+                yield this._pc.setLocalDescription(offer);
+                this._remoteSdp.sendSctpAssociation({ offerMediaObject });
+                const answer = { type: "answer", sdp: this._remoteSdp.getSdp() };
+                logger$5.debug("sendDataChannel() | calling pc.setRemoteDescription() [answer:%o]", answer);
+                yield this._pc.setRemoteDescription(answer);
+                this._hasDataChannelMediaSection = true;
+            }
+            const sctpStreamParameters = {
+                streamId: options.id,
+                ordered: options.ordered,
+                maxPacketLifeTime: options.maxPacketLifeTime,
+                maxRetransmits: options.maxRetransmits,
+            };
+            return { dataChannel, sctpStreamParameters };
+        });
+    }
+    receive(optionsList) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertRecvDirection();
+            const results = [];
+            const mapLocalId = new Map();
+            for (const options of optionsList) {
+                const { trackId, kind, rtpParameters, streamId } = options;
+                logger$5.debug("receive() [trackId:%s, kind:%s]", trackId, kind);
+                const localId = (_a = rtpParameters.mid) !== null && _a !== void 0 ? _a : String(this._mapMidTransceiver.size);
+                mapLocalId.set(trackId, localId);
+                this._remoteSdp.receive({
+                    mid: localId,
+                    kind,
+                    offerRtpParameters: rtpParameters,
+                    streamId: streamId !== null && streamId !== void 0 ? streamId : rtpParameters.rtcp.cname,
+                    trackId,
+                });
+            }
+            const offer = { type: "offer", sdp: this._remoteSdp.getSdp() };
+            logger$5.debug("receive() | calling pc.setRemoteDescription() [offer:%o]", offer);
+            yield this._pc.setRemoteDescription(offer);
+            for (const options of optionsList) {
+                const { trackId, onRtpReceiver } = options;
+                if (onRtpReceiver) {
+                    const localId = mapLocalId.get(trackId);
+                    const transceiver = this._pc.getTransceivers().find((t) => t.mid === localId);
+                    if (!transceiver) {
+                        throw new Error("transceiver not found");
+                    }
+                    onRtpReceiver(transceiver.receiver);
+                }
+            }
+            let answer = yield this._pc.createAnswer();
+            const localSdpObject = sdpTransform__namespace.parse(answer.sdp);
+            for (const options of optionsList) {
+                const { trackId, rtpParameters } = options;
+                const localId = mapLocalId.get(trackId);
+                const answerMediaObject = localSdpObject.media.find((m) => String(m.mid) === localId);
+                sdpCommonUtils__namespace.applyCodecParameters({
+                    offerRtpParameters: rtpParameters,
+                    answerMediaObject,
+                });
+            }
+            answer = { type: "answer", sdp: sdpTransform__namespace.write(localSdpObject) };
+            if (!this._transportReady) {
+                yield this.setupTransport({
+                    localDtlsRole: (_b = this._forcedLocalDtlsRole) !== null && _b !== void 0 ? _b : "client",
+                    localSdpObject,
+                });
+            }
+            logger$5.debug("receive() | calling pc.setLocalDescription() [answer:%o]", answer);
+            yield this._pc.setLocalDescription(answer);
+            for (const options of optionsList) {
+                const { trackId } = options;
+                const localId = mapLocalId.get(trackId);
+                const transceiver = this._pc.getTransceivers().find((t) => t.mid === localId);
+                if (!transceiver) {
+                    throw new Error("new RTCRtpTransceiver not found");
+                }
+                this._mapMidTransceiver.set(localId, transceiver);
+                results.push({
+                    localId,
+                    track: transceiver.receiver.track,
+                    rtpReceiver: transceiver.receiver,
+                });
+            }
+            return results;
+        });
+    }
+    stopReceiving(localIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertRecvDirection();
+            if (this._closed) {
+                return;
+            }
+            for (const localId of localIds) {
+                logger$5.debug("stopReceiving() [localId:%s]", localId);
+                const transceiver = this._mapMidTransceiver.get(localId);
+                if (!transceiver) {
+                    throw new Error("associated RTCRtpTransceiver not found");
+                }
+                this._remoteSdp.closeMediaSection(transceiver.mid);
+            }
+            const offer = { type: "offer", sdp: this._remoteSdp.getSdp() };
+            logger$5.debug("stopReceiving() | calling pc.setRemoteDescription() [offer:%o]", offer);
+            yield this._pc.setRemoteDescription(offer);
+            const answer = yield this._pc.createAnswer();
+            logger$5.debug("stopReceiving() | calling pc.setLocalDescription() [answer:%o]", answer);
+            yield this._pc.setLocalDescription(answer);
+            for (const localId of localIds) {
+                this._mapMidTransceiver.delete(localId);
+            }
+        });
+    }
+    pauseReceiving(localIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertRecvDirection();
+            for (const localId of localIds) {
+                logger$5.debug("pauseReceiving() [localId:%s]", localId);
+                const transceiver = this._mapMidTransceiver.get(localId);
+                if (!transceiver) {
+                    throw new Error("associated RTCRtpTransceiver not found");
+                }
+                transceiver.direction = "inactive";
+                this._remoteSdp.pauseMediaSection(localId);
+            }
+            const offer = { type: "offer", sdp: this._remoteSdp.getSdp() };
+            logger$5.debug("pauseReceiving() | calling pc.setRemoteDescription() [offer:%o]", offer);
+            yield this._pc.setRemoteDescription(offer);
+            const answer = yield this._pc.createAnswer();
+            logger$5.debug("pauseReceiving() | calling pc.setLocalDescription() [answer:%o]", answer);
+            yield this._pc.setLocalDescription(answer);
+        });
+    }
+    resumeReceiving(localIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertRecvDirection();
+            for (const localId of localIds) {
+                logger$5.debug("resumeReceiving() [localId:%s]", localId);
+                const transceiver = this._mapMidTransceiver.get(localId);
+                if (!transceiver) {
+                    throw new Error("associated RTCRtpTransceiver not found");
+                }
+                transceiver.direction = "recvonly";
+                this._remoteSdp.resumeReceivingMediaSection(localId);
+            }
+            const offer = { type: "offer", sdp: this._remoteSdp.getSdp() };
+            logger$5.debug("resumeReceiving() | calling pc.setRemoteDescription() [offer:%o]", offer);
+            yield this._pc.setRemoteDescription(offer);
+            const answer = yield this._pc.createAnswer();
+            logger$5.debug("resumeReceiving() | calling pc.setLocalDescription() [answer:%o]", answer);
+            yield this._pc.setLocalDescription(answer);
+        });
+    }
+    getReceiverStats(localId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertRecvDirection();
+            const transceiver = this._mapMidTransceiver.get(localId);
+            if (!transceiver) {
+                throw new Error("associated RTCRtpTransceiver not found");
+            }
+            return transceiver.receiver.getStats();
+        });
+    }
+    receiveDataChannel({ sctpStreamParameters, label, protocol, }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotClosed();
+            this.assertRecvDirection();
+            const { streamId, ordered, maxPacketLifeTime, maxRetransmits } = sctpStreamParameters;
+            const options = {
+                negotiated: true,
+                id: streamId,
+                ordered,
+                maxPacketLifeTime,
+                maxRetransmits,
+                protocol,
+            };
+            logger$5.debug("receiveDataChannel() [options:%o]", options);
+            const dataChannel = this._pc.createDataChannel(label, options);
+            if (!this._hasDataChannelMediaSection) {
+                this._remoteSdp.receiveSctpAssociation();
+                const offer = { type: "offer", sdp: this._remoteSdp.getSdp() };
+                logger$5.debug("receiveDataChannel() | calling pc.setRemoteDescription() [offer:%o]", offer);
+                yield this._pc.setRemoteDescription(offer);
+                const answer = yield this._pc.createAnswer();
+                if (!this._transportReady) {
+                    const localSdpObject = sdpTransform__namespace.parse(answer.sdp);
+                    yield this.setupTransport({
+                        localDtlsRole: (_a = this._forcedLocalDtlsRole) !== null && _a !== void 0 ? _a : "client",
+                        localSdpObject,
+                    });
+                }
+                logger$5.debug("receiveDataChannel() | calling pc.setRemoteDescription() [answer:%o]", answer);
+                yield this._pc.setLocalDescription(answer);
+                this._hasDataChannelMediaSection = true;
+            }
+            return { dataChannel };
+        });
+    }
+    setupTransport({ localDtlsRole, localSdpObject, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!localSdpObject) {
+                localSdpObject = sdpTransform__namespace.parse(this._pc.localDescription.sdp);
+            }
+            const dtlsParameters = sdpCommonUtils__namespace.extractDtlsParameters({
+                sdpObject: localSdpObject,
+            });
+            dtlsParameters.role = localDtlsRole;
+            this._remoteSdp.updateDtlsRole(localDtlsRole === "client" ? "server" : "client");
+            yield new Promise((resolve, reject) => {
+                this.safeEmit("@connect", { dtlsParameters }, resolve, reject);
+            });
+            this._transportReady = true;
+        });
+    }
+    assertNotClosed() {
+        if (this._closed) {
+            throw new errors.InvalidStateError("method called in a closed handler");
+        }
+    }
+    assertSendDirection() {
+        if (this._direction !== "send") {
+            throw new Error('method can just be called for handlers with "send" direction');
+        }
+    }
+    assertRecvDirection() {
+        if (this._direction !== "recv") {
+            throw new Error('method can just be called for handlers with "recv" direction');
+        }
+    }
+}
+
+const getMediasoupDevice = (features) => {
+    var _a;
+    if (features.isNodeSdk) {
+        return new mediasoupClient.Device({ handlerFactory: Safari12_js.Safari12.createFactory() });
+    }
+    let handlerName = mediasoupClient.detectDevice() || (/applecoremedia|applewebkit|safari/i.test(navigator.userAgent) ? "Safari17" : undefined);
+    if (handlerName === "Safari12" && typeof navigator === "object" && typeof navigator.userAgent === "string") {
+        const uaParser = new uaParserJs.UAParser(navigator.userAgent);
+        const browser = uaParser.getBrowser();
+        const browserVersion = parseInt((_a = browser.major) !== null && _a !== void 0 ? _a : "0");
+        if (browserVersion >= 17 && features.safari17HandlerOn) {
+            handlerName = "Safari17";
+        }
+    }
     if (/iphone|ipad/i.test(navigator.userAgent))
-        handlerName = "Safari12";
-    return handlerName;
+        handlerName = "Safari17";
+    if (handlerName === "Safari17") {
+        return new mediasoupClient.Device({ handlerFactory: Safari17.createFactory() });
+    }
+    return new mediasoupClient.Device({ handlerName });
 };
 
 const maybeTurnOnly = (transportConfig, features) => {
@@ -3564,7 +4274,7 @@ const OUTBOUND_SCREEN_OUTBOUND_STREAM_ID = uuid.v4();
 if (browserName === "chrome")
     window.document.addEventListener("beforeunload", () => (unloading = true));
 class VegaRtcManager {
-    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features, eventClaim, deviceHandlerFactory, }) {
+    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features, eventClaim, }) {
         const { session, iceServers, sfuServer, mediaserverConfigTtlSeconds } = room;
         this._selfId = selfId;
         this._room = room;
@@ -3577,12 +4287,7 @@ class VegaRtcManager {
         this._vegaConnection = null;
         this._micAnalyser = null;
         this._micAnalyserDebugger = null;
-        if (deviceHandlerFactory) {
-            this._mediasoupDevice = new mediasoupClient.Device({ handlerFactory: deviceHandlerFactory });
-        }
-        else {
-            this._mediasoupDevice = new mediasoupClient.Device({ handlerName: getHandler() });
-        }
+        this._mediasoupDevice = getMediasoupDevice(features);
         this._routerRtpCapabilities = null;
         this._sendTransport = null;
         this._receiveTransport = null;
@@ -3718,6 +4423,7 @@ class VegaRtcManager {
         this._emitToPWA(rtcManagerEvents.SFU_CONNECTION_CLOSED);
     }
     _join() {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             logger$4.info("join()");
             this._emitToPWA(rtcManagerEvents.SFU_CONNECTION_OPEN);
@@ -3726,10 +4432,10 @@ class VegaRtcManager {
                 if (!this._routerRtpCapabilities) {
                     modifyMediaCapabilities(routerRtpCapabilities, this._features);
                     this._routerRtpCapabilities = routerRtpCapabilities;
-                    yield this._mediasoupDevice.load({ routerRtpCapabilities });
+                    yield ((_a = this._mediasoupDevice) === null || _a === void 0 ? void 0 : _a.load({ routerRtpCapabilities }));
                 }
                 this._vegaConnection.message("setCapabilities", {
-                    rtpCapabilities: this._mediasoupDevice.rtpCapabilities,
+                    rtpCapabilities: (_b = this._mediasoupDevice) === null || _b === void 0 ? void 0 : _b.rtpCapabilities,
                 });
                 if (this._colocation)
                     this._vegaConnection.message("setColocation", { colocation: this._colocation });
@@ -3751,6 +4457,7 @@ class VegaRtcManager {
         });
     }
     _createTransport(send) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const creator = send ? "createSendTransport" : "createRecvTransport";
             const transportOptions = yield this._vegaConnection.request("createTransport", {
@@ -3771,7 +4478,7 @@ class VegaRtcManager {
             });
             transportOptions.iceServers = this._iceServers;
             maybeTurnOnly(transportOptions, this._features);
-            const transport = this._mediasoupDevice[creator](transportOptions);
+            const transport = (_a = this._mediasoupDevice) === null || _a === void 0 ? void 0 : _a[creator](transportOptions);
             const onConnectionStateListener = (connectionState) => __awaiter(this, void 0, void 0, function* () {
                 logger$4.info(`Transport ConnectionStateChanged ${connectionState}`);
                 if (connectionState !== "disconnected" && connectionState !== "failed") {
@@ -3794,25 +4501,23 @@ class VegaRtcManager {
                     });
                 }
             });
-            transport
-                .on("connect", ({ dtlsParameters }, callback) => {
+            transport === null || transport === void 0 ? void 0 : transport.on("connect", ({ dtlsParameters }, callback) => {
                 var _a;
                 (_a = this._vegaConnection) === null || _a === void 0 ? void 0 : _a.message("connectTransport", {
                     transportId: transport.id,
                     dtlsParameters,
                 });
                 callback();
-            })
-                .on("connectionstatechange", onConnectionStateListener);
-            transport.observer.once("close", () => {
-                transport.removeListener(onConnectionStateListener);
+            }).on("connectionstatechange", onConnectionStateListener);
+            transport === null || transport === void 0 ? void 0 : transport.observer.once("close", () => {
+                transport.removeListener("connectionstatechange", onConnectionStateListener);
             });
             if (send) {
-                transport.on("produce", ({ kind, rtpParameters, appData, }, callback, errback) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
+                transport === null || transport === void 0 ? void 0 : transport.on("produce", ({ kind, rtpParameters, appData, }, callback, errback) => __awaiter(this, void 0, void 0, function* () {
+                    var _b;
                     try {
                         const { paused } = appData;
-                        const { id } = yield ((_a = this._vegaConnection) === null || _a === void 0 ? void 0 : _a.request("produce", {
+                        const { id } = yield ((_b = this._vegaConnection) === null || _b === void 0 ? void 0 : _b.request("produce", {
                             transportId: transport.id,
                             kind,
                             rtpParameters,
@@ -3825,10 +4530,10 @@ class VegaRtcManager {
                         errback(error);
                     }
                 }));
-                transport.on("producedata", ({ appData, sctpStreamParameters, }, callback, errback) => __awaiter(this, void 0, void 0, function* () {
-                    var _b;
+                transport === null || transport === void 0 ? void 0 : transport.on("producedata", ({ appData, sctpStreamParameters, }, callback, errback) => __awaiter(this, void 0, void 0, function* () {
+                    var _c;
                     try {
-                        const { id } = yield ((_b = this._vegaConnection) === null || _b === void 0 ? void 0 : _b.request("produceData", {
+                        const { id } = yield ((_c = this._vegaConnection) === null || _c === void 0 ? void 0 : _c.request("produceData", {
                             transportId: transport.id,
                             sctpStreamParameters,
                             appData,
@@ -4921,7 +5626,6 @@ class RtcManagerDispatcher {
                 webrtcProvider,
                 features,
                 eventClaim,
-                deviceHandlerFactory: features === null || features === void 0 ? void 0 : features.deviceHandlerFactory,
             };
             const isSfu = !!room.sfuServer;
             roomMode = isSfu ? "group" : "normal";
@@ -6252,7 +6956,7 @@ class BandwidthTester extends EventEmitter {
         this.closed = false;
         this._features = features || {};
         this._vegaConnection = null;
-        this._mediasoupDevice = new mediasoupClient.Device({ handlerName: getHandler() });
+        this._mediasoupDevice = getMediasoupDevice(features);
         this._routerRtpCapabilities = null;
         this._sendTransport = null;
         this._receiveTransport = null;
@@ -6321,6 +7025,7 @@ class BandwidthTester extends EventEmitter {
         this.emit("close");
     }
     _start() {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             logger$1.info("_start()");
             this._connectTime = Date.now() - this._startTime;
@@ -6339,10 +7044,10 @@ class BandwidthTester extends EventEmitter {
                 if (!this._routerRtpCapabilities) {
                     modifyMediaCapabilities(routerRtpCapabilities, this._features);
                     this._routerRtpCapabilities = routerRtpCapabilities;
-                    yield this._mediasoupDevice.load({ routerRtpCapabilities });
+                    yield ((_a = this._mediasoupDevice) === null || _a === void 0 ? void 0 : _a.load({ routerRtpCapabilities }));
                 }
                 this._vegaConnection.message("setCapabilities", {
-                    rtpCapabilities: this._mediasoupDevice.rtpCapabilities,
+                    rtpCapabilities: (_b = this._mediasoupDevice) === null || _b === void 0 ? void 0 : _b.rtpCapabilities,
                 });
                 yield Promise.all([this._createTransport(true), this._createTransport(false)]);
                 yield this._createProducer();
@@ -6373,6 +7078,7 @@ class BandwidthTester extends EventEmitter {
         });
     }
     _createTransport(send) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const creator = send ? "createSendTransport" : "createRecvTransport";
             const transportOptions = yield this._vegaConnection.request("createTransport", {
@@ -6383,8 +7089,8 @@ class BandwidthTester extends EventEmitter {
                 preferUdp: true,
             });
             transportOptions.iceServers = [{ urls: "stun:any.turn.svc.whereby.com" }];
-            const transport = this._mediasoupDevice[creator](transportOptions);
-            transport.on("connect", ({ dtlsParameters }, callback) => {
+            const transport = (_a = this._mediasoupDevice) === null || _a === void 0 ? void 0 : _a[creator](transportOptions);
+            transport === null || transport === void 0 ? void 0 : transport.on("connect", ({ dtlsParameters }, callback) => {
                 this._vegaConnection.message("connectTransport", {
                     transportId: transport.id,
                     dtlsParameters,
@@ -6392,7 +7098,7 @@ class BandwidthTester extends EventEmitter {
                 callback();
             });
             if (send) {
-                transport.on("produce", ({ kind, rtpParameters, appData }, callback, errback) => __awaiter(this, void 0, void 0, function* () {
+                transport === null || transport === void 0 ? void 0 : transport.on("produce", ({ kind, rtpParameters, appData }, callback, errback) => __awaiter(this, void 0, void 0, function* () {
                     try {
                         const { paused } = appData;
                         const { id } = yield this._vegaConnection.request("produce", {
@@ -7046,10 +7752,10 @@ exports.getConstraints = getConstraints;
 exports.getCurrentPeerConnections = getCurrentPeerConnections;
 exports.getDeviceData = getDeviceData;
 exports.getDisplayMedia = getDisplayMedia;
-exports.getHandler = getHandler;
 exports.getIssuesAndMetrics = getIssuesAndMetrics;
 exports.getMediaConstraints = getMediaConstraints;
 exports.getMediaSettings = getMediaSettings;
+exports.getMediasoupDevice = getMediasoupDevice;
 exports.getNumFailedStatsReports = getNumFailedStatsReports;
 exports.getNumFailedTrackSsrcLookups = getNumFailedTrackSsrcLookups;
 exports.getNumMissingTrackSsrcLookups = getNumMissingTrackSsrcLookups;