@stream-io/video-client 1.58.0 → 1.59.1

package/dist/index.browser.es.js

@@ -7,7 +7,7 @@ import { TwirpFetchTransport, TwirpErrorCode } from '@protobuf-ts/twirp-transpor
 import * as scopedLogger from '@stream-io/logger';
 export { LogLevelEnum } from '@stream-io/logger';
 import { parse, write } from 'sdp-transform';
-import { Subject, Observable, combineLatest, BehaviorSubject, ReplaySubject, shareReplay, map, distinctUntilChanged, startWith, takeWhile, distinctUntilKeyChanged, fromEventPattern, concatMap, merge, from, fromEvent, tap, debounceTime, pairwise, firstValueFrom, of } from 'rxjs';
+import { Subject, Observable, combineLatest, BehaviorSubject, ReplaySubject, shareReplay, map, distinctUntilChanged, startWith, takeWhile, distinctUntilKeyChanged, fromEventPattern, concatMap, merge, from, fromEvent, tap, debounceTime, pairwise, firstValueFrom, of, Subscription } from 'rxjs';
 import { UAParser } from 'ua-parser-js';
 import { WorkerTimer } from '@stream-io/worker-timer';
 
@@ -4411,6 +4411,28 @@ function isErrorResponse(res) {
 function isCloseEvent(res) {
     return res.code !== undefined;
 }
+/**
+ * Invokes a single event listener in isolation, so that a faulty listener
+ * cannot abort the dispatch loop nor the bookkeeping that follows it.
+ *
+ * @param listener the listener to invoke.
+ * @param event the event to pass to the listener.
+ * @param logger the logger to report listener failures with.
+ */
+const invokeEventListener = (listener, event, logger) => {
+    try {
+        const result = listener(event);
+        if (result && typeof result.then === 'function') {
+            Promise.resolve(result).catch((error) => report(logger, error, event));
+        }
+    }
+    catch (error) {
+        report(logger, error, event);
+    }
+};
+const report = (logger, error, event) => {
+    logger.error('Unhandled error in event listener', error, event);
+};
 
 /**
  * Checks whether we are using React Native
@@ -5059,7 +5081,7 @@ const toIceCandidate = (iceTrickle) => {
     }
 };
 
-const version = "1.58.0";
+const version = "1.59.1";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -5316,6 +5338,27 @@ const withoutConcurrency = createRunner(wrapWithContinuationTracking);
  */
 const withCancellation = createRunner(wrapWithCancellation);
 const pendingPromises = new Map();
+/**
+ * Wraps an async function so concurrent calls share the in-flight promise
+ * instead of queueing another execution.
+ *
+ * @param cb Async function to wrap.
+ * @returns Wrapped async function.
+ */
+function singleFlight(cb) {
+    let pending;
+    return (...args) => {
+        if (pending)
+            return pending;
+        const promise = cb(...args).finally(() => {
+            if (pending === promise) {
+                pending = undefined;
+            }
+        });
+        pending = promise;
+        return promise;
+    };
+}
 function hasPending(tag) {
     return pendingPromises.has(tag);
 }
@@ -5887,6 +5930,27 @@ const publishingAudio = (a, b) => {
         return 1;
     return 0;
 };
+/**
+ * A comparator which prioritizes participants who are publishing any track
+ * over participants who are not publishing at all.
+ *
+ * Unlike `publishingVideo` and `publishingAudio`, this comparator does not
+ * distinguish between track types. Muting the microphone or turning off the
+ * camera does not change a participant's rank as long as they still publish
+ * something, which keeps the ordering stable across ordinary device toggles.
+ *
+ * @param a the first participant.
+ * @param b the second participant.
+ */
+const publishing = (a, b) => {
+    const hasA = a.publishedTracks.length > 0;
+    const hasB = b.publishedTracks.length > 0;
+    if (hasA && !hasB)
+        return -1;
+    if (!hasA && hasB)
+        return 1;
+    return 0;
+};
 /**
  * A comparator which prioritizes participants who are pinned.
  *
@@ -5997,11 +6061,11 @@ const withVideoIngressSource = withParticipantSource(ParticipantSource.RTMP, Par
 /**
  * The default sorting preset.
  */
-const defaultSortPreset = combineComparators(screenSharing, pinned, ifInvisibleBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), publishingVideo, publishingAudio)));
+const defaultSortPreset = combineComparators(screenSharing, pinned, publishing, ifInvisibleBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), publishingVideo, publishingAudio)));
 /**
  * The sorting preset for speaker layout.
  */
-const speakerLayoutSortPreset = combineComparators(screenSharing, pinned, dominantSpeaker, ifInvisibleBy(combineComparators(speaking, reactionType('raised-hand'), withVideoIngressSource, publishingVideo, publishingAudio)));
+const speakerLayoutSortPreset = combineComparators(screenSharing, pinned, dominantSpeaker, publishing, ifInvisibleBy(combineComparators(speaking, reactionType('raised-hand'), withVideoIngressSource, publishingVideo, publishingAudio)));
 /**
  * The sorting preset for layouts that don't render all participants but
  * instead, render them in pages.
@@ -6010,7 +6074,7 @@ const paginatedLayoutSortPreset = combineComparators(pinned, ifInvisibleOrUnknow
 /**
  * The sorting preset for livestreams and audio rooms.
  */
-const livestreamOrAudioRoomSortPreset = combineComparators(ifInvisibleOrUnknownBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), withVideoIngressSource, publishingVideo, publishingAudio)), role('admin', 'host', 'speaker'));
+const livestreamOrAudioRoomSortPreset = combineComparators(publishing, ifInvisibleOrUnknownBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), withVideoIngressSource, publishingVideo, publishingAudio)), role('admin', 'host', 'speaker'));
 
 /**
  * Returns the default egress object - when no egress data is available.
@@ -9804,6 +9868,11 @@ class Subscriber extends BasePeerConnection {
             throw e;
         }
     };
+    /**
+     * Whether the given stream is one the SFU echoed back to us
+     * (`allowOwnTracksLoopback`) rather than a local capture stream.
+     */
+    isSelfSubscribedStream = (stream) => !!stream && !!this.trackedStreams?.has(stream);
     handleOnTrack = (e) => {
         const { streams, track } = e;
         const [primaryStream] = streams;
@@ -9893,6 +9962,8 @@ class Subscriber extends BasePeerConnection {
         const target = this.state.participants.find((p) => p.trackLookupPrefix === trackId);
         if (!target)
             return;
+        if (target.isLocalParticipant)
+            return;
         this.state.updateParticipant(target.sessionId, (p) => {
             const current = p.interruptedTracks ?? [];
             const has = current.includes(trackType);
@@ -10635,7 +10706,6 @@ const watchCallRejected = (call) => {
  */
 const watchCallEnded = (call) => {
     return function onCallEnded() {
-        globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
         const { callingState } = call.state;
         if (callingState !== CallingState.IDLE &&
             callingState !== CallingState.LEFT) {
@@ -10644,9 +10714,13 @@ const watchCallEnded = (call) => {
                 reason: 'call.ended event received',
             });
             call
-                .leave({ message: 'call.ended event received', reject: false })
+                .leave({
+                message: 'call.ended event received',
+                reject: false,
+                reason: 'ended',
+            })
                 .catch((err) => {
-                call.logger.error('Failed to leave call after call.ended ', err);
+                call.logger.error('Failed to leave call after call.ended', err);
             });
         }
     };
@@ -13452,7 +13526,7 @@ class DeviceManager {
             createSyntheticDevice(selectedDevice, deviceKind);
         writePreferences(currentDevice, deviceKey, muted, storageKey);
     }
-    async applyPersistedPreferences(enabledInCallType) {
+    async applyPersistedPreferences(enabledInCallType, forceDisabled = false) {
         const deviceKey = this.trackType === TrackType.AUDIO ? 'microphone' : 'camera';
         const preferences = readPreferences(this.devicePersistence.storageKey);
         const preferenceList = toPreferenceList(preferences[deviceKey]);
@@ -13479,13 +13553,13 @@ class DeviceManager {
         }
         const canPublish = this.call.permissionsContext.canPublish(this.trackType);
         if (typeof muted === 'boolean' && enabledInCallType && canPublish) {
-            await this.applyMutedState(muted);
+            await this.applyMutedState(muted, forceDisabled);
             appliedMute = true;
         }
         return appliedDevice || appliedMute;
     }
-    async applyMutedState(muted) {
-        if (this.state.status !== undefined)
+    async applyMutedState(muted, forceDisabled) {
+        if (forceDisabled || this.state.status !== undefined)
             return;
         if (muted) {
             await this.disable();
@@ -13837,8 +13911,9 @@ class CameraManager extends DeviceManager {
      *
      * @param settings the video settings to apply.
      * @param publish whether to publish the stream after applying the settings.
+     * @param forceDisabled whether to keep the camera disabled, regardless of server-side or local preferences.
      */
-    async apply(settings, publish) {
+    async apply(settings, publish, forceDisabled = false) {
         // Wait for any in progress camera operation
         await this.statusChangeSettled();
         await this.selectTargetResolution(settings.target_resolution);
@@ -13850,8 +13925,7 @@ class CameraManager extends DeviceManager {
         if (shouldApplyDefaults &&
             this.devicePersistence.enabled &&
             permissionState === 'granted') {
-            persistedPreferencesApplied =
-                await this.applyPersistedPreferences(enabledInCallType);
+            persistedPreferencesApplied = await this.applyPersistedPreferences(enabledInCallType, forceDisabled);
         }
         // apply a direction and enable the camera only if in "pristine" state,
         // and there are no persisted preferences
@@ -13861,7 +13935,10 @@ class CameraManager extends DeviceManager {
                 const direction = settings.camera_facing === 'front' ? 'front' : 'back';
                 await this.selectDirection(direction, { enableCamera: false });
             }
-            if (canPublish && settings.camera_default_on && enabledInCallType) {
+            if (!forceDisabled &&
+                canPublish &&
+                settings.camera_default_on &&
+                enabledInCallType) {
                 await this.enable();
             }
         }
@@ -14456,8 +14533,9 @@ class MicrophoneManager extends AudioDeviceManager {
      * Applies the audio settings to the microphone.
      * @param settings the audio settings to apply.
      * @param publish whether to publish the stream after applying the settings.
+     * @param forceDisabled whether to keep the mic disabled, regardless of server-side or local preferences.
      */
-    async apply(settings, publish) {
+    async apply(settings, publish, forceDisabled = false) {
         // Wait for any in progress mic operation
         await this.statusChangeSettled();
         // apply server-side settings only when the device state is pristine
@@ -14469,11 +14547,11 @@ class MicrophoneManager extends AudioDeviceManager {
         if (shouldApplyDefaults &&
             this.devicePersistence.enabled &&
             permissionState === 'granted') {
-            persistedPreferencesApplied = await this.applyPersistedPreferences(true);
+            persistedPreferencesApplied = await this.applyPersistedPreferences(true, forceDisabled);
         }
         const canPublish = this.call.permissionsContext.canPublish(this.trackType);
         if (shouldApplyDefaults && !persistedPreferencesApplied) {
-            if (canPublish && settings.mic_default_on) {
+            if (!forceDisabled && canPublish && settings.mic_default_on) {
                 await this.enable();
             }
         }
@@ -15442,7 +15520,7 @@ class Call {
                     }
                 }
             }
-            globalThis.streamRNVideoSDK?.callingX?.endCall(this);
+            globalThis.streamRNVideoSDK?.callingX?.endCall(this, reason === 'ended' ? 'remote' : undefined);
             this.statsReporter?.stop();
             this.statsReporter = undefined;
             const leaveReason = message ?? reason ?? 'user is leaving the call';
@@ -15605,8 +15683,18 @@ class Call {
         // const calls = useCalls().filter((c) => c.ringing);
         const calls = this.clientStore.calls.filter((c) => c.cid !== this.cid);
         this.clientStore.setCalls([this, ...calls]);
-        const skipSpeakerApply = isReactNative();
-        await this.applyDeviceConfig(settings, false, skipSpeakerApply);
+        await this.applyDeviceConfig(settings, { publish: false });
+    };
+    /**
+     * Applies a backend-provided call state snapshot
+     * (call, members, own capabilities) to this instance.
+     *
+     * @internal an internal method and should not be used outside the SDK.
+     */
+    updateFromCallStateResponse = (response) => {
+        this.state.updateFromCallResponse(response.call);
+        this.state.setMembers(response.members);
+        this.state.setOwnCapabilities(response.own_capabilities);
     };
     /**
      * Loads the information about the call.
@@ -15619,9 +15707,7 @@ class Call {
     get = async (params) => {
         await this.setup();
         const response = await this.streamClient.get(this.streamClientBasePath, params);
-        this.state.updateFromCallResponse(response.call);
-        this.state.setMembers(response.members);
-        this.state.setOwnCapabilities(response.own_capabilities);
+        this.updateFromCallStateResponse(response);
         if (params?.ring) {
             this.ringingSubject.next(true);
         }
@@ -15629,9 +15715,7 @@ class Call {
             this.watching = true;
             this.clientStore.registerOrUpdateCall(this);
         }
-        // Skip speaker setup on RN if ringing was requested or the call is already ringing
-        const skipSpeakerApply = isReactNative();
-        await this.applyDeviceConfig(response.call.settings, false, skipSpeakerApply);
+        await this.applyDeviceConfig(response.call.settings, { publish: false });
         return response;
     };
     /**
@@ -15642,9 +15726,7 @@ class Call {
     getOrCreate = async (data) => {
         await this.setup();
         const response = await this.streamClient.post(this.streamClientBasePath, data);
-        this.state.updateFromCallResponse(response.call);
-        this.state.setMembers(response.members);
-        this.state.setOwnCapabilities(response.own_capabilities);
+        this.updateFromCallStateResponse(response);
         if (data?.ring) {
             this.ringingSubject.next(true);
         }
@@ -15652,9 +15734,7 @@ class Call {
             this.watching = true;
             this.clientStore.registerOrUpdateCall(this);
         }
-        // Skip speaker setup on RN if ringing was requested or the call is already ringing
-        const skipSpeakerApply = isReactNative();
-        await this.applyDeviceConfig(response.call.settings, false, skipSpeakerApply);
+        await this.applyDeviceConfig(response.call.settings, { publish: false });
         return response;
     };
     /**
@@ -15718,7 +15798,7 @@ class Call {
      *
      * @returns a promise which resolves once the call join-flow has finished.
      */
-    join = async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, allowOwnTracksLoopback = false, ...data } = {}) => {
+    join = singleFlight(async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, allowOwnTracksLoopback = false, ...data } = {}) => {
         const callingState = this.state.callingState;
         if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
             throw new Error(`Illegal State: call.join() shall be called only once`);
@@ -15740,7 +15820,6 @@ class Call {
             callId: this.id,
             getCallSessionId: () => this.state.session?.id ?? '',
             getSfuId: () => this.credentials?.server.edge_name ?? '',
-            getUserSessionId: () => this.sfuClient?.sessionId ?? '',
         });
         this.joinResponseTimeout = joinResponseTimeout;
         this.rpcRequestTimeout = rpcRequestTimeout;
@@ -15792,7 +15871,7 @@ class Call {
             callingX?.endCall(this, 'error');
             throw error;
         }
-    };
+    });
     /**
      * Will make a single attempt to watch for call related WebSocket events
      * and initiate a call session with the server.
@@ -15964,7 +16043,10 @@ class Call {
         if (!this.deviceSettingsAppliedOnce &&
             this.state.settings &&
             !supersededByLeave()) {
-            await this.applyDeviceConfig(this.state.settings, true, false);
+            await this.applyDeviceConfig(this.state.settings, {
+                publish: true,
+                skipSpeakerApply: false,
+            });
             this.deviceSettingsAppliedOnce = true;
         }
         if (!this.callManagerStarted && !supersededByLeave()) {
@@ -16754,12 +16836,16 @@ class Call {
             const streamStateProp = trackTypeToParticipantStreamKey(trackType);
             if (!streamStateProp)
                 continue;
-            this.state.updateParticipant(sessionId, (p) => ({
-                publishedTracks: mediaStream
-                    ? pushToIfMissing([...p.publishedTracks], trackType)
-                    : p.publishedTracks.filter((t) => t !== trackType),
-                [streamStateProp]: mediaStream,
-            }));
+            this.state.updateParticipant(sessionId, (p) => {
+                const currentStream = p[streamStateProp];
+                const isEchoedStream = this.subscriber?.isSelfSubscribedStream(currentStream);
+                return {
+                    publishedTracks: mediaStream
+                        ? pushToIfMissing([...p.publishedTracks], trackType)
+                        : p.publishedTracks.filter((t) => t !== trackType),
+                    [streamStateProp]: isEchoedStream ? currentStream : mediaStream,
+                };
+            });
         }
     };
     /**
@@ -17449,18 +17535,21 @@ class Call {
      *
      * @internal
      */
-    applyDeviceConfig = async (settings, publish, skipSpeakerApply) => {
+    applyDeviceConfig = async (settings, opts) => {
+        const { publish, 
+        // Skip speaker setup on RN until joining (explicitly passed as false during join())
+        skipSpeakerApply = isReactNative(), withDisabledDevices, } = opts;
         if (!skipSpeakerApply) {
-            await this.speaker.apply(settings).catch((err) => {
-                this.logger.warn('Speaker init failed', err);
-            });
+            await this.speaker
+                .apply(settings)
+                .catch((err) => this.logger.warn('Speaker init failed', err));
         }
-        await this.camera.apply(settings.video, publish).catch((err) => {
-            this.logger.warn('Camera init failed', err);
-        });
-        await this.microphone.apply(settings.audio, publish).catch((err) => {
-            this.logger.warn('Mic init failed', err);
-        });
+        await this.camera
+            .apply(settings.video, publish, withDisabledDevices)
+            .catch((err) => this.logger.warn('Camera init failed', err));
+        await this.microphone
+            .apply(settings.audio, publish, withDisabledDevices)
+            .catch((err) => this.logger.warn('Mic init failed', err));
     };
     /**
      * Will begin tracking the given element for visibility changes within the
@@ -18946,11 +19035,11 @@ class StreamClient {
             return;
         // call generic listeners
         for (const listener of this.listeners.all || []) {
-            listener(event);
+            invokeEventListener(listener, event, this.logger);
         }
         // call type specific listeners
         for (const listener of this.listeners[event.type] || []) {
-            listener(event);
+            invokeEventListener(listener, event, this.logger);
         }
     };
     /**
@@ -18970,11 +19059,11 @@ class StreamClient {
         return await this.wsConnection.connect(this.defaultWSTimeout);
     };
     getSdkVersion = () => this.options.clientAppIdentifier?.sdkVersion ||
-        "1.58.0";
+        "1.59.1";
     getUserAgent = () => {
         if (!this.cachedUserAgent) {
             const { clientAppIdentifier = {} } = this.options;
-            const { sdkName = 'js', sdkVersion = "1.58.0", ...extras } = clientAppIdentifier;
+            const { sdkName = 'js', sdkVersion = "1.59.1", ...extras } = clientAppIdentifier;
             this.cachedUserAgent = [
                 `stream-video-${sdkName}-v${sdkVersion}`,
                 ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -19337,7 +19426,6 @@ class ClientEventReporter {
             user_id: this.streamClient.userID || this.coordinatorConnectUserId,
             type: ctx?.callType,
             id: ctx?.callId,
-            call_cid: cid,
             stage: 'JoinInitiated',
             join_attempt_id: joinAttemptId,
             ...(coordinatorConnectId && {
@@ -19519,7 +19607,6 @@ class ClientEventReporter {
             startedAt: Date.now(),
             joinAttemptIdSnapshot: this.joinAttemptIds.get(cid),
             sfuId: this.getSfuId(cid),
-            userSessionId: this.getUserSessionId(cid),
             wasPreviouslyConnected: this.pcEverConnected.get(key) === true,
             lastIceState: iceConnectionState,
         };
@@ -19530,9 +19617,6 @@ class ClientEventReporter {
             peer_connection: role,
             was_previously_connected: pair.wasPreviouslyConnected,
             ...(pair.sfuId && { sfu_id: pair.sfuId }),
-            ...(pair.userSessionId && {
-                user_session_id: pair.userSessionId,
-            }),
             event_type: 'initiated',
         });
     };
@@ -19547,9 +19631,6 @@ class ClientEventReporter {
             peer_connection: role,
             was_previously_connected: pair.wasPreviouslyConnected,
             ...(pair.sfuId && { sfu_id: pair.sfuId }),
-            ...(pair.userSessionId && {
-                user_session_id: pair.userSessionId,
-            }),
             event_type: 'completed',
             outcome: 'success',
             retry_count_attempt: 0,
@@ -19567,9 +19648,6 @@ class ClientEventReporter {
             ...this.sessionIdField(cid),
             peer_connection: role,
             was_previously_connected: pair.wasPreviouslyConnected,
-            ...(pair.userSessionId && {
-                user_session_id: pair.userSessionId,
-            }),
             ...(pair.sfuId && { sfu_id: pair.sfuId }),
             event_type: 'completed',
             outcome: 'failure',
@@ -19582,7 +19660,6 @@ class ClientEventReporter {
         this.peerConnectionPairs.delete(key);
     };
     getSfuId = (cid) => this.callContexts.get(cid)?.getSfuId() ?? '';
-    getUserSessionId = (cid) => this.callContexts.get(cid)?.getUserSessionId() ?? '';
     sessionIdField = (cid) => {
         const callSessionId = this.callContexts.get(cid)?.getCallSessionId() ?? '';
         return callSessionId ? { call_session_id: callSessionId } : {};
@@ -19594,7 +19671,6 @@ class ClientEventReporter {
             user_id: this.streamClient.userID || this.coordinatorConnectUserId,
             type: ctx?.callType ?? '',
             id: ctx?.callId ?? '',
-            call_cid: cid,
             stage,
             stage_id: pair.sid,
             ...(pair.joinAttemptIdSnapshot && {
@@ -19845,6 +19921,7 @@ class StreamVideoClient {
                         }
                         else {
                             await call.updateFromRingingEvent(e);
+                            await call.get();
                         }
                     }
                     else {
@@ -19883,6 +19960,13 @@ class StreamVideoClient {
             this.logger.error(`Failed to init call from event ${e.type}`, err);
         }
     };
+    /**
+     * Queries the API for calls matching the given filters.
+     * @param data the query data.
+     */
+    doQueryCalls = (data) => {
+        return this.streamClient.post('/calls', data);
+    };
     /**
      * Rewatches the given calls with retry logic.
      * @param callsToReWatch array of call IDs to rewatch
@@ -19893,10 +19977,16 @@ class StreamVideoClient {
         for (let attempt = 0; attempt < maxRetries; attempt++) {
             try {
                 this.logger.info(`Rewatching calls ${callsToReWatch.join(', ')} attempt ${attempt + 1}`);
-                await this.queryCalls({
+                const response = await this.doQueryCalls({
                     watch: true,
                     filter_conditions: { cid: { $in: callsToReWatch } },
                 });
+                for (const c of response.calls) {
+                    const call = this.writeableStateStore.findCall(c.call.type, c.call.id);
+                    if (call) {
+                        call.updateFromCallStateResponse(c);
+                    }
+                }
                 return;
             }
             catch (err) {
@@ -20039,9 +20129,11 @@ class StreamVideoClient {
      * Will query the API for calls matching the given filters.
      *
      * @param data the query data.
+     * @param opts additional options, for tweaking the API behavior.
      */
-    queryCalls = async (data = {}) => {
-        const response = await this.streamClient.post('/calls', data);
+    queryCalls = async (data = {}, opts = {}) => {
+        const { withDisabledDevices = true } = opts;
+        const response = await this.doQueryCalls(data);
         const calls = [];
         for (const c of response.calls) {
             const call = new Call({
@@ -20055,7 +20147,10 @@ class StreamVideoClient {
                 clientStore: this.writeableStateStore,
             });
             call.state.updateFromCallResponse(c.call);
-            await call.applyDeviceConfig(c.call.settings, false, isReactNative());
+            await call.applyDeviceConfig(c.call.settings, {
+                publish: false,
+                withDisabledDevices,
+            });
             if (data.watch) {
                 await call.setup();
                 this.writeableStateStore.registerCall(call);
@@ -20207,6 +20302,202 @@ const humanize = (n) => {
     return String(n);
 };
 
+/** Default loopback stream wait timeout. */
+const LOOPBACK_STREAMS_WAIT_TIMEOUT_MS = 10 * 1000;
+/** Default loopback recording duration. */
+const DEFAULT_LOOPBACK_RECORDING_DURATION_MS = 10 * 1000;
+/** Shortest permitted loopback recording duration. */
+const MIN_LOOPBACK_RECORDING_DURATION_MS = 5 * 1000;
+/** Longest permitted loopback recording duration. */
+const MAX_LOOPBACK_RECORDING_DURATION_MS = 2 * 60 * 1000;
+/** Thrown when loopback tracks do not arrive in time. */
+class LoopbackStreamsTimeoutError extends Error {
+    constructor() {
+        super('Timed out waiting for loopback streams. Ensure the call was joined ' +
+            'with `allowOwnTracksLoopback: true` and that the SFU is configured ' +
+            'to echo self-sub tracks.');
+        this.name = 'LoopbackStreamsTimeoutError';
+    }
+}
+/**
+ * Returns the streams on the given participant that the SFU echoed back to us,
+ * ignoring the local capture streams the publishing path writes to the same
+ * fields.
+ */
+const getLoopbackStreams = (call, participant) => {
+    const { subscriber } = call ?? {};
+    const { audioStream, videoStream } = participant ?? {};
+    return {
+        loopbackVideoStream: subscriber?.isSelfSubscribedStream(videoStream)
+            ? videoStream
+            : undefined,
+        loopbackAudioStream: subscriber?.isSelfSubscribedStream(audioStream)
+            ? audioStream
+            : undefined,
+    };
+};
+/**
+ * Returns loopback tracks when all required tracks are present.
+ *
+ * Prefer {@link waitForLoopbackStreams}, which observes call state until the
+ * tracks arrive. This is the synchronous snapshot it is built from.
+ *
+ * @internal
+ */
+const getLoopbackTracks = (call, participant, includeVideo) => {
+    if (!participant)
+        return undefined;
+    const { loopbackAudioStream, loopbackVideoStream } = getLoopbackStreams(call, participant);
+    const audioTrack = loopbackAudioStream?.getAudioTracks()[0];
+    const videoTrack = includeVideo
+        ? loopbackVideoStream?.getVideoTracks()[0]
+        : undefined;
+    if (!audioTrack || (includeVideo && !videoTrack)) {
+        return undefined;
+    }
+    return { audioTrack, videoTrack };
+};
+/** Waits for the requested loopback tracks. */
+const waitForLoopbackStreams = (call, opts) => {
+    const callState = call.state;
+    const { includeVideo, signal, timeoutMs = LOOPBACK_STREAMS_WAIT_TIMEOUT_MS, } = opts;
+    return new Promise((resolve, reject) => {
+        const initial = getLoopbackTracks(call, callState.localParticipant, includeVideo);
+        if (initial) {
+            resolve(initial);
+            return;
+        }
+        if (signal.aborted) {
+            resolve(null);
+            return;
+        }
+        let settled = false;
+        const subscriptions = new Subscription();
+        const cleanup = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutId);
+            signal.removeEventListener('abort', onAbort);
+            subscriptions.unsubscribe();
+        };
+        const onAbort = () => {
+            cleanup();
+            resolve(null);
+        };
+        const timeoutId = setTimeout(() => {
+            cleanup();
+            reject(new LoopbackStreamsTimeoutError());
+        }, timeoutMs);
+        signal.addEventListener('abort', onAbort);
+        subscriptions.add(callState.localParticipant$.subscribe((participant) => {
+            const ready = getLoopbackTracks(call, participant, includeVideo);
+            if (ready) {
+                cleanup();
+                resolve(ready);
+            }
+        }));
+    });
+};
+/** Enables loopback audio while `fn` runs, then restores it. */
+const withLoopbackAudioEnabled = async (tracks, fn) => {
+    const restore = enableLoopbackAudio(tracks);
+    try {
+        return await fn();
+    }
+    finally {
+        restore();
+    }
+};
+/** Enables loopback audio and returns a restore function. */
+const enableLoopbackAudio = (tracks) => {
+    const { audioTrack } = tracks;
+    const previous = audioTrack?.enabled ?? false;
+    if (audioTrack) {
+        audioTrack.enabled = true;
+    }
+    return () => {
+        if (audioTrack) {
+            audioTrack.enabled = previous;
+        }
+    };
+};
+/** Clamps and rounds a loopback recording duration. */
+const clampLoopbackRecordingDuration = (durationMs) => Math.round(Math.min(MAX_LOOPBACK_RECORDING_DURATION_MS, Math.max(MIN_LOOPBACK_RECORDING_DURATION_MS, durationMs)));
+
+/** Single-use `MediaRecorder` wrapper that returns an in-memory blob. */
+class MediaStreamRecorder {
+    recording = promiseWithResolvers();
+    logger = videoLoggerSystem.getLogger('MediaStreamRecorder');
+    chunks = [];
+    timeoutId;
+    recorder;
+    tracks;
+    maxDurationMs;
+    constructor(stream, options = {}) {
+        if (typeof MediaRecorder === 'undefined') {
+            throw new Error('MediaRecorder is not available in this environment');
+        }
+        this.tracks = stream.getTracks();
+        if (this.tracks.length === 0) {
+            throw new Error('cannot record a MediaStream that has no tracks');
+        }
+        this.maxDurationMs = options.maxDurationMs;
+        this.recorder = new MediaRecorder(new MediaStream(this.tracks));
+        this.recorder.ondataavailable = (event) => {
+            if (event.data?.size)
+                this.chunks.push(event.data);
+        };
+        this.recorder.onstop = this.handleStop;
+        this.recorder.onerror = this.handleError;
+    }
+    /** Starts recording and resolves when recording stops. */
+    start = () => {
+        if (this.isSettled()) {
+            throw new Error('MediaStreamRecorder is single-use: this instance has already ' +
+                'recorded. Construct a new one.');
+        }
+        if (this.recorder.state === 'inactive') {
+            this.tracks.forEach((track) => track.addEventListener('ended', this.stop));
+            if (this.maxDurationMs !== undefined) {
+                this.timeoutId = setTimeout(this.stop, this.maxDurationMs);
+            }
+            this.recorder.start();
+        }
+        return this.recording.promise;
+    };
+    /** Stops recording early. */
+    stop = () => {
+        if (this.recorder.state !== 'inactive')
+            this.recorder.stop();
+    };
+    isSettled = () => this.recording.isResolved() || this.recording.isRejected();
+    detach = () => {
+        clearTimeout(this.timeoutId);
+        this.tracks.forEach((track) => track.removeEventListener('ended', this.stop));
+    };
+    handleStop = () => {
+        this.detach();
+        if (this.chunks.length === 0) {
+            this.logger.warn('MediaRecorder recording produced no data');
+            this.recording.resolve(null);
+            return;
+        }
+        const mimeType = this.chunks[0].type || this.recorder.mimeType;
+        this.recording.resolve({
+            blob: new Blob(this.chunks, { type: mimeType }),
+        });
+    };
+    handleError = (event) => {
+        if (this.isSettled())
+            return;
+        this.detach();
+        const error = event.error;
+        this.logger.error('MediaRecorder error', error);
+        this.recording.reject(error ?? new Error('MediaRecorder failed'));
+    };
+}
+
 /**
  * Tiny, type-safe event emitter.
  *
@@ -20525,5 +20816,5 @@ class EncryptionManager extends TypedEventEmitter {
     };
 }
 
-export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallRecordingFailedEventRecordingTypeEnum, CallRecordingReadyEventRecordingTypeEnum, CallRecordingStartedEventRecordingTypeEnum, CallRecordingStoppedEventRecordingTypeEnum, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, EncryptionManager, EncryptionSettingsRequestModeEnum, EncryptionSettingsResponseModeEnum, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, HLSSettingsRequestQualityTracksEnum, IndividualRecordingSettingsRequestModeEnum, IndividualRecordingSettingsRequestOutputTypesEnum, IndividualRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RawRecordingSettingsRequestModeEnum, RawRecordingSettingsResponseModeEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, RequestPermissionRequestPermissionsEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, SfuJoinError, models as SfuModels, SfuTimeoutError, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, TranslationSettingsLanguagesEnum, UpdateUserPermissionsRequestGrantPermissionsEnum, UpdateUserPermissionsRequestRevokePermissionsEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, WSAuthMessageProductsEnum, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getCallMediaEngineProvider, 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, setCallMediaEngineProvider, 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, DEFAULT_LOOPBACK_RECORDING_DURATION_MS, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, EncryptionManager, EncryptionSettingsRequestModeEnum, EncryptionSettingsResponseModeEnum, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, HLSSettingsRequestQualityTracksEnum, IndividualRecordingSettingsRequestModeEnum, IndividualRecordingSettingsRequestOutputTypesEnum, IndividualRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LOOPBACK_STREAMS_WAIT_TIMEOUT_MS, LayoutSettingsRequestNameEnum, LoopbackStreamsTimeoutError, MAX_LOOPBACK_RECORDING_DURATION_MS, MIN_LOOPBACK_RECORDING_DURATION_MS, MediaStreamRecorder, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RawRecordingSettingsRequestModeEnum, RawRecordingSettingsResponseModeEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, RequestPermissionRequestPermissionsEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, SfuJoinError, models as SfuModels, SfuTimeoutError, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, TranslationSettingsLanguagesEnum, UpdateUserPermissionsRequestGrantPermissionsEnum, UpdateUserPermissionsRequestRevokePermissionsEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, WSAuthMessageProductsEnum, checkIfAudioOutputChangeSupported, clampLoopbackRecordingDuration, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, enableLoopbackAudio, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getCallMediaEngineProvider, getClientDetails, getDeviceState, getLoopbackStreams, getLoopbackTracks, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio$1 as hasAudio, hasInterruptedTrack, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, humanize, isPinned, livestreamOrAudioRoomSortPreset, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishing, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setCallMediaEngineProvider, setDeviceInfo, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, videoLoggerSystem, waitForLoopbackStreams, withLoopbackAudioEnabled, withParticipantSource };
 //# sourceMappingURL=index.browser.es.js.map