@stream-io/video-client 1.50.0 → 1.52.0

package/dist/index.es.js

@@ -1187,6 +1187,14 @@ var SdkType;
      * @generated from protobuf enum value: SDK_TYPE_PLAIN_JAVASCRIPT = 9;
      */
     SdkType[SdkType["PLAIN_JAVASCRIPT"] = 9] = "PLAIN_JAVASCRIPT";
+    /**
+     * @generated from protobuf enum value: SDK_TYPE_PYTHON = 10;
+     */
+    SdkType[SdkType["PYTHON"] = 10] = "PYTHON";
+    /**
+     * @generated from protobuf enum value: SDK_TYPE_VISION_AGENTS = 11;
+     */
+    SdkType[SdkType["VISION_AGENTS"] = 11] = "VISION_AGENTS";
 })(SdkType || (SdkType = {}));
 /**
  * @generated from protobuf enum stream.video.sfu.models.TrackUnpublishReason
@@ -1398,6 +1406,12 @@ var ClientCapability;
      * @generated from protobuf enum value: CLIENT_CAPABILITY_SUBSCRIBER_VIDEO_PAUSE = 1;
      */
     ClientCapability[ClientCapability["SUBSCRIBER_VIDEO_PAUSE"] = 1] = "SUBSCRIBER_VIDEO_PAUSE";
+    /**
+     * Instructs SFU that stats will be sent to the coordinator
+     *
+     * @generated from protobuf enum value: CLIENT_CAPABILITY_COORDINATOR_STATS = 2;
+     */
+    ClientCapability[ClientCapability["COORDINATOR_STATS"] = 2] = "COORDINATOR_STATS";
 })(ClientCapability || (ClientCapability = {}));
 /**
  * DegradationPreference represents the RTCDegradationPreference from WebRTC.
@@ -1863,6 +1877,12 @@ class ClientDetails$Type extends MessageType {
             { no: 2, name: 'os', kind: 'message', T: () => OS },
             { no: 3, name: 'browser', kind: 'message', T: () => Browser },
             { no: 4, name: 'device', kind: 'message', T: () => Device },
+            {
+                no: 5,
+                name: 'webrtc_version',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
         ]);
     }
 }
@@ -2135,6 +2155,171 @@ class PerformanceStats$Type extends MessageType {
  * @generated MessageType for protobuf message stream.video.sfu.models.PerformanceStats
  */
 const PerformanceStats = new PerformanceStats$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RtpBase$Type extends MessageType {
+    constructor() {
+        super('stream.video.sfu.models.RtpBase', [
+            { no: 1, name: 'ssrc', kind: 'scalar', T: 13 /*ScalarType.UINT32*/ },
+            { no: 2, name: 'kind', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            {
+                no: 3,
+                name: 'timestamp_ms',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.RtpBase
+ */
+const RtpBase = new RtpBase$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class InboundRtp$Type extends MessageType {
+    constructor() {
+        super('stream.video.sfu.models.InboundRtp', [
+            { no: 1, name: 'base', kind: 'message', T: () => RtpBase },
+            {
+                no: 2,
+                name: 'jitter_seconds',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+            {
+                no: 3,
+                name: 'packets_received',
+                kind: 'scalar',
+                T: 4 /*ScalarType.UINT64*/,
+            },
+            {
+                no: 4,
+                name: 'packets_lost',
+                kind: 'scalar',
+                T: 4 /*ScalarType.UINT64*/,
+            },
+            {
+                no: 5,
+                name: 'packet_loss_percent',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+            {
+                no: 10,
+                name: 'concealment_events',
+                kind: 'scalar',
+                T: 13 /*ScalarType.UINT32*/,
+            },
+            {
+                no: 11,
+                name: 'concealment_percent',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+            { no: 20, name: 'fps', kind: 'scalar', T: 1 /*ScalarType.DOUBLE*/ },
+            {
+                no: 21,
+                name: 'freeze_duration_seconds',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+            {
+                no: 22,
+                name: 'avg_decode_time_seconds',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+            {
+                no: 23,
+                name: 'min_dimension_px',
+                kind: 'scalar',
+                T: 13 /*ScalarType.UINT32*/,
+            },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.InboundRtp
+ */
+const InboundRtp = new InboundRtp$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OutboundRtp$Type extends MessageType {
+    constructor() {
+        super('stream.video.sfu.models.OutboundRtp', [
+            { no: 1, name: 'base', kind: 'message', T: () => RtpBase },
+            { no: 10, name: 'fps', kind: 'scalar', T: 1 /*ScalarType.DOUBLE*/ },
+            {
+                no: 11,
+                name: 'avg_encode_time_seconds',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+            {
+                no: 12,
+                name: 'bitrate_bps',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+            {
+                no: 13,
+                name: 'min_dimension_px',
+                kind: 'scalar',
+                T: 13 /*ScalarType.UINT32*/,
+            },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.OutboundRtp
+ */
+const OutboundRtp = new OutboundRtp$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoteInboundRtp$Type extends MessageType {
+    constructor() {
+        super('stream.video.sfu.models.RemoteInboundRtp', [
+            { no: 1, name: 'base', kind: 'message', T: () => RtpBase },
+            {
+                no: 2,
+                name: 'jitter_seconds',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+            {
+                no: 3,
+                name: 'round_trip_time_s',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.RemoteInboundRtp
+ */
+const RemoteInboundRtp = new RemoteInboundRtp$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoteOutboundRtp$Type extends MessageType {
+    constructor() {
+        super('stream.video.sfu.models.RemoteOutboundRtp', [
+            { no: 1, name: 'base', kind: 'message', T: () => RtpBase },
+            {
+                no: 2,
+                name: 'jitter_seconds',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+            {
+                no: 3,
+                name: 'round_trip_time_s',
+                kind: 'scalar',
+                T: 1 /*ScalarType.DOUBLE*/,
+            },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.RemoteOutboundRtp
+ */
+const RemoteOutboundRtp = new RemoteOutboundRtp$Type();
 
 var models = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -2159,8 +2344,10 @@ var models = /*#__PURE__*/Object.freeze({
     get ErrorCode () { return ErrorCode; },
     get GoAwayReason () { return GoAwayReason; },
     ICETrickle: ICETrickle$1,
+    InboundRtp: InboundRtp,
     InputDevices: InputDevices,
     OS: OS,
+    OutboundRtp: OutboundRtp,
     Participant: Participant,
     ParticipantCount: ParticipantCount,
     get ParticipantSource () { return ParticipantSource; },
@@ -2169,6 +2356,9 @@ var models = /*#__PURE__*/Object.freeze({
     Pin: Pin,
     PublishOption: PublishOption,
     RTMPIngress: RTMPIngress,
+    RemoteInboundRtp: RemoteInboundRtp,
+    RemoteOutboundRtp: RemoteOutboundRtp,
+    RtpBase: RtpBase,
     Sdk: Sdk,
     get SdkType () { return SdkType; },
     StreamQuality: StreamQuality,
@@ -2286,6 +2476,62 @@ class Telemetry$Type extends MessageType {
  */
 const Telemetry = new Telemetry$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class SendMetricsRequest$Type extends MessageType {
+    constructor() {
+        super('stream.video.sfu.signal.SendMetricsRequest', [
+            { no: 1, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            {
+                no: 2,
+                name: 'unified_session_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 3,
+                name: 'inbounds',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => InboundRtp,
+            },
+            {
+                no: 4,
+                name: 'outbounds',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => OutboundRtp,
+            },
+            {
+                no: 5,
+                name: 'remote_inbounds',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => RemoteInboundRtp,
+            },
+            {
+                no: 6,
+                name: 'remote_outbounds',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => RemoteOutboundRtp,
+            },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.SendMetricsRequest
+ */
+const SendMetricsRequest = new SendMetricsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SendMetricsResponse$Type extends MessageType {
+    constructor() {
+        super('stream.video.sfu.signal.SendMetricsResponse', []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.SendMetricsResponse
+ */
+const SendMetricsResponse = new SendMetricsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class SendStatsRequest$Type extends MessageType {
     constructor() {
         super('stream.video.sfu.signal.SendStatsRequest', [
@@ -2559,6 +2805,12 @@ class SendAnswerRequest$Type extends MessageType {
             },
             { no: 2, name: 'sdp', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
             { no: 3, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            {
+                no: 4,
+                name: 'negotiation_id',
+                kind: 'scalar',
+                T: 13 /*ScalarType.UINT32*/,
+            },
         ]);
     }
 }
@@ -2666,6 +2918,12 @@ const SignalServer = new ServiceType('stream.video.sfu.signal.SignalServer', [
         I: SendStatsRequest,
         O: SendStatsResponse,
     },
+    {
+        name: 'SendMetrics',
+        options: {},
+        I: SendMetricsRequest,
+        O: SendMetricsResponse,
+    },
     {
         name: 'StartNoiseCancellation',
         options: {},
@@ -3346,6 +3604,12 @@ class SubscriberOffer$Type extends MessageType {
         super('stream.video.sfu.event.SubscriberOffer', [
             { no: 1, name: 'ice_restart', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
             { no: 2, name: 'sdp', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            {
+                no: 3,
+                name: 'negotiation_id',
+                kind: 'scalar',
+                T: 13 /*ScalarType.UINT32*/,
+            },
         ]);
     }
 }
@@ -3804,18 +4068,25 @@ class SignalServerClient {
         const method = this.methods[6], opt = this._transport.mergeOptions(options);
         return stackIntercept('unary', this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: SendMetrics(stream.video.sfu.signal.SendMetricsRequest) returns (stream.video.sfu.signal.SendMetricsResponse);
+     */
+    sendMetrics(input, options) {
+        const method = this.methods[7], opt = this._transport.mergeOptions(options);
+        return stackIntercept('unary', this._transport, method, opt, input);
+    }
     /**
      * @generated from protobuf rpc: StartNoiseCancellation(stream.video.sfu.signal.StartNoiseCancellationRequest) returns (stream.video.sfu.signal.StartNoiseCancellationResponse);
      */
     startNoiseCancellation(input, options) {
-        const method = this.methods[7], opt = this._transport.mergeOptions(options);
+        const method = this.methods[8], opt = this._transport.mergeOptions(options);
         return stackIntercept('unary', this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: StopNoiseCancellation(stream.video.sfu.signal.StopNoiseCancellationRequest) returns (stream.video.sfu.signal.StopNoiseCancellationResponse);
      */
     stopNoiseCancellation(input, options) {
-        const method = this.methods[8], opt = this._transport.mergeOptions(options);
+        const method = this.methods[9], opt = this._transport.mergeOptions(options);
         return stackIntercept('unary', this._transport, method, opt, input);
     }
 }
@@ -4995,6 +5266,16 @@ const hasScreenShareAudio = (p) => p.publishedTracks.includes(TrackType.SCREEN_S
  * @param p the participant.
  */
 const isPinned = (p) => !!p.pin && (p.pin.isLocalPin || p.pin.pinnedAt > 0);
+/**
+ * Check if a participant has a track that is currently interrupted: the
+ * participant intends to publish it (it is in `publishedTracks`) but no
+ * media is flowing right now (it is in `interruptedTracks`).
+ *
+ * @param p the participant to check.
+ * @param trackType the track type to check.
+ */
+const hasInterruptedTrack = (p, trackType) => !!p.interruptedTracks?.includes(trackType) &&
+    p.publishedTracks.includes(trackType);
 /**
  * Check if a participant has a paused track of the specified type.
  *
@@ -6360,7 +6641,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.50.0";
+const version = "1.52.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -6458,6 +6739,7 @@ const getClientDetails = async () => {
             sdk: sdkInfo,
             os: osInfo,
             device: deviceInfo,
+            webrtcVersion: webRtcInfo?.version || '',
         };
     }
     // @ts-expect-error - userAgentData is not yet in the TS types
@@ -6485,11 +6767,12 @@ const getClientDetails = async () => {
     // Eliminates the generic "Chromium" name and "Not)A_Brand" name from the list.
     // https://wicg.github.io/ua-client-hints/#create-arbitrary-brands-section
     const uaBrowser = userAgentData?.fullVersionList?.find((v) => !v.brand.includes('Chromium') && !v.brand.match(/[()\-./:;=?_]/g));
+    const browserVersion = uaBrowser?.version || browser.version || '';
     return {
         sdk: sdkInfo,
         browser: {
             name: uaBrowser?.brand || browser.name || navigator.userAgent,
-            version: uaBrowser?.version || browser.version || '',
+            version: browserVersion,
         },
         os: {
             name: userAgentData?.platform || os.name || '',
@@ -6502,6 +6785,7 @@ const getClientDetails = async () => {
                 .join(' '),
             version: '',
         },
+        webrtcVersion: browserVersion,
     };
 };
 
@@ -7165,7 +7449,7 @@ class StatsTracer {
     /**
      * Creates a new StatsTracer instance.
      */
-    constructor(pc, peerType, trackIdToTrackType) {
+    constructor(pc, peerType, trackIdToTrackType, statsTimestampDriftThresholdMs = 0) {
         this.previousStats = {};
         this.frameTimeHistory = [];
         this.fpsHistory = [];
@@ -7179,7 +7463,7 @@ class StatsTracer {
          */
         this.get = async () => {
             const stats = await this.pc.getStats();
-            const currentStats = toObject(stats);
+            const currentStats = toObjectWithCorrectedTimestamp(stats, Date.now(), this.driftThresholdMs);
             const performanceStats = this.withOverrides(this.peerType === PeerType.SUBSCRIBER
                 ? this.getDecodeStats(currentStats)
                 : this.getEncodeStats(currentStats));
@@ -7298,17 +7582,28 @@ class StatsTracer {
         this.pc = pc;
         this.peerType = peerType;
         this.trackIdToTrackType = trackIdToTrackType;
+        this.driftThresholdMs = statsTimestampDriftThresholdMs;
     }
 }
 /**
- * Convert the stat report to an object.
+ * Convert the stat report to an object, correcting clock drift along the way.
+ * Entries whose `timestamp` differs from `wallNow` by more than `thresholdMs`
+ * are replaced with a clone whose `timestamp` is set to `wallNow`. The platform
+ * clock backing `DOMHighResTimeStamp` can desynchronise from `Date.now()` after
+ * system sleep or clock-jump events (notably on Electron/Chromium), which
+ * corrupts the delta-compressed stats payload. A non-positive `thresholdMs`
+ * disables correction.
  *
  * @param report the stat report to convert.
+ * @param wallNow current wall-clock time used as the drift reference.
+ * @param thresholdMs maximum tolerated drift in milliseconds.
  */
-const toObject = (report) => {
+const toObjectWithCorrectedTimestamp = (report, wallNow, thresholdMs) => {
     const obj = {};
+    const correct = thresholdMs > 0;
     report.forEach((v, k) => {
-        obj[k] = v;
+        const drift = Math.abs(v.timestamp - wallNow);
+        obj[k] = correct && drift > thresholdMs ? { ...v, timestamp: wallNow } : v;
     });
     return obj;
 };
@@ -7440,7 +7735,7 @@ class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, tag, enableTracing, clientPublishOptions, iceRestartDelay = 2500, }) {
+    constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, tag, enableTracing, clientPublishOptions, iceRestartDelay = 2500, statsTimestampDriftThresholdMs = 0, }) {
         this.iceHasEverConnected = false;
         this.isIceRestarting = false;
         this.isDisposed = false;
@@ -7479,7 +7774,7 @@ class BasePeerConnection {
         this.on = (event, fn) => {
             const getTag = () => this.tag;
             this.subscriptions.push(this.dispatcher.on(event, getTag, (e) => {
-                const lockKey = `pc.${this.lock}.${event}`;
+                const lockKey = this.eventLockKey(event);
                 withoutConcurrency(lockKey, async () => fn(e)).catch((err) => {
                     if (this.isDisposed)
                         return;
@@ -7487,6 +7782,13 @@ class BasePeerConnection {
                 });
             }));
         };
+        /**
+         * Returns the per-event `withoutConcurrency` tag used to serialize the
+         * dispatcher handler for `event` on this peer connection.
+         */
+        this.eventLockKey = (event) => {
+            return `pc.${this.lock}.${event}`;
+        };
         /**
          * Appends the trickled ICE candidates to the `RTCPeerConnection`.
          */
@@ -7727,7 +8029,7 @@ class BasePeerConnection {
         this.onIceConnected = onIceConnected;
         this.logger = videoLoggerSystem.getLogger(peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher', { tags: [tag] });
         this.pc = this.createPeerConnection(connectionConfig);
-        this.stats = new StatsTracer(this.pc, peerType, this.trackIdToTrackType);
+        this.stats = new StatsTracer(this.pc, peerType, this.trackIdToTrackType, statsTimestampDriftThresholdMs);
         if (enableTracing) {
             this.tracer = new Tracer(`${tag}-${peerType === PeerType.SUBSCRIBER ? 'sub' : 'pub'}`);
             this.tracer.trace('create', {
@@ -7740,7 +8042,7 @@ class BasePeerConnection {
     /**
      * Disposes the `RTCPeerConnection` instance.
      */
-    dispose() {
+    async dispose() {
         clearTimeout(this.iceRestartTimeout);
         this.iceRestartTimeout = undefined;
         clearTimeout(this.preConnectStuckTimeout);
@@ -7762,6 +8064,7 @@ class BasePeerConnection {
         pc.removeEventListener('signalingstatechange', this.onSignalingChange);
         pc.removeEventListener('iceconnectionstatechange', this.onIceConnectionStateChange);
         pc.removeEventListener('icegatheringstatechange', this.onIceGatherChange);
+        pc.removeEventListener('connectionstatechange', this.onConnectionStateChange);
         this.unsubscribeIceTrickle?.();
         this.subscriptions.forEach((unsubscribe) => unsubscribe());
         this.subscriptions = [];
@@ -7789,8 +8092,14 @@ class TransceiverCache {
          * Gets the transceiver for the given publish option.
          */
         this.get = (publishOption) => {
-            return this.cache.find((bundle) => bundle.publishOption.id === publishOption.id &&
-                bundle.publishOption.trackType === publishOption.trackType);
+            return this.getBy(publishOption.id, publishOption.trackType);
+        };
+        /**
+         * Gets the transceiver for the given publish option id and track type.
+         */
+        this.getBy = (publishOptionId, trackType) => {
+            return this.cache.find((bundle) => bundle.publishOption.id === publishOptionId &&
+                bundle.publishOption.trackType === trackType);
         };
         /**
          * Updates the cached bundle with the given patch.
@@ -8075,6 +8384,21 @@ const toRTCDegradationPreference = (preference) => {
             ensureExhausted(preference, 'Unknown degradation preference');
     }
 };
+const fromRTCDegradationPreference = (preference) => {
+    switch (preference) {
+        case 'balanced':
+            return DegradationPreference.BALANCED;
+        case 'maintain-framerate':
+            return DegradationPreference.MAINTAIN_FRAMERATE;
+        case 'maintain-resolution':
+            return DegradationPreference.MAINTAIN_RESOLUTION;
+        // @ts-expect-error not in the typedefs yet
+        case 'maintain-framerate-and-resolution':
+            return DegradationPreference.MAINTAIN_FRAMERATE_AND_RESOLUTION;
+        default:
+            return DegradationPreference.UNSPECIFIED;
+    }
+};
 
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
@@ -8109,13 +8433,13 @@ class Publisher extends BasePeerConnection {
                 // create a clone of the track as otherwise the same trackId will
                 // appear in the SDP in multiple transceivers
                 const trackToPublish = this.cloneTrack(track);
-                const { transceiver } = this.transceiverCache.get(publishOption) || {};
-                if (!transceiver) {
+                const bundle = this.transceiverCache.get(publishOption);
+                if (!bundle) {
                     await this.addTransceiver(trackToPublish, publishOption, options);
                 }
                 else {
-                    const previousTrack = transceiver.sender.track;
-                    await this.updateTransceiver(transceiver, trackToPublish, trackType, options);
+                    const previousTrack = bundle.transceiver.sender.track;
+                    await this.updateTransceiver(bundle, trackToPublish, options);
                     if (!isReactNative()) {
                         this.stopTrack(previousTrack);
                     }
@@ -8150,13 +8474,20 @@ class Publisher extends BasePeerConnection {
         /**
          * Updates the transceiver with the given track and track type.
          */
-        this.updateTransceiver = async (transceiver, track, trackType, options = {}) => {
+        this.updateTransceiver = async (bundle, track, options = {}) => {
+            const { transceiver, publishOption } = bundle;
+            const trackType = publishOption.trackType;
             const sender = transceiver.sender;
             if (sender.track)
                 this.trackIdToTrackType.delete(sender.track.id);
             await sender.replaceTrack(track);
-            if (track)
+            if (track) {
                 this.trackIdToTrackType.set(track.id, trackType);
+                if (isFirefox() && bundle.videoSender) {
+                    // restore the encoding config from the cache, if any
+                    await this.changePublishQuality(bundle.videoSender, bundle);
+                }
+            }
             if (isAudioTrackType(trackType)) {
                 await this.updateAudioPublishOptions(trackType, options);
             }
@@ -8216,7 +8547,7 @@ class Publisher extends BasePeerConnection {
                     continue;
                 // it is safe to stop the track here, it is a clone
                 this.stopTrack(transceiver.sender.track);
-                await this.updateTransceiver(transceiver, null, publishOption.trackType);
+                await this.updateTransceiver(item, null);
             }
         };
         /**
@@ -8273,33 +8604,38 @@ class Publisher extends BasePeerConnection {
         /**
          * Stops the cloned track that is being published to the SFU.
          */
-        this.stopTracks = (...trackTypes) => {
-            for (const item of this.transceiverCache.items()) {
-                const { publishOption, transceiver } = item;
-                if (!trackTypes.includes(publishOption.trackType))
-                    continue;
-                this.stopTrack(transceiver.sender.track);
-            }
+        this.stopTracks = async (...trackTypes) => {
+            return withoutConcurrency(this.eventLockKey('changePublishQuality'), async () => {
+                for (const item of this.transceiverCache.items()) {
+                    const { publishOption, transceiver } = item;
+                    if (!trackTypes.includes(publishOption.trackType))
+                        continue;
+                    const track = transceiver.sender.track;
+                    await this.silenceSenderOnFirefox(item);
+                    this.stopTrack(track);
+                }
+            });
         };
         /**
          * Stops all the cloned tracks that are being published to the SFU.
          */
-        this.stopAllTracks = () => {
-            for (const { transceiver } of this.transceiverCache.items()) {
-                this.stopTrack(transceiver.sender.track);
-            }
-            for (const track of this.clonedTracks) {
-                this.stopTrack(track);
-            }
+        this.stopAllTracks = async () => {
+            return withoutConcurrency(this.eventLockKey('changePublishQuality'), async () => {
+                for (const item of this.transceiverCache.items()) {
+                    const track = item.transceiver.sender.track;
+                    await this.silenceSenderOnFirefox(item);
+                    this.stopTrack(track);
+                }
+                for (const track of this.clonedTracks) {
+                    this.stopTrack(track);
+                }
+            });
         };
-        this.changePublishQuality = async (videoSender) => {
-            const { trackType, layers, publishOptionId } = videoSender;
-            const enabledLayers = layers.filter((l) => l.active);
+        this.changePublishQuality = async (videoSender, bundle) => {
+            const enabledLayers = videoSender.layers.filter((l) => l.active);
             const tag = 'Update publish quality:';
             this.logger.info(`${tag} requested layers by SFU:`, enabledLayers);
-            const transceiverId = this.transceiverCache.find((t) => t.publishOption.id === publishOptionId &&
-                t.publishOption.trackType === trackType);
-            const sender = transceiverId?.transceiver.sender;
+            const sender = bundle?.transceiver.sender;
             if (!sender) {
                 return this.logger.warn(`${tag} no video sender found.`);
             }
@@ -8307,7 +8643,7 @@ class Publisher extends BasePeerConnection {
             if (params.encodings.length === 0) {
                 return this.logger.warn(`${tag} there are no encodings set.`);
             }
-            const codecInUse = transceiverId?.publishOption.codec?.name;
+            const codecInUse = bundle?.publishOption.codec?.name;
             const usesSvcCodec = codecInUse && isSvcCodec(codecInUse);
             let changed = false;
             for (const encoder of params.encodings) {
@@ -8507,6 +8843,72 @@ class Publisher extends BasePeerConnection {
             track.stop();
             this.clonedTracks.delete(track);
         };
+        /**
+         * Silences a Firefox sender on the wire during unpublish.
+         *
+         * Firefox keeps emitting RTP after track.stop(), but the right lever
+         * differs by track type:
+         *   - audio: `replaceTrack(null)` is the only reliable silencer;
+         *     `setParameters({encodings:[...active:false]})` does NOT stop
+         *     the Opus encoder.
+         *   - video: `setParameters({encodings:[...active:false]})` pauses
+         *     the encoder; `replaceTrack(null)` does NOT reliably stop the
+         *     video encoder. The prior active=true configuration is captured
+         *     onto `bundle.videoSender` so `updateTransceiver` can restore
+         *     it on the next publish.
+         *
+         * No-op on non-Firefox browsers and during teardown.
+         */
+        this.silenceSenderOnFirefox = async (bundle) => {
+            if (this.isDisposed || !isFirefox())
+                return;
+            const { transceiver, publishOption } = bundle;
+            if (isAudioTrackType(publishOption.trackType)) {
+                await transceiver.sender.replaceTrack(null).catch((err) => {
+                    this.logger.warn('Failed to clear audio sender track', err);
+                });
+                return;
+            }
+            await this.disableAllEncodings(bundle);
+        };
+        this.disableAllEncodings = async (bundle) => {
+            const { transceiver, publishOption } = bundle;
+            const sender = transceiver.sender;
+            const params = sender.getParameters();
+            if (!params.encodings || params.encodings.length === 0)
+                return;
+            if (!bundle.videoSender) {
+                this.transceiverCache.update(publishOption, {
+                    videoSender: {
+                        trackType: publishOption.trackType,
+                        publishOptionId: publishOption.id,
+                        codec: publishOption.codec,
+                        degradationPreference: fromRTCDegradationPreference(params.degradationPreference),
+                        layers: params.encodings.map((e) => ({
+                            name: e.rid ?? 'q',
+                            active: e.active ?? true,
+                            maxBitrate: e.maxBitrate ?? 0,
+                            scaleResolutionDownBy: e.scaleResolutionDownBy ?? 0,
+                            maxFramerate: e.maxFramerate ?? 0,
+                            // @ts-expect-error scalabilityMode is not in the typedefs yet
+                            scalabilityMode: e.scalabilityMode ?? '',
+                        })),
+                    },
+                });
+            }
+            let changed = false;
+            for (const encoding of params.encodings) {
+                if (encoding.active !== false) {
+                    encoding.active = false;
+                    changed = true;
+                }
+            }
+            if (!changed)
+                return;
+            await sender.setParameters(params).catch((err) => {
+                this.logger.error('Failed to disable video sender encodings:', err);
+            });
+        };
         this.publishOptions = publishOptions;
         this.on('iceRestart', (iceRestart) => {
             if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED)
@@ -8515,7 +8917,16 @@ class Publisher extends BasePeerConnection {
         });
         this.on('changePublishQuality', async (event) => {
             for (const videoSender of event.videoSenders) {
-                await this.changePublishQuality(videoSender);
+                // if not publishing, update the encodingConfigCache and don't modify the state.
+                // we'll apply this config on the next publish/unmute.
+                const { trackType, publishOptionId } = videoSender;
+                const bundle = this.transceiverCache.getBy(publishOptionId, trackType);
+                if (bundle) {
+                    this.transceiverCache.update(bundle.publishOption, { videoSender });
+                }
+                if (isFirefox() && !this.isPublishing(trackType))
+                    continue;
+                await this.changePublishQuality(videoSender, bundle);
             }
         });
         this.on('changePublishOptions', (event) => {
@@ -8526,9 +8937,14 @@ class Publisher extends BasePeerConnection {
     /**
      * Disposes this Publisher instance.
      */
-    dispose() {
-        super.dispose();
-        this.stopAllTracks();
+    async dispose() {
+        await super.dispose();
+        try {
+            await this.stopAllTracks();
+        }
+        catch (err) {
+            this.logger.warn('Failed to stop tracks during dispose', err);
+        }
         this.clonedTracks.clear();
     }
 }
@@ -8699,6 +9115,7 @@ class Subscriber extends BasePeerConnection {
             await this.sfuClient.sendAnswer({
                 peerType: PeerType.SUBSCRIBER,
                 sdp: answer.sdp || '',
+                negotiationId: subscriberOffer.negotiationId,
             });
             this.isIceRestarting = false;
         };
@@ -11312,8 +11729,8 @@ const normalize = (options) => {
             : false,
     };
 };
-const createSyntheticDevice = (deviceId, kind) => {
-    return { deviceId, kind, label: '', groupId: '' };
+const createSyntheticDevice = (deviceId, kind, label = '') => {
+    return { deviceId, kind, label, groupId: '' };
 };
 const readPreferences = (storageKey) => {
     try {
@@ -11367,6 +11784,8 @@ class DeviceManager {
         this.areSubscriptionsSetUp = false;
         this.isTrackStoppedDueToTrackEnd = false;
         this.filters = [];
+        this.virtualDevicesSubject = new BehaviorSubject([]);
+        this.virtualDeviceConcurrencyTag = Symbol('virtualDeviceConcurrencyTag');
         this.statusChangeConcurrencyTag = Symbol('statusChangeConcurrencyTag');
         this.filterRegistrationConcurrencyTag = Symbol('filterRegistrationConcurrencyTag');
         /**
@@ -11379,6 +11798,7 @@ class DeviceManager {
             this.subscriptions.forEach((s) => s());
             this.subscriptions = [];
             this.areSubscriptionsSetUp = false;
+            this.virtualDevicesSubject.next([]);
         };
         this.runCurrentStreamCleanups = () => {
             this.currentStreamCleanups.forEach((c) => c());
@@ -11437,7 +11857,93 @@ class DeviceManager {
      * @returns an Observable that will be updated if a device is connected or disconnected
      */
     listDevices() {
-        return this.getDevices();
+        return combineLatest([this.getDevices(), this.virtualDevicesSubject]).pipe(map(([real, virtual]) => [
+            ...real,
+            ...virtual.map((d) => createSyntheticDevice(d.deviceId, d.kind, d.label)),
+        ]));
+    }
+    /**
+     * Registers a virtual camera or microphone backed by a caller-supplied
+     * stream factory. The device appears in `listDevices()` and can be selected
+     * via `select()` like any real device.
+     *
+     * Web only. React Native is not supported.
+     *
+     * Only supported for camera and microphone managers; calling on any other
+     * manager throws.
+     */
+    registerVirtualDevice(virtualDevice) {
+        if (isReactNative()) {
+            throw new Error('Virtual devices are not supported on React Native.');
+        }
+        if (this.trackType !== TrackType.AUDIO &&
+            this.trackType !== TrackType.VIDEO) {
+            throw new Error('Virtual devices are only supported for camera and microphone.');
+        }
+        const deviceId = `stream-virtual:${generateUUIDv4()}`;
+        const entry = {
+            deviceId,
+            kind: this.mediaDeviceKind,
+            ...virtualDevice,
+        };
+        setCurrentValue(this.virtualDevicesSubject, (current) => [
+            ...current,
+            entry,
+        ]);
+        return {
+            deviceId: entry.deviceId,
+            unregister: async () => {
+                await withoutConcurrency(this.virtualDeviceConcurrencyTag, async () => {
+                    setCurrentValue(this.virtualDevicesSubject, (current) => current.filter((d) => d !== entry));
+                    if (this.activeVirtualSession?.deviceId === deviceId) {
+                        await this.stopActiveVirtualSession();
+                    }
+                });
+                if (this.state.selectedDevice === deviceId) {
+                    await this.statusChangeSettled();
+                    await this.disable({ forceStop: true });
+                    await this.select(undefined);
+                }
+            },
+        };
+    }
+    sanitizeVirtualStream(stream) {
+        stream.getTracks().forEach((track) => {
+            const originalGetSettings = track.getSettings.bind(track);
+            track.getSettings = () => {
+                const settings = originalGetSettings();
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { deviceId, ...rest } = settings;
+                return rest;
+            };
+        });
+        return stream;
+    }
+    findVirtualDevice(deviceId) {
+        if (!deviceId)
+            return undefined;
+        return getCurrentValue(this.virtualDevicesSubject).find((d) => d.deviceId === deviceId);
+    }
+    async stopActiveVirtualSession() {
+        const session = this.activeVirtualSession;
+        this.activeVirtualSession = undefined;
+        await session?.stop?.();
+    }
+    async getSelectedStream(constraints) {
+        const deviceId = this.state.selectedDevice;
+        if (!deviceId?.startsWith('stream-virtual')) {
+            return this.getStream(constraints);
+        }
+        return withoutConcurrency(this.virtualDeviceConcurrencyTag, async () => {
+            const virtualDevice = this.findVirtualDevice(deviceId);
+            if (!virtualDevice) {
+                throw new Error(`Virtual device is not registered: ${deviceId}`);
+            }
+            await this.stopActiveVirtualSession();
+            const { stream, stop } = await virtualDevice.getUserMedia(constraints);
+            this.activeVirtualSession = { deviceId, stop };
+            return this.sanitizeVirtualStream(stream);
+        });
     }
     /**
      * Returns `true` when this device is in enabled state.
@@ -11597,6 +12103,9 @@ class DeviceManager {
             }
         });
     }
+    getResolvedConstraints(constraints) {
+        return constraints;
+    }
     publishStream(stream, options) {
         return this.call.publish(stream, this.trackType, options);
     }
@@ -11617,6 +12126,7 @@ class DeviceManager {
         this.muteLocalStream(stopTracks);
         const allEnded = this.getTracks().every((t) => t.readyState === 'ended');
         if (allEnded) {
+            await this.stopActiveVirtualSession();
             // @ts-expect-error release() is present in react-native-webrtc
             if (typeof mediaStream.release === 'function') {
                 // @ts-expect-error called to dispose the stream in RN
@@ -11672,12 +12182,12 @@ class DeviceManager {
             // before chainWith below registers new ones for the new chain.
             this.runCurrentStreamCleanups();
             const defaultConstraints = this.state.defaultConstraints;
-            const constraints = {
+            const constraints = this.getResolvedConstraints({
                 ...defaultConstraints,
                 deviceId: this.state.selectedDevice
                     ? { exact: this.state.selectedDevice }
                     : undefined,
-            };
+            });
             /**
              * Chains two media streams together.
              *
@@ -11734,7 +12244,7 @@ class DeviceManager {
             };
             // the rootStream represents the stream coming from the actual device
             // e.g. camera or microphone stream
-            rootStreamPromise = this.getStream(constraints);
+            rootStreamPromise = this.getSelectedStream(constraints);
             // we publish the last MediaStream of the chain
             stream = await this.filters.reduce((parent, entry) => parent
                 .then((inputStream) => {
@@ -12051,7 +12561,10 @@ class DeviceManagerState {
         setCurrentValue(this.mediaStreamSubject, stream);
         setCurrentValue(this.rootMediaStreamSubject, rootStream);
         if (rootStream) {
-            this.setDevice(this.getDeviceIdFromStream(rootStream));
+            const derived = this.getDeviceIdFromStream(rootStream);
+            if (derived) {
+                this.setDevice(derived);
+            }
         }
     }
     /**
@@ -12264,7 +12777,7 @@ class CameraManager extends DeviceManager {
     getDevices() {
         return getVideoDevices(this.call.tracer);
     }
-    getStream(constraints) {
+    getResolvedConstraints(constraints) {
         constraints.width = this.targetResolution.width;
         constraints.height = this.targetResolution.height;
         // We can't set both device id and facing mode
@@ -12275,6 +12788,9 @@ class CameraManager extends DeviceManager {
             constraints.facingMode =
                 this.state.direction === 'front' ? 'user' : 'environment';
         }
+        return constraints;
+    }
+    getStream(constraints) {
         return getVideoStream(constraints, this.call.tracer);
     }
 }
@@ -13602,9 +14118,10 @@ class Call {
                 this.sfuStatsReporter?.flush();
                 this.sfuStatsReporter?.stop();
                 this.sfuStatsReporter = undefined;
-                this.subscriber?.dispose();
+                this.lastStatsOptions = undefined;
+                await this.subscriber?.dispose();
                 this.subscriber = undefined;
-                this.publisher?.dispose();
+                await this.publisher?.dispose();
                 this.publisher = undefined;
                 await this.sfuClient?.leaveAndClose(leaveReason);
                 this.sfuClient = undefined;
@@ -13880,15 +14397,17 @@ class Call {
             const performingMigration = this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE;
             const performingRejoin = this.reconnectStrategy === WebsocketReconnectStrategy.REJOIN;
             const performingFastReconnect = this.reconnectStrategy === WebsocketReconnectStrategy.FAST;
-            let statsOptions = this.sfuStatsReporter?.options;
+            let statsOptions = this.lastStatsOptions;
             if (!this.credentials ||
                 !statsOptions ||
                 performingRejoin ||
-                performingMigration) {
+                performingMigration ||
+                data?.migrating_from) {
                 try {
                     const joinResponse = await this.doJoinRequest(data);
                     this.credentials = joinResponse.credentials;
                     statsOptions = joinResponse.stats_options;
+                    this.lastStatsOptions = statsOptions;
                 }
                 catch (error) {
                     // prevent triggering reconnect flow if the state is OFFLINE
@@ -13995,7 +14514,7 @@ class Call {
             }
             else {
                 const connectionConfig = toRtcConfiguration(this.credentials.ice_servers);
-                this.initPublisherAndSubscriber({
+                await this.initPublisherAndSubscriber({
                     sfuClient,
                     connectionConfig,
                     clientDetails,
@@ -14140,11 +14659,11 @@ class Call {
          * Initializes the Publisher and Subscriber Peer Connections.
          * @internal
          */
-        this.initPublisherAndSubscriber = (opts) => {
+        this.initPublisherAndSubscriber = async (opts) => {
             const { sfuClient, connectionConfig, clientDetails, statsOptions, publishOptions, closePreviousInstances, unifiedSessionId, } = opts;
-            const { enable_rtc_stats: enableTracing } = statsOptions;
+            const { enable_rtc_stats: enableTracing, reporting_interval_ms: reportingIntervalMs, } = statsOptions;
             if (closePreviousInstances && this.subscriber) {
-                this.subscriber.dispose();
+                await this.subscriber.dispose();
             }
             const basePeerConnectionOptions = {
                 sfuClient,
@@ -14153,6 +14672,7 @@ class Call {
                 connectionConfig,
                 tag: sfuClient.tag,
                 enableTracing,
+                statsTimestampDriftThresholdMs: reportingIntervalMs / 2,
                 clientPublishOptions: this.clientPublishOptions,
                 onReconnectionNeeded: (kind, reason, peerType) => {
                     this.reconnect(kind, reason).catch((err) => {
@@ -14173,7 +14693,7 @@ class Call {
             const isAnonymous = this.streamClient.user?.type === 'anonymous';
             if (!isAnonymous) {
                 if (closePreviousInstances && this.publisher) {
-                    this.publisher.dispose();
+                    await this.publisher.dispose();
                 }
                 this.publisher = new Publisher(basePeerConnectionOptions, publishOptions);
             }
@@ -14276,10 +14796,17 @@ class Call {
          *   `ICE_NEVER_CONNECTED` increments the unsupported-network counter).
          */
         this.reconnect = async (strategy, reason) => {
-            if (this.state.callingState === CallingState.RECONNECTING ||
+            if (this.state.callingState === CallingState.JOINING ||
+                this.state.callingState === CallingState.RECONNECTING ||
                 this.state.callingState === CallingState.MIGRATING ||
                 this.state.callingState === CallingState.RECONNECTING_FAILED)
                 return;
+            // Drop redundant reconnect calls. If a reconnect is already queued or
+            // running for this Call, that entry will resolve whatever broke;
+            // queueing more entries just replays the full REJOIN cycle (one extra
+            // `POST /join` per entry) once the call is already healthy again.
+            if (hasPending(this.reconnectConcurrencyTag))
+                return;
             return withoutConcurrency(this.reconnectConcurrencyTag, async () => {
                 const reconnectStartTime = Date.now();
                 this.reconnectStrategy = strategy;
@@ -14484,8 +15011,8 @@ class Call {
                 this.state.setCallingState(CallingState.JOINED);
             }
             finally {
-                currentSubscriber?.dispose();
-                currentPublisher?.dispose();
+                await currentSubscriber?.dispose();
+                await currentPublisher?.dispose();
                 // and close the previous SFU client, without specifying close code
                 currentSfuClient.close(StreamSfuClient.NORMAL_CLOSURE, 'Migrating away');
             }
@@ -14674,7 +15201,7 @@ class Call {
         this.stopPublish = async (...trackTypes) => {
             if (!this.sfuClient || !this.publisher)
                 return;
-            this.publisher.stopTracks(...trackTypes);
+            await this.publisher.stopTracks(...trackTypes);
             await this.updateLocalStreamState(undefined, ...trackTypes);
         };
         /**
@@ -16787,7 +17314,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.50.0", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.52.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -17423,5 +17950,5 @@ const humanize = (n) => {
     return String(n);
 };
 
-export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallRecordingFailedEventRecordingTypeEnum, CallRecordingReadyEventRecordingTypeEnum, CallRecordingStartedEventRecordingTypeEnum, CallRecordingStoppedEventRecordingTypeEnum, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, IndividualRecordingSettingsRequestModeEnum, IndividualRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RawRecordingSettingsRequestModeEnum, RawRecordingSettingsResponseModeEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, SfuJoinError, models as SfuModels, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceState, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio$1 as hasAudio, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, humanize, isPinned, livestreamOrAudioRoomSortPreset, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setDeviceInfo, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, videoLoggerSystem, withParticipantSource };
+export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallRecordingFailedEventRecordingTypeEnum, CallRecordingReadyEventRecordingTypeEnum, CallRecordingStartedEventRecordingTypeEnum, CallRecordingStoppedEventRecordingTypeEnum, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, IndividualRecordingSettingsRequestModeEnum, IndividualRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RawRecordingSettingsRequestModeEnum, RawRecordingSettingsResponseModeEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, SfuJoinError, models as SfuModels, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceState, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio$1 as hasAudio, hasInterruptedTrack, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, humanize, isPinned, livestreamOrAudioRoomSortPreset, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setDeviceInfo, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, videoLoggerSystem, withParticipantSource };
 //# sourceMappingURL=index.es.js.map