@stream-io/video-client 1.58.0 → 1.59.1

package/dist/index.cjs.js

@@ -4431,6 +4431,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
@@ -5079,7 +5101,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,
@@ -5336,6 +5358,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);
 }
@@ -5907,6 +5950,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.
  *
@@ -6017,11 +6081,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.
@@ -6030,7 +6094,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.
@@ -9824,6 +9888,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;
@@ -9913,6 +9982,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);
@@ -10655,7 +10726,6 @@ const watchCallRejected = (call) => {
  */
 const watchCallEnded = (call) => {
     return function onCallEnded() {
-        globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
         const { callingState } = call.state;
         if (callingState !== exports.CallingState.IDLE &&
             callingState !== exports.CallingState.LEFT) {
@@ -10664,9 +10734,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);
             });
         }
     };
@@ -13472,7 +13546,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]);
@@ -13499,13 +13573,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();
@@ -13857,8 +13931,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);
@@ -13870,8 +13945,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
@@ -13881,7 +13955,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();
             }
         }
@@ -14476,8 +14553,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
@@ -14489,11 +14567,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();
             }
         }
@@ -15462,7 +15540,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';
@@ -15625,8 +15703,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.
@@ -15639,9 +15727,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);
         }
@@ -15649,9 +15735,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;
     };
     /**
@@ -15662,9 +15746,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);
         }
@@ -15672,9 +15754,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;
     };
     /**
@@ -15738,7 +15818,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 ([exports.CallingState.JOINED, exports.CallingState.JOINING].includes(callingState)) {
             throw new Error(`Illegal State: call.join() shall be called only once`);
@@ -15760,7 +15840,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;
@@ -15812,7 +15891,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.
@@ -15984,7 +16063,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()) {
@@ -16774,12 +16856,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,
+                };
+            });
         }
     };
     /**
@@ -17469,18 +17555,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
@@ -18964,11 +19053,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);
         }
     };
     /**
@@ -18988,11 +19077,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}`),
@@ -19355,7 +19444,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 && {
@@ -19537,7 +19625,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,
         };
@@ -19548,9 +19635,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',
         });
     };
@@ -19565,9 +19649,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,
@@ -19585,9 +19666,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',
@@ -19600,7 +19678,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 } : {};
@@ -19612,7 +19689,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 && {
@@ -19863,6 +19939,7 @@ class StreamVideoClient {
                         }
                         else {
                             await call.updateFromRingingEvent(e);
+                            await call.get();
                         }
                     }
                     else {
@@ -19901,6 +19978,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
@@ -19911,10 +19995,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) {
@@ -20057,9 +20147,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({
@@ -20073,7 +20165,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);
@@ -20225,6 +20320,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 rxjs.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.
  *
@@ -20598,6 +20889,7 @@ exports.CallTypes = CallTypes;
 exports.CameraManager = CameraManager;
 exports.CameraManagerState = CameraManagerState;
 exports.CreateDeviceRequestPushProviderEnum = CreateDeviceRequestPushProviderEnum;
+exports.DEFAULT_LOOPBACK_RECORDING_DURATION_MS = DEFAULT_LOOPBACK_RECORDING_DURATION_MS;
 exports.DeviceManager = DeviceManager;
 exports.DeviceManagerState = DeviceManagerState;
 exports.DynascaleManager = DynascaleManager;
@@ -20615,7 +20907,12 @@ exports.IndividualRecordingSettingsResponseModeEnum = IndividualRecordingSetting
 exports.IngressAudioEncodingOptionsRequestChannelsEnum = IngressAudioEncodingOptionsRequestChannelsEnum;
 exports.IngressSourceRequestFpsEnum = IngressSourceRequestFpsEnum;
 exports.IngressVideoLayerRequestCodecEnum = IngressVideoLayerRequestCodecEnum;
+exports.LOOPBACK_STREAMS_WAIT_TIMEOUT_MS = LOOPBACK_STREAMS_WAIT_TIMEOUT_MS;
 exports.LayoutSettingsRequestNameEnum = LayoutSettingsRequestNameEnum;
+exports.LoopbackStreamsTimeoutError = LoopbackStreamsTimeoutError;
+exports.MAX_LOOPBACK_RECORDING_DURATION_MS = MAX_LOOPBACK_RECORDING_DURATION_MS;
+exports.MIN_LOOPBACK_RECORDING_DURATION_MS = MIN_LOOPBACK_RECORDING_DURATION_MS;
+exports.MediaStreamRecorder = MediaStreamRecorder;
 exports.MicrophoneManager = MicrophoneManager;
 exports.MicrophoneManagerState = MicrophoneManagerState;
 exports.NoiseCancellationSettingsModeEnum = NoiseCancellationSettingsModeEnum;
@@ -20656,6 +20953,7 @@ exports.VideoSettingsResponseCameraFacingEnum = VideoSettingsResponseCameraFacin
 exports.ViewportTracker = ViewportTracker;
 exports.WSAuthMessageProductsEnum = WSAuthMessageProductsEnum;
 exports.checkIfAudioOutputChangeSupported = checkIfAudioOutputChangeSupported;
+exports.clampLoopbackRecordingDuration = clampLoopbackRecordingDuration;
 exports.combineComparators = combineComparators;
 exports.conditional = conditional;
 exports.createSoundDetector = createSoundDetector;
@@ -20664,6 +20962,7 @@ exports.descending = descending;
 exports.deviceIds$ = deviceIds$;
 exports.disposeOfMediaStream = disposeOfMediaStream;
 exports.dominantSpeaker = dominantSpeaker;
+exports.enableLoopbackAudio = enableLoopbackAudio;
 exports.getAudioBrowserPermission = getAudioBrowserPermission;
 exports.getAudioDevices = getAudioDevices;
 exports.getAudioOutputDevices = getAudioOutputDevices;
@@ -20671,6 +20970,8 @@ exports.getAudioStream = getAudioStream;
 exports.getCallMediaEngineProvider = getCallMediaEngineProvider;
 exports.getClientDetails = getClientDetails;
 exports.getDeviceState = getDeviceState;
+exports.getLoopbackStreams = getLoopbackStreams;
+exports.getLoopbackTracks = getLoopbackTracks;
 exports.getScreenShareStream = getScreenShareStream;
 exports.getSdkInfo = getSdkInfo;
 exports.getVideoBrowserPermission = getVideoBrowserPermission;
@@ -20691,6 +20992,7 @@ exports.name = name;
 exports.noopComparator = noopComparator;
 exports.paginatedLayoutSortPreset = paginatedLayoutSortPreset;
 exports.pinned = pinned;
+exports.publishing = publishing;
 exports.publishingAudio = publishingAudio;
 exports.publishingVideo = publishingVideo;
 exports.reactionType = reactionType;
@@ -20707,5 +21009,7 @@ exports.setWebRTCInfo = setWebRTCInfo;
 exports.speakerLayoutSortPreset = speakerLayoutSortPreset;
 exports.speaking = speaking;
 exports.videoLoggerSystem = videoLoggerSystem;
+exports.waitForLoopbackStreams = waitForLoopbackStreams;
+exports.withLoopbackAudioEnabled = withLoopbackAudioEnabled;
 exports.withParticipantSource = withParticipantSource;
 //# sourceMappingURL=index.cjs.js.map