@fishjam-cloud/webrtc-client 0.30.0 → 0.30.2-rc.0

package/dist/index.d.mts

@@ -1,12 +1,6 @@
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
 import TypedEmitter from 'typed-emitter';
 
-declare const getLogger: (enableLogging: boolean) => {
-    readonly debug: (arg: unknown, ...args: unknown[]) => void;
-    readonly warn: (arg: unknown, ...args: unknown[]) => void;
-    readonly error: (arg: unknown, ...args: unknown[]) => void;
-};
-
 declare enum Variant {
     VARIANT_UNSPECIFIED = 0,
     VARIANT_LOW = 1,
@@ -41,6 +35,42 @@ interface MessageFns$2<T> {
     fromPartial<I extends Exact$2<DeepPartial$2<T>, I>>(object: I): T;
 }
 
+interface MediaEvent_Track_SimulcastConfig {
+    enabled: boolean;
+    enabledVariants: Variant[];
+    disabledVariants: Variant[];
+}
+declare const MediaEvent_Track_SimulcastConfig: MessageFns$1<MediaEvent_Track_SimulcastConfig>;
+interface MediaEvent_OfferData_TrackTypes {
+    audio: number;
+    video: number;
+}
+declare const MediaEvent_OfferData_TrackTypes: MessageFns$1<MediaEvent_OfferData_TrackTypes>;
+type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$1<T[K]>;
+} : Partial<T>;
+type KeysOfUnion$1<T> = T extends T ? keyof T : never;
+type Exact$1<P, I extends P> = P extends Builtin$1 ? P : P & {
+    [K in keyof P]: Exact$1<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion$1<P>>]: never;
+};
+interface MessageFns$1<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact$1<DeepPartial$1<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact$1<DeepPartial$1<T>, I>>(object: I): T;
+}
+
+declare const getLogger: (enableLogging: boolean) => {
+    readonly debug: (arg: unknown, ...args: unknown[]) => void;
+    readonly warn: (arg: unknown, ...args: unknown[]) => void;
+    readonly error: (arg: unknown, ...args: unknown[]) => void;
+};
+
 /** Defines any type of message sent from Peer to Membrane RTC Engine */
 interface MediaEvent$1 {
     connect?: MediaEvent_Connect | undefined;
@@ -56,36 +86,36 @@ interface MediaEvent$1 {
     setTargetTrackVariant?: MediaEvent_SetTargetTrackVariant | undefined;
     unmuteTrack?: MediaEvent_UnmuteTrack | undefined;
 }
-declare const MediaEvent$1: MessageFns$1<MediaEvent$1>;
+declare const MediaEvent$1: MessageFns<MediaEvent$1>;
 interface MediaEvent_VariantBitrate {
     variant: Variant;
     bitrate: number;
 }
-declare const MediaEvent_VariantBitrate: MessageFns$1<MediaEvent_VariantBitrate>;
+declare const MediaEvent_VariantBitrate: MessageFns<MediaEvent_VariantBitrate>;
 /** Sent when a peer wants to join WebRTC Endpoint. */
 interface MediaEvent_Connect {
     metadataJson: string;
 }
-declare const MediaEvent_Connect: MessageFns$1<MediaEvent_Connect>;
+declare const MediaEvent_Connect: MessageFns<MediaEvent_Connect>;
 /** Sent when a peer disconnects from WebRTC Endpoint. */
 interface MediaEvent_Disconnect {
 }
-declare const MediaEvent_Disconnect: MessageFns$1<MediaEvent_Disconnect>;
+declare const MediaEvent_Disconnect: MessageFns<MediaEvent_Disconnect>;
 /** Sent when a peer wants to update its metadata */
 interface MediaEvent_UpdateEndpointMetadata {
     metadataJson: string;
 }
-declare const MediaEvent_UpdateEndpointMetadata: MessageFns$1<MediaEvent_UpdateEndpointMetadata>;
+declare const MediaEvent_UpdateEndpointMetadata: MessageFns<MediaEvent_UpdateEndpointMetadata>;
 /** Sent when a peer wants to update its track's metadata */
 interface MediaEvent_UpdateTrackMetadata {
     trackId: string;
     metadataJson: string;
 }
-declare const MediaEvent_UpdateTrackMetadata: MessageFns$1<MediaEvent_UpdateTrackMetadata>;
+declare const MediaEvent_UpdateTrackMetadata: MessageFns<MediaEvent_UpdateTrackMetadata>;
 /** Sent when peer wants to renegotiate connection due to adding a track or removing a track */
 interface MediaEvent_RenegotiateTracks {
 }
-declare const MediaEvent_RenegotiateTracks: MessageFns$1<MediaEvent_RenegotiateTracks>;
+declare const MediaEvent_RenegotiateTracks: MessageFns<MediaEvent_RenegotiateTracks>;
 /**
  * Sent as a response to `offerData` media event during renegotiation
  * Maps contain only information about current peer's `sendonly` tracks.
@@ -105,65 +135,35 @@ interface MediaEvent_SdpOffer {
         [key: string]: string;
     };
 }
-declare const MediaEvent_SdpOffer: MessageFns$1<MediaEvent_SdpOffer>;
+declare const MediaEvent_SdpOffer: MessageFns<MediaEvent_SdpOffer>;
 /** Sent when Peer wants to update its track's bitrate */
 interface MediaEvent_TrackBitrates {
     trackId: string;
     /** Bitrate of each variant. For non-simulcast tracks use VARIANT_UNSPECIFIED. */
     variantBitrates: MediaEvent_VariantBitrate[];
 }
-declare const MediaEvent_TrackBitrates: MessageFns$1<MediaEvent_TrackBitrates>;
+declare const MediaEvent_TrackBitrates: MessageFns<MediaEvent_TrackBitrates>;
 /** Sent when client disables one of the track variants */
 interface MediaEvent_DisableTrackVariant {
     trackId: string;
     variant: Variant;
 }
-declare const MediaEvent_DisableTrackVariant: MessageFns$1<MediaEvent_DisableTrackVariant>;
+declare const MediaEvent_DisableTrackVariant: MessageFns<MediaEvent_DisableTrackVariant>;
 /** Sent when client enables one of the track variants */
 interface MediaEvent_EnableTrackVariant {
     trackId: string;
     variant: Variant;
 }
-declare const MediaEvent_EnableTrackVariant: MessageFns$1<MediaEvent_EnableTrackVariant>;
+declare const MediaEvent_EnableTrackVariant: MessageFns<MediaEvent_EnableTrackVariant>;
 interface MediaEvent_SetTargetTrackVariant {
     trackId: string;
     variant: Variant;
 }
-declare const MediaEvent_SetTargetTrackVariant: MessageFns$1<MediaEvent_SetTargetTrackVariant>;
+declare const MediaEvent_SetTargetTrackVariant: MessageFns<MediaEvent_SetTargetTrackVariant>;
 interface MediaEvent_UnmuteTrack {
     trackId: string;
 }
-declare const MediaEvent_UnmuteTrack: MessageFns$1<MediaEvent_UnmuteTrack>;
-type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$1<T[K]>;
-} : Partial<T>;
-type KeysOfUnion$1<T> = T extends T ? keyof T : never;
-type Exact$1<P, I extends P> = P extends Builtin$1 ? P : P & {
-    [K in keyof P]: Exact$1<P[K], I[K]>;
-} & {
-    [K in Exclude<keyof I, KeysOfUnion$1<P>>]: never;
-};
-interface MessageFns$1<T> {
-    encode(message: T, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): T;
-    fromJSON(object: any): T;
-    toJSON(message: T): unknown;
-    create<I extends Exact$1<DeepPartial$1<T>, I>>(base?: I): T;
-    fromPartial<I extends Exact$1<DeepPartial$1<T>, I>>(object: I): T;
-}
-
-interface MediaEvent_Track_SimulcastConfig {
-    enabled: boolean;
-    enabledVariants: Variant[];
-    disabledVariants: Variant[];
-}
-declare const MediaEvent_Track_SimulcastConfig: MessageFns<MediaEvent_Track_SimulcastConfig>;
-interface MediaEvent_OfferData_TrackTypes {
-    audio: number;
-    video: number;
-}
-declare const MediaEvent_OfferData_TrackTypes: MessageFns<MediaEvent_OfferData_TrackTypes>;
+declare const MediaEvent_UnmuteTrack: MessageFns<MediaEvent_UnmuteTrack>;
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
@@ -200,13 +200,14 @@ type TrackKind = 'audio' | 'video';
  */
 type VadStatus = 'speech' | 'silence';
 /**
- * Type describing maximal bandwidth that can be used, in kbps. 0 is interpreted as unlimited bandwidth.
+ * Type describing maximal bandwidth that can be used, in kbps.
+ * Video limits are clamped to `MAX_BANDWIDTH_LIMITS`; 0 is interpreted as "use the cap".
  */
 type BandwidthLimit = number;
 /**
  * Type describing bandwidth limit for simulcast track.
  * It is a mapping (encoding => BandwidthLimit).
- * If encoding isn't present in this mapping, it will be assumed that this particular encoding shouldn't have any bandwidth limit
+ * If encoding isn't present in this mapping, the cap from `MAX_BANDWIDTH_LIMITS.simulcast` is used for it.
  */
 type SimulcastBandwidthLimit = Map<Variant, BandwidthLimit>;
 /**
@@ -495,6 +496,25 @@ type WebRTCEndpointProps = {
 };
 type Logger = ReturnType<typeof getLogger>;
 
+/**
+ * Hard caps (in kbps) for the bitrate of an outgoing video track.
+ * A limit passed to the SDK is never allowed to exceed these values, and an unset (0) limit resolves to them.
+ */
+declare const MAX_BANDWIDTH_LIMITS: {
+    readonly singleStream: BandwidthLimit;
+    readonly simulcast: {
+        readonly 1: BandwidthLimit;
+        readonly 2: BandwidthLimit;
+        readonly 3: BandwidthLimit;
+    };
+};
+/**
+ * Resolves a user-provided video bandwidth limit against {@link MAX_BANDWIDTH_LIMITS}.
+ * - a number is a single-stream limit; 0 or negative means "use the cap", higher values are clamped to it
+ * - a Map holds per-variant simulcast limits; each variant is resolved the same way
+ */
+declare const resolveBandwidthLimit: (limit: TrackBandwidthLimit) => TrackBandwidthLimit;
+
 declare class ConnectionManager {
     private readonly connection;
     constructor(iceServers: RTCIceServer[]);
@@ -726,7 +746,7 @@ declare class WebRTCEndpoint extends WebRTCEndpoint_base {
      * In case trackId points at the simulcast track bandwidth is split between all of the variant streams proportionally to their resolution.
      *
      * @param {string} trackId
-     * @param {BandwidthLimit} bandwidth in kbps
+     * @param {BandwidthLimit} bandwidth in kbps, clamped to `MAX_BANDWIDTH_LIMITS.singleStream`
      * @returns {Promise<boolean>} success
      */
     setTrackBandwidth(trackId: string, bandwidth: BandwidthLimit): Promise<void>;
@@ -735,7 +755,7 @@ declare class WebRTCEndpoint extends WebRTCEndpoint_base {
      *
      * @param {string} trackId - id of the track
      * @param {string} rid - rid of the encoding
-     * @param {BandwidthLimit} bandwidth - desired max bandwidth used by the encoding (in kbps)
+     * @param {BandwidthLimit} bandwidth - desired max bandwidth used by the encoding (in kbps), clamped to `MAX_BANDWIDTH_LIMITS.simulcast[rid]`
      * @returns
      */
     setEncodingBandwidth(trackId: string, rid: Variant, bandwidth: BandwidthLimit): Promise<void>;
@@ -896,4 +916,4 @@ declare class WebRTCEndpoint extends WebRTCEndpoint_base {
     private onIceConnectionStateChange;
 }
 
-export { type BandwidthLimit, type DataCallback, type DataChannelMessagePayload, type DataChannelOptions, type DataChannelType, type EncodingReason, type Endpoint, type Logger, type MediaEvent, type SerializedMediaEvent, type SimulcastBandwidthLimit, MediaEvent_Track_SimulcastConfig as SimulcastConfig, type TrackBandwidthLimit, type TrackContext, type TrackContextEvents, type TrackKind, type VadStatus, Variant, WebRTCEndpoint, type WebRTCEndpointEvents, getLogger };
+export { type BandwidthLimit, type DataCallback, type DataChannelMessagePayload, type DataChannelOptions, type DataChannelType, type EncodingReason, type Endpoint, type Logger, MAX_BANDWIDTH_LIMITS, type MediaEvent, type SerializedMediaEvent, type SimulcastBandwidthLimit, MediaEvent_Track_SimulcastConfig as SimulcastConfig, type TrackBandwidthLimit, type TrackContext, type TrackContextEvents, type TrackKind, type VadStatus, Variant, WebRTCEndpoint, type WebRTCEndpointEvents, getLogger, resolveBandwidthLimit };

package/dist/index.mjs

@@ -1,20 +1,3 @@
-// src/logger.ts
-var FISHJAM_PREFIX = "[FISHJAM]";
-var getLogger = (enableLogging) => ({
-  debug: (arg, ...args) => {
-    if (enableLogging) console.debug(FISHJAM_PREFIX, arg, ...args);
-  },
-  warn: (arg, ...args) => {
-    if (enableLogging) console.warn(FISHJAM_PREFIX, arg, ...args);
-  },
-  error: (arg, ...args) => {
-    if (enableLogging) console.error(FISHJAM_PREFIX, arg, ...args);
-  }
-});
-
-// ../protobufs/fishjam/media_events/peer/peer.ts
-import { BinaryReader as BinaryReader2, BinaryWriter as BinaryWriter2 } from "@bufbuild/protobuf/wire";
-
 // ../protobufs/fishjam/media_events/shared.ts
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 var Variant = /* @__PURE__ */ ((Variant4) => {
@@ -162,7 +145,67 @@ function isSet(value) {
   return value !== null && value !== void 0;
 }
 
+// src/bitrate.ts
+var MAX_BANDWIDTH_LIMITS = {
+  singleStream: 1500,
+  simulcast: {
+    [1 /* VARIANT_LOW */]: 150,
+    [2 /* VARIANT_MEDIUM */]: 500,
+    [3 /* VARIANT_HIGH */]: 1500
+  }
+};
+var SIMULCAST_VARIANTS = [1 /* VARIANT_LOW */, 2 /* VARIANT_MEDIUM */, 3 /* VARIANT_HIGH */];
+var isSimulcastVariant = (variant) => SIMULCAST_VARIANTS.includes(variant);
+var resolveAgainstCap = (limit, cap, label) => {
+  if (!limit || limit <= 0) return cap;
+  if (limit > cap) {
+    console.warn(`[Fishjam] ${label} bandwidth limit ${limit} kbps exceeds the cap of ${cap} kbps, using the cap`);
+    return cap;
+  }
+  return limit;
+};
+var resolveBandwidthLimit = (limit) => {
+  if (typeof limit === "number") return resolveAgainstCap(limit, MAX_BANDWIDTH_LIMITS.singleStream, "single stream");
+  const resolved = /* @__PURE__ */ new Map();
+  for (const variant of SIMULCAST_VARIANTS) {
+    resolved.set(variant, resolveAgainstCap(limit.get(variant), MAX_BANDWIDTH_LIMITS.simulcast[variant], Variant[variant]));
+  }
+  return resolved;
+};
+var resolveVariantBandwidthLimit = (variant, limit) => {
+  const cap = isSimulcastVariant(variant) ? MAX_BANDWIDTH_LIMITS.simulcast[variant] : MAX_BANDWIDTH_LIMITS.singleStream;
+  return resolveAgainstCap(limit, cap, Variant[variant]);
+};
+var kbpsToBps = (kbps) => kbps * 1024;
+var defaultBitrates = {
+  audio: 5e4,
+  video: kbpsToBps(MAX_BANDWIDTH_LIMITS.singleStream)
+};
+var UNLIMITED_BANDWIDTH = 0;
+var defaultSimulcastBitrates = {
+  [3 /* VARIANT_HIGH */]: kbpsToBps(MAX_BANDWIDTH_LIMITS.simulcast[3 /* VARIANT_HIGH */]),
+  [2 /* VARIANT_MEDIUM */]: kbpsToBps(MAX_BANDWIDTH_LIMITS.simulcast[2 /* VARIANT_MEDIUM */]),
+  [1 /* VARIANT_LOW */]: kbpsToBps(MAX_BANDWIDTH_LIMITS.simulcast[1 /* VARIANT_LOW */]),
+  [0 /* VARIANT_UNSPECIFIED */]: 0,
+  [-1 /* UNRECOGNIZED */]: 0
+};
+
+// src/logger.ts
+var FISHJAM_PREFIX = "[FISHJAM]";
+var getLogger = (enableLogging) => ({
+  debug: (arg, ...args) => {
+    if (enableLogging) console.debug(FISHJAM_PREFIX, arg, ...args);
+  },
+  warn: (arg, ...args) => {
+    if (enableLogging) console.warn(FISHJAM_PREFIX, arg, ...args);
+  },
+  error: (arg, ...args) => {
+    if (enableLogging) console.error(FISHJAM_PREFIX, arg, ...args);
+  }
+});
+
 // ../protobufs/fishjam/media_events/peer/peer.ts
+import { BinaryReader as BinaryReader2, BinaryWriter as BinaryWriter2 } from "@bufbuild/protobuf/wire";
 function createBaseMediaEvent() {
   return {
     connect: void 0,
@@ -3963,18 +4006,15 @@ var TrackContextImpl = class extends EventEmitter2 {
   }
 };
 
-// src/bitrate.ts
-var defaultBitrates = {
-  audio: 5e4,
-  video: 25e5
-};
-var UNLIMITED_BANDWIDTH = 0;
-var defaultSimulcastBitrates = {
-  [3 /* VARIANT_HIGH */]: 25e5,
-  [2 /* VARIANT_MEDIUM */]: 5e5,
-  [1 /* VARIANT_LOW */]: 15e4,
-  [0 /* VARIANT_UNSPECIFIED */]: 0,
-  [-1 /* UNRECOGNIZED */]: 0
+// src/tracks/bitrates.ts
+var getVariantBitrates = (trackContext) => {
+  const kind = trackContext.track?.kind ?? trackContext.trackKind;
+  if (kind === "audio") return [{ variant: 0 /* VARIANT_UNSPECIFIED */, bitrate: defaultBitrates.audio }];
+  const { maxBandwidth } = trackContext;
+  if (typeof maxBandwidth === "number") {
+    return [{ variant: 0 /* VARIANT_UNSPECIFIED */, bitrate: kbpsToBps(maxBandwidth) || defaultBitrates.video }];
+  }
+  return [...maxBandwidth.entries()].map(([variant, limit]) => ({ variant, bitrate: kbpsToBps(limit) }));
 };
 
 // src/tracks/bandwidth.ts
@@ -4367,9 +4407,10 @@ var Local = class {
     const trackManager = this.localTracks[trackId];
     if (!trackManager) throw new Error(`Cannot find ${trackId}`);
     await trackManager.setTrackBandwidth(bandwidth);
+    trackManager.trackContext.maxBandwidth = bandwidth;
     const trackBitrates = MediaEvent_TrackBitrates.create({
       trackId,
-      variantBitrates: [{ variant: 0 /* VARIANT_UNSPECIFIED */, bitrate: bandwidth }]
+      variantBitrates: getVariantBitrates(trackManager.trackContext)
     });
     this.sendMediaEvent(MediaEvent.create({ trackBitrates }));
     this.emit("localTrackBandwidthSet", {
@@ -4390,19 +4431,11 @@ var Local = class {
     const trackManager = this.localTracks[trackId];
     if (!trackManager) throw new Error(`Cannot find ${trackId}`);
     await trackManager.setEncodingBandwidth(rid, bandwidth);
-    const bitrates = trackManager.getTrackBitrates();
-    let variantBitrates = [];
-    if (typeof bitrates === "number") {
-      variantBitrates = [{ variant: 0 /* VARIANT_UNSPECIFIED */, bitrate: bitrates }];
-    } else if (bitrates) {
-      variantBitrates = Object.entries(bitrates).map(([variant, bitrate]) => ({
-        variant: Number(variant),
-        bitrate
-      }));
-    }
+    const { maxBandwidth } = trackManager.trackContext;
+    if (maxBandwidth instanceof Map) maxBandwidth.set(rid, bandwidth);
     const trackBitrates = MediaEvent_TrackBitrates.create({
       trackId,
-      variantBitrates
+      variantBitrates: getVariantBitrates(trackManager.trackContext)
     });
     this.sendMediaEvent(MediaEvent.create({ trackBitrates }));
     this.emit("localTrackEncodingBandwidthSet", {
@@ -4471,8 +4504,13 @@ var Local = class {
     (acc, { id, trackContext }) => ({ ...acc, [id]: JSON.stringify(trackContext.metadata) }),
     {}
   );
-  // TODO add bitrates
-  getTrackIdToTrackBitrates = () => Object.values(this.localTracks).reduce((acc, { id }) => ({ ...acc, [id]: { bitrate: 15e5 } }), {});
+  getTrackIdToTrackBitrates = () => Object.values(this.localTracks).reduce(
+    (acc, { id, trackContext }) => ({
+      ...acc,
+      [id]: MediaEvent_TrackBitrates.create({ trackId: id, variantBitrates: getVariantBitrates(trackContext) })
+    }),
+    {}
+  );
   getMidToTrackId = () => {
     if (!this.connection) return {};
     const mappingFromTransceivers = this.getTransceiverMapping();
@@ -5078,7 +5116,7 @@ var WebRTCEndpoint = class extends EventEmitter3 {
     const resolutionNotifier = new Deferred();
     const trackId = this.getTrackId(uuidv4());
     const trackStream = stream ?? new MediaStream();
-    const resolvedMaxBandwidth = typeof maxBandwidth === "number" && maxBandwidth > 0 ? maxBandwidth : 0;
+    const resolvedMaxBandwidth = track.kind === "video" ? resolveBandwidthLimit(maxBandwidth) : 0;
     try {
       if (!stream) trackStream.addTrack(track);
       this.commandsQueue.pushCommand({
@@ -5171,24 +5209,24 @@ var WebRTCEndpoint = class extends EventEmitter3 {
    * In case trackId points at the simulcast track bandwidth is split between all of the variant streams proportionally to their resolution.
    *
    * @param {string} trackId
-   * @param {BandwidthLimit} bandwidth in kbps
+   * @param {BandwidthLimit} bandwidth in kbps, clamped to `MAX_BANDWIDTH_LIMITS.singleStream`
    * @returns {Promise<boolean>} success
    */
   setTrackBandwidth(trackId, bandwidth) {
     if (!this.connectionManager) throw new Error(`There is no active RTCPeerConnection`);
-    return this.local.setTrackBandwidth(trackId, bandwidth);
+    return this.local.setTrackBandwidth(trackId, resolveBandwidthLimit(bandwidth));
   }
   /**
    * Updates maximum bandwidth for the given simulcast encoding of the given track.
    *
    * @param {string} trackId - id of the track
    * @param {string} rid - rid of the encoding
-   * @param {BandwidthLimit} bandwidth - desired max bandwidth used by the encoding (in kbps)
+   * @param {BandwidthLimit} bandwidth - desired max bandwidth used by the encoding (in kbps), clamped to `MAX_BANDWIDTH_LIMITS.simulcast[rid]`
    * @returns
    */
   async setEncodingBandwidth(trackId, rid, bandwidth) {
     if (!this.connectionManager) throw new Error(`There is no active RTCPeerConnection`);
-    return await this.local.setEncodingBandwidth(trackId, rid, bandwidth);
+    return await this.local.setEncodingBandwidth(trackId, rid, resolveVariantBandwidthLimit(rid, bandwidth));
   }
   /**
    * Removes a track from connection that was sent to the RTC Engine.
@@ -5485,8 +5523,10 @@ var WebRTCEndpoint = class extends EventEmitter3 {
   };
 };
 export {
+  MAX_BANDWIDTH_LIMITS,
   MediaEvent_Track_SimulcastConfig as SimulcastConfig,
   Variant,
   WebRTCEndpoint,
-  getLogger
+  getLogger,
+  resolveBandwidthLimit
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fishjam-cloud/webrtc-client",
-  "version": "0.30.0",
+  "version": "0.30.2-rc.0",
   "description": "Typescript client library for ExWebRTC/WebRTC endpoint in Membrane RTC Engine",
   "license": "Apache-2.0",
   "author": "Fishjam Team",