@livekit/rtc-node 0.13.31 → 0.13.33

package/dist/async_queue.d.ts

@@ -9,7 +9,7 @@
  * This eliminates the need for manual coordination logic, polling loops, and
  * complex state management throughout the rest of the codebase.
  */
-declare class AsyncQueue<T> {
+export declare class AsyncQueue<T> {
     private capacity;
     private items;
     private waitingProducers;
@@ -26,5 +26,4 @@ declare class AsyncQueue<T> {
     close(): void;
     get length(): number;
 }
-
-export { AsyncQueue };
+//# sourceMappingURL=async_queue.d.ts.map

package/dist/audio_filter.d.ts

@@ -1,5 +1,4 @@
-declare class AudioFilter {
+export declare class AudioFilter {
     constructor(moduleId: string, path: string, dependencies?: string[]);
 }
-
-export { AudioFilter };
+//# sourceMappingURL=audio_filter.d.ts.map

package/dist/audio_frame.d.ts

@@ -1,6 +1,6 @@
-import { OwnedAudioFrameBuffer, AudioFrameBufferInfo } from '@livekit/rtc-ffi-bindings';
-
-declare class AudioFrame {
+import type { OwnedAudioFrameBuffer } from '@livekit/rtc-ffi-bindings';
+import { AudioFrameBufferInfo } from '@livekit/rtc-ffi-bindings';
+export declare class AudioFrame {
     data: Int16Array;
     sampleRate: number;
     channels: number;
@@ -24,6 +24,5 @@ declare class AudioFrame {
  *
  * @param buffer - a single AudioFrame or list thereof
  */
-declare const combineAudioFrames: (buffer: AudioFrame | AudioFrame[]) => AudioFrame;
-
-export { AudioFrame, combineAudioFrames };
+export declare const combineAudioFrames: (buffer: AudioFrame | AudioFrame[]) => AudioFrame;
+//# sourceMappingURL=audio_frame.d.ts.map

package/dist/audio_mixer.d.ts

@@ -1,13 +1,11 @@
 import { AudioFrame } from './audio_frame.js';
 export { AsyncQueue } from './async_queue.js';
-import '@livekit/rtc-ffi-bindings';
-
 type AudioStream = {
     [Symbol.asyncIterator](): {
         next(): Promise<IteratorResult<AudioFrame>>;
     };
 };
-interface AudioMixerOptions {
+export interface AudioMixerOptions {
     /**
      * The size of the audio block (in samples) for mixing.
      * If not provided, defaults to sampleRate / 10 (100ms).
@@ -47,7 +45,7 @@ interface AudioMixerOptions {
  * }
  * ```
  */
-declare class AudioMixer {
+export declare class AudioMixer {
     private streams;
     private buffers;
     private streamIterators;
@@ -114,5 +112,4 @@ declare class AudioMixer {
      *  cleared via `.finally()` so callers don't need to manage cleanup. */
     private timeoutRace;
 }
-
-export { AudioMixer, type AudioMixerOptions };
+//# sourceMappingURL=audio_mixer.d.ts.map

package/dist/audio_resampler.d.ts

@@ -1,11 +1,9 @@
 import { AudioFrame } from './audio_frame.js';
-import '@livekit/rtc-ffi-bindings';
-
 /**
  * Resampler quality. Higher quality settings result in better audio quality but require more
  * processing power.
  */
-declare enum AudioResamplerQuality {
+export declare enum AudioResamplerQuality {
     QUICK = 0,
     LOW = 1,
     MEDIUM = 2,
@@ -17,7 +15,7 @@ declare enum AudioResamplerQuality {
  * an output sample rate using the Sox resampling library. It supports multiple channels and
  * configurable resampling quality.
  */
-declare class AudioResampler {
+export declare class AudioResampler {
     #private;
     /**
      * Initializes a new AudioResampler.
@@ -58,5 +56,4 @@ declare class AudioResampler {
      */
     flush(): AudioFrame[];
 }
-
-export { AudioResampler, AudioResamplerQuality };
+//# sourceMappingURL=audio_resampler.d.ts.map

package/dist/audio_source.d.ts

@@ -1,7 +1,7 @@
-import { AudioSourceInfo, FfiHandle } from '@livekit/rtc-ffi-bindings';
-import { AudioFrame } from './audio_frame.js';
-
-declare class AudioSource {
+import type { AudioSourceInfo } from '@livekit/rtc-ffi-bindings';
+import { FfiHandle } from '@livekit/rtc-ffi-bindings';
+import type { AudioFrame } from './audio_frame.js';
+export declare class AudioSource {
     /** @internal */
     info: AudioSourceInfo;
     /** @internal */
@@ -37,5 +37,4 @@ declare class AudioSource {
     captureFrame(frame: AudioFrame): Promise<void>;
     close(): Promise<void>;
 }
-
-export { AudioSource };
+//# sourceMappingURL=audio_source.d.ts.map

package/dist/{audio_stream-B4hGVcKz.d.cts → audio_stream-CnODFAmo.d.cts}

@@ -108,6 +108,7 @@ declare class LocalParticipant extends Participant {
         destinationIdentities?: Array<string>;
         streamId?: string;
         senderIdentity?: string;
+        totalSize?: number;
     }): Promise<TextStreamWriter>;
     sendText(text: string, options?: {
         topic?: string;
@@ -420,6 +421,17 @@ declare abstract class Track {
     registerAudioStream(stream: AudioStreamSource): void;
     /** @internal */
     unregisterAudioStream(stream: AudioStreamSource): void;
+    /**
+     * End every {@link AudioStream} attached to this track.
+     *
+     * @remarks
+     * The FFI keeps feeding an audio stream until the stream's own handle is
+     * dropped, so streams on a track that is no longer subscribed would otherwise
+     * go on delivering audio for the lifetime of the process.
+     *
+     * @internal
+     */
+    closeAudioStreams(): void;
     private iterateStreams;
     private pushProcessorMetadataToStream;
     get sid(): string | undefined;
@@ -486,6 +498,20 @@ declare class AudioStreamSource implements UnderlyingSource<AudioFrame> {
     get processor(): FrameProcessor<AudioFrame> | null;
     private onEvent;
     start(controller: ReadableStreamDefaultController<AudioFrame>): void;
+    /**
+     * Detach from the FFI and release resources: on `eos`, on `cancel()`, or
+     * because the track went away (e.g. it was unsubscribed — which never
+     * produces an `eos`, so without this the stream would keep delivering
+     * frames). Already-buffered frames stay readable and the consumer sees `done`
+     * after draining them.
+     *
+     * @remarks
+     * Idempotent, so `eos` arriving after a `cancel()` (or vice versa) doesn't
+     * double-dispose the handle while buffered frames are still queued.
+     *
+     * @internal
+     */
+    teardown(): void;
     cancel(): void;
 }
 declare class AudioStream extends ReadableStream<AudioFrame> {

package/dist/audio_stream.cjs

@@ -53,16 +53,7 @@ class AudioStreamSource {
           this.controller.enqueue(frame);
           break;
         case "eos":
-          import_ffi_client.FfiClient.instance.off(import_ffi_client.FfiClientEvent.FfiEvent, this.onEvent);
-          this.controller.close();
-          if (!this.disposed) {
-            this.disposed = true;
-            this.track.unregisterAudioStream(this);
-            this.ffiHandle.dispose();
-            if (this.frameProcessor && this.autoCloseProcessor) {
-              this.frameProcessor.close();
-            }
-          }
+          this.teardown();
           break;
       }
     };
@@ -109,16 +100,38 @@ class AudioStreamSource {
   start(controller) {
     this.controller = controller;
   }
-  cancel() {
+  /**
+   * Detach from the FFI and release resources: on `eos`, on `cancel()`, or
+   * because the track went away (e.g. it was unsubscribed — which never
+   * produces an `eos`, so without this the stream would keep delivering
+   * frames). Already-buffered frames stay readable and the consumer sees `done`
+   * after draining them.
+   *
+   * @remarks
+   * Idempotent, so `eos` arriving after a `cancel()` (or vice versa) doesn't
+   * double-dispose the handle while buffered frames are still queued.
+   *
+   * @internal
+   */
+  teardown() {
+    var _a;
     import_ffi_client.FfiClient.instance.off(import_ffi_client.FfiClientEvent.FfiEvent, this.onEvent);
-    if (!this.disposed) {
-      this.disposed = true;
-      this.track.unregisterAudioStream(this);
-      this.ffiHandle.dispose();
-      if (this.frameProcessor && this.autoCloseProcessor) {
-        this.frameProcessor.close();
-      }
+    if (this.disposed) {
+      return;
     }
+    this.disposed = true;
+    this.track.unregisterAudioStream(this);
+    this.ffiHandle.dispose();
+    if (this.frameProcessor && this.autoCloseProcessor) {
+      this.frameProcessor.close();
+    }
+    try {
+      (_a = this.controller) == null ? void 0 : _a.close();
+    } catch {
+    }
+  }
+  cancel() {
+    this.teardown();
   }
 }
 class AudioStream extends ReadableStream {

package/dist/audio_stream.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/audio_stream.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2024 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { NewAudioStreamResponse } from '@livekit/rtc-ffi-bindings';\nimport { AudioStreamType, NewAudioStreamRequest } from '@livekit/rtc-ffi-bindings';\nimport type { UnderlyingSource } from 'node:stream/web';\nimport { AudioFrame } from './audio_frame.js';\nimport type { FfiEvent } from './ffi_client.js';\nimport { FfiClient, FfiClientEvent, FfiHandle } from './ffi_client.js';\nimport { type FrameProcessor, isFrameProcessor } from './frame_processor.js';\nimport { log } from './log.js';\nimport type { Track } from './track.js';\n\nexport interface AudioStreamOptions {\n  noiseCancellation?: NoiseCancellationOptions | FrameProcessor<AudioFrame>;\n  /**\n   * When the audio stream closes, whether to run the {@link FrameProcessor}'s\n   * `close()` method. If `false`, the processor is left open so it can be\n   * reused with another {@link AudioStream}. Only relevant when\n   * `noiseCancellation` is a {@link FrameProcessor}. Defaults to `true`.\n   */\n  autoCloseNoiseCancellation?: boolean;\n  sampleRate?: number;\n  numChannels?: number;\n  frameSizeMs?: number;\n}\n\nexport interface NoiseCancellationOptions {\n  moduleId: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  options: Record<string, any>;\n}\n\n/** @internal */\nexport class AudioStreamSource implements UnderlyingSource<AudioFrame> {\n  private controller?: ReadableStreamDefaultController<AudioFrame>;\n  private ffiHandle: FfiHandle;\n  private disposed = false;\n  private sampleRate: number;\n  private numChannels: number;\n  private legacyNcOptions?: NoiseCancellationOptions;\n  private frameProcessor: FrameProcessor<AudioFrame> | null = null;\n  private autoCloseProcessor = true;\n  private frameSizeMs?: number;\n  private track: Track;\n\n  constructor(\n    track: Track,\n    sampleRateOrOptions?: number | AudioStreamOptions,\n    numChannels?: number,\n  ) {\n    this.track = track;\n    if (sampleRateOrOptions !== undefined && typeof sampleRateOrOptions !== 'number') {\n      this.sampleRate = sampleRateOrOptions.sampleRate ?? 48000;\n      this.numChannels = sampleRateOrOptions.numChannels ?? 1;\n      if (isFrameProcessor(sampleRateOrOptions.noiseCancellation)) {\n        this.frameProcessor = sampleRateOrOptions.noiseCancellation;\n        this.autoCloseProcessor = sampleRateOrOptions.autoCloseNoiseCancellation ?? true;\n      } else {\n        this.legacyNcOptions = sampleRateOrOptions.noiseCancellation;\n      }\n      this.frameSizeMs = sampleRateOrOptions.frameSizeMs;\n    } else {\n      this.sampleRate = (sampleRateOrOptions as number) ?? 48000;\n      this.numChannels = numChannels ?? 1;\n    }\n\n    const req = new NewAudioStreamRequest({\n      type: AudioStreamType.AUDIO_STREAM_NATIVE,\n      trackHandle: track.ffi_handle.handle,\n      sampleRate: this.sampleRate,\n      numChannels: this.numChannels,\n      frameSizeMs: this.frameSizeMs,\n      ...(this.legacyNcOptions\n        ? {\n            audioFilterModuleId: this.legacyNcOptions.moduleId,\n            audioFilterOptions: JSON.stringify(this.legacyNcOptions.options),\n          }\n        : {}),\n    });\n\n    const res = FfiClient.instance.request<NewAudioStreamResponse>({\n      message: {\n        case: 'newAudioStream',\n        value: req,\n      },\n    });\n\n    this.ffiHandle = new FfiHandle(res.stream!.handle!.id!);\n\n    FfiClient.instance.on(FfiClientEvent.FfiEvent, this.onEvent);\n    track.registerAudioStream(this);\n  }\n\n  /** @internal */\n  get processor(): FrameProcessor<AudioFrame> | null {\n    return this.frameProcessor;\n  }\n\n  private onEvent = (ev: FfiEvent) => {\n    if (!this.controller) {\n      throw new Error('Stream controller not initialized');\n    }\n\n    if (\n      ev.message.case != 'audioStreamEvent' ||\n      ev.message.value.streamHandle != this.ffiHandle.handle\n    ) {\n      return;\n    }\n\n    const streamEvent = ev.message.value.message;\n    switch (streamEvent.case) {\n      case 'frameReceived':\n        let frame = AudioFrame.fromOwnedInfo(streamEvent.value.frame!);\n        if (this.frameProcessor && this.frameProcessor.isEnabled()) {\n          try {\n            frame = this.frameProcessor.process(frame);\n          } catch (err: unknown) {\n            log.warn(`Frame processing failed, passing through original frame: ${err}`);\n          }\n        }\n        this.controller.enqueue(frame);\n        break;\n      case 'eos':\n        FfiClient.instance.off(FfiClientEvent.FfiEvent, this.onEvent);\n        this.controller.close();\n        // Dispose the native handle so the FD is released on stream end,\n        // not just when cancel() is called explicitly by the consumer.\n        // Guard against double-dispose if cancel() is called after EOS\n        // while buffered frames are still in the ReadableStream queue.\n        if (!this.disposed) {\n          this.disposed = true;\n          this.track.unregisterAudioStream(this);\n          this.ffiHandle.dispose();\n          if (this.frameProcessor && this.autoCloseProcessor) {\n            this.frameProcessor.close();\n          }\n        }\n        break;\n    }\n  };\n\n  start(controller: ReadableStreamDefaultController<AudioFrame>) {\n    this.controller = controller;\n  }\n\n  cancel() {\n    FfiClient.instance.off(FfiClientEvent.FfiEvent, this.onEvent);\n    if (!this.disposed) {\n      this.disposed = true;\n      this.track.unregisterAudioStream(this);\n      this.ffiHandle.dispose();\n      // Also close the frame processor on cancel for symmetry with the EOS path,\n      // so resources are released regardless of how the stream ends.\n      if (this.frameProcessor && this.autoCloseProcessor) {\n        this.frameProcessor.close();\n      }\n    }\n  }\n}\n\nexport class AudioStream extends ReadableStream<AudioFrame> {\n  constructor(track: Track);\n  constructor(track: Track, sampleRate: number);\n  constructor(track: Track, sampleRate: number, numChannels: number);\n  constructor(track: Track, options: AudioStreamOptions);\n  constructor(\n    track: Track,\n    sampleRateOrOptions?: number | AudioStreamOptions,\n    numChannels?: number,\n  ) {\n    super(new AudioStreamSource(track, sampleRateOrOptions, numChannels));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,8BAAuD;AAEvD,yBAA2B;AAE3B,wBAAqD;AACrD,6BAAsD;AACtD,iBAAoB;AAwBb,MAAM,kBAA0D;AAAA,EAYrE,YACE,OACA,qBACA,aACA;AAbF,SAAQ,WAAW;AAInB,SAAQ,iBAAoD;AAC5D,SAAQ,qBAAqB;AAyD7B,SAAQ,UAAU,CAAC,OAAiB;AAClC,UAAI,CAAC,KAAK,YAAY;AACpB,cAAM,IAAI,MAAM,mCAAmC;AAAA,MACrD;AAEA,UACE,GAAG,QAAQ,QAAQ,sBACnB,GAAG,QAAQ,MAAM,gBAAgB,KAAK,UAAU,QAChD;AACA;AAAA,MACF;AAEA,YAAM,cAAc,GAAG,QAAQ,MAAM;AACrC,cAAQ,YAAY,MAAM;AAAA,QACxB,KAAK;AACH,cAAI,QAAQ,8BAAW,cAAc,YAAY,MAAM,KAAM;AAC7D,cAAI,KAAK,kBAAkB,KAAK,eAAe,UAAU,GAAG;AAC1D,gBAAI;AACF,sBAAQ,KAAK,eAAe,QAAQ,KAAK;AAAA,YAC3C,SAAS,KAAc;AACrB,6BAAI,KAAK,4DAA4D,GAAG,EAAE;AAAA,YAC5E;AAAA,UACF;AACA,eAAK,WAAW,QAAQ,KAAK;AAC7B;AAAA,QACF,KAAK;AACH,sCAAU,SAAS,IAAI,iCAAe,UAAU,KAAK,OAAO;AAC5D,eAAK,WAAW,MAAM;AAKtB,cAAI,CAAC,KAAK,UAAU;AAClB,iBAAK,WAAW;AAChB,iBAAK,MAAM,sBAAsB,IAAI;AACrC,iBAAK,UAAU,QAAQ;AACvB,gBAAI,KAAK,kBAAkB,KAAK,oBAAoB;AAClD,mBAAK,eAAe,MAAM;AAAA,YAC5B;AAAA,UACF;AACA;AAAA,MACJ;AAAA,IACF;AA1FE,SAAK,QAAQ;AACb,QAAI,wBAAwB,UAAa,OAAO,wBAAwB,UAAU;AAChF,WAAK,aAAa,oBAAoB,cAAc;AACpD,WAAK,cAAc,oBAAoB,eAAe;AACtD,cAAI,yCAAiB,oBAAoB,iBAAiB,GAAG;AAC3D,aAAK,iBAAiB,oBAAoB;AAC1C,aAAK,qBAAqB,oBAAoB,8BAA8B;AAAA,MAC9E,OAAO;AACL,aAAK,kBAAkB,oBAAoB;AAAA,MAC7C;AACA,WAAK,cAAc,oBAAoB;AAAA,IACzC,OAAO;AACL,WAAK,aAAc,uBAAkC;AACrD,WAAK,cAAc,eAAe;AAAA,IACpC;AAEA,UAAM,MAAM,IAAI,8CAAsB;AAAA,MACpC,MAAM,wCAAgB;AAAA,MACtB,aAAa,MAAM,WAAW;AAAA,MAC9B,YAAY,KAAK;AAAA,MACjB,aAAa,KAAK;AAAA,MAClB,aAAa,KAAK;AAAA,MAClB,GAAI,KAAK,kBACL;AAAA,QACE,qBAAqB,KAAK,gBAAgB;AAAA,QAC1C,oBAAoB,KAAK,UAAU,KAAK,gBAAgB,OAAO;AAAA,MACjE,IACA,CAAC;AAAA,IACP,CAAC;AAED,UAAM,MAAM,4BAAU,SAAS,QAAgC;AAAA,MAC7D,SAAS;AAAA,QACP,MAAM;AAAA,QACN,OAAO;AAAA,MACT;AAAA,IACF,CAAC;AAED,SAAK,YAAY,IAAI,4BAAU,IAAI,OAAQ,OAAQ,EAAG;AAEtD,gCAAU,SAAS,GAAG,iCAAe,UAAU,KAAK,OAAO;AAC3D,UAAM,oBAAoB,IAAI;AAAA,EAChC;AAAA;AAAA,EAGA,IAAI,YAA+C;AACjD,WAAO,KAAK;AAAA,EACd;AAAA,EA8CA,MAAM,YAAyD;AAC7D,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,SAAS;AACP,gCAAU,SAAS,IAAI,iCAAe,UAAU,KAAK,OAAO;AAC5D,QAAI,CAAC,KAAK,UAAU;AAClB,WAAK,WAAW;AAChB,WAAK,MAAM,sBAAsB,IAAI;AACrC,WAAK,UAAU,QAAQ;AAGvB,UAAI,KAAK,kBAAkB,KAAK,oBAAoB;AAClD,aAAK,eAAe,MAAM;AAAA,MAC5B;AAAA,IACF;AAAA,EACF;AACF;AAEO,MAAM,oBAAoB,eAA2B;AAAA,EAK1D,YACE,OACA,qBACA,aACA;AACA,UAAM,IAAI,kBAAkB,OAAO,qBAAqB,WAAW,CAAC;AAAA,EACtE;AACF;","names":[]}
+{"version":3,"sources":["../src/audio_stream.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2024 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { NewAudioStreamResponse } from '@livekit/rtc-ffi-bindings';\nimport { AudioStreamType, NewAudioStreamRequest } from '@livekit/rtc-ffi-bindings';\nimport type { UnderlyingSource } from 'node:stream/web';\nimport { AudioFrame } from './audio_frame.js';\nimport type { FfiEvent } from './ffi_client.js';\nimport { FfiClient, FfiClientEvent, FfiHandle } from './ffi_client.js';\nimport { type FrameProcessor, isFrameProcessor } from './frame_processor.js';\nimport { log } from './log.js';\nimport type { Track } from './track.js';\n\nexport interface AudioStreamOptions {\n  noiseCancellation?: NoiseCancellationOptions | FrameProcessor<AudioFrame>;\n  /**\n   * When the audio stream closes, whether to run the {@link FrameProcessor}'s\n   * `close()` method. If `false`, the processor is left open so it can be\n   * reused with another {@link AudioStream}. Only relevant when\n   * `noiseCancellation` is a {@link FrameProcessor}. Defaults to `true`.\n   */\n  autoCloseNoiseCancellation?: boolean;\n  sampleRate?: number;\n  numChannels?: number;\n  frameSizeMs?: number;\n}\n\nexport interface NoiseCancellationOptions {\n  moduleId: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  options: Record<string, any>;\n}\n\n/** @internal */\nexport class AudioStreamSource implements UnderlyingSource<AudioFrame> {\n  private controller?: ReadableStreamDefaultController<AudioFrame>;\n  private ffiHandle: FfiHandle;\n  private disposed = false;\n  private sampleRate: number;\n  private numChannels: number;\n  private legacyNcOptions?: NoiseCancellationOptions;\n  private frameProcessor: FrameProcessor<AudioFrame> | null = null;\n  private autoCloseProcessor = true;\n  private frameSizeMs?: number;\n  private track: Track;\n\n  constructor(\n    track: Track,\n    sampleRateOrOptions?: number | AudioStreamOptions,\n    numChannels?: number,\n  ) {\n    this.track = track;\n    if (sampleRateOrOptions !== undefined && typeof sampleRateOrOptions !== 'number') {\n      this.sampleRate = sampleRateOrOptions.sampleRate ?? 48000;\n      this.numChannels = sampleRateOrOptions.numChannels ?? 1;\n      if (isFrameProcessor(sampleRateOrOptions.noiseCancellation)) {\n        this.frameProcessor = sampleRateOrOptions.noiseCancellation;\n        this.autoCloseProcessor = sampleRateOrOptions.autoCloseNoiseCancellation ?? true;\n      } else {\n        this.legacyNcOptions = sampleRateOrOptions.noiseCancellation;\n      }\n      this.frameSizeMs = sampleRateOrOptions.frameSizeMs;\n    } else {\n      this.sampleRate = (sampleRateOrOptions as number) ?? 48000;\n      this.numChannels = numChannels ?? 1;\n    }\n\n    const req = new NewAudioStreamRequest({\n      type: AudioStreamType.AUDIO_STREAM_NATIVE,\n      trackHandle: track.ffi_handle.handle,\n      sampleRate: this.sampleRate,\n      numChannels: this.numChannels,\n      frameSizeMs: this.frameSizeMs,\n      ...(this.legacyNcOptions\n        ? {\n            audioFilterModuleId: this.legacyNcOptions.moduleId,\n            audioFilterOptions: JSON.stringify(this.legacyNcOptions.options),\n          }\n        : {}),\n    });\n\n    const res = FfiClient.instance.request<NewAudioStreamResponse>({\n      message: {\n        case: 'newAudioStream',\n        value: req,\n      },\n    });\n\n    this.ffiHandle = new FfiHandle(res.stream!.handle!.id!);\n\n    FfiClient.instance.on(FfiClientEvent.FfiEvent, this.onEvent);\n    track.registerAudioStream(this);\n  }\n\n  /** @internal */\n  get processor(): FrameProcessor<AudioFrame> | null {\n    return this.frameProcessor;\n  }\n\n  private onEvent = (ev: FfiEvent) => {\n    if (!this.controller) {\n      throw new Error('Stream controller not initialized');\n    }\n\n    if (\n      ev.message.case != 'audioStreamEvent' ||\n      ev.message.value.streamHandle != this.ffiHandle.handle\n    ) {\n      return;\n    }\n\n    const streamEvent = ev.message.value.message;\n    switch (streamEvent.case) {\n      case 'frameReceived':\n        let frame = AudioFrame.fromOwnedInfo(streamEvent.value.frame!);\n        if (this.frameProcessor && this.frameProcessor.isEnabled()) {\n          try {\n            frame = this.frameProcessor.process(frame);\n          } catch (err: unknown) {\n            log.warn(`Frame processing failed, passing through original frame: ${err}`);\n          }\n        }\n        this.controller.enqueue(frame);\n        break;\n      case 'eos':\n        // Disposes the native handle so the FD is released on stream end, not\n        // just when cancel() is called explicitly by the consumer.\n        this.teardown();\n        break;\n    }\n  };\n\n  start(controller: ReadableStreamDefaultController<AudioFrame>) {\n    this.controller = controller;\n  }\n\n  /**\n   * Detach from the FFI and release resources: on `eos`, on `cancel()`, or\n   * because the track went away (e.g. it was unsubscribed — which never\n   * produces an `eos`, so without this the stream would keep delivering\n   * frames). Already-buffered frames stay readable and the consumer sees `done`\n   * after draining them.\n   *\n   * @remarks\n   * Idempotent, so `eos` arriving after a `cancel()` (or vice versa) doesn't\n   * double-dispose the handle while buffered frames are still queued.\n   *\n   * @internal\n   */\n  teardown() {\n    FfiClient.instance.off(FfiClientEvent.FfiEvent, this.onEvent);\n    if (this.disposed) {\n      return;\n    }\n    this.disposed = true;\n    this.track.unregisterAudioStream(this);\n    this.ffiHandle.dispose();\n    // Close the frame processor on every teardown path so resources are\n    // released regardless of how the stream ended.\n    if (this.frameProcessor && this.autoCloseProcessor) {\n      this.frameProcessor.close();\n    }\n    try {\n      this.controller?.close();\n    } catch {\n      // Already closed — e.g. cancel(), where the consumer has torn the\n      // ReadableStream down before the underlying source is notified.\n    }\n  }\n\n  cancel() {\n    this.teardown();\n  }\n}\n\nexport class AudioStream extends ReadableStream<AudioFrame> {\n  constructor(track: Track);\n  constructor(track: Track, sampleRate: number);\n  constructor(track: Track, sampleRate: number, numChannels: number);\n  constructor(track: Track, options: AudioStreamOptions);\n  constructor(\n    track: Track,\n    sampleRateOrOptions?: number | AudioStreamOptions,\n    numChannels?: number,\n  ) {\n    super(new AudioStreamSource(track, sampleRateOrOptions, numChannels));\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/audio_stream.d.cts

@@ -1,7 +1,7 @@
 import 'node:stream/web';
 import './audio_frame.cjs';
 import './frame_processor.cjs';
-export { A as AudioStream, r as AudioStreamOptions, s as AudioStreamSource, N as NoiseCancellationOptions } from './audio_stream-B4hGVcKz.cjs';
+export { A as AudioStream, r as AudioStreamOptions, s as AudioStreamSource, N as NoiseCancellationOptions } from './audio_stream-CnODFAmo.cjs';
 import '@livekit/rtc-ffi-bindings';
 import './video_frame.cjs';
 import './audio_source.cjs';

package/dist/audio_stream.d.ts

@@ -1,18 +1,61 @@
-import 'node:stream/web';
-import './audio_frame.js';
-import './frame_processor.js';
-export { A as AudioStream, r as AudioStreamOptions, s as AudioStreamSource, N as NoiseCancellationOptions } from './audio_stream-DEG1JKge.js';
-import '@livekit/rtc-ffi-bindings';
-import './video_frame.js';
-import './audio_source.js';
-import './ffi_client.js';
-import '@livekit/typed-emitter';
-import './types-_PdPVish.js';
-import './e2ee.js';
-import '@livekit/mutex';
-import 'node:fs';
-import './data_streams/stream_writer.js';
-import './rpc.js';
-import './transcription.js';
-import './types.js';
-import './video_source.js';
+import type { UnderlyingSource } from 'node:stream/web';
+import { AudioFrame } from './audio_frame.js';
+import { type FrameProcessor } from './frame_processor.js';
+import type { Track } from './track.js';
+export interface AudioStreamOptions {
+    noiseCancellation?: NoiseCancellationOptions | FrameProcessor<AudioFrame>;
+    /**
+     * When the audio stream closes, whether to run the {@link FrameProcessor}'s
+     * `close()` method. If `false`, the processor is left open so it can be
+     * reused with another {@link AudioStream}. Only relevant when
+     * `noiseCancellation` is a {@link FrameProcessor}. Defaults to `true`.
+     */
+    autoCloseNoiseCancellation?: boolean;
+    sampleRate?: number;
+    numChannels?: number;
+    frameSizeMs?: number;
+}
+export interface NoiseCancellationOptions {
+    moduleId: string;
+    options: Record<string, any>;
+}
+/** @internal */
+export declare class AudioStreamSource implements UnderlyingSource<AudioFrame> {
+    private controller?;
+    private ffiHandle;
+    private disposed;
+    private sampleRate;
+    private numChannels;
+    private legacyNcOptions?;
+    private frameProcessor;
+    private autoCloseProcessor;
+    private frameSizeMs?;
+    private track;
+    constructor(track: Track, sampleRateOrOptions?: number | AudioStreamOptions, numChannels?: number);
+    /** @internal */
+    get processor(): FrameProcessor<AudioFrame> | null;
+    private onEvent;
+    start(controller: ReadableStreamDefaultController<AudioFrame>): void;
+    /**
+     * Detach from the FFI and release resources: on `eos`, on `cancel()`, or
+     * because the track went away (e.g. it was unsubscribed — which never
+     * produces an `eos`, so without this the stream would keep delivering
+     * frames). Already-buffered frames stay readable and the consumer sees `done`
+     * after draining them.
+     *
+     * @remarks
+     * Idempotent, so `eos` arriving after a `cancel()` (or vice versa) doesn't
+     * double-dispose the handle while buffered frames are still queued.
+     *
+     * @internal
+     */
+    teardown(): void;
+    cancel(): void;
+}
+export declare class AudioStream extends ReadableStream<AudioFrame> {
+    constructor(track: Track);
+    constructor(track: Track, sampleRate: number);
+    constructor(track: Track, sampleRate: number, numChannels: number);
+    constructor(track: Track, options: AudioStreamOptions);
+}
+//# sourceMappingURL=audio_stream.d.ts.map

package/dist/audio_stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audio_stream.d.ts","sourceRoot":"","sources":["../src/audio_stream.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAAE,KAAK,cAAc,EAAoB,MAAM,sBAAsB,CAAC;AAE7E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,kBAAkB;IACjC,iBAAiB,CAAC,EAAE,wBAAwB,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC;IAC1E;;;;;OAKG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,MAAM,CAAC;IAEjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED,gBAAgB;AAChB,qBAAa,iBAAkB,YAAW,gBAAgB,CAAC,UAAU,CAAC;IACpE,OAAO,CAAC,UAAU,CAAC,CAA8C;IACjE,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,eAAe,CAAC,CAA2B;IACnD,OAAO,CAAC,cAAc,CAA2C;IACjE,OAAO,CAAC,kBAAkB,CAAQ;IAClC,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,KAAK,CAAQ;gBAGnB,KAAK,EAAE,KAAK,EACZ,mBAAmB,CAAC,EAAE,MAAM,GAAG,kBAAkB,EACjD,WAAW,CAAC,EAAE,MAAM;IA6CtB,gBAAgB;IAChB,IAAI,SAAS,IAAI,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,CAEjD;IAED,OAAO,CAAC,OAAO,CA0Cb;IAEF,KAAK,CAAC,UAAU,EAAE,+BAA+B,CAAC,UAAU,CAAC;IAI7D,MAAM;CAaP;AAED,qBAAa,WAAY,SAAQ,cAAc,CAAC,UAAU,CAAC;gBAC7C,KAAK,EAAE,KAAK;gBACZ,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM;gBAChC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;gBACrD,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,kBAAkB;CAQtD"}
+{"version":3,"file":"audio_stream.d.ts","sourceRoot":"","sources":["../src/audio_stream.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAAE,KAAK,cAAc,EAAoB,MAAM,sBAAsB,CAAC;AAE7E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,kBAAkB;IACjC,iBAAiB,CAAC,EAAE,wBAAwB,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC;IAC1E;;;;;OAKG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,MAAM,CAAC;IAEjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED,gBAAgB;AAChB,qBAAa,iBAAkB,YAAW,gBAAgB,CAAC,UAAU,CAAC;IACpE,OAAO,CAAC,UAAU,CAAC,CAA8C;IACjE,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,eAAe,CAAC,CAA2B;IACnD,OAAO,CAAC,cAAc,CAA2C;IACjE,OAAO,CAAC,kBAAkB,CAAQ;IAClC,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,KAAK,CAAQ;gBAGnB,KAAK,EAAE,KAAK,EACZ,mBAAmB,CAAC,EAAE,MAAM,GAAG,kBAAkB,EACjD,WAAW,CAAC,EAAE,MAAM;IA6CtB,gBAAgB;IAChB,IAAI,SAAS,IAAI,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,CAEjD;IAED,OAAO,CAAC,OAAO,CA+Bb;IAEF,KAAK,CAAC,UAAU,EAAE,+BAA+B,CAAC,UAAU,CAAC;IAI7D;;;;;;;;;;;;OAYG;IACH,QAAQ;IAqBR,MAAM;CAGP;AAED,qBAAa,WAAY,SAAQ,cAAc,CAAC,UAAU,CAAC;gBAC7C,KAAK,EAAE,KAAK;gBACZ,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM;gBAChC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;gBACrD,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,kBAAkB;CAQtD"}

package/dist/data_streams/index.d.ts

@@ -1,3 +1,4 @@
-export { B as BaseStreamInfo, a as ByteStreamHandler, b as ByteStreamInfo, c as ByteStreamOptions, d as ByteStreamReader, D as DataStreamOptions, S as StreamController, T as TextStreamHandler, e as TextStreamInfo, f as TextStreamOptions, g as TextStreamReader } from '../types-_PdPVish.js';
-export { ByteStreamWriter, TextStreamWriter } from './stream_writer.js';
-import '@livekit/rtc-ffi-bindings';
+export * from './stream_reader.js';
+export * from './stream_writer.js';
+export type * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/data_streams/stream_reader.d.ts

@@ -1,2 +1,48 @@
-import '@livekit/rtc-ffi-bindings';
-export { d as ByteStreamReader, g as TextStreamReader } from '../types-_PdPVish.js';
+import type { DataStream_Chunk } from '@livekit/rtc-ffi-bindings';
+import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from './types.js';
+declare abstract class BaseStreamReader<T extends BaseStreamInfo> {
+    protected reader: ReadableStream<DataStream_Chunk>;
+    protected totalByteSize?: number;
+    protected _info: T;
+    protected bytesReceived: number;
+    get info(): T;
+    constructor(info: T, stream: ReadableStream<DataStream_Chunk>, totalByteSize?: number);
+    protected abstract handleChunkReceived(chunk: DataStream_Chunk): void;
+    onProgress?: (progress: number | undefined) => void;
+    abstract readAll(): Promise<string | Array<Uint8Array>>;
+}
+/**
+ * A class to read chunks from a ReadableStream and provide them in a structured format.
+ */
+export declare class ByteStreamReader extends BaseStreamReader<ByteStreamInfo> {
+    protected handleChunkReceived(chunk: DataStream_Chunk): void;
+    [Symbol.asyncIterator](): {
+        next: () => Promise<IteratorResult<Uint8Array>>;
+        return(): IteratorResult<Uint8Array>;
+    };
+    readAll(): Promise<Array<Uint8Array>>;
+}
+/**
+ * A class to read chunks from a ReadableStream and provide them in a structured format.
+ */
+export declare class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
+    private receivedChunks;
+    /**
+     * A TextStreamReader instance can be used as an AsyncIterator that returns the entire string
+     * that has been received up to the current point in time.
+     */
+    constructor(info: TextStreamInfo, stream: ReadableStream<DataStream_Chunk>, totalChunkCount?: number);
+    protected handleChunkReceived(chunk: DataStream_Chunk): void;
+    /**
+     * Async iterator implementation to allow usage of `for await...of` syntax.
+     * Yields structured chunks from the stream.
+     *
+     */
+    [Symbol.asyncIterator](): {
+        next: () => Promise<IteratorResult<string>>;
+        return(): IteratorResult<string>;
+    };
+    readAll(): Promise<string>;
+}
+export {};
+//# sourceMappingURL=stream_reader.d.ts.map

package/dist/data_streams/stream_writer.d.ts

@@ -1,6 +1,4 @@
-import { B as BaseStreamInfo, e as TextStreamInfo, b as ByteStreamInfo } from '../types-_PdPVish.js';
-import '@livekit/rtc-ffi-bindings';
-
+import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from './types.js';
 declare class BaseStreamWriter<T, InfoType extends BaseStreamInfo> {
     protected writableStream: WritableStream<T>;
     protected defaultWriter: WritableStreamDefaultWriter<T>;
@@ -10,9 +8,9 @@ declare class BaseStreamWriter<T, InfoType extends BaseStreamInfo> {
     write(chunk: T): Promise<void>;
     close(): Promise<void>;
 }
-declare class TextStreamWriter extends BaseStreamWriter<string, TextStreamInfo> {
+export declare class TextStreamWriter extends BaseStreamWriter<string, TextStreamInfo> {
 }
-declare class ByteStreamWriter extends BaseStreamWriter<Uint8Array, ByteStreamInfo> {
+export declare class ByteStreamWriter extends BaseStreamWriter<Uint8Array, ByteStreamInfo> {
 }
-
-export { ByteStreamWriter, TextStreamWriter };
+export {};
+//# sourceMappingURL=stream_writer.d.ts.map

package/dist/data_streams/types.d.ts

@@ -1,2 +1,41 @@
-import '@livekit/rtc-ffi-bindings';
-export { B as BaseStreamInfo, a as ByteStreamHandler, b as ByteStreamInfo, c as ByteStreamOptions, D as DataStreamOptions, S as StreamController, T as TextStreamHandler, e as TextStreamInfo, f as TextStreamOptions } from '../types-_PdPVish.js';
+import type { DataStream_Chunk, DataStream_Header } from '@livekit/rtc-ffi-bindings';
+import type { ByteStreamReader, TextStreamReader } from './stream_reader.js';
+export interface StreamController<T extends DataStream_Chunk> {
+    header: DataStream_Header;
+    controller: ReadableStreamDefaultController<T>;
+    startTime: number;
+    endTime?: number;
+}
+export interface BaseStreamInfo {
+    streamId: string;
+    mimeType: string;
+    topic: string;
+    timestamp: number;
+    /** total size in bytes for finite streams and undefined for streams of unknown size */
+    totalSize?: number;
+    attributes?: Record<string, string>;
+}
+export type ByteStreamInfo = BaseStreamInfo & {
+    name: string;
+};
+export type TextStreamInfo = BaseStreamInfo;
+export interface DataStreamOptions {
+    topic?: string;
+    destinationIdentities?: Array<string>;
+    attributes?: Record<string, string>;
+    mimeType?: string;
+}
+export interface TextStreamOptions extends DataStreamOptions {
+    attachments?: [];
+}
+export interface ByteStreamOptions extends DataStreamOptions {
+    name?: string;
+    onProgress?: (progress: number) => void;
+}
+export type ByteStreamHandler = (reader: ByteStreamReader, participantInfo: {
+    identity: string;
+}) => void;
+export type TextStreamHandler = (reader: TextStreamReader, participantInfo: {
+    identity: string;
+}) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/e2ee.d.ts

@@ -1,18 +1,17 @@
 import { EncryptionType } from '@livekit/rtc-ffi-bindings';
-
-interface KeyProviderOptions {
+export interface KeyProviderOptions {
     sharedKey?: Uint8Array;
     ratchetSalt?: Uint8Array;
     ratchetWindowSize?: number;
     failureTolerance?: number;
 }
-declare const defaultKeyProviderOptions: KeyProviderOptions;
-interface E2EEOptions {
+export declare const defaultKeyProviderOptions: KeyProviderOptions;
+export interface E2EEOptions {
     keyProviderOptions: KeyProviderOptions;
     encryptionType?: EncryptionType;
 }
-declare const defaultE2EEOptions: E2EEOptions;
-declare class KeyProvider {
+export declare const defaultE2EEOptions: E2EEOptions;
+export declare class KeyProvider {
     private roomHandle;
     options: KeyProviderOptions;
     /** internal */
@@ -24,7 +23,7 @@ declare class KeyProvider {
     exportKey(participantIdentity: string, keyIndex: number): Uint8Array;
     ratchetKey(participantIdentity: string, keyIndex: number): Uint8Array;
 }
-declare class FrameCryptor {
+export declare class FrameCryptor {
     private roomHandle;
     participantIdentity: string;
     keyIndex: number;
@@ -33,7 +32,7 @@ declare class FrameCryptor {
     setEnabled(enabled: boolean): void;
     setKeyIndex(keyIndex: number): void;
 }
-declare class E2EEManager {
+export declare class E2EEManager {
     private roomHandle;
     private options;
     private keyProvider;
@@ -42,5 +41,4 @@ declare class E2EEManager {
     setEnabled(enabled: boolean): void;
     frameCryptors(): FrameCryptor[];
 }
-
-export { E2EEManager, type E2EEOptions, FrameCryptor, KeyProvider, type KeyProviderOptions, defaultE2EEOptions, defaultKeyProviderOptions };
+//# sourceMappingURL=e2ee.d.ts.map

package/dist/ffi_client.d.ts

@@ -1,18 +1,17 @@
-import { FfiEvent, PartialMessage, FfiRequest } from '@livekit/rtc-ffi-bindings';
-export { FfiEvent, FfiHandle, FfiRequest, FfiResponse, livekitDispose as dispose } from '@livekit/rtc-ffi-bindings';
-import { TypedEventEmitter } from '@livekit/typed-emitter';
-
-type FfiClientCallbacks = {
+import { FfiEvent, FfiHandle, FfiRequest, FfiResponse, type PartialMessage, livekitDispose } from '@livekit/rtc-ffi-bindings';
+import type { TypedEventEmitter as TypedEmitter } from '@livekit/typed-emitter';
+export { FfiHandle, type FfiEvent, type FfiResponse, FfiRequest, livekitDispose as dispose };
+export type FfiClientCallbacks = {
     ffi_event: (event: FfiEvent) => void;
 };
-declare enum FfiClientEvent {
+export declare enum FfiClientEvent {
     FfiEvent = "ffi_event"
 }
 declare global {
     var _ffiClientInstance: FfiClient | undefined;
 }
-declare const FfiClient_base: new () => TypedEventEmitter<FfiClientCallbacks>;
-declare class FfiClient extends FfiClient_base {
+declare const FfiClient_base: new () => TypedEmitter<FfiClientCallbacks>;
+export declare class FfiClient extends FfiClient_base {
     /** @internal */
     static get instance(): FfiClient;
     private _nextRequestAsyncId;
@@ -25,5 +24,4 @@ declare class FfiClient extends FfiClient_base {
         signal?: AbortSignal;
     }): Promise<T>;
 }
-
-export { FfiClient, type FfiClientCallbacks, FfiClientEvent };
+//# sourceMappingURL=ffi_client.d.ts.map

package/dist/frame_processor.d.ts

@@ -1,19 +1,17 @@
-import { AudioFrame } from './audio_frame.js';
-import { VideoFrame } from './video_frame.js';
-import '@livekit/rtc-ffi-bindings';
-
-type FrameProcessorStreamInfo = {
+import { type AudioFrame } from './audio_frame.js';
+import { type VideoFrame } from './video_frame.js';
+export type FrameProcessorStreamInfo = {
     roomName: string;
     participantIdentity: string;
     publicationSid: string;
 };
-type FrameProcessorCredentials = {
+export type FrameProcessorCredentials = {
     token: string;
     url: string;
 };
-declare const FrameProcessorSymbol: unique symbol;
-declare function isFrameProcessor<T extends FrameProcessor<AudioFrame> | FrameProcessor<VideoFrame> | unknown>(maybeProcessor: unknown): maybeProcessor is T extends FrameProcessor<AudioFrame> ? FrameProcessor<AudioFrame> : T extends FrameProcessor<VideoFrame> ? FrameProcessor<VideoFrame> : FrameProcessor<AudioFrame> | FrameProcessor<VideoFrame>;
-declare abstract class FrameProcessor<Frame extends VideoFrame | AudioFrame> {
+export declare const FrameProcessorSymbol: unique symbol;
+export declare function isFrameProcessor<T extends FrameProcessor<AudioFrame> | FrameProcessor<VideoFrame> | unknown>(maybeProcessor: unknown): maybeProcessor is T extends FrameProcessor<AudioFrame> ? FrameProcessor<AudioFrame> : T extends FrameProcessor<VideoFrame> ? FrameProcessor<VideoFrame> : FrameProcessor<AudioFrame> | FrameProcessor<VideoFrame>;
+export declare abstract class FrameProcessor<Frame extends VideoFrame | AudioFrame> {
     readonly symbol: symbol;
     abstract isEnabled(): boolean;
     abstract setEnabled(enabled: boolean): void;
@@ -24,5 +22,4 @@ declare abstract class FrameProcessor<Frame extends VideoFrame | AudioFrame> {
     abstract process(frame: Frame): Frame;
     abstract close(): void;
 }
-
-export { FrameProcessor, type FrameProcessorCredentials, type FrameProcessorStreamInfo, FrameProcessorSymbol, isFrameProcessor };
+//# sourceMappingURL=frame_processor.d.ts.map