livekit-client 2.16.0 → 2.16.1

package/src/room/RTCEngine.ts

@@ -62,6 +62,7 @@ import {
   ConnectionError,
   ConnectionErrorReason,
   NegotiationError,
+  SignalReconnectError,
   TrackInvalidError,
   UnexpectedConnectionState,
 } from './errors';
@@ -92,6 +93,8 @@ const reliableDataChannel = '_reliable';
 const minReconnectWait = 2 * 1000;
 const leaveReconnect = 'leave-reconnect';
 const reliabeReceiveStateTTL = 30_000;
+const lossyDataChannelBufferThresholdMin = 8 * 1024;
+const lossyDataChannelBufferThresholdMax = 256 * 1024;
 
 enum PCState {
   New,
@@ -203,6 +206,14 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private reliableReceivedState: TTLMap<string, number> = new TTLMap(reliabeReceiveStateTTL);
 
+  private lossyDataStatCurrentBytes: number = 0;
+
+  private lossyDataStatByterate: number = 0;
+
+  private lossyDataStatInterval: ReturnType<typeof setInterval> | undefined;
+
+  private lossyDataDropCount: number = 0;
+
   private midToTrackId: { [key: string]: string } = {};
 
   /** used to indicate whether the browser is currently waiting to reconnect */
@@ -312,6 +323,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.removeAllListeners();
       this.deregisterOnLineListener();
       this.clearPendingReconnect();
+      this.cleanupLossyDataStats();
       await this.cleanupPeerConnections();
       await this.cleanupClient();
     } finally {
@@ -347,6 +359,16 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.reliableReceivedState.clear();
   }
 
+  cleanupLossyDataStats() {
+    this.lossyDataStatByterate = 0;
+    this.lossyDataStatCurrentBytes = 0;
+    if (this.lossyDataStatInterval) {
+      clearInterval(this.lossyDataStatInterval);
+      this.lossyDataStatInterval = undefined;
+    }
+    this.lossyDataDropCount = 0;
+  }
+
   async cleanupClient() {
     await this.client.close();
     this.client.resetCallbacks();
@@ -360,10 +382,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       const publicationTimeout = setTimeout(() => {
         delete this.pendingTrackResolvers[req.cid];
         reject(
-          new ConnectionError(
-            'publication of local track timed out, no response from server',
-            ConnectionErrorReason.Timeout,
-          ),
+          ConnectionError.timeout('publication of local track timed out, no response from server'),
         );
       }, 10_000);
       this.pendingTrackResolvers[req.cid] = {
@@ -713,6 +732,22 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     // handle buffer amount low events
     this.lossyDC.onbufferedamountlow = this.handleBufferedAmountLow;
     this.reliableDC.onbufferedamountlow = this.handleBufferedAmountLow;
+
+    this.cleanupLossyDataStats();
+    this.lossyDataStatInterval = setInterval(() => {
+      this.lossyDataStatByterate = this.lossyDataStatCurrentBytes;
+      this.lossyDataStatCurrentBytes = 0;
+
+      const dc = this.dataChannelForKind(DataPacket_Kind.LOSSY);
+      if (dc) {
+        // control buffered latency to ~100ms
+        const threshold = this.lossyDataStatByterate / 10;
+        dc.bufferedAmountLowThreshold = Math.min(
+          Math.max(threshold, lossyDataChannelBufferThresholdMin),
+          lossyDataChannelBufferThresholdMax,
+        );
+      }
+    }, 1000);
   }
 
   private handleDataChannel = async ({ channel }: RTCDataChannelEvent) => {
@@ -1191,10 +1226,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     } catch (e: any) {
       // TODO do we need a `failed` state here for the PC?
       this.pcState = PCState.Disconnected;
-      throw new ConnectionError(
-        `could not establish PC connection, ${e.message}`,
-        ConnectionErrorReason.InternalError,
-      );
+      throw ConnectionError.internal(`could not establish PC connection, ${e.message}`);
     }
   }
 
@@ -1282,12 +1314,24 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     const msg = packet.toBinary();
 
-    await this.waitForBufferStatusLow(kind);
-
     const dc = this.dataChannelForKind(kind);
     if (dc) {
       if (kind === DataPacket_Kind.RELIABLE) {
+        await this.waitForBufferStatusLow(kind);
         this.reliableMessageBuffer.push({ data: msg, sequence: packet.sequence });
+      } else {
+        // lossy channel, drop messages to reduce latency
+        if (!this.isBufferStatusLow(kind)) {
+          this.lossyDataDropCount += 1;
+          if (this.lossyDataDropCount % 100 === 0) {
+            this.log.warn(
+              `dropping lossy data channel messages, total dropped: ${this.lossyDataDropCount}`,
+              this.logContext,
+            );
+          }
+          return;
+        }
+        this.lossyDataStatCurrentBytes += msg.byteLength;
       }
 
       if (this.attemptingReconnect) {
@@ -1363,10 +1407,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     const transport = subscriber ? this.pcManager.subscriber : this.pcManager.publisher;
     const transportName = subscriber ? 'Subscriber' : 'Publisher';
     if (!transport) {
-      throw new ConnectionError(
-        `${transportName} connection not set`,
-        ConnectionErrorReason.InternalError,
-      );
+      throw ConnectionError.internal(`${transportName} connection not set`);
     }
 
     let needNegotiation = false;
@@ -1407,9 +1448,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       await sleep(50);
     }
 
-    throw new ConnectionError(
+    throw ConnectionError.internal(
       `could not establish ${transportName} connection, state: ${transport.getICEConnectionState()}`,
-      ConnectionErrorReason.InternalError,
     );
   }
 
@@ -1699,8 +1739,6 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   }
 }
 
-class SignalReconnectError extends Error {}
-
 export type EngineEventCallbacks = {
   connected: (joinResp: JoinResponse) => void;
   disconnected: (reason?: DisconnectReason) => void;

package/src/room/RegionUrlProvider.test.ts

@@ -1,5 +1,5 @@
-import type { RegionInfo, RegionSettings } from '@livekit/protocol';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { RegionInfo, RegionSettings } from '@livekit/protocol';
 import { RegionUrlProvider } from './RegionUrlProvider';
 import { ConnectionError, ConnectionErrorReason } from './errors';
 
@@ -180,8 +180,9 @@ describe('RegionUrlProvider', () => {
       const provider = new RegionUrlProvider('wss://test.livekit.cloud', 'token');
       fetchMock.mockResolvedValue(createMockResponse(401));
 
-      await expect(provider.fetchRegionSettings()).rejects.toThrow(ConnectionError);
-      await expect(provider.fetchRegionSettings()).rejects.toMatchObject({
+      const error = await provider.fetchRegionSettings().catch((e) => e);
+      expect(error).toBeInstanceOf(ConnectionError);
+      expect(error).toMatchObject({
         reason: ConnectionErrorReason.NotAllowed,
         status: 401,
       });
@@ -191,11 +192,9 @@ describe('RegionUrlProvider', () => {
       const provider = new RegionUrlProvider('wss://test.livekit.cloud', 'token');
       fetchMock.mockResolvedValue(createMockResponse(500));
 
-      await expect(provider.fetchRegionSettings()).rejects.toThrow(ConnectionError);
-      await expect(provider.fetchRegionSettings()).rejects.toMatchObject({
-        reason: ConnectionErrorReason.InternalError,
-        status: 500,
-      });
+      const error = await provider.fetchRegionSettings().catch((e) => e);
+      expect(error).toBeInstanceOf(ConnectionError);
+      expect(error.reason).toBe(ConnectionErrorReason.InternalError);
     });
 
     it('extracts max-age from Cache-Control header', async () => {
@@ -725,7 +724,7 @@ describe('RegionUrlProvider', () => {
 
       expect(error).toBeInstanceOf(ConnectionError);
       expect(error.reason).toBe(ConnectionErrorReason.ServerUnreachable);
-      expect(error.status).toBe(500);
+      expect(error.status).toBe(undefined);
       expect(error.message).toContain('Failed to fetch');
     });
 

package/src/room/RegionUrlProvider.ts

@@ -45,26 +45,27 @@ export class RegionUrlProvider {
         const regionSettings = (await regionSettingsResponse.json()) as RegionSettings;
         return { regionSettings, updatedAtInMs: Date.now(), maxAgeInMs };
       } else {
-        throw new ConnectionError(
-          `Could not fetch region settings: ${regionSettingsResponse.statusText}`,
-          regionSettingsResponse.status === 401
-            ? ConnectionErrorReason.NotAllowed
-            : ConnectionErrorReason.InternalError,
-          regionSettingsResponse.status,
-        );
+        if (regionSettingsResponse.status === 401) {
+          throw ConnectionError.notAllowed(
+            `Could not fetch region settings: ${regionSettingsResponse.statusText}`,
+            regionSettingsResponse.status,
+          );
+        } else {
+          throw ConnectionError.internal(
+            `Could not fetch region settings: ${regionSettingsResponse.statusText}`,
+          );
+        }
       }
     } catch (e: unknown) {
       if (e instanceof ConnectionError) {
         // rethrow connection errors
         throw e;
       } else if (signal?.aborted) {
-        throw new ConnectionError(`Region fetching was aborted`, ConnectionErrorReason.Cancelled);
+        throw ConnectionError.cancelled(`Region fetching was aborted`);
       } else {
-        // wrap other errors as connection errors (e.g. timeouts)
-        throw new ConnectionError(
+        // wrap other errors as connection errors
+        throw ConnectionError.serverUnreachable(
           `Could not fetch region settings, ${e instanceof Error ? `${e.name}: ${e.message}` : e}`,
-          ConnectionErrorReason.ServerUnreachable,
-          500, // using 500 as a catch-all manually set error code here
         );
       }
     } finally {

package/src/room/Room.ts

@@ -31,8 +31,9 @@ import {
   protoInt64,
 } from '@livekit/protocol';
 import { EventEmitter } from 'events';
-import type TypedEmitter from 'typed-emitter';
 import 'webrtc-adapter';
+import type TypedEmitter from 'typed-emitter';
+import { ensureTrailingSlash } from '../api/utils';
 import { EncryptionEvent } from '../e2ee';
 import { type BaseE2EEManager, E2EEManager } from '../e2ee/E2eeManager';
 import log, { LoggerNames, getLogger } from '../logger';
@@ -644,7 +645,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
 
     this.setAndEmitConnectionState(ConnectionState.Connecting);
-    if (this.regionUrlProvider?.getServerUrl().toString() !== url) {
+    if (this.regionUrlProvider?.getServerUrl().toString() !== ensureTrailingSlash(url)) {
       this.regionUrl = undefined;
       this.regionUrlProvider = undefined;
     }
@@ -686,7 +687,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       try {
         await BackOffStrategy.getInstance().getBackOffPromise(url);
         if (abortController.signal.aborted) {
-          throw new ConnectionError('Connection attempt aborted', ConnectionErrorReason.Cancelled);
+          throw ConnectionError.cancelled('Connection attempt aborted');
         }
         await this.attemptConnection(regionUrl ?? url, token, opts, abortController);
         this.abortController = undefined;
@@ -894,12 +895,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     } catch (err) {
       await this.engine.close();
       this.recreateEngine();
-      const resultingError = new ConnectionError(
-        `could not establish signal connection`,
-        abortController.signal.aborted
-          ? ConnectionErrorReason.Cancelled
-          : ConnectionErrorReason.ServerUnreachable,
-      );
+
+      const resultingError = abortController.signal.aborted
+        ? ConnectionError.cancelled('Signal connection aborted')
+        : ConnectionError.serverUnreachable('could not establish signal connection');
+
       if (err instanceof Error) {
         resultingError.message = `${resultingError.message}: ${err.message}`;
       }
@@ -917,7 +917,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (abortController.signal.aborted) {
       await this.engine.close();
       this.recreateEngine();
-      throw new ConnectionError(`Connection attempt aborted`, ConnectionErrorReason.Cancelled);
+      throw ConnectionError.cancelled(`Connection attempt aborted`);
     }
 
     try {
@@ -938,7 +938,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       window.addEventListener('beforeunload', this.onPageLeave);
     }
     if (isWeb()) {
-      document.addEventListener('freeze', this.onPageLeave);
+      window.addEventListener('freeze', this.onPageLeave);
     }
     this.setAndEmitConnectionState(ConnectionState.Connected);
     this.emit(RoomEvent.Connected);
@@ -974,9 +974,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.log.warn(msg, this.logContext);
         this.abortController?.abort(msg);
         // in case the abort controller didn't manage to cancel the connection attempt, reject the connect promise explicitly
-        this.connectFuture?.reject?.(
-          new ConnectionError('Client initiated disconnect', ConnectionErrorReason.Cancelled),
-        );
+        this.connectFuture?.reject?.(ConnectionError.cancelled('Client initiated disconnect'));
         this.connectFuture = undefined;
       }
 
@@ -1925,7 +1923,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       });
       if (byteLength(response) > MAX_PAYLOAD_BYTES) {
         responseError = RpcError.builtIn('RESPONSE_PAYLOAD_TOO_LARGE');
-        console.warn(`RPC Response payload too large for ${method}`);
+        this.log.warn(`RPC Response payload too large for ${method}`);
       } else {
         responsePayload = response;
       }
@@ -1933,7 +1931,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       if (error instanceof RpcError) {
         responseError = error;
       } else {
-        console.warn(
+        this.log.warn(
           `Uncaught error returned by RPC handler for ${method}. Returning APPLICATION_ERROR instead.`,
           error,
         );

package/src/room/data-stream/outgoing/OutgoingDataStreamManager.ts

@@ -93,7 +93,6 @@ export default class OutgoingDataStreamManager {
 
   /**
    * @internal
-   * @experimental CAUTION, might get removed in a minor release
    */
   async streamText(options?: StreamTextOptions): Promise<TextStreamWriter> {
     const streamId = options?.streamId ?? crypto.randomUUID();

package/src/room/errors.ts

@@ -10,6 +10,14 @@ export class LivekitError extends Error {
   }
 }
 
+export class SimulatedError extends LivekitError {
+  readonly name = 'simulated';
+
+  constructor(message = 'Simulated failure') {
+    super(-1, message);
+  }
+}
+
 export enum ConnectionErrorReason {
   NotAllowed,
   ServerUnreachable,
@@ -17,80 +25,189 @@ export enum ConnectionErrorReason {
   Cancelled,
   LeaveRequest,
   Timeout,
+  WebSocket,
 }
 
-export class ConnectionError extends LivekitError {
+type NotAllowed = {
+  reason: ConnectionErrorReason.NotAllowed;
+  status: number;
+  context?: unknown;
+};
+
+type InternalError = {
+  reason: ConnectionErrorReason.InternalError;
+  status: never;
+  context?: { status?: number; statusText?: string };
+};
+
+type ConnectionTimeout = {
+  reason: ConnectionErrorReason.Timeout;
+  status: never;
+  context: never;
+};
+
+type LeaveRequest = {
+  reason: ConnectionErrorReason.LeaveRequest;
+  status: never;
+  context: DisconnectReason;
+};
+
+type Cancelled = {
+  reason: ConnectionErrorReason.Cancelled;
+  status: never;
+  context: never;
+};
+
+type ServerUnreachable = {
+  reason: ConnectionErrorReason.ServerUnreachable;
+  status?: number;
+  context?: never;
+};
+
+type WebSocket = {
+  reason: ConnectionErrorReason.WebSocket;
   status?: number;
+  context?: string;
+};
+
+type ConnectionErrorVariants =
+  | NotAllowed
+  | ConnectionTimeout
+  | LeaveRequest
+  | InternalError
+  | Cancelled
+  | ServerUnreachable
+  | WebSocket;
 
-  context?: unknown | DisconnectReason;
+export class ConnectionError<
+  Variant extends ConnectionErrorVariants = ConnectionErrorVariants,
+> extends LivekitError {
+  status?: Variant['status'];
 
-  reason: ConnectionErrorReason;
+  context: Variant['context'];
+
+  reason: Variant['reason'];
 
   reasonName: string;
 
-  constructor(
+  readonly name = 'ConnectionError';
+
+  protected constructor(
     message: string,
-    reason: ConnectionErrorReason,
-    status?: number,
-    context?: unknown | DisconnectReason,
+    reason: Variant['reason'],
+    status?: Variant['status'],
+    context?: Variant['context'],
   ) {
     super(1, message);
-    this.name = 'ConnectionError';
     this.status = status;
     this.reason = reason;
     this.context = context;
     this.reasonName = ConnectionErrorReason[reason];
   }
+
+  static notAllowed(message: string, status: number, context?: unknown) {
+    return new ConnectionError<NotAllowed>(
+      message,
+      ConnectionErrorReason.NotAllowed,
+      status,
+      context,
+    );
+  }
+
+  static timeout(message: string) {
+    return new ConnectionError<ConnectionTimeout>(message, ConnectionErrorReason.Timeout);
+  }
+
+  static leaveRequest(message: string, context: DisconnectReason) {
+    return new ConnectionError<LeaveRequest>(
+      message,
+      ConnectionErrorReason.LeaveRequest,
+      undefined,
+      context,
+    );
+  }
+
+  static internal(message: string, context?: { status?: number; statusText?: string }) {
+    return new ConnectionError<InternalError>(
+      message,
+      ConnectionErrorReason.InternalError,
+      undefined,
+      context,
+    );
+  }
+
+  static cancelled(message: string) {
+    return new ConnectionError<Cancelled>(message, ConnectionErrorReason.Cancelled);
+  }
+
+  static serverUnreachable(message: string, status?: number) {
+    return new ConnectionError<ServerUnreachable>(
+      message,
+      ConnectionErrorReason.ServerUnreachable,
+      status,
+    );
+  }
+
+  static websocket(message: string, status?: number, reason?: string) {
+    return new ConnectionError<WebSocket>(message, ConnectionErrorReason.WebSocket, status, reason);
+  }
 }
 
 export class DeviceUnsupportedError extends LivekitError {
+  readonly name = 'DeviceUnsupportedError';
+
   constructor(message?: string) {
     super(21, message ?? 'device is unsupported');
-    this.name = 'DeviceUnsupportedError';
   }
 }
 
 export class TrackInvalidError extends LivekitError {
+  readonly name = 'TrackInvalidError';
+
   constructor(message?: string) {
     super(20, message ?? 'track is invalid');
-    this.name = 'TrackInvalidError';
   }
 }
 
 export class UnsupportedServer extends LivekitError {
+  readonly name = 'UnsupportedServer';
+
   constructor(message?: string) {
     super(10, message ?? 'unsupported server');
-    this.name = 'UnsupportedServer';
   }
 }
 
 export class UnexpectedConnectionState extends LivekitError {
+  readonly name = 'UnexpectedConnectionState';
+
   constructor(message?: string) {
     super(12, message ?? 'unexpected connection state');
-    this.name = 'UnexpectedConnectionState';
   }
 }
 
 export class NegotiationError extends LivekitError {
+  readonly name = 'NegotiationError';
+
   constructor(message?: string) {
     super(13, message ?? 'unable to negotiate');
-    this.name = 'NegotiationError';
   }
 }
 
 export class PublishDataError extends LivekitError {
+  readonly name = 'PublishDataError';
+
   constructor(message?: string) {
     super(14, message ?? 'unable to publish data');
-    this.name = 'PublishDataError';
   }
 }
 
 export class PublishTrackError extends LivekitError {
+  readonly name = 'PublishTrackError';
+
   status: number;
 
   constructor(message: string, status: number) {
     super(15, message);
-    this.name = 'PublishTrackError';
     this.status = status;
   }
 }
@@ -100,6 +217,8 @@ export type RequestErrorReason =
   | 'TimeoutError';
 
 export class SignalRequestError extends LivekitError {
+  readonly name = 'SignalRequestError';
+
   reason: RequestErrorReason;
 
   reasonName: string;
@@ -136,18 +255,27 @@ export enum DataStreamErrorReason {
 }
 
 export class DataStreamError extends LivekitError {
+  readonly name = 'DataStreamError';
+
   reason: DataStreamErrorReason;
 
   reasonName: string;
 
   constructor(message: string, reason: DataStreamErrorReason) {
     super(16, message);
-    this.name = 'DataStreamError';
     this.reason = reason;
     this.reasonName = DataStreamErrorReason[reason];
   }
 }
 
+export class SignalReconnectError extends LivekitError {
+  readonly name = 'SignalReconnectError';
+
+  constructor(message?: string) {
+    super(18, message);
+  }
+}
+
 export enum MediaDeviceFailure {
   // user rejected permissions
   PermissionDenied = 'PermissionDenied',

package/src/room/participant/LocalParticipant.ts

@@ -1824,7 +1824,7 @@ export default class LocalParticipant extends Participant {
         resolve: (responsePayload: string | null, responseError: RpcError | null) => {
           clearTimeout(responseTimeoutId);
           if (this.pendingAcks.has(id)) {
-            console.warn('RPC response received before ack', id);
+            this.log.warn('RPC response received before ack', id);
             this.pendingAcks.delete(id);
             clearTimeout(ackTimeoutId);
           }

package/src/room/token-source/TokenSource.ts

@@ -245,9 +245,13 @@ class TokenSourceSandboxTokenServer extends TokenSourceEndpoint {
 }
 
 export {
+  /** The return type of {@link TokenSource.literal} */
   type TokenSourceLiteral,
+  /** The return type of {@link TokenSource.custom} */
   type TokenSourceCustom,
+  /** The return type of {@link TokenSource.endpoint} */
   type TokenSourceEndpoint,
+  /** The return type of {@link TokenSource.sandboxTokenServer} */
   type TokenSourceSandboxTokenServer,
   decodeTokenPayload,
   areTokenSourceFetchOptionsEqual,
@@ -273,7 +277,7 @@ export const TokenSource = {
   /**
    * TokenSource.endpoint creates a token source that fetches credentials from a given URL using
    * the standard endpoint format:
-   * FIXME: add docs link here in the future!
+   * @see https://cloud.livekit.io/projects/p_/sandbox/templates/token-server
    */
   endpoint(url: string, options: EndpointOptions = {}) {
     return new TokenSourceEndpoint(url, options);

package/src/room/track/LocalTrack.ts

@@ -518,8 +518,6 @@ export default abstract class LocalTrack<
    * Sets a processor on this track.
    * See https://github.com/livekit/track-processors-js for example usage
    *
-   * @experimental
-   *
    * @param processor
    * @param showProcessedStreamLocally
    * @returns
@@ -592,8 +590,6 @@ export default abstract class LocalTrack<
    * Stops the track processor
    * See https://github.com/livekit/track-processors-js for example usage
    *
-   * @experimental
-   * @returns
    */
   async stopProcessor(keepElement = true) {
     const unlock = await this.trackChangeLock.lock();

package/src/room/track/TrackPublication.ts

@@ -1,11 +1,11 @@
 import { Encryption_Type } from '@livekit/protocol';
+import { EventEmitter } from 'events';
 import type {
   SubscriptionError,
   TrackInfo,
   UpdateSubscription,
   UpdateTrackSettings,
 } from '@livekit/protocol';
-import { EventEmitter } from 'events';
 import type TypedEventEmitter from 'typed-emitter';
 import log, { LoggerNames, getLogger } from '../../logger';
 import { TrackEvent } from '../events';

package/src/room/track/processor/types.ts

@@ -11,9 +11,6 @@ export type ProcessorOptions<T extends Track.Kind> = {
   audioContext?: AudioContext;
 };
 
-/**
- * @experimental
- */
 export interface AudioProcessorOptions extends ProcessorOptions<Track.Kind.Audio> {
   audioContext: AudioContext;
 }
@@ -23,9 +20,6 @@ export interface AudioProcessorOptions extends ProcessorOptions<Track.Kind.Audio
  */
 export interface VideoProcessorOptions extends ProcessorOptions<Track.Kind.Video> {}
 
-/**
- * @experimental
- */
 export interface TrackProcessor<
   T extends Track.Kind,
   U extends ProcessorOptions<T> = ProcessorOptions<T>,