@stream-io/video-client 1.45.0 → 1.46.1

package/dist/src/Call.d.ts

@@ -162,7 +162,7 @@ export declare class Call {
     /**
      * A flag indicating whether the call was created by the current user.
      */
-    get isCreatedByMe(): boolean;
+    get isCreatedByMe(): boolean | "" | undefined;
     /**
      * Update from the call response from the "call.ring" event
      * @internal
@@ -804,6 +804,10 @@ export declare class Call {
      * @param trackType the kind of audio.
      */
     bindAudioElement: (audioElement: HTMLAudioElement, sessionId: string, trackType?: AudioTrackType) => (() => void) | undefined;
+    /**
+     * Plays all audio elements blocked by the browser's autoplay policy.
+     */
+    resumeAudio: () => Promise<void>;
     /**
      * Binds a DOM <img> element to this call's thumbnail (if enabled in settings).
      *

package/dist/src/gen/video/sfu/event/events.d.ts

@@ -574,6 +574,10 @@ export interface ParticipantJoined {
      * @generated from protobuf field: stream.video.sfu.models.Participant participant = 2;
      */
     participant?: Participant;
+    /**
+     * @generated from protobuf field: bool is_pinned = 3;
+     */
+    isPinned: boolean;
 }
 /**
  * ParticipantJoined is fired when a user leaves a call

package/dist/src/helpers/DynascaleManager.d.ts

@@ -42,6 +42,19 @@ export declare class DynascaleManager {
     private sfuClient;
     private pendingSubscriptionsUpdate;
     readonly audioBindingsWatchdog: AudioBindingsWatchdog | undefined;
+    /**
+     * Audio elements that were blocked by the browser's autoplay policy.
+     * These can be retried by calling `resumeAudio()` from a user gesture.
+     */
+    private blockedAudioElementsSubject;
+    /**
+     * Whether the browser's autoplay policy is blocking audio playback.
+     * Will be `true` when the browser blocks autoplay (e.g., no prior user interaction).
+     * Use `resumeAudio()` within a user gesture to unblock.
+     */
+    autoplayBlocked$: import("rxjs").Observable<boolean>;
+    private addBlockedAudioElement;
+    private removeBlockedAudioElement;
     private videoTrackSubscriptionOverridesSubject;
     videoTrackSubscriptionOverrides$: import("rxjs").Observable<VideoTrackSubscriptionOverrides>;
     incomingVideoSettings$: import("rxjs").Observable<{
@@ -121,6 +134,13 @@ export declare class DynascaleManager {
      * @returns a cleanup function that will unbind the audio element.
      */
     bindAudioElement: (audioElement: HTMLAudioElement, sessionId: string, trackType: AudioTrackType) => (() => void) | undefined;
+    /**
+     * Plays all audio elements blocked by the browser's autoplay policy.
+     * Must be called from within a user gesture (e.g., click handler).
+     *
+     * @returns a promise that resolves when all blocked elements have been retried.
+     */
+    resumeAudio: () => Promise<void>;
     private getOrCreateAudioContext;
     private resumeAudioContext;
 }

package/dist/src/helpers/RNSpeechDetector.d.ts

@@ -1,9 +1,10 @@
 import { SoundStateChangeHandler } from './sound-detector';
 export declare class RNSpeechDetector {
-    private pc1;
-    private pc2;
+    private readonly pc1;
+    private readonly pc2;
     private audioStream;
     private externalAudioStream;
+    private isStopped;
     constructor(externalAudioStream?: MediaStream);
     /**
      * Starts the speech detection.
@@ -18,4 +19,5 @@ export declare class RNSpeechDetector {
      */
     private onSpeakingDetectedStateChange;
     private cleanupAudioStream;
+    private forwardIceCandidate;
 }

package/dist/src/types.d.ts

@@ -5,6 +5,7 @@ import type { RejectReason, StreamClientOptions, TokenProvider, User } from './c
 import type { Comparator } from './sorting';
 import type { StreamVideoWriteableStateStore } from './store';
 import { AxiosError } from 'axios';
+import type { Call } from './Call';
 export type StreamReaction = Pick<ReactionResponse, 'type' | 'emoji_code' | 'custom'>;
 export declare enum VisibilityState {
     UNKNOWN = "UNKNOWN",
@@ -316,22 +317,53 @@ export type StartCallRecordingFnType = {
     (request: StartRecordingRequest): Promise<StartRecordingResponse>;
     (request: StartRecordingRequest, type: CallRecordingType): Promise<StartRecordingResponse>;
 };
+type StreamRNVideoSDKCallManagerRingingParams = {
+    isRingingTypeCall: boolean;
+};
+type StreamRNVideoSDKCallManagerSetupParams = StreamRNVideoSDKCallManagerRingingParams & {
+    defaultDevice: AudioSettingsRequestDefaultDeviceEnum;
+};
+type StreamRNVideoSDKEndCallReason = 
+/** Call ended by the local user (e.g., hanging up). */
+'local'
+/** Call ended by the remote party, or outgoing call was not answered. */
+ | 'remote'
+/** Call was rejected/declined by the user. */
+ | 'rejected'
+/** Remote party was busy. */
+ | 'busy'
+/** Call was answered on another device. */
+ | 'answeredElsewhere'
+/** No response to an incoming call. */
+ | 'missed'
+/** Call failed due to an error (e.g., network issue). */
+ | 'error'
+/** Call was canceled before the remote party could answer. */
+ | 'canceled'
+/** Call restricted (e.g., airplane mode, dialing restrictions). */
+ | 'restricted'
+/** Unknown or unspecified disconnect reason. */
+ | 'unknown';
+type StreamRNVideoSDKCallingX = {
+    joinCall: (call: Call, activeCalls: Call[]) => Promise<void>;
+    endCall: (call: Call, reason?: StreamRNVideoSDKEndCallReason) => Promise<void>;
+    registerOutgoingCall: (call: Call) => Promise<void>;
+};
 export type StreamRNVideoSDKGlobals = {
+    callingX: StreamRNVideoSDKCallingX;
     callManager: {
         /**
          * Sets up the in call manager.
          */
-        setup({ defaultDevice, }: {
-            defaultDevice: AudioSettingsRequestDefaultDeviceEnum;
-        }): void;
+        setup({ defaultDevice, isRingingTypeCall, }: StreamRNVideoSDKCallManagerSetupParams): void;
         /**
          * Starts the in call manager.
          */
-        start(): void;
+        start({ isRingingTypeCall, }: StreamRNVideoSDKCallManagerRingingParams): void;
         /**
          * Stops the in call manager.
          */
-        stop(): void;
+        stop({ isRingingTypeCall }: StreamRNVideoSDKCallManagerRingingParams): void;
     };
     permissions: {
         /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.45.0",
+  "version": "1.46.1",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/Call.ts

@@ -421,6 +421,7 @@ export class Call {
         const currentUserId = this.currentUserId;
         if (currentUserId && blockedUserIds.includes(currentUserId)) {
           this.logger.info('Leaving call because of being blocked');
+          globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'restricted');
           await this.leave({ message: 'user blocked' }).catch((err) => {
             this.logger.error('Error leaving call after being blocked', err);
           });
@@ -465,6 +466,10 @@ export class Call {
           (isAcceptedElsewhere || isRejectedByMe) &&
           !hasPending(this.joinLeaveConcurrencyTag)
         ) {
+          globalThis.streamRNVideoSDK?.callingX?.endCall(
+            this,
+            isAcceptedElsewhere ? 'answeredElsewhere' : 'rejected',
+          );
           this.leave().catch(() => {
             this.logger.error(
               'Could not leave a call that was accepted or rejected elsewhere',
@@ -480,6 +485,10 @@ export class Call {
     const receiver_id = this.clientStore.connectedUser?.id;
     const ended_at = callSession?.ended_at;
     const created_by_id = this.state.createdBy?.id;
+
+    if (this.currentUserId && created_by_id === this.currentUserId) {
+      globalThis.streamRNVideoSDK?.callingX?.registerOutgoingCall(this);
+    }
     const rejected_by = callSession?.rejected_by;
     const accepted_by = callSession?.accepted_by;
     let leaveCallIdle = false;
@@ -636,16 +645,30 @@ export class Call {
 
       if (callingState === CallingState.RINGING && reject !== false) {
         if (reject) {
-          await this.reject(reason ?? 'decline');
+          const reasonToEndCallReason = {
+            timeout: 'missed',
+            cancel: 'canceled',
+            busy: 'busy',
+            decline: 'rejected',
+          } as const;
+          const rejectReason = reason ?? 'decline';
+          const endCallReason =
+            reasonToEndCallReason[
+              rejectReason as keyof typeof reasonToEndCallReason
+            ] ?? 'rejected';
+          await this.reject(rejectReason);
+          globalThis.streamRNVideoSDK?.callingX?.endCall(this, endCallReason);
         } else {
           // if reject was undefined, we still have to cancel the call automatically
           // when I am the creator and everyone else left the call
           const hasOtherParticipants = this.state.remoteParticipants.length > 0;
           if (this.isCreatedByMe && !hasOtherParticipants) {
             await this.reject('cancel');
+            globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'canceled');
           }
         }
       }
+      globalThis.streamRNVideoSDK?.callingX?.endCall(this);
 
       this.statsReporter?.stop();
       this.statsReporter = undefined;
@@ -680,7 +703,9 @@ export class Call {
       this.cancelAutoDrop();
       this.clientStore.unregisterCall(this);
 
-      globalThis.streamRNVideoSDK?.callManager.stop();
+      globalThis.streamRNVideoSDK?.callManager.stop({
+        isRingingTypeCall: this.ringing,
+      });
 
       this.camera.dispose();
       this.microphone.dispose();
@@ -720,7 +745,9 @@ export class Call {
    * A flag indicating whether the call was created by the current user.
    */
   get isCreatedByMe() {
-    return this.state.createdBy?.id === this.currentUserId;
+    return (
+      this.currentUserId && this.state.createdBy?.id === this.currentUserId
+    );
   }
 
   /**
@@ -766,6 +793,7 @@ export class Call {
     video?: boolean;
   }): Promise<GetCallResponse> => {
     await this.setup();
+
     const response = await this.streamClient.get<GetCallResponse>(
       this.streamClientBasePath,
       params,
@@ -805,6 +833,7 @@ export class Call {
    */
   getOrCreate = async (data?: GetOrCreateCallRequest) => {
     await this.setup();
+
     const response = await this.streamClient.post<
       GetOrCreateCallResponse,
       GetOrCreateCallRequest
@@ -930,60 +959,73 @@ export class Call {
     joinResponseTimeout?: number;
     rpcRequestTimeout?: number;
   } = {}): Promise<void> => {
-    await this.setup();
     const callingState = this.state.callingState;
 
     if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
       throw new Error(`Illegal State: call.join() shall be called only once`);
     }
 
+    if (data?.ring) {
+      this.ringingSubject.next(true);
+    }
+    const callingX = globalThis.streamRNVideoSDK?.callingX;
+    if (callingX) {
+      // for Android/iOS, we need to start the call in the callingx library as soon as possible
+      await callingX.joinCall(this, this.clientStore.calls);
+    }
+
+    await this.setup();
+
     this.joinResponseTimeout = joinResponseTimeout;
     this.rpcRequestTimeout = rpcRequestTimeout;
-
     // we will count the number of join failures per SFU.
     // once the number of failures reaches 2, we will piggyback on the `migrating_from`
     // field to force the coordinator to provide us another SFU
     const sfuJoinFailures = new Map<string, number>();
     const joinData: JoinCallData = data;
     maxJoinRetries = Math.max(maxJoinRetries, 1);
-    for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
-      try {
-        this.logger.trace(`Joining call (${attempt})`, this.cid);
-        await this.doJoin(data);
-        delete joinData.migrating_from;
-        delete joinData.migrating_from_list;
-        break;
-      } catch (err) {
-        this.logger.warn(`Failed to join call (${attempt})`, this.cid);
-        if (
-          (err instanceof ErrorFromResponse && err.unrecoverable) ||
-          (err instanceof SfuJoinError && err.unrecoverable)
-        ) {
-          // if the error is unrecoverable, we should not retry as that signals
-          // that connectivity is good, but the coordinator doesn't allow the user
-          // to join the call due to some reason (e.g., ended call, expired token...)
-          throw err;
-        }
+    try {
+      for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
+        try {
+          this.logger.trace(`Joining call (${attempt})`, this.cid);
+          await this.doJoin(data);
+          delete joinData.migrating_from;
+          delete joinData.migrating_from_list;
+          break;
+        } catch (err) {
+          this.logger.warn(`Failed to join call (${attempt})`, this.cid);
+          if (
+            (err instanceof ErrorFromResponse && err.unrecoverable) ||
+            (err instanceof SfuJoinError && err.unrecoverable)
+          ) {
+            // if the error is unrecoverable, we should not retry as that signals
+            // that connectivity is good, but the coordinator doesn't allow the user
+            // to join the call due to some reason (e.g., ended call, expired token...)
+            throw err;
+          }
 
-        // immediately switch to a different SFU in case of recoverable join error
-        const switchSfu =
-          err instanceof SfuJoinError &&
-          SfuJoinError.isJoinErrorCode(err.errorEvent);
-
-        const sfuId = this.credentials?.server.edge_name || '';
-        const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
-        sfuJoinFailures.set(sfuId, failures);
-        if (switchSfu || failures >= 2) {
-          joinData.migrating_from = sfuId;
-          joinData.migrating_from_list = Array.from(sfuJoinFailures.keys());
-        }
+          // immediately switch to a different SFU in case of recoverable join error
+          const switchSfu =
+            err instanceof SfuJoinError &&
+            SfuJoinError.isJoinErrorCode(err.errorEvent);
+
+          const sfuId = this.credentials?.server.edge_name || '';
+          const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
+          sfuJoinFailures.set(sfuId, failures);
+          if (switchSfu || failures >= 2) {
+            joinData.migrating_from = sfuId;
+            joinData.migrating_from_list = Array.from(sfuJoinFailures.keys());
+          }
 
-        if (attempt === maxJoinRetries - 1) {
-          throw err;
+          if (attempt === maxJoinRetries - 1) {
+            throw err;
+          }
         }
+        await sleep(retryInterval(attempt));
       }
-
-      await sleep(retryInterval(attempt));
+    } catch (error) {
+      callingX?.endCall(this, 'error');
+      throw error;
     }
   };
 
@@ -1166,7 +1208,9 @@ export class Call {
     // re-apply them on later reconnections or server-side data fetches
     if (!this.deviceSettingsAppliedOnce && this.state.settings) {
       await this.applyDeviceConfig(this.state.settings, true, false);
-      globalThis.streamRNVideoSDK?.callManager.start();
+      globalThis.streamRNVideoSDK?.callManager.start({
+        isRingingTypeCall: this.ringing,
+      });
       this.deviceSettingsAppliedOnce = true;
     }
 
@@ -1711,6 +1755,7 @@ export class Call {
       if (SfuJoinError.isJoinErrorCode(e)) return;
       if (strategy === WebsocketReconnectStrategy.UNSPECIFIED) return;
       if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
+        globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'error');
         this.leave({ message: 'SFU instructed to disconnect' }).catch((err) => {
           this.logger.warn(`Can't leave call after disconnect request`, err);
         });
@@ -2922,6 +2967,13 @@ export class Call {
     };
   };
 
+  /**
+   * Plays all audio elements blocked by the browser's autoplay policy.
+   */
+  resumeAudio = () => {
+    return this.dynascaleManager.resumeAudio();
+  };
+
   /**
    * Binds a DOM <img> element to this call's thumbnail (if enabled in settings).
    *

package/src/devices/MicrophoneManager.ts

@@ -158,6 +158,7 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
           const devices = await firstValueFrom(this.listDevices());
           const label = devices.find((d) => d.deviceId === deviceId)?.label;
 
+          let lastCapturesAudio: boolean | undefined;
           this.noAudioDetectorCleanup = createNoAudioDetector(mediaStream, {
             noAudioThresholdMs: this.silenceThresholdMs,
             emitIntervalMs: this.silenceThresholdMs,
@@ -169,7 +170,12 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
                 deviceId,
                 label,
               };
-              this.call.tracer.trace('mic.capture_report', event);
+
+              if (capturesAudio !== lastCapturesAudio) {
+                lastCapturesAudio = capturesAudio;
+                this.call.tracer.trace('mic.capture_report', event);
+              }
+
               this.call.streamClient.dispatchEvent(event);
             },
           });

package/src/devices/SpeakerManager.ts

@@ -85,6 +85,7 @@ export class SpeakerManager {
       this.defaultDevice = defaultDevice;
       globalThis.streamRNVideoSDK?.callManager.setup({
         defaultDevice,
+        isRingingTypeCall: this.call.ringing,
       });
     }
   }

package/src/events/__tests__/participant.test.ts

@@ -74,6 +74,47 @@ describe('Participant events', () => {
 
       expect(state.participants).toEqual([]);
     });
+
+    it('sets a server-side pin when isPinned is true', () => {
+      const state = new CallState();
+      state.setSortParticipantsBy(noopComparator());
+
+      const onParticipantJoined = watchParticipantJoined(state);
+      const now = Date.now();
+
+      onParticipantJoined({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+        },
+        isPinned: true,
+      });
+
+      const participant = state.findParticipantBySessionId('session-id');
+      expect(participant?.pin).toBeDefined();
+      expect(participant?.pin?.isLocalPin).toBe(false);
+      expect(participant?.pin?.pinnedAt).toBeGreaterThanOrEqual(now);
+    });
+
+    it('does not set a pin when isPinned is false', () => {
+      const state = new CallState();
+      state.setSortParticipantsBy(noopComparator());
+
+      const onParticipantJoined = watchParticipantJoined(state);
+
+      onParticipantJoined({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+        },
+        isPinned: false,
+      });
+
+      const participant = state.findParticipantBySessionId('session-id');
+      expect(participant?.pin).toBeUndefined();
+    });
   });
 
   describe('orphaned tracks reconciliation', () => {

package/src/events/call.ts

@@ -69,6 +69,7 @@ export const watchCallRejected = (call: Call) => {
     } else {
       if (rejectedBy[eventCall.created_by.id]) {
         call.logger.info('call creator rejected, leaving call');
+        globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
         await call.leave({ message: 'ring: creator rejected' });
       }
     }
@@ -80,6 +81,7 @@ export const watchCallRejected = (call: Call) => {
  */
 export const watchCallEnded = (call: Call) => {
   return function onCallEnded() {
+    globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
     const { callingState } = call.state;
     if (
       callingState !== CallingState.IDLE &&
@@ -113,6 +115,7 @@ export const watchSfuCallEnded = (call: Call) => {
       // update the call state to reflect the call has ended.
       call.state.setEndedAt(new Date());
       const reason = CallEndedReason[e.reason];
+      globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
       await call.leave({ message: `callEnded received: ${reason}` });
     } catch (err) {
       call.logger.error(

package/src/events/participant.ts

@@ -38,6 +38,7 @@ export const watchParticipantJoined = (state: CallState) => {
         StreamVideoParticipantPatch | undefined,
         Partial<StreamVideoParticipant>
       >(participant, orphanedTracks, {
+        ...(e.isPinned && { pin: { isLocalPin: false, pinnedAt: Date.now() } }),
         viewportVisibilityState: {
           videoTrack: VisibilityState.UNKNOWN,
           screenShareTrack: VisibilityState.UNKNOWN,

package/src/gen/video/sfu/event/events.ts

@@ -625,6 +625,10 @@ export interface ParticipantJoined {
    * @generated from protobuf field: stream.video.sfu.models.Participant participant = 2;
    */
   participant?: Participant;
+  /**
+   * @generated from protobuf field: bool is_pinned = 3;
+   */
+  isPinned: boolean;
 }
 /**
  * ParticipantJoined is fired when a user leaves a call
@@ -1557,6 +1561,7 @@ class ParticipantJoined$Type extends MessageType<ParticipantJoined> {
     super('stream.video.sfu.event.ParticipantJoined', [
       { no: 1, name: 'call_cid', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
       { no: 2, name: 'participant', kind: 'message', T: () => Participant },
+      { no: 3, name: 'is_pinned', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
     ]);
   }
 }

package/src/helpers/DynascaleManager.ts

@@ -79,6 +79,40 @@ export class DynascaleManager {
   private pendingSubscriptionsUpdate: NodeJS.Timeout | null = null;
   readonly audioBindingsWatchdog: AudioBindingsWatchdog | undefined;
 
+  /**
+   * Audio elements that were blocked by the browser's autoplay policy.
+   * These can be retried by calling `resumeAudio()` from a user gesture.
+   */
+  private blockedAudioElementsSubject = new BehaviorSubject<
+    Set<HTMLAudioElement>
+  >(new Set());
+
+  /**
+   * Whether the browser's autoplay policy is blocking audio playback.
+   * Will be `true` when the browser blocks autoplay (e.g., no prior user interaction).
+   * Use `resumeAudio()` within a user gesture to unblock.
+   */
+  autoplayBlocked$ = this.blockedAudioElementsSubject.pipe(
+    map((elements) => elements.size > 0),
+    distinctUntilChanged(),
+  );
+
+  private addBlockedAudioElement = (audioElement: HTMLAudioElement) => {
+    setCurrentValue(this.blockedAudioElementsSubject, (elements) => {
+      const next = new Set(elements);
+      next.add(audioElement);
+      return next;
+    });
+  };
+
+  private removeBlockedAudioElement = (audioElement: HTMLAudioElement) => {
+    setCurrentValue(this.blockedAudioElementsSubject, (elements) => {
+      const nextElements = new Set(elements);
+      nextElements.delete(audioElement);
+      return nextElements;
+    });
+  };
+
   private videoTrackSubscriptionOverridesSubject =
     new BehaviorSubject<VideoTrackSubscriptionOverrides>({});
 
@@ -136,6 +170,7 @@ export class DynascaleManager {
       clearTimeout(this.pendingSubscriptionsUpdate);
     }
     this.audioBindingsWatchdog?.dispose();
+    setCurrentValue(this.blockedAudioElementsSubject, new Set());
     const context = this.audioContext;
     if (context && context.state !== 'closed') {
       document.removeEventListener('click', this.resumeAudioContext);
@@ -575,7 +610,10 @@ export class DynascaleManager {
 
         setTimeout(() => {
           audioElement.srcObject = source ?? null;
-          if (!source) return;
+          if (!source) {
+            this.removeBlockedAudioElement(audioElement);
+            return;
+          }
 
           // Safari has a special quirk that prevents playing audio until the user
           // interacts with the page or focuses on the tab where the call happens.
@@ -599,6 +637,10 @@ export class DynascaleManager {
             audioElement.muted = false;
             audioElement.play().catch((e) => {
               this.tracer.trace('audioPlaybackError', e.message);
+              if (e.name === 'NotAllowedError') {
+                this.tracer.trace('audioPlaybackBlocked', null);
+                this.addBlockedAudioElement(audioElement);
+              }
               this.logger.warn(`Failed to play audio stream`, e);
             });
           }
@@ -628,6 +670,7 @@ export class DynascaleManager {
 
     return () => {
       this.audioBindingsWatchdog?.unregister(sessionId, trackType);
+      this.removeBlockedAudioElement(audioElement);
       sinkIdSubscription?.unsubscribe();
       volumeSubscription.unsubscribe();
       updateMediaStreamSubscription.unsubscribe();
@@ -637,6 +680,34 @@ export class DynascaleManager {
     };
   };
 
+  /**
+   * Plays all audio elements blocked by the browser's autoplay policy.
+   * Must be called from within a user gesture (e.g., click handler).
+   *
+   * @returns a promise that resolves when all blocked elements have been retried.
+   */
+  resumeAudio = async () => {
+    this.tracer.trace('resumeAudio', null);
+    const blocked = new Set<HTMLAudioElement>();
+    await Promise.all(
+      Array.from(
+        getCurrentValue(this.blockedAudioElementsSubject),
+        async (el) => {
+          try {
+            if (el.srcObject) {
+              await el.play();
+            }
+          } catch {
+            this.logger.warn(`Can't resume audio for element: `, el);
+            blocked.add(el);
+          }
+        },
+      ),
+    );
+
+    setCurrentValue(this.blockedAudioElementsSubject, blocked);
+  };
+
   private getOrCreateAudioContext = (): AudioContext | undefined => {
     if (!this.useWebAudio) return;
     if (this.audioContext) return this.audioContext;