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

package/dist/index.d.mts

@@ -1,6 +1,12 @@
 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,
@@ -35,42 +41,6 @@ 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;
@@ -86,36 +56,36 @@ interface MediaEvent$1 {
     setTargetTrackVariant?: MediaEvent_SetTargetTrackVariant | undefined;
     unmuteTrack?: MediaEvent_UnmuteTrack | undefined;
 }
-declare const MediaEvent$1: MessageFns<MediaEvent$1>;
+declare const MediaEvent$1: MessageFns$1<MediaEvent$1>;
 interface MediaEvent_VariantBitrate {
     variant: Variant;
     bitrate: number;
 }
-declare const MediaEvent_VariantBitrate: MessageFns<MediaEvent_VariantBitrate>;
+declare const MediaEvent_VariantBitrate: MessageFns$1<MediaEvent_VariantBitrate>;
 /** Sent when a peer wants to join WebRTC Endpoint. */
 interface MediaEvent_Connect {
     metadataJson: string;
 }
-declare const MediaEvent_Connect: MessageFns<MediaEvent_Connect>;
+declare const MediaEvent_Connect: MessageFns$1<MediaEvent_Connect>;
 /** Sent when a peer disconnects from WebRTC Endpoint. */
 interface MediaEvent_Disconnect {
 }
-declare const MediaEvent_Disconnect: MessageFns<MediaEvent_Disconnect>;
+declare const MediaEvent_Disconnect: MessageFns$1<MediaEvent_Disconnect>;
 /** Sent when a peer wants to update its metadata */
 interface MediaEvent_UpdateEndpointMetadata {
     metadataJson: string;
 }
-declare const MediaEvent_UpdateEndpointMetadata: MessageFns<MediaEvent_UpdateEndpointMetadata>;
+declare const MediaEvent_UpdateEndpointMetadata: MessageFns$1<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<MediaEvent_UpdateTrackMetadata>;
+declare const MediaEvent_UpdateTrackMetadata: MessageFns$1<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<MediaEvent_RenegotiateTracks>;
+declare const MediaEvent_RenegotiateTracks: MessageFns$1<MediaEvent_RenegotiateTracks>;
 /**
  * Sent as a response to `offerData` media event during renegotiation
  * Maps contain only information about current peer's `sendonly` tracks.
@@ -135,35 +105,65 @@ interface MediaEvent_SdpOffer {
         [key: string]: string;
     };
 }
-declare const MediaEvent_SdpOffer: MessageFns<MediaEvent_SdpOffer>;
+declare const MediaEvent_SdpOffer: MessageFns$1<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<MediaEvent_TrackBitrates>;
+declare const MediaEvent_TrackBitrates: MessageFns$1<MediaEvent_TrackBitrates>;
 /** Sent when client disables one of the track variants */
 interface MediaEvent_DisableTrackVariant {
     trackId: string;
     variant: Variant;
 }
-declare const MediaEvent_DisableTrackVariant: MessageFns<MediaEvent_DisableTrackVariant>;
+declare const MediaEvent_DisableTrackVariant: MessageFns$1<MediaEvent_DisableTrackVariant>;
 /** Sent when client enables one of the track variants */
 interface MediaEvent_EnableTrackVariant {
     trackId: string;
     variant: Variant;
 }
-declare const MediaEvent_EnableTrackVariant: MessageFns<MediaEvent_EnableTrackVariant>;
+declare const MediaEvent_EnableTrackVariant: MessageFns$1<MediaEvent_EnableTrackVariant>;
 interface MediaEvent_SetTargetTrackVariant {
     trackId: string;
     variant: Variant;
 }
-declare const MediaEvent_SetTargetTrackVariant: MessageFns<MediaEvent_SetTargetTrackVariant>;
+declare const MediaEvent_SetTargetTrackVariant: MessageFns$1<MediaEvent_SetTargetTrackVariant>;
 interface MediaEvent_UnmuteTrack {
     trackId: string;
 }
-declare const MediaEvent_UnmuteTrack: MessageFns<MediaEvent_UnmuteTrack>;
+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>;
 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,14 +200,13 @@ type TrackKind = 'audio' | 'video';
  */
 type VadStatus = 'speech' | 'silence';
 /**
- * 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 describing maximal bandwidth that can be used, in kbps. 0 is interpreted as unlimited bandwidth.
  */
 type BandwidthLimit = number;
 /**
  * Type describing bandwidth limit for simulcast track.
  * It is a mapping (encoding => BandwidthLimit).
- * If encoding isn't present in this mapping, the cap from `MAX_BANDWIDTH_LIMITS.simulcast` is used for it.
+ * If encoding isn't present in this mapping, it will be assumed that this particular encoding shouldn't have any bandwidth limit
  */
 type SimulcastBandwidthLimit = Map<Variant, BandwidthLimit>;
 /**
@@ -496,25 +495,6 @@ 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[]);
@@ -746,7 +726,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, clamped to `MAX_BANDWIDTH_LIMITS.singleStream`
+     * @param {BandwidthLimit} bandwidth in kbps
      * @returns {Promise<boolean>} success
      */
     setTrackBandwidth(trackId: string, bandwidth: BandwidthLimit): Promise<void>;
@@ -755,7 +735,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), clamped to `MAX_BANDWIDTH_LIMITS.simulcast[rid]`
+     * @param {BandwidthLimit} bandwidth - desired max bandwidth used by the encoding (in kbps)
      * @returns
      */
     setEncodingBandwidth(trackId: string, rid: Variant, bandwidth: BandwidthLimit): Promise<void>;
@@ -916,4 +896,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, 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 };
+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 };

package/dist/index.mjs

@@ -1,3 +1,20 @@
+// 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) => {
@@ -145,67 +162,7 @@ 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,
@@ -4006,15 +3963,18 @@ var TrackContextImpl = class extends EventEmitter2 {
   }
 };
 
-// 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/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/bandwidth.ts
@@ -4407,10 +4367,9 @@ 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: getVariantBitrates(trackManager.trackContext)
+      variantBitrates: [{ variant: 0 /* VARIANT_UNSPECIFIED */, bitrate: bandwidth }]
     });
     this.sendMediaEvent(MediaEvent.create({ trackBitrates }));
     this.emit("localTrackBandwidthSet", {
@@ -4431,11 +4390,19 @@ var Local = class {
     const trackManager = this.localTracks[trackId];
     if (!trackManager) throw new Error(`Cannot find ${trackId}`);
     await trackManager.setEncodingBandwidth(rid, bandwidth);
-    const { maxBandwidth } = trackManager.trackContext;
-    if (maxBandwidth instanceof Map) maxBandwidth.set(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 trackBitrates = MediaEvent_TrackBitrates.create({
       trackId,
-      variantBitrates: getVariantBitrates(trackManager.trackContext)
+      variantBitrates
     });
     this.sendMediaEvent(MediaEvent.create({ trackBitrates }));
     this.emit("localTrackEncodingBandwidthSet", {
@@ -4504,13 +4471,8 @@ var Local = class {
     (acc, { id, trackContext }) => ({ ...acc, [id]: JSON.stringify(trackContext.metadata) }),
     {}
   );
-  getTrackIdToTrackBitrates = () => Object.values(this.localTracks).reduce(
-    (acc, { id, trackContext }) => ({
-      ...acc,
-      [id]: MediaEvent_TrackBitrates.create({ trackId: id, variantBitrates: getVariantBitrates(trackContext) })
-    }),
-    {}
-  );
+  // TODO add bitrates
+  getTrackIdToTrackBitrates = () => Object.values(this.localTracks).reduce((acc, { id }) => ({ ...acc, [id]: { bitrate: 15e5 } }), {});
   getMidToTrackId = () => {
     if (!this.connection) return {};
     const mappingFromTransceivers = this.getTransceiverMapping();
@@ -5116,7 +5078,7 @@ var WebRTCEndpoint = class extends EventEmitter3 {
     const resolutionNotifier = new Deferred();
     const trackId = this.getTrackId(uuidv4());
     const trackStream = stream ?? new MediaStream();
-    const resolvedMaxBandwidth = track.kind === "video" ? resolveBandwidthLimit(maxBandwidth) : 0;
+    const resolvedMaxBandwidth = typeof maxBandwidth === "number" && maxBandwidth > 0 ? maxBandwidth : 0;
     try {
       if (!stream) trackStream.addTrack(track);
       this.commandsQueue.pushCommand({
@@ -5209,24 +5171,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, clamped to `MAX_BANDWIDTH_LIMITS.singleStream`
+   * @param {BandwidthLimit} bandwidth in kbps
    * @returns {Promise<boolean>} success
    */
   setTrackBandwidth(trackId, bandwidth) {
     if (!this.connectionManager) throw new Error(`There is no active RTCPeerConnection`);
-    return this.local.setTrackBandwidth(trackId, resolveBandwidthLimit(bandwidth));
+    return this.local.setTrackBandwidth(trackId, 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), clamped to `MAX_BANDWIDTH_LIMITS.simulcast[rid]`
+   * @param {BandwidthLimit} bandwidth - desired max bandwidth used by the encoding (in kbps)
    * @returns
    */
   async setEncodingBandwidth(trackId, rid, bandwidth) {
     if (!this.connectionManager) throw new Error(`There is no active RTCPeerConnection`);
-    return await this.local.setEncodingBandwidth(trackId, rid, resolveVariantBandwidthLimit(rid, bandwidth));
+    return await this.local.setEncodingBandwidth(trackId, rid, bandwidth);
   }
   /**
    * Removes a track from connection that was sent to the RTC Engine.
@@ -5523,10 +5485,8 @@ var WebRTCEndpoint = class extends EventEmitter3 {
   };
 };
 export {
-  MAX_BANDWIDTH_LIMITS,
   MediaEvent_Track_SimulcastConfig as SimulcastConfig,
   Variant,
   WebRTCEndpoint,
-  getLogger,
-  resolveBandwidthLimit
+  getLogger
 };

package/package.json

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