@stream-io/video-client 1.50.0 → 1.52.0

package/src/gen/video/sfu/signal_rpc/signal.ts

@@ -1,23 +1,24 @@
 // @generated by protobuf-ts 2.10.0 with parameter long_type_string,client_generic,server_none,eslint_disable,optimize_code_size
 // @generated from protobuf file "video/sfu/signal_rpc/signal.proto" (package "stream.video.sfu.signal", syntax proto3)
 // tslint:disable
-import {
-  AndroidState,
-  AppleState,
-  Error,
-  ICETrickle,
-  InputDevices,
-  PeerType,
-  PerformanceStats,
-  RTMPIngress,
-  TrackInfo,
-  TrackType,
-  VideoDimension,
-  WebsocketReconnectStrategy,
-} from '../models/models';
+import { ICETrickle } from '../models/models';
 import { ServiceType } from '@protobuf-ts/runtime-rpc';
 import { MessageType } from '@protobuf-ts/runtime';
-
+import { TrackInfo } from '../models/models';
+import { VideoDimension } from '../models/models';
+import { TrackType } from '../models/models';
+import { PeerType } from '../models/models';
+import { PerformanceStats } from '../models/models';
+import { RTMPIngress } from '../models/models';
+import { AppleState } from '../models/models';
+import { AndroidState } from '../models/models';
+import { InputDevices } from '../models/models';
+import { RemoteOutboundRtp } from '../models/models';
+import { RemoteInboundRtp } from '../models/models';
+import { OutboundRtp } from '../models/models';
+import { InboundRtp } from '../models/models';
+import { WebsocketReconnectStrategy } from '../models/models';
+import { Error } from '../models/models';
 /**
  * @generated from protobuf message stream.video.sfu.signal.StartNoiseCancellationRequest
  */
@@ -93,6 +94,39 @@ export interface Telemetry {
         oneofKind: undefined;
       };
 }
+/**
+ * @generated from protobuf message stream.video.sfu.signal.SendMetricsRequest
+ */
+export interface SendMetricsRequest {
+  /**
+   * @generated from protobuf field: string session_id = 1;
+   */
+  sessionId: string;
+  /**
+   * @generated from protobuf field: string unified_session_id = 2;
+   */
+  unifiedSessionId: string;
+  /**
+   * @generated from protobuf field: repeated stream.video.sfu.models.InboundRtp inbounds = 3;
+   */
+  inbounds: InboundRtp[];
+  /**
+   * @generated from protobuf field: repeated stream.video.sfu.models.OutboundRtp outbounds = 4;
+   */
+  outbounds: OutboundRtp[];
+  /**
+   * @generated from protobuf field: repeated stream.video.sfu.models.RemoteInboundRtp remote_inbounds = 5;
+   */
+  remoteInbounds: RemoteInboundRtp[];
+  /**
+   * @generated from protobuf field: repeated stream.video.sfu.models.RemoteOutboundRtp remote_outbounds = 6;
+   */
+  remoteOutbounds: RemoteOutboundRtp[];
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.SendMetricsResponse
+ */
+export interface SendMetricsResponse {}
 /**
  * @generated from protobuf message stream.video.sfu.signal.SendStatsRequest
  */
@@ -336,6 +370,10 @@ export interface SendAnswerRequest {
    * @generated from protobuf field: string session_id = 3;
    */
   sessionId: string;
+  /**
+   * @generated from protobuf field: uint32 negotiation_id = 4;
+   */
+  negotiationId: number;
 }
 /**
  * @generated from protobuf message stream.video.sfu.signal.SendAnswerResponse
@@ -502,6 +540,62 @@ class Telemetry$Type extends MessageType<Telemetry> {
  */
 export const Telemetry = new Telemetry$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class SendMetricsRequest$Type extends MessageType<SendMetricsRequest> {
+  constructor() {
+    super('stream.video.sfu.signal.SendMetricsRequest', [
+      { no: 1, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+      {
+        no: 2,
+        name: 'unified_session_id',
+        kind: 'scalar',
+        T: 9 /*ScalarType.STRING*/,
+      },
+      {
+        no: 3,
+        name: 'inbounds',
+        kind: 'message',
+        repeat: 2 /*RepeatType.UNPACKED*/,
+        T: () => InboundRtp,
+      },
+      {
+        no: 4,
+        name: 'outbounds',
+        kind: 'message',
+        repeat: 2 /*RepeatType.UNPACKED*/,
+        T: () => OutboundRtp,
+      },
+      {
+        no: 5,
+        name: 'remote_inbounds',
+        kind: 'message',
+        repeat: 2 /*RepeatType.UNPACKED*/,
+        T: () => RemoteInboundRtp,
+      },
+      {
+        no: 6,
+        name: 'remote_outbounds',
+        kind: 'message',
+        repeat: 2 /*RepeatType.UNPACKED*/,
+        T: () => RemoteOutboundRtp,
+      },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.SendMetricsRequest
+ */
+export const SendMetricsRequest = new SendMetricsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SendMetricsResponse$Type extends MessageType<SendMetricsResponse> {
+  constructor() {
+    super('stream.video.sfu.signal.SendMetricsResponse', []);
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.SendMetricsResponse
+ */
+export const SendMetricsResponse = new SendMetricsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class SendStatsRequest$Type extends MessageType<SendStatsRequest> {
   constructor() {
     super('stream.video.sfu.signal.SendStatsRequest', [
@@ -776,6 +870,12 @@ class SendAnswerRequest$Type extends MessageType<SendAnswerRequest> {
       },
       { no: 2, name: 'sdp', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
       { no: 3, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+      {
+        no: 4,
+        name: 'negotiation_id',
+        kind: 'scalar',
+        T: 13 /*ScalarType.UINT32*/,
+      },
     ]);
   }
 }
@@ -885,6 +985,12 @@ export const SignalServer = new ServiceType(
       I: SendStatsRequest,
       O: SendStatsResponse,
     },
+    {
+      name: 'SendMetrics',
+      options: {},
+      I: SendMetricsRequest,
+      O: SendMetricsResponse,
+    },
     {
       name: 'StartNoiseCancellation',
       options: {},

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

@@ -23,6 +23,14 @@ import { VisibilityState } from '../../types';
 import { noopComparator } from '../../sorting';
 import { TrackType } from '../../gen/video/sfu/models/models';
 
+vi.mock(import('../browsers'), async (importOriginal) => {
+  const module = await importOriginal();
+  return {
+    ...module,
+    isSafari: () => globalThis._isSafari ?? false,
+  };
+});
+
 describe('DynascaleManager', () => {
   let dynascaleManager: DynascaleManager;
   let call: Call;
@@ -50,13 +58,6 @@ describe('DynascaleManager', () => {
     beforeEach(() => {
       // Mock global isSafari to false for testing
       globalThis._isSafari = false;
-      vi.mock(import('../browsers'), async (importOriginal) => {
-        const module = await importOriginal();
-        return {
-          ...module,
-          isSafari: () => globalThis._isSafari ?? false,
-        };
-      });
 
       dynascaleManager.setUseWebAudio(false);
 

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

@@ -9,6 +9,10 @@ import {
 import { getClientDetails } from '../client-details';
 import { ClientDetails } from '../../gen/video/sfu/models/models';
 
+vi.mock('../client-details', () => ({
+  getClientDetails: vi.fn(),
+}));
+
 describe('browsers', () => {
   beforeEach(() => {
     Object.defineProperty(globalThis, 'navigator', {
@@ -156,10 +160,6 @@ describe('browsers', () => {
   });
 
   describe('isSupportedBrowser', () => {
-    vi.mock('../client-details', () => ({
-      getClientDetails: vi.fn(),
-    }));
-
     it('should return false if browser is undefined', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
         browser: undefined,

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

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import {
   hasAudio,
+  hasInterruptedTrack,
   hasPausedTrack,
   hasScreenShare,
   hasScreenShareAudio,
@@ -120,6 +121,52 @@ describe('participantUtils', () => {
     });
   });
 
+  describe('hasInterruptedTrack', () => {
+    it('returns true when the track is both interrupted and published', () => {
+      const participant = createMockParticipant({
+        publishedTracks: [TrackType.AUDIO],
+        interruptedTracks: [TrackType.AUDIO],
+      });
+      expect(hasInterruptedTrack(participant, TrackType.AUDIO)).toBe(true);
+    });
+
+    it('returns false when the track is interrupted but no longer published', () => {
+      const participant = createMockParticipant({
+        publishedTracks: [],
+        interruptedTracks: [TrackType.AUDIO],
+      });
+      expect(hasInterruptedTrack(participant, TrackType.AUDIO)).toBe(false);
+    });
+
+    it('returns false when the track is published but not interrupted', () => {
+      const participant = createMockParticipant({
+        publishedTracks: [TrackType.AUDIO],
+        interruptedTracks: [],
+      });
+      expect(hasInterruptedTrack(participant, TrackType.AUDIO)).toBe(false);
+    });
+
+    it('returns false when interruptedTracks is undefined', () => {
+      const participant = createMockParticipant({
+        publishedTracks: [TrackType.AUDIO],
+        interruptedTracks: undefined,
+      });
+      expect(hasInterruptedTrack(participant, TrackType.AUDIO)).toBe(false);
+    });
+
+    it('checks each track type independently', () => {
+      const participant = createMockParticipant({
+        publishedTracks: [TrackType.AUDIO, TrackType.VIDEO],
+        interruptedTracks: [TrackType.VIDEO],
+      });
+      expect(hasInterruptedTrack(participant, TrackType.AUDIO)).toBe(false);
+      expect(hasInterruptedTrack(participant, TrackType.VIDEO)).toBe(true);
+      expect(hasInterruptedTrack(participant, TrackType.SCREEN_SHARE)).toBe(
+        false,
+      );
+    });
+  });
+
   describe('hasPausedTrack', () => {
     it('should return true when participant has paused VIDEO track', () => {
       const participant = createMockParticipant({

package/src/helpers/client-details.ts

@@ -137,6 +137,7 @@ export const getClientDetails = async (): Promise<ClientDetails> => {
       sdk: sdkInfo,
       os: osInfo,
       device: deviceInfo,
+      webrtcVersion: webRtcInfo?.version || '',
     };
   }
 
@@ -173,11 +174,12 @@ export const getClientDetails = async (): Promise<ClientDetails> => {
   const uaBrowser = userAgentData?.fullVersionList?.find(
     (v) => !v.brand.includes('Chromium') && !v.brand.match(/[()\-./:;=?_]/g),
   );
+  const browserVersion = uaBrowser?.version || browser.version || '';
   return {
     sdk: sdkInfo,
     browser: {
       name: uaBrowser?.brand || browser.name || navigator.userAgent,
-      version: uaBrowser?.version || browser.version || '',
+      version: browserVersion,
     },
     os: {
       name: userAgentData?.platform || os.name || '',
@@ -190,5 +192,6 @@ export const getClientDetails = async (): Promise<ClientDetails> => {
         .join(' '),
       version: '',
     },
+    webrtcVersion: browserVersion,
   };
 };

package/src/helpers/participantUtils.ts

@@ -41,6 +41,21 @@ export const hasScreenShareAudio = (p: StreamVideoParticipant): boolean =>
 export const isPinned = (p: StreamVideoParticipant): boolean =>
   !!p.pin && (p.pin.isLocalPin || p.pin.pinnedAt > 0);
 
+/**
+ * Check if a participant has a track that is currently interrupted: the
+ * participant intends to publish it (it is in `publishedTracks`) but no
+ * media is flowing right now (it is in `interruptedTracks`).
+ *
+ * @param p the participant to check.
+ * @param trackType the track type to check.
+ */
+export const hasInterruptedTrack = (
+  p: StreamVideoParticipant,
+  trackType: TrackType,
+): boolean =>
+  !!p.interruptedTracks?.includes(trackType) &&
+  p.publishedTracks.includes(trackType);
+
 /**
  * Check if a participant has a paused track of the specified type.
  *

package/src/rtc/BasePeerConnection.ts

@@ -42,7 +42,7 @@ export abstract class BasePeerConnection {
   private iceRestartTimeout?: NodeJS.Timeout;
   private preConnectStuckTimeout?: NodeJS.Timeout;
   protected isIceRestarting = false;
-  private isDisposed = false;
+  protected isDisposed = false;
 
   protected trackIdToTrackType = new Map<string, TrackType>();
 
@@ -69,6 +69,7 @@ export abstract class BasePeerConnection {
       enableTracing,
       clientPublishOptions,
       iceRestartDelay = 2500,
+      statsTimestampDriftThresholdMs = 0,
     }: BasePeerConnectionOpts,
   ) {
     this.peerType = peerType;
@@ -85,7 +86,12 @@ export abstract class BasePeerConnection {
       { tags: [tag] },
     );
     this.pc = this.createPeerConnection(connectionConfig);
-    this.stats = new StatsTracer(this.pc, peerType, this.trackIdToTrackType);
+    this.stats = new StatsTracer(
+      this.pc,
+      peerType,
+      this.trackIdToTrackType,
+      statsTimestampDriftThresholdMs,
+    );
     if (enableTracing) {
       this.tracer = new Tracer(
         `${tag}-${peerType === PeerType.SUBSCRIBER ? 'sub' : 'pub'}`,
@@ -115,7 +121,7 @@ export abstract class BasePeerConnection {
   /**
    * Disposes the `RTCPeerConnection` instance.
    */
-  dispose() {
+  async dispose(): Promise<void> {
     clearTimeout(this.iceRestartTimeout);
     this.iceRestartTimeout = undefined;
     clearTimeout(this.preConnectStuckTimeout);
@@ -141,6 +147,10 @@ export abstract class BasePeerConnection {
       this.onIceConnectionStateChange,
     );
     pc.removeEventListener('icegatheringstatechange', this.onIceGatherChange);
+    pc.removeEventListener(
+      'connectionstatechange',
+      this.onConnectionStateChange,
+    );
     this.unsubscribeIceTrickle?.();
     this.subscriptions.forEach((unsubscribe) => unsubscribe());
     this.subscriptions = [];
@@ -183,7 +193,7 @@ export abstract class BasePeerConnection {
     const getTag = () => this.tag;
     this.subscriptions.push(
       this.dispatcher.on(event, getTag, (e) => {
-        const lockKey = `pc.${this.lock}.${event}`;
+        const lockKey = this.eventLockKey(event);
         withoutConcurrency(lockKey, async () => fn(e)).catch((err) => {
           if (this.isDisposed) return;
           this.logger.warn(`Error handling ${event}`, err);
@@ -192,6 +202,14 @@ export abstract class BasePeerConnection {
     );
   };
 
+  /**
+   * Returns the per-event `withoutConcurrency` tag used to serialize the
+   * dispatcher handler for `event` on this peer connection.
+   */
+  protected eventLockKey = (event: keyof AllSfuEvents): string => {
+    return `pc.${this.lock}.${event}`;
+  };
+
   /**
    * Appends the trickled ICE candidates to the `RTCPeerConnection`.
    */

package/src/rtc/Publisher.ts

@@ -20,11 +20,15 @@ import {
   toVideoLayers,
 } from './layers';
 import { isSvcCodec } from './codecs';
-import { toRTCDegradationPreference } from './helpers/degradationPreference';
+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';
 
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
@@ -53,7 +57,16 @@ export class Publisher extends BasePeerConnection {
 
     this.on('changePublishQuality', async (event) => {
       for (const videoSender of event.videoSenders) {
-        await this.changePublishQuality(videoSender);
+        // if not publishing, update the encodingConfigCache and don't modify the state.
+        // we'll apply this config on the next publish/unmute.
+        const { trackType, publishOptionId } = videoSender;
+        const bundle = this.transceiverCache.getBy(publishOptionId, trackType);
+        if (bundle) {
+          this.transceiverCache.update(bundle.publishOption, { videoSender });
+        }
+        if (isFirefox() && !this.isPublishing(trackType)) continue;
+
+        await this.changePublishQuality(videoSender, bundle);
       }
     });
 
@@ -66,9 +79,13 @@ export class Publisher extends BasePeerConnection {
   /**
    * Disposes this Publisher instance.
    */
-  dispose() {
-    super.dispose();
-    this.stopAllTracks();
+  async dispose(): Promise<void> {
+    await super.dispose();
+    try {
+      await this.stopAllTracks();
+    } catch (err) {
+      this.logger.warn('Failed to stop tracks during dispose', err);
+    }
     this.clonedTracks.clear();
   }
 
@@ -98,17 +115,12 @@ export class Publisher extends BasePeerConnection {
       // appear in the SDP in multiple transceivers
       const trackToPublish = this.cloneTrack(track);
 
-      const { transceiver } = this.transceiverCache.get(publishOption) || {};
-      if (!transceiver) {
+      const bundle = this.transceiverCache.get(publishOption);
+      if (!bundle) {
         await this.addTransceiver(trackToPublish, publishOption, options);
       } else {
-        const previousTrack = transceiver.sender.track;
-        await this.updateTransceiver(
-          transceiver,
-          trackToPublish,
-          trackType,
-          options,
-        );
+        const previousTrack = bundle.transceiver.sender.track;
+        await this.updateTransceiver(bundle, trackToPublish, options);
         if (!isReactNative()) {
           this.stopTrack(previousTrack);
         }
@@ -153,15 +165,22 @@ export class Publisher extends BasePeerConnection {
    * Updates the transceiver with the given track and track type.
    */
   private updateTransceiver = async (
-    transceiver: RTCRtpTransceiver,
+    bundle: PublishBundle,
     track: MediaStreamTrack | null,
-    trackType: TrackType,
     options: TrackPublishOptions = {},
   ) => {
+    const { transceiver, publishOption } = bundle;
+    const trackType = publishOption.trackType;
     const sender = transceiver.sender;
     if (sender.track) this.trackIdToTrackType.delete(sender.track.id);
     await sender.replaceTrack(track);
-    if (track) this.trackIdToTrackType.set(track.id, trackType);
+    if (track) {
+      this.trackIdToTrackType.set(track.id, trackType);
+      if (isFirefox() && bundle.videoSender) {
+        // restore the encoding config from the cache, if any
+        await this.changePublishQuality(bundle.videoSender, bundle);
+      }
+    }
     if (isAudioTrackType(trackType)) {
       await this.updateAudioPublishOptions(trackType, options);
     }
@@ -230,7 +249,7 @@ export class Publisher extends BasePeerConnection {
       if (hasPublishOption) continue;
       // it is safe to stop the track here, it is a clone
       this.stopTrack(transceiver.sender.track);
-      await this.updateTransceiver(transceiver, null, publishOption.trackType);
+      await this.updateTransceiver(item, null);
     }
   };
 
@@ -286,39 +305,50 @@ export class Publisher extends BasePeerConnection {
   /**
    * Stops the cloned track that is being published to the SFU.
    */
-  stopTracks = (...trackTypes: TrackType[]) => {
-    for (const item of this.transceiverCache.items()) {
-      const { publishOption, transceiver } = item;
-      if (!trackTypes.includes(publishOption.trackType)) continue;
-      this.stopTrack(transceiver.sender.track);
-    }
+  stopTracks = async (...trackTypes: TrackType[]) => {
+    return withoutConcurrency(
+      this.eventLockKey('changePublishQuality'),
+      async () => {
+        for (const item of this.transceiverCache.items()) {
+          const { publishOption, transceiver } = item;
+          if (!trackTypes.includes(publishOption.trackType)) continue;
+          const track = transceiver.sender.track;
+          await this.silenceSenderOnFirefox(item);
+          this.stopTrack(track);
+        }
+      },
+    );
   };
 
   /**
    * Stops all the cloned tracks that are being published to the SFU.
    */
-  stopAllTracks = () => {
-    for (const { transceiver } of this.transceiverCache.items()) {
-      this.stopTrack(transceiver.sender.track);
-    }
-    for (const track of this.clonedTracks) {
-      this.stopTrack(track);
-    }
+  stopAllTracks = async () => {
+    return withoutConcurrency(
+      this.eventLockKey('changePublishQuality'),
+      async () => {
+        for (const item of this.transceiverCache.items()) {
+          const track = item.transceiver.sender.track;
+          await this.silenceSenderOnFirefox(item);
+          this.stopTrack(track);
+        }
+        for (const track of this.clonedTracks) {
+          this.stopTrack(track);
+        }
+      },
+    );
   };
 
-  private changePublishQuality = async (videoSender: VideoSender) => {
-    const { trackType, layers, publishOptionId } = videoSender;
-    const enabledLayers = layers.filter((l) => l.active);
+  private changePublishQuality = async (
+    videoSender: VideoSender,
+    bundle: PublishBundle | undefined,
+  ) => {
+    const enabledLayers = videoSender.layers.filter((l) => l.active);
 
     const tag = 'Update publish quality:';
     this.logger.info(`${tag} requested layers by SFU:`, enabledLayers);
 
-    const transceiverId = this.transceiverCache.find(
-      (t) =>
-        t.publishOption.id === publishOptionId &&
-        t.publishOption.trackType === trackType,
-    );
-    const sender = transceiverId?.transceiver.sender;
+    const sender = bundle?.transceiver.sender;
     if (!sender) {
       return this.logger.warn(`${tag} no video sender found.`);
     }
@@ -328,7 +358,7 @@ export class Publisher extends BasePeerConnection {
       return this.logger.warn(`${tag} there are no encodings set.`);
     }
 
-    const codecInUse = transceiverId?.publishOption.codec?.name;
+    const codecInUse = bundle?.publishOption.codec?.name;
     const usesSvcCodec = codecInUse && isSvcCodec(codecInUse);
 
     let changed = false;
@@ -560,4 +590,73 @@ export class Publisher extends BasePeerConnection {
     track.stop();
     this.clonedTracks.delete(track);
   };
+
+  /**
+   * Silences a Firefox sender on the wire during unpublish.
+   *
+   * Firefox keeps emitting RTP after track.stop(), but the right lever
+   * differs by track type:
+   *   - audio: `replaceTrack(null)` is the only reliable silencer;
+   *     `setParameters({encodings:[...active:false]})` does NOT stop
+   *     the Opus encoder.
+   *   - video: `setParameters({encodings:[...active:false]})` pauses
+   *     the encoder; `replaceTrack(null)` does NOT reliably stop the
+   *     video encoder. The prior active=true configuration is captured
+   *     onto `bundle.videoSender` so `updateTransceiver` can restore
+   *     it on the next publish.
+   *
+   * No-op on non-Firefox browsers and during teardown.
+   */
+  private silenceSenderOnFirefox = async (bundle: PublishBundle) => {
+    if (this.isDisposed || !isFirefox()) return;
+    const { transceiver, publishOption } = bundle;
+    if (isAudioTrackType(publishOption.trackType)) {
+      await transceiver.sender.replaceTrack(null).catch((err) => {
+        this.logger.warn('Failed to clear audio sender track', err);
+      });
+      return;
+    }
+    await this.disableAllEncodings(bundle);
+  };
+
+  private disableAllEncodings = async (bundle: PublishBundle) => {
+    const { transceiver, publishOption } = bundle;
+    const sender = transceiver.sender;
+    const params = sender.getParameters();
+    if (!params.encodings || params.encodings.length === 0) return;
+
+    if (!bundle.videoSender) {
+      this.transceiverCache.update(publishOption, {
+        videoSender: {
+          trackType: publishOption.trackType,
+          publishOptionId: publishOption.id,
+          codec: publishOption.codec,
+          degradationPreference: fromRTCDegradationPreference(
+            params.degradationPreference,
+          ),
+          layers: params.encodings.map((e) => ({
+            name: e.rid ?? 'q',
+            active: e.active ?? true,
+            maxBitrate: e.maxBitrate ?? 0,
+            scaleResolutionDownBy: e.scaleResolutionDownBy ?? 0,
+            maxFramerate: e.maxFramerate ?? 0,
+            // @ts-expect-error scalabilityMode is not in the typedefs yet
+            scalabilityMode: e.scalabilityMode ?? '',
+          })),
+        },
+      });
+    }
+
+    let changed = false;
+    for (const encoding of params.encodings) {
+      if (encoding.active !== false) {
+        encoding.active = false;
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    await sender.setParameters(params).catch((err) => {
+      this.logger.error('Failed to disable video sender encodings:', err);
+    });
+  };
 }

package/src/rtc/Subscriber.ts

@@ -196,6 +196,7 @@ export class Subscriber extends BasePeerConnection {
     await this.sfuClient.sendAnswer({
       peerType: PeerType.SUBSCRIBER,
       sdp: answer.sdp || '',
+      negotiationId: subscriberOffer.negotiationId,
     });
 
     this.isIceRestarting = false;