@stream-io/video-client 1.54.0 → 1.55.0

package/src/helpers/__tests__/browsers.test.ts

@@ -169,70 +169,70 @@ describe('browsers', () => {
 
     it('should return true for supported Chrome version', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'Chrome', version: '124' },
+        browser: { name: 'Chrome', version: '136' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(true);
     });
 
     it('should return true for supported Chrome detailed version', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'Chrome', version: '124.0.7204.158' },
+        browser: { name: 'Chrome', version: '136.0.7204.158' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(true);
     });
 
     it('should return false for unsupported Chrome version', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'Chrome', version: '123' },
+        browser: { name: 'Chrome', version: '135' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(false);
     });
 
     it('should return false for unsupported Chrome detailed version', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'Chrome', version: '123.0.1234.99' },
+        browser: { name: 'Chrome', version: '135.0.1234.99' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(false);
     });
 
     it('should return true for supported Edge version', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'Edge', version: '124' },
+        browser: { name: 'Edge', version: '136' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(true);
     });
 
     it('should return false for unsupported Edge version', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'Edge', version: '123' },
+        browser: { name: 'Edge', version: '135' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(false);
     });
 
     it('should return true for supported Firefox version', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'Firefox', version: '124' },
+        browser: { name: 'Firefox', version: '137' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(true);
     });
 
     it('should return false for unsupported Firefox version', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'Firefox', version: '123' },
+        browser: { name: 'Firefox', version: '136' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(false);
     });
 
     it('should return true for supported Safari version', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'Safari', version: '17' },
+        browser: { name: 'Safari', version: '18' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(true);
     });
 
     it('should return false for unsupported Safari version', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'Safari', version: '16' },
+        browser: { name: 'Safari', version: '17' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(false);
     });
@@ -253,14 +253,14 @@ describe('browsers', () => {
 
     it('should return true for supported WebView version (WebView on Android)', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'WebView', version: '124' },
+        browser: { name: 'WebView', version: '136' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(true);
     });
 
     it('should return false for unsupported WebView version (WebView on Android)', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
-        browser: { name: 'WebView', version: '123' },
+        browser: { name: 'WebView', version: '135' },
       } as ClientDetails);
       expect(await isSupportedBrowser()).toBe(false);
     });

package/src/helpers/browsers.ts

@@ -62,11 +62,11 @@ export const isSupportedBrowser = async (): Promise<boolean> => {
   const [major] = browser.version.split('.');
   const version = parseInt(major, 10);
   return (
-    (name.includes('chrome') && version >= 124) ||
-    (name.includes('edge') && version >= 124) ||
-    (name.includes('firefox') && version >= 124) ||
-    (name.includes('safari') && version >= 17) ||
+    (name.includes('chrome') && version >= 136) ||
+    (name.includes('edge') && version >= 136) ||
+    (name.includes('firefox') && version >= 137) ||
+    (name.includes('safari') && version >= 18) ||
     (name.includes('webkit') && version >= 605) || // WebView on iOS
-    (name.includes('webview') && version >= 124) // WebView on Android
+    (name.includes('webview') && version >= 136) // WebView on Android
   );
 };

package/src/reporting/ClientEventReporter.ts

@@ -219,7 +219,7 @@ export class ClientEventReporter {
       joinAttemptIdSnapshot: this.joinAttemptIds.get(cid),
     };
 
-    this.send({
+    this.sendForCall(cid, {
       ...this.buildCommon(cid, 'MediaDevicePermission', pair),
       ...this.sessionIdField(cid),
       microphone_permission_status: readPermissionStatus(
@@ -322,7 +322,7 @@ export class ClientEventReporter {
     };
 
     const resolvedSfuId = this.getSfuId(cid);
-    this.send({
+    this.sendForCall(cid, {
       ...this.buildCommon(cid, stage, pair),
       ...this.sessionIdField(cid),
       ...(resolvedSfuId && { sfu_id: resolvedSfuId }),
@@ -395,7 +395,7 @@ export class ClientEventReporter {
     const coordinatorConnectId = this.coordinatorConnectId;
     const ctx = this.callContexts.get(cid);
 
-    this.send({
+    this.sendForCall(cid, {
       user_id: this.streamClient.userID || this.coordinatorConnectUserId,
       type: ctx?.callType,
       id: ctx?.callId,
@@ -454,7 +454,7 @@ export class ClientEventReporter {
         joinReasonSnapshot: this.joinReasons.get(cid),
       };
       this.coordinatorPairs.set(cid, pair);
-      this.send({
+      this.sendForCall(cid, {
         ...this.buildCommon(cid, 'CoordinatorJoin', pair),
         ...(pair.joinReasonSnapshot && {
           join_reason: pair.joinReasonSnapshot,
@@ -469,7 +469,7 @@ export class ClientEventReporter {
   private succeedCoordinator = (cid: string) => {
     const pair = this.coordinatorPairs.get(cid);
     if (!pair) return;
-    this.send({
+    this.sendForCall(cid, {
       ...this.buildCommon(cid, 'CoordinatorJoin', pair),
       ...this.sessionIdField(cid),
       ...(pair.joinReasonSnapshot && { join_reason: pair.joinReasonSnapshot }),
@@ -488,7 +488,7 @@ export class ClientEventReporter {
       return;
     }
     const { reason, code } = pair.lastError;
-    this.send({
+    this.sendForCall(cid, {
       ...this.buildCommon(cid, 'CoordinatorJoin', pair),
       ...this.sessionIdField(cid),
       ...(pair.joinReasonSnapshot && { join_reason: pair.joinReasonSnapshot }),
@@ -513,7 +513,7 @@ export class ClientEventReporter {
       };
       this.wsPairs.set(cid, pair);
       const sfuId = this.getSfuId(cid);
-      this.send({
+      this.sendForCall(cid, {
         ...this.buildCommon(cid, 'WSJoin', pair),
         ...this.sessionIdField(cid),
         ...(sfuId && { sfu_id: sfuId }),
@@ -529,7 +529,7 @@ export class ClientEventReporter {
     const pair = this.wsPairs.get(cid);
     if (!pair) return;
     const sfuId = this.getSfuId(cid);
-    this.send({
+    this.sendForCall(cid, {
       ...this.buildCommon(cid, 'WSJoin', pair),
       ...this.sessionIdField(cid),
       ...(sfuId && { sfu_id: sfuId }),
@@ -552,7 +552,7 @@ export class ClientEventReporter {
     const { reason, code } = pair.lastError;
     const sfuId = this.getSfuId(cid);
 
-    this.send({
+    this.sendForCall(cid, {
       ...this.buildCommon(cid, 'WSJoin', pair),
       ...this.sessionIdField(cid),
       event_type: 'completed',
@@ -627,7 +627,7 @@ export class ClientEventReporter {
     };
     this.peerConnectionPairs.set(key, pair);
 
-    this.send({
+    this.sendForCall(cid, {
       ...this.buildCommon(cid, 'PeerConnectionConnect', pair),
       ...this.sessionIdField(cid),
       peer_connection: role,
@@ -648,7 +648,7 @@ export class ClientEventReporter {
     const pair = this.peerConnectionPairs.get(key);
     if (!pair) return;
 
-    this.send({
+    this.sendForCall(cid, {
       ...this.buildCommon(cid, 'PeerConnectionConnect', pair),
       ...this.sessionIdField(cid),
       peer_connection: role,
@@ -676,7 +676,7 @@ export class ClientEventReporter {
     const pair = this.peerConnectionPairs.get(key);
     if (!pair) return;
 
-    this.send({
+    this.sendForCall(cid, {
       ...this.buildCommon(cid, 'PeerConnectionConnect', pair),
       ...this.sessionIdField(cid),
       peer_connection: role,
@@ -738,6 +738,11 @@ export class ClientEventReporter {
     void this.sendWithRetry(body);
   };
 
+  private sendForCall = (cid: string, body: Record<string, unknown>) => {
+    if (!this.callContexts.has(cid)) return;
+    this.send(body);
+  };
+
   private sendWithRetry = async (
     body: Record<string, unknown>,
   ): Promise<boolean> => {

package/src/reporting/__tests__/ClientEventReporter.test.ts

@@ -617,6 +617,58 @@ describe('ClientEventReporter', () => {
     expect(ws1.every((e) => e.sfu_id === 'sfu-1')).toBe(true);
     expect(ws2.every((e) => e.sfu_id === 'sfu-2')).toBe(true);
   });
+
+  describe('drops events for an unregistered call', () => {
+    it('does not emit stage events after the call is unregistered', async () => {
+      reporter.startCorrelation(cid, 'first-attempt');
+      reporter.unregisterCall(cid);
+      await flush();
+      doAxiosRequest.mockClear();
+
+      await reporter.track(cid, 'WSJoin', () => Promise.resolve('ok'));
+      reporter.reportFirstFrame(cid, TrackType.VIDEO, 'track-1');
+      await flush();
+
+      expect(doAxiosRequest).not.toHaveBeenCalled();
+    });
+
+    it('does not emit a stage completion when unregistered mid-flight', async () => {
+      reporter.startCorrelation(cid, 'first-attempt');
+      await flush();
+      doAxiosRequest.mockClear();
+
+      await reporter.track(cid, 'WSJoin', async () => {
+        reporter.unregisterCall(cid);
+        return 'ok';
+      });
+      await flush();
+
+      const completed = postedEvents().filter(
+        (e) => e.stage === 'WSJoin' && e.event_type === 'completed',
+      );
+      expect(completed).toHaveLength(0);
+    });
+
+    it('does not emit JoinInitiated for an unregistered call', async () => {
+      reporter.unregisterCall(cid);
+      reporter.startCorrelation(cid, 'first-attempt');
+      await flush();
+
+      const joinInitiated = postedEvents().filter(
+        (e) => e.stage === 'JoinInitiated',
+      );
+      expect(joinInitiated).toHaveLength(0);
+    });
+
+    it('still emits CoordinatorWS events (connection-scoped, not call-gated)', async () => {
+      reporter.unregisterCall(cid);
+      await reporter.trackCoordinatorWs(() => Promise.resolve('ok'));
+      await flush();
+
+      const ws = postedEvents().filter((e) => e.stage === 'CoordinatorWS');
+      expect(ws.length).toBeGreaterThan(0);
+    });
+  });
 });
 
 describe('ClientEventReporter (disabled)', () => {

package/src/rtc/BasePeerConnection.ts

@@ -13,6 +13,7 @@ import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
 import { withoutConcurrency } from '../helpers/concurrency';
 import { StatsTracer, Tracer, traceRTCPeerConnection } from '../stats';
+import { toJSON } from './helpers/iceCandiates';
 import {
   BasePeerConnectionOpts,
   OnIceConnected,
@@ -37,7 +38,7 @@ export abstract class BasePeerConnection {
   protected tag: string;
   protected sfuClient: StreamSfuClient;
 
-  private onReconnectionNeeded?: OnReconnectionNeeded;
+  protected onReconnectionNeeded?: OnReconnectionNeeded;
   private onIceConnected?: OnIceConnected;
   private onPeerConnectionStateChange?: OnPeerConnectionStateChange;
   protected onRemoteTrackUnmute?: OnRemoteTrackUnmute;
@@ -224,11 +225,17 @@ export abstract class BasePeerConnection {
    * Appends the trickled ICE candidates to the `RTCPeerConnection`.
    */
   protected addTrickledIceCandidates = () => {
+    // Declare the ICE generation this negotiation established so the buffer
+    // only replays candidates of the current generation.
     const { iceTrickleBuffer } = this.sfuClient;
+    const sdp = this.pc.remoteDescription?.sdp;
+    iceTrickleBuffer.updateActiveGeneration(this.peerType, sdp);
+
+    const { subscriber, publisher } = iceTrickleBuffer;
     const observable =
       this.peerType === PeerType.SUBSCRIBER
-        ? iceTrickleBuffer.subscriberCandidates
-        : iceTrickleBuffer.publisherCandidates;
+        ? subscriber.candidates
+        : publisher.candidates;
 
     this.unsubscribeIceTrickle?.();
     this.unsubscribeIceTrickle = createSafeAsyncSubscription(
@@ -283,20 +290,6 @@ export abstract class BasePeerConnection {
     return !failedStates.has(iceState) && !failedStates.has(connectionState);
   };
 
-  /**
-   * Returns true only when the peer connection is currently fully established
-   * (ICE `connected`/`completed` AND connection state `connected`).
-   * Transient states like `disconnected`, `checking`, or `new` return false.
-   */
-  isStable = () => {
-    const iceState = this.pc.iceConnectionState;
-    const connectionState = this.pc.connectionState;
-    return (
-      (iceState === 'connected' || iceState === 'completed') &&
-      connectionState === 'connected'
-    );
-  };
-
   /**
    * Handles the ICECandidate event and
    * Initiates an ICE Trickle process with the SFU.
@@ -308,7 +301,7 @@ export abstract class BasePeerConnection {
       return;
     }
 
-    const iceCandidate = this.asJSON(candidate);
+    const iceCandidate = toJSON(candidate);
     this.sfuClient
       .iceTrickle({ peerType: this.peerType, iceCandidate })
       .catch((err) => {
@@ -317,20 +310,6 @@ export abstract class BasePeerConnection {
       });
   };
 
-  /**
-   * Converts the ICE candidate to a JSON string.
-   */
-  private asJSON = (candidate: RTCIceCandidate): string => {
-    if (!candidate.usernameFragment) {
-      // react-native-webrtc doesn't include usernameFragment in the candidate
-      const segments = candidate.candidate.split(' ');
-      const ufragIndex = segments.findIndex((s) => s === 'ufrag') + 1;
-      const usernameFragment = segments[ufragIndex];
-      return JSON.stringify({ ...candidate, usernameFragment });
-    }
-    return JSON.stringify(candidate.toJSON());
-  };
-
   /**
    * Handles the ConnectionStateChange event.
    */
@@ -343,8 +322,10 @@ export abstract class BasePeerConnection {
     });
     if (this.tracer && (state === 'connected' || state === 'failed')) {
       try {
-        const stats = await this.stats.get();
-        this.tracer.trace('getstats', stats.delta);
+        // Sample stats into the delivery chain at connect/fail. The reporter
+        // ships and commits the un-acked chain, so we must not trace the delta
+        // separately here (that would double-send it and corrupt the chain).
+        await this.stats.takeSample();
       } catch (err) {
         this.tracer.trace('getstatsOnFailure', (err as Error).toString());
       }

package/src/rtc/IceTrickleBuffer.ts

@@ -1,33 +1,126 @@
-import { ReplaySubject } from 'rxjs';
+import { Observable, Subject } from 'rxjs';
 import { ICETrickle } from '../gen/video/sfu/event/events';
 import { PeerType } from '../gen/video/sfu/models/models';
 import { videoLoggerSystem } from '../logger';
+import { getCandidateUfrag, parseIceUfrag } from './helpers/iceCandiates';
+import { ensureExhausted } from '../helpers/ensureExhausted';
 
 /**
  * A buffer for ICE Candidates. Used for ICE Trickle:
  * - https://bloggeek.me/webrtcglossary/trickle-ice/
+ *
+ * The buffer is generation-aware: each peer connection tells it which ICE
+ * generation is current via `updateActiveGeneration` (whenever it applies an
+ * offer/answer). Candidate streams then emit only candidates of the active
+ * generation, hold candidates of a not-yet-applied (future) generation until
+ * it becomes active, and drop candidates of a superseded generation so they
+ * are never replayed. Candidates with no detectable generation, or before any
+ * generation is set, are emitted as-is (fail open).
  */
 export class IceTrickleBuffer {
-  readonly subscriberCandidates = new ReplaySubject<RTCIceCandidateInit>();
-  readonly publisherCandidates = new ReplaySubject<RTCIceCandidateInit>();
+  readonly subscriber = new CandidateGenerationBuffer();
+  readonly publisher = new CandidateGenerationBuffer();
 
   push = (iceTrickle: ICETrickle) => {
     const iceCandidate = toIceCandidate(iceTrickle);
     if (!iceCandidate) return;
 
-    if (iceTrickle.peerType === PeerType.SUBSCRIBER) {
-      this.subscriberCandidates.next(iceCandidate);
-    } else if (iceTrickle.peerType === PeerType.PUBLISHER_UNSPECIFIED) {
-      this.publisherCandidates.next(iceCandidate);
-    } else {
-      const logger = videoLoggerSystem.getLogger('sfu-client');
-      logger.warn(`ICETrickle, Unknown peer type`, iceTrickle);
+    const { peerType } = iceTrickle;
+    switch (peerType) {
+      case PeerType.SUBSCRIBER:
+        this.subscriber.push(iceCandidate);
+        break;
+      case PeerType.PUBLISHER_UNSPECIFIED:
+        this.publisher.push(iceCandidate);
+        break;
+      default:
+        ensureExhausted(peerType, `ICETrickle, Unknown peer type`);
+    }
+  };
+
+  /**
+   * Declares the ICE generation that is now current for the given peer type,
+   * derived from the `ice-ufrag` of the just-applied remote description.
+   * Candidates of superseded generations are evicted; candidates of the active
+   * generation flow to subscribers.
+   */
+  updateActiveGeneration = (peerType: PeerType, sdp: string | undefined) => {
+    const ufrag = parseIceUfrag(sdp);
+    switch (peerType) {
+      case PeerType.SUBSCRIBER:
+        this.subscriber.updateActiveGeneration(ufrag);
+        break;
+      case PeerType.PUBLISHER_UNSPECIFIED:
+        this.publisher.updateActiveGeneration(ufrag);
+        break;
+      default:
+        ensureExhausted(peerType, `updateActiveGeneration, Unknown peer type`);
     }
   };
 
   dispose = () => {
-    this.subscriberCandidates.complete();
-    this.publisherCandidates.complete();
+    this.subscriber.dispose();
+    this.publisher.dispose();
+  };
+}
+
+/**
+ * Per-peer-connection generation-aware candidate store. Retains trickled
+ * candidates and replays the active generation to each new subscriber, then
+ * forwards matching live candidates.
+ */
+class CandidateGenerationBuffer {
+  private readonly store: RTCIceCandidateInit[] = [];
+  private readonly live = new Subject<RTCIceCandidateInit>();
+  private readonly seenUfrags = new Set<string>();
+  private activeUfrag: string | undefined;
+
+  readonly candidates = new Observable<RTCIceCandidateInit>((subscriber) => {
+    for (const candidate of this.store.slice()) {
+      if (this.isCurrent(candidate)) subscriber.next(candidate);
+    }
+    const subscription = this.live.subscribe((candidate) => {
+      if (this.isCurrent(candidate)) subscriber.next(candidate);
+    });
+    return () => subscription.unsubscribe();
+  });
+
+  push = (candidate: RTCIceCandidateInit) => {
+    this.store.push(candidate);
+    this.live.next(candidate);
+  };
+
+  updateActiveGeneration = (ufrag: string | undefined) => {
+    if (ufrag) this.seenUfrags.add(ufrag);
+    this.activeUfrag = ufrag;
+    // evict candidates from superseded generations (a generation we have
+    // applied before but is no longer current); keep future generations.
+    for (let i = this.store.length - 1; i >= 0; i--) {
+      const candidateUfrag = getCandidateUfrag(this.store[i]);
+      if (
+        candidateUfrag &&
+        candidateUfrag !== this.activeUfrag &&
+        this.seenUfrags.has(candidateUfrag)
+      ) {
+        this.store.splice(i, 1);
+      }
+    }
+  };
+
+  dispose = () => {
+    this.store.length = 0;
+    this.live.complete();
+  };
+
+  /**
+   * A candidate belongs to the current generation when its ufrag matches the
+   * active one. Fail open when either the candidate's generation or the active
+   * generation is unknown, so untagged candidates are never withheld.
+   */
+  private isCurrent = (candidate: RTCIceCandidateInit): boolean => {
+    const candidateUfrag = getCandidateUfrag(candidate);
+    if (!candidateUfrag || !this.activeUfrag) return true;
+    return candidateUfrag === this.activeUfrag;
   };
 }
 

package/src/rtc/Publisher.ts

@@ -1,34 +1,34 @@
-import { BasePeerConnection } from './BasePeerConnection';
-import type {
-  BasePeerConnectionOpts,
-  PublishBundle,
-  TrackPublishOptions,
-} from './types';
-import { NegotiationError } from './NegotiationError';
-import { TransceiverCache } from './TransceiverCache';
+import { VideoSender } from '../gen/video/sfu/event/events';
 import {
   PeerType,
   PublishOption,
   TrackInfo,
   TrackType,
 } from '../gen/video/sfu/models/models';
-import { VideoSender } from '../gen/video/sfu/event/events';
-import {
-  computeAudioLayers,
-  computeVideoLayers,
-  toSvcEncodings,
-  toVideoLayers,
-} from './layers';
+import { isFirefox } from '../helpers/browsers';
+import { withoutConcurrency } from '../helpers/concurrency';
+import { isReactNative } from '../helpers/platforms';
+import { BasePeerConnection } from './BasePeerConnection';
 import { isSvcCodec } from './codecs';
 import {
   fromRTCDegradationPreference,
   toRTCDegradationPreference,
 } from './helpers/degradationPreference';
-import { isAudioTrackType } from './helpers/tracks';
 import { extractMid, removeCodecsExcept, setStartBitrate } from './helpers/sdp';
-import { withoutConcurrency } from '../helpers/concurrency';
-import { isReactNative } from '../helpers/platforms';
-import { isFirefox } from '../helpers/browsers';
+import { isAudioTrackType } from './helpers/tracks';
+import {
+  computeAudioLayers,
+  computeVideoLayers,
+  toSvcEncodings,
+  toVideoLayers,
+} from './layers';
+import { NegotiationError } from './NegotiationError';
+import { TransceiverCache } from './TransceiverCache';
+import type {
+  BasePeerConnectionOpts,
+  PublishBundle,
+  TrackPublishOptions,
+} from './types';
 
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
@@ -39,6 +39,7 @@ export class Publisher extends BasePeerConnection {
   private readonly transceiverCache = new TransceiverCache();
   private readonly clonedTracks = new Set<MediaStreamTrack>();
   private publishOptions: PublishOption[];
+  private readonly selfSubEnabled: boolean;
 
   /**
    * Constructs a new `Publisher` instance.
@@ -46,9 +47,11 @@ export class Publisher extends BasePeerConnection {
   constructor(
     baseOptions: BasePeerConnectionOpts,
     publishOptions: PublishOption[],
+    opts: { selfSubEnabled?: boolean } = {},
   ) {
     super(PeerType.PUBLISHER_UNSPECIFIED, baseOptions);
     this.publishOptions = publishOptions;
+    this.selfSubEnabled = opts.selfSubEnabled ?? false;
 
     this.on('iceRestart', (iceRestart) => {
       if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED) return;
@@ -576,6 +579,7 @@ export class Publisher extends BasePeerConnection {
       muted: !isTrackLive,
       codec: publishOption.codec,
       publishOptionId: publishOption.id,
+      selfSubAudioVideo: this.selfSubEnabled,
     };
   };