@stream-io/video-client 1.11.5 → 1.11.7

package/src/coordinator/connection/connection.ts

@@ -1,13 +1,7 @@
-import WebSocket from 'isomorphic-ws';
 import { StreamClient } from './client';
-import {
-  buildWsFatalInsight,
-  buildWsSuccessAfterFailureInsight,
-  postInsights,
-} from './insights';
 import {
   addConnectionEventListeners,
-  convertErrorToJson,
+  isCloseEvent,
   KnownCodes,
   randomId,
   removeConnectionEventListeners,
@@ -15,20 +9,13 @@ import {
   sleep,
 } from './utils';
 import type { LogLevel, StreamVideoEvent, UR } from './types';
-import type { ConnectedEvent, WSAuthMessage } from '../../gen/coordinator';
+import type {
+  ConnectedEvent,
+  ConnectionErrorEvent,
+  WSAuthMessage,
+} from '../../gen/coordinator';
 import { makeSafePromise, type SafePromise } from '../../helpers/promise';
 
-// Type guards to check WebSocket error type
-const isCloseEvent = (
-  res: WebSocket.CloseEvent | WebSocket.Data | WebSocket.ErrorEvent,
-): res is WebSocket.CloseEvent =>
-  (res as WebSocket.CloseEvent).code !== undefined;
-
-const isErrorEvent = (
-  res: WebSocket.CloseEvent | WebSocket.Data | WebSocket.ErrorEvent,
-): res is WebSocket.ErrorEvent =>
-  (res as WebSocket.ErrorEvent).error !== undefined;
-
 /**
  * StableWSConnection - A WS connection that reconnects upon failure.
  * - the browser will sometimes report that you're online or offline
@@ -50,7 +37,6 @@ export class StableWSConnection {
   // local vars
   connectionID?: string;
   private connectionOpenSafe?: SafePromise<ConnectedEvent>;
-  authenticationSent: boolean;
   consecutiveFailures: number;
   pingInterval: number;
   healthCheckTimeoutRef?: NodeJS.Timeout;
@@ -84,8 +70,6 @@ export class StableWSConnection {
     this.totalFailures = 0;
     /** We only make 1 attempt to reconnect at the same time.. */
     this.isConnecting = false;
-    /** True after the auth payload is sent to the server */
-    this.authenticationSent = false;
     /** To avoid reconnect if client is disconnected */
     this.isDisconnected = false;
     /** Boolean that indicates if the connection promise is resolved */
@@ -219,12 +203,9 @@ export class StableWSConnection {
    */
   _buildUrl = () => {
     const params = new URLSearchParams();
-    // const qs = encodeURIComponent(this.client._buildWSPayload(this.requestID));
-    // params.set('json', qs);
     params.set('api_key', this.client.key);
     params.set('stream-auth-type', this.client.getAuthType());
     params.set('X-Stream-Client', this.client.getUserAgent());
-    // params.append('authorization', this.client._getToken()!);
 
     return `${this.client.wsBaseURL}/connect?${params.toString()}`;
   };
@@ -243,22 +224,13 @@ export class StableWSConnection {
     this.isDisconnected = true;
 
     // start by removing all the listeners
-    if (this.healthCheckTimeoutRef) {
-      clearInterval(this.healthCheckTimeoutRef);
-    }
-    if (this.connectionCheckTimeoutRef) {
-      clearInterval(this.connectionCheckTimeoutRef);
-    }
+    clearInterval(this.healthCheckTimeoutRef);
+    clearInterval(this.connectionCheckTimeoutRef);
 
     removeConnectionEventListeners(this.onlineStatusChanged);
 
     this.isHealthy = false;
 
-    // remove ws handlers...
-    if (this.ws && this.ws.removeAllListeners) {
-      this.ws.removeAllListeners();
-    }
-
     let isClosedPromise: Promise<void>;
     // and finally close...
     // Assigning to local here because we will remove it from this before the
@@ -266,7 +238,7 @@ export class StableWSConnection {
     const { ws } = this;
     if (ws && ws.close && ws.readyState === ws.OPEN) {
       isClosedPromise = new Promise((resolve) => {
-        const onclose = (event: WebSocket.CloseEvent) => {
+        const onclose = (event: CloseEvent) => {
           this._log(
             `disconnect() - resolving isClosedPromise ${
               event ? 'with' : 'without'
@@ -308,14 +280,9 @@ export class StableWSConnection {
    * @return {ConnectAPIResponse<ConnectedEvent>} Promise that completes once the first health check message is received
    */
   async _connect() {
-    if (
-      this.isConnecting ||
-      (this.isDisconnected && this.client.options.enableWSFallback)
-    )
-      return; // simply ignore _connect if it's currently trying to connect
+    if (this.isConnecting) return; // simply ignore _connect if it's currently trying to connect
     this.isConnecting = true;
     this.requestID = randomId();
-    this.client.insightMetrics.connectionStartTimestamp = new Date().getTime();
     let isTokenReady = false;
     try {
       this._log(`_connect() - waiting for token`);
@@ -342,7 +309,8 @@ export class StableWSConnection {
         wsURL,
         requestID: this.requestID,
       });
-      this.ws = new WebSocket(wsURL);
+      const WS = this.client.options.WebSocketImpl ?? WebSocket;
+      this.ws = new WS(wsURL);
       this.ws.onopen = this.onopen.bind(this, this.wsID);
       this.ws.onclose = this.onclose.bind(this, this.wsID);
       this.ws.onerror = this.onerror.bind(this, this.wsID);
@@ -353,18 +321,6 @@ export class StableWSConnection {
       if (response) {
         this.connectionID = response.connection_id;
         this.client.resolveConnectionId?.(this.connectionID);
-        if (
-          this.client.insightMetrics.wsConsecutiveFailures > 0 &&
-          this.client.options.enableInsights
-        ) {
-          postInsights(
-            'ws_success_after_failure',
-            buildWsSuccessAfterFailureInsight(
-              this as unknown as StableWSConnection,
-            ),
-          );
-          this.client.insightMetrics.wsConsecutiveFailures = 0;
-        }
         return response;
       }
     } catch (err) {
@@ -372,16 +328,6 @@ export class StableWSConnection {
       this.isConnecting = false;
       // @ts-ignore
       this._log(`_connect() - Error - `, err);
-      if (this.client.options.enableInsights) {
-        this.client.insightMetrics.wsConsecutiveFailures++;
-        this.client.insightMetrics.wsTotalFailures++;
-
-        const insights = buildWsFatalInsight(
-          this as unknown as StableWSConnection,
-          convertErrorToJson(err as Error),
-        );
-        postInsights?.('ws_fatal', insights);
-      }
       this.client.rejectConnectionId?.(err);
       throw err;
     }
@@ -422,7 +368,7 @@ export class StableWSConnection {
       return;
     }
 
-    if (this.isDisconnected && this.client.options.enableWSFallback) {
+    if (this.isDisconnected) {
       this._log('_reconnect() - Abort (3) since disconnect() is called');
       return;
     }
@@ -518,12 +464,11 @@ export class StableWSConnection {
       },
     };
 
-    this.authenticationSent = true;
     this.ws?.send(JSON.stringify(authMessage));
     this._log('onopen() - onopen callback', { wsID });
   };
 
-  onmessage = (wsID: number, event: WebSocket.MessageEvent) => {
+  onmessage = (wsID: number, event: MessageEvent) => {
     if (this.wsID !== wsID) return;
 
     this._log('onmessage() - onmessage callback', { event, wsID });
@@ -538,7 +483,6 @@ export class StableWSConnection {
     if (!this.isResolved && data && data.type === 'connection.error') {
       this.isResolved = true;
       if (data.error) {
-        // @ts-expect-error - the types of _errorFromWSEvent are incorrect
         this.rejectPromise?.(this._errorFromWSEvent(data, false));
         return;
       }
@@ -584,7 +528,7 @@ export class StableWSConnection {
     this.scheduleConnectionCheck();
   };
 
-  onclose = (wsID: number, event: WebSocket.CloseEvent) => {
+  onclose = (wsID: number, event: CloseEvent) => {
     if (this.wsID !== wsID) return;
 
     this._log('onclose() - onclose callback - ' + event.code, { event, wsID });
@@ -594,11 +538,15 @@ export class StableWSConnection {
       // usually caused by invalid auth details
       const error = new Error(
         `WS connection reject with error ${event.reason}`,
-      ) as Error & WebSocket.CloseEvent;
+      );
 
+      // @ts-expect-error
       error.reason = event.reason;
+      // @ts-expect-error
       error.code = event.code;
+      // @ts-expect-error
       error.wasClean = event.wasClean;
+      // @ts-expect-error
       error.target = event.target;
 
       this.rejectPromise?.(error);
@@ -622,14 +570,14 @@ export class StableWSConnection {
     }
   };
 
-  onerror = (wsID: number, event: WebSocket.ErrorEvent) => {
+  onerror = (wsID: number, event: Event) => {
     if (this.wsID !== wsID) return;
 
     this.consecutiveFailures += 1;
     this.totalFailures += 1;
     this._setHealth(false);
     this.isConnecting = false;
-    this.rejectPromise?.(this._errorFromWSEvent(event));
+    this.rejectPromise?.(new Error(`WebSocket error: ${event}`));
     this._log(`onerror() - WS connection resulted into error`, { event });
 
     this._reconnect();
@@ -641,7 +589,6 @@ export class StableWSConnection {
    *
    * @param {boolean} healthy boolean indicating if the connection is healthy or not
    * @param {boolean} dispatchImmediately boolean indicating to dispatch event immediately even if the connection is unhealthy
-   *
    */
   _setHealth = (healthy: boolean, dispatchImmediately = false) => {
     if (healthy === this.isHealthy) return;
@@ -668,40 +615,31 @@ export class StableWSConnection {
 
   /**
    * _errorFromWSEvent - Creates an error object for the WS event
-   *
    */
-  _errorFromWSEvent = (
-    event: WebSocket.CloseEvent | WebSocket.Data | WebSocket.ErrorEvent,
+  private _errorFromWSEvent = (
+    event: CloseEvent | ConnectionErrorEvent,
     isWSFailure = true,
   ) => {
-    let code;
-    let statusCode;
-    let message;
+    let code: number;
+    let statusCode: number;
+    let message: string;
     if (isCloseEvent(event)) {
       code = event.code;
-      statusCode = 'unknown';
       message = event.reason;
+      statusCode = 0;
+    } else {
+      const { error } = event;
+      code = error.code;
+      message = error.message;
+      statusCode = error.StatusCode;
     }
 
-    if (isErrorEvent(event)) {
-      code = event.error.code;
-      statusCode = event.error.StatusCode;
-      message = event.error.message;
-    }
-
-    // Keeping this `warn` level log, to avoid cluttering of error logs from ws failures.
-    this._log(
-      `_errorFromWSEvent() - WS failed with code ${code}`,
-      { event },
-      'warn',
-    );
-
-    const error = new Error(
-      `WS failed with code ${code} and reason - ${message}`,
-    ) as Error & {
-      code?: string | number;
+    const msg = `WS failed with code: ${code} and reason: ${message}`;
+    this._log(msg, { event }, 'warn');
+    const error = new Error(msg) as Error & {
+      code?: number;
       isWSFailure?: boolean;
-      StatusCode?: string | number;
+      StatusCode?: number;
     };
     error.code = code;
     /**
@@ -723,7 +661,6 @@ export class StableWSConnection {
     this.wsID += 1;
 
     try {
-      this?.ws?.removeAllListeners();
       this?.ws?.close();
     } catch (e) {
       // we don't care
@@ -752,11 +689,8 @@ export class StableWSConnection {
    * Schedules a next health check ping for websocket.
    */
   scheduleNextPing = () => {
-    if (this.healthCheckTimeoutRef) {
-      clearTimeout(this.healthCheckTimeoutRef);
-    }
-
     // 30 seconds is the recommended interval (messenger uses this)
+    clearTimeout(this.healthCheckTimeoutRef);
     this.healthCheckTimeoutRef = setTimeout(() => {
       // send the healthcheck..., server replies with a health check event
       const data = [{ type: 'health.check', client_id: this.client.clientID }];
@@ -775,10 +709,7 @@ export class StableWSConnection {
    * to be reconnected.
    */
   scheduleConnectionCheck = () => {
-    if (this.connectionCheckTimeoutRef) {
-      clearTimeout(this.connectionCheckTimeoutRef);
-    }
-
+    clearTimeout(this.connectionCheckTimeoutRef);
     this.connectionCheckTimeoutRef = setTimeout(() => {
       const now = new Date();
       if (

package/src/coordinator/connection/signing.ts

@@ -1,19 +1,4 @@
-import { decodeBase64, encodeBase64 } from './base64';
-
-/**
- *
- * @param {string} userId the id of the user
- * @return {string}
- */
-export function DevToken(userId: string) {
-  return [
-    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9', //{"alg": "HS256", "typ": "JWT"}
-    encodeBase64(JSON.stringify({ user_id: userId })),
-    'devtoken', // hardcoded signature
-  ].join('.');
-}
-
-export function UserFromToken(token: string) {
+export function getUserFromToken(token: string) {
   const fragments = token.split('.');
   if (fragments.length !== 3) {
     return '';
@@ -21,5 +6,34 @@ export function UserFromToken(token: string) {
   const b64Payload = fragments[1];
   const payload = decodeBase64(b64Payload);
   const data = JSON.parse(payload);
-  return data.user_id as string;
+  return data.user_id as string | undefined;
 }
+
+// base-64 decoder throws exception if encoded string is not padded by '=' to make string length
+// in multiples of 4. So gonna use our own method for this purpose to keep backwards compatibility
+// https://github.com/beatgammit/base64-js/blob/master/index.js#L26
+const decodeBase64 = (s: string): string => {
+  const e = {} as { [key: string]: number },
+    w = String.fromCharCode,
+    L = s.length;
+  let i,
+    b = 0,
+    c,
+    x,
+    l = 0,
+    a,
+    r = '';
+  const A = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  for (i = 0; i < 64; i++) {
+    e[A.charAt(i)] = i;
+  }
+  for (x = 0; x < L; x++) {
+    c = e[s.charAt(x)];
+    b = (b << 6) + c;
+    l += 6;
+    while (l >= 8) {
+      ((a = (b >>> (l -= 8)) & 0xff) || x < L - 2) && (r += w(a));
+    }
+  }
+  return r;
+};

package/src/coordinator/connection/token_manager.ts

@@ -1,4 +1,4 @@
-import { UserFromToken } from './signing';
+import { getUserFromToken } from './signing';
 import { isFunction } from './utils';
 import type { TokenOrProvider, UserWithId } from './types';
 
@@ -16,15 +16,10 @@ export class TokenManager {
   user?: UserWithId;
   /**
    * Constructor
-   *
-   * @param {Secret} secret
    */
   constructor(secret?: string) {
     this.loadTokenPromise = null;
-    if (secret) {
-      this.secret = secret;
-    }
-
+    this.secret = secret;
     this.type = 'static';
   }
 
@@ -95,7 +90,7 @@ export class TokenManager {
       // Allow empty token for anonymous users
       if (isAnonymous && tokenOrProvider === '') return;
 
-      const tokenUserId = UserFromToken(tokenOrProvider);
+      const tokenUserId = getUserFromToken(tokenOrProvider);
       if (
         tokenOrProvider != null &&
         (tokenUserId == null ||
@@ -116,7 +111,6 @@ export class TokenManager {
   // Fetches a token from tokenProvider function and sets in tokenManager.
   // In case of static token, it will simply resolve to static token.
   loadToken = () => {
-    // eslint-disable-next-line no-async-promise-executor
     this.loadTokenPromise = new Promise(async (resolve, reject) => {
       if (this.type === 'static') {
         return resolve(this.token as string);

package/src/coordinator/connection/types.ts

@@ -1,5 +1,4 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { StableWSConnection } from './connection';
 import { ConnectedEvent, UserRequest, WSEvent } from '../../gen/coordinator';
 import { AllSfuEvents } from '../../rtc';
 
@@ -115,10 +114,6 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
    */
   baseURL?: string;
   browser?: boolean;
-  // device?: BaseDeviceFields;
-  enableInsights?: boolean;
-  /** experimental feature, please contact support if you want this feature enabled for you */
-  enableWSFallback?: boolean;
   logger?: Logger;
   logLevel?: LogLevel;
   /**
@@ -146,10 +141,11 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
    */
   secret?: string;
 
-  warmUp?: boolean;
-  // Set the instance of StableWSConnection on chat client. Its purely for testing purpose and should
-  // not be used in production apps.
-  wsConnection?: StableWSConnection;
+  /**
+   * The WebSocket implementation to use. This is mainly useful for testing.
+   * In Node.js environment, you can use the `ws` package.
+   */
+  WebSocketImpl?: typeof WebSocket;
 };
 
 export type TokenProvider = () => Promise<string>;

package/src/coordinator/connection/utils.ts

@@ -1,7 +1,8 @@
-import { Logger } from './types';
+import type { AxiosResponse } from 'axios';
+import type { APIErrorResponse } from './types';
+import type { ConnectionErrorEvent } from '../../gen/coordinator';
 
-export const sleep = (m: number): Promise<void> =>
-  new Promise((r) => setTimeout(r, m));
+export const sleep = (m: number) => new Promise((r) => setTimeout(r, m));
 
 export function isFunction<T>(value: Function | T): value is Function {
   return (
@@ -92,63 +93,17 @@ function getRandomBytes(length: number): Uint8Array {
   return bytes;
 }
 
-export function convertErrorToJson(err: Error) {
-  const jsonObj = {} as Record<string, unknown>;
-
-  if (!err) return jsonObj;
-
-  try {
-    Object.getOwnPropertyNames(err).forEach((key) => {
-      jsonObj[key] = Object.getOwnPropertyDescriptor(err, key);
-    });
-  } catch (_) {
-    return {
-      error: 'failed to serialize the error',
-    };
-  }
-
-  return jsonObj;
-}
-
 /**
  * Informs if a promise is yet to be resolved or rejected
  */
 export async function isPromisePending<T>(promise: Promise<T>) {
   const emptyObj = {};
   return Promise.race([promise, emptyObj]).then(
-    (value) => (value === emptyObj ? true : false),
+    (value) => value === emptyObj,
     () => false,
   );
 }
 
-/**
- * isOnline safely return the navigator.online value for browser env
- * if navigator is not in global object, it always return true
- */
-export function isOnline(logger: Logger) {
-  const nav =
-    typeof navigator !== 'undefined'
-      ? navigator
-      : typeof window !== 'undefined' && window.navigator
-        ? window.navigator
-        : undefined;
-
-  if (!nav) {
-    logger(
-      'warn',
-      'isOnline failed to access window.navigator and assume browser is online',
-    );
-    return true;
-  }
-
-  // RN navigator has undefined for onLine
-  if (typeof nav.onLine !== 'boolean') {
-    return true;
-  }
-
-  return nav.onLine;
-}
-
 /**
  * listenForConnectionChanges - Adds an event listener fired on browser going online or offline
  */
@@ -165,3 +120,16 @@ export function removeConnectionEventListeners(cb: (e: Event) => void) {
     window.removeEventListener('online', cb);
   }
 }
+
+export function isErrorResponse(
+  res: AxiosResponse<unknown>,
+): res is AxiosResponse<APIErrorResponse> {
+  return !res.status || res.status < 200 || 300 <= res.status;
+}
+
+// Type guards to check WebSocket error type
+export function isCloseEvent(
+  res: CloseEvent | ConnectionErrorEvent,
+): res is CloseEvent {
+  return (res as CloseEvent).code !== undefined;
+}

package/src/devices/__tests__/InputMediaDeviceManagerState.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { beforeAll, describe, expect, it, vi } from 'vitest';
 import { InputMediaDeviceManagerState } from '../InputMediaDeviceManagerState';
 import { firstValueFrom } from 'rxjs';
 import { BrowserPermission } from '../BrowserPermission';
@@ -27,10 +27,18 @@ function mockPermissionStatus(state: PermissionState): PermissionStatus {
 
 describe('InputMediaDeviceManagerState', () => {
   describe('hasBrowserPermission', () => {
+    beforeAll(() => {
+      Object.defineProperty(navigator, 'permissions', {
+        value: {
+          query: vi.fn(),
+        },
+      });
+    });
+
     it('should emit true when permission is granted', async () => {
       const permissionStatus = mockPermissionStatus('granted');
       const query = vi.fn(() => Promise.resolve(permissionStatus));
-      globalThis.navigator = { permissions: { query } } as any;
+      vi.spyOn(navigator.permissions, 'query').mockImplementation(query);
       const state = new TestInputMediaDeviceManagerState();
 
       const hasPermission = await firstValueFrom(state.hasBrowserPermission$);
@@ -43,7 +51,7 @@ describe('InputMediaDeviceManagerState', () => {
     it('should emit false when permission is denied', async () => {
       const permissionStatus = mockPermissionStatus('denied');
       const query = vi.fn(() => Promise.resolve(permissionStatus));
-      globalThis.navigator = { permissions: { query } } as any;
+      vi.spyOn(navigator.permissions, 'query').mockImplementation(query);
       const state = new TestInputMediaDeviceManagerState();
 
       const hasPermission = await firstValueFrom(state.hasBrowserPermission$);
@@ -56,7 +64,7 @@ describe('InputMediaDeviceManagerState', () => {
     it('should emit true when prompt is needed', async () => {
       const permissionStatus = mockPermissionStatus('prompt');
       const query = vi.fn(() => Promise.resolve(permissionStatus));
-      globalThis.navigator = { permissions: { query } } as any;
+      vi.spyOn(navigator.permissions, 'query').mockImplementation(query);
       const state = new TestInputMediaDeviceManagerState();
 
       const hasPermission = await firstValueFrom(state.hasBrowserPermission$);
@@ -68,7 +76,7 @@ describe('InputMediaDeviceManagerState', () => {
 
     it('should emit true when permissions cannot be queried', async () => {
       const query = vi.fn(() => Promise.reject());
-      globalThis.navigator = { permissions: { query } } as any;
+      vi.spyOn(navigator.permissions, 'query').mockImplementation(query);
       const state = new TestInputMediaDeviceManagerState();
 
       const hasPermission = await firstValueFrom(state.hasBrowserPermission$);
@@ -78,11 +86,8 @@ describe('InputMediaDeviceManagerState', () => {
     });
 
     it('should emit true when permissions API is unavailable', async () => {
-      globalThis.navigator = {} as any;
       const state = new TestInputMediaDeviceManagerState();
-
       const hasPermission = await firstValueFrom(state.hasBrowserPermission$);
-
       expect(hasPermission).toBe(true);
     });
   });

package/src/devices/__tests__/mocks.ts

@@ -207,10 +207,6 @@ export const mockScreenShareStream = (includeAudio: boolean = true) => {
 
 let deviceIds: Subject<MediaDeviceInfo[]>;
 export const mockDeviceIds$ = () => {
-  global.navigator = {
-    //@ts-expect-error
-    mediaDevices: {},
-  };
   deviceIds = new Subject();
   return deviceIds;
 };

package/src/rtc/Publisher.ts

@@ -459,9 +459,14 @@ export class Publisher {
   private getCodecPreferences = (
     trackType: TrackType,
     preferredCodec?: string,
+    codecPreferencesSource?: 'sender' | 'receiver',
   ) => {
     if (trackType === TrackType.VIDEO) {
-      return getPreferredCodecs('video', preferredCodec || 'vp8');
+      return getPreferredCodecs(
+        'video',
+        preferredCodec || 'vp8',
+        codecPreferencesSource,
+      );
     }
     if (trackType === TrackType.AUDIO) {
       const defaultAudioCodec = this.isRedEnabled ? 'red' : 'opus';
@@ -575,8 +580,8 @@ export class Publisher {
     const opts = this.publishOptsForTrack.get(trackType);
     if (!opts || !opts.forceSingleCodec) return sdp;
 
-    const codec = opts.forceCodec || opts.preferredCodec;
-    const orderedCodecs = this.getCodecPreferences(trackType, codec);
+    const codec = opts.forceCodec || getOptimalVideoCodec(opts.preferredCodec);
+    const orderedCodecs = this.getCodecPreferences(trackType, codec, 'sender');
     if (!orderedCodecs || orderedCodecs.length === 0) return sdp;
 
     const transceiver = this.transceiverCache.get(trackType);

package/src/rtc/codecs.ts

@@ -9,15 +9,19 @@ import type { PreferredCodec } from '../types';
  * @param kind the kind of codec to get.
  * @param preferredCodec the codec to prioritize (vp8, h264, vp9, av1...).
  * @param codecToRemove the codec to exclude from the list.
+ * @param codecPreferencesSource the source of the codec preferences.
  */
 export const getPreferredCodecs = (
   kind: 'audio' | 'video',
   preferredCodec: string,
   codecToRemove?: string,
-): RTCRtpCodecCapability[] | undefined => {
-  if (!('getCapabilities' in RTCRtpReceiver)) return;
+  codecPreferencesSource: 'sender' | 'receiver' = 'receiver',
+): RTCRtpCodec[] | undefined => {
+  const source =
+    codecPreferencesSource === 'receiver' ? RTCRtpReceiver : RTCRtpSender;
+  if (!('getCapabilities' in source)) return;
 
-  const capabilities = RTCRtpReceiver.getCapabilities(kind);
+  const capabilities = source.getCapabilities(kind);
   if (!capabilities) return;
 
   const preferred: RTCRtpCodecCapability[] = [];

package/dist/src/coordinator/connection/base64.d.ts

@@ -1,2 +0,0 @@
-export declare const encodeBase64: (data: string) => string;
-export declare const decodeBase64: (s: string) => string;